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.
PR breakpoints/10738
* dwarf2read.c (use_deprecated_index_sections): New global.
(struct partial_die_info): New member may_be_inlined.
(read_partial_die): Set may_be_inlined where appropriate.
(add_partial_subprogram): Add partial symbols for partial
DIEs that may be inlined.
(new_symbol_full): Add inlined subroutines to the current
scope.
(write_psymtabs_to_index): Bump version number.
(dwarf2_read_index): Read only version 6 indices unless
use_deprecated_index_sections is set.
* linespec.c (symbol_and_data_callback): New structure.
(iterate_inline_only): New function.
(iterate_over_all_matching_symtabs): New argument
"include_inline". If nonzero, also call the callback for
symbols representing inlined subroutines.
(lookup_prefix_sym): Pass extra argument to the above.
(find_function_symbols): Likewise.
(add_matching_symbols_to_info): Likewise.
* NEWS: Mention that GDB can now set breakpoints on inlined
functions.
gdb/doc:
PR breakpoints/10738
* gdb.texinfo (Inline Functions): Remove the now-unnecessary @item
stating that GDB cannot set breakpoints on inlined functions.
(Mode Options): Document --use-deprecated-index-sections.
(Index Section Format): Document new index section version format.
gdb/testsuite:
PR breakpoints/10738
* gdb.opt/inline-break.exp: New file.
* gdb.opt/inline-break.c: Likewise.
* gdb.dwarf2/inline-break.exp: Likewise.
* gdb.dwarf2/inline-break.S: Likewise.
* gdb.base/annota1.exp: Cope with old .gdb_index warnings.
* gdb.base/async-shell.exp: Likewise.
* lib/mi-support.exp (library_loaded_re): Likewise.
(arm_register_g_packet_guesses): New function.
(arm_gdbarch_init): Don't force a target description with
registers when the executable is detected as M-profile. Instead
set gdbarch->tdep->is_m. Register `g' packet guesses.
(_initialize_arm_tdep): Initialize the new target description.
* features/arm-with-m-fpa-layout.xml: New description.
* features/arm-with-m-fpa-layout.c: New, generated.
When debugging on Windows with GDBserver, the debugger starts
failing after hitting a breakpoint. For instance:
(gdb) b foo
Breakpoint 1 at 0x40177e: file foo.adb, line 5.
(gdb) cont
Continuing.
Breakpoint 1, foo () at foo.adb:5
5 Put_Line ("Hello World."); -- STOP
(gdb) n
Program received signal SIGSEGV, Segmentation fault.
0x00401782 in foo () at foo.adb:5
5 Put_Line ("Hello World."); -- STOP
There are two issues:
1. While trying to re-insert a breakpoint that is still inserted
in memory, insert_bp_location wipes out the breakpoint location's
shadow_contents. As a consequence, we cannot restore the proper
instruction when removing the breakpoint anymore. That's why
the inferior's behavior changes when trying to resume after
the breakpoint was hit.
2. mem-break.c:default_memory_insert_breakpoint passes a breakpoint
location's shadow_contents as the buffer for a memory read.
This reveals a limitation of the various memory-read target
functions. This patch documents this limitation and adjust
the two calls that seem to hit that limitation.
gdb/ChangeLog:
* breakpoint.c (breakpoint_xfer_memory): Add assertion.
Update function description.
(insert_bp_location): Do not wipe bl->target_info out.
* mem-break.c: #include "gdb_string.h".
(default_memory_insert_breakpoint): Do not call target_read_memory
with a pointer to the breakpoint's shadow_contents buffer. Use
a local buffer instead.
* m32r-tdep.c (m32r_memory_insert_breakpoint): Ditto.
Fix double prompt of 'interpreter-exec mi'.
* mi/mi-interp.c (mi_execute_command_input_handler): New prototype.
(mi_interpreter_resume): use it.
(mi_execute_command_input_handler): New function.
* mi/mi-main.c (mi_execute_command): Move prompt printing to
mi_execute_command_input_handler.
gdb/testsuite/
* gdb.mi/mi2-prompt.exp: New file.
This patch fixes a problem when using gdb + gdbserver, and trying
to break on a function when one of the (enum) parameters is equal
to a certain value, and the size of that enum is 1 byte.
(gdb) break mixed.adb:15 if light = green
Breakpoint 2 at 0x402d5a: file mixed.adb, line 15.
(gdb) cont
Continuing.
[Inferior 1 (process 9742) exited normally]
The debugger should have stopped once when our function was call
with light set to green.
Here is what happens: Because we're using a recent GDBserver,
GDB hands off the evaluation of the condition to GDBserver, by
providing it in the Z0 packet. This is what GDB sends:
$Z0,402d5a,1;X13,26000622100223ff1c16100219162022011327#cf
I decoded the condition as follow:
260006 reg 6 -> push
2210 const8 0x10 -> push
02 add (stack now has 1 element equal to reg6 + 16)
23ff1c const16 0xff1c
1610 ext 16 (sign extend 16 bits)
02 add (stack now has 1 element equal to reg6 + 16 - 228)
19 ref32: Pop as addr, push 32bit value at addr.
1620 ext 32 (sign extend 32 bits)
2201 const8 0x01
13 equal
27 end
The beginning of the agent expression can be explained by the address
of symbol "light":
(gdb) info addr light
Symbol "light" is a variable at frame base reg $rbp offset 16+-228.
However, the mistake is the "ext 32" operation (extend 32 bits),
because our variable is *not* 32bits, only 8:
(gdb) print light'size
$5 = 8
But the reason why GDB decides to use a 32bit extension is because
it overrides the symbol's type with a plain integer type in
ax-gdb.c:gen_usual_unary...
/* If the value is an enum or a bool, call it an integer. */
case TYPE_CODE_ENUM:
case TYPE_CODE_BOOL:
value->type = builtin_type (exp->gdbarch)->builtin_int;
break;
... before calling require_rvalue. And of course, that causes the
generator to generate a sizeof(int) extension of the result.
One way to fix this would be to use an integer type of the correct
size, but I do not understand why this is necessary. The two routines
that use that information to generate the opcode down the line are
gen_fetch (for a memory value), or gen_extend (for a register value).
And they both have handling of enums and bools.
So the fix we elected to implement was simply to remove that code.
gdb/ChangeLog:
* ax-gdb.c (gen_usual_unary): Remove special handling of
enum and bool types.
This patch fixes an error that occurs with GDB + GDBserver when
trying to insert a breakpoint with a condition that involves
a range type. For instance:
type INT_T is range 0 .. 1000;
INT_VAR : INT_T := 12;
And then trying to insert the breakpoint:
(gdb) break foo.adb:18 if int_var > 15
Breakpoint 1 at 0x4021eb: file foo.adb, line 18.
(gdb) cont
Continuing.
/[...]/ax-gdb.c:560: internal-error: gen_fetch: bad type code
A problem internal to GDB has been detected,
further debugging may prove unreliable.
Quit this debugging session? (y or n)
This patch fixes the problem by adding handling for range types
in gen_fetch.
gdb/ChangeLog:
* ax-gdb.c (gen_fetch): Add handling for TYPE_CODE_RANGE types.
This is a minor cleanup that makes supply_fprs more consistent with
how fill_fprs was written.
gdb/ChangeLog:
* aix-thread.c (supply_fprs): Make more consistent with fill_fprs.
gdb/
2012-03-08 Chris January <chris.january@allinea.com>
* aix-thread.c (fill_sprs): Store the floating point registers
at the correct offsets into vals.
* common/linux-procfs.c (linux_proc_get_int): New, from
linux_proc_get_tgid, change its LWPID type to pid_t, add parameter
field.
(linux_proc_get_tgid): Only call linux_proc_get_int.
(linux_proc_get_tracerpid): New.
(linux_proc_pid_has_state): New, from linux_proc_pid_is_zombie.
(linux_proc_pid_is_stopped, linux_proc_pid_is_zombie): Only call
linux_proc_pid_has_state.
* common/linux-procfs.h (linux_proc_get_tracerpid): New declaration.
* common/linux-ptrace.c: Include linux-procfs.h and buffer.h.
(linux_ptrace_attach_warnings): New.
* common/linux-ptrace.h (struct buffer, linux_ptrace_attach_warnings):
New declaration.
* linux-nat.c: Include exceptions.h, linux-ptrace.h and buffer.h.
(linux_nat_attach): New variables ex, buffer, message and message_s.
Wrap to_attach by TRY_CATCH and call linux_ptrace_attach_warnings.
gdb/gdbserver/
* linux-low.c (linux_attach_lwp_1): New variable buffer. Call
linux_ptrace_attach_warnings.
gdb/testsuite/
* gdb.base/attach-twice.c: New files.
* gdb.base/attach-twice.exp: New files.
Hui Zhu <teawater@gmail.com>
Yao Qi <yao@codesourcery.com>
* remote.c (struct remote_state): New field `starting_up'.
(remote_start_remote): Set and clear it.
(remote_can_download_tracepoint): If starting up, return false.
