/* Rust language support routines for GDB, the GNU debugger.
- Copyright (C) 2016-2020 Free Software Foundation, Inc.
+ Copyright (C) 2016-2021 Free Software Foundation, Inc.
This file is part of GDB.
#include <string>
#include <vector>
#include "cli/cli-style.h"
+#include "parser-defs.h"
+#include "rust-exp.h"
/* See rust-lang.h. */
\f
-/* language_defn::printstr implementation for Rust. */
+/* See language.h. */
-static void
-rust_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)
+void
+rust_language::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) const
{
/* Rust always uses UTF-8, but let the caller override this if need
be. */
\f
-static void rust_value_print_inner (struct value *val, struct ui_file *stream,
- int recurse,
- const struct value_print_options *options);
-
/* Helper function to print a string slice. */
static void
options);
}
-/* rust_val_print helper for structs and untagged unions. */
+/* See rust-lang.h. */
-static void
-val_print_struct (struct value *val, struct ui_file *stream, int recurse,
- const struct value_print_options *options)
+void
+rust_language::val_print_struct
+ (struct value *val, struct ui_file *stream, int recurse,
+ const struct value_print_options *options) const
{
int i;
int first_field;
if (!is_tuple)
{
if (type->name () != NULL)
- fprintf_filtered (stream, "%s", type->name ());
+ fprintf_filtered (stream, "%s", type->name ());
if (type->num_fields () == 0)
- return;
+ return;
if (type->name () != NULL)
- fputs_filtered (" ", stream);
+ fputs_filtered (" ", stream);
}
if (is_tuple || is_tuple_struct)
for (i = 0; i < type->num_fields (); ++i)
{
if (field_is_static (&type->field (i)))
- continue;
+ continue;
if (!first_field)
- fputs_filtered (",", stream);
+ fputs_filtered (",", stream);
if (options->prettyformat)
- {
+ {
fputs_filtered ("\n", stream);
print_spaces_filtered (2 + 2 * recurse, stream);
- }
+ }
else if (!first_field)
- fputs_filtered (" ", stream);
+ fputs_filtered (" ", stream);
first_field = 0;
if (!is_tuple && !is_tuple_struct)
- {
+ {
fputs_styled (TYPE_FIELD_NAME (type, i),
variable_name_style.style (), stream);
fputs_filtered (": ", stream);
- }
+ }
- rust_value_print_inner (value_field (val, i), stream, recurse + 1,
- &opts);
+ value_print_inner (value_field (val, i), stream, recurse + 1, &opts);
}
if (options->prettyformat)
fputs_filtered ("}", stream);
}
-/* rust_val_print helper for discriminated unions (Rust enums). */
+/* See rust-lang.h. */
-static void
-rust_print_enum (struct value *val, struct ui_file *stream, int recurse,
- const struct value_print_options *options)
+void
+rust_language::print_enum (struct value *val, struct ui_file *stream,
+ int recurse,
+ const struct value_print_options *options) const
{
struct value_print_options opts = *options;
struct type *type = check_typedef (value_type (val));
styled_string (variable_name_style.style (),
TYPE_FIELD_NAME (variant_type, j)));
- rust_value_print_inner (value_field (val, j), stream, recurse + 1,
- &opts);
+ value_print_inner (value_field (val, j), stream, recurse + 1, &opts);
}
if (is_tuple)
"]"
};
-/* la_value_print_inner implementation for Rust. */
-static void
-rust_value_print_inner (struct value *val, struct ui_file *stream,
- int recurse,
- const struct value_print_options *options)
+/* See language.h. */
+
+void
+rust_language::value_print_inner
+ (struct value *val, struct ui_file *stream, int recurse,
+ const struct value_print_options *options) const
{
struct value_print_options opts = *options;
opts.deref_ref = 1;
that. */
struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));
CORE_ADDR addr = value_as_address (val);
- struct gdbarch *arch = get_type_arch (type);
+ struct gdbarch *arch = type->arch ();
if (opts.addressprint)
{
byte string, hence the choice of "ASCII" as the
encoding. */
fputs_filtered ("b", stream);
- rust_printstr (stream, TYPE_TARGET_TYPE (type),
- value_contents_for_printing (val),
- high_bound - low_bound + 1, "ASCII", 0, &opts);
+ printstr (stream, TYPE_TARGET_TYPE (type),
+ value_contents_for_printing (val),
+ high_bound - low_bound + 1, "ASCII", 0, &opts);
}
break;
case TYPE_CODE_STRUCT:
if (rust_enum_p (type))
- rust_print_enum (val, stream, recurse, &opts);
+ print_enum (val, stream, recurse, &opts);
else
val_print_struct (val, stream, recurse, &opts);
break;
&& type->name () != NULL)
{
/* Rust calls the unit type "void" in its debuginfo,
- but we don't want to print it as that. */
+ but we don't want to print it as that. */
if (type->code () == TYPE_CODE_VOID)
- fputs_filtered ("()", stream);
+ fputs_filtered ("()", stream);
else
- fputs_filtered (type->name (), stream);
+ fputs_filtered (type->name (), stream);
return;
}
fputs_filtered (")", stream);
/* If it returns unit, we can omit the return type. */
if (TYPE_TARGET_TYPE (type)->code () != TYPE_CODE_VOID)
- {
- fputs_filtered (" -> ", stream);
- rust_internal_print_type (TYPE_TARGET_TYPE (type), "", stream,
+ {
+ fputs_filtered (" -> ", stream);
+ rust_internal_print_type (TYPE_TARGET_TYPE (type), "", stream,
-1, 0, flags, false, podata);
- }
+ }
break;
case TYPE_CODE_ARRAY:
&& name[len] == ':'
&& name[len + 1] == ':')
name += len + 2;
- fprintfi_filtered (level + 2, stream, "%ps,\n",
- styled_string (variable_name_style.style (),
- name));
+ fprintf_filtered (stream, "%*s%ps,\n",
+ level + 2, "",
+ styled_string (variable_name_style.style (),
+ name));
}
fputs_filtered ("}", stream);
return type;
}
-enum rust_primitive_types
-{
- rust_primitive_bool,
- rust_primitive_char,
- rust_primitive_i8,
- rust_primitive_u8,
- rust_primitive_i16,
- rust_primitive_u16,
- rust_primitive_i32,
- rust_primitive_u32,
- rust_primitive_i64,
- rust_primitive_u64,
- rust_primitive_isize,
- rust_primitive_usize,
- rust_primitive_f32,
- rust_primitive_f64,
- rust_primitive_unit,
- rust_primitive_str,
- nr_rust_primitive_types
-};
-
\f
-/* A helper for rust_evaluate_subexp that handles OP_FUNCALL. */
-
-static struct value *
-rust_evaluate_funcall (struct expression *exp, int *pos, enum noside noside)
-{
- int i;
- int num_args = exp->elts[*pos + 1].longconst;
- const char *method;
- struct value *function, *result, *arg0;
- struct type *type, *fn_type;
- const struct block *block;
- struct block_symbol sym;
-
- /* For an ordinary function call we can simply defer to the
- generic implementation. */
- if (exp->elts[*pos + 3].opcode != STRUCTOP_STRUCT)
- return evaluate_subexp_standard (NULL, exp, pos, noside);
-
- /* Skip over the OP_FUNCALL and the STRUCTOP_STRUCT. */
- *pos += 4;
- method = &exp->elts[*pos + 1].string;
- *pos += 3 + BYTES_TO_EXP_ELEM (exp->elts[*pos].longconst + 1);
-
- /* Evaluate the argument to STRUCTOP_STRUCT, then find its
- type in order to look up the method. */
- arg0 = evaluate_subexp (nullptr, exp, pos, noside);
-
- if (noside == EVAL_SKIP)
- {
- for (i = 0; i < num_args; ++i)
- evaluate_subexp (nullptr, exp, pos, noside);
- return arg0;
- }
-
- std::vector<struct value *> args (num_args + 1);
- args[0] = arg0;
-
- /* We don't yet implement real Deref semantics. */
- while (value_type (args[0])->code () == TYPE_CODE_PTR)
- args[0] = value_ind (args[0]);
-
- type = value_type (args[0]);
- if ((type->code () != TYPE_CODE_STRUCT
- && type->code () != TYPE_CODE_UNION
- && type->code () != TYPE_CODE_ENUM)
- || rust_tuple_type_p (type))
- error (_("Method calls only supported on struct or enum types"));
- if (type->name () == NULL)
- error (_("Method call on nameless type"));
-
- std::string name = std::string (type->name ()) + "::" + method;
-
- block = get_selected_block (0);
- sym = lookup_symbol (name.c_str (), block, VAR_DOMAIN, NULL);
- if (sym.symbol == NULL)
- error (_("Could not find function named '%s'"), name.c_str ());
-
- fn_type = SYMBOL_TYPE (sym.symbol);
- if (fn_type->num_fields () == 0)
- error (_("Function '%s' takes no arguments"), name.c_str ());
-
- if (fn_type->field (0).type ()->code () == TYPE_CODE_PTR)
- args[0] = value_addr (args[0]);
-
- function = address_of_variable (sym.symbol, block);
-
- for (i = 0; i < num_args; ++i)
- args[i + 1] = evaluate_subexp (nullptr, exp, pos, noside);
-
- if (noside == EVAL_AVOID_SIDE_EFFECTS)
- result = value_zero (TYPE_TARGET_TYPE (fn_type), not_lval);
- else
- result = call_function_by_hand (function, NULL, args);
- return result;
-}
-
/* A helper for rust_evaluate_subexp that handles OP_RANGE. */
-static struct value *
-rust_range (struct expression *exp, int *pos, enum noside noside)
+struct value *
+rust_range (struct type *expect_type, struct expression *exp,
+ enum noside noside, enum range_flag kind,
+ struct value *low, struct value *high)
{
- enum range_type kind;
- struct value *low = NULL, *high = NULL;
struct value *addrval, *result;
CORE_ADDR addr;
struct type *range_type;
struct type *temp_type;
const char *name;
- kind = (enum range_type) longest_to_int (exp->elts[*pos + 1].longconst);
- *pos += 3;
-
- if (kind == HIGH_BOUND_DEFAULT || kind == NONE_BOUND_DEFAULT
- || kind == NONE_BOUND_DEFAULT_EXCLUSIVE)
- low = evaluate_subexp (nullptr, exp, pos, noside);
- if (kind == LOW_BOUND_DEFAULT || kind == LOW_BOUND_DEFAULT_EXCLUSIVE
- || kind == NONE_BOUND_DEFAULT || kind == NONE_BOUND_DEFAULT_EXCLUSIVE)
- high = evaluate_subexp (nullptr, exp, pos, noside);
- bool inclusive = (kind == NONE_BOUND_DEFAULT || kind == LOW_BOUND_DEFAULT);
-
- if (noside == EVAL_SKIP)
- return value_from_longest (builtin_type (exp->gdbarch)->builtin_int, 1);
+ bool inclusive = !(kind & RANGE_HIGH_BOUND_EXCLUSIVE);
if (low == NULL)
{
static void
rust_compute_range (struct type *type, struct value *range,
LONGEST *low, LONGEST *high,
- enum range_type *kind)
+ range_flags *kind)
{
int i;
*low = 0;
*high = 0;
- *kind = BOTH_BOUND_DEFAULT;
+ *kind = RANGE_LOW_BOUND_DEFAULT | RANGE_HIGH_BOUND_DEFAULT;
if (type->num_fields () == 0)
return;
i = 0;
if (strcmp (TYPE_FIELD_NAME (type, 0), "start") == 0)
{
- *kind = HIGH_BOUND_DEFAULT;
+ *kind = RANGE_HIGH_BOUND_DEFAULT;
*low = value_as_long (value_field (range, 0));
++i;
}
if (type->num_fields () > i
&& strcmp (TYPE_FIELD_NAME (type, i), "end") == 0)
{
- *kind = (*kind == BOTH_BOUND_DEFAULT
- ? LOW_BOUND_DEFAULT : NONE_BOUND_DEFAULT);
+ *kind = (*kind == (RANGE_LOW_BOUND_DEFAULT | RANGE_HIGH_BOUND_DEFAULT)
+ ? RANGE_LOW_BOUND_DEFAULT : RANGE_STANDARD);
*high = value_as_long (value_field (range, i));
if (rust_inclusive_range_type_p (type))
/* A helper for rust_evaluate_subexp that handles BINOP_SUBSCRIPT. */
-static struct value *
-rust_subscript (struct expression *exp, int *pos, enum noside noside,
- int for_addr)
+struct value *
+rust_subscript (struct type *expect_type, struct expression *exp,
+ enum noside noside, bool for_addr,
+ struct value *lhs, struct value *rhs)
{
- struct value *lhs, *rhs, *result;
+ struct value *result;
struct type *rhstype;
LONGEST low, high_bound;
/* Initialized to appease the compiler. */
- enum range_type kind = BOTH_BOUND_DEFAULT;
+ range_flags kind = RANGE_LOW_BOUND_DEFAULT | RANGE_HIGH_BOUND_DEFAULT;
LONGEST high = 0;
int want_slice = 0;
- ++*pos;
- lhs = evaluate_subexp (nullptr, exp, pos, noside);
- rhs = evaluate_subexp (nullptr, exp, pos, noside);
-
- if (noside == EVAL_SKIP)
- return lhs;
-
rhstype = check_typedef (value_type (rhs));
if (rust_range_type_p (rhstype))
{
else
error (_("Cannot subscript non-array type"));
- if (want_slice
- && (kind == BOTH_BOUND_DEFAULT || kind == LOW_BOUND_DEFAULT))
+ if (want_slice && (kind & RANGE_LOW_BOUND_DEFAULT))
low = low_bound;
if (low < 0)
error (_("Index less than zero"));
CORE_ADDR addr;
struct value *addrval, *tem;
- if (kind == BOTH_BOUND_DEFAULT || kind == HIGH_BOUND_DEFAULT)
+ if (kind & RANGE_HIGH_BOUND_DEFAULT)
high = high_bound;
if (high < 0)
error (_("High index less than zero"));
return result;
}
-/* evaluate_exp implementation for Rust. */
+/* A helper function for UNOP_IND. */
-static struct value *
-rust_evaluate_subexp (struct type *expect_type, struct expression *exp,
- int *pos, enum noside noside)
+struct value *
+eval_op_rust_ind (struct type *expect_type, struct expression *exp,
+ enum noside noside,
+ enum exp_opcode opcode,
+ struct value *value)
{
- struct value *result;
+ gdb_assert (noside == EVAL_NORMAL);
+ struct value *trait_ptr = rust_get_trait_object_pointer (value);
+ if (trait_ptr != NULL)
+ value = trait_ptr;
- switch (exp->elts[*pos].opcode)
- {
- case UNOP_IND:
- {
- if (noside != EVAL_NORMAL)
- result = evaluate_subexp_standard (expect_type, exp, pos, noside);
- else
- {
- ++*pos;
- struct value *value = evaluate_subexp (expect_type, exp, pos,
- noside);
-
- struct value *trait_ptr = rust_get_trait_object_pointer (value);
- if (trait_ptr != NULL)
- value = trait_ptr;
-
- result = value_ind (value);
- }
- }
- break;
-
- case UNOP_COMPLEMENT:
- {
- struct value *value;
-
- ++*pos;
- value = evaluate_subexp (nullptr, exp, pos, noside);
- if (noside == EVAL_SKIP)
- {
- /* Preserving the type is enough. */
- return value;
- }
- if (value_type (value)->code () == TYPE_CODE_BOOL)
- result = value_from_longest (value_type (value),
- value_logical_not (value));
- else
- result = value_complement (value);
- }
- break;
-
- case BINOP_SUBSCRIPT:
- result = rust_subscript (exp, pos, noside, 0);
- break;
-
- case OP_FUNCALL:
- result = rust_evaluate_funcall (exp, pos, noside);
- break;
-
- case OP_AGGREGATE:
- {
- int pc = (*pos)++;
- struct type *type = exp->elts[pc + 1].type;
- int arglen = longest_to_int (exp->elts[pc + 2].longconst);
- int i;
- CORE_ADDR addr = 0;
- struct value *addrval = NULL;
-
- *pos += 3;
-
- if (noside == EVAL_NORMAL)
- {
- addrval = value_allocate_space_in_inferior (TYPE_LENGTH (type));
- addr = value_as_long (addrval);
- result = value_at_lazy (type, addr);
- }
-
- if (arglen > 0 && exp->elts[*pos].opcode == OP_OTHERS)
- {
- struct value *init;
-
- ++*pos;
- init = rust_evaluate_subexp (NULL, exp, pos, noside);
- if (noside == EVAL_NORMAL)
- {
- /* This isn't quite right but will do for the time
- being, seeing that we can't implement the Copy
- trait anyway. */
- value_assign (result, init);
- }
-
- --arglen;
- }
-
- gdb_assert (arglen % 2 == 0);
- for (i = 0; i < arglen; i += 2)
- {
- int len;
- const char *fieldname;
- struct value *value, *field;
-
- gdb_assert (exp->elts[*pos].opcode == OP_NAME);
- ++*pos;
- len = longest_to_int (exp->elts[*pos].longconst);
- ++*pos;
- fieldname = &exp->elts[*pos].string;
- *pos += 2 + BYTES_TO_EXP_ELEM (len + 1);
-
- value = rust_evaluate_subexp (NULL, exp, pos, noside);
- if (noside == EVAL_NORMAL)
- {
- field = value_struct_elt (&result, NULL, fieldname, NULL,
- "structure");
- value_assign (field, value);
- }
- }
-
- if (noside == EVAL_SKIP)
- return value_from_longest (builtin_type (exp->gdbarch)->builtin_int,
- 1);
- else if (noside == EVAL_AVOID_SIDE_EFFECTS)
- result = allocate_value (type);
- else
- result = value_at_lazy (type, addr);
- }
- break;
-
- case OP_RUST_ARRAY:
- {
- (*pos)++;
- int copies;
- struct value *elt;
- struct value *ncopies;
-
- elt = rust_evaluate_subexp (NULL, exp, pos, noside);
- ncopies = rust_evaluate_subexp (NULL, exp, pos, noside);
- copies = value_as_long (ncopies);
- if (copies < 0)
- error (_("Array with negative number of elements"));
-
- if (noside == EVAL_NORMAL)
- {
- int i;
- std::vector<struct value *> eltvec (copies);
-
- for (i = 0; i < copies; ++i)
- eltvec[i] = elt;
- result = value_array (0, copies - 1, eltvec.data ());
- }
- else
- {
- struct type *arraytype
- = lookup_array_range_type (value_type (elt), 0, copies - 1);
- result = allocate_value (arraytype);
- }
- }
- break;
-
- case STRUCTOP_ANONYMOUS:
- {
- /* Anonymous field access, i.e. foo.1. */
- struct value *lhs;
- int pc, field_number, nfields;
- struct type *type;
-
- pc = (*pos)++;
- field_number = longest_to_int (exp->elts[pc + 1].longconst);
- (*pos) += 2;
- lhs = evaluate_subexp (nullptr, exp, pos, noside);
-
- type = value_type (lhs);
-
- if (type->code () == TYPE_CODE_STRUCT)
- {
- struct type *outer_type = NULL;
-
- if (rust_enum_p (type))
- {
- gdb::array_view<const gdb_byte> view (value_contents (lhs),
- TYPE_LENGTH (type));
- type = resolve_dynamic_type (type, view, value_address (lhs));
-
- if (rust_empty_enum_p (type))
- error (_("Cannot access field %d of empty enum %s"),
- field_number, type->name ());
-
- int fieldno = rust_enum_variant (type);
- lhs = value_primitive_field (lhs, 0, fieldno, type);
- outer_type = type;
- type = value_type (lhs);
- }
-
- /* Tuples and tuple structs */
- nfields = type->num_fields ();
-
- if (field_number >= nfields || field_number < 0)
- {
- if (outer_type != NULL)
- error(_("Cannot access field %d of variant %s::%s, "
- "there are only %d fields"),
- field_number, outer_type->name (),
- rust_last_path_segment (type->name ()),
- nfields);
- else
- error(_("Cannot access field %d of %s, "
- "there are only %d fields"),
- field_number, type->name (), nfields);
- }
-
- /* Tuples are tuple structs too. */
- if (!rust_tuple_struct_type_p (type))
- {
- if (outer_type != NULL)
- error(_("Variant %s::%s is not a tuple variant"),
- outer_type->name (),
- rust_last_path_segment (type->name ()));
- else
- error(_("Attempting to access anonymous field %d "
- "of %s, which is not a tuple, tuple struct, or "
- "tuple-like variant"),
- field_number, type->name ());
- }
-
- result = value_primitive_field (lhs, 0, field_number, type);
- }
- else
- error(_("Anonymous field access is only allowed on tuples, \
-tuple structs, and tuple-like enum variants"));
- }
- break;
-
- case STRUCTOP_STRUCT:
- {
- struct value *lhs;
- struct type *type;
- int tem, pc;
-
- pc = (*pos)++;
- tem = longest_to_int (exp->elts[pc + 1].longconst);
- (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
- lhs = evaluate_subexp (nullptr, exp, pos, noside);
-
- const char *field_name = &exp->elts[pc + 2].string;
- type = value_type (lhs);
- if (type->code () == TYPE_CODE_STRUCT && rust_enum_p (type))
- {
- gdb::array_view<const gdb_byte> view (value_contents (lhs),
- TYPE_LENGTH (type));
- type = resolve_dynamic_type (type, view, value_address (lhs));
-
- if (rust_empty_enum_p (type))
- error (_("Cannot access field %s of empty enum %s"),
- field_name, type->name ());
-
- int fieldno = rust_enum_variant (type);
- lhs = value_primitive_field (lhs, 0, fieldno, type);
-
- struct type *outer_type = type;
- type = value_type (lhs);
- if (rust_tuple_type_p (type) || rust_tuple_struct_type_p (type))
- error (_("Attempting to access named field %s of tuple "
- "variant %s::%s, which has only anonymous fields"),
- field_name, outer_type->name (),
- rust_last_path_segment (type->name ()));
-
- try
- {
- result = value_struct_elt (&lhs, NULL, field_name,
- NULL, "structure");
- }
- catch (const gdb_exception_error &except)
- {
- error (_("Could not find field %s of struct variant %s::%s"),
- field_name, outer_type->name (),
- rust_last_path_segment (type->name ()));
- }
- }
- else
- result = value_struct_elt (&lhs, NULL, field_name, NULL, "structure");
- if (noside == EVAL_AVOID_SIDE_EFFECTS)
- result = value_zero (value_type (result), VALUE_LVAL (result));
- }
- break;
+ return value_ind (value);
+}
- case OP_RANGE:
- result = rust_range (exp, pos, noside);
- break;
+/* A helper function for UNOP_COMPLEMENT. */
- case UNOP_ADDR:
- /* We might have &array[range], in which case we need to make a
- slice. */
- if (exp->elts[*pos + 1].opcode == BINOP_SUBSCRIPT)
- {
- ++*pos;
- result = rust_subscript (exp, pos, noside, 1);
- break;
- }
- /* Fall through. */
- default:
- result = evaluate_subexp_standard (expect_type, exp, pos, noside);
- break;
- }
-
- return result;
+struct value *
+eval_op_rust_complement (struct type *expect_type, struct expression *exp,
+ enum noside noside,
+ enum exp_opcode opcode,
+ struct value *value)
+{
+ if (value_type (value)->code () == TYPE_CODE_BOOL)
+ return value_from_longest (value_type (value), value_logical_not (value));
+ return value_complement (value);
}
-/* operator_length implementation for Rust. */
+/* A helper function for OP_ARRAY. */
-static void
-rust_operator_length (const struct expression *exp, int pc, int *oplenp,
- int *argsp)
+struct value *
+eval_op_rust_array (struct type *expect_type, struct expression *exp,
+ enum noside noside,
+ enum exp_opcode opcode,
+ struct value *elt, struct value *ncopies)
{
- int oplen = 1;
- int args = 0;
+ int copies = value_as_long (ncopies);
+ if (copies < 0)
+ error (_("Array with negative number of elements"));
- switch (exp->elts[pc - 1].opcode)
+ if (noside == EVAL_NORMAL)
{
- case OP_AGGREGATE:
- /* We handle aggregate as a type and argument count. The first
- argument might be OP_OTHERS. After that the arguments
- alternate: first an OP_NAME, then an expression. */
- oplen = 4;
- args = longest_to_int (exp->elts[pc - 2].longconst);
- break;
+ int i;
+ std::vector<struct value *> eltvec (copies);
- case OP_OTHERS:
- oplen = 1;
- args = 1;
- break;
-
- case STRUCTOP_ANONYMOUS:
- oplen = 3;
- args = 1;
- break;
-
- case OP_RUST_ARRAY:
- oplen = 1;
- args = 2;
- break;
-
- default:
- operator_length_standard (exp, pc, oplenp, argsp);
- return;
+ for (i = 0; i < copies; ++i)
+ eltvec[i] = elt;
+ return value_array (0, copies - 1, eltvec.data ());
}
-
- *oplenp = oplen;
- *argsp = args;
-}
-
-/* op_name implementation for Rust. */
-
-static const char *
-rust_op_name (enum exp_opcode opcode)
-{
- switch (opcode)
+ else
{
- case OP_AGGREGATE:
- return "OP_AGGREGATE";
- case OP_OTHERS:
- return "OP_OTHERS";
- default:
- return op_name_standard (opcode);
+ struct type *arraytype
+ = lookup_array_range_type (value_type (elt), 0, copies - 1);
+ return allocate_value (arraytype);
}
}
-/* dump_subexp_body implementation for Rust. */
+/* A helper function for STRUCTOP_ANONYMOUS. */
-static int
-rust_dump_subexp_body (struct expression *exp, struct ui_file *stream,
- int elt)
+struct value *
+eval_op_rust_struct_anon (struct type *expect_type, struct expression *exp,
+ enum noside noside,
+ int field_number, struct value *lhs)
{
- switch (exp->elts[elt].opcode)
- {
- case OP_AGGREGATE:
- {
- int length = longest_to_int (exp->elts[elt + 2].longconst);
- int i;
-
- fprintf_filtered (stream, "Type @");
- gdb_print_host_address (exp->elts[elt + 1].type, stream);
- fprintf_filtered (stream, " (");
- type_print (exp->elts[elt + 1].type, NULL, stream, 0);
- fprintf_filtered (stream, "), length %d", length);
-
- elt += 4;
- for (i = 0; i < length; ++i)
- elt = dump_subexp (exp, stream, elt);
- }
- break;
+ struct type *type = value_type (lhs);
- case OP_STRING:
- case OP_NAME:
- {
- LONGEST len = exp->elts[elt + 1].longconst;
-
- fprintf_filtered (stream, "%s: %s",
- (exp->elts[elt].opcode == OP_STRING
- ? "string" : "name"),
- &exp->elts[elt + 2].string);
- elt += 4 + BYTES_TO_EXP_ELEM (len + 1);
- }
- break;
-
- case OP_OTHERS:
- elt = dump_subexp (exp, stream, elt + 1);
- break;
+ if (type->code () == TYPE_CODE_STRUCT)
+ {
+ struct type *outer_type = NULL;
- case STRUCTOP_ANONYMOUS:
- {
- int field_number;
+ if (rust_enum_p (type))
+ {
+ gdb::array_view<const gdb_byte> view (value_contents (lhs),
+ TYPE_LENGTH (type));
+ type = resolve_dynamic_type (type, view, value_address (lhs));
+
+ if (rust_empty_enum_p (type))
+ error (_("Cannot access field %d of empty enum %s"),
+ field_number, type->name ());
+
+ int fieldno = rust_enum_variant (type);
+ lhs = value_primitive_field (lhs, 0, fieldno, type);
+ outer_type = type;
+ type = value_type (lhs);
+ }
- field_number = longest_to_int (exp->elts[elt + 1].longconst);
+ /* Tuples and tuple structs */
+ int nfields = type->num_fields ();
- fprintf_filtered (stream, "Field number: %d", field_number);
- elt = dump_subexp (exp, stream, elt + 3);
- }
- break;
+ if (field_number >= nfields || field_number < 0)
+ {
+ if (outer_type != NULL)
+ error(_("Cannot access field %d of variant %s::%s, "
+ "there are only %d fields"),
+ field_number, outer_type->name (),
+ rust_last_path_segment (type->name ()),
+ nfields);
+ else
+ error(_("Cannot access field %d of %s, "
+ "there are only %d fields"),
+ field_number, type->name (), nfields);
+ }
- case OP_RUST_ARRAY:
- ++elt;
- break;
+ /* Tuples are tuple structs too. */
+ if (!rust_tuple_struct_type_p (type))
+ {
+ if (outer_type != NULL)
+ error(_("Variant %s::%s is not a tuple variant"),
+ outer_type->name (),
+ rust_last_path_segment (type->name ()));
+ else
+ error(_("Attempting to access anonymous field %d "
+ "of %s, which is not a tuple, tuple struct, or "
+ "tuple-like variant"),
+ field_number, type->name ());
+ }
- default:
- elt = dump_subexp_body_standard (exp, stream, elt);
- break;
+ return value_primitive_field (lhs, 0, field_number, type);
}
-
- return elt;
+ else
+ error(_("Anonymous field access is only allowed on tuples, \
+tuple structs, and tuple-like enum variants"));
}
-/* print_subexp implementation for Rust. */
+/* A helper function for STRUCTOP_STRUCT. */
-static void
-rust_print_subexp (struct expression *exp, int *pos, struct ui_file *stream,
- enum precedence prec)
+struct value *
+eval_op_rust_structop (struct type *expect_type, struct expression *exp,
+ enum noside noside,
+ struct value *lhs, const char *field_name)
{
- switch (exp->elts[*pos].opcode)
+ struct value *result;
+ struct type *type = value_type (lhs);
+ if (type->code () == TYPE_CODE_STRUCT && rust_enum_p (type))
{
- case OP_AGGREGATE:
- {
- int length = longest_to_int (exp->elts[*pos + 2].longconst);
- int i;
-
- type_print (exp->elts[*pos + 1].type, "", stream, 0);
- fputs_filtered (" { ", stream);
-
- *pos += 4;
- for (i = 0; i < length; ++i)
- {
- rust_print_subexp (exp, pos, stream, prec);
- fputs_filtered (", ", stream);
- }
- fputs_filtered (" }", stream);
- }
- break;
-
- case OP_NAME:
- {
- LONGEST len = exp->elts[*pos + 1].longconst;
-
- fputs_filtered (&exp->elts[*pos + 2].string, stream);
- *pos += 4 + BYTES_TO_EXP_ELEM (len + 1);
- }
- break;
-
- case OP_OTHERS:
- {
- fputs_filtered ("<<others>> (", stream);
- ++*pos;
- rust_print_subexp (exp, pos, stream, prec);
- fputs_filtered (")", stream);
- }
- break;
-
- case STRUCTOP_ANONYMOUS:
- {
- int tem = longest_to_int (exp->elts[*pos + 1].longconst);
-
- (*pos) += 3;
- print_subexp (exp, pos, stream, PREC_SUFFIX);
- fprintf_filtered (stream, ".%d", tem);
- }
- break;
-
- case OP_RUST_ARRAY:
- ++*pos;
- fprintf_filtered (stream, "[");
- rust_print_subexp (exp, pos, stream, prec);
- fprintf_filtered (stream, "; ");
- rust_print_subexp (exp, pos, stream, prec);
- fprintf_filtered (stream, "]");
- break;
-
- default:
- print_subexp_standard (exp, pos, stream, prec);
- break;
+ gdb::array_view<const gdb_byte> view (value_contents (lhs),
+ TYPE_LENGTH (type));
+ type = resolve_dynamic_type (type, view, value_address (lhs));
+
+ if (rust_empty_enum_p (type))
+ error (_("Cannot access field %s of empty enum %s"),
+ field_name, type->name ());
+
+ int fieldno = rust_enum_variant (type);
+ lhs = value_primitive_field (lhs, 0, fieldno, type);
+
+ struct type *outer_type = type;
+ type = value_type (lhs);
+ if (rust_tuple_type_p (type) || rust_tuple_struct_type_p (type))
+ error (_("Attempting to access named field %s of tuple "
+ "variant %s::%s, which has only anonymous fields"),
+ field_name, outer_type->name (),
+ rust_last_path_segment (type->name ()));
+
+ try
+ {
+ result = value_struct_elt (&lhs, NULL, field_name,
+ NULL, "structure");
+ }
+ catch (const gdb_exception_error &except)
+ {
+ error (_("Could not find field %s of struct variant %s::%s"),
+ field_name, outer_type->name (),
+ rust_last_path_segment (type->name ()));
+ }
}
+ else
+ result = value_struct_elt (&lhs, NULL, field_name, NULL, "structure");
+ if (noside == EVAL_AVOID_SIDE_EFFECTS)
+ result = value_zero (value_type (result), VALUE_LVAL (result));
+ return result;
}
-/* operator_check implementation for Rust. */
-
-static int
-rust_operator_check (struct expression *exp, int pos,
- int (*objfile_func) (struct objfile *objfile,
- void *data),
- void *data)
+namespace expr
{
- switch (exp->elts[pos].opcode)
- {
- case OP_AGGREGATE:
- {
- struct type *type = exp->elts[pos + 1].type;
- struct objfile *objfile = TYPE_OBJFILE (type);
-
- if (objfile != NULL && (*objfile_func) (objfile, data))
- return 1;
- }
- break;
- case OP_OTHERS:
- case OP_NAME:
- case OP_RUST_ARRAY:
- break;
+value *
+rust_aggregate_operation::evaluate (struct type *expect_type,
+ struct expression *exp,
+ enum noside noside)
+{
+ struct type *type = std::get<0> (m_storage);
+ CORE_ADDR addr = 0;
+ struct value *addrval = NULL;
+ value *result;
- default:
- return operator_check_standard (exp, pos, objfile_func, data);
+ if (noside == EVAL_NORMAL)
+ {
+ addrval = value_allocate_space_in_inferior (TYPE_LENGTH (type));
+ addr = value_as_long (addrval);
+ result = value_at_lazy (type, addr);
}
- return 0;
-}
-
-\f
-
-static const struct exp_descriptor exp_descriptor_rust =
-{
- rust_print_subexp,
- rust_operator_length,
- rust_operator_check,
- rust_op_name,
- rust_dump_subexp_body,
- rust_evaluate_subexp
-};
+ if (std::get<1> (m_storage) != nullptr)
+ {
+ struct value *init = std::get<1> (m_storage)->evaluate (nullptr, exp,
+ noside);
-static const char * const rust_extensions[] =
-{
- ".rs", NULL
-};
+ if (noside == EVAL_NORMAL)
+ {
+ /* This isn't quite right but will do for the time
+ being, seeing that we can't implement the Copy
+ trait anyway. */
+ value_assign (result, init);
+ }
+ }
-/* Constant data representing the Rust language. */
+ for (const auto &item : std::get<2> (m_storage))
+ {
+ value *val = item.second->evaluate (nullptr, exp, noside);
+ if (noside == EVAL_NORMAL)
+ {
+ const char *fieldname = item.first.c_str ();
+ value *field = value_struct_elt (&result, nullptr, fieldname,
+ nullptr, "structure");
+ value_assign (field, val);
+ }
+ }
-extern const struct language_data rust_language_data =
-{
- "rust",
- "Rust",
- language_rust,
- range_check_on,
- case_sensitive_on,
- array_row_major,
- macro_expansion_no,
- rust_extensions,
- &exp_descriptor_rust,
- NULL, /* name_of_this */
- false, /* la_store_sym_names_in_linkage_form_p */
- c_op_print_tab, /* expression operators for printing */
- 1, /* c-style arrays */
- 0, /* String lower bound */
- &default_varobj_ops,
- "{...}" /* la_struct_too_deep_ellipsis */
-};
+ if (noside == EVAL_AVOID_SIDE_EFFECTS)
+ result = allocate_value (type);
+ else
+ result = value_at_lazy (type, addr);
-/* Class representing the Rust language. */
+ return result;
+}
-class rust_language : public language_defn
+value *
+rust_structop::evaluate_funcall (struct type *expect_type,
+ struct expression *exp,
+ enum noside noside,
+ const std::vector<operation_up> &ops)
{
-public:
- rust_language ()
- : language_defn (language_rust, rust_language_data)
- { /* Nothing. */ }
-
- /* 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);
-
- struct type **types
- = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_rust_primitive_types + 1,
- struct type *);
-
- types[rust_primitive_bool] = arch_boolean_type (gdbarch, 8, 1, "bool");
- types[rust_primitive_char] = arch_character_type (gdbarch, 32, 1, "char");
- types[rust_primitive_i8] = arch_integer_type (gdbarch, 8, 0, "i8");
- types[rust_primitive_u8] = arch_integer_type (gdbarch, 8, 1, "u8");
- types[rust_primitive_i16] = arch_integer_type (gdbarch, 16, 0, "i16");
- types[rust_primitive_u16] = arch_integer_type (gdbarch, 16, 1, "u16");
- types[rust_primitive_i32] = arch_integer_type (gdbarch, 32, 0, "i32");
- types[rust_primitive_u32] = arch_integer_type (gdbarch, 32, 1, "u32");
- types[rust_primitive_i64] = arch_integer_type (gdbarch, 64, 0, "i64");
- types[rust_primitive_u64] = arch_integer_type (gdbarch, 64, 1, "u64");
-
- unsigned int length = 8 * TYPE_LENGTH (builtin->builtin_data_ptr);
- types[rust_primitive_isize] = arch_integer_type (gdbarch, length, 0, "isize");
- types[rust_primitive_usize] = arch_integer_type (gdbarch, length, 1, "usize");
-
- types[rust_primitive_f32] = arch_float_type (gdbarch, 32, "f32",
- floatformats_ieee_single);
- types[rust_primitive_f64] = arch_float_type (gdbarch, 64, "f64",
- floatformats_ieee_double);
-
- types[rust_primitive_unit] = arch_integer_type (gdbarch, 0, 1, "()");
-
- struct type *tem = make_cv_type (1, 0, types[rust_primitive_u8], NULL);
- types[rust_primitive_str] = rust_slice_type ("&str", tem,
- types[rust_primitive_usize]);
-
- lai->primitive_type_vector = types;
- lai->bool_type_default = types[rust_primitive_bool];
- lai->string_char_type = types[rust_primitive_u8];
- }
-
- /* See language.h. */
- bool sniff_from_mangled_name (const char *mangled,
- char **demangled) const override
- {
- *demangled = gdb_demangle (mangled, DMGL_PARAMS | DMGL_ANSI);
- return *demangled != NULL;
- }
-
- /* See language.h. */
+ std::vector<struct value *> args (ops.size () + 1);
- char *demangle (const char *mangled, int options) const override
- {
- return gdb_demangle (mangled, options);
- }
-
- /* See language.h. */
+ /* Evaluate the argument to STRUCTOP_STRUCT, then find its
+ type in order to look up the method. */
+ args[0] = std::get<0> (m_storage)->evaluate (nullptr, exp, noside);
+ /* We don't yet implement real Deref semantics. */
+ while (value_type (args[0])->code () == TYPE_CODE_PTR)
+ args[0] = value_ind (args[0]);
- 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
- {
- print_offset_data podata;
- rust_internal_print_type (type, varstring, stream, show, level,
- flags, false, &podata);
- }
+ struct type *type = value_type (args[0]);
+ if ((type->code () != TYPE_CODE_STRUCT
+ && type->code () != TYPE_CODE_UNION
+ && type->code () != TYPE_CODE_ENUM)
+ || rust_tuple_type_p (type))
+ error (_("Method calls only supported on struct or enum types"));
+ if (type->name () == NULL)
+ error (_("Method call on nameless type"));
- /* See language.h. */
+ std::string name = (std::string (type->name ()) + "::"
+ + std::get<1> (m_storage));
- gdb::unique_xmalloc_ptr<char> watch_location_expression
- (struct type *type, CORE_ADDR addr) const override
- {
- type = check_typedef (TYPE_TARGET_TYPE (check_typedef (type)));
- std::string name = type_to_string (type);
- return gdb::unique_xmalloc_ptr<char>
- (xstrprintf ("*(%s as *mut %s)", core_addr_to_string (addr),
- name.c_str ()));
- }
+ const struct block *block = get_selected_block (0);
+ struct block_symbol sym = lookup_symbol (name.c_str (), block,
+ VAR_DOMAIN, NULL);
+ if (sym.symbol == NULL)
+ error (_("Could not find function named '%s'"), name.c_str ());
- /* See language.h. */
+ struct type *fn_type = SYMBOL_TYPE (sym.symbol);
+ if (fn_type->num_fields () == 0)
+ error (_("Function '%s' takes no arguments"), name.c_str ());
- void value_print_inner
- (struct value *val, struct ui_file *stream, int recurse,
- const struct value_print_options *options) const override
- {
- return rust_value_print_inner (val, stream, recurse, options);
- }
+ if (fn_type->field (0).type ()->code () == TYPE_CODE_PTR)
+ args[0] = value_addr (args[0]);
- /* See language.h. */
+ value *function = address_of_variable (sym.symbol, block);
- struct block_symbol lookup_symbol_nonlocal
- (const char *name, const struct block *block,
- const domain_enum domain) const override
- {
- struct block_symbol result = {};
+ for (int i = 0; i < ops.size (); ++i)
+ args[i + 1] = ops[i]->evaluate (nullptr, exp, noside);
- if (symbol_lookup_debug)
- {
- fprintf_unfiltered (gdb_stdlog,
- "rust_lookup_symbol_non_local"
- " (%s, %s (scope %s), %s)\n",
- name, host_address_to_string (block),
- block_scope (block), domain_name (domain));
- }
+ if (noside == EVAL_AVOID_SIDE_EFFECTS)
+ return value_zero (TYPE_TARGET_TYPE (fn_type), not_lval);
+ return call_function_by_hand (function, NULL, args);
+}
- /* Look up bare names in the block's scope. */
- std::string scopedname;
- if (name[cp_find_first_component (name)] == '\0')
- {
- const char *scope = block_scope (block);
+}
- if (scope[0] != '\0')
- {
- scopedname = std::string (scope) + "::" + name;
- name = scopedname.c_str ();
- }
- else
- name = NULL;
- }
+\f
- if (name != NULL)
- {
- result = lookup_symbol_in_static_block (name, block, domain);
- if (result.symbol == NULL)
- result = lookup_global_symbol (name, block, domain);
- }
- return result;
- }
+/* See language.h. */
- /* See language.h. */
+void
+rust_language::language_arch_info (struct gdbarch *gdbarch,
+ struct language_arch_info *lai) const
+{
+ const struct builtin_type *builtin = builtin_type (gdbarch);
- int parser (struct parser_state *ps) const override
+ /* Helper function to allow shorter lines below. */
+ auto add = [&] (struct type * t) -> struct type *
{
- return rust_parse (ps);
- }
+ lai->add_primitive_type (t);
+ return t;
+ };
+
+ struct type *bool_type
+ = add (arch_boolean_type (gdbarch, 8, 1, "bool"));
+ add (arch_character_type (gdbarch, 32, 1, "char"));
+ add (arch_integer_type (gdbarch, 8, 0, "i8"));
+ struct type *u8_type
+ = add (arch_integer_type (gdbarch, 8, 1, "u8"));
+ add (arch_integer_type (gdbarch, 16, 0, "i16"));
+ add (arch_integer_type (gdbarch, 16, 1, "u16"));
+ add (arch_integer_type (gdbarch, 32, 0, "i32"));
+ add (arch_integer_type (gdbarch, 32, 1, "u32"));
+ add (arch_integer_type (gdbarch, 64, 0, "i64"));
+ add (arch_integer_type (gdbarch, 64, 1, "u64"));
+
+ unsigned int length = 8 * TYPE_LENGTH (builtin->builtin_data_ptr);
+ add (arch_integer_type (gdbarch, length, 0, "isize"));
+ struct type *usize_type
+ = add (arch_integer_type (gdbarch, length, 1, "usize"));
+
+ add (arch_float_type (gdbarch, 32, "f32", floatformats_ieee_single));
+ add (arch_float_type (gdbarch, 64, "f64", floatformats_ieee_double));
+ add (arch_integer_type (gdbarch, 0, 1, "()"));
+
+ struct type *tem = make_cv_type (1, 0, u8_type, NULL);
+ add (rust_slice_type ("&str", tem, usize_type));
+
+ lai->set_bool_type (bool_type);
+ lai->set_string_char_type (u8_type);
+}
- /* See language.h. */
+/* See language.h. */
- void emitchar (int ch, struct type *chtype,
- struct ui_file *stream, int quoter) const override
- {
- if (!rust_chartype_p (chtype))
- generic_emit_char (ch, chtype, stream, quoter,
- target_charset (get_type_arch (chtype)));
- else if (ch == '\\' || ch == quoter)
- fprintf_filtered (stream, "\\%c", ch);
- else if (ch == '\n')
- fputs_filtered ("\\n", stream);
- else if (ch == '\r')
- fputs_filtered ("\\r", stream);
- else if (ch == '\t')
- fputs_filtered ("\\t", stream);
- else if (ch == '\0')
- fputs_filtered ("\\0", stream);
- else if (ch >= 32 && ch <= 127 && isprint (ch))
- fputc_filtered (ch, stream);
- else if (ch <= 255)
- fprintf_filtered (stream, "\\x%02x", ch);
- else
- fprintf_filtered (stream, "\\u{%06x}", ch);
- }
-
- /* See language.h. */
-
- void printchar (int ch, struct type *chtype,
- struct ui_file *stream) const override
- {
- fputs_filtered ("'", stream);
- LA_EMIT_CHAR (ch, chtype, stream, '\'');
- fputs_filtered ("'", stream);
- }
-
- /* See language.h. */
+void
+rust_language::print_type (struct type *type, const char *varstring,
+ struct ui_file *stream, int show, int level,
+ const struct type_print_options *flags) const
+{
+ print_offset_data podata;
+ rust_internal_print_type (type, varstring, stream, show, level,
+ flags, false, &podata);
+}
- void printstr (struct ui_file *stream, struct type *elttype,
- const gdb_byte *string, unsigned int length,
- const char *encoding, int force_ellipses,
- const struct value_print_options *options) const override
- {
- rust_printstr (stream, elttype, string, length, encoding,
- force_ellipses, options);
- }
+/* See language.h. */
- /* See language.h. */
+void
+rust_language::emitchar (int ch, struct type *chtype,
+ struct ui_file *stream, int quoter) const
+{
+ if (!rust_chartype_p (chtype))
+ generic_emit_char (ch, chtype, stream, quoter,
+ target_charset (chtype->arch ()));
+ else if (ch == '\\' || ch == quoter)
+ fprintf_filtered (stream, "\\%c", ch);
+ else if (ch == '\n')
+ fputs_filtered ("\\n", stream);
+ else if (ch == '\r')
+ fputs_filtered ("\\r", stream);
+ else if (ch == '\t')
+ fputs_filtered ("\\t", stream);
+ else if (ch == '\0')
+ fputs_filtered ("\\0", stream);
+ else if (ch >= 32 && ch <= 127 && isprint (ch))
+ fputc_filtered (ch, stream);
+ else if (ch <= 255)
+ fprintf_filtered (stream, "\\x%02x", ch);
+ else
+ fprintf_filtered (stream, "\\u{%06x}", ch);
+}
- void print_typedef (struct type *type, struct symbol *new_symbol,
- struct ui_file *stream) const override
- {
- type = check_typedef (type);
- fprintf_filtered (stream, "type %s = ", new_symbol->print_name ());
- type_print (type, "", stream, 0);
- fprintf_filtered (stream, ";");
- }
+/* See language.h. */
- /* See language.h. */
+bool
+rust_language::is_string_type_p (struct type *type) const
+{
+ LONGEST low_bound, high_bound;
- bool is_string_type_p (struct type *type) const override
- {
- LONGEST low_bound, high_bound;
-
- type = check_typedef (type);
- return ((type->code () == TYPE_CODE_STRING)
- || (type->code () == TYPE_CODE_PTR
- && (TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_ARRAY
- && rust_u8_type_p (TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (type)))
- && get_array_bounds (TYPE_TARGET_TYPE (type), &low_bound,
- &high_bound)))
- || (type->code () == TYPE_CODE_STRUCT
- && !rust_enum_p (type)
- && rust_slice_type_p (type)
- && strcmp (type->name (), "&str") == 0));
- }
-};
+ type = check_typedef (type);
+ return ((type->code () == TYPE_CODE_STRING)
+ || (type->code () == TYPE_CODE_PTR
+ && (TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_ARRAY
+ && rust_u8_type_p (TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (type)))
+ && get_array_bounds (TYPE_TARGET_TYPE (type), &low_bound,
+ &high_bound)))
+ || (type->code () == TYPE_CODE_STRUCT
+ && !rust_enum_p (type)
+ && rust_slice_type_p (type)
+ && strcmp (type->name (), "&str") == 0));
+}
/* Single instance of the Rust language class. */
projects / binutils.git / blobdiff