/* C language support routines for GDB, the GNU debugger.
- Copyright (C) 1992-2019 Free Software Foundation, Inc.
+ Copyright (C) 1992-2020 Free Software Foundation, Inc.
This file is part of GDB.
#include "gdb_obstack.h"
#include <ctype.h>
#include "gdbcore.h"
+#include "gdbarch.h"
/* Given a C string type, STR_TYPE, return the corresponding target
character set name. */
that would do the wrong thing. */
while (elttype)
{
- const char *name = TYPE_NAME (elttype);
+ const char *name = elttype->name ();
- if (TYPE_CODE (elttype) == TYPE_CODE_CHAR || !name)
+ if (elttype->code () == TYPE_CODE_CHAR || !name)
{
result = C_CHAR;
goto done;
goto done;
}
- if (TYPE_CODE (elttype) != TYPE_CODE_TYPEDEF)
+ if (elttype->code () != TYPE_CODE_TYPEDEF)
break;
/* Call for side effects. */
struct type *element_type = TYPE_TARGET_TYPE (type);
int req_length = *length;
enum bfd_endian byte_order
- = gdbarch_byte_order (get_type_arch (type));
+ = type_byte_order (type);
if (element_type == NULL)
goto error;
- if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
+ if (type->code () == TYPE_CODE_ARRAY)
{
/* If we know the size of the array, we can use it as a limit on
the number of characters to be fetched. */
- if (TYPE_NFIELDS (type) == 1
- && TYPE_CODE (TYPE_FIELD_TYPE (type, 0)) == TYPE_CODE_RANGE)
+ if (type->num_fields () == 1
+ && TYPE_FIELD_TYPE (type, 0)->code () == TYPE_CODE_RANGE)
{
LONGEST low_bound, high_bound;
else
fetchlimit = UINT_MAX;
}
- else if (TYPE_CODE (type) == TYPE_CODE_PTR)
+ else if (type->code () == TYPE_CODE_PTR)
fetchlimit = UINT_MAX;
else
/* We work only with arrays and pointers. */
/* If the string lives in GDB's memory instead of the inferior's,
then we just need to copy it to BUFFER. Also, since such strings
are arrays with known size, FETCHLIMIT will hold the size of the
- array. */
+ array.
+
+ An array is assumed to live in GDB's memory, so we take this path
+ here.
+
+ However, it's possible for the caller to request more array
+ elements than apparently exist -- this can happen when using the
+ C struct hack. So, only do this if either no length was
+ specified, or the length is within the existing bounds. This
+ avoids running off the end of the value's contents. */
if ((VALUE_LVAL (value) == not_lval
- || VALUE_LVAL (value) == lval_internalvar)
- && fetchlimit != UINT_MAX)
+ || VALUE_LVAL (value) == lval_internalvar
+ || type->code () == TYPE_CODE_ARRAY)
+ && fetchlimit != UINT_MAX
+ && (*length < 0 || *length <= fetchlimit))
{
int i;
const gdb_byte *contents = value_contents (value);
if (*length >= 0)
i = *length;
else
- /* Otherwise, look for a null character. */
- for (i = 0; i < fetchlimit; i++)
+ /* Otherwise, look for a null character. */
+ for (i = 0; i < fetchlimit; i++)
if (extract_unsigned_integer (contents + i * width,
width, byte_order) == 0)
- break;
+ break;
/* I is now either a user-defined length, the number of non-null
- characters, or FETCHLIMIT. */
+ characters, or FETCHLIMIT. */
*length = i * width;
buffer->reset ((gdb_byte *) xmalloc (*length));
memcpy (buffer->get (), contents, *length);
}
else
{
- CORE_ADDR addr = value_as_address (value);
+ /* value_as_address does not return an address for an array when
+ c_style_arrays is false, so we handle that specially
+ here. */
+ CORE_ADDR addr;
+ if (type->code () == TYPE_CODE_ARRAY)
+ {
+ if (VALUE_LVAL (value) != lval_memory)
+ error (_("Attempt to take address of value "
+ "not located in memory."));
+ addr = value_address (value);
+ }
+ else
+ addr = value_as_address (value);
/* Prior to the fix for PR 16196 read_string would ignore fetchlimit
if length > 0. The old "broken" behaviour is the behaviour we want:
exp->gdbarch);
break;
case C_WIDE_STRING:
- type = lookup_typename (exp->language_defn, exp->gdbarch,
- "wchar_t", NULL, 0);
+ type = lookup_typename (exp->language_defn, "wchar_t", NULL, 0);
break;
case C_STRING_16:
- type = lookup_typename (exp->language_defn, exp->gdbarch,
- "char16_t", NULL, 0);
+ type = lookup_typename (exp->language_defn, "char16_t", NULL, 0);
break;
case C_STRING_32:
- type = lookup_typename (exp->language_defn, exp->gdbarch,
- "char32_t", NULL, 0);
+ type = lookup_typename (exp->language_defn, "char32_t", NULL, 0);
break;
default:
internal_error (__FILE__, __LINE__, _("unhandled c_string_type"));
/* If the caller expects an array of some integral type,
satisfy them. If something odder is expected, rely on the
caller to cast. */
- if (expect_type && TYPE_CODE (expect_type) == TYPE_CODE_ARRAY)
+ if (expect_type && expect_type->code () == TYPE_CODE_ARRAY)
{
struct type *element_type
= check_typedef (TYPE_TARGET_TYPE (expect_type));
- if (TYPE_CODE (element_type) == TYPE_CODE_INT
- || TYPE_CODE (element_type) == TYPE_CODE_CHAR)
+ if (element_type->code () == TYPE_CODE_INT
+ || element_type->code () == TYPE_CODE_CHAR)
{
type = element_type;
satisfy_expected = 1;
(xstrprintf ("* (%s *) %s", name.c_str (), core_addr_to_string (addr)));
}
+/* See c-lang.h. */
+
+bool
+c_is_string_type_p (struct type *type)
+{
+ type = check_typedef (type);
+ while (type->code () == TYPE_CODE_REF)
+ {
+ type = TYPE_TARGET_TYPE (type);
+ type = check_typedef (type);
+ }
+
+ switch (type->code ())
+ {
+ case TYPE_CODE_ARRAY:
+ {
+ /* See if target type looks like a string. */
+ struct type *array_target_type = TYPE_TARGET_TYPE (type);
+ return (TYPE_LENGTH (type) > 0
+ && TYPE_LENGTH (array_target_type) > 0
+ && c_textual_element_type (array_target_type, 0));
+ }
+ case TYPE_CODE_STRING:
+ return true;
+ case TYPE_CODE_PTR:
+ {
+ struct type *element_type = TYPE_TARGET_TYPE (type);
+ return c_textual_element_type (element_type, 0);
+ }
+ default:
+ break;
+ }
+
+ return false;
+}
+
\f
/* Table mapping opcodes into strings for printing operators
and precedences of the operators. */
".c", NULL
};
-extern const struct language_defn c_language_defn =
+/* Constant data that describes the C language. */
+
+extern const struct language_data c_language_data =
{
"c", /* Language name */
"C",
c_emit_char, /* Print a single char */
c_print_type, /* Print a type using appropriate syntax */
c_print_typedef, /* Print a typedef using appropriate syntax */
- c_val_print, /* Print a value using appropriate syntax */
+ c_value_print_inner, /* la_value_print_inner */
c_value_print, /* Print a top-level value */
default_read_var_value, /* la_read_var_value */
NULL, /* Language specific skip_trampoline */
c_language_arch_info,
default_print_array_index,
default_pass_by_reference,
- c_get_string,
c_watch_location_expression,
NULL, /* la_get_symbol_name_matcher */
iterate_over_symbols,
default_search_name_hash,
&c_varobj_ops,
c_get_compile_context,
- c_compute_program
+ c_compute_program,
+ c_is_string_type_p,
+ "{...}" /* la_struct_too_deep_ellipsis */
};
+/* Class representing the C language. */
+
+class c_language : public language_defn
+{
+public:
+ c_language ()
+ : language_defn (language_c, c_language_data)
+ { /* Nothing. */ }
+};
+
+/* Single instance of the C language class. */
+
+static c_language c_language_defn;
+
enum cplus_primitive_types {
cplus_primitive_type_int,
cplus_primitive_type_long,
".C", ".cc", ".cp", ".cpp", ".cxx", ".c++", NULL
};
-extern const struct language_defn cplus_language_defn =
+/* Constant data that describes the C++ language. */
+
+extern const struct language_data cplus_language_data =
{
"c++", /* Language name */
"C++",
c_emit_char, /* Print a single char */
c_print_type, /* Print a type using appropriate syntax */
c_print_typedef, /* Print a typedef using appropriate syntax */
- c_val_print, /* Print a value using appropriate syntax */
+ c_value_print_inner, /* la_value_print_inner */
c_value_print, /* Print a top-level value */
default_read_var_value, /* la_read_var_value */
cplus_skip_trampoline, /* Language specific skip_trampoline */
cplus_language_arch_info,
default_print_array_index,
cp_pass_by_reference,
- c_get_string,
c_watch_location_expression,
cp_get_symbol_name_matcher,
iterate_over_symbols,
cp_search_name_hash,
&cplus_varobj_ops,
cplus_get_compile_context,
- cplus_compute_program
+ cplus_compute_program,
+ c_is_string_type_p,
+ "{...}" /* la_struct_too_deep_ellipsis */
+};
+
+/* A class for the C++ language. */
+
+class cplus_language : public language_defn
+{
+public:
+ cplus_language ()
+ : language_defn (language_cplus, cplus_language_data)
+ { /* Nothing. */ }
};
+/* The single instance of the C++ language class. */
+
+static cplus_language cplus_language_defn;
+
static const char *asm_extensions[] =
{
".s", ".sx", ".S", NULL
};
-extern const struct language_defn asm_language_defn =
+/* Constant data that describes the ASM language. */
+
+extern const struct language_data asm_language_data =
{
"asm", /* Language name */
"assembly",
c_emit_char, /* Print a single char */
c_print_type, /* Print a type using appropriate syntax */
c_print_typedef, /* Print a typedef using appropriate syntax */
- c_val_print, /* Print a value using appropriate syntax */
+ c_value_print_inner, /* la_value_print_inner */
c_value_print, /* Print a top-level value */
default_read_var_value, /* la_read_var_value */
NULL, /* Language specific skip_trampoline */
0, /* String lower bound */
default_word_break_characters,
default_collect_symbol_completion_matches,
- c_language_arch_info, /* FIXME: la_language_arch_info. */
+ c_language_arch_info, /* FIXME: la_language_arch_info. */
default_print_array_index,
default_pass_by_reference,
- c_get_string,
c_watch_location_expression,
NULL, /* la_get_symbol_name_matcher */
iterate_over_symbols,
default_search_name_hash,
&default_varobj_ops,
NULL,
- NULL
+ NULL,
+ c_is_string_type_p,
+ "{...}" /* la_struct_too_deep_ellipsis */
+};
+
+/* A class for the ASM language. */
+
+class asm_language : public language_defn
+{
+public:
+ asm_language ()
+ : language_defn (language_asm, asm_language_data)
+ { /* Nothing. */ }
};
+/* The single instance of the ASM language class. */
+static asm_language asm_language_defn;
+
/* The following language_defn does not represent a real language.
It just provides a minimal support a-la-C that should allow users
to do some simple operations when debugging applications that use
a language currently not supported by GDB. */
-extern const struct language_defn minimal_language_defn =
+extern const struct language_data minimal_language_data =
{
"minimal", /* Language name */
"Minimal",
c_emit_char, /* Print a single char */
c_print_type, /* Print a type using appropriate syntax */
c_print_typedef, /* Print a typedef using appropriate syntax */
- c_val_print, /* Print a value using appropriate syntax */
+ c_value_print_inner, /* la_value_print_inner */
c_value_print, /* Print a top-level value */
default_read_var_value, /* la_read_var_value */
NULL, /* Language specific skip_trampoline */
c_language_arch_info,
default_print_array_index,
default_pass_by_reference,
- c_get_string,
c_watch_location_expression,
NULL, /* la_get_symbol_name_matcher */
iterate_over_symbols,
default_search_name_hash,
&default_varobj_ops,
NULL,
- NULL
+ NULL,
+ c_is_string_type_p,
+ "{...}" /* la_struct_too_deep_ellipsis */
+};
+
+/* A class for the minimal language. */
+
+class minimal_language : public language_defn
+{
+public:
+ minimal_language ()
+ : language_defn (language_minimal, minimal_language_data)
+ { /* Nothing. */ }
};
+
+/* The single instance of the minimal language class. */
+static minimal_language minimal_language_defn;
projects / deliverable / binutils-gdb.git / blobdiff