mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-12-21 04:42:53 +08:00
1c0e43634c
The Rust compiler plans to change the encoding of a Rust 'char' type
to use DW_ATE_UTF. You can see the discussion here:
https://github.com/rust-lang/rust/pull/89887
However, this fails in gdb. I looked into this, and it turns out that
the handling of DW_ATE_UTF is currently fairly specific to C++. In
particular, the code here assumes the C++ type names, and it creates
an integer type.
This comes from commit 53e710acd
("GDB thinks char16_t and char32_t
are signed in C++"). The message says:
Both places need fixing. But since I couldn't tell why dwarf2read.c
needs to create a new type, I've made it use the per-arch built-in
types instead, so that the types are only created once per arch
instead of once per objfile. That seems to work fine.
... which is fine, but it seems to me that it's also correct to make a
new character type; and this approach is better because it preserves
the type name as well. This does use more memory, but first we
shouldn't be too concerned about the memory use of types coming from
debuginfo; and second, if we are, we should implement type interning
anyway.
Changing this code to use a character type revealed a couple of
oddities in the C/C++ handling of TYPE_CODE_CHAR. This patch fixes
these as well.
I filed PR rust/28637 for this issue, so that this patch can be
backported to the gdb 11 branch.
1137 lines
30 KiB
C
1137 lines
30 KiB
C
/* C language support routines for GDB, the GNU debugger.
|
||
|
||
Copyright (C) 1992-2021 Free Software Foundation, Inc.
|
||
|
||
This file is part of GDB.
|
||
|
||
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 "defs.h"
|
||
#include "symtab.h"
|
||
#include "gdbtypes.h"
|
||
#include "expression.h"
|
||
#include "parser-defs.h"
|
||
#include "language.h"
|
||
#include "varobj.h"
|
||
#include "c-lang.h"
|
||
#include "c-support.h"
|
||
#include "valprint.h"
|
||
#include "macroscope.h"
|
||
#include "charset.h"
|
||
#include "demangle.h"
|
||
#include "cp-abi.h"
|
||
#include "cp-support.h"
|
||
#include "gdb_obstack.h"
|
||
#include <ctype.h>
|
||
#include "gdbcore.h"
|
||
#include "gdbarch.h"
|
||
#include "compile/compile-internal.h"
|
||
#include "c-exp.h"
|
||
|
||
/* Given a C string type, STR_TYPE, return the corresponding target
|
||
character set name. */
|
||
|
||
static const char *
|
||
charset_for_string_type (c_string_type str_type, struct gdbarch *gdbarch)
|
||
{
|
||
switch (str_type & ~C_CHAR)
|
||
{
|
||
case C_STRING:
|
||
return target_charset (gdbarch);
|
||
case C_WIDE_STRING:
|
||
return target_wide_charset (gdbarch);
|
||
case C_STRING_16:
|
||
/* FIXME: UTF-16 is not always correct. */
|
||
if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
|
||
return "UTF-16BE";
|
||
else
|
||
return "UTF-16LE";
|
||
case C_STRING_32:
|
||
/* FIXME: UTF-32 is not always correct. */
|
||
if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
|
||
return "UTF-32BE";
|
||
else
|
||
return "UTF-32LE";
|
||
}
|
||
internal_error (__FILE__, __LINE__, _("unhandled c_string_type"));
|
||
}
|
||
|
||
/* Classify ELTTYPE according to what kind of character it is. Return
|
||
the enum constant representing the character type. Also set
|
||
*ENCODING to the name of the character set to use when converting
|
||
characters of this type in target BYTE_ORDER to the host character
|
||
set. */
|
||
|
||
static c_string_type
|
||
classify_type (struct type *elttype, struct gdbarch *gdbarch,
|
||
const char **encoding)
|
||
{
|
||
c_string_type result;
|
||
|
||
/* We loop because ELTTYPE may be a typedef, and we want to
|
||
successively peel each typedef until we reach a type we
|
||
understand. We don't use CHECK_TYPEDEF because that will strip
|
||
all typedefs at once -- but in C, wchar_t is itself a typedef, so
|
||
that would do the wrong thing. */
|
||
while (elttype)
|
||
{
|
||
const char *name = elttype->name ();
|
||
|
||
if (name == nullptr)
|
||
{
|
||
result = C_CHAR;
|
||
goto done;
|
||
}
|
||
|
||
if (!strcmp (name, "wchar_t"))
|
||
{
|
||
result = C_WIDE_CHAR;
|
||
goto done;
|
||
}
|
||
|
||
if (!strcmp (name, "char16_t"))
|
||
{
|
||
result = C_CHAR_16;
|
||
goto done;
|
||
}
|
||
|
||
if (!strcmp (name, "char32_t"))
|
||
{
|
||
result = C_CHAR_32;
|
||
goto done;
|
||
}
|
||
|
||
if (elttype->code () != TYPE_CODE_TYPEDEF)
|
||
break;
|
||
|
||
/* Call for side effects. */
|
||
check_typedef (elttype);
|
||
|
||
if (TYPE_TARGET_TYPE (elttype))
|
||
elttype = TYPE_TARGET_TYPE (elttype);
|
||
else
|
||
{
|
||
/* Perhaps check_typedef did not update the target type. In
|
||
this case, force the lookup again and hope it works out.
|
||
It never will for C, but it might for C++. */
|
||
elttype = check_typedef (elttype);
|
||
}
|
||
}
|
||
|
||
/* Punt. */
|
||
result = C_CHAR;
|
||
|
||
done:
|
||
if (encoding)
|
||
*encoding = charset_for_string_type (result, gdbarch);
|
||
|
||
return result;
|
||
}
|
||
|
||
/* Print the character C on STREAM as part of the contents of a
|
||
literal string whose delimiter is QUOTER. Note that that format
|
||
for printing characters and strings is language specific. */
|
||
|
||
void
|
||
c_emit_char (int c, struct type *type,
|
||
struct ui_file *stream, int quoter)
|
||
{
|
||
const char *encoding;
|
||
|
||
classify_type (type, type->arch (), &encoding);
|
||
generic_emit_char (c, type, stream, quoter, encoding);
|
||
}
|
||
|
||
/* See language.h. */
|
||
|
||
void
|
||
language_defn::printchar (int c, struct type *type,
|
||
struct ui_file * stream) const
|
||
{
|
||
c_string_type str_type;
|
||
|
||
str_type = classify_type (type, type->arch (), NULL);
|
||
switch (str_type)
|
||
{
|
||
case C_CHAR:
|
||
break;
|
||
case C_WIDE_CHAR:
|
||
fputc_filtered ('L', stream);
|
||
break;
|
||
case C_CHAR_16:
|
||
fputc_filtered ('u', stream);
|
||
break;
|
||
case C_CHAR_32:
|
||
fputc_filtered ('U', stream);
|
||
break;
|
||
}
|
||
|
||
fputc_filtered ('\'', stream);
|
||
emitchar (c, type, stream, '\'');
|
||
fputc_filtered ('\'', stream);
|
||
}
|
||
|
||
/* Print the character string STRING, printing at most LENGTH
|
||
characters. LENGTH is -1 if the string is nul terminated. Each
|
||
character is WIDTH bytes long. Printing stops early if the number
|
||
hits print_max; repeat counts are printed as appropriate. Print
|
||
ellipses at the end if we had to stop before printing LENGTH
|
||
characters, or if FORCE_ELLIPSES. */
|
||
|
||
void
|
||
c_printstr (struct ui_file *stream, struct type *type,
|
||
const gdb_byte *string, unsigned int length,
|
||
const char *user_encoding, int force_ellipses,
|
||
const struct value_print_options *options)
|
||
{
|
||
c_string_type str_type;
|
||
const char *type_encoding;
|
||
const char *encoding;
|
||
|
||
str_type = (classify_type (type, type->arch (), &type_encoding)
|
||
& ~C_CHAR);
|
||
switch (str_type)
|
||
{
|
||
case C_STRING:
|
||
break;
|
||
case C_WIDE_STRING:
|
||
fputs_filtered ("L", stream);
|
||
break;
|
||
case C_STRING_16:
|
||
fputs_filtered ("u", stream);
|
||
break;
|
||
case C_STRING_32:
|
||
fputs_filtered ("U", stream);
|
||
break;
|
||
}
|
||
|
||
encoding = (user_encoding && *user_encoding) ? user_encoding : type_encoding;
|
||
|
||
generic_printstr (stream, type, string, length, encoding, force_ellipses,
|
||
'"', 1, options);
|
||
}
|
||
|
||
/* Obtain a C string from the inferior storing it in a newly allocated
|
||
buffer in BUFFER, which should be freed by the caller. If the in-
|
||
and out-parameter *LENGTH is specified at -1, the string is read
|
||
until a null character of the appropriate width is found, otherwise
|
||
the string is read to the length of characters specified. The size
|
||
of a character is determined by the length of the target type of
|
||
the pointer or array.
|
||
|
||
If VALUE is an array with a known length, and *LENGTH is -1,
|
||
the function will not read past the end of the array. However, any
|
||
declared size of the array is ignored if *LENGTH > 0.
|
||
|
||
On completion, *LENGTH will be set to the size of the string read in
|
||
characters. (If a length of -1 is specified, the length returned
|
||
will not include the null character). CHARSET is always set to the
|
||
target charset. */
|
||
|
||
void
|
||
c_get_string (struct value *value, gdb::unique_xmalloc_ptr<gdb_byte> *buffer,
|
||
int *length, struct type **char_type,
|
||
const char **charset)
|
||
{
|
||
int err, width;
|
||
unsigned int fetchlimit;
|
||
struct type *type = check_typedef (value_type (value));
|
||
struct type *element_type = TYPE_TARGET_TYPE (type);
|
||
int req_length = *length;
|
||
enum bfd_endian byte_order
|
||
= type_byte_order (type);
|
||
|
||
if (element_type == NULL)
|
||
goto error;
|
||
|
||
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->num_fields () == 1
|
||
&& type->field (0).type ()->code () == TYPE_CODE_RANGE)
|
||
{
|
||
LONGEST low_bound, high_bound;
|
||
|
||
get_discrete_bounds (type->field (0).type (),
|
||
&low_bound, &high_bound);
|
||
fetchlimit = high_bound - low_bound + 1;
|
||
}
|
||
else
|
||
fetchlimit = UINT_MAX;
|
||
}
|
||
else if (type->code () == TYPE_CODE_PTR)
|
||
fetchlimit = UINT_MAX;
|
||
else
|
||
/* We work only with arrays and pointers. */
|
||
goto error;
|
||
|
||
if (! c_textual_element_type (element_type, 0))
|
||
goto error;
|
||
classify_type (element_type, element_type->arch (), charset);
|
||
width = TYPE_LENGTH (element_type);
|
||
|
||
/* 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.
|
||
|
||
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
|
||
|| type->code () == TYPE_CODE_ARRAY)
|
||
&& fetchlimit != UINT_MAX
|
||
&& (*length < 0 || *length <= fetchlimit))
|
||
{
|
||
int i;
|
||
const gdb_byte *contents = value_contents (value).data ();
|
||
|
||
/* If a length is specified, use that. */
|
||
if (*length >= 0)
|
||
i = *length;
|
||
else
|
||
/* Otherwise, look for a null character. */
|
||
for (i = 0; i < fetchlimit; i++)
|
||
if (extract_unsigned_integer (contents + i * width,
|
||
width, byte_order) == 0)
|
||
break;
|
||
|
||
/* I is now either a user-defined length, the number of non-null
|
||
characters, or FETCHLIMIT. */
|
||
*length = i * width;
|
||
buffer->reset ((gdb_byte *) xmalloc (*length));
|
||
memcpy (buffer->get (), contents, *length);
|
||
err = 0;
|
||
}
|
||
else
|
||
{
|
||
/* 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:
|
||
The caller may want to fetch 100 bytes from a variable length array
|
||
implemented using the common idiom of having an array of length 1 at
|
||
the end of a struct. In this case we want to ignore the declared
|
||
size of the array. However, it's counterintuitive to implement that
|
||
behaviour in read_string: what does fetchlimit otherwise mean if
|
||
length > 0. Therefore we implement the behaviour we want here:
|
||
If *length > 0, don't specify a fetchlimit. This preserves the
|
||
previous behaviour. We could move this check above where we know
|
||
whether the array is declared with a fixed size, but we only want
|
||
to apply this behaviour when calling read_string. PR 16286. */
|
||
if (*length > 0)
|
||
fetchlimit = UINT_MAX;
|
||
|
||
err = read_string (addr, *length, width, fetchlimit,
|
||
byte_order, buffer, length);
|
||
if (err != 0)
|
||
memory_error (TARGET_XFER_E_IO, addr);
|
||
}
|
||
|
||
/* If the LENGTH is specified at -1, we want to return the string
|
||
length up to the terminating null character. If an actual length
|
||
was specified, we want to return the length of exactly what was
|
||
read. */
|
||
if (req_length == -1)
|
||
/* If the last character is null, subtract it from LENGTH. */
|
||
if (*length > 0
|
||
&& extract_unsigned_integer (buffer->get () + *length - width,
|
||
width, byte_order) == 0)
|
||
*length -= width;
|
||
|
||
/* The read_string function will return the number of bytes read.
|
||
If length returned from read_string was > 0, return the number of
|
||
characters read by dividing the number of bytes by width. */
|
||
if (*length != 0)
|
||
*length = *length / width;
|
||
|
||
*char_type = element_type;
|
||
|
||
return;
|
||
|
||
error:
|
||
{
|
||
std::string type_str = type_to_string (type);
|
||
if (!type_str.empty ())
|
||
{
|
||
error (_("Trying to read string with inappropriate type `%s'."),
|
||
type_str.c_str ());
|
||
}
|
||
else
|
||
error (_("Trying to read string with inappropriate type."));
|
||
}
|
||
}
|
||
|
||
|
||
/* Evaluating C and C++ expressions. */
|
||
|
||
/* Convert a UCN. The digits of the UCN start at P and extend no
|
||
farther than LIMIT. DEST_CHARSET is the name of the character set
|
||
into which the UCN should be converted. The results are written to
|
||
OUTPUT. LENGTH is the maximum length of the UCN, either 4 or 8.
|
||
Returns a pointer to just after the final digit of the UCN. */
|
||
|
||
static const char *
|
||
convert_ucn (const char *p, const char *limit, const char *dest_charset,
|
||
struct obstack *output, int length)
|
||
{
|
||
unsigned long result = 0;
|
||
gdb_byte data[4];
|
||
int i;
|
||
|
||
for (i = 0; i < length && p < limit && ISXDIGIT (*p); ++i, ++p)
|
||
result = (result << 4) + host_hex_value (*p);
|
||
|
||
for (i = 3; i >= 0; --i)
|
||
{
|
||
data[i] = result & 0xff;
|
||
result >>= 8;
|
||
}
|
||
|
||
convert_between_encodings ("UTF-32BE", dest_charset, data,
|
||
4, 4, output, translit_none);
|
||
|
||
return p;
|
||
}
|
||
|
||
/* Emit a character, VALUE, which was specified numerically, to
|
||
OUTPUT. TYPE is the target character type. */
|
||
|
||
static void
|
||
emit_numeric_character (struct type *type, unsigned long value,
|
||
struct obstack *output)
|
||
{
|
||
gdb_byte *buffer;
|
||
|
||
buffer = (gdb_byte *) alloca (TYPE_LENGTH (type));
|
||
pack_long (buffer, type, value);
|
||
obstack_grow (output, buffer, TYPE_LENGTH (type));
|
||
}
|
||
|
||
/* Convert an octal escape sequence. TYPE is the target character
|
||
type. The digits of the escape sequence begin at P and extend no
|
||
farther than LIMIT. The result is written to OUTPUT. Returns a
|
||
pointer to just after the final digit of the escape sequence. */
|
||
|
||
static const char *
|
||
convert_octal (struct type *type, const char *p,
|
||
const char *limit, struct obstack *output)
|
||
{
|
||
int i;
|
||
unsigned long value = 0;
|
||
|
||
for (i = 0;
|
||
i < 3 && p < limit && ISDIGIT (*p) && *p != '8' && *p != '9';
|
||
++i)
|
||
{
|
||
value = 8 * value + host_hex_value (*p);
|
||
++p;
|
||
}
|
||
|
||
emit_numeric_character (type, value, output);
|
||
|
||
return p;
|
||
}
|
||
|
||
/* Convert a hex escape sequence. TYPE is the target character type.
|
||
The digits of the escape sequence begin at P and extend no farther
|
||
than LIMIT. The result is written to OUTPUT. Returns a pointer to
|
||
just after the final digit of the escape sequence. */
|
||
|
||
static const char *
|
||
convert_hex (struct type *type, const char *p,
|
||
const char *limit, struct obstack *output)
|
||
{
|
||
unsigned long value = 0;
|
||
|
||
while (p < limit && ISXDIGIT (*p))
|
||
{
|
||
value = 16 * value + host_hex_value (*p);
|
||
++p;
|
||
}
|
||
|
||
emit_numeric_character (type, value, output);
|
||
|
||
return p;
|
||
}
|
||
|
||
#define ADVANCE \
|
||
do { \
|
||
++p; \
|
||
if (p == limit) \
|
||
error (_("Malformed escape sequence")); \
|
||
} while (0)
|
||
|
||
/* Convert an escape sequence to a target format. TYPE is the target
|
||
character type to use, and DEST_CHARSET is the name of the target
|
||
character set. The backslash of the escape sequence is at *P, and
|
||
the escape sequence will not extend past LIMIT. The results are
|
||
written to OUTPUT. Returns a pointer to just past the final
|
||
character of the escape sequence. */
|
||
|
||
static const char *
|
||
convert_escape (struct type *type, const char *dest_charset,
|
||
const char *p, const char *limit, struct obstack *output)
|
||
{
|
||
/* Skip the backslash. */
|
||
ADVANCE;
|
||
|
||
switch (*p)
|
||
{
|
||
case '\\':
|
||
obstack_1grow (output, '\\');
|
||
++p;
|
||
break;
|
||
|
||
case 'x':
|
||
ADVANCE;
|
||
if (!ISXDIGIT (*p))
|
||
error (_("\\x used with no following hex digits."));
|
||
p = convert_hex (type, p, limit, output);
|
||
break;
|
||
|
||
case '0':
|
||
case '1':
|
||
case '2':
|
||
case '3':
|
||
case '4':
|
||
case '5':
|
||
case '6':
|
||
case '7':
|
||
p = convert_octal (type, p, limit, output);
|
||
break;
|
||
|
||
case 'u':
|
||
case 'U':
|
||
{
|
||
int length = *p == 'u' ? 4 : 8;
|
||
|
||
ADVANCE;
|
||
if (!ISXDIGIT (*p))
|
||
error (_("\\u used with no following hex digits"));
|
||
p = convert_ucn (p, limit, dest_charset, output, length);
|
||
}
|
||
}
|
||
|
||
return p;
|
||
}
|
||
|
||
/* Given a single string from a (C-specific) OP_STRING list, convert
|
||
it to a target string, handling escape sequences specially. The
|
||
output is written to OUTPUT. DATA is the input string, which has
|
||
length LEN. DEST_CHARSET is the name of the target character set,
|
||
and TYPE is the type of target character to use. */
|
||
|
||
static void
|
||
parse_one_string (struct obstack *output, const char *data, int len,
|
||
const char *dest_charset, struct type *type)
|
||
{
|
||
const char *limit;
|
||
|
||
limit = data + len;
|
||
|
||
while (data < limit)
|
||
{
|
||
const char *p = data;
|
||
|
||
/* Look for next escape, or the end of the input. */
|
||
while (p < limit && *p != '\\')
|
||
++p;
|
||
/* If we saw a run of characters, convert them all. */
|
||
if (p > data)
|
||
convert_between_encodings (host_charset (), dest_charset,
|
||
(const gdb_byte *) data, p - data, 1,
|
||
output, translit_none);
|
||
/* If we saw an escape, convert it. */
|
||
if (p < limit)
|
||
p = convert_escape (type, dest_charset, p, limit, output);
|
||
data = p;
|
||
}
|
||
}
|
||
|
||
namespace expr
|
||
{
|
||
|
||
value *
|
||
c_string_operation::evaluate (struct type *expect_type,
|
||
struct expression *exp,
|
||
enum noside noside)
|
||
{
|
||
struct type *type;
|
||
struct value *result;
|
||
c_string_type dest_type;
|
||
const char *dest_charset;
|
||
int satisfy_expected = 0;
|
||
|
||
auto_obstack output;
|
||
|
||
dest_type = std::get<0> (m_storage);
|
||
|
||
switch (dest_type & ~C_CHAR)
|
||
{
|
||
case C_STRING:
|
||
type = language_string_char_type (exp->language_defn,
|
||
exp->gdbarch);
|
||
break;
|
||
case C_WIDE_STRING:
|
||
type = lookup_typename (exp->language_defn, "wchar_t", NULL, 0);
|
||
break;
|
||
case C_STRING_16:
|
||
type = lookup_typename (exp->language_defn, "char16_t", NULL, 0);
|
||
break;
|
||
case C_STRING_32:
|
||
type = lookup_typename (exp->language_defn, "char32_t", NULL, 0);
|
||
break;
|
||
default:
|
||
internal_error (__FILE__, __LINE__, _("unhandled c_string_type"));
|
||
}
|
||
|
||
/* Ensure TYPE_LENGTH is valid for TYPE. */
|
||
check_typedef (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 && expect_type->code () == TYPE_CODE_ARRAY)
|
||
{
|
||
struct type *element_type
|
||
= check_typedef (TYPE_TARGET_TYPE (expect_type));
|
||
|
||
if (element_type->code () == TYPE_CODE_INT
|
||
|| element_type->code () == TYPE_CODE_CHAR)
|
||
{
|
||
type = element_type;
|
||
satisfy_expected = 1;
|
||
}
|
||
}
|
||
|
||
dest_charset = charset_for_string_type (dest_type, exp->gdbarch);
|
||
|
||
for (const std::string &item : std::get<1> (m_storage))
|
||
parse_one_string (&output, item.c_str (), item.size (),
|
||
dest_charset, type);
|
||
|
||
if ((dest_type & C_CHAR) != 0)
|
||
{
|
||
LONGEST value;
|
||
|
||
if (obstack_object_size (&output) != TYPE_LENGTH (type))
|
||
error (_("Could not convert character "
|
||
"constant to target character set"));
|
||
value = unpack_long (type, (gdb_byte *) obstack_base (&output));
|
||
result = value_from_longest (type, value);
|
||
}
|
||
else
|
||
{
|
||
int i;
|
||
|
||
/* Write the terminating character. */
|
||
for (i = 0; i < TYPE_LENGTH (type); ++i)
|
||
obstack_1grow (&output, 0);
|
||
|
||
if (satisfy_expected)
|
||
{
|
||
LONGEST low_bound, high_bound;
|
||
int element_size = TYPE_LENGTH (type);
|
||
|
||
if (!get_discrete_bounds (expect_type->index_type (),
|
||
&low_bound, &high_bound))
|
||
{
|
||
low_bound = 0;
|
||
high_bound = (TYPE_LENGTH (expect_type) / element_size) - 1;
|
||
}
|
||
if (obstack_object_size (&output) / element_size
|
||
> (high_bound - low_bound + 1))
|
||
error (_("Too many array elements"));
|
||
|
||
result = allocate_value (expect_type);
|
||
memcpy (value_contents_raw (result).data (), obstack_base (&output),
|
||
obstack_object_size (&output));
|
||
}
|
||
else
|
||
result = value_cstring ((const char *) obstack_base (&output),
|
||
obstack_object_size (&output),
|
||
type);
|
||
}
|
||
return result;
|
||
}
|
||
|
||
} /* namespace expr */
|
||
|
||
|
||
/* 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;
|
||
}
|
||
|
||
|
||
|
||
void
|
||
c_language_arch_info (struct gdbarch *gdbarch,
|
||
struct language_arch_info *lai)
|
||
{
|
||
const struct builtin_type *builtin = builtin_type (gdbarch);
|
||
|
||
/* Helper function to allow shorter lines below. */
|
||
auto add = [&] (struct type * t)
|
||
{
|
||
lai->add_primitive_type (t);
|
||
};
|
||
|
||
add (builtin->builtin_int);
|
||
add (builtin->builtin_long);
|
||
add (builtin->builtin_short);
|
||
add (builtin->builtin_char);
|
||
add (builtin->builtin_float);
|
||
add (builtin->builtin_double);
|
||
add (builtin->builtin_void);
|
||
add (builtin->builtin_long_long);
|
||
add (builtin->builtin_signed_char);
|
||
add (builtin->builtin_unsigned_char);
|
||
add (builtin->builtin_unsigned_short);
|
||
add (builtin->builtin_unsigned_int);
|
||
add (builtin->builtin_unsigned_long);
|
||
add (builtin->builtin_unsigned_long_long);
|
||
add (builtin->builtin_long_double);
|
||
add (builtin->builtin_complex);
|
||
add (builtin->builtin_double_complex);
|
||
add (builtin->builtin_decfloat);
|
||
add (builtin->builtin_decdouble);
|
||
add (builtin->builtin_declong);
|
||
|
||
lai->set_string_char_type (builtin->builtin_char);
|
||
lai->set_bool_type (builtin->builtin_int);
|
||
}
|
||
|
||
/* Class representing the C language. */
|
||
|
||
class c_language : public language_defn
|
||
{
|
||
public:
|
||
c_language ()
|
||
: language_defn (language_c)
|
||
{ /* Nothing. */ }
|
||
|
||
/* See language.h. */
|
||
|
||
const char *name () const override
|
||
{ return "c"; }
|
||
|
||
/* See language.h. */
|
||
|
||
const char *natural_name () const override
|
||
{ return "C"; }
|
||
|
||
/* See language.h. */
|
||
|
||
const std::vector<const char *> &filename_extensions () const override
|
||
{
|
||
static const std::vector<const char *> extensions = { ".c" };
|
||
return extensions;
|
||
}
|
||
|
||
/* See language.h. */
|
||
void language_arch_info (struct gdbarch *gdbarch,
|
||
struct language_arch_info *lai) const override
|
||
{
|
||
c_language_arch_info (gdbarch, lai);
|
||
}
|
||
|
||
/* See language.h. */
|
||
std::unique_ptr<compile_instance> get_compile_instance () const override
|
||
{
|
||
return c_get_compile_context ();
|
||
}
|
||
|
||
/* See language.h. */
|
||
std::string compute_program (compile_instance *inst,
|
||
const char *input,
|
||
struct gdbarch *gdbarch,
|
||
const struct block *expr_block,
|
||
CORE_ADDR expr_pc) const override
|
||
{
|
||
return c_compute_program (inst, input, gdbarch, expr_block, expr_pc);
|
||
}
|
||
|
||
/* See language.h. */
|
||
|
||
void print_type (struct type *type, const char *varstring,
|
||
struct ui_file *stream, int show, int level,
|
||
const struct type_print_options *flags) const override
|
||
{
|
||
c_print_type (type, varstring, stream, show, level, flags);
|
||
}
|
||
|
||
/* See language.h. */
|
||
|
||
bool store_sym_names_in_linkage_form_p () const override
|
||
{ return true; }
|
||
|
||
/* See language.h. */
|
||
|
||
enum macro_expansion macro_expansion () const override
|
||
{ return macro_expansion_c; }
|
||
};
|
||
|
||
/* Single instance of the C language class. */
|
||
|
||
static c_language c_language_defn;
|
||
|
||
/* A class for the C++ language. */
|
||
|
||
class cplus_language : public language_defn
|
||
{
|
||
public:
|
||
cplus_language ()
|
||
: language_defn (language_cplus)
|
||
{ /* Nothing. */ }
|
||
|
||
/* See language.h. */
|
||
|
||
const char *name () const override
|
||
{ return "c++"; }
|
||
|
||
/* See language.h. */
|
||
|
||
const char *natural_name () const override
|
||
{ return "C++"; }
|
||
|
||
/* See language.h. */
|
||
|
||
const std::vector<const char *> &filename_extensions () const override
|
||
{
|
||
static const std::vector<const char *> extensions
|
||
= { ".C", ".cc", ".cp", ".cpp", ".cxx", ".c++" };
|
||
return extensions;
|
||
}
|
||
|
||
/* See language.h. */
|
||
|
||
struct language_pass_by_ref_info pass_by_reference_info
|
||
(struct type *type) const override
|
||
{
|
||
return cp_pass_by_reference (type);
|
||
}
|
||
|
||
/* See language.h. */
|
||
void language_arch_info (struct gdbarch *gdbarch,
|
||
struct language_arch_info *lai) const override
|
||
{
|
||
const struct builtin_type *builtin = builtin_type (gdbarch);
|
||
|
||
/* Helper function to allow shorter lines below. */
|
||
auto add = [&] (struct type * t)
|
||
{
|
||
lai->add_primitive_type (t);
|
||
};
|
||
|
||
add (builtin->builtin_int);
|
||
add (builtin->builtin_long);
|
||
add (builtin->builtin_short);
|
||
add (builtin->builtin_char);
|
||
add (builtin->builtin_float);
|
||
add (builtin->builtin_double);
|
||
add (builtin->builtin_void);
|
||
add (builtin->builtin_long_long);
|
||
add (builtin->builtin_signed_char);
|
||
add (builtin->builtin_unsigned_char);
|
||
add (builtin->builtin_unsigned_short);
|
||
add (builtin->builtin_unsigned_int);
|
||
add (builtin->builtin_unsigned_long);
|
||
add (builtin->builtin_unsigned_long_long);
|
||
add (builtin->builtin_long_double);
|
||
add (builtin->builtin_complex);
|
||
add (builtin->builtin_double_complex);
|
||
add (builtin->builtin_bool);
|
||
add (builtin->builtin_decfloat);
|
||
add (builtin->builtin_decdouble);
|
||
add (builtin->builtin_declong);
|
||
add (builtin->builtin_char16);
|
||
add (builtin->builtin_char32);
|
||
add (builtin->builtin_wchar);
|
||
|
||
lai->set_string_char_type (builtin->builtin_char);
|
||
lai->set_bool_type (builtin->builtin_bool, "bool");
|
||
}
|
||
|
||
/* See language.h. */
|
||
struct type *lookup_transparent_type (const char *name) const override
|
||
{
|
||
return cp_lookup_transparent_type (name);
|
||
}
|
||
|
||
/* See language.h. */
|
||
std::unique_ptr<compile_instance> get_compile_instance () const override
|
||
{
|
||
return cplus_get_compile_context ();
|
||
}
|
||
|
||
/* See language.h. */
|
||
std::string compute_program (compile_instance *inst,
|
||
const char *input,
|
||
struct gdbarch *gdbarch,
|
||
const struct block *expr_block,
|
||
CORE_ADDR expr_pc) const override
|
||
{
|
||
return cplus_compute_program (inst, input, gdbarch, expr_block, expr_pc);
|
||
}
|
||
|
||
/* See language.h. */
|
||
unsigned int search_name_hash (const char *name) const override
|
||
{
|
||
return cp_search_name_hash (name);
|
||
}
|
||
|
||
/* See language.h. */
|
||
bool sniff_from_mangled_name
|
||
(const char *mangled,
|
||
gdb::unique_xmalloc_ptr<char> *demangled) const override
|
||
{
|
||
*demangled = gdb_demangle (mangled, DMGL_PARAMS | DMGL_ANSI);
|
||
return *demangled != NULL;
|
||
}
|
||
|
||
/* See language.h. */
|
||
|
||
gdb::unique_xmalloc_ptr<char> demangle_symbol (const char *mangled,
|
||
int options) const override
|
||
{
|
||
return gdb_demangle (mangled, options);
|
||
}
|
||
|
||
/* See language.h. */
|
||
|
||
void print_type (struct type *type, const char *varstring,
|
||
struct ui_file *stream, int show, int level,
|
||
const struct type_print_options *flags) const override
|
||
{
|
||
c_print_type (type, varstring, stream, show, level, flags);
|
||
}
|
||
|
||
/* See language.h. */
|
||
|
||
CORE_ADDR skip_trampoline (struct frame_info *fi,
|
||
CORE_ADDR pc) const override
|
||
{
|
||
return cplus_skip_trampoline (fi, pc);
|
||
}
|
||
|
||
/* See language.h. */
|
||
|
||
char *class_name_from_physname (const char *physname) const override
|
||
{
|
||
return cp_class_name_from_physname (physname);
|
||
}
|
||
|
||
/* See language.h. */
|
||
|
||
struct block_symbol lookup_symbol_nonlocal
|
||
(const char *name, const struct block *block,
|
||
const domain_enum domain) const override
|
||
{
|
||
return cp_lookup_symbol_nonlocal (this, name, block, domain);
|
||
}
|
||
|
||
/* See language.h. */
|
||
|
||
const char *name_of_this () const override
|
||
{ return "this"; }
|
||
|
||
/* See language.h. */
|
||
|
||
enum macro_expansion macro_expansion () const override
|
||
{ return macro_expansion_c; }
|
||
|
||
/* See language.h. */
|
||
|
||
const struct lang_varobj_ops *varobj_ops () const override
|
||
{ return &cplus_varobj_ops; }
|
||
|
||
protected:
|
||
|
||
/* See language.h. */
|
||
|
||
symbol_name_matcher_ftype *get_symbol_name_matcher_inner
|
||
(const lookup_name_info &lookup_name) const override
|
||
{
|
||
return cp_get_symbol_name_matcher (lookup_name);
|
||
}
|
||
};
|
||
|
||
/* The single instance of the C++ language class. */
|
||
|
||
static cplus_language cplus_language_defn;
|
||
|
||
/* A class for the ASM language. */
|
||
|
||
class asm_language : public language_defn
|
||
{
|
||
public:
|
||
asm_language ()
|
||
: language_defn (language_asm)
|
||
{ /* Nothing. */ }
|
||
|
||
/* See language.h. */
|
||
|
||
const char *name () const override
|
||
{ return "asm"; }
|
||
|
||
/* See language.h. */
|
||
|
||
const char *natural_name () const override
|
||
{ return "Assembly"; }
|
||
|
||
/* See language.h. */
|
||
|
||
const std::vector<const char *> &filename_extensions () const override
|
||
{
|
||
static const std::vector<const char *> extensions
|
||
= { ".s", ".sx", ".S" };
|
||
return extensions;
|
||
}
|
||
|
||
/* See language.h.
|
||
|
||
FIXME: Should this have its own arch info method? */
|
||
void language_arch_info (struct gdbarch *gdbarch,
|
||
struct language_arch_info *lai) const override
|
||
{
|
||
c_language_arch_info (gdbarch, lai);
|
||
}
|
||
|
||
/* See language.h. */
|
||
|
||
void print_type (struct type *type, const char *varstring,
|
||
struct ui_file *stream, int show, int level,
|
||
const struct type_print_options *flags) const override
|
||
{
|
||
c_print_type (type, varstring, stream, show, level, flags);
|
||
}
|
||
|
||
/* See language.h. */
|
||
|
||
bool store_sym_names_in_linkage_form_p () const override
|
||
{ return true; }
|
||
|
||
/* See language.h. */
|
||
|
||
enum macro_expansion macro_expansion () const override
|
||
{ return macro_expansion_c; }
|
||
};
|
||
|
||
/* The single instance of the ASM language class. */
|
||
static asm_language asm_language_defn;
|
||
|
||
/* A class for the minimal language. This 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. */
|
||
|
||
class minimal_language : public language_defn
|
||
{
|
||
public:
|
||
minimal_language ()
|
||
: language_defn (language_minimal)
|
||
{ /* Nothing. */ }
|
||
|
||
/* See language.h. */
|
||
|
||
const char *name () const override
|
||
{ return "minimal"; }
|
||
|
||
/* See language.h. */
|
||
|
||
const char *natural_name () const override
|
||
{ return "Minimal"; }
|
||
|
||
/* See language.h. */
|
||
void language_arch_info (struct gdbarch *gdbarch,
|
||
struct language_arch_info *lai) const override
|
||
{
|
||
c_language_arch_info (gdbarch, lai);
|
||
}
|
||
|
||
/* See language.h. */
|
||
|
||
void print_type (struct type *type, const char *varstring,
|
||
struct ui_file *stream, int show, int level,
|
||
const struct type_print_options *flags) const override
|
||
{
|
||
c_print_type (type, varstring, stream, show, level, flags);
|
||
}
|
||
|
||
/* See language.h. */
|
||
|
||
bool store_sym_names_in_linkage_form_p () const override
|
||
{ return true; }
|
||
|
||
/* See language.h. */
|
||
|
||
enum macro_expansion macro_expansion () const override
|
||
{ return macro_expansion_c; }
|
||
};
|
||
|
||
/* The single instance of the minimal language class. */
|
||
static minimal_language minimal_language_defn;
|