functionality is also available for dprintf when dprintf-style is
'gdb'.
+* When the printf command requires a string to be fetched from the
+ inferior, GDB now uses the existing 'max-value-size' setting to the
+ limit the memory allocated within GDB. The default 'max-value-size'
+ is 64k. To print longer strings you should increase
+ 'max-value-size'.
+
* New commands
maintenance print record-instruction [ N ]
/* This is a %s argument. Build the string in STR which is
currently empty. */
gdb_assert (str.size () == 0);
- for (size_t len = 0;; len++)
+ size_t len;
+ for (len = 0;; len++)
{
gdb_byte c;
QUIT;
+
read_memory (tem + len, &c, 1);
- str.push_back (c);
+ if (!exceeds_max_value_size (len + 1))
+ str.push_back (c);
if (c == 0)
break;
}
+ if (exceeds_max_value_size (len + 1))
+ error (_("printed string requires %s bytes, which is more than "
+ "max-value-size"), plongest (len + 1));
+
/* We will have passed through the above loop at least once, and will
only exit the loop when we have pushed a zero byte onto the end of
STR. */
for (len = 0;; len += wcwidth)
{
QUIT;
- tem_str->resize (tem_str->size () + wcwidth);
- gdb_byte *dst = tem_str->data () + len;
+ gdb_byte *dst;
+ if (!exceeds_max_value_size (len + wcwidth))
+ {
+ tem_str->resize (tem_str->size () + wcwidth);
+ dst = tem_str->data () + len;
+ }
+ else
+ {
+ /* We still need to check for the null-character, so we need
+ somewhere to place the data read from the inferior. We
+ can't keep growing TEM_STR, it's gotten too big, so
+ instead just read the new character into the start of
+ TEMS_STR. This will corrupt the previously read contents,
+ but we're not going to print this string anyway, we just
+ want to know how big it would have been so we can tell the
+ user in the error message (see below).
+
+ And we know there will be space in this buffer so long as
+ WCWIDTH is smaller than our LONGEST type, the
+ max-value-size can't be smaller than a LONGEST. */
+ dst = tem_str->data ();
+ }
read_memory (tem + len, dst, wcwidth);
if (extract_unsigned_integer (dst, wcwidth, byte_order) == 0)
break;
}
+ if (exceeds_max_value_size (len + wcwidth))
+ error (_("printed string requires %s bytes, which is more than "
+ "max-value-size"), plongest (len + wcwidth));
+
str = tem_str->data ();
}
typedef char *charptr;
charptr teststring2 = "more contents";
+const char *teststring3 = "this is a longer test string that we can use";
+
/* Test printing of a struct containing character arrays. */
struct some_arrays {
# PR cli/14977.
gdb_test "printf \"%s\\n\", 0" "\\(null\\)"
+
+ with_max_value_size 20 {
+ gdb_test {printf "%s", teststring3} \
+ "^printed string requires 45 bytes, which is more than max-value-size"
+ }
}
#Test printing DFP values with printf
#include <wchar.h>
const wchar_t wide_str[] = L"wide string";
+const wchar_t long_wide_str[]
+ = L"this is a much longer wide string that we can use if needed";
int
main (void)
}
gdb_test {printf "%ls\n", wide_str} "^wide string"
+
+# Check that if the max-value-size will kick in when using printf on strings.
+with_max_value_size 20 {
+ gdb_test {printf "%ls\n", long_wide_str} \
+ "^printed string requires 240 bytes, which is more than max-value-size"
+}
}
}
+# Run tests in BODY with max-value-size set to SIZE. When BODY is
+# finished restore max-value-size.
+
+proc with_max_value_size { size body } {
+ global gdb_prompt
+
+ set saved ""
+ gdb_test_multiple "show max-value-size" "" {
+ -re -wrap "Maximum value size is ($::decimal) bytes\\." {
+ set saved $expect_out(1,string)
+ }
+ -re ".*$gdb_prompt " {
+ fail "get max-value-size"
+ }
+ }
+
+ gdb_test_no_output -nopass "set max-value-size $size"
+
+ set code [catch {uplevel 1 $body} result]
+
+ gdb_test_no_output -nopass "set max-value-size $saved"
+
+ if {$code == 1} {
+ global errorInfo errorCode
+ return -code $code -errorinfo $errorInfo -errorcode $errorCode $result
+ } else {
+ return -code $code $result
+ }
+}
+
# Switch the default spawn id to SPAWN_ID, so that gdb_test,
# mi_gdb_test etc. default to using it.
{
ULONGEST length = type->length ();
- if (max_value_size > -1 && length > max_value_size)
+ if (exceeds_max_value_size (length))
{
if (type->name () != NULL)
error (_("value of type `%s' requires %s bytes, which is more "
}
}
+/* See value.h. */
+
+bool
+exceeds_max_value_size (ULONGEST length)
+{
+ return max_value_size > -1 && length > max_value_size;
+}
+
/* When this has a value, it is used to limit the number of array elements
of an array that are loaded into memory when an array value is made
non-lazy. */
of floating-point, fixed-point, or integer type. */
extern gdb_mpq value_to_gdb_mpq (struct value *value);
+/* Return true if LEN (in bytes) exceeds the max-value-size setting,
+ otherwise, return false. If the user has disabled (set to unlimited)
+ the max-value-size setting then this function will always return false. */
+extern bool exceeds_max_value_size (ULONGEST length);
+
/* While an instance of this class is live, and array values that are
created, that are larger than max_value_size, will be restricted in size
to a particular number of elements. */