Age | Commit message (Collapse) | Author | Files | Lines |
|
gdb/testsuite/ChangeLog:
2017-12-12 Stafford Horne <shorne@gmail.com>
* gdb.xml/tdesc-regs.exp: Add or1k support.
|
|
The test case requires adding a nop instruction. For or1k the
instruction is `l.nop`. This change uses the correct operation.
gdb/testsuite/ChangeLog:
2017-12-12 Stafford Horne <shorne@gmail.com>
* gdb.base/bp-permanent.c: Define nop of or1k.
|
|
This patch prepares the current GDB port of the OpenRISC processor from
https://github.com/openrisc/binutils-gdb for upstream merging.
Testing has been done with a cgen sim provided in a separate patch. This
has been tested with 2 toolchains. GCC [1] 5.4.0 from the OpenRISC
project with Newlib [2] and GCC 5.4.0 with Musl [3] 1.1.4.
It supports or1knd (no delay slot target).
The default target is or1k (with delay slot).
You can change the target arch with:
(gdb) set architecture or1knd
The target architecture is assumed to be or1knd
[1] https://github.com/openrisc/or1k-gcc
[2] https://github.com/openrisc/newlib
[3] https://github.com/openrisc/musl-cross
gdb/doc/ChangeLog:
2017-12-12 Stafford Horne <shorne@gmail.com>
Stefan Wallentowitz <stefan@wallentowitz.de>
Franck Jullien <franck.jullien@gmail.com>
Jeremy Bennett <jeremy.bennett@embecosm.com>
* gdb.texinfo: Add OpenRISC documentation.
gdb/ChangeLog:
2017-12-12 Stafford Horne <shorne@gmail.com>
Stefan Wallentowitz <stefan@wallentowitz.de>
Stefan Kristiansson <stefan.kristiansson@saunalahti.fi>
Franck Jullien <franck.jullien@gmail.com>
Jeremy Bennett <jeremy.bennett@embecosm.com>
* configure.tgt: Add targets for or1k and or1knd.
* or1k-tdep.c: New file.
* or1k-tdep.h: New file.
* features/Makefile: Add or1k.xml to build.
* features/or1k.xml: New file.
* features/or1k-core.xml: New file.
* features/or1k.c: Generated.
|
|
The TOC pointer register, r2, on powerpc64 is generally not mentioned
in debug info. It is saved and restored by call linkage code, and
set to the callee value either by call stub code (ELFv1) or in the
callee global entry point code (ELFv2). A call stub uses the caller
TOC pointer to access the PLT. So for gdb to read the correct PLT
entry in order to determine the destination of the trampoline, gdb
needs to know the caller r2. When skipping over trampolines in the
normal forward direction, the caller r2 is simply the current value of
r2 (at the start of the trampoline). However, when reversing over
trampolines the current value of r2 is that for the callee. Using
that value results in wild reads of memory rather than the correct PLT
entry.
This patch corrects the value of r2 by using the value saved on the
stack for reverse execution. Note that in reverse execution mode it
isn't really necessary for skip_trampoline_code to return the actual
destination, so we're doing a little more work than needed here. Any
non-zero return value would do (and it would be nicer if the interface
was changed to return the start of the stub).
PR tdep/22576
* ppc64-tdep.c (ppc64_plt_entry_point): Rewrite to take TOC-relative
PLT offset, and retrieve r2 from stack when executing in reverse.
(ppc64_standard_linkage1_target): Drop pc param. Calculate offset
rather than PLT address.
(ppc64_standard_linkage2_target): Likewise.
(ppc64_standard_linkage3_target): Likewise.
(ppc64_standard_linkage4_target): Likewise.
(ppc64_skip_trampoline_code_1): Adjust to suit.
|
|
Commit
remote: C++ify thread_item and threads_listing_context
21fe1c752e254167d953fa8c846280f63a3a5290
broke the test gdb.threads/names.exp. The problem is that since we now
use an std::string to hold the extra_info, an empty string is returned
by target_extra_thread_info to print_thread_info_1 when the remote stub
didn't send any extra info, instead of NULL before. Because of that,
print_thread_info_1 prints the extra info between parentheses, which
results in some spurious empty parentheses.
Expected: * 1 Thread 22752.22752 "main" all_threads_ready () at ...
Actual : * 1 Thread 22752.22752 "main" () all_threads_ready () a ...
Since the bug was introduced by a behavior change in the remote target,
I chose to fix it on the remote target side by making it return NULL
when the extra string is empty. This will avoid possibly changing the
behavior of the common code and affecting other targets.
The name field has the same problem. If a remote stub returns no thread
names, remote_thread_name will return an empty string instead of NULL,
so print_thread_info_1 will show empty quotes ("") instead of nothing.
gdb/ChangeLog:
PR gdb/22556
* remote.c (remote_thread_name): Return NULL if name is empty.
(remote_threads_extra_info): Return NULL if extra info is empty.
|
|
As reported at
<https://sourceware.org/ml/gdb-patches/2017-12/msg00229.html>, this
commit:
~~~~
commit abccd1e7b7a37385159610ca4e0bc2632a547e9a
Author: Jan Kratochvil <jan.kratochvil@redhat.com>
AuthorDate: Fri Dec 8 22:44:11 2017 +0000
Change dwarf2_initialize_objfile's return value
dwarf2_initialize_objfile was returning boolean whether it is psymtabs
or .gdb_index while now it needs to return also whether it is
.debug_names.
~~~~
breaks non-ELF-target builds:
dwarf2read.o: In function `dwarf2_initialize_objfile(objfile*)':
/home/yao.qi/SourceCode/gnu/binutils-gdb/gdb/dwarf2read.c:6486:
undefined reference to `elf_sym_fns_gdb_index'
/home/yao.qi/SourceCode/gnu/binutils-gdb/gdb/dwarf2read.c:6490:
undefined reference to `elf_sym_fns_debug_names'
/home/yao.qi/SourceCode/gnu/binutils-gdb/gdb/dwarf2read.c:6495:
undefined reference to `elf_sym_fns_lazy_psyms'
collect2: error: ld returned 1 exit status
Makefile:1920: recipe for target 'gdb' failed
because gdb/elfread.c is not included in the gdb build unless bfd also
includes elf support.
Fix this by reverting the patch mentioned above and at the same time
re-adding .debug_names support by adding a new output parameter to
dwarf2_initialize_objfile to indicate the index variant in use. We
can reuse the new dw_index_kind enum in dwarf2read.c for that.
gdb/ChangeLog:
2017-12-11 Pedro Alves <palves@redhat.com>
* defs.h (elf_sym_fns_lazy_psyms, elf_sym_fns_gdb_index)
(elf_sym_fns_debug_names): Move to elfread.c.
* dwarf2read.c (dwarf2_initialize_objfile): Return a boolean
instead of a sym_fns and add 'index_kind' output parameter. Fill
the latter in with the index variant kind if using an index.
(enum dw_index_kind): Moved to symfile.h.
* elfread.c (elf_sym_fns_gdb_index, elf_sym_fns_debug_names)
(elf_sym_fns_lazy_psyms): Move from defs.h.
(elf_symfile_read): Adjust to new dwarf2_initialize_objfile
interface.
* symfile.h (enum class dw_index_kind): New, moved from
dwarf2read.c.
(dwarf2_initialize_objfile): Change prototype.
|
|
When converting parts of the mantissa to MPFR, we need to make sure to do
an *unsigned* conversion. Since we convert at most 32 bits at a time,
stored in an unsigned long, this doesn't matter on systems where "long"
is larger than 32 bits. But on systems where it is 32 bits, we can get
conversion errors.
gdb/ChangeLog
2017-12-11 Ulrich Weigand <uweigand@de.ibm.com>
* target-float.c (mpfr_float_ops::from_target): Use mpfr_set_ui
instead of mpfr_set_si to convert mantissa bits.
|
|
Recent versions of GNAT are capable of reordering record components
to make their access for efficient. This patch adapts this test to
accept both cases (reordered or not).
gdb/testsuite/ChangeLog:
* gdb.ada/variant_record_packed_array.exp: Adapt test to accept
output with components being reordered.
Tested on x86_64-linux.
|
|
There was a difference between C++ dispatch table and Ada's in the
way the Offset_To_Top field is used to determined the base address
of an object:
* in C++ it is a negative offset, so converting abstract interface to
deriving object requires adding this offset to “this”;
* in Ada, it was a positive offset, so the same conversion required
subtracting the offset value.
So in ada, the base address for a tagged type was computed using this formula:
base_address = value_address (obj) - offset_to_top;
The offset_to_top value was previously set to 0 or a positive value.
With recent version of AdaCore's GNAT compiler, the offset has been
changed to match C++, which means it's set to zero or a negative value
As a result, the new formula has to be:
base_address = value_address (obj) + offset_to_top;
Because we want to support old code compiled before GNAT compiler change
done in 19.0w (20171023-64) with this version and future versions of gdb,
then we change the sign of the offset_to_top if required. Required here
means if offset_to_top is positive since it indicates that the code has
been compiled with an old GNAT compiler.
This patch changes the formula as described above.
Also, one side-effect of offset_to_top now being negative is that
we now have to worry about the sign when we read its value from the
inferior. Up to now, we have been reading its value using the data
address builtin type. But since addresses are not always signed, we
now need to make sure we use the proper type (type Storage_Offset
from System.Storage_Elements). Ideally, we would be looking this type
up from the inferior, and then use that type. However, it is not
guaranteed that this type always be described in the debugging
information, so this patch just builds our own, adding it to Ada's
list of primitive types.
gdb/ChangeLog:
* ada-lang.c (ada_tag_value_at_base_address): Change the way
tagged type base address is computed.
(enum ada_primitive_types) <ada_primitive_type_storage_offset>:
New enumerate.
(ada_language_arch_info): Set the ada_primitive_type_storage_offset
element of lai->primitive_type_vector.
Tested on x86_64-linux. Fixes the following tests when using the newer
version of the compiler.
gdb.ada/iwide.exp: print My_Drawable
gdb.ada/iwide.exp: print d_access.all
gdb.ada/iwide.exp: print dp_access.all
gdb.ada/mi_interface.exp: create ggg1 varobj (unexpected output)
gdb.ada/mi_interface.exp: list ggg1's children (unexpected output)
gdb.mi/mi-var-rtti.exp: run to mi-var-rtti.cc:63 (set breakpoint) (unexpected output)
gdb.mi/mi-var-rtti.exp: run to mi-var-rtti.cc:63 (set breakpoint)
|
|
Recent versions of GNAT are capable of reordering record components
to make their access for efficient. This patch adapts this test to
accept both cases (reordered or not).
gdb/testsuite/ChangeLog:
* gdb.ada/pkd_arr_elem.exp: Adapt "print test" test to accept
output with components being reordered.
|
|
Now that dw2_expand_symtabs_matching_symbol works with the abstract
mapped_index_base, we can make mock_mapped_index inherit
mapped_index_base too instead of having it pretend to be a real
.gdb_index table.
gdb/ChangeLog:
2017-12-08 Pedro Alves <palves@redhat.com>
* dwarf2read.c (mock_mapped_index): Reimplement as an extension of
mapped_index_base.
(check_match): Adjust to use mock_index directly.
(check_find_bounds_finds)
(test_mapped_index_find_name_component_bounds): Adjust to work
with a mapped_index_base.
|
|
dw2_debug_names_expand_symtabs_matching currently doesn't support
symbol_name_match_type::WILD, it always matches symbol names fully.
The .gdb_index code supports via dw2_expand_symtabs_matching_symbol,
which builds the mapped_index::name_components table on demand, and
then binary searches that table.
The .debug_names names index is pretty much the same as the .gdb_index
names index, i.e., a list of fully-qualified names with no
parameter/overload info. (There's no
what-is-the-language-of-symbol-name info in .debug_names either,
unfortunately.)
So this fixes .debug_names by factoring out the related .gdb_index
code out of the mapped_index class to a base class that is inherited
by both the .gdb_index (mapped_index) and .debug_names
(mapped_debug_names) map classes.
gdb/ChangeLog:
2017-12-08 Pedro Alves <palves@redhat.com>
* dwarf2read.c (struct mapped_index_base): New, partially factored
out from ...
(struct mapped_index): ... this. Inherit mapped_index_base.
(mapped_index::symbol_name_slot_invalid):
(mapped_index::symbol_name_at): Add override marker.
(mapped_index::symbol_name_count): New.
(struct mapped_debug_names): Inherit mapped_index_base.
(mapped_debug_names::symbol_name_at): New.
(mapped_debug_names::symbol_name_count): New.
(mapped_index::find_name_components_bounds): Rename to ...
(mapped_index_base::find_name_components_bounds): ... this.
(mapped_index::build_name_components): Rename to ...
(mapped_index_base::build_name_components): ... this. Adjust to
use mapped_index_base::symbol_name_count and
mapped_index_base::symbol_name_slot_invalid.
(dw2_expand_symtabs_matching_symbol): Take a mapped_index_base
instead of a mapped_index. Use
dw2_expand_symtabs_matching_symbol.
|
|
This replaces a couple ptr+size pairs with gdb::array_view in the
.gdb_index code, and simplifies things by using an aggregate for the
type of the symbol table hash bucket instead of having to consider the
distinction between size of table vs number of slots and access name
vs vec by index.
gdb/ChangeLog:
2017-12-08 Pedro Alves <palves@redhat.com>
* dwarf2read.c (mapped_index::symbol_table_slot): New.
(mapped_index::address_table): Now a gdb::array_view of const
gdb_byte.
(mapped_index::symbol_table): Now a gdb::array_view of
symbol_table_slot.
(mapped_index::address_table_size)
(mapped_index::symbol_table_slots): Delete.
(create_addrmap_from_index): Adjust.
(find_slot_in_mapped_hash): Adjust.
(read_index_from_section): Adjust.
(dwarf2_read_index): Adjust.
|
|
Some testcases needed to be updated as they were missing
.debug_aranges. While that does not matter for no-index (as GDB
builds the mapping internally during dwarf2_build_psymtabs_hard) and
neither for .gdb_index (as GDB uses that internally built mapping
which it stores into .gdb_index) it does matter for .debug_names as
that simply assumes existing .debug_aranges from GCC.
gdb/ChangeLog:
2017-12-08 Jan Kratochvil <jan.kratochvil@redhat.com>
Pedro Alves <palves@redhat.com>
* defs.h (elf_sym_fns_debug_names): New declaration.
* dwarf2read.c: Include "hash_enum.h".
(mapped_debug_names): New.
(struct dwarf2_per_objfile): Add debug_names, debug_aranges and
debug_names_table.
(dwarf2_elf_names): Add ".debug_names" and ".debug_aranges".
(struct dwz_file): Add debug_names.
(dwarf2_per_objfile::locate_sections): Handle debug_names and
debug_aranges.
(locate_dwz_sections): Handle debug_names.
(create_signatured_type_table_from_debug_names)
(create_addrmap_from_aranges): New.
(dwarf2_read_index): Update function comment.
(dwarf5_augmentation): Moved up.
(read_debug_names_from_section, create_cus_from_debug_names_list)
(create_cus_from_debug_names, dwarf2_read_debug_names): New.
(dwarf5_djb_hash): Moved up.
(dw2_debug_names_iterator): New.
(read_indirect_string_at_offset): New declaration.
(mapped_debug_names::namei_to_name)
(dw2_debug_names_iterator::find_vec_in_debug_names)
(dw2_debug_names_iterator::next, dw2_debug_names_lookup_symbol)
(dw2_debug_names_dump, dw2_debug_names_expand_symtabs_for_function)
(dw2_debug_names_expand_symtabs_matching, dwarf2_debug_names_functions):
New.
(dwarf2_initialize_objfile): Return also elf_sym_fns_debug_names.
(debug_names::djb_hash): Rename it to dwarf5_djb_hash.
(debug_names::build): Update djb_hash caller.
(write_debug_names): Move out and rename augmentation to
dwarf5_augmentation.
* elfread.c (elf_sym_fns_debug_names): New.
* psymtab.h (dwarf2_debug_names_functions): New declaration.
* symfile.h (struct dwarf2_debug_sections): Add debug_names and
debug_aranges.
* xcoffread.c (dwarf2_xcoff_names): Add debug_names and debug_aranges.
gdb/testsuite/ChangeLog:
2017-12-08 Jan Kratochvil <jan.kratochvil@redhat.com>
Pedro Alves <palves@redhat.com>
* gdb.base/maint.exp (check for .gdb_index): Check also for
.debug_names.
* gdb.dlang/watch-loc.c (.debug_aranges): New.
* gdb.dwarf2/dw2-case-insensitive-debug.S: Likewise.
* gdb.dwarf2/gdb-index.exp (check if index present, .gdb_index used)
(.gdb_index used after symbol reloading): Support also .debug_names.
* gdb.mi/dw2-ref-missing-frame-func.c (.debug_aranges): New.
|
|
The DWARF-5 .debug_names consumer patch will want to use an
std::unordered_map with an enum as key type, like:
std::unordered_map<sect_offset, dwarf2_per_cu_data*>
That doesn't work in C++11 in non-recent compilers due to a language
defect:
http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#2148
~~~
In file included from /usr/include/c++/5.3.1/bits/hashtable.h:35:0,
from /usr/include/c++/5.3.1/unordered_set:47,
from src/gdb/dwarf2read.c:79:
/usr/include/c++/5.3.1/bits/hashtable_policy.h: In instantiation of ‘struct std::__detail::__is_noexcept_hash<sect_offset, std::hash<sect_offset> >’:
/usr/include/c++/5.3.1/type_traits:137:12: required from ‘struct std::__and_<std::__is_fast_hash<std::hash<sect_offset> >, std::__detail::__is_noexcept_hash<sect_offset, std::hash<sect_offset> > >’
/usr/include/c++/5.3.1/type_traits:148:38: required from ‘struct std::__not_<std::__and_<std::__is_fast_hash<std::hash<sect_offset> >, std::__detail::__is_noexcept_hash<sect_offset, std::hash<sect_offset> > > >’
/usr/include/c++/5.3.1/bits/unordered_map.h:100:66: required from ‘class std::unordered_map<sect_offset, dwarf2_per_cu_data*>’
src/gdb/dwarf2read.c:3260:30: required from here
/usr/include/c++/5.3.1/bits/hashtable_policy.h:85:34: error: no match for call to ‘(const std::hash<sect_offset>) (const sect_offset&)’
noexcept(declval<const _Hash&>()(declval<const _Key&>()))>
^
In file included from /usr/include/c++/5.3.1/bits/move.h:57:0,
from /usr/include/c++/5.3.1/bits/stl_pair.h:59,
from /usr/include/c++/5.3.1/bits/stl_algobase.h:64,
from /usr/include/c++/5.3.1/bits/char_traits.h:39,
from /usr/include/c++/5.3.1/string:40,
from /home/pedro/gdb/mygit/src/gdb/common/common-utils.h:23,
from /home/pedro/gdb/mygit/src/gdb/common/common-defs.h:78,
from /home/pedro/gdb/mygit/src/gdb/defs.h:28,
from /home/pedro/gdb/mygit/src/gdb/dwarf2read.c:31:
~~~
This commits adds a helper replacement.
gdb/ChangeLog:
2017-12-08 Pedro Alves <palves@redhat.com>
* common/hash_enum.h: New file.
|
|
Preparation for the next patch.
gdb/ChangeLog
2017-12-08 Jan Kratochvil <jan.kratochvil@redhat.com>
* dwarf2read.c (create_cu_from_index_list): New from ...
(create_cus_from_index_list): ... this function, use it.
(dw_expand_symtabs_matching_file_matcher)
(dw2_expand_symtabs_matching_one): New from ...
(dw2_expand_symtabs_matching): ... this function, use them.
|
|
dwarf2_initialize_objfile was returning boolean whether it is psymtabs
or .gdb_index while now it needs to return also whether it is
.debug_names.
gdb/ChangeLog
2017-12-08 Jan Kratochvil <jan.kratochvil@redhat.com>
* defs.h (elf_sym_fns_lazy_psyms, elf_sym_fns_gdb_index): Move here
declarations from elfread.c.
(dwarf2_initialize_objfile): Change return value.
* elfread.c (elf_sym_fns_lazy_psyms, elf_sym_fns_gdb_index): Move these
declarations to defs.h.
(elf_symfile_read): Adjust dwarf2_initialize_objfile caller.
* symfile.h (dwarf2_initialize_objfile): Change return type.
|
|
This adds a new "-dwarf-5" switch to "save gdb-index" that makes it
generate index files with DWARF-5 .debug_names/.debug_str sections
instead of GDB's own .gdb_index.
We should probably add a command line option to
contrib/gdb-add-index.sh (incl. cc-with-tweaks.sh) for the new
-dwarf-5 GDB option, and a new target board to make it more convenient
to exercise this. To be done later.
gdb/ChangeLog
2017-12-08 Jan Kratochvil <jan.kratochvil@redhat.com>
Pedro Alves <palves@redhat.com>
* contrib/gdb-add-index.sh (index): Rename to ...
(index4): ... here.
(index5, debugstr, debugstrmerge, debugstrerr): New variables.
Support also .debug_names and .debug_str.
* dwarf2read.c: Include cmath, set, list.
(INDEX_SUFFIX): Rename to ...
(INDEX4_SUFFIX): ... here.
(INDEX5_SUFFIX, DEBUG_STR_SUFFIX): New.
(file_write(FILE *, const void *, size_t)): New.
(file_write(FILE *, const std::vector<Elem, Alloc> &)): New.
(data_buf::append_unsigned_leb128, data_buf::empty): New.
(data_buf::file_write): Use ::file_write.
(data_buf::c_str, dwarf5_djb_hash, debug_names)
(check_dwarf64_offsets): New.
(psyms_seen_size, write_gdbindex): New from
write_psymtabs_to_index code.
(dwarf5_gdb_augmentation, write_debug_names, assert_file_size)
(enum dw_index_kind): New.
(write_psymtabs_to_index): New parameter index_kind. Support
filename_str and out_file_str. Move code to write_gdbindex,
possibly call write_debug_names.
(save_gdb_index_command): New parameter -dwarf-5.
(_initialize_dwarf2_read): Document the new parameter -dwarf-5.
gdb/doc/ChangeLog
2017-12-08 Jan Kratochvil <jan.kratochvil@redhat.com>
* gdb.texinfo (Index Files): Document .debug_names and -dwarf-5.
--
gdb/contrib/gdb-add-index.sh | 53 ++
gdb/doc/gdb.texinfo | 24 +
gdb/dwarf2read.c | 919 ++++++++++++++++++++++++++++++++++++++++--
3 files changed, 935 insertions(+), 61 deletions(-)
|
|
With DWARF-5 .debug_names, the commands to add the index to the symbol
file are more complicated, as now also .debug_str needs to be
modified.
Currently, contrib/cc-with-tweaks.sh calls objcopy to handle the '-i'
option instead of using contrib/gdb-add-index.sh which basically does
the same. To help with .debug_names, this commit makes
contrib/cc-with-tweaks.sh reuse contrib/gdb-add-index.sh instead.
A problem this ran into is whether contrib/cc-with-tweaks.sh should
fail or not when no index is produced.
Currently, contrib/cc-with-tweaks.sh is more quiet (=successful) than
contrib/gdb-add-index.sh and so with no further changes testsuite runs
with an index would "regress". This commit tries to keep the behavior
unchanged. Some cases still error with:
Ada is not currently supported by the index
But some cases (such as some trivial gdb.dwarf2/ testcases with no DWARF data
to index) produce no index while the testcases still PASS now instead of:
-PASS: gdb.arch/i386-bp_permanent.exp: stack pointer value matches
+gdb compile failed, gdb-add-index.sh: No index was created for gdb/testsuite.unix.-m64/outputs/gdb.arch/i386-bp_permanent/i386-bp_permanent
+gdb-add-index.sh: [Was there no debuginfo? Was there already an index?]
+UNTESTED: gdb.arch/i386-bp_permanent.exp: failed to compile
gdb/ChangeLog
2017-12-08 Jan Kratochvil <jan.kratochvil@redhat.com>
Pedro Alves <palves@redhat.com>
* contrib/cc-with-tweaks.sh: Change interpreter to bash, incl. initial
comment.
(GDB_ADD_INDEX): New variable.
<$want_index>: Call $GDB_ADD_INDEX.
|
|
While investigating PR gdb/22557 ("Regression:
gdb.base/dtrace-probe.exp"), I noticed that the code is wrongly
declaring a new "expression_up" variable inside the TRY block in
"dtrace_process_dof_probe". This causes the outter "expr" variable to
be empty, which may have an impact later when evaluating the
expression.
This commit fixes that. Unfortunately the script used to test DTrace
probes (gdb/testsuite/lib/pdtrace.in) is not very reliable so I cannot
say whether this commit fixes the PR mentioned above. Nonetheless,
it's an obvious fix and should go in.
gdb/ChangeLog:
2017-12-08 Sergio Durigan Junior <sergiodj@redhat.com>
* dtrace-probe.c (dtrace_process_dof_probe): Do not declare a new
"expression_up" inside the TRY block.
|
|
Nowadays, GDB can't set watchpoint on tagged address on AArch64,
(gdb) p p2
$1 = (int *) 0xf000fffffffff474
(gdb) watch *((int *) 0xf000fffffffff474)
Hardware watchpoint 2: *((int *) 0xf000fffffffff474)
(gdb) c
Continuing.
main () at
binutils-gdb/gdb/testsuite/gdb.arch/aarch64-tagged-pointer.c:45
45 void (*func_ptr) (void) = foo;
Unexpected error setting hardware debug registers
This patch is about setting watchpoint on a tagged address. Unlike
breakpoint, watchpoint record the expression rather than the address, and
when a watchpoint is fired, GDB checks the expression value changed
instead of matching address, so we can mask the watchpoint address by
getting rid of non-significant bits of address.
gdb:
2017-12-08 Yao Qi <yao.qi@linaro.org>
* breakpoint.c (update_watchpoint): Call
address_significant.
gdb/testsuite:
2017-12-08 Yao Qi <yao.qi@linaro.org>
* gdb.arch/aarch64-tagged-pointer.c (main): Update.
* gdb.arch/aarch64-tagged-pointer.exp: Add tests for watchpoint.
|
|
Tag in tagged address on AArch64 is treated as a non-significant bits of
address, which can be got by gdbarch method significant_addr_bit, and gdb
can clear these bits.
With this patch, when user sets a breakpoint on tagged address on AArch64,
GDB will drop the top byte of address, and put breakpoint at the new place,
as shown below,
(gdb) hbreak *func_ptr
warning: Breakpoint address adjusted from 0xf000000000400690 to 0x00400690.
Hardware assisted breakpoint 2 at 0x400690
(gdb) break *func_ptr
warning: Breakpoint address adjusted from 0xf000000000400690 to 0x00400690.
Breakpoint 3 at 0x400690
When program hits a breakpoint, the stopped pc reported by Linux kernel is
the address *without* tag, so it is better the address recorded in
breakpoint location is the one without tag too, so we can still match
breakpoint location address and stopped pc reported by Linux kernel, by
simple compare.
gdb:
2017-12-08 Yao Qi <yao.qi@linaro.org>
* breakpoint.c (adjust_breakpoint_address): Call
address_significant.
gdb/testsuite:
2017-12-08 Yao Qi <yao.qi@linaro.org>
* gdb.arch/aarch64-tagged-pointer.c (main): Update.
* gdb.arch/aarch64-tagged-pointer.exp: Add test for breakpoint.
|
|
ARMv8 supports tagged address, that is, the top one byte in address
is ignored. It is always enabled on aarch64-linux. See
https://www.kernel.org/doc/Documentation/arm64/tagged-pointers.txt
The tag in the tagged address is modeled as non-significant bits in
address, so this patch adds a new gdbarch method significant_addr_bit and
clear the non-significant bits (the top byte in ARMv8) of the virtual
address at the point before passing address to target cache layer. IOW,
the address used in the target cache layer is already cleared.
Before this patch,
(gdb) x/x 0x0000000000411030
0x411030 <global>: 0x00000000
(gdb) x/x 0xf000000000411030
0xf000000000411030: Cannot access memory at address 0xf000000000411030
After this patch,
(gdb) x/x 0x0000000000411030
0x411030 <global>: 0x00000000
(gdb) x/x 0xf000000000411030
0xf000000000411030: 0x00000000
Note that I used address_significant in paddress, but it causes a
regression gdb.base/long_long.exp, because gdb clears the non-significant
bits in address, but test still expects them.
p/a val.oct^M
$24 = 0x2ee53977053977^M
(gdb) FAIL: gdb.base/long_long.exp: p/a val.oct
so I defer the change there.
gdb:
2017-12-08 Yao Qi <yao.qi@linaro.org>
* aarch64-tdep.c (aarch64_gdbarch_init): Install gdbarch
significant_addr_bit.
* gdbarch.sh (significant_addr_bit): New.
* gdbarch.c, gdbarch.h: Re-generated.
* target.c (memory_xfer_partial): Call address_significant.
* utils.c (address_significant): New function.
* utils.h (address_significant): Declare.
2017-12-08 Yao Qi <yao.qi@linaro.org>
gdb/testsuite:
* gdb.arch/aarch64-tagged-pointer.c: New file.
* gdb.arch/aarch64-tagged-pointer.exp: New file.
|
|
This replaces parse_format_string with a class, removing some
constructors along the way. While doing this, I found that one
argument to gen_printf is unused, so I removed it.
Also, I am not completely sure, but the use of `release' in
maint_agent_printf_command and parse_cmd_to_aexpr seems like it may
leak expressions.
Regression tested by the buildbot.
ChangeLog
2017-12-08 Tom Tromey <tom@tromey.com>
* printcmd.c (ui_printf): Update. Use std::vector.
* common/format.h (struct format_piece): Add constructor.
<string>: Now const.
(class format_pieces): New class.
(parse_format_string, free_format_pieces)
(free_format_pieces_cleanup): Remove.
* common/format.c (format_pieces::format_pieces): Rename from
parse_format_string. Update.
(free_format_pieces, free_format_pieces_cleanup): Remove.
* breakpoint.c (parse_cmd_to_aexpr): Update. Use std::vector.
* ax-gdb.h (gen_printf): Remove argument.
* ax-gdb.c (gen_printf): Remove "frags" argument.
(maint_agent_printf_command): Update. Use std::vector.
gdbserver/ChangeLog
2017-12-08 Tom Tromey <tom@tromey.com>
* ax.c (ax_printf): Update.
|
|
Since:
commit 7022349d5c86bae74b49225515f42d2e221bd368
Author: Pedro Alves <palves@redhat.com>
Date: Mon Sep 4 20:21:13 2017 +0100
Stop assuming no-debug-info functions return int
We now have to explicitly tell GDB the type of the non-debug-info
function we want to print (by casting). This commit adjusts the
"print" statement on gdb.arch/i386-sse-stack-align.exp to do the
proper cast, fixing a failure that started to happen after the
mentioned commit.
gdb/testsuite/ChangeLog:
2017-12-08 Sergio Durigan Junior <sergiodj@redhat.com>
* gdb.arch/i386-sse-stack-align.exp: Cast "print" function call
"int".
|
|
PR 22567 is that breakpoint location can't correct gdbarch from SAL,
because its fields .section and .symtab is NULL. We use to have code
setting .section, but was removed by 4024cf2
- if (msymbol_is_text (msymbol))
+ CORE_ADDR func_addr;
+ if (msymbol_is_function (objfile, msymbol, &func_addr))
{
- sal = find_pc_sect_line (MSYMBOL_VALUE_ADDRESS (objfile, msymbol),
- (struct obj_section *) 0, 0);
- sal.section = MSYMBOL_OBJ_SECTION (objfile, msymbol);
this patch adds this back by moving it to the common place at the bottom
of the function.
gdb:
2017-12-08 Yao Qi <yao.qi@linaro.org>
PR breakpionts/22567
* linespec.c (minsym_found): Set sal.section.
|
|
For some reason symfile-mem.o is not included in the configuration for
"s390*-*-linux*". It was added to the configuration of most GNU/Linux
targets with a patch from Andrew Cagney:
"Add symfile-mem to all linux targets" --
https://sourceware.org/ml/gdb-patches/2005-02/msg00053.html
But the s390 target was overlooked at that time. Thus the command
"add-symbol-file-from-memory" is missing and VDSO symbols are not loaded.
This is fixed.
gdb/ChangeLog:
* configure.tgt (s390*-*-linux*): Add symfile-mem.o.
|
|
breakpoints/22569 involves an internal error generated by the rather
innocent looking command:
(gdb) break -source test.cpp main
.../linespec.c:3302: internal-error: void decode_line_full(...):
Assertion `result.size () == 1 || canonical->pre_expanded' failed.
A problem internal to GDB has been detected,
further debugging may prove unreliable.
Quit this debugging session? (y or n)
The input string is tokenized into "-source", "test.cpp", and "main"
(input parsing breaks on whitespace). create_breakpoint is then called with
the explicit location (containing only the source file name) and "main" as
the extra_string argument.
No SaLs are created for this underspecified explicit location, and the
"result.size () == 1" evaluates false (as does the pre_expanded condition).
This triggers the assertion.
Normally string_to_explicit_location validates the input string. However,
the presence of the string "main" causes the parser to exit early:
802 else
803 {
804 /* End of the explicit location specification.
805 Stop parsing and return whatever explicit location was
806 parsed. */
807 *argp = start;
808 return location;
809 }
This bypasses the validation that is done a few lines down in this function
which would have emitted the expected error. This patch fixes that.
Additionally, this patch also fixes an inconsistency with error reporting
in this use case:
(gdb) b -source foo
Source filename requires function, label, or line offset.
(gdb) b -source foo main
No source file named foo.
These two commands should have elicited the same error message.
gdb/ChangeLog:
PR breakpoints/22569
* location.c (string_to_explicit_location): When terminating
parsing early, break out of enclosing loop instead of returning.
gdb/testsuite/ChangeLog:
PR breakpoints/22569
* gdb.linespec/ls-errs.exp: Change expected result of "break
-source this file has spaces.c -line 3".
Check that an explicit source file followed by whitespace is
identified as an invalid explicit location.
|
|
GDB currently does not track types defined in classes. Consider:
class A
{
public:
class B
{
public:
class C { };
};
};
(gdb) ptype A
type = class A {
<no data fields>
}
This patch changes this behavior so that GDB records these nested types
and displays them to the user when he has set the (new) "print type"
option "nested-type-limit."
Example:
(gdb) set print type nested-type-limit 1
(gdb) ptype A
type = class A {
<no data fields>
class A::B {
<no data fields>
};
}
(gdb) set print type nested-type-limit 2
type = class A {
<no data fields>
class A::B {
<no data fields>
class A::B::C {
<no data fields>
};
};
}
By default, the code maintains the status quo, that is, it will not print
any nested type definitions at all.
Testing is carried out via cp_ptype_class which required quite a bit of
modification to permit recursive calling (for the nested types). This
was most easily facilitated by turning the ptype command output into a
queue. Upshot: the test suite now has stack and queue data structures that
may be used by test writers.
gdb/ChangeLog
* NEWS (New commands): Mention set/show print type nested-type-limit.
* c-typeprint.c (c_type_print_base): Print out nested types.
* dwarf2read.c (struct typedef_field_list): Rename to ...
(struct decl_field_list): ... this. Change all uses.
(struct field_info) <nested_types_list, nested_types_list_count>:
New fields.
(add_partial_symbol): Look for nested type definitions in C++, too.
(dwarf2_add_typedef): Rename to ...
(dwarf2_add_type_defn): ... this.
(type_can_define_types): New function.
Update assertion to use type_can_define_types.
Permit NULL for a field's name.
(process_structure_scope): Handle child DIEs of types that can
define types.
Copy the list of nested types into the type struct.
* gdbtypes.h (struct typedef_field): Rename to ...
(struct decl_field): ... this. Change all uses.
[is_protected, is_private]: New fields.
(struct cplus_struct_type) <nested_types, nested_types_count>: New
fields.
(TYPE_NESTED_TYPES_ARRAY, TYPE_NESTED_TYPES_FIELD)
(TYPE_NESTED_TYPES_FIELD_NAME, TYPE_NESTED_TYPES_FIELD_TYPE)
(TYPE_NESTED_TYPES_COUNT, TYPE_NESTED_TYPES_FIELD_PROTECTED)
(TYPE_NESTED_TYPES_FIELD_PRIVATE): New macros.
* typeprint.c (type_print_raw_options, default_ptype_flags): Add
default value for print_nested_type_limit.
(print_nested_type_limit): New static variable.
(set_print_type_nested_types, show_print_type_nested_types): New
functions.
(_initialize_typeprint): Register new commands for set/show
`print-nested-type-limit'.
* typeprint.h (struct type_print_options) [print_nested_type_limit]:
New field.
gdb/testsuite/ChangeLog
* gdb.cp/nested-types.cc: New file.
* gdb.cp/nested-types.exp: New file.
* lib/cp-support.exp: Load data-structures.exp library.
(debug_cp_test_ptype_class): New global.
(cp_ptype_class_verbose, next_line): New procedures.
(cp_test_ptype_class): Add and document new parameter `recursive_qid'.
Add and document new return value.
Switch the list of lines to a queue.
Add support for new `type' key for nested type definitions.
Add debugging/troubleshooting messages.
* lib/data-structures.exp: New file.
gdb/doc/ChangeLog
* gdb.texinfo (Symbols): Document "set print type nested-type-limit"
and "show print type nested-type-limit".
|
|
The prefix in test_bkpt_explicit_loc is wrong. Instead of using
with_test_prefix directly, define test_bkpt_explicit_loc with
proc_with_prefix.
gdb/testsuite/ChangeLog:
* gdb.python/py-breakpoint.exp (test_bkpt_explicit_loc): Define
with proc_with_prefix, don't use with_test_prefix.
|
|
Pedro pointed out a regression in "commands", where trying to clear a
breakpoint's command list would fail:
(top-gdb) commands
Type commands for breakpoint(s) 3, one per line.
End with a line saying just "end".
>end
No breakpoints specified.
(top-gdb)
I believe the bug was introduced by my patch that changes
counted_command_line to be a shared_ptr. This causes the problem
because now the counted_command_line in commands_command_1 can be NULL,
whereas previously it never could be.
After some discussion, we agreed to simply remove the error case from
commands_command_1.
2017-12-07 Tom Tromey <tom@tromey.com>
PR breakpoints/22511:
* breakpoint.c (commands_command_1): Don't throw an exception when
no commands have been read.
2017-12-07 Tom Tromey <tom@tromey.com>
* gdb.base/break.exp: Add test for empty "commands".
|
|
With g++ 6.3.1:
target-descriptions.c: In member function ‘virtual void
print_c_tdesc::visit_pre(const target_desc*)’:
target-descriptions.c:1836:16: error: types may not be defined in a
for-range-declaration [-Werror]
for (const struct bfd_arch_info *compatible : e->compatible)
^~~~~~
I think at some point the forward declaration of this struct had been
removed and declared as a typedef. This fixes that.
gdb/ChangeLog:
2017-12-07 Adam Stylinski <adam.stylinski@etegent.com>
PR c++/21222
* target-descriptions.c (print_c_tdesc::visit_pre): Change type of
range-for variable.
|
|
Target descriptions are allocated lazily, that is fine in GDBserver,
but it is not safe to call malloc in gdb_collect in IPA, because we
can set a fast tracepoint in malloc, and when the tracepoint is hit,
gdb_collect/malloc is called, deadlock or memory corruption may be
triggered.
#0 0xf7cfc200 in malloc ()
#1 0xf7efdc07 in operator new(unsigned int) ()
#2 0xf7ef7636 in allocate_target_description() ()
#3 0xf7efcbe1 in i386_create_target_description(unsigned long long, bool) ()
#4 0xf7efb474 in i386_linux_read_description(unsigned long long) ()
#5 0xf7efb190 in get_ipa_tdesc(int) ()
#6 0xf7ef9baa in gdb_collect ()
The fix is to initialize all target descriptions earlier, when the
IPA is loaded. In order to guarantee malloc is not called in IPA
in gdb_collect, I change the test to set a breakpoint on malloc, if
IPA gdb_collect calls malloc, program will hit the breakpoint, and
test fail.
continue
Continuing.
Thread 1 "" hit Breakpoint 5, 0xf7cfc200 in malloc ()
(gdb) FAIL: gdb.trace/ftrace.exp: advance through tracing
gdb/gdbserver:
2017-12-07 Yao Qi <yao.qi@linaro.org>
* linux-aarch64-ipa.c (initialize_low_tracepoint): Call
aarch64_linux_read_description.
* linux-amd64-ipa.c (idx2mask): New array.
(get_ipa_tdesc): Move idx2mask out.
(initialize_low_tracepoint): Initialize target descriptions.
* linux-i386-ipa.c (idx2mask): New array.
(get_ipa_tdesc): Move idx2mask out.
(initialize_low_tracepoint): Initialize target descriptions.
gdb/testsuite:
2017-12-07 Yao Qi <yao.qi@linaro.org>
* gdb.trace/ftrace.exp (run_trace_experiment): Set breakpoint on
malloc and catch syscall.
|
|
Clang 6 shows this warning
In file included from /home/emaisin/src/binutils-gdb/gdb/common/selftest.c:19:
In file included from /home/emaisin/src/binutils-gdb/gdb/common/common-defs.h:92:
In file included from /home/emaisin/src/binutils-gdb/gdb/common/gdb_unique_ptr.h:23:
In file included from /usr/bin/../lib/gcc/x86_64-linux-gnu/5.4.0/../../../../include/c++/5.4.0/memory:81:
/usr/bin/../lib/gcc/x86_64-linux-gnu/5.4.0/../../../../include/c++/5.4.0/bits/unique_ptr.h:76:2: error: delete called on 'selftests::selftest' that is abstract but has non-virtual destructor [-Werror,-Wdelete-non-virtual-dtor]
delete __ptr;
^
/usr/bin/../lib/gcc/x86_64-linux-gnu/5.4.0/../../../../include/c++/5.4.0/bits/unique_ptr.h:236:4: note: in instantiation of member function 'std::default_delete<selftests::selftest>::operator()' requested here
get_deleter()(__ptr);
^
/home/emaisin/src/binutils-gdb/gdb/common/selftest.c:57:17: note: in instantiation of member function 'std::unique_ptr<selftests::selftest, std::default_delete<selftests::selftest> >::~unique_ptr' requested here
tests[name] = std::unique_ptr<selftest> (test);
^
The error is legitimate, we (the unique_ptr) are deleting selftest
objects through the base pointer, so technically the destructor should
be virtual, so that the destructor of the subclass is invoked.
gdb/ChangeLog:
* common/selftest.h (struct selftest): Add virtual destructor.
|
|
This introduces several new keywords to the bppy_init constructor.
The spec parameter is now optional but mutually exclusive to the
explicit keywords source, label, function and line.
gdb/ChangeLog
2017-12-07 Phil Muldoon <pmuldoon@redhat.com>
* python/py-breakpoint.c (bppy_init): Use string_to_event_location
over basic location code. Implement explicit location keywords.
(bppy_init_validate_args): New function.
* NEWS: Document Python explicit breakpoint locations.
doc/ChangeLog
2017-12-07 Phil Muldoon <pmuldoon@redhat.com>
* python.texi (Breakpoints In Python): Add text relating
to allowed explicit locations and keywords in gdb.Breakpoints.
testsuite/ChangeLog
2017-12-07 Phil Muldoon <pmuldoon@redhat.com>
* gdb.python/py-breakpoint.exp (test_bkpt_explicit_loc): Add new
tests for explicit locations.
|
|
This patch restores some entries removed by a recent patch whose purpose
was to update the list of active maintainers. I thought that, the target
information was purely to document the scope of the given target, and
thus could be removed is maintainerless. But, in fact, those entries
are still useful, as a number of scripts (eg: gdb_buildall.sh) use
that information to build GDB with all targets enabled.
gdb/ChangeLog:
* MAINTAINERS: Restore target entries for m68hc11-elf,
score-elf and xstormy16-elf, incorrectly removed in a previous
patch meant to only update the list of active maintainers.
|
|
I noticed that we're passing down a data/size pair to
target_ops::to_set_syscall_catchpoint. This commit makes use of
gdb::array_view instead. While at it, use bool where appropriate as
well.
gdb/ChangeLog:
* break-catch-syscall.c (insert_catch_syscall)
(remove_catch_syscall): Adjust to pass reference to
inf_data->syscalls_counts directly via gdb::array_view.
* fbsd-nat.c (fbsd_set_syscall_catchpoint): Adjust to use bool
and gdb::array_view.
* linux-nat.c (linux_child_set_syscall_catchpoint): Likewise.
* remote.c (remote_set_syscall_catchpoint): Likewise.
* target-debug.h (target_debug_print_bool): New.
(define target_debug_print_gdb_array_view_const_int): New.
* target-delegates.c: Regenerate.
* target.h (target_ops) <to_set_syscall_catchpoint>: Use
gdb::array_view and bool.
(target_set_syscall_catchpoint): Likewise.
|
|
The test gdb.base/catch-syscall.exp has been failing since commit
3d415c26bad3a15eed00d2ddf85c4268df77a4cc
Remove cleanups from break-catch-syscall.c
The reason is that we are putting into the group_ptr array a pointer to
the buffer of the local string object. If the string is small enough to
fit in the internal string buffer (used for small string optimizations),
the pointer will point to the local object directly. So even if we
std::move the string to the vector, the pointer in group_ptr will still
point to the local object. When we reuse that object (technically a new
instance, but most likely the same memory) for the next syscall, we'll
overwrite the previous string. The result is that we'll get less
results than expected, since there will be duplicates.
We'll also run into problems if we push the string to the vector, and
then record the c_str () pointer using the string object in the vector.
The vector might get reallocated, the string may move in memory, and our
pointer in group_ptr will point to stale memory.
Instead, we have to push all the strings first, then, when we know the
vector won't change anymore, build the group_ptr array. This is what
this patch does.
gdb/ChangeLog:
* break-catch-syscall.c (catch_syscall_completer): Get pointers
to syscall group strings after building the string vector.
|
|
I've noticed that "set remote target-features-packet off" before
connecting has no effect -- GDB still fetches a target description
anyway.
The problem is that while most "set remote foo-packet" commands were
fixed by:
From 4082afcc3d1af9d8063d1c8e02deb34a8b97a489 Mon Sep 17 00:00:00 2001
From: Pedro Alves <palves@redhat.com>
Date: Fri, 25 Apr 2014 18:07:02 +0100
Subject: [PATCH] Fix several "set remote foo-packet on/off" commands.
<https://sourceware.org/ml/gdb-patches/2014-04/msg00006.html>
the "qXfer" packets where missed. This commit fixes that.
I've changed remote_search_memory too for consistency (seems like
those are the last direct references to packet->support), though the
difference is not observable because the qSearch:memory packet is auto
probed. Note gdb.base/find-unmapped.exp already exercises explicit
"set remote search-memory-packet off".
gdb/ChangeLog:
2017-12-06 Pedro Alves <palves@redhat.com>
* remote.c (remote_query_supported): Don't send "xmlRegisters=" if
"qXfer:features:read"" is disabled.
(remote_write_qxfer, remote_read_qxfer, remote_search_memory):
Check packet_config_support instead of packet->support directly.
gdb/testsuite/ChangeLog:
2017-12-06 Pedro Alves <palves@redhat.com>
* gdb.arch/i386-avx.exp: If testing with a RSP target, check
force-disabling XML descriptions.
--
gdb/remote.c | 16 +++++++++-------
gdb/testsuite/gdb.arch/i386-avx.exp | 25 +++++++++++++++++++++++++
2 files changed, 34 insertions(+), 7 deletions(-)
|
|
I failed at git and missed adding/lost changes on the wrong branch, the
result being that I didn't incorporate fixes resulting from Yao's review
comments. This patch fixes that.
There are two places where we should use the unique pointer typedef, and
ChangeLog entries missing.
gdb/ChangeLog:
* target-descriptions.c (struct tdesc_feature) <registers>: Use
tdesc_reg_up typedef.
(struct target_desc) <features>: Use tdesc_feature_up typedef.
|
|
This patch makes tdesc_type an abstract base class and creates three
subclasses:
- tdesc_type_builtin, for builtin types
- tdesc_type_vector, for vector types
- tdesc_type_with_fields, for struct, union, flag and enum types
This allows getting rid of the union in tdesc_type and to not allow the
std::vector separately. I tried to go further and create separate
classes for struct, union, flag and enum, but it proved too difficult.
One problem is that from the point of the of the target description
code, the types tdesc_type_* are opaque (only forward-declared).
Therefore, it doesn't know about inheritance relationship between those
classes. This makes it impossible to make functions that accept a
pointer to a base class and pass a pointer to a derived class, for
example. I think this patch here is a good compromise, and if somebody
wants to improve things further, the door is open.
A make_gdb_type virtual pure method is added to tdesc_type, which
replaces the current tdesc_gdb_type function. Calling this method on a
tdesc_type returns the corresponding built gdb type.
gdb/ChangeLog:
* target-descriptions.c (struct tdesc_type): Use default
destructor.
<u>: Remove.
<accept>: Remove.
(struct tdesc_type_builtin): New.
(struct tdesc_type_vector): New.
(struct tdesc_type_with_fields): New.
(tdesc_predefined_types): Change type to tdesc_type_builtin[].
(tdesc_gdb_type): Remove.
(tdesc_register_type): Adjust.
(tdesc_create_vector): Create tdesc_type_vector.
(tdesc_create_struct): Create tdesc_type_with_fields.
(tdesc_set_struct_size): Change parameter type.
(tdesc_create_union): Create tdesc_type_with_fields.
(tdesc_create_flags): Likewise.
(tdesc_create_enum): Likewise.
(tdesc_add_field): Change parameter type.
(tdesc_add_typed_bitfield): Likewise.
(tdesc_add_bitfield): Likewise.
(tdesc_add_flag): Likewise.
(tdesc_add_enum_value): Likewise.
(print_c_tdesc) <visit>: Remove overload with tdesc_type
parameter, add overloads for tdesc_type_builtin,
tdesc_type_with_fields and tdesc_type_vector.
<m_printed_type>: Remove.
<m_printed_element_type, m_printed_type_with_fields>: Add.
* target-descriptions.h (tdesc_create_enum): Change return type.
(tdesc_add_typed_bitfield): Change parameter type.
(tdesc_add_enum_value): Change parameter type.
* xml-tdesc.c (struct tdesc_parsing_data) <current_type>: Change
type to tdesc_type_with_fields.
(tdesc_start_struct): Adjust.
(tdesc_start_flags): Adjust.
(tdesc_start_enum): Adjust.
(tdesc_start_field): Adjust.
* arch/tdesc.h (struct tdesc_type_builtin): Forward-declare.
(struct tdesc_type_vector): Forward-declare.
(struct tdesc_type_with_fields): Forward-declare.
(tdesc_create_struct): Change return type.
(tdesc_create_union): Likewise.
(tdesc_create_flags): Likewise.
(tdesc_add_field): Change parameter type.
(tdesc_set_struct_size): Likewise.
(tdesc_add_bitfield): Likewise.
(tdesc_add_flag): Likewise.
* features: Re-generate C files.
gdb/gdbserver/ChangeLog:
* tdesc.c (struct tdesc_type): Change return type.
(tdesc_add_flag): Change parameter type.
(tdesc_add_bitfield): Likewise.
(tdesc_add_field): Likewise.
(tdesc_set_struct_size): Likewise.
|
|
Make tdesc_arch_data::arch_regs be an std::vector of tdesc_arch_reg
objects.
On particularity is that the tdesc_arch_data linked to a gdbarch is
allocated on the gdbarch's obstack. To be safe, I did not change it and
called placement-new on the area returned by OBSTACK_ZALLOC.
gdb/ChangeLog:
* target-descriptions.c (tdesc_arch_reg): Remove typedef.
(struct tdesc_arch_reg): Add constructor.
(DEF_VEC_O (tdesc_arch_reg)): Remove.
(struct tdesc_arch_data): Initialize fields.
<arch_regs>: Change type to std::vector.
(target_find_description): Adjust.
(tdesc_find_type): Adjust.
(tdesc_data_init): Call tdesc_arch_data constructor.
(tdesc_data_alloc): Allocate tdesc_arch_data with new.
(tdesc_data_cleanup): Free data with delete.
(tdesc_numbered_register): Adjust.
(tdesc_find_arch_register): Adjust.
(tdesc_use_registers): Adjust.
|
|
This patch makes the tdesc_type::u::u::fields an std::vector of
tdesc_type_field. The difficulty here is that the vector is part of a
union. Because of this, I made fields a pointer to a vector, and
instantiate/destroy the vector if the type is one that uses this member
of the union
The field tdesc_type_field::name is changed to an std::string at the
same time.
gdb/ChangeLog:
* target-descriptions.c (tdesc_type_field): Remove typedef.
(DEF_VEC_O (tdesc_type_field)): Remove.
(struct tdesc_type_field): Add constructor.
<name>: Change type to std::string.
(struct tdesc_type) <tdesc_type>: Instantiate vector if the type
kind uses it.
<~tdesc_type>: Destroy vector if the type kind uses it.
<u::u::fields>: Change type to std::vector.
(tdesc_gdb_type): Adjust.
(tdesc_add_field): Adjust.
(tdesc_add_typed_bitfield): Adjust.
(tdesc_add_field): Adjust.
(tdesc_add_enum_value): Adjust.
(class print_c_tdesc) <visit>: Adjust.
|
|
This patch makes tdesc_type::name an std::string. This way, we don't
need to free it manually in ~tdesc_type. I think the comment on top of
name is not correct, the string is always malloc'ed.
gdb/ChangeLog:
* target-descriptions.c (struct tdesc_type) <name>: Change type
to std::string.
<~tdesc_type>: Don't manually free name.
<operator==>: Adjust.
(tdesc_named_type): Adjust.
(tdesc_find_type): Adjust.
(tdesc_gdb_type): Adjust.
(class print_c_tdesc) <visit>: Adjust.
|
|
This patch makes tdesc_feature::types an std::vector of unique_ptr of
tdesc_type. This way, we don't need to manually free the objects and
the vector in ~tdesc_feature.
gdb/ChangeLog:
* target-descriptions.c (tdesc_type_p): Remove typedef.
(DEF_VEC_P (tdesc_type_p)): Remove.
(struct tdesc_feature) <types>: Change type to std::vector.
<~tdesc_feature>: Replace with default implementation.
<accept>: Adjust.
(tdesc_named_type): Adjust.
(tdesc_create_vector): Adjust.
(tdesc_create_struct): Adjust.
(tdesc_create_union): Adjust.
(tdesc_create_flags): Adjust.
(tdesc_create_enum): Adjust.
|
|
Make the name, group and type fields of tdesc_reg std::strings. This
way, we don't have to manually free them in ~tdesc_reg.
Doing so results in a small change in the generated tdesc. Instead of
passing an empty string for the group parameter of tdesc_create_reg, the
two modified tdesc now pass NULL. The end result should be the same.
gdb/ChangeLog:
* target-descriptions.c (struct tdesc_reg) <tdesc_reg>: Change
type of name_ parameter, adjust to std::string change.
<name, group, type>: Change type to std::string.
<~tdesc_reg>: Replace with default implementation.
<operator==>: Adjust.
(tdesc_find_register_early): Adjust.
(tdesc_register_name): Adjust.
(tdesc_register_type): Adjust.
(tdesc_register_in_reggroup_p): Adjust.
(class print_c_tdesc) <visit>: Adjust.
(class print_c_feature) <visit>: Adjust.
|
|
This patch makes tdesc_feature::registers an std::vector of unique_ptr
to tdesc_reg. This way, we don't have to manually free the tdesc_reg
objects and the vector in the tdesc_feature destructor.
gdb/ChangeLog:
* target-descriptions.c (tdesc_reg_p): Remove typedef.
(DEF_VEC_P (tdesc_reg_p)): Remove.
(struct tdesc_feature) <registers>: Change type to std::vector.
<~tdesc_feature>: Don't manually free registers.
<accept>: Adjust.
<operator==>: Adjust.
(tdesc_has_registers): Adjust.
(tdesc_find_register_early): Adjust.
(tdesc_use_registers): Adjust.
(tdesc_create_reg): Adjust.
|
|
... so we don't have to manually free it in ~tdesc_feature.
gdb/ChangeLog:
* target-descriptions.c (tdesc_feature) <name>: Change type to
std::string.
<~tdesc_feature>: Don't manually free name.
<operator==>: Adjust.
(tdesc_find_feature): Adjust.
(tdesc_feature_name): Adjust.
(class print_c_tdesc) <visit_pre>: Adjust.
(class print_c_feature) <visit_pre>: Adjust.
|
|
This patch makes target_desc to be a vector of unique_ptr to
tdesc_feature objects. This way, we don't have to manually free the
features and the vector in the target_desc destructor.
gdb/ChangeLog:
* target-descriptions.c (tdesc_feature_p): Remove typedef.
(DEF_VEC_P (tdesc_feature_p)): Remove.
(struct target_desc) <features>: Change type to std::vector.
<~target_desc>: Replace with default implementation.
<accept>: Adjust.
<operator==>: Adjust.
(tdesc_has_registers): Adjust.
(tdesc_find_feature): Adjust.
(tdesc_use_registers): Adjust.
(tdesc_create_feature): Adjust.
|
|
This patch changes target_desc::compatible to be a vector of
bfd_arch_info *. This way, we don't need to manually free the vector in
the target_desc destructor.
gdb/ChangeLog:
* target-descriptions.c (arch_p): Remove typedef.
(DEF_VEC_P (arch_p)): Remove.
(struct target_desc) <compatible>: Change type to std::vector.
<~target_desc>: Don't manually free compatible.
(tdesc_compatible_p): Adjust.
(tdesc_add_compatible): Adjust.
(class print_c_tdesc) <visit_pre>: Adjust.
|