[PATCHv3] gdb: building inferior strings from within GDB
Commit Message
History Of This Patch
=====================
This commit aims to address PR gdb/21699. There have now been a
couple of attempts to fix this issue. Simon originally posted two
patches back in 2021:
https://sourceware.org/pipermail/gdb-patches/2021-July/180894.html
https://sourceware.org/pipermail/gdb-patches/2021-July/180896.html
Before Pedro then posted a version of his own:
https://sourceware.org/pipermail/gdb-patches/2021-July/180970.html
After this the conversation halted. Then in 2023 I (Andrew) also took
a look at this bug and posted two versions:
https://sourceware.org/pipermail/gdb-patches/2023-April/198570.html
https://sourceware.org/pipermail/gdb-patches/2023-April/198680.html
The approach taken in my first patch was pretty similar to what Simon
originally posted back in 2021. My second attempt was only a slight
variation on the first.
Pedro then pointed out his older patch, and so we arrive at this
patch. The GDB changes here are mostly Pedro's work, but updated by
me (Andrew), any mistakes are mine.
The tests here are a combinations of everyone's work, and the commit
message is new, but copies bits from everyone's earlier work.
Problem Description
===================
Bug PR gdb/21699 makes the observation that using $_as_string with
GDB's printf can cause GDB to print unexpected data from the
inferior. The reproducer is pretty simple:
#include <stddef.h>
static char arena[100];
/* Override malloc() so value_coerce_to_target() gets a known
pointer, and we know we"ll see an error if $_as_string() gives
a string that isn't null terminated. */
void
*malloc (size_t size)
{
memset (arena, 'x', sizeof (arena));
if (size > sizeof (arena))
return NULL;
return arena;
}
int
main ()
{
return 0;
}
And then in a GDB session:
$ gdb -q test
Reading symbols from /tmp/test...
(gdb) start
Temporary breakpoint 1 at 0x4004c8: file test.c, line 17.
Starting program: /tmp/test
Temporary breakpoint 1, main () at test.c:17
17 return 0;
(gdb) printf "%s\n", $_as_string("hello")
"hello"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
(gdb) quit
The problem above is caused by how value_cstring is used within
py-value.c, but once we understand the issue then it turns out that
value_cstring is used in an unexpected way in many places within GDB.
Within py-value.c we have a null-terminated C-style string. We then
pass a pointer to this string, along with the length of this
string (so not including the null-character) to value_cstring.
In value_cstring GDB allocates an array value of the given character
type, and copies in requested number of characters. However
value_cstring does not add a null-character of its own. This means
that the value created by calling value_cstring is only
null-terminated if the null-character is included in the passed in
length. In py-value.c this is not the case, and indeed, in most uses
of value_cstring, this is not the case.
When GDB tries to print one of these strings the value contents are
pushed to the inferior, and then read back as a C-style string, that
is, GDB reads inferior memory until it finds a null-terminator. For
the py-value.c case, no null-terminator is pushed into the inferior,
so GDB will continue reading inferior memory until a null-terminator
is found, with unpredictable results.
Patch Description
=================
The first thing this patch does is better define what the arguments
for the two function value_cstring and value_string should represent.
The comments in the header file are updated to describe whether the
length argument should, or should not, include a null-character.
Also, the data argument is changed to type gdb_byte. The functions as
they currently exist will handle wide-characters, in which case more
than one 'char' would be needed for each character. As such using
gdb_byte seems to make more sense.
To avoid adding casts throughout GDB, I've also added an overload that
still takes a 'char *', but asserts that the character type being used
is of size '1'.
The value_cstring function is now responsible for adding a null
character at the end of the string value it creates.
However, once we start looking at how value_cstring is used, we
realise there's another, related, problem. Not every language's
strings are null terminated. Fortran and Ada strings, for example,
are just an array of characters, GDB already has the function
value_string which can be used to create such values.
Consider this example using current GDB:
(gdb) set language ada
(gdb) p $_gdb_setting("arch")
$1 = (97, 117, 116, 111)
(gdb) ptype $
type = array (1 .. 4) of char
(gdb) p $_gdb_maint_setting("test-settings string")
$2 = (0)
(gdb) ptype $
type = array (1 .. 1) of char
This shows two problems, first, the $_gdb_setting and
$_gdb_maint_setting functions are calling value_cstring using the
builtin_char character, rather than a language appropriate type. In
the first call, the 'arch' case, the value_cstring call doesn't
include the null character, so the returned array only contains the
expected characters. But, in the $_gdb_maint_setting example we do
end up including the null-character, even though this is not expected
for Ada strings.
This commit adds a new language method language_defn::value_string,
this function takes a pointer and length and creates a language
appropriate value that represents the string. For C, C++, etc this
will be a null-terminated string (by calling value_cstring), and for
Fortran and Ada this can be a bounded array of characters with no null
terminator. Additionally, this new language_defn::value_string
function is responsible for selecting a language appropriate character
type.
After this commit the only calls to value_cstring are from the C
expression evaluator and from the default language_defn::value_string.
And the only calls to value_string are from Fortan, Ada, and ObjectC
related code.
Bug: https://sourceware.org/bugzilla/show_bug.cgi?id=21699
Co-Authored-By: Simon Marchi <simon.marchi@efficios.com>
Co-Authored-By: Andrew Burgess <aburgess@redhat.com>
Co-Authored-By: Pedro Alves <pedro@palves.net>
---
gdb/ada-lang.c | 13 +
gdb/c-lang.c | 14 +-
gdb/cli/cli-cmds.c | 16 +-
gdb/f-lang.c | 10 +
gdb/f-lang.h | 5 +
gdb/guile/scm-math.c | 4 +-
gdb/language.c | 10 +
gdb/language.h | 6 +
gdb/python/py-value.c | 8 +-
.../gdb.base/internal-string-values.c | 32 ++
.../gdb.base/internal-string-values.exp | 279 ++++++++++++++++++
.../gdb.base/print-internal-string.c | 56 ++++
.../gdb.base/print-internal-string.exp | 64 ++++
gdb/testsuite/gdb.base/settings.exp | 2 +-
gdb/testsuite/gdb.python/py-mi.exp | 2 +-
gdb/valops.c | 23 +-
gdb/value.c | 5 +-
gdb/value.h | 41 ++-
18 files changed, 546 insertions(+), 44 deletions(-)
create mode 100644 gdb/testsuite/gdb.base/internal-string-values.c
create mode 100644 gdb/testsuite/gdb.base/internal-string-values.exp
create mode 100644 gdb/testsuite/gdb.base/print-internal-string.c
create mode 100644 gdb/testsuite/gdb.base/print-internal-string.exp
base-commit: e84060b489746d031ed1ec9e7b6b39fdf4b6cfe3
Comments
On 5/24/23 10:10, Andrew Burgess wrote:
> History Of This Patch
> =====================
>
> This commit aims to address PR gdb/21699. There have now been a
> couple of attempts to fix this issue. Simon originally posted two
> patches back in 2021:
>
> https://sourceware.org/pipermail/gdb-patches/2021-July/180894.html
> https://sourceware.org/pipermail/gdb-patches/2021-July/180896.html
>
> Before Pedro then posted a version of his own:
>
> https://sourceware.org/pipermail/gdb-patches/2021-July/180970.html
>
> After this the conversation halted. Then in 2023 I (Andrew) also took
> a look at this bug and posted two versions:
>
> https://sourceware.org/pipermail/gdb-patches/2023-April/198570.html
> https://sourceware.org/pipermail/gdb-patches/2023-April/198680.html
>
> The approach taken in my first patch was pretty similar to what Simon
> originally posted back in 2021. My second attempt was only a slight
> variation on the first.
>
> Pedro then pointed out his older patch, and so we arrive at this
> patch. The GDB changes here are mostly Pedro's work, but updated by
> me (Andrew), any mistakes are mine.
>
> The tests here are a combinations of everyone's work, and the commit
> message is new, but copies bits from everyone's earlier work.
>
> Problem Description
> ===================
>
> Bug PR gdb/21699 makes the observation that using $_as_string with
> GDB's printf can cause GDB to print unexpected data from the
> inferior. The reproducer is pretty simple:
>
> #include <stddef.h>
> static char arena[100];
>
> /* Override malloc() so value_coerce_to_target() gets a known
> pointer, and we know we"ll see an error if $_as_string() gives
> a string that isn't null terminated. */
> void
> *malloc (size_t size)
> {
> memset (arena, 'x', sizeof (arena));
> if (size > sizeof (arena))
> return NULL;
> return arena;
> }
>
> int
> main ()
> {
> return 0;
> }
>
> And then in a GDB session:
>
> $ gdb -q test
> Reading symbols from /tmp/test...
> (gdb) start
> Temporary breakpoint 1 at 0x4004c8: file test.c, line 17.
> Starting program: /tmp/test
>
> Temporary breakpoint 1, main () at test.c:17
> 17 return 0;
> (gdb) printf "%s\n", $_as_string("hello")
> "hello"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
> (gdb) quit
>
> The problem above is caused by how value_cstring is used within
> py-value.c, but once we understand the issue then it turns out that
> value_cstring is used in an unexpected way in many places within GDB.
>
> Within py-value.c we have a null-terminated C-style string. We then
> pass a pointer to this string, along with the length of this
> string (so not including the null-character) to value_cstring.
>
> In value_cstring GDB allocates an array value of the given character
> type, and copies in requested number of characters. However
> value_cstring does not add a null-character of its own. This means
> that the value created by calling value_cstring is only
> null-terminated if the null-character is included in the passed in
> length. In py-value.c this is not the case, and indeed, in most uses
> of value_cstring, this is not the case.
>
> When GDB tries to print one of these strings the value contents are
> pushed to the inferior, and then read back as a C-style string, that
> is, GDB reads inferior memory until it finds a null-terminator. For
> the py-value.c case, no null-terminator is pushed into the inferior,
> so GDB will continue reading inferior memory until a null-terminator
> is found, with unpredictable results.
>
> Patch Description
> =================
>
> The first thing this patch does is better define what the arguments
> for the two function value_cstring and value_string should represent.
> The comments in the header file are updated to describe whether the
> length argument should, or should not, include a null-character.
> Also, the data argument is changed to type gdb_byte. The functions as
> they currently exist will handle wide-characters, in which case more
> than one 'char' would be needed for each character. As such using
> gdb_byte seems to make more sense.
>
> To avoid adding casts throughout GDB, I've also added an overload that
> still takes a 'char *', but asserts that the character type being used
> is of size '1'.
>
> The value_cstring function is now responsible for adding a null
> character at the end of the string value it creates.
>
> However, once we start looking at how value_cstring is used, we
> realise there's another, related, problem. Not every language's
> strings are null terminated. Fortran and Ada strings, for example,
> are just an array of characters, GDB already has the function
> value_string which can be used to create such values.
>
> Consider this example using current GDB:
>
> (gdb) set language ada
> (gdb) p $_gdb_setting("arch")
> $1 = (97, 117, 116, 111)
> (gdb) ptype $
> type = array (1 .. 4) of char
> (gdb) p $_gdb_maint_setting("test-settings string")
> $2 = (0)
> (gdb) ptype $
> type = array (1 .. 1) of char
>
> This shows two problems, first, the $_gdb_setting and
> $_gdb_maint_setting functions are calling value_cstring using the
> builtin_char character, rather than a language appropriate type. In
> the first call, the 'arch' case, the value_cstring call doesn't
> include the null character, so the returned array only contains the
> expected characters. But, in the $_gdb_maint_setting example we do
> end up including the null-character, even though this is not expected
> for Ada strings.
>
> This commit adds a new language method language_defn::value_string,
> this function takes a pointer and length and creates a language
> appropriate value that represents the string. For C, C++, etc this
> will be a null-terminated string (by calling value_cstring), and for
> Fortran and Ada this can be a bounded array of characters with no null
> terminator. Additionally, this new language_defn::value_string
> function is responsible for selecting a language appropriate character
> type.
>
> After this commit the only calls to value_cstring are from the C
> expression evaluator and from the default language_defn::value_string.
>
> And the only calls to value_string are from Fortan, Ada, and ObjectC
> related code.
>
> Bug: https://sourceware.org/bugzilla/show_bug.cgi?id=21699
>
> Co-Authored-By: Simon Marchi <simon.marchi@efficios.com>
> Co-Authored-By: Andrew Burgess <aburgess@redhat.com>
> Co-Authored-By: Pedro Alves <pedro@palves.net>
This LGTM:
Approved-By: Simon Marchi <simon.marchi@efficios.com>
Just one small question:
> diff --git a/gdb/cli/cli-cmds.c b/gdb/cli/cli-cmds.c
> index b7b65303a0b..3fa833d596c 100644
> --- a/gdb/cli/cli-cmds.c
> +++ b/gdb/cli/cli-cmds.c
> @@ -2316,11 +2316,9 @@ value_from_setting (const setting &var, struct gdbarch *gdbarch)
> }
>
> if (len > 0)
> - return value_cstring (value, len,
> - builtin_type (gdbarch)->builtin_char);
> + return current_language->value_string (gdbarch, value, len);
> else
> - return value_cstring ("", 1,
> - builtin_type (gdbarch)->builtin_char);
> + return current_language->value_string (gdbarch, "", 0);
Do we still need the two calls, or can we just do with the first (even
when len is 0)? Same idea for str_value_from_setting.
Simon
Simon Marchi <simark@simark.ca> writes:
> On 5/24/23 10:10, Andrew Burgess wrote:
>> History Of This Patch
>> =====================
>>
>> This commit aims to address PR gdb/21699. There have now been a
>> couple of attempts to fix this issue. Simon originally posted two
>> patches back in 2021:
>>
>> https://sourceware.org/pipermail/gdb-patches/2021-July/180894.html
>> https://sourceware.org/pipermail/gdb-patches/2021-July/180896.html
>>
>> Before Pedro then posted a version of his own:
>>
>> https://sourceware.org/pipermail/gdb-patches/2021-July/180970.html
>>
>> After this the conversation halted. Then in 2023 I (Andrew) also took
>> a look at this bug and posted two versions:
>>
>> https://sourceware.org/pipermail/gdb-patches/2023-April/198570.html
>> https://sourceware.org/pipermail/gdb-patches/2023-April/198680.html
>>
>> The approach taken in my first patch was pretty similar to what Simon
>> originally posted back in 2021. My second attempt was only a slight
>> variation on the first.
>>
>> Pedro then pointed out his older patch, and so we arrive at this
>> patch. The GDB changes here are mostly Pedro's work, but updated by
>> me (Andrew), any mistakes are mine.
>>
>> The tests here are a combinations of everyone's work, and the commit
>> message is new, but copies bits from everyone's earlier work.
>>
>> Problem Description
>> ===================
>>
>> Bug PR gdb/21699 makes the observation that using $_as_string with
>> GDB's printf can cause GDB to print unexpected data from the
>> inferior. The reproducer is pretty simple:
>>
>> #include <stddef.h>
>> static char arena[100];
>>
>> /* Override malloc() so value_coerce_to_target() gets a known
>> pointer, and we know we"ll see an error if $_as_string() gives
>> a string that isn't null terminated. */
>> void
>> *malloc (size_t size)
>> {
>> memset (arena, 'x', sizeof (arena));
>> if (size > sizeof (arena))
>> return NULL;
>> return arena;
>> }
>>
>> int
>> main ()
>> {
>> return 0;
>> }
>>
>> And then in a GDB session:
>>
>> $ gdb -q test
>> Reading symbols from /tmp/test...
>> (gdb) start
>> Temporary breakpoint 1 at 0x4004c8: file test.c, line 17.
>> Starting program: /tmp/test
>>
>> Temporary breakpoint 1, main () at test.c:17
>> 17 return 0;
>> (gdb) printf "%s\n", $_as_string("hello")
>> "hello"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
>> (gdb) quit
>>
>> The problem above is caused by how value_cstring is used within
>> py-value.c, but once we understand the issue then it turns out that
>> value_cstring is used in an unexpected way in many places within GDB.
>>
>> Within py-value.c we have a null-terminated C-style string. We then
>> pass a pointer to this string, along with the length of this
>> string (so not including the null-character) to value_cstring.
>>
>> In value_cstring GDB allocates an array value of the given character
>> type, and copies in requested number of characters. However
>> value_cstring does not add a null-character of its own. This means
>> that the value created by calling value_cstring is only
>> null-terminated if the null-character is included in the passed in
>> length. In py-value.c this is not the case, and indeed, in most uses
>> of value_cstring, this is not the case.
>>
>> When GDB tries to print one of these strings the value contents are
>> pushed to the inferior, and then read back as a C-style string, that
>> is, GDB reads inferior memory until it finds a null-terminator. For
>> the py-value.c case, no null-terminator is pushed into the inferior,
>> so GDB will continue reading inferior memory until a null-terminator
>> is found, with unpredictable results.
>>
>> Patch Description
>> =================
>>
>> The first thing this patch does is better define what the arguments
>> for the two function value_cstring and value_string should represent.
>> The comments in the header file are updated to describe whether the
>> length argument should, or should not, include a null-character.
>> Also, the data argument is changed to type gdb_byte. The functions as
>> they currently exist will handle wide-characters, in which case more
>> than one 'char' would be needed for each character. As such using
>> gdb_byte seems to make more sense.
>>
>> To avoid adding casts throughout GDB, I've also added an overload that
>> still takes a 'char *', but asserts that the character type being used
>> is of size '1'.
>>
>> The value_cstring function is now responsible for adding a null
>> character at the end of the string value it creates.
>>
>> However, once we start looking at how value_cstring is used, we
>> realise there's another, related, problem. Not every language's
>> strings are null terminated. Fortran and Ada strings, for example,
>> are just an array of characters, GDB already has the function
>> value_string which can be used to create such values.
>>
>> Consider this example using current GDB:
>>
>> (gdb) set language ada
>> (gdb) p $_gdb_setting("arch")
>> $1 = (97, 117, 116, 111)
>> (gdb) ptype $
>> type = array (1 .. 4) of char
>> (gdb) p $_gdb_maint_setting("test-settings string")
>> $2 = (0)
>> (gdb) ptype $
>> type = array (1 .. 1) of char
>>
>> This shows two problems, first, the $_gdb_setting and
>> $_gdb_maint_setting functions are calling value_cstring using the
>> builtin_char character, rather than a language appropriate type. In
>> the first call, the 'arch' case, the value_cstring call doesn't
>> include the null character, so the returned array only contains the
>> expected characters. But, in the $_gdb_maint_setting example we do
>> end up including the null-character, even though this is not expected
>> for Ada strings.
>>
>> This commit adds a new language method language_defn::value_string,
>> this function takes a pointer and length and creates a language
>> appropriate value that represents the string. For C, C++, etc this
>> will be a null-terminated string (by calling value_cstring), and for
>> Fortran and Ada this can be a bounded array of characters with no null
>> terminator. Additionally, this new language_defn::value_string
>> function is responsible for selecting a language appropriate character
>> type.
>>
>> After this commit the only calls to value_cstring are from the C
>> expression evaluator and from the default language_defn::value_string.
>>
>> And the only calls to value_string are from Fortan, Ada, and ObjectC
>> related code.
>>
>> Bug: https://sourceware.org/bugzilla/show_bug.cgi?id=21699
>>
>> Co-Authored-By: Simon Marchi <simon.marchi@efficios.com>
>> Co-Authored-By: Andrew Burgess <aburgess@redhat.com>
>> Co-Authored-By: Pedro Alves <pedro@palves.net>
>
> This LGTM:
>
> Approved-By: Simon Marchi <simon.marchi@efficios.com>
>
> Just one small question:
>
>> diff --git a/gdb/cli/cli-cmds.c b/gdb/cli/cli-cmds.c
>> index b7b65303a0b..3fa833d596c 100644
>> --- a/gdb/cli/cli-cmds.c
>> +++ b/gdb/cli/cli-cmds.c
>> @@ -2316,11 +2316,9 @@ value_from_setting (const setting &var, struct gdbarch *gdbarch)
>> }
>>
>> if (len > 0)
>> - return value_cstring (value, len,
>> - builtin_type (gdbarch)->builtin_char);
>> + return current_language->value_string (gdbarch, value, len);
>> else
>> - return value_cstring ("", 1,
>> - builtin_type (gdbarch)->builtin_char);
>> + return current_language->value_string (gdbarch, "", 0);
>
> Do we still need the two calls, or can we just do with the first (even
> when len is 0)? Same idea for str_value_from_setting.
You are right. I merged these two calls, and the other two in
str_value_from_setting, and pushed this patch.
Thanks,
Andrew
On 6/5/23 08:26, Andrew Burgess via Gdb-patches wrote:
> You are right. I merged these two calls, and the other two in
> str_value_from_setting, and pushed this patch.
Turns out this test triggers an ASan error:
(gdb) PASS: gdb.base/internal-string-values.exp: test_setting: all langs: lang=ada: ptype "foo"
print $_gdb_maint_setting("test-settings string")
=================================================================
==80377==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x603000068034 at pc 0x564785cba682 bp 0x7ffd20644620 sp 0x7ffd20644610
READ of size 1 at 0x603000068034 thread T0
#0 0x564785cba681 in find_command_name_length(char const*) /home/smarchi/src/binutils-gdb/gdb/cli/cli-decode.c:2129
#1 0x564785cbacb2 in lookup_cmd_1(char const**, cmd_list_element*, cmd_list_element**, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*, int, bool) /home/smarchi/src/binutils-gdb/gdb/cli/cli-decode.c:2186
#2 0x564785cbb539 in lookup_cmd_1(char const**, cmd_list_element*, cmd_list_element**, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*, int, bool) /home/smarchi/src/binutils-gdb/gdb/cli/cli-decode.c:2248
#3 0x564785cbbcf3 in lookup_cmd(char const**, cmd_list_element*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*, int, int) /home/smarchi/src/binutils-gdb/gdb/cli/cli-decode.c:2339
#4 0x564785c82df2 in setting_cmd /home/smarchi/src/binutils-gdb/gdb/cli/cli-cmds.c:2219
#5 0x564785c84274 in gdb_maint_setting_internal_fn /home/smarchi/src/binutils-gdb/gdb/cli/cli-cmds.c:2348
#6 0x564788167b3b in call_internal_function(gdbarch*, language_defn const*, value*, int, value**) /home/smarchi/src/binutils-gdb/gdb/value.c:2321
#7 0x5647854b6ebd in expr::ada_funcall_operation::evaluate(type*, expression*, noside) /home/smarchi/src/binutils-gdb/gdb/ada-lang.c:11254
#8 0x564786658266 in expression::evaluate(type*, noside) /home/smarchi/src/binutils-gdb/gdb/eval.c:111
#9 0x5647871242d6 in process_print_command_args /home/smarchi/src/binutils-gdb/gdb/printcmd.c:1322
#10 0x5647871244b3 in print_command_1 /home/smarchi/src/binutils-gdb/gdb/printcmd.c:1335
#11 0x564787125384 in print_command /home/smarchi/src/binutils-gdb/gdb/printcmd.c:1468
#12 0x564785caac44 in do_simple_func /home/smarchi/src/binutils-gdb/gdb/cli/cli-decode.c:95
#13 0x564785cc18f0 in cmd_func(cmd_list_element*, char const*, int) /home/smarchi/src/binutils-gdb/gdb/cli/cli-decode.c:2735
#14 0x564787c70c68 in execute_command(char const*, int) /home/smarchi/src/binutils-gdb/gdb/top.c:574
#15 0x564786686180 in command_handler(char const*) /home/smarchi/src/binutils-gdb/gdb/event-top.c:543
#16 0x56478668752f in command_line_handler(std::unique_ptr<char, gdb::xfree_deleter<char> >&&) /home/smarchi/src/binutils-gdb/gdb/event-top.c:779
#17 0x564787dcb29a in tui_command_line_handler /home/smarchi/src/binutils-gdb/gdb/tui/tui-interp.c:104
#18 0x56478668443d in gdb_rl_callback_handler /home/smarchi/src/binutils-gdb/gdb/event-top.c:250
#19 0x7f4efd506246 in rl_callback_read_char (/usr/lib/libreadline.so.8+0x3b246) (BuildId: 092e91fc4361b0ef94561e3ae03a75f69398acbb)
#20 0x564786683dea in gdb_rl_callback_read_char_wrapper_noexcept /home/smarchi/src/binutils-gdb/gdb/event-top.c:192
#21 0x564786684042 in gdb_rl_callback_read_char_wrapper /home/smarchi/src/binutils-gdb/gdb/event-top.c:225
#22 0x564787f1b119 in stdin_event_handler /home/smarchi/src/binutils-gdb/gdb/ui.c:155
#23 0x56478862438d in handle_file_event /home/smarchi/src/binutils-gdb/gdbsupport/event-loop.cc:573
#24 0x564788624d23 in gdb_wait_for_event /home/smarchi/src/binutils-gdb/gdbsupport/event-loop.cc:694
#25 0x56478862297c in gdb_do_one_event(int) /home/smarchi/src/binutils-gdb/gdbsupport/event-loop.cc:264
#26 0x564786df99f0 in start_event_loop /home/smarchi/src/binutils-gdb/gdb/main.c:412
#27 0x564786dfa069 in captured_command_loop /home/smarchi/src/binutils-gdb/gdb/main.c:476
#28 0x564786dff61f in captured_main /home/smarchi/src/binutils-gdb/gdb/main.c:1320
#29 0x564786dff75c in gdb_main(captured_main_args*) /home/smarchi/src/binutils-gdb/gdb/main.c:1339
#30 0x564785381b6d in main /home/smarchi/src/binutils-gdb/gdb/gdb.c:32
#31 0x7f4efbc3984f (/usr/lib/libc.so.6+0x2384f) (BuildId: 2f005a79cd1a8e385972f5a102f16adba414d75e)
#32 0x7f4efbc39909 in __libc_start_main (/usr/lib/libc.so.6+0x23909) (BuildId: 2f005a79cd1a8e385972f5a102f16adba414d75e)
#33 0x564785381934 in _start (/home/smarchi/build/binutils-gdb/gdb/gdb+0xabc5934) (BuildId: 90de353ac158646e7dab501b76a18a76628fca33)
0x603000068034 is located 0 bytes after 20-byte region [0x603000068020,0x603000068034)
allocated by thread T0 here:
#0 0x7f4efcee0cd1 in __interceptor_calloc /usr/src/debug/gcc/gcc/libsanitizer/asan/asan_malloc_linux.cpp:77
#1 0x5647856265d8 in xcalloc /home/smarchi/src/binutils-gdb/gdb/alloc.c:97
#2 0x564788610c6b in xzalloc(unsigned long) /home/smarchi/src/binutils-gdb/gdbsupport/common-utils.cc:29
#3 0x56478815721a in value::allocate_contents(bool) /home/smarchi/src/binutils-gdb/gdb/value.c:929
#4 0x564788157285 in value::allocate(type*, bool) /home/smarchi/src/binutils-gdb/gdb/value.c:941
#5 0x56478815733a in value::allocate(type*) /home/smarchi/src/binutils-gdb/gdb/value.c:951
#6 0x5647854ae81c in expr::ada_string_operation::evaluate(type*, expression*, noside) /home/smarchi/src/binutils-gdb/gdb/ada-lang.c:10675
#7 0x5647854b63b8 in expr::ada_funcall_operation::evaluate(type*, expression*, noside) /home/smarchi/src/binutils-gdb/gdb/ada-lang.c:11184
#8 0x564786658266 in expression::evaluate(type*, noside) /home/smarchi/src/binutils-gdb/gdb/eval.c:111
#9 0x5647871242d6 in process_print_command_args /home/smarchi/src/binutils-gdb/gdb/printcmd.c:1322
#10 0x5647871244b3 in print_command_1 /home/smarchi/src/binutils-gdb/gdb/printcmd.c:1335
#11 0x564787125384 in print_command /home/smarchi/src/binutils-gdb/gdb/printcmd.c:1468
#12 0x564785caac44 in do_simple_func /home/smarchi/src/binutils-gdb/gdb/cli/cli-decode.c:95
#13 0x564785cc18f0 in cmd_func(cmd_list_element*, char const*, int) /home/smarchi/src/binutils-gdb/gdb/cli/cli-decode.c:2735
#14 0x564787c70c68 in execute_command(char const*, int) /home/smarchi/src/binutils-gdb/gdb/top.c:574
#15 0x564786686180 in command_handler(char const*) /home/smarchi/src/binutils-gdb/gdb/event-top.c:543
#16 0x56478668752f in command_line_handler(std::unique_ptr<char, gdb::xfree_deleter<char> >&&) /home/smarchi/src/binutils-gdb/gdb/event-top.c:779
#17 0x564787dcb29a in tui_command_line_handler /home/smarchi/src/binutils-gdb/gdb/tui/tui-interp.c:104
#18 0x56478668443d in gdb_rl_callback_handler /home/smarchi/src/binutils-gdb/gdb/event-top.c:250
#19 0x7f4efd506246 in rl_callback_read_char (/usr/lib/libreadline.so.8+0x3b246) (BuildId: 092e91fc4361b0ef94561e3ae03a75f69398acbb)
Simon
Simon Marchi <simark@simark.ca> writes:
> On 6/5/23 08:26, Andrew Burgess via Gdb-patches wrote:
>> You are right. I merged these two calls, and the other two in
>> str_value_from_setting, and pushed this patch.
>
> Turns out this test triggers an ASan error:
>
> (gdb) PASS: gdb.base/internal-string-values.exp: test_setting: all langs: lang=ada: ptype "foo"
> print $_gdb_maint_setting("test-settings string")
> =================================================================
> ==80377==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x603000068034 at pc 0x564785cba682 bp 0x7ffd20644620 sp 0x7ffd20644610
> READ of size 1 at 0x603000068034 thread T0
Thanks for pointing this out. I see what's going on here.
What about this patch for fixing it?
Thanks,
Andrew
---
commit 2cf56b25deb3e74de60cf165f3f852a871125136
Author: Andrew Burgess <aburgess@redhat.com>
Date: Tue Jun 6 16:34:35 2023 +0100
gdb: fix ASan failure after recent string changes
After this commit:
commit baab375361c365afee2577c94cbbd3fdd443d6da
Date: Tue Jul 13 14:44:27 2021 -0400
gdb: building inferior strings from within GDB
It was pointed out that a new ASan failure had been introduced which
was triggered by gdb.base/internal-string-values.exp:
(gdb) PASS: gdb.base/internal-string-values.exp: test_setting: all langs: lang=ada: ptype "foo"
print $_gdb_maint_setting("test-settings string")
=================================================================
==80377==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x603000068034 at pc 0x564785cba682 bp 0x7ffd20644620 sp 0x7ffd20644610
READ of size 1 at 0x603000068034 thread T0
#0 0x564785cba681 in find_command_name_length(char const*) /tmp/src/binutils-gdb/gdb/cli/cli-decode.c:2129
#1 0x564785cbacb2 in lookup_cmd_1(char const**, cmd_list_element*, cmd_list_element**, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*, int, bool) /tmp/src/binutils-gdb/gdb/cli/cli-decode.c:2186
#2 0x564785cbb539 in lookup_cmd_1(char const**, cmd_list_element*, cmd_list_element**, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*, int, bool) /tmp/src/binutils-gdb/gdb/cli/cli-decode.c:2248
#3 0x564785cbbcf3 in lookup_cmd(char const**, cmd_list_element*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >*, int, int) /tmp/src/binutils-gdb/gdb/cli/cli-decode.c:2339
#4 0x564785c82df2 in setting_cmd /tmp/src/binutils-gdb/gdb/cli/cli-cmds.c:2219
#5 0x564785c84274 in gdb_maint_setting_internal_fn /tmp/src/binutils-gdb/gdb/cli/cli-cmds.c:2348
#6 0x564788167b3b in call_internal_function(gdbarch*, language_defn const*, value*, int, value**) /tmp/src/binutils-gdb/gdb/value.c:2321
#7 0x5647854b6ebd in expr::ada_funcall_operation::evaluate(type*, expression*, noside) /tmp/src/binutils-gdb/gdb/ada-lang.c:11254
#8 0x564786658266 in expression::evaluate(type*, noside) /tmp/src/binutils-gdb/gdb/eval.c:111
#9 0x5647871242d6 in process_print_command_args /tmp/src/binutils-gdb/gdb/printcmd.c:1322
#10 0x5647871244b3 in print_command_1 /tmp/src/binutils-gdb/gdb/printcmd.c:1335
#11 0x564787125384 in print_command /tmp/src/binutils-gdb/gdb/printcmd.c:1468
#12 0x564785caac44 in do_simple_func /tmp/src/binutils-gdb/gdb/cli/cli-decode.c:95
#13 0x564785cc18f0 in cmd_func(cmd_list_element*, char const*, int) /tmp/src/binutils-gdb/gdb/cli/cli-decode.c:2735
#14 0x564787c70c68 in execute_command(char const*, int) /tmp/src/binutils-gdb/gdb/top.c:574
#15 0x564786686180 in command_handler(char const*) /tmp/src/binutils-gdb/gdb/event-top.c:543
#16 0x56478668752f in command_line_handler(std::unique_ptr<char, gdb::xfree_deleter<char> >&&) /tmp/src/binutils-gdb/gdb/event-top.c:779
#17 0x564787dcb29a in tui_command_line_handler /tmp/src/binutils-gdb/gdb/tui/tui-interp.c:104
#18 0x56478668443d in gdb_rl_callback_handler /tmp/src/binutils-gdb/gdb/event-top.c:250
#19 0x7f4efd506246 in rl_callback_read_char (/usr/lib/libreadline.so.8+0x3b246) (BuildId: 092e91fc4361b0ef94561e3ae03a75f69398acbb)
#20 0x564786683dea in gdb_rl_callback_read_char_wrapper_noexcept /tmp/src/binutils-gdb/gdb/event-top.c:192
#21 0x564786684042 in gdb_rl_callback_read_char_wrapper /tmp/src/binutils-gdb/gdb/event-top.c:225
#22 0x564787f1b119 in stdin_event_handler /tmp/src/binutils-gdb/gdb/ui.c:155
#23 0x56478862438d in handle_file_event /tmp/src/binutils-gdb/gdbsupport/event-loop.cc:573
#24 0x564788624d23 in gdb_wait_for_event /tmp/src/binutils-gdb/gdbsupport/event-loop.cc:694
#25 0x56478862297c in gdb_do_one_event(int) /tmp/src/binutils-gdb/gdbsupport/event-loop.cc:264
#26 0x564786df99f0 in start_event_loop /tmp/src/binutils-gdb/gdb/main.c:412
#27 0x564786dfa069 in captured_command_loop /tmp/src/binutils-gdb/gdb/main.c:476
#28 0x564786dff61f in captured_main /tmp/src/binutils-gdb/gdb/main.c:1320
#29 0x564786dff75c in gdb_main(captured_main_args*) /tmp/src/binutils-gdb/gdb/main.c:1339
#30 0x564785381b6d in main /tmp/src/binutils-gdb/gdb/gdb.c:32
#31 0x7f4efbc3984f (/usr/lib/libc.so.6+0x2384f) (BuildId: 2f005a79cd1a8e385972f5a102f16adba414d75e)
#32 0x7f4efbc39909 in __libc_start_main (/usr/lib/libc.so.6+0x23909) (BuildId: 2f005a79cd1a8e385972f5a102f16adba414d75e)
#33 0x564785381934 in _start (/tmp/build/binutils-gdb/gdb/gdb+0xabc5934) (BuildId: 90de353ac158646e7dab501b76a18a76628fca33)
0x603000068034 is located 0 bytes after 20-byte region [0x603000068020,0x603000068034) allocated by thread T0 here:
#0 0x7f4efcee0cd1 in __interceptor_calloc /usr/src/debug/gcc/gcc/libsanitizer/asan/asan_malloc_linux.cpp:77
#1 0x5647856265d8 in xcalloc /tmp/src/binutils-gdb/gdb/alloc.c:97
#2 0x564788610c6b in xzalloc(unsigned long) /tmp/src/binutils-gdb/gdbsupport/common-utils.cc:29
#3 0x56478815721a in value::allocate_contents(bool) /tmp/src/binutils-gdb/gdb/value.c:929
#4 0x564788157285 in value::allocate(type*, bool) /tmp/src/binutils-gdb/gdb/value.c:941
#5 0x56478815733a in value::allocate(type*) /tmp/src/binutils-gdb/gdb/value.c:951
#6 0x5647854ae81c in expr::ada_string_operation::evaluate(type*, expression*, noside) /tmp/src/binutils-gdb/gdb/ada-lang.c:10675
#7 0x5647854b63b8 in expr::ada_funcall_operation::evaluate(type*, expression*, noside) /tmp/src/binutils-gdb/gdb/ada-lang.c:11184
#8 0x564786658266 in expression::evaluate(type*, noside) /tmp/src/binutils-gdb/gdb/eval.c:111
#9 0x5647871242d6 in process_print_command_args /tmp/src/binutils-gdb/gdb/printcmd.c:1322
#10 0x5647871244b3 in print_command_1 /tmp/src/binutils-gdb/gdb/printcmd.c:1335
#11 0x564787125384 in print_command /tmp/src/binutils-gdb/gdb/printcmd.c:1468
#12 0x564785caac44 in do_simple_func /tmp/src/binutils-gdb/gdb/cli/cli-decode.c:95
#13 0x564785cc18f0 in cmd_func(cmd_list_element*, char const*, int) /tmp/src/binutils-gdb/gdb/cli/cli-decode.c:2735
#14 0x564787c70c68 in execute_command(char const*, int) /tmp/src/binutils-gdb/gdb/top.c:574
#15 0x564786686180 in command_handler(char const*) /tmp/src/binutils-gdb/gdb/event-top.c:543
#16 0x56478668752f in command_line_handler(std::unique_ptr<char, gdb::xfree_deleter<char> >&&) /tmp/src/binutils-gdb/gdb/event-top.c:779
#17 0x564787dcb29a in tui_command_line_handler /tmp/src/binutils-gdb/gdb/tui/tui-interp.c:104
#18 0x56478668443d in gdb_rl_callback_handler /tmp/src/binutils-gdb/gdb/event-top.c:250
#19 0x7f4efd506246 in rl_callback_read_char (/usr/lib/libreadline.so.8+0x3b246) (BuildId: 092e91fc4361b0ef94561e3ae03a75f69398acbb)
The problem is in cli/cli-cmds.c, in the function setting_cmd, where
we do this:
const char *a0 = (const char *) argv[0]->contents ().data ();
Here argv[0] is a value* which we know is either a TYPE_CODE_ARRAY or
a TYPE_CODE_STRING. The problem is that the above line is casting the
value contents directly to a C-string, i.e. one that is assumed to
have a null-terminator at the end.
After the above commit this can no longer be assumed to be true. A
string value will be represented just as it would be in the current
language, so for Ada and Fortran the string will be an array of
characters with no null-terminator at the end.
My proposed solution is to copy the string contents into a std::string
object, and then use the std::string::c_str() value, this will ensure
that a null-terminator has been added.
I had a check through GDB at places TYPE_CODE_STRING was used and
couldn't see any other obvious places where this type of assumption
was being made, so hopefully this is the only offender.
Running the above test with ASan compiled in no longer gives an error.
diff --git a/gdb/cli/cli-cmds.c b/gdb/cli/cli-cmds.c
index 8994cc5ea3d..638c138e7cb 100644
--- a/gdb/cli/cli-cmds.c
+++ b/gdb/cli/cli-cmds.c
@@ -2215,7 +2215,13 @@ setting_cmd (const char *fnname, struct cmd_list_element *showlist,
&& type0->code () != TYPE_CODE_STRING)
error (_("First argument of %s must be a string."), fnname);
- const char *a0 = (const char *) argv[0]->contents ().data ();
+ /* Not all languages null-terminate their strings, by moving the string
+ content into a std::string we ensure that a null-terminator is added.
+ For languages that do add a null-terminator the std::string might end
+ up with two null characters at the end, but that's harmless. */
+ const std::string setting ((const char *) argv[0]->contents ().data (),
+ type0->length ());
+ const char *a0 = setting.c_str ();
cmd_list_element *cmd = lookup_cmd (&a0, showlist, "", NULL, -1, 0);
if (cmd == nullptr || cmd->type != show_cmd)
>>>>> "Andrew" == Andrew Burgess via Gdb-patches <gdb-patches@sourceware.org> writes:
Andrew> Thanks for pointing this out. I see what's going on here.
Andrew> What about this patch for fixing it?
Looks good to me.
If this idiom:
Andrew> + const std::string setting ((const char *) argv[0]->contents ().data (),
Andrew> + type0->length ());
is needed elsewhere, then maybe a new function or value method would be good.
For a single use though it doesn't seem to matter.
Tom
Tom Tromey <tom@tromey.com> writes:
>>>>>> "Andrew" == Andrew Burgess via Gdb-patches <gdb-patches@sourceware.org> writes:
>
> Andrew> Thanks for pointing this out. I see what's going on here.
>
> Andrew> What about this patch for fixing it?
>
> Looks good to me.
>
> If this idiom:
>
> Andrew> + const std::string setting ((const char *) argv[0]->contents ().data (),
> Andrew> + type0->length ());
>
> is needed elsewhere, then maybe a new function or value method would be good.
> For a single use though it doesn't seem to matter.
I have some patches that move in this direction, but haven't finished
they yet. Something like language_defn::value_to_string(value *) to
build a std::string from a value for a particular language.
I'll go ahead and push this patch as it is for now as it fixes a
regression.
Thanks,
Andrew
@@ -13526,6 +13526,19 @@ class ada_language : public language_defn
return symbol->is_artificial ();
}
+ /* See language.h. */
+ struct value *value_string (struct gdbarch *gdbarch,
+ const char *ptr, ssize_t len) const override
+ {
+ struct type *type = language_string_char_type (this, gdbarch);
+ value *val = ::value_string (ptr, len, type);
+ /* VAL will be a TYPE_CODE_STRING, but Ada only knows how to print
+ strings that are arrays of characters, so fix the type now. */
+ gdb_assert (val->type ()->code () == TYPE_CODE_STRING);
+ val->type ()->set_code (TYPE_CODE_ARRAY);
+ return val;
+ }
+
/* See language.h. */
void language_arch_info (struct gdbarch *gdbarch,
struct language_arch_info *lai) const override
@@ -652,16 +652,11 @@ c_string_operation::evaluate (struct type *expect_type,
}
else
{
- int i;
-
- /* Write the terminating character. */
- for (i = 0; i < type->length (); ++i)
- obstack_1grow (&output, 0);
+ int element_size = type->length ();
if (satisfy_expected)
{
LONGEST low_bound, high_bound;
- int element_size = type->length ();
if (!get_discrete_bounds (expect_type->index_type (),
&low_bound, &high_bound))
@@ -676,10 +671,13 @@ c_string_operation::evaluate (struct type *expect_type,
result = value::allocate (expect_type);
memcpy (result->contents_raw ().data (), obstack_base (&output),
obstack_object_size (&output));
+ /* Write the terminating character. */
+ memset (result->contents_raw ().data () + obstack_object_size (&output),
+ 0, element_size);
}
else
- result = value_cstring ((const char *) obstack_base (&output),
- obstack_object_size (&output),
+ result = value_cstring ((const gdb_byte *) obstack_base (&output),
+ obstack_object_size (&output) / element_size,
type);
}
return result;
@@ -2316,11 +2316,9 @@ value_from_setting (const setting &var, struct gdbarch *gdbarch)
}
if (len > 0)
- return value_cstring (value, len,
- builtin_type (gdbarch)->builtin_char);
+ return current_language->value_string (gdbarch, value, len);
else
- return value_cstring ("", 1,
- builtin_type (gdbarch)->builtin_char);
+ return current_language->value_string (gdbarch, "", 0);
}
default:
gdb_assert_not_reached ("bad var_type");
@@ -2372,8 +2370,8 @@ str_value_from_setting (const setting &var, struct gdbarch *gdbarch)
{
std::string cmd_val = get_setshow_command_value_string (var);
- return value_cstring (cmd_val.c_str (), cmd_val.size (),
- builtin_type (gdbarch)->builtin_char);
+ return current_language->value_string (gdbarch, cmd_val.c_str (),
+ cmd_val.size ());
}
case var_string:
@@ -2401,11 +2399,9 @@ str_value_from_setting (const setting &var, struct gdbarch *gdbarch)
}
if (len > 0)
- return value_cstring (value, len,
- builtin_type (gdbarch)->builtin_char);
+ return current_language->value_string (gdbarch, value, len);
else
- return value_cstring ("", 1,
- builtin_type (gdbarch)->builtin_char);
+ return current_language->value_string (gdbarch, "", 0);
}
default:
gdb_assert_not_reached ("bad var_type");
@@ -101,6 +101,16 @@ f_language::get_encoding (struct type *type)
return encoding;
}
+/* See language.h. */
+
+struct value *
+f_language::value_string (struct gdbarch *gdbarch,
+ const char *ptr, ssize_t len) const
+{
+ struct type *type = language_string_char_type (this, gdbarch);
+ return ::value_string (ptr, len, type);
+}
+
/* A helper function for the "bound" intrinsics that checks that TYPE
is an array. LBOUND_P is true for lower bound; this is used for
the error message, if any. */
@@ -203,6 +203,11 @@ class f_language : public language_defn
/* See language.h. */
+ struct value *value_string (struct gdbarch *gdbarch,
+ const char *ptr, ssize_t len) const override;
+
+ /* See language.h. */
+
const char *struct_too_deep_ellipsis () const override
{ return "(...)"; }
@@ -803,9 +803,7 @@ vlscm_convert_typed_value_from_scheme (const char *func_name,
0 /*non-strict*/,
&except_scm);
if (s != NULL)
- value = value_cstring (s.get (), len,
- language_string_char_type (language,
- gdbarch));
+ value = language->value_string (gdbarch, s.get (), len);
else
value = NULL;
}
@@ -874,6 +874,16 @@ language_string_char_type (const struct language_defn *la,
/* See language.h. */
+struct value *
+language_defn::value_string (struct gdbarch *gdbarch,
+ const char *ptr, ssize_t len) const
+{
+ struct type *type = language_string_char_type (this, gdbarch);
+ return value_cstring (ptr, len, type);
+}
+
+/* See language.h. */
+
struct type *
language_bool_type (const struct language_defn *la,
struct gdbarch *gdbarch)
@@ -602,6 +602,12 @@ struct language_defn
virtual char string_lower_bound () const
{ return c_style_arrays_p () ? 0 : 1; }
+ /* Return the LEN characters long string at PTR as a value suitable for
+ this language. GDBARCH is used to infer the character type. The
+ default implementation returns a null-terminated C string. */
+ virtual struct value *value_string (struct gdbarch *gdbarch,
+ const char *ptr, ssize_t len) const;
+
/* Returns true if the symbols names should be stored in GDB's data
structures for minimal/partial/full symbols using their linkage (aka
mangled) form; false if the symbol names should be demangled first.
@@ -54,9 +54,6 @@
#define builtin_type_pybool \
language_bool_type (current_language, gdbpy_enter::get_gdbarch ())
-#define builtin_type_pychar \
- language_string_char_type (current_language, gdbpy_enter::get_gdbarch ())
-
struct value_object {
PyObject_HEAD
struct value_object *next;
@@ -1881,8 +1878,9 @@ convert_value_from_python (PyObject *obj)
gdb::unique_xmalloc_ptr<char> s
= python_string_to_target_string (obj);
if (s != NULL)
- value = value_cstring (s.get (), strlen (s.get ()),
- builtin_type_pychar);
+ value
+ = current_language->value_string (gdbpy_enter::get_gdbarch (),
+ s.get (), strlen (s.get ()));
}
else if (PyObject_TypeCheck (obj, &value_object_type))
value = ((value_object *) obj)->value->copy ();
new file mode 100644
@@ -0,0 +1,32 @@
+/* This testcase is part of GDB, the GNU debugger.
+
+ Copyright 2021-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 <http://www.gnu.org/licenses/>. */
+
+static void
+trace_me (void)
+{}
+
+static void
+end (void)
+{}
+
+int
+main (void)
+{
+ trace_me ();
+ end ();
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,279 @@
+# Copyright 2021-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 <http://www.gnu.org/licenses/>.
+
+# Test that string values are correctly allocated inside GDB when doing
+# various operations that yield strings.
+#
+# The issue that lead to this test was a missing NULL terminator in the
+# C-string values. We verify that we can print the null terminator of these
+# strings.
+
+load_lib "trace-support.exp"
+load_lib "gdb-guile.exp"
+
+standard_testfile
+
+if {[build_executable "failed to prepare" $testfile $srcfile ]} {
+ return
+}
+
+set user_conv_funcs {$_gdb_setting $_gdb_setting_str}
+set maint_conv_funcs {$_gdb_maint_setting $_gdb_maint_setting_str}
+
+# Add language (LANG) appropriate quotation marks around string STR.
+proc quote_for_lang {lang str} {
+ if {$lang == "fortran"} {
+ return "'$str'"
+ } else {
+ return "\"$str\""
+ }
+}
+
+# Check that the string contained in the convenienced variable $v is
+# EXPECTED_STR.
+#
+# In particular, check that the null terminator is there and that we can't
+# access a character past the end of the string.
+
+proc check_v_string { expected_str } {
+ set len [string length $expected_str]
+
+ for { set i 0 } { $i < $len } { incr i } {
+ set c [string index $expected_str $i]
+ gdb_test "print \$v\[$i\]" "= $::decimal '$c'"
+ }
+
+ # Check that the string ends with a null terminator.
+ gdb_test "print \$v\[$i\]" {= 0 '\\000'}
+
+ # Check that we can't access a character after the end of the string.
+ incr i
+ gdb_test "print \$v\[$i\]" "no such vector element"
+}
+
+# Test with string values made by $_gdb_setting & co.
+
+proc_with_prefix test_setting { } {
+ clean_restart
+
+ # This is an internal GDB implementation detail, but the variable backing
+ # a string setting starts as nullptr (unless explicitly initialized at
+ # startup). When assigning an empty value, the variable then points to an
+ # empty string. Test both cases, as it triggers different code paths (in
+ # addition to a non-empty value).
+ #
+ # Use "set trace-user" and "maintenance set test-settings string" as they
+ # are both not initialized at startup.
+ with_test_prefix "user setting" {
+ with_test_prefix "not set" {
+ foreach_with_prefix conv_func $::user_conv_funcs {
+ gdb_test_no_output "set \$v = ${conv_func}(\"trace-user\")"
+ check_v_string ""
+ }
+ }
+
+ with_test_prefix "set to empty" {
+ gdb_test "set trace-user"
+ foreach_with_prefix conv_func $::user_conv_funcs {
+ gdb_test_no_output "set \$v = ${conv_func}(\"trace-user\")"
+ check_v_string ""
+ }
+ }
+
+ with_test_prefix "set" {
+ gdb_test "set trace-user poulet"
+ foreach_with_prefix conv_func $::user_conv_funcs {
+ gdb_test_no_output {set $v = $_gdb_setting("trace-user")}
+ check_v_string "poulet"
+ }
+ }
+ }
+
+ with_test_prefix "maintenance setting" {
+ with_test_prefix "not set" {
+ foreach_with_prefix conv_func $::maint_conv_funcs {
+ gdb_test_no_output \
+ "set \$v = ${conv_func}(\"test-settings string\")"
+ check_v_string ""
+ }
+ }
+
+ with_test_prefix "set to empty" {
+ gdb_test "maintenance set test-settings string"
+ foreach_with_prefix conv_func $::maint_conv_funcs {
+ gdb_test_no_output \
+ "set \$v = ${conv_func}(\"test-settings string\")"
+ check_v_string ""
+ }
+ }
+
+ with_test_prefix "set" {
+ gdb_test "maintenance set test-settings string perchaude"
+ foreach_with_prefix conv_func $::maint_conv_funcs {
+ gdb_test_no_output \
+ "set \$v = ${conv_func}(\"test-settings string\")"
+ check_v_string "perchaude"
+ }
+ }
+ }
+
+ # Test with a non-string setting, this tests yet another code path.
+ with_test_prefix "integer setting" {
+ gdb_test_no_output {set $v = $_gdb_setting_str("remotetimeout")}
+ check_v_string "2"
+ }
+
+ # Test string values made by $_gdb_setting & co. in all languages.
+ with_test_prefix "all langs" {
+ # Get list of supported languages.
+ set langs [gdb_supported_languages]
+
+ gdb_test "maintenance set test-settings string foo"
+ foreach_with_prefix lang $langs {
+ gdb_test_no_output "set language $lang"
+
+ if {$lang == "modula-2"} {
+ # The Modula-2 parser doesn't know how to build a
+ # suitable string expression.
+ gdb_test "print \"foo\"" "strings are not implemented"
+ continue
+ }
+
+ if {$lang == "rust"} {
+ # Rust strings are actually structs, without a running
+ # inferior into which the string data can be pushed
+ # GDB can't print anything.
+ gdb_test "print \"foo\"" \
+ "evaluation of this expression requires the target program to be active"
+ gdb_test "print \$_gdb_maint_setting(\"test-settings string\")" \
+ "evaluation of this expression requires the target program to be active"
+ continue
+ }
+
+ if {$lang == "unknown"} {
+ # Skipped because expression parsing is not supported
+ # for the "unknown" language. See gdb/28093 for more
+ # details.
+ continue
+ }
+
+ set print_output ""
+ set ptype_output ""
+
+ set foo_str [quote_for_lang $lang foo]
+ gdb_test_multiple "print $foo_str" "" {
+ -wrap -re " = (.*)" {
+ set print_output $expect_out(1,string)
+ pass $gdb_test_name
+ }
+ }
+
+ gdb_test_multiple "ptype $foo_str" "" {
+ -wrap -re " = (.*)" {
+ set ptype_output $expect_out(1,string)
+ pass $gdb_test_name
+ }
+ }
+
+ set cmd_str [quote_for_lang $lang "test-settings string"]
+ set ptype_output_re [string_to_regexp $ptype_output]
+ set print_output_re [string_to_regexp $print_output]
+
+ foreach_with_prefix conv_func $::maint_conv_funcs {
+ gdb_test "print ${conv_func}($cmd_str)" \
+ " = $print_output_re"
+ gdb_test "ptype \$" \
+ " = $ptype_output_re"
+ }
+ }
+ }
+}
+
+# Test with a string value created by gdb.Value in Python.
+
+proc_with_prefix test_python_value { } {
+ clean_restart
+
+ if {![allow_python_tests]} {
+ untested "skipping test_python_value"
+ return
+ }
+
+ gdb_test_no_output "python gdb.set_convenience_variable(\"v\", \"bar\")" \
+ "set convenience var"
+ check_v_string "bar"
+}
+
+# Test with a string value created by make-value in Guile.
+
+proc_with_prefix test_guile_value { } {
+ clean_restart
+
+ if {![allow_guile_tests]} {
+ untested "skipping test_guile_value"
+ return
+ }
+
+ # We can't set a convenience var from Guile, but we can append to history.
+ # Do that, then transfer to a convenience var with a CLI command.
+ gdb_test_no_output "guile (use-modules (gdb))"
+ gdb_test_multiple "guile (history-append! (make-value \"foo\"))" "make value" {
+ -re -wrap "($::decimal)" {
+ set histnum $expect_out(1,string)
+ }
+ }
+
+ gdb_test_no_output "set \$v = \$$histnum"
+ check_v_string "foo"
+}
+
+# Test with a string value coming from a string internal var. The only internal
+# vars of this type, at the time of writing, are $trace_func and $trace_file.
+# They both require inspecting a trace frame. So if the target is capable start
+# tracing, record one trace frame, and use $trace_func.
+
+proc_with_prefix test_internal_var { } {
+ if {![gdb_trace_common_supports_arch]} {
+ unsupported "arch does not support trace"
+ return
+ }
+
+ clean_restart $::binfile
+
+ if {![runto_main]} {
+ fail "could not run to main"
+ return
+ }
+
+ if {![gdb_target_supports_trace]} {
+ unsupported "target does not support trace"
+ return
+ }
+
+ gdb_breakpoint "end"
+ gdb_test "trace trace_me" "Tracepoint $::decimal at $::hex.*"
+ gdb_test_no_output "tstart"
+ gdb_continue_to_breakpoint "breakpoint at end"
+ gdb_test_no_output "tstop"
+ gdb_test "tfind" "Found trace frame 0, tracepoint $::decimal.*"
+ gdb_test_no_output "set \$v = \$trace_func"
+ gdb_test "tfind none" "No longer looking at any trace frame.*"
+ check_v_string "trace_me"
+}
+
+test_setting
+test_python_value
+test_guile_value
+test_internal_var
new file mode 100644
@@ -0,0 +1,56 @@
+/* This testcase is part of GDB, the GNU debugger.
+
+ Copyright 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 <http://www.gnu.org/licenses/>. */
+
+#include <stddef.h>
+#include <string.h>
+
+/* A memory area used as the malloc memory buffer. */
+
+static char arena[256];
+
+/* Override malloc(). When GDB tries to push strings into the inferior we
+ will always return the same pointer (to arena). This does mean we can't
+ have multiple strings in use at the same time, but that's fine for this
+ simple test. On each malloc call the contents of arena are reset, which
+ should make it more obvious if GDB tried to print memory that it
+ shouldn't. */
+
+void *
+malloc (size_t size)
+{
+ /* Reset the contents of arena, and ensure there's a null-character at
+ the end just in case GDB tries to print memory that it shouldn't. */
+ memset (arena, 'X', sizeof (arena));
+ arena [sizeof (arena) - 1] = '\0';
+ if (size > sizeof (arena))
+ return NULL;
+ return arena;
+}
+
+/* This function is called from GDB. */
+
+void
+take_string (const char *str)
+{
+ /* Nothing. */
+}
+
+int
+main (void)
+{
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,64 @@
+# Copyright 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 <http://www.gnu.org/licenses/>.
+
+# Test different ways in which GDB can create a string and then push
+# that string into the inferior before reading it back. Check that
+# the thing that is read back is correctly interpreted as a string.
+
+standard_testfile
+
+if { [prepare_for_testing "failed to prepare" $testfile $srcfile] } {
+ return -1
+}
+
+if {![runto_main]} {
+ return 0
+}
+
+if [allow_python_tests] {
+ # The $_as_string convenience function is implemented in Python.
+ gdb_test {printf "%s\n", $_as_string("aabbcc")} "\"aabbcc\""
+
+ # Create a gdb.Value object for a string. Take its address (which
+ # forces it into the inferior), and then print the address as a
+ # string.
+ gdb_test_no_output {python addr = gdb.Value("ccbbaa").address}
+ gdb_test {python gdb.execute("x/1s 0x%x" % addr)} \
+ "$hex <arena>:\\s+\"ccbbaa\""
+
+ # Call an inferior function through a gdb.Value object, pass a
+ # string to the inferior function and ensure it arrives correctly.
+ gdb_test "p/x take_string" " = $hex.*"
+ gdb_test_no_output "python func_ptr = gdb.history (0)" \
+ "place address of take_string into Python variable"
+ gdb_test "python func_value = func_ptr.dereference()" ""
+ gdb_breakpoint "take_string"
+ gdb_test {python result = func_value("qqaazz")} \
+ "Breakpoint $decimal, take_string \\(str=$hex <arena> \"qqaazz\"\\) at .*"
+ gdb_test "continue" "Continuing\\."
+}
+
+# Use printf on a string parsed by the C expression parser.
+gdb_test {printf "%s\n", "ddeeff"} "ddeeff"
+
+# Parse a string in the C expression parser, force it into the
+# inferior by taking its address, then print it as a string.
+gdb_test {x/1s &"gghhii"} "$hex <arena>:\\s+\"gghhii\""
+
+# Use $_gdb_setting_str and $_gdb_maint_setting_str to create a string
+# value, and then print using printf, which forces the string into the
+# inferior.
+gdb_test {printf "%s\n", $_gdb_setting_str("arch")} "auto"
+gdb_test {printf "%s\n", $_gdb_maint_setting_str("bfd-sharing")} "on"
@@ -504,7 +504,7 @@ proc_with_prefix test-enum {} {
gdb_test_no_output "$set_cmd zzz"
show_setting "$show_cmd" "zzz" 0 "yyy"
- check_type "test-settings enum" "type = char \\\[3\\\]"
+ check_type "test-settings enum" "type = char \\\[4\\\]"
test_gdb_complete_multiple "$set_cmd " "" "" {
"xxx"
@@ -288,7 +288,7 @@ mi_create_dynamic_varobj nstype2 nstype2 ".*" 1 \
"create nstype2 varobj"
mi_list_varobj_children nstype2 {
- { {nstype2.<error at 0>} {<error at 0>} 6 {char \[6\]} }
+ { {nstype2.<error at 0>} {<error at 0>} 7 {char \[7\]} }
} "list children after setting exception flag"
mi_create_varobj me me \
@@ -1738,39 +1738,38 @@ value_array (int lowbound, int highbound, struct value **elemvec)
return val;
}
+/* See value.h. */
+
struct value *
-value_cstring (const char *ptr, ssize_t len, struct type *char_type)
+value_cstring (const gdb_byte *ptr, ssize_t count, struct type *char_type)
{
struct value *val;
int lowbound = current_language->string_lower_bound ();
- ssize_t highbound = len / char_type->length ();
+ ssize_t highbound = count + 1;
struct type *stringtype
= lookup_array_range_type (char_type, lowbound, highbound + lowbound - 1);
val = value::allocate (stringtype);
+ ssize_t len = count * char_type->length ();
memcpy (val->contents_raw ().data (), ptr, len);
+ /* Write the terminating null-character. */
+ memset (val->contents_raw ().data () + len, 0, char_type->length ());
return val;
}
-/* Create a value for a string constant by allocating space in the
- inferior, copying the data into that space, and returning the
- address with type TYPE_CODE_STRING. PTR points to the string
- constant data; LEN is number of characters.
-
- Note that string types are like array of char types with a lower
- bound of zero and an upper bound of LEN - 1. Also note that the
- string may contain embedded null bytes. */
+/* See value.h. */
struct value *
-value_string (const char *ptr, ssize_t len, struct type *char_type)
+value_string (const gdb_byte *ptr, ssize_t count, struct type *char_type)
{
struct value *val;
int lowbound = current_language->string_lower_bound ();
- ssize_t highbound = len / char_type->length ();
+ ssize_t highbound = count;
struct type *stringtype
= lookup_string_range_type (char_type, lowbound, highbound + lowbound - 1);
val = value::allocate (stringtype);
+ ssize_t len = count * char_type->length ();
memcpy (val->contents_raw ().data (), ptr, len);
return val;
}
@@ -2044,8 +2044,9 @@ value_of_internalvar (struct gdbarch *gdbarch, struct internalvar *var)
break;
case INTERNALVAR_STRING:
- val = value_cstring (var->u.string, strlen (var->u.string),
- builtin_type (gdbarch)->builtin_char);
+ val = current_language->value_string (gdbarch,
+ var->u.string,
+ strlen (var->u.string));
break;
case INTERNALVAR_VALUE:
@@ -1182,11 +1182,48 @@ class scoped_value_mark
const struct value *m_value;
};
-extern struct value *value_cstring (const char *ptr, ssize_t len,
+/* Create not_lval value representing a NULL-terminated C string. The
+ resulting value has type TYPE_CODE_ARRAY. The string passed in should
+ not include embedded null characters.
+
+ PTR points to the string data; COUNT is number of characters (does
+ not include the NULL terminator) pointed to by PTR, each character is of
+ type (and size of) CHAR_TYPE. */
+
+extern struct value *value_cstring (const gdb_byte *ptr, ssize_t count,
struct type *char_type);
-extern struct value *value_string (const char *ptr, ssize_t len,
+
+/* Specialisation of value_cstring above. In this case PTR points to
+ single byte characters. CHAR_TYPE must have a length of 1. */
+inline struct value *value_cstring (const char *ptr, ssize_t count,
+ struct type *char_type)
+{
+ gdb_assert (char_type->length () == 1);
+ return value_cstring ((const gdb_byte *) ptr, count, char_type);
+}
+
+/* Create a not_lval value with type TYPE_CODE_STRING, the resulting value
+ has type TYPE_CODE_STRING.
+
+ PTR points to the string data; COUNT is number of characters pointed to
+ by PTR, each character has the type (and size of) CHAR_TYPE.
+
+ Note that string types are like array of char types with a lower bound
+ defined by the language (usually zero or one). Also the string may
+ contain embedded null characters. */
+
+extern struct value *value_string (const gdb_byte *ptr, ssize_t count,
struct type *char_type);
+/* Specialisation of value_string above. In this case PTR points to
+ single byte characters. CHAR_TYPE must have a length of 1. */
+inline struct value *value_string (const char *ptr, ssize_t count,
+ struct type *char_type)
+{
+ gdb_assert (char_type->length () == 1);
+ return value_string ((const gdb_byte *) ptr, count, char_type);
+}
+
extern struct value *value_array (int lowbound, int highbound,
struct value **elemvec);