It makes just a little more sense to use input_bfd when retrieving
insns for relocation, since the relocations match the endianness of
the input bfd.
* elf32-ppc.c (ppc64_elf_relocate_section): Calculate d_offset for
input_bfd. Replace occurrences of output_bfd as bfd_get_32 and
bfd_put_32 param with input_bfd.
* elf32-ppc.c (ppc_elf_relocate_section): Likewise. Also
ppc_elf_vle_split16 param.
(ppc_elf_vle_split16): Rename output_bfd param to input_bfd.
We renamed VALUE_FRAME_ID to VALUE_NEXT_FRAME_ID recently,
https://sourceware.org/ml/gdb-patches/2016-11/msg00018.html
and we should use VALUE_NEXT_FRAME_ID in value_from_component
too.
gdb:
2016-11-22 Yao Qi <yao.qi@linaro.org>
* value.c (value_from_component): Use VALUE_NEXT_FRAME_ID
instead of VALUE_FROM_ID.
A little oversight from my part, it caused the Makefile not to track
the dependencies from mi/*.c files.
gdb/ChangeLog:
* Makefile.in (%o: $(srcdir)/mi/%.c): Add missing POSTCOMPILE
step.
2016-11-21 Igor Kudrin <ikudrin@accesssoftek.com>
gold/
* layout.cc: Include windows.h and rpcdce.h (for MinGW32).
(Layout::create_build_id): Generate uuid using UuidCreate().
Fix a commit 089e3718bd ("Greatly improve the speed if looking up
DWARF line number information.") build regression:
cc1: warnings being treated as errors
.../bfd/dwarf2.c: In function 'build_line_info_table':
.../bfd/dwarf2.c:1614: warning: declaration of 'index' shadows a global declaration
/usr/include/string.h:304: warning: shadowed declaration is here
.../bfd/dwarf2.c: In function 'build_lookup_funcinfo_table':
.../bfd/dwarf2.c:2262: warning: declaration of 'index' shadows a global declaration
/usr/include/string.h:304: warning: shadowed declaration is here
make[4]: *** [dwarf2.lo] Error 1
in a way following commit 91d6fa6a03 ("Add -Wshadow to the gcc command
line options used when compiling the binutils.").
bfd/
* dwarf2.c (build_line_info_table): Rename `index' local
variable to `line_index'.
(build_lookup_funcinfo_table): Rename `index' local variable to
`func_index'.
Nowadays, we create a value of subobject in pretty printer with 'address'
being used,
value = value_from_contents_and_address (type, valaddr + embedded_offset,
address + embedded_offset);
set_value_component_location (value, val);
/* set_value_component_location resets the address, so we may
need to set it again. */
if (VALUE_LVAL (value) != lval_internalvar
&& VALUE_LVAL (value) != lval_internalvar_component
&& VALUE_LVAL (value) != lval_computed)
set_value_address (value, address + embedded_offset);
value_from_contents_and_address creates a value from memory, but the
value we are pretty-printing may not from memory at all.
Instead of using value_from_contents_and_address, we create a value
of subobject with the same location as object's but different offset.
We avoid using address in this way. As a result, parameter 'address'
in apply_val_pretty_printer is no longer needed, we can remove it in
next step.
We've already had the location of the 'whole' value, so it is safe
to assume we can create a value of 'component' or 'suboject' value
at the same location but with different offset.
gdb:
2016-11-21 Yao Qi <yao.qi@linaro.org>
* guile/scm-pretty-print.c (gdbscm_apply_val_pretty_printer):
Don't call value_from_contents_and_address and
set_value_address. Call value_from_component.
* python/py-prettyprint.c (gdbpy_apply_val_pretty_printer):
Likewise.
* value.c (value_from_component): New function.
* value.h (value_from_component): Likewise.
* valarith.c (value_subscripted_rvalue): Call
value_from_component.
We shouldn't be using these, since their output goes straight to
stdout, which doesn't allow redirection. So this patch updates
the ARI to detect any such use.
gdb/ChangeLog:
* contrib/ari/gdb_ari.sh: Add detection of printf_vma and
sprintf_vma.
This reverts commit b19753ce31.
As it turns out, GCC (and the assembler) needs additional work in
order to support negative GOT offsets in 64-bit sparc. This is
breaking TLS Local Dynamic in position-independent code.
gas/
2016-11-18 Claudiu Zissulescu <claziss@synopsys.com>
* testsuite/gas/arc/cl-warn.s: New file.
* testsuite/gas/arc/cpu-pseudop-1.d: Likewise.
* testsuite/gas/arc/cpu-pseudop-1.s: Likewise.
* testsuite/gas/arc/cpu-pseudop-2.d: Likewise.
* testsuite/gas/arc/cpu-pseudop-2.s: Likewise.
* testsuite/gas/arc/cpu-warn2.s: Likewise.
* config/tc-arc.c (selected_cpu): Initialize.
(feature_type): New struct.
(feature_list): New variable.
(arc_check_feature): New function.
(arc_select_cpu): Check for .cpu duplicates. Don't overwrite the
current cpu features. Check if a feature is available for a given
cpu.
(md_parse_option): Test if features are available for a given cpu.
bfd/ChangeLog:
2016-11-18 James Clarke <jrtc27@jrtc27.com>
* elfxx-sparc.c (_bfd_sparc_elf_relocate_section): Don't convert
R_SPARC_GOTDATA_OP_HIX22 and R_SPARC_GOTDATA_OP_LOX10 to
R_SPARC_GOT* for non-local references. Instead, treat them like
R_SPARC_GOTDATA_HIX22/R_SPARC_GOTDATA_LOX10 when filling in the
immediate with the calculated relocation.
Adds Rust symbol demangler. Rust mangles symbols using GNU_V3 style,
adding a hash and various special character subtitutions. This adds
a new rust style to cplus_demangle and adds 3 helper functions
rust_demangle, rust_demangle_sym and rust_is_mangled.
rust-demangle.c was written by David. Mark did the code formatting to
GNU style and integration into the gcc/libiberty build system and
testsuite.
include/ChangeLog:
2016-11-03 David Tolnay <dtolnay@gmail.com>
Mark Wielaard <mark@klomp.org>
* demangle.h (DMGL_RUST): New macro.
(DMGL_STYLE_MASK): Add DMGL_RUST.
(demangling_styles): Add dlang_rust.
(RUST_DEMANGLING_STYLE_STRING): New macro.
(RUST_DEMANGLING): New macro.
(rust_demangle): New prototype.
(rust_is_mangled): Likewise.
(rust_demangle_sym): Likewise.
libiberty/ChangeLog:
2016-11-03 David Tolnay <dtolnay@gmail.com>
Mark Wielaard <mark@klomp.org>
* Makefile.in (CFILES): Add rust-demangle.c.
(REQUIRED_OFILES): Add rust-demangle.o.
* cplus-dem.c (libiberty_demanglers): Add rust_demangling case.
(cplus_demangle): Handle RUST_DEMANGLING.
(rust_demangle): New function.
* rust-demangle.c: New file.
* testsuite/Makefile.in (really-check): Add check-rust-demangle.
(check-rust-demangle): New rule.
* testsuite/rust-demangle-expected: New file.
When constructing an :? or fold expression that requires a third
expression only the first and second were explicitly checked to
not be NULL. Since the third expression is also required in these
constructs it needs to be explicitly checked and rejected when missing.
Otherwise the demangler will crash once it tries to d_print the
NULL component. Added two examples to demangle-expected of strings
that would crash before this fix.
Found by American Fuzzy Lop (afl) fuzzer.
In various situations the cplus_demangle () function could read past the
end of input causing crashes. Add checks in various places to not advance
the demangle string location and fail early when end of string is reached.
Add various examples of input strings to the testsuite that would crash
test-demangle before the fixes.
Found by using the American Fuzzy Lop (afl) fuzzer.
libiberty/ChangeLog:
* cplus-dem.c (demangle_signature): After 'H', template function,
no success and don't advance position if end of string reached.
(demangle_template): After 'z', template name, return zero on
premature end of string.
(gnu_special): Guard strchr against searching for zero characters.
(do_type): If member, only advance mangled string when 'F' found.
* testsuite/demangle-expected: Add examples of strings that could
crash the demangler by reading past end of input.
Adjust some comments, add some explicit fall through comments or explicit
returns where necessary to not get implicit-fallthrough warnings.
All fall throughs were deliberate. In one case I added an explicit return
false for clarity instead of falling through a default case (that also
would return false).
libiberty/ChangeLog:
* cplus-dem.c (demangle_signature): Move fall through comment.
(demangle_fund_type): Add fall through comment between 'G' and 'I'.
* hashtab.c (iterative_hash): Add fall through comments.
* regex.c (regex_compile): Add Fall through comment after '+'/'?'.
(byte_re_match_2_internal): Add Fall through comment after jump_n.
Change "Note fall through" to "Fall through".
(common_op_match_null_string_p): Return false after set_number_at
instead of fall through.
When a symbol cannot be demangled in ada_demangle a new demangled VEC
will be allocated without deleting the demangled VEC already in use.
Running testsuite/test-demangle under valgrind will show the leak for
this entry in testsuite/demangle-expected:
# Elaborated flag (not demangled)
--format=gnat
x_E
<x_E>
11 bytes in 1 blocks are definitely lost in loss record 1 of 1
at 0x4C27BE3: malloc (vg_replace_malloc.c:299)
by 0x413FE7: xmalloc (xmalloc.c:148)
by 0x4025EC: ada_demangle (cplus-dem.c:930)
by 0x402C59: cplus_demangle (cplus-dem.c:892)
by 0x400FEC: main (test-demangle.c:317)
libiberty/ChangeLog:
* cplus-dem.c (ada_demangle): Initialize demangled to NULL and
XDELETEVEC demangled when unknown.
Add libiberty/testsuite/demangle-expected testcase for:
PR c++/71696
* cplus-dem.c: Prevent infinite recursion when there is a cycle
in the referencing of remembered mangled types.
(work_stuff): New stack to keep track of the remembered mangled
types that are currently being processed.
(push_processed_type): New method to push currently processed
remembered type onto the stack.
(pop_processed_type): New method to pop currently processed
remembered type from the stack.
(work_stuff_copy_to_from): Copy values of new variables.
(delete_non_B_K_work_stuff): Free stack memory.
(demangle_args): Push/Pop currently processed remembered type.
(do_type): Do not demangle a cyclic reference and push/pop
referenced remembered type.
Add support for FCMLA and FCADD complex arithmetic SIMD instructions.
FCMLA has an indexed element variant where the index range has to be
treated specially because a complex number takes two elements and the
indexed vector size depends on the other operands.
These complex number SIMD instructions are part of ARMv8.3
https://community.arm.com/groups/processors/blog/2016/10/27/armv8-a-architecture-2016-additions
include/
2016-11-18 Szabolcs Nagy <szabolcs.nagy@arm.com>
* opcode/aarch64.h (enum aarch64_opnd): Add AARCH64_OPND_IMM_ROT1,
AARCH64_OPND_IMM_ROT2, AARCH64_OPND_IMM_ROT3.
(enum aarch64_op): Add OP_FCMLA_ELEM.
opcodes/
2016-11-18 Szabolcs Nagy <szabolcs.nagy@arm.com>
* aarch64-tbl.h (QL_V3SAMEHSD_ROT, QL_ELEMENT_ROT): Define.
(aarch64_feature_simd_v8_3, SIMD_V8_3): Define.
(aarch64_opcode_table): Add fcmla and fcadd.
(AARCH64_OPERANDS): Add IMM_ROT{1,2,3}.
* aarch64-asm.h (aarch64_ins_imm_rotate): Declare.
* aarch64-asm.c (aarch64_ins_imm_rotate): Define.
* aarch64-dis.h (aarch64_ext_imm_rotate): Declare.
* aarch64-dis.c (aarch64_ext_imm_rotate): Define.
* aarch64-opc.h (enum aarch64_field_kind): Add FLD_rotate{1,2,3}.
* aarch64-opc.c (fields): Add FLD_rotate{1,2,3}.
(operand_general_constraint_met_p): Rotate and index range check.
(aarch64_print_operand): Handle rotate operand.
* aarch64-asm-2.c: Regenerate.
* aarch64-dis-2.c: Likewise.
* aarch64-opc-2.c: Likewise.
gas/
2016-11-18 Szabolcs Nagy <szabolcs.nagy@arm.com>
* config/tc-aarch64.c (parse_operands): Handle AARCH64_OPND_IMM_ROT*.
* testsuite/gas/aarch64/advsimd-armv8_3.d: New.
* testsuite/gas/aarch64/advsimd-armv8_3.s: New.
* testsuite/gas/aarch64/illegal-fcmla.s: New.
* testsuite/gas/aarch64/illegal-fcmla.l: New.
* testsuite/gas/aarch64/illegal-fcmla.d: New.
When adding a .c file in subdirectory (e.g. mi/), the current practice
is to add an explicit rule, such as:
mi-cmd-break.o: $(srcdir)/mi/mi-cmd-break.c
$(COMPILE) $(srcdir)/mi/mi-cmd-break.c
$(POSTCOMPILE)
I find it a bit verbose and cumbersome. Since we now require GNU make,
we can change those rules with pattern rules, one for each subdirectory.
For example, the following rule works for all files under mi:
%.o: $(srcdir)/mi/%.c
$(COMPILE) $<
$(POSTCOMPILE)
Those pattern rules assume that the source and target files have the
same stem (foo.c and foo.o). In one case, common-agent.o is generated
from common/agent.c, to avoid a conflict with the agent.o in gdb/. In
this case, I kept the explicit rule, which takes precedence over the
pattern rule. We could also rename common/agent.c to
common/common-agent.c to get rid of the special case and still avoid the
clash, as it is done with common/common-regcache.c, for example.
This strategy was the least intrusive I found, as it only requires
changing the rules, not the target names.
I also considered two other solutions, which I did not like because I
would have had to change target names a bit everywhere.
- Replicate the source directory structure in the build directory,
which would generate common/agent.o from common/agent.c. However,
something was not right with the dependency tracking (the .deps
directory). It's probably not hard to fix, but I did not
investigate further.
- Name the object files after the directory they are in, so that
common/agent.c would generate common_agent.c.
GDBserver can benefit from the same treatment, but I'll do it in another
patch.
Built-tested with --enable-targets=all.
New in v2:
- Regroup pattern rules for .c -> .o compilation in a single place.
- Add comment about common-agent.o.
gdb/ChangeLog:
(PYTHON_CFLAGS): Move up.
(%.o: $(srcdir)/arch/%.c): New rule.
(%.o: $(srcdir)/cli/%.c): New rule.
(%.o: $(srcdir)/common/%.c): New rule.
(%.o: $(srcdir)/compile/%.c): New rule.
(%.o: $(srcdir)/gdbtk/generic/%.c): New rule.
(%.o: $(srcdir)/guile/%.c): New rule.
(%.o: $(srcdir)/mi/%.c): New rule.
(%.o: $(srcdir)/nat/%.c): New rule.
(%.o: $(srcdir)/python/%.c): New rule.
(%.o: $(srcdir)/target/%.c): New rule.
(%.o: $(srcdir)/tui/%.c): New rule.
(cli-cmds.o): Remove.
(cli-decode.o): Likewise.
(cli-dump.o): Likewise.
(cli-interp.o): Likewise.
(cli-logging.o): Likewise.
(cli-script.o): Likewise.
(cli-setshow.o): Likewise.
(cli-utils.o): Likewise.
(compile.o): Likewise.
(compile-c-types.o): Likewise.
(compile-c-symbols.o): Likewise.
(compile-object-load.o): Likewise.
(compile-object-run.o): Likewise.
(compile-loc2c.o): Likewise.
(compile-c-support.o): Likewise.
(gdbtk.o): Likewise.
(gdbtk-bp.o): Likewise.
(gdbtk-cmds.o): Likewise.
(gdbtk-hooks.o): Likewise.
(gdbtk-interp.o): Likewise.
(gdbtk-main.o): Likewise.
(gdbtk-register.o): Likewise.
(gdbtk-stack.o): Likewise.
(gdbtk-varobj.o): Likewise.
(gdbtk-wrapper.o): Likewise.
(mi-cmd-break.o): Likewise.
(mi-cmd-catch.o): Likewise.
(mi-cmd-disas.o): Likewise.
(mi-cmd-env.o): Likewise.
(mi-cmd-file.o): Likewise.
(mi-cmd-info.o): Likewise.
(mi-cmds.o): Likewise.
(mi-cmd-stack.o): Likewise.
(mi-cmd-target.o): Likewise.
(mi-cmd-var.o): Likewise.
(mi-console.o): Likewise.
(mi-getopt.o): Likewise.
(mi-interp.o): Likewise.
(mi-main.o): Likewise.
(mi-out.o): Likewise.
(mi-parse.o): Likewise.
(mi-symbol-cmds.o): Likewise.
(mi-common.o): Likewise.
(signals.o): Likewise.
(common-utils.o): Likewise.
(gdb_vecs.o): Likewise.
(xml-utils.o): Likewise.
(ptid.o): Likewise.
(buffer.o): Likewise.
(filestuff.o): Likewise.
(format.o): Likewise.
(vec.o): Likewise.
(print-utils.o): Likewise.
(rsp-low.o): Likewise.
(errors.o): Likewise.
(common-debug.o): Likewise.
(cleanups.o): Likewise.
(common-exceptions.o
(posix-strerror.o): Likewise.
(mingw-strerror.o): Likewise.
(btrace-common.o): Likewise.
(fileio.o): Likewise.
(common-regcache.o): Likewise.
(signals-state-save-restore.o): Likewise.
(new-op.o): Likewise.
(waitstatus.o): Likewise.
(arm.o): Likewise.
(arm-linux.o): Likewise.
(arm-get-next-pcs.o): Likewise.
(x86-dregs.o): Likewise.
(linux-btrace.o): Likewise.
(linux-osdata.o): Likewise.
(linux-procfs.o): Likewise.
(linux-ptrace.o): Likewise.
(linux-waitpid.o): Likewise.
(mips-linux-watch.o): Likewise.
(ppc-linux.o): Likewise.
(linux-personality.o): Likewise.
(x86-linux.o): Likewise.
(x86-linux-dregs.o): Likewise.
(amd64-linux-siginfo.o): Likewise.
(linux-namespaces.o): Likewise.
(aarch64-linux-hw-point.o): Likewise.
(aarch64-linux.o): Likewise.
(aarch64-insn.o): Likewise.
(tui.o): Likewise.
(tui-command.o): Likewise.
(tui-data.o): Likewise.
(tui-disasm.o): Likewise.
(tui-file.o): Likewise.
(tui-hooks.o): Likewise.
(tui-interp.o): Likewise.
(tui-io.o): Likewise.
(tui-layout.o): Likewise.
(tui-out.o): Likewise.
(tui-regs.o): Likewise.
(tui-source.o): Likewise.
(tui-stack.o): Likewise.
(tui-win.o): Likewise.
(tui-windata.o): Likewise.
(tui-wingeneral.o): Likewise.
(tui-winsource.o): Likewise.
(guile.o): Likewise.
(scm-arch.o): Likewise.
(scm-auto-load.o): Likewise.
(scm-block.o): Likewise.
(scm-breakpoint.o): Likewise.
(scm-cmd.o): Likewise.
(scm-disasm.o): Likewise.
(scm-exception.o): Likewise.
(scm-frame.o): Likewise.
(scm-gsmob.o): Likewise.
(scm-iterator.o): Likewise.
(scm-lazy-string.o): Likewise.
(scm-math.o): Likewise.
(scm-objfile.o): Likewise.
(scm-param.o): Likewise.
(scm-ports.o): Likewise.
(scm-pretty-print.o): Likewise.
(scm-progspace.o): Likewise.
(scm-safe-call.o): Likewise.
(scm-string.o): Likewise.
(scm-symbol.o): Likewise.
(scm-symtab.o): Likewise.
(scm-type.o): Likewise.
(scm-utils.o): Likewise.
(scm-value.o): Likewise.
(python.o): Likewise.
(py-arch.o): Likewise.
(py-auto-load.o): Likewise.
(py-block.o): Likewise.
(py-bpevent.o): Likewise.
(py-breakpoint.o): Likewise.
(py-cmd.o): Likewise.
(py-continueevent.o): Likewise.
(py-xmethods.o): Likewise.
(py-event.o): Likewise.
(py-evtregistry.o): Likewise.
(py-evts.o): Likewise.
(py-exitedevent.o): Likewise.
(py-finishbreakpoint.o): Likewise.
(py-frame.o): Likewise.
(py-framefilter.o): Likewise.
(py-function.o): Likewise.
(py-gdb-readline.o): Likewise.
(py-inferior.o): Likewise.
(py-infevents.o): Likewise.
(py-infthread.o): Likewise.
(py-lazy-string.o): Likewise.
(py-linetable.o): Likewise.
(py-newobjfileevent.o): Likewise.
(py-objfile.o): Likewise.
(py-param.o): Likewise.
(py-prettyprint.o): Likewise.
(py-progspace.o): Likewise.
(py-signalevent.o): Likewise.
(py-stopevent.o): Likewise.
(py-symbol.o): Likewise.
(py-symtab.o): Likewise.
(py-threadevent.o): Likewise.
(py-type.o): Likewise.
(py-unwind.o): Likewise.
(py-utils.o): Likewise.
(py-value.o): Likewise.
(py-varobj.o): Likewise.
As mentioned here [1], suffix rules are obsolete and have been
superseeded with pattern rules. People (myself included, before writing
this patch) are more likely to know what pattern rules are than suffix
rules.
AFAIK, .SUFFIXES targets are only used for those rules, and can be
removed as well.
New in v2:
- Replace rule in gdbserver/Makefile.in as well.
[1] https://www.gnu.org/software/make/manual/html_node/Suffix-Rules.html
gdb/ChangeLog:
* Makefile.in (.c.o): Replace rule with ...
(%.o: %.c): ... this one.
(.po.gmo): Replace rule with ...
(%.gmo: %.po): ... this one.
(.po.pox): Replace rule with ...
(%.pox: %.po): ... this one.
(.y.c): Replace rule with ...
(%.c: %.y): ... this one.
(.l.c): Replace rule with ...
(%.c: %.l): ... this one.
(.SUFFIXES): Remove all instances.
gdb/gdbserver/ChangeLog:
* Makefile.in (.c.o): Replace rule with ...
(%.o: %.c): ... this one.
Since GNU make is now required to build GDB, we can remove everything
that checks whether the current make implemention is the GNU one or
not. I simply removed the @GMAKE_TRUE@ prefixes and removed the whole
lines that were prefixed with @GMAKE_FALSE@.
I removed the code in the configure scripts that set those variables.
I also removed the following bits from the configure scripts:
AC_CHECK_PROGS(MAKE, make): GNU make already defines a MAKE variable
internally to be used when invoking Makefiles recursively. I don't see
this variable being used anywhere else (in scripts for example), so I
think it's safe for removal.
AC_PROG_MAKE_SET: This macro defines a SET_MAKE output variable, which
is meant to be used in Makefiles to define the MAKE variable when
using an implementation of make that doesn't already define it.
Since we are now requiring GNU make, we don't need it anymore.
Plus, I don't see SET_MAKE being used anywhere, so I don't think it
was actually doing anything...
gdb/ChangeLog:
* Makefile.in: Remove @GMAKE_TRUE@ prefixes and removes lines
prefixed with @GMAKE_FALSE@. Update comment related to non-GNU
make.
* configure.ac: Remove checks for the make program.
* configure: Re-generate.
gdb/gdbserver/ChangeLog:
* Makefile.in: Remove @GMAKE_TRUE@ prefixes and removes lines
prefixed with @GMAKE_FALSE@. Update comment related to non-GNU
make.
* configure.ac: Remove checks for the make program.
* configure: Re-generate.
gdb/testsuite/ChangeLog:
* Makefile.in: Remove @GMAKE_TRUE@ prefixes and removes lines
prefixed with @GMAKE_FALSE@. Update comment related to non-GNU
make.
* configure.ac: Remove checks for the make program.
* configure: Re-generate.
As discussed in [1], it would be benificial for the GDB project to start
requiring GNU make to build its software. It would allow using useful
GNU-specific constructs, such as pattern rules. It would also allow
removing the alternative code paths in the Makefiles (guarded by
GMAKE_TRUE/GMAKE_FALSE), simplifying the Makefile code.
[1] https://sourceware.org/ml/gdb-patches/2016-11/msg00331.html
gdb/ChangeLog:
* NEWS: Mention requirement of GNU make.
Switching GDB to make use of gnulib's C++ namespace support mode
revealed these direct uses of fprintf in the C parser, where
parser_fprintf should be used to handle rewiring stderr to gdb_stderr:
..../src/gdb/c-exp.y: In function ‘void c_print_token(FILE*, int, YYSTYPE)’:
..../src/gdb/c-exp.y:3220:45: error: call to ‘fprintf’ declared with attribute warning: The symbol ::fprintf refers to the system function. Use gnulib::fprintf instead. [-Werror]
pulongest (value.typed_val_int.val));
^
..../src/gdb/c-exp.y:3231:62: error: call to ‘fprintf’ declared with attribute warning: The symbol ::fprintf refers to the system function. Use gnulib::fprintf instead. [-Werror]
fprintf (file, "tsval<type=%d, %s>", value.tsval.type, copy);
^
..../src/gdb/c-exp.y:3237:57: error: call to ‘fprintf’ declared with attribute warning: The symbol ::fprintf refers to the system function. Use gnulib::fprintf instead. [-Werror]
fprintf (file, "sval<%s>", copy_name (value.sval));
^
..../src/gdb/c-exp.y:3243:39: error: call to ‘fprintf’ declared with attribute warning: The symbol ::fprintf refers to the system function. Use gnulib::fprintf instead. [-Werror]
copy_name (value.tsym.stoken));
^
..../src/gdb/c-exp.y:3254:39: error: call to ‘fprintf’ declared with attribute warning: The symbol ::fprintf refers to the system function. Use gnulib::fprintf instead. [-Werror]
value.ssym.is_a_field_of_this);
^
..../src/gdb/c-exp.y:3258:70: error: call to ‘fprintf’ declared with attribute warning: The symbol ::fprintf refers to the system function. Use gnulib::fprintf instead. [-Werror]
fprintf (file, "bval<%s>", host_address_to_string (value.bval));
^
gdb/ChangeLog:
2016-11-17 Pedro Alves <palves@redhat.com>
* c-exp.y (c_print_token): Use parser_fprintf instead of fprintf.
Making GDB use gnulib's C++ namespace support shows this build error
on mingw:
../../src/gdb/ctf.c: In function 'void ctf_start(trace_file_writer*, const char*)':
../../src/gdb/ctf.c:309:46: error: no match for call to '(const gnulib::_gl_mkdir_wrapper) (const char*&)'
#define mkdir(pathname, mode) mkdir (pathname)
^
../../src/gdb/ctf.c:327:15: note: in expansion of macro 'mkdir'
if (gnulib::mkdir (dirname, hmode) && errno != EEXIST)
^
../../src/gdb/ctf.c:309:46: note: candidate: gnulib::_gl_mkdir_wrapper::type {aka int (*)(const char*, short unsigned int)} <conversion>
#define mkdir(pathname, mode) mkdir (pathname)
^
../../src/gdb/ctf.c:327:15: note: in expansion of macro 'mkdir'
if (gnulib::mkdir (dirname, hmode) && errno != EEXIST)
^
../../src/gdb/ctf.c:309:46: note: candidate expects 3 arguments, 2 provided
#define mkdir(pathname, mode) mkdir (pathname)
^
../../src/gdb/ctf.c:327:15: note: in expansion of macro 'mkdir'
if (gnulib::mkdir (dirname, hmode) && errno != EEXIST)
^
The problem is the '#define mkdir ...'
Fortunately, we can just remove it, since gnulib's sys/stat.h
replacement already takes care of the Windows mkdir prototype quirk:
~~~
/* mingw's _mkdir() function has 1 argument, but we pass 2 arguments.
Additionally, it declares _mkdir (and depending on compile flags, an
alias mkdir), only in the nonstandard includes <direct.h> and <io.h>,
which are included above. */
# if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__
# if !GNULIB_defined_rpl_mkdir
static int
rpl_mkdir (char const *name, mode_t mode)
{
return _mkdir (name);
}
~~~
That's sys_stat.in.h, part of the sys_stat module, which we explictly
pull in nowadays. It wasn't being pulled when this macro was added:
https://sourceware.org/ml/gdb-patches/2013-03/msg00736.html
That patch was partially reverted meanwhile here:
https://sourceware.org/ml/gdb-patches/2013-12/msg00023.html
But the mkdir macro had been left behind unnoticed.
gdb/ChangeLog:
2016-11-17 Pedro Alves <palves@redhat.com>
* ctf.c [USE_WIN32API] (mkdir): Delete.
Switching gdb to use gnulib's C++ namespace mode reveals we're calling
malloc instead of xmalloc here:
..../src/gdb/ada-lang.c: In function ‘value* ada_value_primitive_packed_val(value*, const gdb_byte*, long int, int, int, type*)’:
..../src/gdb/ada-lang.c:2592:50: error: call to ‘malloc’ declared with attribute warning: The symbol ::malloc refers to the system function. Use gnulib::malloc instead. [-Werror]
staging = (gdb_byte *) malloc (staging_len);
^
We're unconditionaly using the result afterwards -- so it's not a case
of gracefully handling huge allocations.
Since we want to get rid of all cleanups, fix this by switching to
new[] and unique_ptr<[]> instead, while at it.
Regtested on Fedora 23.
gdb/ChangeLog:
2016-11-16 Pedro Alves <palves@redhat.com>
* ada-lang.c (ada_value_primitive_packed_val): Use unique_ptr and
new gdb_byte[] instead of malloc and cleanups.
I noticed that bfd's printf_vma prints to stdout directly:
bfd-in2.h:202:#define printf_vma(x) fprintf_vma(stdout,x)
This is a bad idea in gdb, where we should use
gdb_stdout/gdb_stderr/gdb_stdlog, etc., to support redirection.
Eliminate uses of sprintf_vma too while at it.
Tested on Fedora 23, w/ gdbserver.
gdb/ChangeLog:
2016-11-17 Pedro Alves <palves@redhat.com>
* tracepoint.c (collection_list::add_memrange): Add gdbarch
parameter. Use paddress instead of printf_vma. Adjust recursive
calls.
(collection_list::stringify): Use paddress and phex_nz instead of
sprintf_vma. Adjust add_memrange call.
* tracepoint.h (collection_list::add_memrange): Add gdbarch
parameter.
This patch ensures that the frame id for the current frame is stashed
before that of the previous frame (to the current frame).
First, it should be noted that the frame id for the current frame is
not stashed by get_current_frame(). The current frame's frame id is
lazily computed and stashed via calls to get_frame_id(). However,
it's possible for get_prev_frame() to be called without first stashing
the current frame.
The frame stash is used not only to speed up frame lookups, but
also to detect cycles. When attempting to compute the frame id
for a "previous" frame (in get_prev_frame_if_no_cycle), a cycle
is detected if the computed frame id is already in the stash.
If it should happen that a previous frame id is stashed which should
represent a cycle for the current frame, then an assertion failure
will trigger should get_frame_id() be later called to determine
the frame id for the current frame.
As of late 2016, with the "Tweak meaning of VALUE_FRAME_ID" patch in
place, this actually occurs when running the
gdb.dwarf2/dw2-dup-frame.exp test. While attempting to generate a
backtrace, the python frame filter code is invoked, leading to
frame_info_to_frame_object() (in python/py-frame.c) being called.
That function will potentially call get_prev_frame() before
get_frame_id() is called. The call to get_prev_frame() can eventually
end up in get_prev_frame_if_no_cycle() which, in turn, calls
compute_frame_id(), after which the frame id is stashed for the
previous frame.
If the frame id for the current frame is stashed, the cycle detection
code (which relies on the frame stash) in get_prev_frame_if_no_cycle()
will be triggered for a cycle starting with the current frame. If the
current frame's id is not stashed, the cycle detecting code can't
operate as designed. Instead, when get_frame_id() is called on the
current frame at some later point, the current frame's id will found
to be already in the stash, triggering an assertion failure.
Below is an in depth examination of the failure which lead to this change.
I've shortened pathnames for brevity and readability.
Here's the portion of the log file showing the failure/internal error:
(gdb) break stop_frame
Breakpoint 1 at 0x40059a: file dw2-dup-frame.c, line 22.
(gdb) run
Starting program: testsuite/outputs/gdb.dwarf2/dw2-dup-frame/dw2-dup-frame
Breakpoint 1, stop_frame () at dw2-dup-frame.c:22
22 }
(gdb) bt
gdb/frame.c:544: internal-error: frame_id get_frame_id(frame_info*): Assertion `stashed' failed.
A problem internal to GDB has been detected,
further debugging may prove unreliable.
Quit this debugging session? (y or n)
FAIL: gdb.dwarf2/dw2-dup-frame.exp: backtrace from stop_frame (GDB internal error)
Here's a partial backtrace from the internal error, showing the frames
which I think are relevant, plus several extra to provide context:
#0 internal_error (
file=0x932b98 "gdb/frame.c", line=544,
fmt=0x932b20 "%s: Assertion `%s' failed.")
at gdb/common/errors.c:54
#1 0x000000000072207e in get_frame_id (fi=0xe5a760)
at gdb/frame.c:544
#2 0x00000000004eb50d in frame_info_to_frame_object (frame=0xe5a760)
at gdb/python/py-frame.c:390
#3 0x00000000004ef5be in bootstrap_python_frame_filters (frame=0xe5a760,
frame_low=0, frame_high=-1)
at gdb/python/py-framefilter.c:1453
#4 0x00000000004ef7a9 in gdbpy_apply_frame_filter (
extlang=0x8857e0 <extension_language_python>, frame=0xe5a760, flags=7,
args_type=CLI_SCALAR_VALUES, out=0xf6def0, frame_low=0, frame_high=-1)
at gdb/python/py-framefilter.c:1548
#5 0x00000000005f2c5a in apply_ext_lang_frame_filter (frame=0xe5a760,
flags=7, args_type=CLI_SCALAR_VALUES, out=0xf6def0, frame_low=0,
frame_high=-1)
at gdb/extension.c:572
#6 0x00000000005ea896 in backtrace_command_1 (count_exp=0x0, show_locals=0,
no_filters=0, from_tty=1)
at gdb/stack.c:1834
Examination of the code in frame_info_to_frame_object(), which is in
python/py-frame.c, is key to understanding this problem:
if (get_prev_frame (frame) == NULL
&& get_frame_unwind_stop_reason (frame) != UNWIND_NO_REASON
&& get_next_frame (frame) != NULL)
{
frame_obj->frame_id = get_frame_id (get_next_frame (frame));
frame_obj->frame_id_is_next = 1;
}
else
{
frame_obj->frame_id = get_frame_id (frame);
frame_obj->frame_id_is_next = 0;
}
I will first note that the frame id for frame has not been computed yet. (This
was verified by placing a breakpoint on compute_frame_id().)
The call to get_prev_frame() causes the the frame id to (eventually) be
computed for the previous frame. Here's a backtrace showing how we
get there:
#0 compute_frame_id (fi=0x10e2810)
at gdb/frame.c:496
#1 0x0000000000724a67 in get_prev_frame_if_no_cycle (this_frame=0xe5a760)
at gdb/frame.c:1871
#2 0x0000000000725136 in get_prev_frame_always_1 (this_frame=0xe5a760)
at gdb/frame.c:2045
#3 0x000000000072516b in get_prev_frame_always (this_frame=0xe5a760)
at gdb/frame.c:2061
#4 0x000000000072570f in get_prev_frame (this_frame=0xe5a760)
at gdb/frame.c:2303
#5 0x00000000004eb471 in frame_info_to_frame_object (frame=0xe5a760)
at gdb/python/py-frame.c:381
For this particular case, we end up in the else clause of the code above
which calls get_frame_id (frame). It's at this point that the frame id
for frame is computed. Again, here's a backtrace:
#0 compute_frame_id (fi=0xe5a760)
at gdb/frame.c:496
#1 0x000000000072203d in get_frame_id (fi=0xe5a760)
at gdb/frame.c:539
#2 0x00000000004eb50d in frame_info_to_frame_object (frame=0xe5a760)
at gdb/python/py-frame.c:390
The test in question, dw2-dup-frame.exp, deliberately creates a broken
(cyclic) stack. So, in this instance, the frame id for the prev
`frame' will be the same as that for `frame'. But that particular
frame id ended up in the stash during the previous frame operation.
When, just a few lines later, we compute the frame id for `frame', the
id in question is already in the stash, thus triggering the assertion
failure.
I considered two other solutions to solving this problem:
We could prevent get_prev_frame() from being called before
get_frame_id() in frame_info_to_frame_object(). (See above for the
snippet of code where this happens.) A call to get_frame_id (frame)
could be placed ahead of that code snippet above. I have tested this
approach and, while it does work, I can't be certain that
get_prev_frame() isn't called ahead of stashing the current frame
somewhere else in GDB, but in a less obvious way.
Another approach is to stash the current frame's id by calling
get_frame_id() in get_current_frame(). This approach is conceptually
simpler, but when importing a python unwinder, has the unwelcome side
effect of causing the unwinder to be called during import.
A cleaner looking fix would be to place this code after code
corresponding to the "Don't compute the frame id of the current frame
yet..." comment in get_prev_frame_if_no_cycle(). Sadly, this does not
work though; by the time we get to this point, the frame state for the
prev frame has been modified just enough to cause an internal error to
occur when attempting to compute the (current) frame id for inline
frames. (The unexpected failure count increases by roughly 130
failures.) Therefore, I decided to place it as early as possible
in get_prev_frame().
gdb/ChangeLog:
* frame.c (get_prev_frame): Stash frame id for current frame
prior to computing frame id for previous frame.
The C function, pending_framepy_read_register(), which implements
the python interface gdb.PendingFrame.read_register does not handle
the so called "user" registers like "pc". An assertion error is
triggered due to the user registers having numbers larger than or
equal to gdbarch_num_regs(gdbarch).
With the VALUE_FRAME_ID tweak in place, the call to
get_frame_register_value() can simply be replaced by a call to
value_of_register(), which handles both real registers as well as the
user registers.
gdb/ChangeLog:
* python/py-unwind.c (pending_framepy_read_register): Use
value_of_register() instead of get_frame_register_value().
The VALUE_FRAME_ID macro provides access to a member in struct value
that's used to hold the frame id that's used when determining a
register's value or when assigning to a register. The underlying
member has a long and obscure name. I won't refer to it here, but
will simply refer to VALUE_FRAME_ID as if it's the struct value member
instead of being a convenient macro.
At the moment, without this patch in place, VALUE_FRAME_ID is set in
value_of_register_lazy() and several other locations to hold the frame
id of the frame passed to those functions.
VALUE_FRAME_ID is used in the lval_register case of
value_fetch_lazy(). To fetch the register's value, it calls
get_frame_register_value() which, in turn, calls
frame_unwind_register_value() with frame->next.
A python based unwinder may wish to determine the value of a register
or evaluate an expression containing a register. When it does this,
value_fetch_lazy() will be called under some circumstances. It will
attempt to determine the frame id associated with the frame passed to
it. In so doing, it will end up back in the frame sniffer of the very
same python unwinder that's attempting to learn the value of a
register as part of the sniffing operation. This recursion is not
desirable.
As noted above, when value_fetch_lazy() wants to fetch a register's
value, it does so (indirectly) by unwinding from frame->next.
With this in mind, a solution suggests itself: Change VALUE_FRAME_ID
to hold the frame id associated with the next frame. Then, when it
comes time to obtain the value associated with the register, we can
simply unwind from the frame corresponding to the frame id stored in
VALUE_FRAME_ID. This neatly avoids the python unwinder recursion
problem by changing when the "next" operation occurs. Instead of the
"next" operation occuring when the register value is fetched, it
occurs earlier on when assigning a frame id to VALUE_FRAME_ID.
(Thanks to Pedro for this suggestion.)
This patch implements this idea.
It builds on the patch "Distinguish sentinel frame from null frame".
Without that work in place, it's necessary to check for null_id at
several places and then obtain the sentinel frame.
It also renames most occurences of VALUE_FRAME_ID to
VALUE_NEXT_FRAME_ID to reflect the new meaning of this field.
There are several uses of VALUE_FRAME_ID which were not changed. In
each case, the original meaning of VALUE_FRAME_ID is required to get
correct results. In all but one of these uses, either
put_frame_register_bytes() or get_frame_register_bytes() is being
called with the frame value obtained from VALUE_FRAME_ID. Both of
these functions perform some unwinding by performing a "->next"
operation on the frame passed to it. If we were to use the new
VALUE_NEXT_FRAME_ID macro, this would effectively do two "->next"
operations, which is not what we want.
The VALUE_FRAME_ID macro has been redefined in terms of
VALUE_NEXT_FRAME_ID. It simply fetches the previous frame's id,
providing this id as the value of the macro.
gdb/ChangeLog:
* value.h (VALUE_FRAME_ID): Rename to VALUE_NEXT_FRAME_ID. Update
comment. Create new VALUE_FRAME_ID which is defined in terms of
VALUE_NEXT_FRAME_ID.
(deprecated_value_frame_id_hack): Rename to
deprecated_value_next_frame_id_hack.
* dwarf2loc.c, findvar.c, frame-unwind.c, sentinel-frame.c,
valarith.c, valops.c, value.c: Adjust nearly all occurences of
VALUE_FRAME_ID to VALUE_NEXT_FRAME_ID. Add comments for those
which did not change.
* value.c (struct value): Rename frame_id field to next_frame_id.
Update comment.
(deprecated_value_frame_id_hack): Rename to
deprecated_value_next_frame_id_hack.
(value_fetch_lazy): Call frame_unwind_register_value()
instead of get_frame_register_value().
* frame.c (get_prev_frame_id_by_id): New function.
* frame.h (get_prev_frame_id_by_id): Declare.
* dwarf2loc.c (dwarf2_evaluate_loc_desc_full): Make
VALUE_NEXT_FRAME_ID refer to the next frame.
* findvar.c (value_of_register_lazy): Likewise.
(default_value_from_register): Likewise.
(value_from_register): Likewise.
* frame_unwind.c (frame_unwind_got_optimized): Likewise.
* sentinel-frame.c (sentinel_frame_prev_register): Likewise.
* value.h (VALUE_FRAME_ID): Update comment describing this macro.
This patch replaces the `current_frame' static global in frame.c with
`sentinel_frame'. It also makes the sentinel frame id unique and
different from the null frame.
By itself, there is not much point to this patch, but it makes
the code cleaner for the VALUE_FRAME_ID changes in another patch.
Since we now allow "navigation" to the sentinel frame, it removes
the necessity of adding special cases to other parts of GDB.
Note that a new function, get_next_frame_sentinel_okay, is introduced
in this patch. It will be used by the VALUE_FRAME_ID changes that
I've made.
Thanks to Pedro Alves for this suggestion.
gdb/ChangeLog:
* frame.h (enum frame_id_stack_status): Add FID_STACK_SENTINEL.
(struct frame_id): Increase number of bits required for storing
stack status to 3 from 2.
(sentinel_frame_id): New declaration.
(get_next_frame_sentinel_okay): Declare.
(frame_find_by_id_sentinel_okay): Declare.
* frame.c (current_frame): Rename this static global to...
(sentinel_frame): ...this static global, which has also been
moved an earlier location in the file.
(fprint_frame_id): Add case for sentinel frame id.
(get_frame_id): Return early for sentinel frame.
(sentinel_frame_id): Define.
(frame_find_by_id): Add case for sentinel_frame_id.
(create_sentinel_frame): Use sentinel_frame_id for this_id.value
instead of null_frame_id.
(get_current_frame): Add local declaration for `current_frame'.
Remove local declaration for `sentinel_frame.'
(get_next_frame_sentinel_okay): New function.
(reinit_frame_cache): Use `sentinel_frame' in place of
`current_frame'.
This patch modifies the unwinder (sniffer) defined in
py-recurse-unwind.py so that, depending upon the value of one of its
class variables, it will take different paths through the code,
testing different functionality.
The original test attempted to obtain the value of an undefined
symbol.
This somewhat expanded test checks to see if 'pc' can be read via
gdb.PendingFrame.read_register() and also via gdb.parse_and_eval().
gdb/testsuite/ChangeLog:
* gdb.python/py-recurse-unwind.c (main): Add loop.
* gdb.python/py-recurse-unwind.py (TestUnwinder): Add calls
to read_register() and gdb.parse_and_eval(). Make each code
call a separate case that can be individually tested.
* gdb.python/py-recurse-unwind.exp (cont_and_backtrace): New
proc. Call cont_and_backtrace for each of the code paths that
we want to test in the unwinder.
