The following Ada type:
type Circle is new Shape and Drawable with record
Center : Point;
Radius : Natural;
end record;
...is displayed as follow in GDB:
(gdb) ptype circle
type = new classes.shape with record
V51s: ada.tags.interface_tag;
center: classes.point;
radius: natural;
end record
V51s is an internal field that is of no interest for the user. It should
not be displayed.
gdb/ChangeLog:
* ada-lang.c (ada_is_interface_tag): New function.
(ada_is_ignored_field): Add interface tags to the list
of ignored fields.
For displaying the full view of a class-wide object, GDB relies on
the assumption that this view will have the same address as the
address of the object. In the case of simple inheritance, this
assumption is correct; the proper type is deduced by decoding
the tag of the object and converting the result to this full-view
type.
Consider for example an abstract class Shape, a child Circle
which implements an interface Drawable, and the corresponding
following objects:
My_Circle : Circle := ((1, 2), 3);
My_Shape : Shape'Class := Shape'Class (My_Circle);
My_Drawable : Drawable'Class := Drawable'Class (My_Circle);
To display My_Shape, the debugger first extracts the tag (an internal
field, usually the first one of the record):
(gdb) p my_shape'address
$2 = (system.address) 0x8063e28
(gdb) x/x my_shape'address
0x8063e28 <classes__my_shape>: 0x08059ec4
Then the type specific data and the expanded name of the tag is read
from there:
(gdb) p my_shape'tag
$3 = (access ada.tags.dispatch_table) 0x8059ec4 (classes.circle)
To get the full view, the debugger converts to the corresponding type:
(gdb) p {classes.circle}0x8063e28
$4 = (center => (x => 1, y => 2), radius => 3)
Now, in the case of multiple inheritance, the assumption does not hold
anymore. The address that we have usually points to some
place lower. The offset to the original address is saved in the field
Offset_To_Top of the metadata that are above the tag, at address
obj'tag - 8. In the case of my_shape, this offset is 0:
(gdb) x/x my_shape'tag - 8
0x8059ebc <classes__circleT+12>: 0x00000000
...but in the case of an interface-wide object, it is not null:
(gdb) x/x my_drawable'tag - 8
0x8063b28 <classes__classes__circle_classes__drawable1T56s+12>: 0x00000004
(gdb) p {classes.circle}(my_drawable'address - 4)
$7 = (center => (x => 1, y => 2), radius => 3)
The following change handles this relocation in the most common cases.
Remaining cases that are still to be investigated are signaled by
comments.
gdb/ChangeLog:
* ada-lang.h (ada_tag_value_at_base_address): New function
declaration.
* ada-lang.c (is_ada95_tag, ada_tag_value_at_base_address):
New functions.
(ada_to_fixed_type_1, ada_evaluate_subexp): Let ada_tag_base_address
relocate the class-wide value if need be.
(ada_value_struct_elt, ada_value_ind, ada_coerce_ref):
Let ada_tag_value_at_base_address relocate the class-wide access/ref
before dereferencing it.
* ada-valprint.c (ada_val_print_1): Relocate to base address
before displaying the content of an interface-wide ref.
gdb/testsuite/ChangeLog:
* gdb.ada/ptype_tagged_param.exp: Adjust expected output in
ptype test.
In the evaluation of an expression in Ada mode, the default case
unwraps the argument unconditionally. For an object of a variant
record type, this unwrapping builds a fixed type from the
specification of the variant type and the actual values of the
object's discriminants. It means that unwrapping needs the "proper"
value for the object, not just a zero value with the proper type.
When not in EVAL_NORMAL, we cannot assume that the evaluation returns
such a proper value; it may well return a zero value of the
appropriate type e.g in EVAL_AVOID_SIDE_EFFECTS. It is wrong to try to
unwrap in that case.
In particular, a problem shows up when using expression of the form
{VARIANT_TYPE}OBJ. GDB first evaluates this expression in
EVAL_AVOID_SIDE_EFFECTS to compute the type, the evaluation of OBJ
in most cases returns a zero value of its type, and as UNOP_MEMVAL
is mapped to the default case its evaluation ends up trying to
read memory around address 0.
gdb/ChangeLog:
* ada-lang.c (ada_evaluate_subexp): Unwrap only in EVAL_NORMAL.
We use a list of regular expressions to match a symtab filenames
against the names of the files in the Ada runtime. These regular
expressions do assume that the filename is a basename, however.
So make sure to evaluate these regular expressions against
the symtab's filename.
Without this patch, we run into problems when the Ada runtime was built
using a project file (through gprbuild).
gdb/ChangeLog:
* ada-lang.c (is_known_support_routine): Use lbasename when
matching the symtab's filename against
known_runtime_file_name_patterns.
Given the following variable declaration...
Www : Wide_String := "12345";
... this patch allows the following assignment to work:
(gdb) set variable www := "qwert"
Without this patch, the debugger rejects the assignment because
the size of the array elements are different:
(gdb) set www := "asdfg"
Incompatible types in assignment
(on the lhs, we have an array of 2-bytes elements, and on the rhs,
we have a standard 1-byte string).
gdb/ChangeLog:
* ada-lang.c (ada_same_array_size_p): New function.
(ada_promote_array_of_integrals): New function.
(coerce_for_assign): Add handling of arrays where the elements
are integrals of a smaller size than the size of the target
array element type.
gdb/testsuite/ChangeLog:
* gdb.ada/set_wstr: New testcase.
gdb/ChangeLog:
* ada-lang.c (ada_template_to_fixed_record_type_1): Do not
strip typedef layer when computing the fixed type's field type,
only when computing its size.
gdb/testsuite/ChangeLog:
* gdb.ada/unc_arr_ptr_in_var_rec: New testcase.
Assuming the following declarations:
type Discriminants_Record (A : Integer; B : Boolean) is record
C : Float;
end record;
Z : Discriminants_Record := (A => 1, B => False, C => 2.0);
If variable Z is not used, and the compiler optimizes it out,
GDB would crash as follow:
(gdb) print Z
/[...]/gdb/valops.c:1121: internal-error: Unexpected lazy value type.
This is because the ada-lang module forgot to set the optimized_out
flag in the value returned by ada_evaluate_subexp during the value's
"fixing" process. Later on, when trying to print the resulting value,
GDB finds that the value is still lazily allocated, and thus tries to
fetch it. But this is not allowed for not_lval values, hence the internal
error.
gdb/ChangeLog:
* ada-lang.c (coerce_unspec_val_to_type): Make sure that
the optimized_out flag is preserved.
gdb/testsuite/ChangeLog:
* gdb.ada/optim_drec: New testcase.
The code for handling calls to internal functions (esp., Python
functions) and for handling STT_GNU_IFUNC had not been added to the Ada
expression evaluator. This change adapts them from eval.c.
gdb/Changelog:
* ada-lang.c (ada_evaluate_subexp): Add cases for
TYPE_CODE_INTERNAL_FUNCTION and for TYPE_GNU_IFUNC, following
their treatment in eval.c.
PR symtab/7259:
* ada-exp.y (convert_char_literal): Use TYPE_FIELD_ENUMVAL.
* ada-lang.c (ada_discrete_type_high_bound)
(ada_discrete_type_low_bound): Use TYPE_FIELD_ENUMVAL for
TYPE_CODE_ENUM.
(ada_identical_enum_types_p): Use TYPE_FIELD_ENUMVAL.
(pos_atr, value_val_atr): Use TYPE_FIELD_ENUMVAL for TYPE_CODE_ENUM.
* ada-typeprint.c (print_enum_type): Change variable lastval to LONGEST.
Use TYPE_FIELD_ENUMVAL.
* ada-valprint.c (print_optional_low_bound, ada_print_scalar)
(ada_val_print_1): Use TYPE_FIELD_ENUMVAL for TYPE_CODE_ENUM.
* c-typeprint.c (c_type_print_base): Move variable lastval to inner
block, change it to LONGEST. Use TYPE_FIELD_ENUMVAL for
TYPE_CODE_ENUM.
* coffread.c (coff_read_enum_type): Use SET_FIELD_ENUMVAL.
* dwarf2read.c (process_enumeration_scope): Likewise.
* gdb-gdb.py (TypeFlagsPrinter): Use field.enumval instead of
field.bitpos.
(class StructMainTypePrettyPrinter): Support also
FIELD_LOC_KIND_ENUMVAL.
* gdbtypes.c (get_discrete_bounds): Use TYPE_FIELD_ENUMVAL for
TYPE_CODE_ENUM.
(recursive_dump_type): Use TYPE_FIELD_ENUMVAL for TYPE_CODE_ENUM.
(copy_type_recursive): Support also FIELD_LOC_KIND_ENUMVAL.
* gdbtypes.h (enum field_loc_kind): New FIELD_LOC_KIND_ENUMVAL.
(struct main_type.flds_bnds.fields.loc): Adjust bitpos comment. New
field enumval.
(struct main_type.flds_bnds.bields): Adjust loc_kind and bitsize to
accommodate enumval.
(struct call_site): Adjust loc_kind to accommodate enumval.
(FIELD_ENUMVAL, FIELD_ENUMVAL_LVAL, SET_FIELD_ENUMVAL)
(TYPE_FIELD_ENUMVAL): New macros.
* m2-typeprint.c (m2_enum): Use TYPE_FIELD_ENUMVAL.
* mdebugread.c (parse_symbol): Use TYPE_FIELD_ENUMVAL for
TYPE_CODE_ENUM.
* p-typeprint.c (pascal_type_print_base): Likewise.
* python/lib/gdb/printing.py (class FlagEnumerationPrinter): Use
enumval.
* python/lib/gdb/types.py (make_enum_dict): Likewise.
* python/py-type.c (convert_field): New variable addrstring. Use
TYPE_FIELD_ENUMVAL for TYPE_CODE_ENUM.
(check_types_equal): Support also FIELD_LOC_KIND_ENUMVAL.
* stabsread.c (read_enum_type): Use SET_FIELD_ENUMVAL.
* typepint.c (print_type_scalar): Use TYPE_FIELD_ENUMVAL for
TYPE_CODE_ENUM.
* valprint.c (generic_val_print): Likewise.
gdb/testsuite/
PR symtab/7259:
* gdb.base/enumval.c: New test case.
* gdb.base/enumval.exp: New test case.
* gdb.python/py-type.exp (test_enums): Use field.enumval instead of
field.bitpos.
Do not rely on FIELD_LOC_KIND_BITPOS being zero.
* ada-lang.c (ada_template_to_fixed_record_type_1): Replace
TYPE_FIELD_BITPOS used as lvalue by SET_FIELD_BITPOS.
* gdbtypes.c (append_flags_type_flag): Likewise, twice.
* jv-lang.c (java_link_class_type): Likewise, once.
* stabsread.c (read_enum_type): Likewise.
This renaming allows us to have variable names that are consistent
with the names of the parameters in the functions where these
variables are used. This also allows us to avoid a -Wshadow warning
in the case of variable "wild_match", which is now renamed to
"wild_match_p".
gdb/ChangeLog:
-Wshadow warning fix.
* ada-lang.c (ada_make_symbol_completion_list): Rename parameters
"wild_match" and "encoded" into "wild_match_p" and "encoded_p".
Adjust code accordingly.
... This is mostly to be consistent with the style used for the other
parameter of the same kind ("wild_match_p") in that function.
gdb/ChangeLog:
* ada-lang.c (symbol_completion_add): Rename parameter
"encoded" into "encoded_p". Ajust code and documentation
accordingly.
... This is mostly to be consistent with the style used for the other
parameter of the same kind ("wild_match_p") in that function.
gdb/ChangeLog:
* ada-lang.c (symbol_completion_match): Rename parameter
"encoded" into "encoded_p". Ajust code and documentation
accordingly.
... to avoid a -Wshadow warning with a symbol exported by BFD.
gdb/ChangeLog:
-Wshadow warning fix.
* ada-lang.c (ada_lookup_encoded_symbol): Rename parameter
"symbol_info" into "info". Adjust code accordingly.
(ada_lookup_symbol): Likewise.
This patch mostly removes a few trailing spaces.
gdb/ChangeLog:
* ada-lang.c (ada_lookup_symbol_list): Minor reformatting
of this function's documentation.
... to avoid -Wshadow warning...
gdb/ChangeLog:
-Wshadow warning fix.
* ada-lang.c (ada_add_local_symbols): Rename "wild_match"
parameter into "wild_match_p". Adjust code accordingly.
Document this parameter in the function description.
This makes ada_lookup_encoded_symbol more consistent with other functions
such as ada_lookup_symbol_list, and also makes it clearer in the code
using that function that symbol and block are related.
gdb/ChangeLog:
* ada-lang.c (ada_lookup_encoded_symbol): Now returns void.
Replace block_found argument by symbol_info. Adjust
implementation accordingly. Add function documentation.
(ada_lookup_symbol): Adjust to new ada_lookup_encoded_symbol.
Fix documentation.
* ada-lang.h (ada_lookup_encoded_symbol): Update declaration.
* ada-exp.y (write_object_renaming): Adjust to new
ada_lookup_encoded_symbol API.
Consider the following declaration:
type Small is new Integer range 0 .. 2 ** 4 - 1;
type Simple_Array is array (1 .. 4) of Small;
pragma Pack (Simple_Array);
SA : Simple_Array := (1, 2, 3, 4);
Trying to change the value of one of the elements in the packed array
causes the debugger to crash:
(gdb) set sa(3) := 9
[1] 4880 segmentation fault gdb -q foo
The circumstances leading to the crash are as follow:
. ada_evaluate_subexp creates a value corresponding to "sa(3)".
. ada_evaluate_subexp then tries to assign 9 to this value, and
for this calls value_assign (via ada_value_assign).
. Because the array is packed, the destination value is 3 bits long,
and as a result, value_assign uses the parent to determine that
element byte address and offset:
| if (value_bitsize (toval))
| {
| struct value *parent = value_parent (toval);
|
| changed_addr = value_address (parent) + value_offset (toval);
The destination value (corresponding to "sa(3)") was incorrectly created
by ada-lang.c:ada_value_primitive_packed_val, because the "parent" was
left as NULL. So, when we try to dereference it to get the parent address,
GDB crashed.
The first part of the fix therefore consists in setting that field.
This required the addition of a new "setter" in value.[hc]. It fixes
the crash, but is still not sufficient for the assignment to actually
work.
The second part of the problem came from the fact that value_assign
seems to expect the "child"'s address to be equal to the parent's address,
with the difference being the offset. Unfortunately, this requirement was
not followed by ada_value_primitive_packed_val, so the second part of
the fix consisted in fixing that.
Still, this was not sufficient, because it caused a regression when
trying to perform an aggregate assignment of a packed array of packed
record. The key element here is the nesting of packed entities.
Looking at the way ada_value_primitive_packed_val creates the value
of each sub-component, one can see that the value's offset is set
to the offset compared to the start of the parent. This was meant to
match what value_primitive_field does as well.
So, with our array of records, if the record offset was 2, and if
the field we're interested in that record is at offset 1, the record
value's offset would be set to 2, and the field value's offset would
be set to 1. But the address for both values would be left to the
array's address. This is where things start breaking down, because
the value_address function for our field value would return the
address of the array + 1, instead of + 3.
This is what causes the final issue, here, because ada-lang.c's
value_assign_to_component needs to compute the offset of the
subcomponent compared to the top-level aggregate's start address
(the array in our case). And it does so by subtracting the array's
address from the sub-component's address. When you have two levels
of packed components, and the mid-level component is at an offset of
the top-level component, things didn't work, because the component's
address was miscomputed (the parent's offset is missing).
The fix consists is fixing value_address to match the work done by
value_primitive_field (where we ignore the parent's offset).
gdb/ChangeLog:
* value.h (set_value_parent): Add declaration.
* value.c (set_value_parent): New function.
(value_address): If VALUE->PARENT is not NULL, then use it as
the base address instead of VALUE->LOCATION.address.
* ada-lang.c (ada_value_primitive_packed_val): Keep V's address
the same as OBJ's address. Adjust V's offset accordingly.
Set V's parent.
gdb/testsuite/ChangeLog:
* gdb.ada/set_pckd_arr_elt: New testcase.
The purpose of this patch is to better support renamings in the
"info locals" command. Consider ...
procedure Foo is
GV : Integer renames Pck.Global_Variable;
begin
Increment (GV); -- STOP
end Foo;
... Pck.Global_Variable is just an integer. After having stopped at
the "STOP" line, "info locals" yields:
(gdb) info locals
gv = <error reading variable gv (Cannot access memory at address 0xffffffffffffffff)>
In reality, two things are happening:
(1) Variable "GV" does not exist, which is normal, since there is
"GV" the renaming of another variable;
(2) But to allow the user access to that renaming the same way
the code has, the compiler produces an artificial variable
whose name encodes the renaming:
gv___XR_pck__global_variable___XE
For practical reasons, the artificial variable itself is given
irrelevant types and addresses.
But the "info locals" command does not act as if it was a short-cut
of "foreach VAR in locals, print VAR". Instead it gets the value of
each VAR directly, which does not work in this case, since the variable
is artificial and needs to be decoded first.
This patch makes the "read_var_value" routine language-specific.
The old implementation of "read_var_value" gets renamed to
"default_read_var_value" and all languages now use it (unchanged
behavior), except for Ada. In Ada, the new function ada_read_var_value
checks if we have a renaming, and if so, evaluates its value, or else
defers to default_read_var_value.
gdb/ChangeLog:
* language.h (struct language_defn): New "method" la_read_var_value.
* findvar.c: #include "language.h".
(default_read_var_value): Renames read_var_value. Rewrite
function description.
(read_var_value): New function.
* value.h (default_read_var_value): Add prototype.
* ada-lang.c (ada_read_renaming_var_value, ada_read_var_value):
New functions.
(ada_language_defn): Add entry for la_read_var_value.
* c-lang.c, d-lang.c, f-lang.c, jv-lang.c, language.c,
* m2-lang.c, objc-lang.c, opencl-lang.c, p-lang.c: Update
language_defn structures to add entry for new la_read_var_value
field.
This is a minor improvement in ada_find_renaming_symbol: What we were
doing was going from a symbol, get its name, and then search for
renamings. But if the original symbol was already itself a renaming,
then we'd look the symbol up again to return it. Since we had the
symbol in the first place, we shouldn't need to look it up again.
This is what this patch does: Modify ada_find_renaming_symbol to
take a symbol instead of the symbol's (linkage) name, and then updates
the one caller.
gdb/ChangeLog:
* ada-lang.h (ada_find_renaming_symbol): Replace parameter
"name" with "struct symbol *name_sym".
* ada-exp.y (write_var_or_type): Update call to
ada_find_renaming_symbol.
* ada-lang.c (ada_find_renaming_symbol): Replace parameter
"name" with "struct symbol *name_sym". Adjust Implementation
accordingly. Adjust the function documentation.
Consider the following function...
3 procedure Foo is
4 I : Integer := Ident (10);
5 Obj : Base;
6 begin
7 Obj.X := I;
8 Do_Nothing (Obj.X'Address);
9 end Foo;
... where type "Base" is defined as a plain tagged record. If the user
stops execution before "Obj" gets initialized (for example, by inserting
a breakpoint "on" the function - or in other words, by inserting a
breakpoint using the function name as the location), one might get
the following of output if you try printing the value of obj:
(gdb) p obj
object size is larger than varsize-limit
object size is larger than varsize-limit
object size is larger than varsize-limit
$1 = object size is larger than varsize-limit
(x => 4204154)
Same thing with "info locals":
(gdb) info locals
i = 0
obj = object size is larger than varsize-limit
(x => 4204154)
We have also seen different error messages such as "Cannot read
memory at 0x...".
The error happens because we are trying to read the dispatch table
of a tagged type variable before it gets initialized. So the errors
might legitimately occur, and are supposed to be be contained.
However, the way things are written in ada-lang.c:ada_tag_name,
although the exception is in fact contained, the error message still
gets to be printed out.
This patch prevents this from happening by eliminating the use of
catch_errors, and using a TRY_CATCH block instead. Doing this removed
the need to use functions specifically fitted for catch_errors, and
thus some other simplifications could me made. In the end, the code
got reorganized a bit to better show the logic behind it, as well as
the common patterns.
gdb/ChangeLog:
* ada-lang.c (struct tag_args): Delete.
(ada_get_tsd_type): Function body moved up in source file.
(ada_tag_name_1, ada_tag_name_2): Delete.
(ada_get_tsd_from_tag): New function.
(ada_tag_name_from_tsd): New function.
(ada_tag_name): Use a TRY_CATCH block instead of catch_errors
to determine the tag name.
gdb/testsuite/ChangeLog:
* gdb.ada/tagged_not_init: New testcase.
This patch introduces two new functions that will be used to support
the implementation of the ada-varobj effort. The function descriptions
should say it all...
gdb/ChangeLog:
* ada-lang.h (ada_get_decoded_value, ada_get_decoded_type): Add
declaration.
* ada-lang.c (ada_get_decoded_value, ada_get_decoded_type): New
function.
The ada_lookup_symbol_list function has recently been changed to accept
a "full_search" parameter. When null, this parameter instructs the
function to perform a partial search (global and static symbols are not
searched). When doing a partial search, the result should not be saved
into the lookup cache, as the result might be incomplete.
This manifested itself when trying to perform a function call on AVR
after having inserted a breakpoint inside that function:
(gdb) b same
Breakpoint 2 at 0x78: file r.adb, line 5.
(gdb) call same(42)
Breakpoint 2, r.same (i=42) at r.adb:5
5 return I;
The program being debugged stopped while in a function called from GDB.
Evaluation of the expression containing the function
(at 0x0x800068) will be abandoned.
^^^^^^^^^^^^^^^
When the function is done executing, GDB will silently stop.
The expected output for the underlined portion is "(r.same)".
What happens is that the breakpoint command triggers 3 lookups of the
name "same":
1. full search in LABEL_DOMAIN -> no match, cached;
2. full search in VAR_DOMAIN -> 1 match, cached;
3. partial search in VAR_DOMAIN -> no match, cached.
The third lookup therefore causes the results of the partial search
to be cached, thus overriding the result of the full search lookup.
During the following command, the reference to "same" triggers a lookup
of that symbol again. And since GDB CAN find the result of that lookup
in the cache, it returns just that, which is: No match. (wrong!)
As a result, we fallback on the symbol table to resolve the lookup.
And instead of pushing an OP_VAR_VALUE subexpression for symbol "same",
the parser ends up pushing an UNOP_MEMVAL subexpression using the value
of the minimal symbol. This is where being on AVR becomes important:
addresses on AVR are modular types, and if GDB thinks an address is
a data address, it converts it.
This is where one notices the fact that the breakpoint was inserted
at 0x78, and yet GDB says that the function we stopped at is at
0x0x800068...
This patch fixes the problem by making sure we only cache the result
of full searches.
gdb/ChangeLog:
* ada-lang.c (ada_lookup_symbol_list): Only cache the result of
full searches.
Consider the following declarations (a packed array indexed by an
enumerated type):
type Color is (Black, Red, Green, Blue, White);
type Full_Table is array (Color) of Boolean;
pragma Pack (Full_Table);
Full : Full_Table := (False, True, False, True, False);
GDB is unable to print the index values correctly. It prints the
enumeration's underlying value instead of the enumeration name:
(gdb) p full
$1 = (0 => false, true, false, true, false)
(gdb) p full'first
$2 = 0
And yet, it is capable of printing the correct type description:
(gdb) ptype full
type = array (black .. white) of boolean <packed: 1-bit elements>
To get to the real index type, one has to follow the parallel XA type.
We already do this for normal arrays. We can do it for this packed
array as well.
gdb/ChangeLog:
* ada-lang.c (constrained_packed_array_type): If there is a
parallel XA type, use it to determine the array index type.
gdb/testsuite/ChangeLog:
* gdb.ada/arrayidx.exp: Adjust expected output for p_one_two_three.
* gdb.ada/enum_idx_packed: New testcase.
We should always unwrap a value before trying to "fix" it. It is
therefore logical that ada_to_fixed_value would call unwrap_value
before creating the fixed value.
This simplifies the code in ada-lang.c a bit.
gdb/ChangeLog:
* ada-lang.c (ada_to_fixed_value): Call unwrap_value before
creating fixed value.
(ada_value_ind, ada_coerce_ref, assign_component)
(ada_evaluate_subexp): Remove call to unwrap_value before
call to ada_to_fixed_value.
Consider the following declaration:
type Full_Table is array (Color) of Integer;
Full : Full_Table := (144, 233, 377, 610, 987);
The debugger correctly prints the type name of variable "full":
(gdb) whatis full
type = pck.full_table
But is unable to do so when using the value history:
(gdb) print full
$1 = (144, 233, 377, 610, 987)
(gdb) whatis $
!!! -> type = array (black .. white) of integer
This is because the evaluation creates a "fixed" version of
the array type, and that "fixed" version is missing a type name.
As a result, whatis falls back to describing the type (a la ptype)
instead of printing the type name.
gdb/ChangeLog:
* ada-lang.c (to_fixed_array_type): Set result's type name.
gdb/testsuite/ChangeLog:
* gdb.ada/whatis_array_val: New testcase.
Previously, conditions could be associated to Ada exception catchpoints,
but not while creating the exception catchpoint:
(gdb) catch exception first_exception if except_counter = 5
Junk at end of expression
This patch improves the parsing of the command arguments to allow
an "if CONDITION" at the end. All Ada exception catchpoint commands
have been enhanced to support this.
gdb/ChangeLog:
* ada-lang.c (catch_ada_exception_command_split): Add new
argument cond_string. Add support for condition at end of
"catch exception" commands.
(ada_decode_exception_location): Add new argument cond_string.
Update call to catch_ada_exception_command_split.
(create_ada_exception_catchpoint): Add new argument cond_string.
Set the breakpoint condition if needed.
(catch_ada_exception_command): Update call to
ada_decode_exception_location.
(ada_decode_assert_location): Add function documentation.
Add support for condition at end of "catch assert" command.
(catch_assert_command): Update calls to ada_decode_assert_location
and create_ada_exception_catchpoint.
The la_get_symbol_name_match_p language hook was poorly named, as
it suggested that the function should return nonzero if the names
match, whereas it is the exact opposite. This patch therefore
renames the hook and associated typedef, as well some of the code
that uses that hook.
gdb/ChangeLog:
* language.h (symbol_name_cmp_ftype): Renames
symbol_name_match_p_ftype.
(struct language_defn)[la_get_symbol_name_cmp]: Renames
la_get_symbol_name_match_p.
* ada-lang.c (ada_get_symbol_name_cmp): Renames
ada_get_symbol_name_match_p. Update comment.
(ada_language_defn)[la_get_symbol_name_cmp]: Update value.
* linespec.c (struct symbol_matcher_data)[symbol_name_cmp]:
Renames symbol_name_match_p. Update field type.
(iterate_name_matcher, iterate_over_all_matching_symtabs): Adjust.
* c-lang.c, d-lang.c, f-lang.c, jv-lang.c, m2-lang.c, objc-lang.c,
opencl-lang.c, p-lang.c: Replace "la_get_symbol_name_match_p" by
"la_get_symbol_name_cmp" in comments.
* language.c: Likewise.
and fields.name members from char * to const char *. All uses updated.
(struct cplus_struct_type): Change type of fn_fieldlists.name member
from char * to const char *. All uses updated.
(type_name_no_tag): Update.
(lookup_unsigned_typename, lookup_signed_typename): Update.
* gdbtypes.c (type_name_no_tag): Change result type
from char * to const char *. All callers updated.
(lookup_unsigned_typename, lookup_signed_typename): Change type of
name parameter from char * to const char *.
* symtab.h (struct cplus_specific): Change type of demangled_name
member from char * to const char *. All uses updated.
(struct general_symbol_info): Change type of name and
mangled_lang.demangled_name members from char * to const char *.
All uses updated.
(symbol_get_demangled_name, symbol_natural_name): Update.
(symbol_demangled_name, symbol_search_name): Update.
* symtab.c (symbol_get_demangled_name): Change result type
from char * to const char *. All callers updated.
(symbol_natural_name, symbol_demangled_name): Ditto.
(symbol_search_name): Ditto.
(completion_list_add_name): Change type of symname,sym_text,
text,word parameters from char * to const char *.
(completion_list_objc_symbol): Change type of sym_text,
text,word parameters from char * to const char *.
* ada-lang.c (find_struct_field): Change type of name parameter
from char * to const char *.
(encoded_ordered_before): Similarly for N0,N1 parameters.
(old_renaming_is_invisible): Similarly for function_name parameter.
(ada_type_name): Change result type from char * to const char *.
All callers updated.
* ada-lang.h (ada_type_name): Update.
* buildsym.c (hashname): Change type of name parameter
from char * to const char *.
* buildsym.h (hashname): Update.
* dbxread.c (end_psymtab): Change type of include_list parameter
from char ** to const char **.
* dwarf2read.c (determine_prefix): Change result type
from char * to const char *. All callers updated.
* f-lang.c (find_common_for_function): Change type of name, funcname
parameters from char * to const char *.
* f-lang.c (find_common_for_function): Update.
* f-valprint.c (list_all_visible_commons): Change type of funcname
parameters from char * to const char *.
* gdbarch.sh (static_transform_name): Change type of name parameter
and result from char * to const char *.
* gdbarch.c: Regenerate.
* gdbarch.h: Regenerate.
* i386-sol2-tdep.c (i386_sol2_static_transform_name): Change type
of name parameter from char * to const char *.
* jv-lang.c (java_primitive_type_from_name): Ditto.
(java_demangled_signature_length): Similarly for signature parameter.
(java_demangled_signature_copy): Ditto.
(java_demangle_type_signature): Ditto.
* jv-lang.h (java_primitive_type_from_name): Update.
(java_demangle_type_signature): Update.
* objc-lang.c (specialcmp): Change type of a,b parameters
from char * to const char *.
* p-lang.c (is_pascal_string_type): Change type of arrayname parameter
from char * to const char *. All callers updated.
* p-lang.h (is_pascal_string_type): Update.
* solib-frv.c (find_canonical_descriptor_in_load_object): Change type
of name parameter from char * to const char *.
* sparc-sol2-tdep.c (sparc_sol2_static_transform_name): Ditto.
* utils.c (fprintf_symbol_filtered): Ditto.
* defs.h (fprintf_symbol_filtered): Update.
* sparc-tdep.h (sparc_sol2_static_transform_name): Update.
* stabsread.h (end_psymtab): Update.
* stack.c (find_frame_funname): Change type of funname parameter
from char ** to const char **.
* stack.h (find_frame_funname): Update.
* typeprint.c (type_print): Change type of varstring parameter
from char * to const char *.
* value.h (type_print): Update.
* xcoffread.c (xcoff_start_psymtab): Change type of filename parameter
from char * to const char *. All callers updated.
(xcoff_end_psymtab): Change type of include_list parameter
from char ** to const char **. All callers updated.
(swap_sym): Similarly for name parameter. All callers updated.
* coffread.c (patch_type): Add (char*) cast to xfree parameter.
Use xstrdup.
(process_coff_symbol): Use xstrdup.
* stabsread.c (stabs_method_name_from_physname): Renamed from
update_method_name_from_physname. Change result type from void
to char *. All callers updated.
(read_member_functions): In has_destructor case, store name in objfile
obstack instead of malloc space. In !has_stub case, fix mem leak.
The quick_symbol_functions struct contains a field which is pointer
a function which takes another function, called name_matcher, as
its parameter. This name_matcher currently has 3 arguments, one
of them being the language. This parameter is no longer used, and
thus deleted.
gdb/ChangeLog:
* symfile.h (struct quick_symbol_functions) [expand_symtabs_matching]:
Remove language parameter from name_matcher. Adjust the comment.
* symtab.c (search_symbols_name_matches, expand_partial_symbol_name):
Remove language parameter.
* ada-lang.c (ada_expand_partial_symbol_name): Likewise.
* linespec.c (iterate_name_matcher): Likewise.
* dwarf2read.c (dw2_expand_symtabs_matching): Adjust type of
name_matcher. Adjust call accordingly.
* psymtab.c (expand_symtabs_matching_via_partial): Likewise.
(maintenance_check_symtabs): Adjust type of parameter "fun".
* psymtab.h (maintenance_check_symtabs): Likewise.
This is the meat, where we replace the old la_symbol_name_compare
language method with the new ada_get_symbol_name_match_p.
It fixes the problem when trying to insert a breakpoint on "+".
gdb/ChangeLog:
* language.h (symbol_name_match_p_ftype): New typedef.
(struct language_defn): Replace field la_symbol_name_compare
by la_get_symbol_name_match_p.
* ada-lang.c (ada_get_symbol_name_match_p): New function.
(ada_language_defn): Use it.
* linespec.c (struct symbol_matcher_data): New type.
(iterate_name_matcher): Rewrite.
(iterate_over_all_matching_symtabs): Pass a pointer to
a symbol_matcher_data struct to expand_symtabs_matching
instead of just the lookup name.
* c-lang.c, d-lang.c, jv-lang.c, m2-lang.c, objc-lang.c,
opencl-lang.c, p-lang.c, language.c: Delete field
la_symbol_name_compare, and replace by NULL for new field
la_get_symbol_name_match_p.
* symfile.h (struct quick_symbol_functions): Update comment.
This is just a minor cleanup that reduces a bit the code in ada-lang.c
by using skip_spaces or skip_to_space, instead of doing the skipping
ourselves.
gdb/ChangeLog:
* ada-lang.c: #include "cli/cli-utils.h".
(get_selections): Use skip_spaces.
(ada_get_next_arg): Use skip_spaces and skip_to_space.
(catch_ada_exception_command_split): Use skip_spaces.
(ada_decode_assert_location): Likewise.
... to avoid code duplication.
gdb/ChangeLog:
* ada-lang.c (should_use_wild_match): New function.
(ada_lookup_simple_minsym): Use should_use_wild_match.
Minor simplification. Add comment.
(ada_lookup_symbol_list): Use should_use_wild_match.
Minor simplification.
Consider the following declaration:
package Pck is
task Dummy_Task is
entry Start;
end Dummy_Task;
end Pck;
Inserting a breakpoint on the body of that task does not currently
work:
(gdb) b pck.dummy_task
"pck.dummy_task" is not a function
Make breakpoint pending on future shared library load? (y or [n]) n
What happens here is that the compiler generates two symbols:
(a) Symbol `pck__dummy_task' which is a *variable* referencing
the task;
(b) Symbol `pck__dummy_taskTKB' which is the subprogram implementing
the body of the task.
The symbol lookup only finds the variable before of the TKB suffix in
the subprogram name. This patch fixes the problem by adjusting the
ada-lang.c:is_name_suffix routine to recognize "TKB" suffixes. But
that's not enough, because the search in the symtab is performed via
the block dictionary, using a hashing algorithm. So, for the search
to find `pck__dummy_taskTKB', I had to modify the hashing function
to ignore TKB suffixes as well.
gdb/ChangeLog:
* ada-lang.c (is_name_suffix): Add handling of "TKB" suffixes.
Update function documentation.
* dictionary.c (dict_hash): Ignore "TKB" suffixes in hash
computation.
gdb/testsuite/ChangeLog:
* gdb.ada/task_bp: New testcase.
Field found_sym in add_nonlocal_symbols's struct match_data is
used uninitialized. Rather than adding the initialization of
this field (to zero), we set the entire structure to zero first,
and then set the fields that need to be initialized to non-zero
next.
gdb/ChangeLog:
* ada-lang.c (add_nonlocal_symbols): Initialize data to
all zeros. Remove setting of data.arg_sym to NULL.
The ada-lang module was using a static global called "exception_info"
for all inferiors. But each inferior might be different, and thus
this patch makes this data per-inferior.
gdb/ChangeLog:
* ada-lang.c (struct ada_inferior_data) [exception_info]:
New field.
(exception_info): Delete.
(ada_exception_support_info_sniffer): Get exception_support_info
data from our per-inferior data. Adjust code accordingly.
(ada_unhandled_exception_name_addr_from_raise): Likewise.
(ada_exception_name_addr_1, ada_exception_sym_name): Ditto.
(ada_executable_changed_observer): Delete.
(_initialize_ada_language): Remove call to
observer_attach_executable_changed.
This patch should help the user understand why the debugger is not
able to insert Ada exception catchpoints when the Ada runtime was
stripped of debugging info, as is often the case on many GNU/Linux
distros:
(gdb) catch exception
Your Ada runtime appears to be missing some debugging information.
Cannot insert Ada exception catchpoint in this configuration.
gdb/ChangeLog:
* ada-lang.c (ada_has_this_exception_support): Raise an error
if we could find the Ada exception hook in the Ada runtime,
but no debugging info for that hook.
gdb/testsuite/ChangeLog:
* gdb.ada/catch_ex.exp, gdb.ada/mi_catch_ex.exp: Adjust
expected output for unsupported case.
This patch cleans up a bit the way we detect which type of runtime
the program uses with respect to Ada exceptions. It also removes
an unnecessary check in ada_exception_sal which is already performed
by ada_exception_support_info_sniffer.
Some of the changes are preparation work for detecting the situation
where the Ada runtime is found, but lacking debugging info.
gdb/ChangeLog:
* ada-lang.c (ada_has_this_exception_support): New function,
extracted out of ada_exception_sal and ada_exception_sal.
(ada_exception_support_info_sniffer): Simplify by using
ada_has_this_exception_support.
(ada_exception_sal): Replace unnecessary checks by assertions.
Minor simplifications.
The ada-lang.c:compare_names function returns the wrong value
when the first string starts with the same contents as the second
string, followed by '_' and then some characters that do not make
a symbol name suffix. For instance:
string1 = "generics__test_generics__instance__print"
string2 = "generics__test_generics"
In that case, compare_names (string1, string2) return -1, when
clearly, string1 is greater than string2.
A consequence of this problem is that GDB may fail to lookup
"generics.test_generics" from our partial symtabs, because
partial symbols are ordered by strcmp_iw_ordered:
(gdb) b generics.test_generics
Function "generics.test_generics" not defined.
Make breakpoint pending on future shared library load? (y or [n])
gdb/ChangeLog:
* ada-lang.c (compare_names): Fix wrong return value in case
string1 starts with the same contents as string2, followed
by an underscore that do not start a symbol name suffix.
gdb/testsuite/ChangeLog:
* gdb.ada/fullname_bp: New testcase.
gdb/ChangeLog:
From Andrey Smirnov <andrew.smirnov@gmail.com>:
* ada-lang.c (assign_aggregate): Remove declaration of local
variable `i' which is shadowing another variable with the same
name declared in the outer scope.
This avoids shadowing issues with variables named base_type.
gdb/ChangeLog:
* ada-lang.c (get_base_type): Renames base_type. Adjust all
calls throughout this file.
Implement most breakpoint_ops methods for all breakpoint types,
and move the default handlings to the proper callbacks.
gdb/
* breakpoint.c (update_watchpoint): Always call the breakpoint's
works_in_software_mode method.
(insert_bp_location): Go through breakpoint_ops->insert_location
for software and hardware watchpoints.
(create_internal_breakpoint): Pass bkpt_breakpoint_ops as
breakpoint_ops.
(remove_breakpoint_1): Go through breakpoint_ops->remove_location
for software and hardware watchpoints.
(print_it_typical): Delete.
(print_bp_stop_message): Always call the breakpoint_ops->print_it
method.
(watchpoint_check): Adjust comment.
(bpstat_check_location): Simply always call the breakpoint's
breakpoint_hit method.
(bpstat_stop_status): Always call the breakpoint's check_status
method. Remove special cases for watchpoints and internal event
breakpoints from here (moved to the check_status implementations).
(print_one_breakpoint_location): Assume b->ops is never NULL.
Remove static tracepoint marker id printing from here (moved to
the print_one_detail callback implementation of tracepoints).
(init_bp_location): Assert OPS is never NULL.
(allocate_bp_location): Always call the breakpoint's
allocate_location method, and remove the default code from here.
(free_bp_location): Always call the location's dtor method, and
remove the default code from here.
(init_raw_breakpoint_without_location): Assert OPS is never NULL.
(set_raw_breakpoint_without_location): Add new breakpoint_ops
parameter. Pass it down.
(set_raw_breakpoint): Ditto.
(print_it_catch_fork): Adjust to take a bpstat as argument.
(catch_fork_breakpoint_ops): Install methods.
(print_it_catch_vfork): Adjust to take a bpstat as argument.
(catch_vfork_breakpoint_ops): Install methods.
(dtor_catch_syscall): Call the base dtor.
(print_it_catch_syscall): Adjust to take a bpstat as argument.
(catch_syscall_breakpoint_ops): Install methods.
(dtor_catch_exec): Call the base dtor.
(print_it_catch_exec): Adjust to take a bpstat as argument.
(catch_exec_breakpoint_ops): Install methods.
(hw_breakpoint_used_count, hw_watchpoint_used_count): Always call
the breakpoint's resources_needed method, and remove the default
code from here.
(set_momentary_breakpoint): Pass bkpt_breakpoint_ops as
breakpoint_ops.
(clone_momentary_breakpoint): Clone the original's ops.
(mention): Always call the breakpoint's print_mention method, and
remove the default code from here.
(create_breakpoint_sal): Adjust to pass the ops to
set_raw_breakpoint rather than setting it manually.
(create_breakpoint): Assert ops is never NULL. Adjust to pass the
ops to set_raw_breakpoint_without_location rather than setting it
manually.
(break_command_1): Pass bkpt_breakpoint_ops as breakpoint_ops.
(print_it_ranged_breakpoint): Adjust to take a bpstat as argument.
(ranged_breakpoint_ops): Install methods.
(break_range_command): Adjust to pass the ops to
set_raw_breakpoint rather than setting it manually.
(re_set_watchpoint, breakpoint_hit_watchpoint)
(check_status_watchpoint, resources_needed_watchpoint)
(works_in_software_mode_watchpoint, print_it_watchpoint)
(print_mention_watchpoint, print_recreate_watchpoint): New
functions.
(watchpoint_breakpoint_ops): Install new methods.
(print_it_masked_watchpoint): New function.
(masked_watchpoint_breakpoint_ops): Install new methods.
(watch_command_1): Adjust to pass the right breakpoint_ops to
set_raw_breakpoint_without_location rather than setting it
manually later. Record the current pspace.
(print_it_exception_catchpoint): Adjust to take a bpstat as
argument.
(gnu_v3_exception_catchpoint_ops): Install new methods.
(say_where): New function.
(null_re_set, null_check_status, null_works_in_software_mode)
(null_resources_needed, null_print_one_detail, bp_location_dtor):
New functions.
(bp_location_ops): New global.
(bkpt_dtor, bkpt_allocate_location, bkpt_re_set)
(bkpt_insert_location, bkpt_remove_location, bkpt_breakpoint_hit)
(bkpt_check_status, bkpt_resources_needed)
(bkpt_works_in_software_mode, bkpt_print_it, bkpt_print_mention)
(bkpt_print_recreate): New functions.
(bkpt_breakpoint_ops): New global.
(tracepoint_re_set, tracepoint_insert_location)
(tracepoint_remove_location, tracepoint_breakpoint_hit)
(tracepoint_check_status, tracepoint_works_in_software_mode)
(tracepoint_print_it, tracepoint_print_one_detail)
(tracepoint_print_mention, tracepoint_print_recreate): New
functions.
(tracepoint_breakpoint_ops): New global.
(delete_breakpoint): Always call the breakpoint's dtor method, and
remove the default handling from here.
(breakpoint_re_set_default): Make static.
(breakpoint_re_set_one): Always call the breakpoints re_set
method, and remove the default handling from here.
(trace_command, ftrace_command, strace_command)
(create_tracepoint_from_upload): Pass appropriate breakpoints_ops
to create_breakpoint.
(save_breakpoints): Always call the breakpoint's print_recreate
method, and remove the default handling from here.
* ada-lang.c (dtor_exception): Call the base dtor.
(re_set_exception): Call the base method.
(print_it_exception, print_it_catch_exception): Adjust to take a
bpstat as argument.
(catch_exception_breakpoint_ops): Install methods.
(print_it_catch_exception_unhandled): Adjust to take a bpstat as
argument.
(catch_exception_unhandled_breakpoint_ops): Install methods.
(print_it_catch_assert): Adjust to take a bpstat as argument.
(catch_assert_breakpoint_ops): Install methods.
* breakpoint.h (struct breakpoint_ops): Adjust the print_it method
to take a bpstat as argument.
(enum print_stop_action): Add describing comments to each enum
value.
(breakpoint_re_set_default): Delete declaration.
(null_re_set, null_works_in_software_mode, null_resources_needed)
(null_check_status, null_print_one_detail): Declare.
(bkpt_breakpoint_ops): Declare.
(bkpt_dtor, bkpt_allocate_location, bkpt_re_set)
(bkpt_insert_location, bkpt_remove_location, bkpt_breakpoint_hit)
(bkpt_check_status, bkpt_resources_needed)
(bkpt_works_in_software_mode, bkpt_print_it)
(null_print_one_detail, bkpt_print_mention, bkpt_print_recreate):
Declare.
* mi/mi-cmd-break.c (mi_cmd_break_insert): Adjust to pass
bkpt_breakpoint_ops.
* python/py-breakpoint.c (bppy_init): Ditto.
Temporary catchpoints on Ada exceptions are now displayed as "Temporary
catchpoint" as opposed to just "Catchpoint". This is cosmetic only, but
in line with what's done for other catchpoints as well as breakpoints.
gdb/ChangeLog:
* ada-lang.c (print_it_exception): Print temporary catchpoints
as "Temporary catchpoint".
(print_mention_exception): Likewise.
gdb/testsuite/ChangeLog:
* gdb.ada/catch_ex.exp: Add temporary catchpoint tests.
This is to avoid an unnecessary multiple-choice menu for an
expression involving an enumeral declared in two types, when
the second type is an identical copy of the first type. This
happens in the following situation:
type Color is (Black, Red, Green, Blue, White);
type RGB_Color is new Color range Red .. Blue;
In that case, an implict type is created, and is used as the base
type for type RGB_Color. This base type is a copy of type Color.
We've added some extensive comments explaining the situation and
our approach further.
gdb/ChangeLog:
* ada-lang.c (ada_identical_enum_types_p): New function.
(symbols_are_identical_enums): New function.
(remove_extra_symbols): Do nothing if NSYMS < 2.
Use symbols_are_identical_enums.
gdb/testsuite/ChangeLog:
* gdb.ada/same_enum: New testcase.
If we declare a type as being an access to array type, and then
declare a variable of that type, for instance:
type Some_Array is array [...];
type Array_Access is access all Some_Array;
Table : Array_Access := [...];
The variable "Table" may be defined in the debugging information
as being a typedef to the array pointer type. In the past, it was
defined directly as the array pointer type, but this has been changed
to make sure that the typedef type gets used.
If the typedef type wasn't used, it would allow the compiler to stop
emitting that typedef type when compiling with
-feliminate-unused-debug-types. The removal of this typedef would
be a problem, because GDB relies on the typedef to create symbols
for pointer types, and without it, we would no longer be able to
do "ptype array_access".
This patch helps prevent incorrect output or even crashes when that
extra typedef layer is used.
The testing is already mostly covered by arrayptr.exp, but I still
added a 'ptype' test, just for good measure.
gdb/ChangeLog: (Eric Botcazou)
* ada-lang.c (thin_descriptor_type): Deal with typedefs.
(decode_constrained_packed_array): Likewise.
(ada_evaluate_subexp) <TERNOP_SLICE>: Likewise.
gdb/testsuite/ChangeLog (Joel Brobecker):
* gdb.ada/arrayptr.exp: Add ptype test.
* breakpoint.c (bpstat_stop_status): Call the check_status
breakpoint_ops method.
(print_one_breakpoint_location): Also print the condition for Ada
exception catchpoints.
(allocate_bp_location): New, factored out from
allocate_bp_location.
(allocate_bp_location): Adjust. Call the owner breakpoint's
allocate_location method, if there is one.
(free_bp_location): Call the locations's dtor method, if there is
one.
(init_raw_breakpoint_without_location): New breakpoint_ops
parameter. Use it.
(set_raw_breakpoint_without_location): Adjust.
(init_raw_breakpoint): New breakpoint_ops parameter. Pass it down.
(set_raw_breakpoint): Adjust.
(catch_fork_breakpoint_ops, catch_vfork_breakpoint_ops)
(catch_syscall_breakpoint_ops): Install NULL allocate_location,
re_set and check_status methods.
(init_catchpoint): Don't memset, initialize thread, addr_string
and enable_state. Pass the ops down to init_raw_breakpoint.
(install_catchpoint): Rename to ...
(install_breakpoint): ... this, and make extern.
(create_fork_vfork_event_catchpoint): Adjust.
(catch_exec_breakpoint_ops): Install NULL allocate_location,
re_set and check_status methods.
(create_syscall_event_catchpoint): Adjust.
(ranged_breakpoint_ops, watchpoint_breakpoint_ops)
(masked_watchpoint_breakpoint_ops): Install NULL
allocate_location, re_set and check_status methods.
(catch_exec_command_1): Adjust.
(gnu_v3_exception_catchpoint_ops): Install NULL allocate_location,
re_set and check_status methods.
(create_ada_exception_breakpoint): Rename to ...
(init_ada_exception_breakpoint): ... this. Add a struct
breakpoint parameter, and delete the exp_string, cond_string and
cond parameters. Use init_raw_breakpoint, and don't install or
mention the breakpoint yet. Don't clear breakpoint fields that
init_raw_breakpoint already clears.
(re_set_breakpoint): Delete, split into ...
(breakpoint_re_set_default, prepare_re_set_context): ... these new
functions.
(breakpoint_re_set_one): Call the breakpoint's
breakpoint_ops->re_set implementation, if there's one. Adjust.
* breakpoint.h: Forward declare struct bpstats and struct bp_location.
(struct bp_location_ops): New type.
(struct bp_location): New field `ops'.
(struct breakpoint_ops): New `allocate_location', `re_set' and
`check_status' fields. Make `breakpoint_hit''s description match
reality.
(init_bp_location): Declare.
(breakpoint_re_set_default): Declare.
(create_ada_exception_breakpoint): Rename to ...
(init_ada_exception_breakpoint): ... this. Add a struct
breakpoint parameter, and delete the exp_string, cond_string and
cond parameters.
(install_breakpoint): Declare.
* ada-lang.c: Include exceptions.h.
<Ada exceptions description>: Update.
(struct ada_catchpoint_location): New type.
(ada_catchpoint_location_dtor): New function.
(ada_catchpoint_location_ops): New global.
(ada_catchpoint): New type.
(create_excep_cond_exprs): New function.
(dtor_exception, allocate_location_exception, re_set_exception)
(should_stop_exception, check_status_exception): New functions.
(print_one_exception, print_mention_exception)
(print_recreate_exception): Adjust.
(dtor_catch_exception, allocate_location_catch_exception)
(re_set_catch_exception, check_status_catch_exception): New
functions.
(catch_exception_breakpoint_ops): Install them.
(dtor_catch_exception_unhandled)
(allocate_location_catch_exception_unhandled)
(re_set_catch_exception_unhandled)
(check_status_catch_exception_unhandled): New functions.
(catch_exception_unhandled_breakpoint_ops): Install them.
(dtor_catch_assert, allocate_location_catch_assert)
(re_set_catch_assert, check_status_catch_assert): New functions.
(catch_assert_breakpoint_ops): Install them.
(ada_exception_catchpoint_p): Delete.
(catch_ada_exception_command_split)
(ada_exception_catchpoint_cond_string): Rename exp_string
parameter to excep_string. Adjust.
(ada_parse_catchpoint_condition): Delete.
(ada_exception_sal): Rename the exp_string parameter to
excep_string. Delete the cond_string and cond parameters.
Adjust.
(ada_decode_exception_location): Rename the exp_string parameter
to excep_string. Delete the cond_string and cond parameters.
Adjust.
(create_ada_exception_catchpoint): New function.
(catch_ada_exception_command, ada_decode_assert_location)
(catch_assert_command): Adjust.
* ada-lang.h (ada_exception_catchpoint_p): Delete declaration.
* ada-lang.c: Include arch-utils.h.
(ada_decode_exception_location): Make static.
(catch_ada_exception_command): Moved here from breakpoint.c.
(ada_decode_assert_location): Make static.
(catch_assert_command): Moved here from breakpoint.c.
(_initialize_ada_lang): Install the exception and assert
catchpoint commands here.
* ada-lang.h (ada_decode_exception_location)
(ada_decode_assert_location): Delete declarations.
* breakpoint.c (CATCH_PERMANENT, CATCH_TEMPORARY): Moved to
breakpoint.h.
(create_ada_exception_breakpoint): Make extern.
(catch_ada_exception_command, catch_assert_command): Moved to
ada-lang.c.
(add_catch_command): Make extern.
(_initilize_breakpoint): Don't install the exception and assert
catchpoint commands here.
* breakpoint.h (CATCH_PERMANENT, CATCH_TEMPORARY): Moved from
breakpoint.c
(add_catch_command, create_ada_exception_breakpoint): Declare.
* breakpoint.h (struct breakpoint_ops): New field `dtor'.
(struct breakpoint): Delete field `syscalls_to_be_caught'.
* breakpoint.c (init_raw_breakpoint_without_location): Remove
reference to syscalls_to_be_caught.
(catch_fork_breakpoint_ops, catch_vfork_breakpoint_ops): Install a
NULL `dtor'.
(struct syscall_catchpoint): New type.
(dtor_catch_syscall): New function.
(insert_catch_syscall, remove_catch_syscall)
(breakpoint_hit_catch_syscall, print_one_catch_syscall)
(print_recreate_catch_syscall): Adjust.
(catch_syscall_breakpoint_ops): Install dtor_catch_syscall.
(catch_exec_breakpoint_ops): Install a NULL `dtor'.
(create_syscall_event_catchpoint): Adjust to use init_catchpoint.
(ranged_breakpoint_ops, watchpoint_breakpoint_ops)
(masked_watchpoint_breakpoint_ops)
(gnu_v3_exception_catchpoint_ops): Install a NULL `dtor'.
(delete_breakpoint): Call the `dtor' breakpoint_ops method, if
there is one. Remove references to syscalls_to_be_caught.
(catching_syscall_number): Adjust.
* ada-lang.c (catch_exception_breakpoint_ops)
(catch_exception_unhandled_breakpoint_ops)
(catch_assert_breakpoint_ops): Install a NULL `dtor'.
This is just a minor cleanup of an ARI violation. As this affects
code that is normally unreachable (you'd need a runtime where
the unit providing the exception hook has been compiled without
debugging information), I tested this manually by commenting out
the code just above, thus forcing this part of the code to be
exercised.
gdb/ChangeLog:
* ada-lang.c (print_it_exception): Avoid use of sprintf.
Tested on x86_64-linux.
Thiago Jung Bauermann <bauerman@br.ibm.com>
Implement support for PowerPC BookE masked watchpoints.
gdb/
* NEWS: Mention masked watchpoint support. Create "Changed commands"
section.
* breakpoint.h (struct breakpoint_ops) <works_in_software_mode>: New
method. Initialize to NULL in all existing breakpoint_ops instances.
(struct breakpoint) <hw_wp_mask>: New field.
* breakpoint.c (is_masked_watchpoint): Add prototype.
(update_watchpoint): Don't set b->val for masked watchpoints. Call
breakpoint's breakpoint_ops.works_in_software_mode if available.
(watchpoints_triggered): Handle the case of a hardware masked
watchpoint trigger.
(watchpoint_check): Likewise.
(works_in_software_mode_watchpoint): New function.
(insert_masked_watchpoint, remove_masked_watchpoint)
(resources_needed_masked_watchpoint)
(works_in_software_mode_masked_watchpoint, print_it_masked_watchpoint)
(print_one_detail_masked_watchpoint, print_mention_masked_watchpoint)
(print_recreate_masked_watchpoint, is_masked_watchpoint): New
functions.
(masked_watchpoint_breakpoint_ops): New structure.
(watch_command_1): Check for the existence of the `mask' parameter.
Set b->ops according to the type of hardware watchpoint being created.
* ppc-linux-nat.c (ppc_linux_insert_mask_watchpoint)
(ppc_linux_remove_mask_watchpoint)
(ppc_linux_masked_watch_num_registers): New functions.
(_initialize_ppc_linux_nat): Initialize to_insert_mask_watchpoint,
to_remove_mask_watchpoint and to_masked_watch_num_registers.
* target.c (update_current_target): Mention to_insert_mask_watchpoint,
to_remove_mask_watchpoint, and to_masked_watch_num_registers.
(target_insert_mask_watchpoint, target_remove_mask_watchpoint)
(target_masked_watch_num_registers): New functions.
* target.h (struct target_ops) <to_insert_mask_watchpoint>,
<to_remove_mask_watchpoint>, <to_masked_watch_num_registers>: New
methods.
(target_insert_mask_watchpoint, target_remove_mask_watchpoint)
(target_masked_watch_num_registers): Add prototypes.
gdb/doc/
* gdb.texinfo (Set Watchpoints): Document mask parameter.
(PowerPC Embedded): Mention support of masked watchpoints.
* ada-lang.c (struct add_partial_datum): Update the comment for
expand_partial_symbol_name.
(ada_add_partial_symbol_completions): Rename to ...
(ada_expand_partial_symbol_name): ... here, change return type, update
function comment, call symbol_completion_match instead of
symbol_completion_add.
(ada_make_symbol_completion_list): Use now expand_partial_symbol_names
and ada_expand_partial_symbol_name.
* dwarf2read.c (dw2_expand_symtabs_matching): Support NULL
FILE_MATCHER.
(dw2_map_symbol_names): Remove.
(dwarf2_gdb_index_functions): Unlist dw2_map_symbol_names.
* psymtab.c (map_symbol_names_psymtab): Remove.
(expand_symtabs_matching_via_partial): Support NULL FILE_MATCHER.
Support KIND == ALL_DOMAIN. Exchange the NAME_MATCHER and KIND check
order.
(psym_functions): Unlist map_symbol_names_psymtab.
(map_partial_symbol_names): Rename to ...
(expand_partial_symbol_names): ... here, change the FUN type, call
expand_symtabs_matching with ALL_DOMAIN and NULL FILE_MATCHER now.
* psymtab.h (map_partial_symbol_names): Rename to ...
(expand_partial_symbol_names): ... here, change the FUN type.
* symfile.h (struct quick_symbol_functions): Update the description of
expand_symtabs_matching. Remove map_symbol_names.
* symtab.c (search_symbols): Add ALL_DOMAIN to the function comment.
(struct add_name_data): Update the comment for
expand_partial_symbol_name.
(add_partial_symbol_name): Rename to ...
(expand_partial_symbol_name): ... here. Replace
completion_list_add_name call by strncmp.
(default_make_symbol_completion_list_break_on): Use now
expand_partial_symbol_names and expand_partial_symbol_name.
* symtab.h (enum search_domain): New element ALL_DOMAIN.
gdb/testsuite/
* gdb.cp/cpcompletion.exp (complete class methods)
(complete class methods beginning with F): Move them above runto. New
comment about the runto delimiter.
A change we are making in the compiler to help preserve useful
types when using -feliminate-unused-debug-types exposed a small
hole in our value-printing code.
One example of the problem happens when trying to print a slice
of an array pointer. If the variable is defined as a pointer to
the typedef of an array, then we fail to print the slice, like so:
(gdb) p arr_ptr(1..2)
cannot take slice of non-array
gdb/ChangeLog:
* ada-lang.c (ada_is_simple_array_type, ada_value_slice_from_ptr)
(ada_value_slice, empty_array, to_fixed_array_type): Deal with
typedefs.
This rewrites the code generating the Ada exception catchpoint hit
notification for both the GDB/MI case as well as the non-MI case,
by using the relevant ui_out_* functions to generate the output.
the MI notifications for Ada exception catchpoints now include
the stop reason, and the breakpoint "disp", much like other breakpoint
events do. It also introduces a new field "exception-name" for
exception catchpoints (excluding "failed assertion catchpoints,
where we just want to know that it was a failed assertion).
gdb/ChangeLog:
* breakpoint.h (bpdisp_text): Add declaration.
* breakpoint.c (bpdisp_text): Make non-static.
* ada-lang.c: #include "mi/mi-common.h".
(print_it_exception): Rewrite to improve GDB/MI output.
gdb/doc/ChangeLog:
* gdb.texinfo (GDB/MI Ada Exception Information): Document
the "exception-name" field in the *stopped async record.
gdb/testsuite/ChangeLog:
* gdb.ada/mi_catch_ex: New testcase.
Sergio Durigan Junior <sergiodj@linux.vnet.ibm.com>
Implement support for PowerPC BookE ranged breakpoints.
gdb/
* NEWS: Mention support for ranged breakpoints on embedded PowerPC.
* breakpoint.h (struct bp_target_info) <length>: New member
variable.
(struct breakpoint_ops) <breakpoint_hit>: Take struct bp_location
instead of struct breakpoint as argument, and also add ASPACE
and BP_ADDR arguments. Update all callers.
(struct breakpoint_ops) <print_one_detail>: New method.
(struct breakpoint) <addr_string_range_end>: New member variable.
* breakpoint.c (breakpoint_location_address_match): Add function
prototype.
(insert_bp_location): Set bl->target_info.length.
(breakpoint_here_p): Call breakpoint_location_address_match.
(moribund_breakpoint_here_p): Likewise.
(regular_breakpoint_inserted_here_p): Likewise.
(breakpoint_thread_match): Likewise.
(bpstat_stop_status): Likewise.
(bpstat_check_location): Move call to
breakpoint_ops.breakpoint_hit to the top.
(print_one_breakpoint_location): Call
breakpoint_ops.print_one_detail if available.
(breakpoint_address_match_range): New function.
(breakpoint_location_address_match): Likewise.
(breakpoint_locations_match): Compare the length field of the
locations too.
(hw_breakpoint_used_count): Count resources used by all locations
in a breakpoint, and use breakpoint_ops.resources_needed if
available.
(breakpoint_hit_ranged_breakpoint): New function.
(resources_needed_ranged_breakpoint): Likewise.
(print_it_ranged_breakpoint): Likewise.
(print_one_ranged_breakpoint): Likewise.
(print_one_detail_ranged_breakpoint): Likewise.
(print_mention_ranged_breakpoint): Likewise.
(print_recreate_ranged_breakpoint): Likewise.
(ranged_breakpoint_ops): New structure.
(find_breakpoint_range_end): New function.
(break_range_command): Likewise.
(delete_breakpoint): Free addr_string_range_end.
(update_breakpoint_locations): Add SALS_END argument. Update
all callers. Calculate breakpoint length if a non-zero SALS_END
is given. Call breakpoint_locations_match instead of
breakpoint_address_match.
(reset_breakpoint): Find SaL of the end of the range if B is a
ranged breakpoint.
(_initialize_breakpoint): Register break-range command.
* defs.h (print_core_address): Add function prototype.
* ppc-linux-nat.c (ppc_linux_ranged_break_num_registers): New
function.
(ppc_linux_insert_hw_breakpoint): Support ranged breakpoints.
(ppc_linux_remove_hw_breakpoint): Likewise.
(_initialize_ppc_linux_nat): Initialize
to_ranged_break_num_registers.
* target.c (update_current_target): Add comment about
to_ranged_break_num_registers.
(target_ranged_break_num_registers): New function.
* target.h (struct target_ops) <to_ranged_break_num_registers>:
New method.
(target_ranged_break_num_registers): Add function prototype.
* ui-out.c (ui_out_field_core_addr): Move address-printing logic to ...
* utils.c (print_core_address): ... here.
gdb/doc/
* gdb.texinfo (PowerPC Embedded): Document ranged breakpoints.
This is to make sure that we cannot have a field with an undefined
value (currently, we are not setting the gdbarch).
gdb/ChangeLog:
* ada-lang.c (replace_operator_with_call): Use xzalloc instead
of xmalloc.
When ada-lang transforms an array descriptor type (an XUP structure)
into an array type, the size of the array type is computed by using
the element size, and multiplying it by the number of elements in
that array. This does not work, however, for packed arrays, where
the *packed* size in bits needs to be used.
This usually does not cause any problem, because we end up reading
more memory than needed. However, we have observed on LynxOS
a memory error while trying to read the entire array, because
the larger-than-needed read tried to read past the end of the stack
into inaccessible memory.
This patch fixes the problem by correctly computing the array size
in bytes in the case of packed arrays.
gdb/ChangeLog:
* ada-lang.c (ada_type_of_array): Fix the size of the array
in the case of an unconstrained packed array.
gdb/testsuite/ChangeLog:
* gdb.ada/packed_array: Expand testcase to test printing of
unconstrained packed array.