diff --git a/_gdb.spec.Patch.include b/_gdb.spec.Patch.include index aa51c90..13eb704 100644 --- a/_gdb.spec.Patch.include +++ b/_gdb.spec.Patch.include @@ -250,3 +250,18 @@ Patch058: gdb-libexec-add-index.patch # =fedoratest Patch059: gdb-rhbz1553104-s390x-arch12-test.patch +# [aarch64] Backport fix from Luis Machado for RH BZ 2177655. +Patch060: gdb-rhbz2177655-aarch64-pauth-valid-regcache.patch + +# Backport "Fix crash in inside_main_func" +# (Tom Tromey, RHBZ 2183595) +Patch061: gdb-rhbz2183595-rustc-inside_main.patch + +# Backport "Fix a potential illegal memory access in the BFD library..." +# (Nick Clifton, binutils/29988) +Patch062: gdb-binutils29988-read_indexed_address.patch + +# Backport upstream patch fixing a "dangling pointer" build problem +# first seen when building with GCC 13.1.1 20230426 (Red Hat ;; 13.1.1-1). +Patch063: gdb-rhbz2192105-ftbs-dangling-pointer + diff --git a/_gdb.spec.patch.include b/_gdb.spec.patch.include index a66b351..7d2cc95 100644 --- a/_gdb.spec.patch.include +++ b/_gdb.spec.patch.include @@ -57,3 +57,7 @@ %patch057 -p1 %patch058 -p1 %patch059 -p1 +%patch060 -p1 +%patch061 -p1 +%patch062 -p1 +%patch063 -p1 diff --git a/_patch_order b/_patch_order index d199ad4..60e004b 100644 --- a/_patch_order +++ b/_patch_order @@ -57,3 +57,7 @@ gdb-container-rh-pkg.patch gdb-linux_perf-bundle.patch gdb-libexec-add-index.patch gdb-rhbz1553104-s390x-arch12-test.patch +gdb-rhbz2177655-aarch64-pauth-valid-regcache.patch +gdb-rhbz2183595-rustc-inside_main.patch +gdb-binutils29988-read_indexed_address.patch +gdb-rhbz2192105-ftbs-dangling-pointer diff --git a/gdb-binutils29988-read_indexed_address.patch b/gdb-binutils29988-read_indexed_address.patch new file mode 100644 index 0000000..af44d12 --- /dev/null +++ b/gdb-binutils29988-read_indexed_address.patch @@ -0,0 +1,24 @@ +From FEDORA_PATCHES Mon Sep 17 00:00:00 2001 +From: Nick Clifton +Date: Wed, 11 Jan 2023 12:13:46 +0000 +Subject: gdb-binutils29988-read_indexed_address.patch + +;; Backport "Fix a potential illegal memory access in the BFD library..." +;; (Nick Clifton, binutils/29988) + + PR 29988 + * dwarf2.c (read_indexed_address): Fix check for an out of range + offset. + +diff --git a/bfd/dwarf2.c b/bfd/dwarf2.c +--- a/bfd/dwarf2.c ++++ b/bfd/dwarf2.c +@@ -1412,7 +1412,7 @@ read_indexed_address (uint64_t idx, struct comp_unit *unit) + offset += unit->dwarf_addr_offset; + if (offset < unit->dwarf_addr_offset + || offset > file->dwarf_addr_size +- || file->dwarf_addr_size - offset < unit->offset_size) ++ || file->dwarf_addr_size - offset < unit->addr_size) + return 0; + + info_ptr = file->dwarf_addr_buffer + offset; diff --git a/gdb-rhbz2177655-aarch64-pauth-valid-regcache.patch b/gdb-rhbz2177655-aarch64-pauth-valid-regcache.patch new file mode 100644 index 0000000..4f72647 --- /dev/null +++ b/gdb-rhbz2177655-aarch64-pauth-valid-regcache.patch @@ -0,0 +1,279 @@ +From FEDORA_PATCHES Mon Sep 17 00:00:00 2001 +From: Kevin Buettner +Date: Fri, 24 Mar 2023 15:26:57 -0700 +Subject: gdb-rhbz2177655-aarch64-pauth-valid-regcache.patch + +;; [aarch64] Backport fix from Luis Machado for RH BZ 2177655. + +aarch64: Check for valid inferior thread/regcache before reading pauth registers + +There were reports of gdb throwing internal errors when calling +inferior_thread ()/get_current_regcache () on a system with +Pointer Authentication enabled. + +In such cases, gdb produces the following backtrace, or a variation +of it (for gdb's with the non-address removal implemented only in +the aarch64-linux-tdep.c file). + +../../../repos/binutils-gdb/gdb/thread.c:86: internal-error: inferior_thread: Assertion `current_thread_ != nullptr' failed. +A problem internal to GDB has been detected, +further debugging may prove unreliable. +----- Backtrace ----- +0xaaaae04a571f gdb_internal_backtrace_1 + ../../../repos/binutils-gdb/gdb/bt-utils.c:122 +0xaaaae04a57f3 _Z22gdb_internal_backtracev + ../../../repos/binutils-gdb/gdb/bt-utils.c:168 +0xaaaae0b52ccf internal_vproblem + ../../../repos/binutils-gdb/gdb/utils.c:401 +0xaaaae0b5310b _Z15internal_verrorPKciS0_St9__va_list + ../../../repos/binutils-gdb/gdb/utils.c:481 +0xaaaae0e24b8f _Z18internal_error_locPKciS0_z + ../../../repos/binutils-gdb/gdbsupport/errors.cc:58 +0xaaaae0a88983 _Z15inferior_threadv + ../../../repos/binutils-gdb/gdb/thread.c:86 +0xaaaae0956c87 _Z20get_current_regcachev + ../../../repos/binutils-gdb/gdb/regcache.c:428 +0xaaaae035223f aarch64_remove_non_address_bits + ../../../repos/binutils-gdb/gdb/aarch64-tdep.c:3572 +0xaaaae03e8abb _Z31gdbarch_remove_non_address_bitsP7gdbarchm + ../../../repos/binutils-gdb/gdb/gdbarch.c:3109 +0xaaaae0a692d7 memory_xfer_partial + ../../../repos/binutils-gdb/gdb/target.c:1620 +0xaaaae0a695e3 _Z19target_xfer_partialP10target_ops13target_objectPKcPhPKhmmPm + ../../../repos/binutils-gdb/gdb/target.c:1684 +0xaaaae0a69e9f target_read_partial + ../../../repos/binutils-gdb/gdb/target.c:1937 +0xaaaae0a69fdf _Z11target_readP10target_ops13target_objectPKcPhml + ../../../repos/binutils-gdb/gdb/target.c:1977 +0xaaaae0a69937 _Z18target_read_memorymPhl + ../../../repos/binutils-gdb/gdb/target.c:1773 +0xaaaae08be523 ps_xfer_memory + ../../../repos/binutils-gdb/gdb/proc-service.c:90 +0xaaaae08be6db ps_pdread + ../../../repos/binutils-gdb/gdb/proc-service.c:124 +0x40001ed7c3b3 _td_fetch_value + /build/glibc-RIFKjK/glibc-2.31/nptl_db/fetch-value.c:115 +0x40001ed791ef td_ta_map_lwp2thr + /build/glibc-RIFKjK/glibc-2.31/nptl_db/td_ta_map_lwp2thr.c:194 +0xaaaae07f4473 thread_from_lwp + ../../../repos/binutils-gdb/gdb/linux-thread-db.c:413 +0xaaaae07f6d6f _ZN16thread_db_target4waitE6ptid_tP17target_waitstatus10enum_flagsI16target_wait_flagE + ../../../repos/binutils-gdb/gdb/linux-thread-db.c:1420 +0xaaaae0a6b33b _Z11target_wait6ptid_tP17target_waitstatus10enum_flagsI16target_wait_flagE + ../../../repos/binutils-gdb/gdb/target.c:2586 +0xaaaae0789cf7 do_target_wait_1 + ../../../repos/binutils-gdb/gdb/infrun.c:3825 +0xaaaae0789e6f operator() + ../../../repos/binutils-gdb/gdb/infrun.c:3884 +0xaaaae078a167 do_target_wait + ../../../repos/binutils-gdb/gdb/infrun.c:3903 +0xaaaae078b0af _Z20fetch_inferior_eventv + ../../../repos/binutils-gdb/gdb/infrun.c:4314 +0xaaaae076652f _Z22inferior_event_handler19inferior_event_type + ../../../repos/binutils-gdb/gdb/inf-loop.c:41 +0xaaaae07dc68b handle_target_event + ../../../repos/binutils-gdb/gdb/linux-nat.c:4206 +0xaaaae0e25fbb handle_file_event + ../../../repos/binutils-gdb/gdbsupport/event-loop.cc:573 +0xaaaae0e264f3 gdb_wait_for_event + ../../../repos/binutils-gdb/gdbsupport/event-loop.cc:694 +0xaaaae0e24f9b _Z16gdb_do_one_eventi + ../../../repos/binutils-gdb/gdbsupport/event-loop.cc:217 +0xaaaae080f033 start_event_loop + ../../../repos/binutils-gdb/gdb/main.c:411 +0xaaaae080f1b7 captured_command_loop + ../../../repos/binutils-gdb/gdb/main.c:475 +0xaaaae0810b97 captured_main + ../../../repos/binutils-gdb/gdb/main.c:1318 +0xaaaae0810c1b _Z8gdb_mainP18captured_main_args + ../../../repos/binutils-gdb/gdb/main.c:1337 +0xaaaae0338453 main + ../../../repos/binutils-gdb/gdb/gdb.c:32 +--------------------- +../../../repos/binutils-gdb/gdb/thread.c:86: internal-error: inferior_thread: Assertion `current_thread_ != nullptr' failed. +A problem internal to GDB has been detected, +further debugging may prove unreliable. +Quit this debugging session? (y or n) + +We also see failures across the testsuite if the tests get executed on a target +that has native support for the pointer authentication feature. But +gdb.base/break.exp and gdb.base/access-mem-running.exp are two examples of +tests that run into errors and internal errors. + +This issue started after commit d88cb738e6a7a7179dfaff8af78d69250c852af1, which +enabled more broad use of pointer authentication masks to remove non-address +bits of pointers, but wasn't immediately detected because systems with native +support for pointer authentication are not that common yet. + +The above crash happens because gdb is in the middle of handling an event, +and do_target_wait_1 calls switch_to_inferior_no_thread, nullifying the +current thread. This means a call to inferior_thread () will assert, and +attempting to call get_current_regcache () will also call inferior_thread (), +resulting in an assertion as well. + +target_has_registers was one function that seemed useful for detecting these +types of situation where we don't have a register cache. The problem with that +is the inconsistent state of inferior_ptid, which is used by +target_has_registers. + +Despite the call to switch_to_no_thread in switch_to_inferior_no_thread from +do_target_wait_1 in the backtrace above clearing inferior_ptid, the call to +ps_xfer_memory sets inferior_ptid momentarily before reading memory: + +static ps_err_e +ps_xfer_memory (const struct ps_prochandle *ph, psaddr_t addr, + gdb_byte *buf, size_t len, int write) +{ + scoped_restore_current_inferior restore_inferior; + set_current_inferior (ph->thread->inf); + + scoped_restore_current_program_space restore_current_progspace; + set_current_program_space (ph->thread->inf->pspace); + + scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid); + inferior_ptid = ph->thread->ptid; + + CORE_ADDR core_addr = ps_addr_to_core_addr (addr); + + int ret; + if (write) + ret = target_write_memory (core_addr, buf, len); + else + ret = target_read_memory (core_addr, buf, len); + return (ret == 0 ? PS_OK : PS_ERR); +} + +Maybe this shouldn't happen, or maybe it is just an unfortunate state to be +in. But this prevents the use of target_has_registers to guard against the +lack of registers, since, although current_thread_ is still nullptr, +inferior_ptid is valid and is not null_ptid. + +There is another crash scenario after we kill a previously active inferior, in +which case the gdbarch will still say we support pointer authentication but we +will also have no current thread (inferior_thread () will assert etc). + +If the target has support for pointer authentication, gdb needs to use +a couple (or 4, for bare-metal) mask registers to mask off some bits of +pointers, and for that it needs to access the registers. + +At some points, like the one from the backtrace above, there is no active +thread/current regcache because gdb is in the middle of doing event handling +and switching between threads. + +Simon suggested the use of inferior_ptid to fetch the register cache, as +opposed to relying on the current register cache. Though we need to make sure +inferior_ptid is valid (not null_ptid), I think this works nicely. + +With inferior_ptid, we can do safety checks along the way, making sure we have +a thread to fetch a register cache from and checking if the thread is actually +stopped or running. + +The following patch implements this idea with safety checks to make sure we +don't run into assertions or errors. If any of the checks fail, we fallback to +using a default mask to remove non-address bits of a pointer. + +I discussed with Pedro the possibility of caching the mask register values +(which are per-process and can change mid-execution), but there isn't a good +spot to cache those values. Besides, the mask registers can change constantly +for bare-metal debugging when switching between exception levels. + +In some cases, it is just not possible to get access to these mask registers, +like the case where threads are running. In those cases, using a default mask +to remove the non-address bits should be enough. + +This can happen when we let threads run in the background and then we attempt +to access a memory address (now that gdb is capable of reading memory even +with threads running). Thus gdb will attempt to remove non-address bits +of that memory access, will attempt to access registers, running into errors. + +Regression-tested on aarch64-linux Ubuntu 20.04. + +diff --git a/gdb/aarch64-linux-tdep.c b/gdb/aarch64-linux-tdep.c +--- a/gdb/aarch64-linux-tdep.c ++++ b/gdb/aarch64-linux-tdep.c +@@ -57,6 +57,9 @@ + #include "elf/common.h" + #include "elf/aarch64.h" + ++/* For inferior_ptid and current_inferior (). */ ++#include "inferior.h" ++ + /* Signal frame handling. + + +------------+ ^ +@@ -1986,29 +1989,60 @@ aarch64_linux_decode_memtag_section (struct gdbarch *gdbarch, + static CORE_ADDR + aarch64_remove_non_address_bits (struct gdbarch *gdbarch, CORE_ADDR pointer) + { +- aarch64_gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); +- + /* By default, we assume TBI and discard the top 8 bits plus the VA range +- select bit (55). */ ++ select bit (55). Below we try to fetch information about pointer ++ authentication masks in order to make non-address removal more ++ precise. */ + CORE_ADDR mask = AARCH64_TOP_BITS_MASK; + +- if (tdep->has_pauth ()) ++ /* Check if we have an inferior first. If not, just use the default ++ mask. ++ ++ We use the inferior_ptid here because the pointer authentication masks ++ should be the same across threads of a process. Since we may not have ++ access to the current thread (gdb may have switched to no inferiors ++ momentarily), we use the inferior ptid. */ ++ if (inferior_ptid != null_ptid) + { +- /* Fetch the PAC masks. These masks are per-process, so we can just +- fetch data from whatever thread we have at the moment. ++ /* If we do have an inferior, attempt to fetch its thread's thread_info ++ struct. */ ++ thread_info *thread ++ = find_thread_ptid (current_inferior ()->process_target (), ++ inferior_ptid); + +- Also, we have both a code mask and a data mask. For now they are the +- same, but this may change in the future. */ +- struct regcache *regs = get_current_regcache (); +- CORE_ADDR cmask, dmask; ++ /* If the thread is running, we will not be able to fetch the mask ++ registers. */ ++ if (thread != nullptr && thread->state != THREAD_RUNNING) ++ { ++ /* Otherwise, fetch the register cache and the masks. */ ++ struct regcache *regs ++ = get_thread_regcache (current_inferior ()->process_target (), ++ inferior_ptid); ++ ++ /* Use the gdbarch from the register cache to check for pointer ++ authentication support, as it matches the features found in ++ that particular thread. */ ++ aarch64_gdbarch_tdep *tdep ++ = gdbarch_tdep (regs->arch ()); ++ ++ /* Is there pointer authentication support? */ ++ if (tdep->has_pauth ()) ++ { ++ /* We have both a code mask and a data mask. For now they are ++ the same, but this may change in the future. */ ++ CORE_ADDR cmask, dmask; + +- if (regs->cooked_read (tdep->pauth_reg_base, &dmask) != REG_VALID) +- dmask = mask; ++ if (regs->cooked_read (tdep->pauth_reg_base, &dmask) ++ != REG_VALID) ++ dmask = mask; + +- if (regs->cooked_read (tdep->pauth_reg_base + 1, &cmask) != REG_VALID) +- cmask = mask; ++ if (regs->cooked_read (tdep->pauth_reg_base + 1, &cmask) ++ != REG_VALID) ++ cmask = mask; + +- mask |= aarch64_mask_from_pac_registers (cmask, dmask); ++ mask |= aarch64_mask_from_pac_registers (cmask, dmask); ++ } ++ } + } + + return aarch64_remove_top_bits (pointer, mask); diff --git a/gdb-rhbz2183595-rustc-inside_main.patch b/gdb-rhbz2183595-rustc-inside_main.patch new file mode 100644 index 0000000..16a77b6 --- /dev/null +++ b/gdb-rhbz2183595-rustc-inside_main.patch @@ -0,0 +1,136 @@ +From FEDORA_PATCHES Mon Sep 17 00:00:00 2001 +From: Tom Tromey +Date: Fri, 24 Feb 2023 10:40:16 -0700 +Subject: gdb-rhbz2183595-rustc-inside_main.patch + +;; Backport "Fix crash in inside_main_func" +;; (Tom Tromey, RHBZ 2183595) + +gdb 13.1 crashes while running the rust compiler's debugger tests. +The crash has a number of causes. + +First, the rust compiler still uses the C++-like _Z mangling, but with +its own twist -- some hex digits added to the end of a symbol. So, +while gdb finds the correct name of "main": + +(top-gdb) p name +$13 = 0x292e0c0 "rustc_gdb_1031745::main" + +It isn't found in the minsyms, because C++ demangling yields: + +[99] t 0x90c0 _ZN17rustc_gdb_10317454main17h5b5be7fe16a97225E section .text rustc_gdb_1031745::main::h5b5be7fe16a97225 zko06yobckx336v + +This could perhaps be fixed. I also filed a new PR to suggest +preferring the linkage name of the main program. + +Next, the rust compiler emits both a DW_TAG_subprogram and a +DW_TAG_namespace for "main". This happens because the file is named +"main.rs" -- i.e., the bug is specific to the source file name. The +crash also seems to require the nested function inside of 'main', at +least for me. The namespace always is generated, but perhaps this +changes the ordering in the DWARF. + +When inside_main_func looks up the main symbol, it finds the namespace +symbol rather than the function. (I filed a bug about fixing gdb's +symbol tables -- long overdue.) + +Meanwhile, as I think it's important to fix this crash sooner rather +than later, this patch changes inside_main_func to check that the +symbol that is found is LOC_BLOCK. This perhaps should have been done +in the first place, anyway. + +Bug: https://sourceware.org/bugzilla/show_bug.cgi?id=30158 + +diff --git a/gdb/frame.c b/gdb/frame.c +--- a/gdb/frame.c ++++ b/gdb/frame.c +@@ -2453,6 +2453,14 @@ inside_main_func (frame_info_ptr this_frame) + if (bs.symbol == nullptr) + return false; + ++ /* We might have found some unrelated symbol. For example, the ++ Rust compiler can emit both a subprogram and a namespace with ++ the same name in the same scope; and due to how gdb's symbol ++ tables currently work, we can't request the one we'd ++ prefer. */ ++ if (bs.symbol->aclass () != LOC_BLOCK) ++ return false; ++ + const struct block *block = bs.symbol->value_block (); + gdb_assert (block != nullptr); + sym_addr = block->start (); +diff --git a/gdb/testsuite/gdb.rust/main-crash.exp b/gdb/testsuite/gdb.rust/main-crash.exp +new file mode 100644 +--- /dev/null ++++ b/gdb/testsuite/gdb.rust/main-crash.exp +@@ -0,0 +1,35 @@ ++# Copyright (C) 2023 Free Software Foundation, Inc. ++ ++# This program is free software; you can redistribute it and/or modify ++# it under the terms of the GNU General Public License as published by ++# the Free Software Foundation; either version 3 of the License, or ++# (at your option) any later version. ++# ++# This program is distributed in the hope that it will be useful, ++# but WITHOUT ANY WARRANTY; without even the implied warranty of ++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++# GNU General Public License for more details. ++# ++# You should have received a copy of the GNU General Public License ++# along with this program. If not, see . ++ ++# Regression test for a crash in inside_main_func. ++ ++load_lib rust-support.exp ++require allow_rust_tests ++ ++standard_testfile main.rs ++if {[prepare_for_testing "failed to prepare" $testfile $srcfile \ ++ {debug rust}]} { ++ return -1 ++} ++ ++set line [gdb_get_line_number "BREAK"] ++# The bug was that this would crash. ++if {![runto ${srcfile}:$line]} { ++ untested "could not run to breakpoint" ++ return -1 ++} ++ ++# Test that gdb is alive. ++gdb_test "print 23" " = 23" +diff --git a/gdb/testsuite/gdb.rust/main.rs b/gdb/testsuite/gdb.rust/main.rs +new file mode 100644 +--- /dev/null ++++ b/gdb/testsuite/gdb.rust/main.rs +@@ -0,0 +1,30 @@ ++// Copyright (C) 2016-2023 Free Software Foundation, Inc. ++ ++// This program is free software; you can redistribute it and/or modify ++// it under the terms of the GNU General Public License as published by ++// the Free Software Foundation; either version 3 of the License, or ++// (at your option) any later version. ++// ++// This program is distributed in the hope that it will be useful, ++// but WITHOUT ANY WARRANTY; without even the implied warranty of ++// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++// GNU General Public License for more details. ++// ++// You should have received a copy of the GNU General Public License ++// along with this program. If not, see . ++ ++#![allow(dead_code)] ++#![allow(unused_variables)] ++#![allow(unused_assignments)] ++ ++fn global_fn(x: u8) { ++ // BREAK ++} ++ ++fn main() { ++ fn nested(y: u8) { ++ global_fn(y) ++ } ++ ++ nested(23); ++} diff --git a/gdb-rhbz2192105-ftbs-dangling-pointer b/gdb-rhbz2192105-ftbs-dangling-pointer new file mode 100644 index 0000000..26ced86 --- /dev/null +++ b/gdb-rhbz2192105-ftbs-dangling-pointer @@ -0,0 +1,107 @@ +From FEDORA_PATCHES Mon Sep 17 00:00:00 2001 +From: Kevin Buettner +Date: Wed, 3 May 2023 11:28:24 -0700 +Subject: gdb-rhbz2192105-ftbs-dangling-pointer +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +;; Backport upstream patch fixing a "dangling pointer" build problem +;; first seen when building with GCC 13.1.1 20230426 (Red Hat ;; 13.1.1-1). + +Pass const frame_info_ptr reference for skip_[language_]trampoline + +g++ 13.1.1 produces a -Werror=dangling-pointer= + +In file included from ../../binutils-gdb/gdb/frame.h:75, + from ../../binutils-gdb/gdb/symtab.h:40, + from ../../binutils-gdb/gdb/language.c:33: +In member function ‘void intrusive_list::push_empty(T&) [with T = frame_info_ptr; AsNode = intrusive_base_node]’, + inlined from ‘void intrusive_list::push_back(reference) [with T = frame_info_ptr; AsNode = intrusive_base_node]’ at gdbsupport/intrusive_list.h:332:24, + inlined from ‘frame_info_ptr::frame_info_ptr(const frame_info_ptr&)’ at gdb/frame.h:241:26, + inlined from ‘CORE_ADDR skip_language_trampoline(frame_info_ptr, CORE_ADDR)’ at gdb/language.c:530:49: +gdbsupport/intrusive_list.h:415:12: error: storing the address of local variable ‘’ in ‘frame_info_ptr::frame_list.intrusive_list::m_back’ [-Werror=dangling-pointer=] + 415 | m_back = &elem; + | ~~~~~~~^~~~~~~ +gdb/language.c: In function ‘CORE_ADDR skip_language_trampoline(frame_info_ptr, CORE_ADDR)’: +gdb/language.c:530:49: note: ‘’ declared here + 530 | CORE_ADDR real_pc = lang->skip_trampoline (frame, pc); + | ~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~ +gdb/frame.h:359:41: note: ‘frame_info_ptr::frame_list’ declared here + 359 | static intrusive_list frame_list; + | ^~~~~~~~~~ + +Each new frame_info_ptr is being pushed on a static frame list and g++ +cannot see why that is safe in case the frame_info_ptr is created and +destroyed immediately when passed as value. + +It isn't clear why only in this one place g++ sees the issue (probably +because it can inline enough code in this specific case). + +Since passing the frame_info_ptr as const reference is cheaper, use +that as workaround for this warning. + +PR build/30413 +Bug: https://sourceware.org/bugzilla/show_bug.cgi?id=30413 + +Tested-by: Kevin Buettner +Reviewed-by: Kevin Buettner +Reviewed-by: Tom Tromey + +diff --git a/gdb/c-lang.c b/gdb/c-lang.c +--- a/gdb/c-lang.c ++++ b/gdb/c-lang.c +@@ -1003,7 +1003,7 @@ class cplus_language : public language_defn + + /* See language.h. */ + +- CORE_ADDR skip_trampoline (frame_info_ptr fi, ++ CORE_ADDR skip_trampoline (const frame_info_ptr &fi, + CORE_ADDR pc) const override + { + return cplus_skip_trampoline (fi, pc); +diff --git a/gdb/language.c b/gdb/language.c +--- a/gdb/language.c ++++ b/gdb/language.c +@@ -528,7 +528,7 @@ add_set_language_command () + Return the result from the first that returns non-zero, or 0 if all + `fail'. */ + CORE_ADDR +-skip_language_trampoline (frame_info_ptr frame, CORE_ADDR pc) ++skip_language_trampoline (const frame_info_ptr &frame, CORE_ADDR pc) + { + for (const auto &lang : language_defn::languages) + { +diff --git a/gdb/language.h b/gdb/language.h +--- a/gdb/language.h ++++ b/gdb/language.h +@@ -471,7 +471,7 @@ struct language_defn + If that PC falls in a trampoline belonging to this language, return + the address of the first pc in the real function, or 0 if it isn't a + language tramp for this language. */ +- virtual CORE_ADDR skip_trampoline (frame_info_ptr fi, CORE_ADDR pc) const ++ virtual CORE_ADDR skip_trampoline (const frame_info_ptr &fi, CORE_ADDR pc) const + { + return (CORE_ADDR) 0; + } +@@ -789,7 +789,7 @@ extern const char *language_str (enum language); + + /* Check for a language-specific trampoline. */ + +-extern CORE_ADDR skip_language_trampoline (frame_info_ptr, CORE_ADDR pc); ++extern CORE_ADDR skip_language_trampoline (const frame_info_ptr &, CORE_ADDR pc); + + /* Return demangled language symbol, or NULL. */ + extern gdb::unique_xmalloc_ptr language_demangle +diff --git a/gdb/objc-lang.c b/gdb/objc-lang.c +--- a/gdb/objc-lang.c ++++ b/gdb/objc-lang.c +@@ -282,7 +282,7 @@ class objc_language : public language_defn + + /* See language.h. */ + +- CORE_ADDR skip_trampoline (frame_info_ptr frame, ++ CORE_ADDR skip_trampoline (const frame_info_ptr &frame, + CORE_ADDR stop_pc) const override + { + struct gdbarch *gdbarch = get_frame_arch (frame); diff --git a/gdb.spec b/gdb.spec index a17f676..e0d86be 100644 --- a/gdb.spec +++ b/gdb.spec @@ -57,7 +57,7 @@ Version: 13.1 # The release always contains a leading reserved number, start it at 1. # `upstream' is not a part of `name' to stay fully rpm dependencies compatible for the testing. -Release: 1.0.riscv64%{?dist} +Release: 4.0.riscv64%{?dist} License: GPLv3+ and GPLv3+ with exceptions and GPLv2+ and GPLv2+ with exceptions and GPL+ and LGPLv2+ and LGPLv3+ and BSD and Public Domain and GFDL # Do not provide URL for snapshots as the file lasts there only for 2 days. @@ -560,7 +560,7 @@ COMMON_GDB_CONFIGURE_FLAGS="\ --mandir=%{_mandir} \ --infodir=%{_infodir} \ --with-gdb-datadir=%{_datadir}/gdb \ - --enable-gdb-build-warnings=,-Wno-unused,-Wno-deprecated-declarations,-Wno-unused-function\ + --enable-gdb-build-warnings=,-Wno-unused,-Wno-deprecated-declarations,-Wno-unused-function,-Wno-stringop-overflow\ %ifarch %{ix86} ,-Wno-format-overflow\ %endif @@ -1192,10 +1192,25 @@ fi %endif %changelog -* Wed Mar 8 2023 David Abdurachmanov - 13.1-1.0.riscv64 +* Fri May 12 2023 David Abdurachmanov - 13.1-4.0.riscv64 - Add riscv64-linux-gnu to enabled targets - Disable inprocess agent for riscv64 +* Wed May 3 2023 Kevin Buettner - 13.1-4 +- Backport "Pass const frame_info_ptr reference for + skip_[language_]trampoline". (Mark Wielaard, RHBZ 2192105, build/30413) + +* Tue Apr 11 2023 Keith Seitz +- Backport "Fix a potential illegal memory access in the BFD library..." + (Nick Clifton, binutils/29988) + +* Fri Mar 31 2023 Keith Seitz - 13.1-3 +- Backport "Fix crash in inside_main_func". + (Tom Tromey, RHBZ 2183595) + +* Fri Mar 24 2023 Kevin Buettner - 13.1-2 +- Backport fix for RHBZ 2177655. (Luis Machado) + * Thu Mar 2 2023 Kevin Buettner - 13.1-1 - Rebase to FSF GDB 13.1. - Update gdb-6.3-rh-testversion-20041202.patch.