This patch enhances the linespec parser to recognize unqualified
operator names in linespecs. This allows the user to insert a breakpoint
on operator "+" as follow, for instance:
(gdb) break "+"
Previously, it was possible to insert such a breakpoint, but one
had to fully qualify the function name. For instance:
(gdb) break ops."+"
gdb/ChangeLog:
* linespec.c (locate_first_half): Add handling of Ada operators
when the current language is Ada.
This fixes a problem where the debugger is trying to locate a minimal
symbol from its address, when the symbol is inside a section whose
VMA is different from its LMA.
We have a program that was built on ppc-elf using a linker script
such that data sections are placed in ROM, and then loaded onto RAM
at execution. So their VMA addresses are indeed different from
their LMA address.
Unfortunately, there is one place where GDB gets slightly confused
into thinking that these data sections are overlayed, while it's
not the case here. This show up when trying to print the list of
Ada tasks, where GDB is unable to determine their names, and thus
prints a generic `Ravenscar task' instead:
(gdb) info tasks
ID TID P-ID Pri State Name
1 1d580 127 Delay Sleep Ravenscar task
2 183f8 127 Delay Sleep Ravenscar task
* 3 13268 127 Runnable Ravenscar task
We expected:
(gdb) info tasks
ID TID P-ID Pri State Name
1 1d580 127 Delay Sleep environment_task
2 183f8 127 Delay Sleep raven2
* 3 13268 127 Runnable raven1
The name of the task is determined by looking up the symbol table
using the task ID, which is the address where the symbol is defined.
So, ada-tasks calls...
msym = lookup_minimal_symbol_by_pc (task_id);
... which in turn first tries to determine the section associated
to this address (find_pc_section), which itself uses a map of sections
to find it. The map itself is recomputed every time objfiles are
loaded/changed by `update_section_map'. And `update_section_map'
relies on `insert_section_p' to determine whether the section should
be inserted in the map or not.
This is where things get interesting for us, because `insert_section_p'
simply rejects overlay sections:
if (lma != 0 && lma != bfd_section_vma (abfd, section)
&& (bfd_get_file_flags (abfd) & BFD_IN_MEMORY) == 0)
/* This is an overlay section. IN_MEMORY check is needed to avoid
discarding sections from the "system supplied DSO" (aka vdso)
on some Linux systems (e.g. Fedora 11). */
return 0;
However, it shouldn't reject our section in this case, since overlay
debugging is off. The fix is to add a check that overlay debugging
is active before rejecting the section. This is similar to what is
done in `section_is_overlay' (which takes obj_section objects), for
instance.
gdb/Changelog:
* objfiles.c (insert_section_p): Do not detect overlay sections
if overlay debugging is off.
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.
Jan Kratochvil <jan.kratochvil@redhat.com>
* linux-nat.c (add_lwp): Don't call linux_nat_new_thread on the
first LWP.
* amd64-linux-nat.c (update_debug_registers_callback): Instantiate
`lwp->arch_private' if NULL.
(amd64_linux_prepare_to_resume): Do nothing if `lwp->arch_private'
is NULL.
* i386-linux-nat.c (update_debug_registers_callback): Instantiate
`lwp->arch_private' if NULL.
(i386_linux_prepare_to_resume): Do nothing if `lwp->arch_private'
is NULL.
* symfile.c (reread_symbols): Move free_objfile_separate_debug,
preserve_values, sym_finish and clear_objfile_data calls before BFD
close. Move free_objfile_separate_debug as the very first call. New
comment on the ordering.
gdb/testsuite/
* gdb.base/reread.exp: If srcfile2 fails to build retry it with
-DNO_SECTIONS.
* gdb.base/reread2.c <!NO_SECTIONS>: New sections block.
Comment says it all:
/* On ia64-hpux, we have discovered that the system linker
adds undefined symbols with nonzero addresses that cannot
be right (their address points inside the code of another
function in the .text section). This creates problems
when trying to determine which symbol corresponds to
a given address.
We try to detect those buggy symbols by checking which
section we think they correspond to. Normally, PLT symbols
are stored inside their own section, and the typical name
for that section is ".plt". So, if there is a ".plt"
section, and yet the section name of our symbol does not
start with ".plt", we ignore that symbol. */
gdb/ChangeLog:
* elfread.c (elf_symtab_read): Ignore undefined symbols with
nonzero addresses if they do not correspond to a .plt section
when one is available in the objfile.
regset_from_core_section.
(amd64obsd_core_init_abi): New function that sets
regset_from_core_section.
(_initialize_amd64obsd_tdep): Use amd64obsd_core_init_abi for
traditional core dumps.
(last_message): Delete.
(exception_messages, exception_messages_size): New static globals.
(throw_it): Use exception_messages array to handle nested calls.
* utils.c: #include "gdb_wait.h".
(sigalrm_handler, wait_to_die_with_timeout): New functions.
* ser-pipe.c: Don't #include "gdb_wait.h".
(pipe_close): Give child a chance to die on its own after closing
its stdin before SIGTERM'ing it.
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.
* ia64-tdep.c (ia64_memory_remove_breakpoint): Use
target_write_raw_memory.
* m32r-tdep.c (m32r_memory_remove_breakpoint): Use
target_write_raw_memory.
* microblaze-linux-tdep.c
(microblaze_linux_memory_remove_breakpoint): Use
target_write_raw_memory.
* ppc-linux-tdep.c (ppc_linux_memory_remove_breakpoint): Use
target_write_raw_memory.
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.
