From: Tom Tromey <tom@tromey.com>
To: gdb-patches@sourceware.org
Subject: [PATCH 27/47] Turn value_fetch_lazy into a method
Date: Thu, 09 Feb 2023 14:38:48 -0700 [thread overview]
Message-ID: <20230209-submit-value-fixups-2023-v1-27-55dc2794dbb9@tromey.com> (raw)
In-Reply-To: <20230209-submit-value-fixups-2023-v1-0-55dc2794dbb9@tromey.com>
This changes value_fetch_lazy to be a method of value.
---
gdb/ada-lang.c | 4 +--
gdb/ada-valprint.c | 2 +-
gdb/eval.c | 6 ++--
gdb/findvar.c | 2 +-
gdb/gnu-v2-abi.c | 2 +-
gdb/guile/scm-pretty-print.c | 2 +-
gdb/guile/scm-value.c | 2 +-
gdb/python/py-prettyprint.c | 2 +-
gdb/python/py-value.c | 2 +-
gdb/rust-lang.c | 2 +-
gdb/stack.c | 10 +++----
gdb/valops.c | 2 +-
gdb/valprint.c | 2 +-
gdb/value.c | 68 ++++++++++++++++++++------------------------
gdb/value.h | 11 +++++--
gdb/varobj.c | 2 +-
16 files changed, 61 insertions(+), 60 deletions(-)
diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c
index 274b5e3ce03..7f962200a1f 100644
--- a/gdb/ada-lang.c
+++ b/gdb/ada-lang.c
@@ -10853,7 +10853,7 @@ ada_var_msym_value_operation::evaluate_for_cast (struct type *expect_type,
if (VALUE_LVAL (val) == lval_memory)
{
if (val->lazy ())
- value_fetch_lazy (val);
+ val->fetch_lazy ();
VALUE_LVAL (val) = not_lval;
}
return val;
@@ -10875,7 +10875,7 @@ ada_var_value_operation::evaluate_for_cast (struct type *expect_type,
if (VALUE_LVAL (val) == lval_memory)
{
if (val->lazy ())
- value_fetch_lazy (val);
+ val->fetch_lazy ();
VALUE_LVAL (val) = not_lval;
}
return val;
diff --git a/gdb/ada-valprint.c b/gdb/ada-valprint.c
index 814678ea0e1..05d30649887 100644
--- a/gdb/ada-valprint.c
+++ b/gdb/ada-valprint.c
@@ -983,7 +983,7 @@ ada_val_print_ref (struct type *type, const gdb_byte *valaddr,
deref_val = ada_tag_value_at_base_address (deref_val);
if (deref_val->lazy ())
- value_fetch_lazy (deref_val);
+ deref_val->fetch_lazy ();
common_val_print (deref_val, stream, recurse + 1,
options, language_def (language_ada));
diff --git a/gdb/eval.c b/gdb/eval.c
index fbc72a5a34e..74ce57ac70c 100644
--- a/gdb/eval.c
+++ b/gdb/eval.c
@@ -212,7 +212,7 @@ fetch_subexp_value (struct expression *exp,
try
{
- value_fetch_lazy (result);
+ result->fetch_lazy ();
*valp = result;
}
catch (const gdb_exception_error &except)
@@ -2878,7 +2878,7 @@ var_msym_value_operation::evaluate_for_cast (struct type *to_type,
if (VALUE_LVAL (val) == lval_memory)
{
if (val->lazy ())
- value_fetch_lazy (val);
+ val->fetch_lazy ();
VALUE_LVAL (val) = not_lval;
}
return val;
@@ -2899,7 +2899,7 @@ var_value_operation::evaluate_for_cast (struct type *to_type,
if (VALUE_LVAL (val) == lval_memory)
{
if (val->lazy ())
- value_fetch_lazy (val);
+ val->fetch_lazy ();
VALUE_LVAL (val) = not_lval;
}
return val;
diff --git a/gdb/findvar.c b/gdb/findvar.c
index a64b35c2bcf..b4852b2cfb3 100644
--- a/gdb/findvar.c
+++ b/gdb/findvar.c
@@ -262,7 +262,7 @@ value_of_register (int regnum, frame_info_ptr frame)
return value_of_user_reg (regnum, frame);
reg_val = value_of_register_lazy (frame, regnum);
- value_fetch_lazy (reg_val);
+ reg_val->fetch_lazy ();
return reg_val;
}
diff --git a/gdb/gnu-v2-abi.c b/gdb/gnu-v2-abi.c
index 908581a2063..4636ad55109 100644
--- a/gdb/gnu-v2-abi.c
+++ b/gdb/gnu-v2-abi.c
@@ -164,7 +164,7 @@ gnuv2_virtual_fn_field (struct value **arg1p, struct fn_field * f, int j,
if (!arg1->lazy ())
{
arg1->set_lazy (1);
- value_fetch_lazy (arg1);
+ arg1->fetch_lazy ();
}
vfn = value_field (entry, 2);
diff --git a/gdb/guile/scm-pretty-print.c b/gdb/guile/scm-pretty-print.c
index 7a680c052d3..ca44133cd7f 100644
--- a/gdb/guile/scm-pretty-print.c
+++ b/gdb/guile/scm-pretty-print.c
@@ -966,7 +966,7 @@ gdbscm_apply_val_pretty_printer (const struct extension_language_defn *extlang,
enum guile_string_repr_result print_result;
if (value->lazy ())
- value_fetch_lazy (value);
+ value->fetch_lazy ();
/* No pretty-printer support for unavailable values. */
if (!value_bytes_available (value, 0, type->length ()))
diff --git a/gdb/guile/scm-value.c b/gdb/guile/scm-value.c
index 8f292c25851..195fd3b8912 100644
--- a/gdb/guile/scm-value.c
+++ b/gdb/guile/scm-value.c
@@ -1248,7 +1248,7 @@ gdbscm_value_fetch_lazy_x (SCM self)
return gdbscm_wrap ([=]
{
if (value->lazy ())
- value_fetch_lazy (value);
+ value->fetch_lazy ();
return SCM_UNSPECIFIED;
});
}
diff --git a/gdb/python/py-prettyprint.c b/gdb/python/py-prettyprint.c
index 0bd54dab5c6..18d2b7f5ba4 100644
--- a/gdb/python/py-prettyprint.c
+++ b/gdb/python/py-prettyprint.c
@@ -579,7 +579,7 @@ gdbpy_apply_val_pretty_printer (const struct extension_language_defn *extlang,
enum gdbpy_string_repr_result print_result;
if (value->lazy ())
- value_fetch_lazy (value);
+ value->fetch_lazy ();
/* No pretty-printer support for unavailable values. */
if (!value_bytes_available (value, 0, type->length ()))
diff --git a/gdb/python/py-value.c b/gdb/python/py-value.c
index 6a176c7efda..465d8d92bd2 100644
--- a/gdb/python/py-value.c
+++ b/gdb/python/py-value.c
@@ -1241,7 +1241,7 @@ valpy_fetch_lazy (PyObject *self, PyObject *args)
try
{
if (value->lazy ())
- value_fetch_lazy (value);
+ value->fetch_lazy ();
}
catch (const gdb_exception &except)
{
diff --git a/gdb/rust-lang.c b/gdb/rust-lang.c
index ff30babca75..cca2baa6f63 100644
--- a/gdb/rust-lang.c
+++ b/gdb/rust-lang.c
@@ -352,7 +352,7 @@ rust_val_print_slice (struct value *val, struct ui_file *stream, int recurse,
struct value *array = value::allocate_lazy (array_type);
VALUE_LVAL (array) = lval_memory;
array->set_address (value_as_address (base));
- value_fetch_lazy (array);
+ array->fetch_lazy ();
generic_value_print (array, stream, recurse, options,
&rust_decorations);
}
diff --git a/gdb/stack.c b/gdb/stack.c
index ca6087f3414..983c99e5860 100644
--- a/gdb/stack.c
+++ b/gdb/stack.c
@@ -581,9 +581,9 @@ read_frame_arg (const frame_print_options &fp_opts,
struct type *type = val->type ();
if (val->lazy ())
- value_fetch_lazy (val);
+ val->fetch_lazy ();
if (entryval->lazy ())
- value_fetch_lazy (entryval);
+ entryval->fetch_lazy ();
if (value_contents_eq (val, 0, entryval, 0, type->length ()))
{
@@ -600,12 +600,12 @@ read_frame_arg (const frame_print_options &fp_opts,
val_deref = coerce_ref (val);
if (val_deref->lazy ())
- value_fetch_lazy (val_deref);
+ val_deref->fetch_lazy ();
type_deref = val_deref->type ();
entryval_deref = coerce_ref (entryval);
if (entryval_deref->lazy ())
- value_fetch_lazy (entryval_deref);
+ entryval_deref->fetch_lazy ();
/* If the reference addresses match but dereferenced
content does not match print them. */
@@ -2750,7 +2750,7 @@ return_command (const char *retval_exp, int from_tty)
/* Make sure the value is fully evaluated. It may live in the
stack frame we're about to pop. */
if (return_value->lazy ())
- value_fetch_lazy (return_value);
+ return_value->fetch_lazy ();
if (thisfun != NULL)
function = read_var_value (thisfun, NULL, thisframe);
diff --git a/gdb/valops.c b/gdb/valops.c
index 738967cc88d..ceec461c483 100644
--- a/gdb/valops.c
+++ b/gdb/valops.c
@@ -992,7 +992,7 @@ get_value_at (struct type *type, CORE_ADDR addr, int lazy)
val = value_from_contents_and_address (type, NULL, addr);
if (!lazy)
- value_fetch_lazy (val);
+ val->fetch_lazy ();
return val;
}
diff --git a/gdb/valprint.c b/gdb/valprint.c
index 8c6973ca1f1..8b565955e1c 100644
--- a/gdb/valprint.c
+++ b/gdb/valprint.c
@@ -1044,7 +1044,7 @@ common_val_print (struct value *value, struct ui_file *stream, int recurse,
value = ada_to_fixed_value (value);
if (value->lazy ())
- value_fetch_lazy (value);
+ value->fetch_lazy ();
struct value_print_options local_opts = *options;
struct type *type = value->type ();
diff --git a/gdb/value.c b/gdb/value.c
index c22c7670a6a..57f57f38b26 100644
--- a/gdb/value.c
+++ b/gdb/value.c
@@ -199,7 +199,7 @@ value_entirely_available (struct value *value)
/* We can only tell whether the whole value is available when we try
to read it. */
if (value->m_lazy)
- value_fetch_lazy (value);
+ value->fetch_lazy ();
if (value->m_unavailable.empty ())
return 1;
@@ -217,7 +217,7 @@ value_entirely_covered_by_range_vector (struct value *value,
/* We can only tell whether the whole value is optimized out /
unavailable when we try to read it. */
if (value->m_lazy)
- value_fetch_lazy (value);
+ value->fetch_lazy ();
if (ranges.size () == 1)
{
@@ -986,7 +986,7 @@ gdb::array_view<const gdb_byte>
value_contents_for_printing (struct value *value)
{
if (value->m_lazy)
- value_fetch_lazy (value);
+ value->fetch_lazy ();
ULONGEST length = value->enclosing_type ()->length ();
return gdb::make_array_view (value->m_contents.get (), length);
@@ -1152,7 +1152,7 @@ value_contents_copy (struct value *dst, LONGEST dst_offset,
struct value *src, LONGEST src_offset, LONGEST length)
{
if (src->m_lazy)
- value_fetch_lazy (src);
+ src->fetch_lazy ();
value_contents_copy_raw (dst, dst_offset, src, src_offset, length);
}
@@ -1170,7 +1170,7 @@ gdb::array_view<gdb_byte>
value::contents_writeable ()
{
if (m_lazy)
- value_fetch_lazy (this);
+ fetch_lazy ();
return contents_raw ();
}
@@ -1194,7 +1194,7 @@ value_optimized_out (struct value *value)
/* Fall back to fetching. */
try
{
- value_fetch_lazy (value);
+ value->fetch_lazy ();
}
catch (const gdb_exception_error &ex)
{
@@ -1578,7 +1578,7 @@ record_latest_value (struct value *val)
the value was taken, and fast watchpoints should be able to assume that
a value on the value history never changes. */
if (val->lazy ())
- value_fetch_lazy (val);
+ val->fetch_lazy ();
/* We preserve VALUE_LVAL so that the user can find out where it was fetched
from. This is a bit dubious, because then *&$1 does not just return $1
but the current contents of that location. c'est la vie... */
@@ -1941,7 +1941,7 @@ value_of_internalvar (struct gdbarch *gdbarch, struct internalvar *var)
case INTERNALVAR_VALUE:
val = value_copy (var->u.value);
if (val->lazy ())
- value_fetch_lazy (val);
+ val->fetch_lazy ();
break;
case INTERNALVAR_MAKE_VALUE:
@@ -2081,7 +2081,7 @@ set_internalvar (struct internalvar *var, struct value *val)
later when this internalvar is referenced and the target is gone or
has changed. */
if (copy->lazy ())
- value_fetch_lazy (copy);
+ copy->fetch_lazy ();
/* Release the value from the value chain to prevent it from being
deleted by free_all_values. From here on this function should not
@@ -2794,7 +2794,7 @@ value_primitive_field (struct value *arg1, LONGEST offset,
+ (bitpos - v->m_bitpos) / 8);
v->set_parent (arg1);
if (!arg1->lazy ())
- value_fetch_lazy (v);
+ v->fetch_lazy ();
}
else if (fieldno < TYPE_N_BASECLASSES (arg_type))
{
@@ -2805,7 +2805,7 @@ value_primitive_field (struct value *arg1, LONGEST offset,
/* Lazy register values with offsets are not supported. */
if (VALUE_LVAL (arg1) == lval_register && arg1->lazy ())
- value_fetch_lazy (arg1);
+ arg1->fetch_lazy ();
/* We special case virtual inheritance here because this
requires access to the contents, which we would rather avoid
@@ -2850,7 +2850,7 @@ value_primitive_field (struct value *arg1, LONGEST offset,
/* Lazy register values with offsets are not supported. */
if (VALUE_LVAL (arg1) == lval_register && arg1->lazy ())
- value_fetch_lazy (arg1);
+ arg1->fetch_lazy ();
if (arg1->lazy ())
v = value::allocate_lazy (type);
@@ -3638,7 +3638,7 @@ value_fetch_lazy_bitfield (struct value *val)
struct value *parent = val->parent ();
if (parent->lazy ())
- value_fetch_lazy (parent);
+ parent->fetch_lazy ();
unpack_value_bitfield (val, val->bitpos (), val->bitsize (),
value_contents_for_printing (parent).data (),
@@ -3719,7 +3719,7 @@ value_fetch_lazy_register (struct value *val)
/* If it's still lazy (for instance, a saved register on the
stack), fetch it. */
if (new_val->lazy ())
- value_fetch_lazy (new_val);
+ new_val->fetch_lazy ();
/* Copy the contents and the unavailability/optimized-out
meta-data from NEW_VAL to VAL. */
@@ -3779,41 +3779,35 @@ value_fetch_lazy_register (struct value *val)
value_free_to_mark (mark);
}
-/* Load the actual content of a lazy value. Fetch the data from the
- user's process and clear the lazy flag to indicate that the data in
- the buffer is valid.
-
- If the value is zero-length, we avoid calling read_memory, which
- would abort. We mark the value as fetched anyway -- all 0 bytes of
- it. */
+/* See value.h. */
void
-value_fetch_lazy (struct value *val)
+value::fetch_lazy ()
{
- gdb_assert (val->lazy ());
- allocate_value_contents (val);
+ gdb_assert (lazy ());
+ allocate_value_contents (this);
/* A value is either lazy, or fully fetched. The
availability/validity is only established as we try to fetch a
value. */
- gdb_assert (val->m_optimized_out.empty ());
- gdb_assert (val->m_unavailable.empty ());
- if (val->m_is_zero)
+ gdb_assert (m_optimized_out.empty ());
+ gdb_assert (m_unavailable.empty ());
+ if (m_is_zero)
{
/* Nothing. */
}
- else if (val->bitsize ())
- value_fetch_lazy_bitfield (val);
- else if (VALUE_LVAL (val) == lval_memory)
- value_fetch_lazy_memory (val);
- else if (VALUE_LVAL (val) == lval_register)
- value_fetch_lazy_register (val);
- else if (VALUE_LVAL (val) == lval_computed
- && val->computed_funcs ()->read != NULL)
- val->computed_funcs ()->read (val);
+ else if (bitsize ())
+ value_fetch_lazy_bitfield (this);
+ else if (VALUE_LVAL (this) == lval_memory)
+ value_fetch_lazy_memory (this);
+ else if (VALUE_LVAL (this) == lval_register)
+ value_fetch_lazy_register (this);
+ else if (VALUE_LVAL (this) == lval_computed
+ && computed_funcs ()->read != NULL)
+ computed_funcs ()->read (this);
else
internal_error (_("Unexpected lazy value type."));
- val->set_lazy (0);
+ set_lazy (0);
}
/* Implementation of the convenience function $_isvoid. */
diff --git a/gdb/value.h b/gdb/value.h
index 4f161a9ed4f..23fffb18158 100644
--- a/gdb/value.h
+++ b/gdb/value.h
@@ -387,6 +387,15 @@ struct value
gdb::array_view<gdb_byte> contents_all_raw ();
gdb::array_view<gdb_byte> contents_writeable ();
+ /* Load the actual content of a lazy value. Fetch the data from the
+ user's process and clear the lazy flag to indicate that the data in
+ the buffer is valid.
+
+ If the value is zero-length, we avoid calling read_memory, which
+ would abort. We mark the value as fetched anyway -- all 0 bytes of
+ it. */
+ void fetch_lazy ();
+
/* Type of value; either not an lval, or one of the various
different possible kinds of lval. */
@@ -660,8 +669,6 @@ extern gdb::array_view<const gdb_byte> value_contents_for_printing (struct value
extern gdb::array_view<const gdb_byte>
value_contents_for_printing_const (const struct value *value);
-extern void value_fetch_lazy (struct value *val);
-
/* If nonzero, this is the value of a variable which does not actually
exist in the program, at least partially. If the value is lazy,
this may fetch it now. */
diff --git a/gdb/varobj.c b/gdb/varobj.c
index 0e023c09cf8..72d5e7f2a25 100644
--- a/gdb/varobj.c
+++ b/gdb/varobj.c
@@ -1268,7 +1268,7 @@ install_new_value (struct varobj *var, struct value *value, bool initial)
try
{
- value_fetch_lazy (value);
+ value->fetch_lazy ();
}
catch (const gdb_exception_error &except)
--
2.39.1
next prev parent reply other threads:[~2023-02-09 21:38 UTC|newest]
Thread overview: 60+ messages / expand[flat|nested] mbox.gz Atom feed top
2023-02-09 21:38 [PATCH 00/47] Use methods for struct value Tom Tromey
2023-02-09 21:38 ` [PATCH 01/47] Rename all fields of " Tom Tromey
2023-02-10 21:05 ` Tom Tromey
2023-02-09 21:38 ` [PATCH 02/47] Move ~value body out-of-line Tom Tromey
2023-02-09 21:38 ` [PATCH 03/47] Move struct value to value.h Tom Tromey
2023-02-09 21:38 ` [PATCH 04/47] Turn value_type into method Tom Tromey
2023-02-09 21:38 ` [PATCH 05/47] Turn deprecated_set_value_type into a method Tom Tromey
2023-02-09 21:38 ` [PATCH 06/47] Turn value_arch into method Tom Tromey
2023-02-10 2:08 ` Simon Marchi
2023-02-10 16:36 ` Tom Tromey
2023-02-09 21:38 ` [PATCH 07/47] Turn value_bitsize " Tom Tromey
2023-02-09 21:38 ` [PATCH 08/47] Turn value_bitpos " Tom Tromey
2023-02-09 21:38 ` [PATCH 09/47] Turn value_parent " Tom Tromey
2023-02-09 21:38 ` [PATCH 10/47] Turn value_offset " Tom Tromey
2023-02-09 21:38 ` [PATCH 11/47] Turn deprecated_value_modifiable " Tom Tromey
2023-02-09 21:38 ` [PATCH 12/47] Turn value_enclosing_type " Tom Tromey
2023-02-09 21:38 ` [PATCH 13/47] Turn some value offset functions " Tom Tromey
2023-02-09 21:38 ` [PATCH 14/47] Turn value_lazy and set_value_lazy functions into methods Tom Tromey
2023-02-09 21:38 ` [PATCH 15/47] Turn value_stack and set_value_stack " Tom Tromey
2023-02-09 21:38 ` [PATCH 16/47] Turn value_computed_closure and value_computed_funcs " Tom Tromey
2023-02-09 21:38 ` [PATCH 17/47] Convert value_lval_const and deprecated_lval_hack to methods Tom Tromey
2023-02-09 21:38 ` [PATCH 18/47] Turn value_initialized and set_value_initialized functions into methods Tom Tromey
2023-02-09 21:38 ` [PATCH 19/47] Turn value_address and set_value_address " Tom Tromey
2023-02-09 21:38 ` [PATCH 20/47] Turn more deprecated_* " Tom Tromey
2023-02-09 21:38 ` [PATCH 21/47] Turn allocate_value_lazy into a static "constructor" Tom Tromey
2023-02-09 21:38 ` [PATCH 22/47] Turn allocate_value " Tom Tromey
2023-02-09 21:38 ` [PATCH 23/47] Turn allocate_computed_value into " Tom Tromey
2023-02-09 21:38 ` [PATCH 24/47] Turn allocate_optimized_out_value " Tom Tromey
2023-02-09 21:38 ` [PATCH 25/47] Turn value_zero " Tom Tromey
2023-02-09 21:38 ` [PATCH 26/47] Turn some value_contents functions into methods Tom Tromey
2023-02-09 21:38 ` Tom Tromey [this message]
2023-02-09 21:38 ` [PATCH 28/47] Turn allocate_value_contents into a method Tom Tromey
2023-02-09 21:38 ` [PATCH 29/47] Turn value_contents_eq " Tom Tromey
2023-02-10 2:18 ` Simon Marchi
2023-02-10 17:46 ` Tom Tromey
2023-02-09 21:38 ` [PATCH 30/47] Turn value_bits_synthetic_pointer " Tom Tromey
2023-02-09 21:38 ` [PATCH 31/47] Move value_ref_policy methods out-of-line Tom Tromey
2023-02-09 21:38 ` [PATCH 32/47] Turn value_incref and value_decref into methods Tom Tromey
2023-02-09 21:38 ` [PATCH 33/47] Turn remaining value_contents functions " Tom Tromey
2023-02-10 2:24 ` Simon Marchi
2023-02-10 17:46 ` Tom Tromey
2023-02-09 21:38 ` [PATCH 34/47] Fully qualify calls to copy in value.c Tom Tromey
2023-02-09 21:38 ` [PATCH 35/47] Turn value_copy into a method Tom Tromey
2023-02-10 2:42 ` Simon Marchi
2023-02-10 18:03 ` Tom Tromey
2023-02-09 21:38 ` [PATCH 36/47] Turn many optimized-out value functions into methods Tom Tromey
2023-02-09 21:38 ` [PATCH 37/47] Turn value_non_lval and value_force_lval " Tom Tromey
2023-02-09 21:38 ` [PATCH 38/47] Turn set_value_component_location into method Tom Tromey
2023-02-09 21:39 ` [PATCH 39/47] Change some code to use value methods Tom Tromey
2023-02-09 21:39 ` [PATCH 40/47] Turn some xmethod functions into methods Tom Tromey
2023-02-09 21:39 ` [PATCH 41/47] Turn preserve_one_value into method Tom Tromey
2023-02-09 21:39 ` [PATCH 42/47] Turn various value copying-related functions into methods Tom Tromey
2023-02-10 20:20 ` Tom Tromey
2023-02-09 21:39 ` [PATCH 43/47] Add value::set_modifiable Tom Tromey
2023-02-09 21:39 ` [PATCH 44/47] Make struct value data members private Tom Tromey
2023-02-09 21:39 ` [PATCH 45/47] Make ~value private Tom Tromey
2023-02-09 21:39 ` [PATCH 46/47] Introduce set_lval method on value Tom Tromey
2023-02-09 21:39 ` [PATCH 47/47] Remove deprecated_lval_hack Tom Tromey
2023-02-10 2:54 ` [PATCH 00/47] Use methods for struct value Simon Marchi
2023-02-10 18:08 ` Tom Tromey
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20230209-submit-value-fixups-2023-v1-27-55dc2794dbb9@tromey.com \
--to=tom@tromey.com \
--cc=gdb-patches@sourceware.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).