From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from smtp.polymtl.ca (smtp.polymtl.ca [132.207.4.11]) by sourceware.org (Postfix) with ESMTPS id 4F5BB3858D33 for ; Wed, 8 Nov 2023 05:14:38 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 4F5BB3858D33 Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=polymtl.ca Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=polymtl.ca ARC-Filter: OpenARC Filter v1.0.0 sourceware.org 4F5BB3858D33 Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=132.207.4.11 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1699420480; cv=none; b=R7EDabcdqIDaJSREPeV3/QrHB8Psph5lE8WOexNsAoIwpYccFmRlC0kAvocjvEuRhdHijsyfflsvk1u+cqwlZEM3GVdzHjNtnCVrrPitwKIz3uqsnyjOqAjl0qLrE0bYIiX2oq2Nuw3e5qCfnCNxKMVzPn2og43X2KnQZD4NTZM= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1699420480; c=relaxed/simple; bh=z0Lghi4XafNJ3zWSzhCMNo0kinrRZarBtO5Wko4xOOk=; h=DKIM-Signature:From:To:Subject:Date:Message-ID:MIME-Version; b=KEW/VyQ7LQKdxlinfaatnWucXsW8tYiI3KpOiIhzycVmXnDc6hIsCALXGZE6CUzrBkmN0U/ShwjxU863WEK7oAOaAclT1LY+qsV+1fn/xg+ijGzTCbDANkciq07Odj/i8Z8uyBSx4aSMee+iBIgpSn4bUWgtH5VCG6lLR+XD23Y= ARC-Authentication-Results: i=1; server2.sourceware.org Received: from simark.ca (simark.ca [158.69.221.121]) (authenticated bits=0) by smtp.polymtl.ca (8.14.7/8.14.7) with ESMTP id 3A85EVIj015671 (version=TLSv1/SSLv3 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 8 Nov 2023 00:14:36 -0500 DKIM-Filter: OpenDKIM Filter v2.11.0 smtp.polymtl.ca 3A85EVIj015671 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=polymtl.ca; s=default; t=1699420476; bh=H+rTrRwM5e5smWCkuvehbU6J+4731T5OT4mdA+8o5Vs=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=aY7xkK3L1UGLZm+jn+VibCWPqACys3skFb4lc+c34kVmAzJi+BoFt448Pf2AB6rBX 95KwDKZxfGby0dH82hbiBHFr90MqH2YOvg8UxhHbLmcBx83aArYe9hMlE+4vtcDvAM 1BDB9YXLVb6XCuyZf5vJaMCj07oeCqX5oXuaCCNA= Received: from simark.localdomain (modemcable238.237-201-24.mc.videotron.ca [24.201.237.238]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (prime256v1) server-digest SHA256) (No client certificate requested) by simark.ca (Postfix) with ESMTPSA id A9D3F1E098; Wed, 8 Nov 2023 00:14:31 -0500 (EST) From: Simon Marchi To: gdb-patches@sourceware.org Cc: Simon Marchi Subject: [PATCH 08/24] gdb: change value_of_register and value_of_register_lazy to take the next frame Date: Wed, 8 Nov 2023 00:00:52 -0500 Message-ID: <20231108051222.1275306-9-simon.marchi@polymtl.ca> X-Mailer: git-send-email 2.42.1 In-Reply-To: <20231108051222.1275306-1-simon.marchi@polymtl.ca> References: <20231108051222.1275306-1-simon.marchi@polymtl.ca> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Poly-FromMTA: (simark.ca [158.69.221.121]) at Wed, 8 Nov 2023 05:14:31 +0000 X-Spam-Status: No, score=-3188.6 required=5.0 tests=BAYES_00,DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,GIT_PATCH_0,RCVD_IN_MSPIKE_H3,RCVD_IN_MSPIKE_WL,SPF_HELO_PASS,SPF_PASS,TXREP,T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org List-Id: From: Simon Marchi Some functions related to the handling of registers in frames accept "this frame", for which we want to read or write the register values, while other functions accept "the next frame", which is the frame next to that. The later is needed because we sometimes need to read register values for a frame that does not exist yet (usually when trying to unwind that frame-to-be). value_of_register and value_of_register_lazy both take "this frame", even if what they ultimately want internally is "the next frame". This is annoying if you are in a spot that currently has "the next frame" and need to call one of these functions (which happens later in this series). You need to get the previous frame only for those functions to get the next frame again. This is more manipulations, more chances of mistake. I propose to change these functions (and a few more functions in the subsequent patches) to operate on "the next frame". Things become a bit less awkward when all these functions agree on which frame they take. So, in this patch, change value_of_register_lazy and value_of_register to take "the next frame" instead of "this frame". This adds a lot of get_next_frame_sentinel_okay, but if we convert the user registers API to also use "the next frame" instead of "this frame", it will get simple again. Change-Id: Iaa24815e648fbe5ae3c214c738758890a91819cd --- gdb/aarch64-tdep.c | 3 +-- gdb/arm-tdep.c | 4 ++-- gdb/eval.c | 3 ++- gdb/findvar.c | 34 ++++++++++++---------------------- gdb/frame-unwind.c | 3 ++- gdb/guile/scm-frame.c | 3 ++- gdb/infcmd.c | 6 +++--- gdb/loongarch-tdep.c | 3 ++- gdb/mi/mi-main.c | 3 ++- gdb/mips-tdep.c | 2 +- gdb/nds32-tdep.c | 5 +++-- gdb/python/py-frame.c | 3 ++- gdb/python/py-unwind.c | 4 ++-- gdb/riscv-tdep.c | 4 ++-- gdb/s12z-tdep.c | 2 +- gdb/std-regs.c | 11 +++++++---- gdb/value.h | 9 +++++++-- 17 files changed, 53 insertions(+), 49 deletions(-) diff --git a/gdb/aarch64-tdep.c b/gdb/aarch64-tdep.c index eaae2d91047b..50bfaa41eee2 100644 --- a/gdb/aarch64-tdep.c +++ b/gdb/aarch64-tdep.c @@ -3449,9 +3449,8 @@ value_of_aarch64_user_reg (frame_info_ptr frame, const void *baton) { const int *reg_p = (const int *) baton; - return value_of_register (*reg_p, frame); + return value_of_register (*reg_p, get_next_frame_sentinel_okay (frame)); } - /* Implement the "software_single_step" gdbarch method, needed to single step through atomic sequences on AArch64. */ diff --git a/gdb/arm-tdep.c b/gdb/arm-tdep.c index 2018f4ed0edd..5c8c4cd4e94b 100644 --- a/gdb/arm-tdep.c +++ b/gdb/arm-tdep.c @@ -9954,9 +9954,9 @@ static struct value * value_of_arm_user_reg (frame_info_ptr frame, const void *baton) { const int *reg_p = (const int *) baton; - return value_of_register (*reg_p, frame); + return value_of_register (*reg_p, get_next_frame_sentinel_okay (frame)); } - + static enum gdb_osabi arm_elf_osabi_sniffer (bfd *abfd) { diff --git a/gdb/eval.c b/gdb/eval.c index b859e825925b..16206d92702a 100644 --- a/gdb/eval.c +++ b/gdb/eval.c @@ -1134,7 +1134,8 @@ eval_op_register (struct type *expect_type, struct expression *exp, && regno < gdbarch_num_cooked_regs (exp->gdbarch)) val = value::zero (register_type (exp->gdbarch, regno), not_lval); else - val = value_of_register (regno, get_selected_frame (NULL)); + val = value_of_register + (regno, get_next_frame_sentinel_okay (get_selected_frame ())); if (val == NULL) error (_("Value of register %s not available."), name); else diff --git a/gdb/findvar.c b/gdb/findvar.c index edb61fb27317..6ee31e780932 100644 --- a/gdb/findvar.c +++ b/gdb/findvar.c @@ -244,42 +244,32 @@ copy_integer_to_size (gdb_byte *dest, int dest_size, const gdb_byte *source, } } -/* Return a `value' with the contents of (virtual or cooked) register - REGNUM as found in the specified FRAME. The register's type is - determined by register_type (). */ +/* See value.h. */ -struct value * -value_of_register (int regnum, frame_info_ptr frame) +value * +value_of_register (int regnum, frame_info_ptr next_frame) { - struct gdbarch *gdbarch = get_frame_arch (frame); - struct value *reg_val; + gdbarch *gdbarch = frame_unwind_arch (next_frame); /* User registers lie completely outside of the range of normal registers. Catch them early so that the target never sees them. */ if (regnum >= gdbarch_num_cooked_regs (gdbarch)) - return value_of_user_reg (regnum, frame); + return value_of_user_reg (regnum, get_prev_frame_always (next_frame)); - reg_val = value_of_register_lazy (frame, regnum); + value *reg_val = value_of_register_lazy (next_frame, regnum); reg_val->fetch_lazy (); return reg_val; } -/* Return a `value' with the contents of (virtual or cooked) register - REGNUM as found in the specified FRAME. The register's type is - determined by register_type (). The value is not fetched. */ +/* See value.h. */ -struct value * -value_of_register_lazy (frame_info_ptr frame, int regnum) +value * +value_of_register_lazy (frame_info_ptr next_frame, int regnum) { - struct gdbarch *gdbarch = get_frame_arch (frame); - struct value *reg_val; - frame_info_ptr next_frame; + gdbarch *gdbarch = frame_unwind_arch (next_frame); gdb_assert (regnum < gdbarch_num_cooked_regs (gdbarch)); - - gdb_assert (frame != NULL); - - next_frame = get_next_frame_sentinel_okay (frame); + gdb_assert (next_frame != nullptr); /* In some cases NEXT_FRAME may not have a valid frame-id yet. This can happen if we end up trying to unwind a register as part of the frame @@ -292,7 +282,7 @@ value_of_register_lazy (frame_info_ptr frame, int regnum) /* We should have a valid next frame. */ gdb_assert (frame_id_p (get_frame_id (next_frame))); - reg_val = value::allocate_lazy (register_type (gdbarch, regnum)); + value *reg_val = value::allocate_lazy (register_type (gdbarch, regnum)); reg_val->set_lval (lval_register); VALUE_REGNUM (reg_val) = regnum; VALUE_NEXT_FRAME_ID (reg_val) = get_frame_id (next_frame); diff --git a/gdb/frame-unwind.c b/gdb/frame-unwind.c index 927b6256b0b3..89ae3d70b200 100644 --- a/gdb/frame-unwind.c +++ b/gdb/frame-unwind.c @@ -278,7 +278,8 @@ struct value * frame_unwind_got_register (frame_info_ptr frame, int regnum, int new_regnum) { - return value_of_register_lazy (frame, new_regnum); + return value_of_register_lazy (get_next_frame_sentinel_okay (frame), + new_regnum); } /* Return a value which indicates that FRAME saved REGNUM in memory at diff --git a/gdb/guile/scm-frame.c b/gdb/guile/scm-frame.c index 45863c587c1d..830acb8b53ed 100644 --- a/gdb/guile/scm-frame.c +++ b/gdb/guile/scm-frame.c @@ -835,7 +835,8 @@ gdbscm_frame_read_register (SCM self, SCM register_scm) register_str, strlen (register_str)); if (regnum >= 0) - value = value_of_register (regnum, frame); + value = value_of_register (regnum, + get_next_frame_sentinel_okay (frame)); } } catch (const gdb_exception &ex) diff --git a/gdb/infcmd.c b/gdb/infcmd.c index cf8cd5279558..63b700c1e669 100644 --- a/gdb/infcmd.c +++ b/gdb/infcmd.c @@ -2318,9 +2318,9 @@ default_print_registers_info (struct gdbarch *gdbarch, if (*(gdbarch_register_name (gdbarch, i)) == '\0') continue; - default_print_one_register_info (file, - gdbarch_register_name (gdbarch, i), - value_of_register (i, frame)); + default_print_one_register_info + (file, gdbarch_register_name (gdbarch, i), + value_of_register (i, get_next_frame_sentinel_okay (frame))); } } diff --git a/gdb/loongarch-tdep.c b/gdb/loongarch-tdep.c index c65e2414bf8a..6d862dcec044 100644 --- a/gdb/loongarch-tdep.c +++ b/gdb/loongarch-tdep.c @@ -392,7 +392,8 @@ loongarch_software_single_step (struct regcache *regcache) static struct value * value_of_loongarch_user_reg (frame_info_ptr frame, const void *baton) { - return value_of_register ((long long) baton, frame); + return value_of_register ((long long) baton, + get_next_frame_sentinel_okay (frame)); } /* Implement the frame_align gdbarch method. */ diff --git a/gdb/mi/mi-main.c b/gdb/mi/mi-main.c index 944c9116731f..dd5079f87c6c 100644 --- a/gdb/mi/mi-main.c +++ b/gdb/mi/mi-main.c @@ -1101,7 +1101,8 @@ output_register (frame_info_ptr frame, int regnum, int format, int skip_unavailable) { struct ui_out *uiout = current_uiout; - struct value *val = value_of_register (regnum, frame); + value *val + = value_of_register (regnum, get_next_frame_sentinel_okay (frame)); struct value_print_options opts; if (skip_unavailable && !val->entirely_available ()) diff --git a/gdb/mips-tdep.c b/gdb/mips-tdep.c index 6bd0a66a6284..ac90aa1f2c5f 100644 --- a/gdb/mips-tdep.c +++ b/gdb/mips-tdep.c @@ -8074,7 +8074,7 @@ static struct value * value_of_mips_user_reg (frame_info_ptr frame, const void *baton) { const int *reg_p = (const int *) baton; - return value_of_register (*reg_p, frame); + return value_of_register (*reg_p, get_next_frame_sentinel_okay (frame)); } static struct gdbarch * diff --git a/gdb/nds32-tdep.c b/gdb/nds32-tdep.c index a81b5fd1fae1..7618a81fc256 100644 --- a/gdb/nds32-tdep.c +++ b/gdb/nds32-tdep.c @@ -267,9 +267,10 @@ static const struct static struct value * value_of_nds32_reg (frame_info_ptr frame, const void *baton) { - return value_of_register ((int) (intptr_t) baton, frame); + return value_of_register ((int) (intptr_t) baton, + get_next_frame_sentinel_okay (frame)); } - + /* Implement the "frame_align" gdbarch method. */ static CORE_ADDR diff --git a/gdb/python/py-frame.c b/gdb/python/py-frame.c index 1a55e514e396..e6e245520323 100644 --- a/gdb/python/py-frame.c +++ b/gdb/python/py-frame.c @@ -260,7 +260,8 @@ frapy_read_register (PyObject *self, PyObject *args, PyObject *kw) return nullptr; gdb_assert (regnum >= 0); - struct value *val = value_of_register (regnum, frame); + value *val + = value_of_register (regnum, get_next_frame_sentinel_okay (frame)); if (val == NULL) PyErr_SetString (PyExc_ValueError, _("Can't read register.")); diff --git a/gdb/python/py-unwind.c b/gdb/python/py-unwind.c index ee50c51b531d..f1162f22290f 100644 --- a/gdb/python/py-unwind.c +++ b/gdb/python/py-unwind.c @@ -467,8 +467,8 @@ pending_framepy_read_register (PyObject *self, PyObject *args, PyObject *kw) which maps to a real register. In the past, get_frame_register_value() was used here, which did not handle the user register case. */ - struct value *val = value_of_register (regnum, - pending_frame->frame_info); + value *val = value_of_register + (regnum, get_next_frame_sentinel_okay (pending_frame->frame_info)); if (val == NULL) PyErr_Format (PyExc_ValueError, "Cannot read register %d from frame.", diff --git a/gdb/riscv-tdep.c b/gdb/riscv-tdep.c index 3a2891c2c920..48f5a9e35e67 100644 --- a/gdb/riscv-tdep.c +++ b/gdb/riscv-tdep.c @@ -168,7 +168,7 @@ static struct value * value_of_riscv_user_reg (frame_info_ptr frame, const void *baton) { const int *reg_p = (const int *) baton; - return value_of_register (*reg_p, frame); + return value_of_register (*reg_p, get_next_frame_sentinel_okay (frame)); } /* Information about a register alias that needs to be set up for this @@ -1149,7 +1149,7 @@ riscv_print_one_register_info (struct gdbarch *gdbarch, try { - val = value_of_register (regnum, frame); + val = value_of_register (regnum, get_next_frame_sentinel_okay (frame)); regtype = val->type (); } catch (const gdb_exception_error &ex) diff --git a/gdb/s12z-tdep.c b/gdb/s12z-tdep.c index 4781eab083eb..42fd1fb1d6ca 100644 --- a/gdb/s12z-tdep.c +++ b/gdb/s12z-tdep.c @@ -494,7 +494,7 @@ s12z_print_ccw_info (struct gdbarch *gdbarch, frame_info_ptr frame, int reg) { - struct value *v = value_of_register (reg, frame); + value *v = value_of_register (reg, get_next_frame_sentinel_okay (frame)); const char *name = gdbarch_register_name (gdbarch, reg); uint32_t ccw = value_as_long (v); gdb_puts (name, file); diff --git a/gdb/std-regs.c b/gdb/std-regs.c index 54cf9018e426..221b15f1de9f 100644 --- a/gdb/std-regs.c +++ b/gdb/std-regs.c @@ -39,7 +39,7 @@ value_of_builtin_frame_fp_reg (frame_info_ptr frame, const void *baton) register can do so by adding "fp" to register name table (mind you, doing this is probably a dangerous thing). */ return value_of_register (gdbarch_deprecated_fp_regnum (gdbarch), - frame); + get_next_frame_sentinel_okay (frame)); else { struct type *data_ptr_type = builtin_type (gdbarch)->builtin_data_ptr; @@ -58,7 +58,8 @@ value_of_builtin_frame_pc_reg (frame_info_ptr frame, const void *baton) struct gdbarch *gdbarch = get_frame_arch (frame); if (gdbarch_pc_regnum (gdbarch) >= 0) - return value_of_register (gdbarch_pc_regnum (gdbarch), frame); + return value_of_register (gdbarch_pc_regnum (gdbarch), + get_next_frame_sentinel_okay (frame)); else { struct type *func_ptr_type = builtin_type (gdbarch)->builtin_func_ptr; @@ -77,7 +78,8 @@ value_of_builtin_frame_sp_reg (frame_info_ptr frame, const void *baton) struct gdbarch *gdbarch = get_frame_arch (frame); if (gdbarch_sp_regnum (gdbarch) >= 0) - return value_of_register (gdbarch_sp_regnum (gdbarch), frame); + return value_of_register (gdbarch_sp_regnum (gdbarch), + get_next_frame_sentinel_okay (frame)); error (_("Standard register ``$sp'' is not available for this target")); } @@ -87,7 +89,8 @@ value_of_builtin_frame_ps_reg (frame_info_ptr frame, const void *baton) struct gdbarch *gdbarch = get_frame_arch (frame); if (gdbarch_ps_regnum (gdbarch) >= 0) - return value_of_register (gdbarch_ps_regnum (gdbarch), frame); + return value_of_register (gdbarch_ps_regnum (gdbarch), + get_next_frame_sentinel_okay (frame)); error (_("Standard register ``$ps'' is not available for this target")); } diff --git a/gdb/value.h b/gdb/value.h index e4912717684b..37017c9dd9f7 100644 --- a/gdb/value.h +++ b/gdb/value.h @@ -1123,9 +1123,14 @@ extern struct value *value_of_variable (struct symbol *var, extern struct value *address_of_variable (struct symbol *var, const struct block *b); -extern struct value *value_of_register (int regnum, frame_info_ptr frame); +/* Return a value with the contents of register REGNUM as found in the frame + previous to NEXT_FRAME. */ -struct value *value_of_register_lazy (frame_info_ptr frame, int regnum); +extern value *value_of_register (int regnum, frame_info_ptr next_frame); + +/* Same as the above, but the value is not fetched. */ + +extern value *value_of_register_lazy (frame_info_ptr next_frame, int regnum); /* Return the symbol's reading requirement. */ -- 2.42.1