/* Rust language support routines for GDB, the GNU debugger.
- Copyright (C) 2016-2021 Free Software Foundation, Inc.
+ Copyright (C) 2016-2023 Free Software Foundation, Inc.
This file is part of GDB.
#include "gdbarch.h"
#include "infcall.h"
#include "objfiles.h"
-#include "psymtab.h"
#include "rust-lang.h"
#include "typeprint.h"
#include "valprint.h"
std::string
rust_crate_for_block (const struct block *block)
{
- const char *scope = block_scope (block);
+ const char *scope = block->scope ();
if (scope[0] == '\0')
return std::string ();
{
/* The active variant is simply the first non-artificial field. */
for (int i = 0; i < type->num_fields (); ++i)
- if (!TYPE_FIELD_ARTIFICIAL (type, i))
+ if (!type->field (i).is_artificial ())
return i;
/* Perhaps we could get here by trying to print an Ada variant
return false;
for (i = 0; i < type->num_fields (); ++i)
{
- if (!field_is_static (&type->field (i)))
+ if (!type->field (i).is_static ())
{
char buf[20];
xsnprintf (buf, sizeof (buf), "__%d", field_number);
- if (strcmp (buf, TYPE_FIELD_NAME (type, i)) != 0)
+ if (strcmp (buf, type->field (i).name ()) != 0)
return false;
field_number++;
}
static bool
rust_slice_type_p (struct type *type)
{
- return (type->code () == TYPE_CODE_STRUCT
- && type->name () != NULL
- && (strncmp (type->name (), "&[", 2) == 0
- || strcmp (type->name (), "&str") == 0));
+ if (type->code () == TYPE_CODE_STRUCT
+ && type->name () != NULL
+ && type->num_fields () == 2)
+ {
+ /* The order of fields doesn't matter. While it would be nice
+ to check for artificiality here, the Rust compiler doesn't
+ emit this information. */
+ const char *n1 = type->field (0).name ();
+ const char *n2 = type->field (1).name ();
+ return ((streq (n1, "data_ptr") && streq (n2, "length"))
+ || (streq (n2, "data_ptr") && streq (n1, "length")));
+ }
+ return false;
}
/* Return true if TYPE is a range type, otherwise false. */
return true;
i = 0;
- if (strcmp (TYPE_FIELD_NAME (type, 0), "start") == 0)
+ if (strcmp (type->field (0).name (), "start") == 0)
{
if (type->num_fields () == 1)
return true;
return false;
}
- return strcmp (TYPE_FIELD_NAME (type, i), "end") == 0;
+ return strcmp (type->field (i).name (), "end") == 0;
}
/* Return true if TYPE is an inclusive range type, otherwise false.
{
return (type->code () == TYPE_CODE_INT
&& type->is_unsigned ()
- && TYPE_LENGTH (type) == 1);
+ && type->length () == 1);
}
/* Return true if TYPE is a Rust character type. */
rust_chartype_p (struct type *type)
{
return (type->code () == TYPE_CODE_CHAR
- && TYPE_LENGTH (type) == 4
+ && type->length () == 4
&& type->is_unsigned ());
}
static struct value *
rust_get_trait_object_pointer (struct value *value)
{
- struct type *type = check_typedef (value_type (value));
+ struct type *type = check_typedef (value->type ());
if (type->code () != TYPE_CODE_STRUCT || type->num_fields () != 2)
return NULL;
int vtable_field = 0;
for (int i = 0; i < 2; ++i)
{
- if (strcmp (TYPE_FIELD_NAME (type, i), "vtable") == 0)
+ if (strcmp (type->field (i).name (), "vtable") == 0)
vtable_field = i;
- else if (strcmp (TYPE_FIELD_NAME (type, i), "pointer") != 0)
+ else if (strcmp (type->field (i).name (), "pointer") != 0)
return NULL;
}
{
/* This is probably some C string, so let's let C deal with
it. */
- c_printstr (stream, type, string, length, user_encoding,
- force_ellipses, options);
+ language_defn::printstr (stream, type, string, length,
+ user_encoding, force_ellipses,
+ options);
return;
}
}
\f
-/* Helper function to print a string slice. */
+static const struct generic_val_print_decorations rust_decorations =
+{
+ /* Complex isn't used in Rust, but we provide C-ish values just in
+ case. */
+ "",
+ " + ",
+ " * I",
+ "true",
+ "false",
+ "()",
+ "[",
+ "]"
+};
+
+/* Helper function to print a slice. */
static void
-rust_val_print_str (struct ui_file *stream, struct value *val,
- const struct value_print_options *options)
+rust_val_print_slice (struct value *val, struct ui_file *stream, int recurse,
+ const struct value_print_options *options)
{
- struct value *base = value_struct_elt (&val, NULL, "data_ptr", NULL,
+ struct value *base = value_struct_elt (&val, {}, "data_ptr", NULL,
"slice");
- struct value *len = value_struct_elt (&val, NULL, "length", NULL, "slice");
+ struct value *len = value_struct_elt (&val, {}, "length", NULL, "slice");
- val_print_string (TYPE_TARGET_TYPE (value_type (base)), "UTF-8",
- value_as_address (base), value_as_long (len), stream,
- options);
+ struct type *type = check_typedef (val->type ());
+ if (strcmp (type->name (), "&str") == 0)
+ val_print_string (base->type ()->target_type (), "UTF-8",
+ value_as_address (base), value_as_long (len), stream,
+ options);
+ else
+ {
+ LONGEST llen = value_as_long (len);
+
+ type_print (val->type (), "", stream, -1);
+ gdb_printf (stream, " ");
+
+ if (llen == 0)
+ gdb_printf (stream, "[]");
+ else
+ {
+ struct type *elt_type = base->type ()->target_type ();
+ struct type *array_type = lookup_array_range_type (elt_type, 0,
+ llen - 1);
+ struct value *array = value::allocate_lazy (array_type);
+ array->set_lval (lval_memory);
+ array->set_address (value_as_address (base));
+ array->fetch_lazy ();
+ generic_value_print (array, stream, recurse, options,
+ &rust_decorations);
+ }
+ }
}
/* See rust-lang.h. */
{
int i;
int first_field;
- struct type *type = check_typedef (value_type (val));
+ struct type *type = check_typedef (val->type ());
- if (rust_slice_type_p (type) && strcmp (type->name (), "&str") == 0)
+ if (rust_slice_type_p (type))
{
- /* If what we are printing here is actually a string within a
- structure then VAL will be the original parent value, while TYPE
- will be the type of the structure representing the string we want
- to print.
- However, RUST_VAL_PRINT_STR looks up the fields of the string
- inside VAL, assuming that VAL is the string.
- So, recreate VAL as a value representing just the string. */
- val = value_at_lazy (type, value_address (val));
- rust_val_print_str (stream, val, options);
+ rust_val_print_slice (val, stream, recurse, options);
return;
}
if (!is_tuple)
{
if (type->name () != NULL)
- fprintf_filtered (stream, "%s", type->name ());
+ gdb_printf (stream, "%s", type->name ());
if (type->num_fields () == 0)
return;
if (type->name () != NULL)
- fputs_filtered (" ", stream);
+ gdb_puts (" ", stream);
}
if (is_tuple || is_tuple_struct)
- fputs_filtered ("(", stream);
+ gdb_puts ("(", stream);
else
- fputs_filtered ("{", stream);
+ gdb_puts ("{", stream);
opts = *options;
- opts.deref_ref = 0;
+ opts.deref_ref = false;
first_field = 1;
for (i = 0; i < type->num_fields (); ++i)
{
- if (field_is_static (&type->field (i)))
+ if (type->field (i).is_static ())
continue;
if (!first_field)
- fputs_filtered (",", stream);
+ gdb_puts (",", stream);
if (options->prettyformat)
{
- fputs_filtered ("\n", stream);
- print_spaces_filtered (2 + 2 * recurse, stream);
+ gdb_puts ("\n", stream);
+ print_spaces (2 + 2 * recurse, stream);
}
else if (!first_field)
- fputs_filtered (" ", stream);
+ gdb_puts (" ", stream);
first_field = 0;
if (!is_tuple && !is_tuple_struct)
{
- fputs_styled (TYPE_FIELD_NAME (type, i),
+ fputs_styled (type->field (i).name (),
variable_name_style.style (), stream);
- fputs_filtered (": ", stream);
+ gdb_puts (": ", stream);
}
- value_print_inner (value_field (val, i), stream, recurse + 1, &opts);
+ common_val_print (value_field (val, i), stream, recurse + 1, &opts,
+ this);
}
if (options->prettyformat)
{
- fputs_filtered ("\n", stream);
- print_spaces_filtered (2 * recurse, stream);
+ gdb_puts ("\n", stream);
+ print_spaces (2 * recurse, stream);
}
if (is_tuple || is_tuple_struct)
- fputs_filtered (")", stream);
+ gdb_puts (")", stream);
else
- fputs_filtered ("}", stream);
+ gdb_puts ("}", stream);
}
/* See rust-lang.h. */
const struct value_print_options *options) const
{
struct value_print_options opts = *options;
- struct type *type = check_typedef (value_type (val));
+ struct type *type = check_typedef (val->type ());
- opts.deref_ref = 0;
+ opts.deref_ref = false;
gdb_assert (rust_enum_p (type));
- gdb::array_view<const gdb_byte> view (value_contents_for_printing (val),
- TYPE_LENGTH (value_type (val)));
- type = resolve_dynamic_type (type, view, value_address (val));
+ gdb::array_view<const gdb_byte> view
+ (val->contents_for_printing ().data (),
+ val->type ()->length ());
+ type = resolve_dynamic_type (type, view, val->address ());
if (rust_empty_enum_p (type))
{
/* Print the enum type name here to be more clear. */
- fprintf_filtered (stream, _("%s {%p[<No data fields>%p]}"),
- type->name (),
- metadata_style.style ().ptr (), nullptr);
+ gdb_printf (stream, _("%s {%p[<No data fields>%p]}"),
+ type->name (),
+ metadata_style.style ().ptr (), nullptr);
return;
}
int variant_fieldno = rust_enum_variant (type);
- val = value_field (val, variant_fieldno);
+ val = val->primitive_field (0, variant_fieldno, type);
struct type *variant_type = type->field (variant_fieldno).type ();
int nfields = variant_type->num_fields ();
bool is_tuple = rust_tuple_struct_type_p (variant_type);
- fprintf_filtered (stream, "%s", variant_type->name ());
+ gdb_printf (stream, "%s", variant_type->name ());
if (nfields == 0)
{
/* In case of a nullary variant like 'None', just output
/* In case of a non-nullary variant, we output 'Foo(x,y,z)'. */
if (is_tuple)
- fprintf_filtered (stream, "(");
+ gdb_printf (stream, "(");
else
{
/* struct variant. */
- fprintf_filtered (stream, "{");
+ gdb_printf (stream, "{");
}
bool first_field = true;
- for (int j = 0; j < variant_type->num_fields (); j++)
+ for (int j = 0; j < nfields; j++)
{
if (!first_field)
- fputs_filtered (", ", stream);
+ gdb_puts (", ", stream);
first_field = false;
if (!is_tuple)
- fprintf_filtered (stream, "%ps: ",
- styled_string (variable_name_style.style (),
- TYPE_FIELD_NAME (variant_type, j)));
+ gdb_printf (stream, "%ps: ",
+ styled_string (variable_name_style.style (),
+ variant_type->field (j).name ()));
- value_print_inner (value_field (val, j), stream, recurse + 1, &opts);
+ common_val_print (value_field (val, j), stream, recurse + 1, &opts,
+ this);
}
if (is_tuple)
- fputs_filtered (")", stream);
+ gdb_puts (")", stream);
else
- fputs_filtered ("}", stream);
+ gdb_puts ("}", stream);
}
-static const struct generic_val_print_decorations rust_decorations =
-{
- /* Complex isn't used in Rust, but we provide C-ish values just in
- case. */
- "",
- " + ",
- " * I",
- "true",
- "false",
- "()",
- "[",
- "]"
-};
-
/* See language.h. */
void
const struct value_print_options *options) const
{
struct value_print_options opts = *options;
- opts.deref_ref = 1;
+ opts.deref_ref = true;
if (opts.prettyformat == Val_prettyformat_default)
opts.prettyformat = (opts.prettyformat_structs
? Val_prettyformat : Val_no_prettyformat);
- struct type *type = check_typedef (value_type (val));
+ struct type *type = check_typedef (val->type ());
switch (type->code ())
{
case TYPE_CODE_PTR:
{
LONGEST low_bound, high_bound;
- if (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,
+ if (type->target_type ()->code () == TYPE_CODE_ARRAY
+ && rust_u8_type_p (type->target_type ()->target_type ())
+ && get_array_bounds (type->target_type (), &low_bound,
&high_bound))
{
/* We have a pointer to a byte string, so just print
that. */
- struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));
+ struct type *elttype = check_typedef (type->target_type ());
CORE_ADDR addr = value_as_address (val);
struct gdbarch *arch = type->arch ();
if (opts.addressprint)
{
- fputs_filtered (paddress (arch, addr), stream);
- fputs_filtered (" ", stream);
+ gdb_puts (paddress (arch, addr), stream);
+ gdb_puts (" ", stream);
}
- fputs_filtered ("b", stream);
- val_print_string (TYPE_TARGET_TYPE (elttype), "ASCII", addr,
+ gdb_puts ("b", stream);
+ val_print_string (elttype->target_type (), "ASCII", addr,
high_bound - low_bound + 1, stream,
&opts);
break;
case TYPE_CODE_INT:
/* Recognize the unit type. */
- if (type->is_unsigned () && TYPE_LENGTH (type) == 0
+ if (type->is_unsigned () && type->length () == 0
&& type->name () != NULL && strcmp (type->name (), "()") == 0)
{
- fputs_filtered ("()", stream);
+ gdb_puts ("()", stream);
break;
}
goto generic_print;
/* If we see a plain TYPE_CODE_STRING, then we're printing a
byte string, hence the choice of "ASCII" as the
encoding. */
- fputs_filtered ("b", stream);
- printstr (stream, TYPE_TARGET_TYPE (type),
- value_contents_for_printing (val),
+ gdb_puts ("b", stream);
+ printstr (stream, type->target_type (),
+ val->contents_for_printing ().data (),
high_bound - low_bound + 1, "ASCII", 0, &opts);
}
break;
if (get_array_bounds (type, &low_bound, &high_bound)
&& high_bound - low_bound + 1 == 0)
- fputs_filtered ("[]", stream);
+ gdb_puts ("[]", stream);
else
goto generic_print;
}
}
}
+/* See language.h. */
+
+void
+rust_language::value_print
+ (struct value *val, struct ui_file *stream,
+ const struct value_print_options *options) const
+{
+ value_print_options opts = *options;
+ opts.deref_ref = true;
+
+ struct type *type = check_typedef (val->type ());
+ if (type->is_pointer_or_reference ())
+ {
+ gdb_printf (stream, "(");
+ type_print (val->type (), "", stream, -1);
+ gdb_printf (stream, ") ");
+ }
+
+ return common_val_print (val, stream, 0, &opts, this);
+}
+
\f
static void
/* Print a tuple type simply. */
if (rust_tuple_type_p (type))
{
- fputs_filtered (type->name (), stream);
+ gdb_puts (type->name (), stream);
return;
}
/* If we see a base class, delegate to C. */
if (TYPE_N_BASECLASSES (type) > 0)
- c_print_type (type, varstring, stream, show, level, flags);
+ c_print_type (type, varstring, stream, show, level, language_rust, flags);
if (flags->print_offsets)
{
/* This code path is also used by unions and enums. */
if (is_enum)
{
- fputs_filtered ("enum ", stream);
+ gdb_puts ("enum ", stream);
dynamic_prop *prop = type->dyn_prop (DYN_PROP_VARIANT_PARTS);
if (prop != nullptr && prop->kind () == PROP_TYPE)
type = prop->original_type ();
}
else if (type->code () == TYPE_CODE_STRUCT)
- fputs_filtered ("struct ", stream);
+ gdb_puts ("struct ", stream);
else
- fputs_filtered ("union ", stream);
+ gdb_puts ("union ", stream);
if (tagname != NULL)
- fputs_filtered (tagname, stream);
+ gdb_puts (tagname, stream);
}
if (type->num_fields () == 0 && !is_tuple)
return;
if (for_rust_enum && !flags->print_offsets)
- fputs_filtered (is_tuple_struct ? "(" : "{", stream);
+ gdb_puts (is_tuple_struct ? "(" : "{", stream);
else
- fputs_filtered (is_tuple_struct ? " (\n" : " {\n", stream);
+ gdb_puts (is_tuple_struct ? " (\n" : " {\n", stream);
/* When printing offsets, we rearrange the fields into storage
order. This lets us show holes more clearly. We work using
std::vector<int> fields;
for (int i = 0; i < type->num_fields (); ++i)
{
- if (field_is_static (&type->field (i)))
+ if (type->field (i).is_static ())
continue;
- if (is_enum && TYPE_FIELD_ARTIFICIAL (type, i))
+ if (is_enum && type->field (i).is_artificial ())
continue;
fields.push_back (i);
}
std::sort (fields.begin (), fields.end (),
[&] (int a, int b)
{
- return (TYPE_FIELD_BITPOS (type, a)
- < TYPE_FIELD_BITPOS (type, b));
+ return (type->field (a).loc_bitpos ()
+ < type->field (b).loc_bitpos ());
});
for (int i : fields)
{
QUIT;
- gdb_assert (!field_is_static (&type->field (i)));
- gdb_assert (! (is_enum && TYPE_FIELD_ARTIFICIAL (type, i)));
+ gdb_assert (!type->field (i).is_static ());
+ gdb_assert (! (is_enum && type->field (i).is_artificial ()));
if (flags->print_offsets)
podata->update (type, i, stream);
/* For a tuple struct we print the type but nothing
else. */
if (!for_rust_enum || flags->print_offsets)
- print_spaces_filtered (level + 2, stream);
+ print_spaces (level + 2, stream);
if (is_enum)
- fputs_styled (TYPE_FIELD_NAME (type, i), variable_name_style.style (),
+ fputs_styled (type->field (i).name (), variable_name_style.style (),
stream);
else if (!is_tuple_struct)
- fprintf_filtered (stream, "%ps: ",
- styled_string (variable_name_style.style (),
- TYPE_FIELD_NAME (type, i)));
+ gdb_printf (stream, "%ps: ",
+ styled_string (variable_name_style.style (),
+ type->field (i).name ()));
rust_internal_print_type (type->field (i).type (), NULL,
stream, (is_enum ? show : show - 1),
level + 2, flags, is_enum, podata);
if (!for_rust_enum || flags->print_offsets)
- fputs_filtered (",\n", stream);
+ gdb_puts (",\n", stream);
/* Note that this check of "I" is ok because we only sorted the
fields by offset when print_offsets was set, so we won't take
this branch in that case. */
else if (i + 1 < type->num_fields ())
- fputs_filtered (", ", stream);
+ gdb_puts (", ", stream);
}
if (flags->print_offsets)
/* Undo the temporary level increase we did above. */
level -= 2;
podata->finish (type, level, stream);
- print_spaces_filtered (print_offset_data::indentation, stream);
+ print_spaces (print_offset_data::indentation, stream);
if (level == 0)
- print_spaces_filtered (2, stream);
+ print_spaces (2, stream);
}
if (!for_rust_enum || flags->print_offsets)
- print_spaces_filtered (level, stream);
- fputs_filtered (is_tuple_struct ? ")" : "}", stream);
+ print_spaces (level, stream);
+ gdb_puts (is_tuple_struct ? ")" : "}", stream);
}
/* la_print_type implementation for Rust. */
/* Rust calls the unit type "void" in its debuginfo,
but we don't want to print it as that. */
if (type->code () == TYPE_CODE_VOID)
- fputs_filtered ("()", stream);
+ gdb_puts ("()", stream);
else
- fputs_filtered (type->name (), stream);
+ gdb_puts (type->name (), stream);
return;
}
unqualified name, and there is nothing else to print
here. */
if (!for_rust_enum)
- fputs_filtered ("()", stream);
+ gdb_puts ("()", stream);
break;
case TYPE_CODE_FUNC:
if (type->has_varargs ())
goto c_printer;
- fputs_filtered ("fn ", stream);
+ gdb_puts ("fn ", stream);
if (varstring != NULL)
- fputs_filtered (varstring, stream);
- fputs_filtered ("(", stream);
+ gdb_puts (varstring, stream);
+ gdb_puts ("(", stream);
for (int i = 0; i < type->num_fields (); ++i)
{
QUIT;
if (i > 0)
- fputs_filtered (", ", stream);
+ gdb_puts (", ", stream);
rust_internal_print_type (type->field (i).type (), "", stream,
-1, 0, flags, false, podata);
}
- fputs_filtered (")", stream);
+ gdb_puts (")", stream);
/* If it returns unit, we can omit the return type. */
- if (TYPE_TARGET_TYPE (type)->code () != TYPE_CODE_VOID)
+ if (type->target_type ()->code () != TYPE_CODE_VOID)
{
- fputs_filtered (" -> ", stream);
- rust_internal_print_type (TYPE_TARGET_TYPE (type), "", stream,
+ gdb_puts (" -> ", stream);
+ rust_internal_print_type (type->target_type (), "", stream,
-1, 0, flags, false, podata);
}
break;
{
LONGEST low_bound, high_bound;
- fputs_filtered ("[", stream);
- rust_internal_print_type (TYPE_TARGET_TYPE (type), NULL,
+ gdb_puts ("[", stream);
+ rust_internal_print_type (type->target_type (), NULL,
stream, show - 1, level, flags, false,
podata);
if (type->bounds ()->high.kind () == PROP_LOCEXPR
|| type->bounds ()->high.kind () == PROP_LOCLIST)
- fprintf_filtered (stream, "; variable length");
+ gdb_printf (stream, "; variable length");
else if (get_array_bounds (type, &low_bound, &high_bound))
- fprintf_filtered (stream, "; %s",
- plongest (high_bound - low_bound + 1));
- fputs_filtered ("]", stream);
+ gdb_printf (stream, "; %s",
+ plongest (high_bound - low_bound + 1));
+ gdb_puts ("]", stream);
}
break;
{
int len = 0;
- fputs_filtered ("enum ", stream);
+ gdb_puts ("enum ", stream);
if (type->name () != NULL)
{
- fputs_filtered (type->name (), stream);
- fputs_filtered (" ", stream);
+ gdb_puts (type->name (), stream);
+ gdb_puts (" ", stream);
len = strlen (type->name ());
}
- fputs_filtered ("{\n", stream);
+ gdb_puts ("{\n", stream);
for (int i = 0; i < type->num_fields (); ++i)
{
- const char *name = TYPE_FIELD_NAME (type, i);
+ const char *name = type->field (i).name ();
QUIT;
&& name[len] == ':'
&& name[len + 1] == ':')
name += len + 2;
- fprintf_filtered (stream, "%*s%ps,\n",
- level + 2, "",
- styled_string (variable_name_style.style (),
- name));
+ gdb_printf (stream, "%*s%ps,\n",
+ level + 2, "",
+ styled_string (variable_name_style.style (),
+ name));
}
- fputs_filtered ("}", stream);
+ gdb_puts ("}", stream);
}
break;
case TYPE_CODE_PTR:
{
if (type->name () != nullptr)
- fputs_filtered (type->name (), stream);
+ gdb_puts (type->name (), stream);
else
{
/* We currently can't distinguish between pointers and
references. */
- fputs_filtered ("*mut ", stream);
- type_print (TYPE_TARGET_TYPE (type), "", stream, 0);
+ gdb_puts ("*mut ", stream);
+ type_print (type->target_type (), "", stream, 0);
}
}
break;
default:
c_printer:
- c_print_type (type, varstring, stream, show, level, flags);
+ c_print_type (type, varstring, stream, show, level, language_rust,
+ flags);
}
}
const char *field1, struct type *type1,
const char *field2, struct type *type2)
{
- struct type *result = alloc_type_copy (original);
+ struct type *result = type_allocator (original).new_type ();
int i, nfields, bitpos;
nfields = 0;
result->set_code (TYPE_CODE_STRUCT);
result->set_name (name);
- result->set_num_fields (nfields);
- result->set_fields
- ((struct field *) TYPE_ZALLOC (result, nfields * sizeof (struct field)));
+ result->alloc_fields (nfields);
i = 0;
bitpos = 0;
{
struct field *field = &result->field (i);
- SET_FIELD_BITPOS (*field, bitpos);
- bitpos += TYPE_LENGTH (type1) * TARGET_CHAR_BIT;
+ field->set_loc_bitpos (bitpos);
+ bitpos += type1->length () * TARGET_CHAR_BIT;
- FIELD_NAME (*field) = field1;
+ field->set_name (field1);
field->set_type (type1);
++i;
}
if (delta != 0)
bitpos += align - delta;
}
- SET_FIELD_BITPOS (*field, bitpos);
+ field->set_loc_bitpos (bitpos);
- FIELD_NAME (*field) = field2;
+ field->set_name (field2);
field->set_type (type2);
++i;
}
if (i > 0)
- TYPE_LENGTH (result)
- = (TYPE_FIELD_BITPOS (result, i - 1) / TARGET_CHAR_BIT +
- TYPE_LENGTH (result->field (i - 1).type ()));
+ result->set_length (result->field (i - 1).loc_bitpos () / TARGET_CHAR_BIT
+ + result->field (i - 1).type ()->length ());
return result;
}
\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 *
+struct value *
rust_range (struct type *expect_type, struct expression *exp,
enum noside noside, enum range_flag kind,
struct value *low, struct value *high)
bool inclusive = !(kind & RANGE_HIGH_BOUND_EXCLUSIVE);
- if (noside == EVAL_SKIP)
- return value_from_longest (builtin_type (exp->gdbarch)->builtin_int, 1);
-
if (low == NULL)
{
if (high == NULL)
}
else
{
- index_type = value_type (high);
+ index_type = high->type ();
name = (inclusive
? "std::ops::RangeToInclusive" : "std::ops::RangeTo");
}
{
if (high == NULL)
{
- index_type = value_type (low);
+ index_type = low->type ();
name = "std::ops::RangeFrom";
}
else
{
- if (!types_equal (value_type (low), value_type (high)))
+ if (!types_equal (low->type (), high->type ()))
error (_("Range expression with different types"));
- index_type = value_type (low);
+ index_type = low->type ();
name = inclusive ? "std::ops::RangeInclusive" : "std::ops::Range";
}
}
high == NULL ? NULL : "end", index_type);
if (noside == EVAL_AVOID_SIDE_EFFECTS)
- return value_zero (range_type, lval_memory);
+ return value::zero (range_type, lval_memory);
- addrval = value_allocate_space_in_inferior (TYPE_LENGTH (range_type));
+ addrval = value_allocate_space_in_inferior (range_type->length ());
addr = value_as_long (addrval);
result = value_at_lazy (range_type, addr);
if (low != NULL)
{
- struct value *start = value_struct_elt (&result, NULL, "start", NULL,
+ struct value *start = value_struct_elt (&result, {}, "start", NULL,
"range");
value_assign (start, low);
if (high != NULL)
{
- struct value *end = value_struct_elt (&result, NULL, "end", NULL,
+ struct value *end = value_struct_elt (&result, {}, "end", NULL,
"range");
value_assign (end, high);
return;
i = 0;
- if (strcmp (TYPE_FIELD_NAME (type, 0), "start") == 0)
+ if (strcmp (type->field (0).name (), "start") == 0)
{
*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)
+ && strcmp (type->field (i).name (), "end") == 0)
{
*kind = (*kind == (RANGE_LOW_BOUND_DEFAULT | RANGE_HIGH_BOUND_DEFAULT)
? RANGE_LOW_BOUND_DEFAULT : RANGE_STANDARD);
/* A helper for rust_evaluate_subexp that handles BINOP_SUBSCRIPT. */
-static struct value *
+struct value *
rust_subscript (struct type *expect_type, struct expression *exp,
enum noside noside, bool for_addr,
struct value *lhs, struct value *rhs)
LONGEST high = 0;
int want_slice = 0;
- if (noside == EVAL_SKIP)
- return lhs;
-
- rhstype = check_typedef (value_type (rhs));
+ rhstype = check_typedef (rhs->type ());
if (rust_range_type_p (rhstype))
{
if (!for_addr)
else
low = value_as_long (rhs);
- struct type *type = check_typedef (value_type (lhs));
+ struct type *type = check_typedef (lhs->type ());
if (noside == EVAL_AVOID_SIDE_EFFECTS)
{
struct type *base_type = nullptr;
if (type->code () == TYPE_CODE_ARRAY)
- base_type = TYPE_TARGET_TYPE (type);
+ base_type = type->target_type ();
else if (rust_slice_type_p (type))
{
for (int i = 0; i < type->num_fields (); ++i)
{
- if (strcmp (TYPE_FIELD_NAME (type, i), "data_ptr") == 0)
+ if (strcmp (type->field (i).name (), "data_ptr") == 0)
{
- base_type = TYPE_TARGET_TYPE (type->field (i).type ());
+ base_type = type->field (i).type ()->target_type ();
break;
}
}
error (_("Could not find 'data_ptr' in slice type"));
}
else if (type->code () == TYPE_CODE_PTR)
- base_type = TYPE_TARGET_TYPE (type);
+ base_type = type->target_type ();
else
error (_("Cannot subscript non-array type"));
else
new_type = base_type;
- return value_zero (new_type, VALUE_LVAL (lhs));
+ return value::zero (new_type, lhs->lval ());
}
else
{
{
struct value *len;
- base = value_struct_elt (&lhs, NULL, "data_ptr", NULL, "slice");
- len = value_struct_elt (&lhs, NULL, "length", NULL, "slice");
+ base = value_struct_elt (&lhs, {}, "data_ptr", NULL, "slice");
+ len = value_struct_elt (&lhs, {}, "length", NULL, "slice");
low_bound = 0;
high_bound = value_as_long (len);
}
&& rust_slice_type_p (type))
? type->name () : "&[*gdb*]");
- slice = rust_slice_type (new_name, value_type (result), usize);
+ slice = rust_slice_type (new_name, result->type (), usize);
- addrval = value_allocate_space_in_inferior (TYPE_LENGTH (slice));
+ addrval = value_allocate_space_in_inferior (slice->length ());
addr = value_as_long (addrval);
tem = value_at_lazy (slice, addr);
return result;
}
-/* A helper function for UNOP_IND. */
+namespace expr
+{
struct value *
-eval_op_rust_ind (struct type *expect_type, struct expression *exp,
- enum noside noside,
- enum exp_opcode opcode,
- struct value *value)
+rust_unop_ind_operation::evaluate (struct type *expect_type,
+ struct expression *exp,
+ enum noside noside)
{
- gdb_assert (noside == EVAL_NORMAL);
+ if (noside != EVAL_NORMAL)
+ return unop_ind_operation::evaluate (expect_type, exp, noside);
+
+ struct value *value = std::get<0> (m_storage)->evaluate (nullptr, exp,
+ noside);
struct value *trait_ptr = rust_get_trait_object_pointer (value);
if (trait_ptr != NULL)
value = trait_ptr;
return value_ind (value);
}
+} /* namespace expr */
+
/* A helper function for UNOP_COMPLEMENT. */
struct value *
enum exp_opcode opcode,
struct value *value)
{
- if (noside == EVAL_SKIP)
- {
- /* Preserving the type is enough. */
- return value;
- }
- if (value_type (value)->code () == TYPE_CODE_BOOL)
- return value_from_longest (value_type (value), value_logical_not (value));
+ if (value->type ()->code () == TYPE_CODE_BOOL)
+ return value_from_longest (value->type (), value_logical_not (value));
return value_complement (value);
}
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;
- return value_array (0, copies - 1, eltvec.data ());
- }
+ return value_array (0, std::vector<value *> (copies, elt));
else
{
struct type *arraytype
- = lookup_array_range_type (value_type (elt), 0, copies - 1);
- return allocate_value (arraytype);
+ = lookup_array_range_type (elt->type (), 0, copies - 1);
+ return value::allocate (arraytype);
}
}
-/* A helper function for STRUCTOP_ANONYMOUS. */
+namespace expr
+{
-static struct value *
-eval_op_rust_struct_anon (struct type *expect_type, struct expression *exp,
- enum noside noside,
- int field_number, struct value *lhs)
+struct value *
+rust_struct_anon::evaluate (struct type *expect_type,
+ struct expression *exp,
+ enum noside noside)
{
- struct type *type = value_type (lhs);
+ value *lhs = std::get<1> (m_storage)->evaluate (nullptr, exp, noside);
+ int field_number = std::get<0> (m_storage);
+
+ struct type *type = lhs->type ();
if (type->code () == TYPE_CODE_STRUCT)
{
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));
+ type = resolve_dynamic_type (type, lhs->contents (),
+ lhs->address ());
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);
+ lhs = lhs->primitive_field (0, fieldno, type);
outer_type = type;
- type = value_type (lhs);
+ type = lhs->type ();
}
/* Tuples and tuple structs */
field_number, type->name ());
}
- return value_primitive_field (lhs, 0, field_number, type);
+ return lhs->primitive_field (0, field_number, type);
}
else
error(_("Anonymous field access is only allowed on tuples, \
tuple structs, and tuple-like enum variants"));
}
-/* A helper function for STRUCTOP_STRUCT. */
-
-static struct value *
-eval_op_rust_structop (struct type *expect_type, struct expression *exp,
- enum noside noside,
- struct value *lhs, const char *field_name)
+struct value *
+rust_structop::evaluate (struct type *expect_type,
+ struct expression *exp,
+ enum noside noside)
{
+ value *lhs = std::get<0> (m_storage)->evaluate (nullptr, exp, noside);
+ const char *field_name = std::get<1> (m_storage).c_str ();
+
struct value *result;
- struct type *type = value_type (lhs);
+ struct type *type = lhs->type ();
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));
+ type = resolve_dynamic_type (type, lhs->contents (),
+ lhs->address ());
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);
+ lhs = lhs->primitive_field (0, fieldno, type);
struct type *outer_type = type;
- type = value_type (lhs);
+ type = lhs->type ();
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"),
try
{
- result = value_struct_elt (&lhs, NULL, field_name,
+ result = value_struct_elt (&lhs, {}, field_name,
NULL, "structure");
}
catch (const gdb_exception_error &except)
}
}
else
- result = value_struct_elt (&lhs, NULL, field_name, NULL, "structure");
+ result = value_struct_elt (&lhs, {}, field_name, NULL, "structure");
if (noside == EVAL_AVOID_SIDE_EFFECTS)
- result = value_zero (value_type (result), VALUE_LVAL (result));
+ result = value::zero (result->type (), result->lval ());
return result;
}
-/* evaluate_exp implementation for Rust. */
-
-static struct value *
-rust_evaluate_subexp (struct type *expect_type, struct expression *exp,
- int *pos, enum noside noside)
+value *
+rust_aggregate_operation::evaluate (struct type *expect_type,
+ struct expression *exp,
+ enum noside noside)
{
- struct value *result;
- enum exp_opcode op = exp->elts[*pos].opcode;
+ struct type *type = std::get<0> (m_storage);
+ CORE_ADDR addr = 0;
+ struct value *addrval = NULL;
+ value *result;
- switch (op)
+ if (noside == EVAL_NORMAL)
{
- 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);
- result = eval_op_rust_ind (expect_type, exp, noside, op, value);
- }
- }
- break;
-
- case UNOP_COMPLEMENT:
- {
- struct value *value;
-
- ++*pos;
- value = evaluate_subexp (nullptr, exp, pos, noside);
- result = eval_op_rust_complement (expect_type, exp, noside, op, value);
- }
- break;
-
- case BINOP_SUBSCRIPT:
- {
- ++*pos;
- struct value *lhs = evaluate_subexp (nullptr, exp, pos, noside);
- struct value *rhs = evaluate_subexp (nullptr, exp, pos, noside);
- result = rust_subscript (expect_type, exp, noside, false, lhs, rhs);
- }
- 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)++;
- struct value *elt;
- struct value *ncopies;
-
- elt = rust_evaluate_subexp (NULL, exp, pos, noside);
- ncopies = rust_evaluate_subexp (NULL, exp, pos, noside);
- return eval_op_rust_array (expect_type, exp, noside, op, elt, ncopies);
- }
- break;
-
- case STRUCTOP_ANONYMOUS:
- {
- /* Anonymous field access, i.e. foo.1. */
- struct value *lhs;
- int pc, field_number;
-
- pc = (*pos)++;
- field_number = longest_to_int (exp->elts[pc + 1].longconst);
- (*pos) += 2;
- lhs = evaluate_subexp (nullptr, exp, pos, noside);
-
- return eval_op_rust_struct_anon (expect_type, exp, noside,
- field_number, lhs);
- }
- break;
-
- case STRUCTOP_STRUCT:
- {
- struct value *lhs;
- 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;
- return eval_op_rust_structop (expect_type, exp, noside, lhs,
- field_name);
- }
- break;
-
- case OP_RANGE:
- {
- struct value *low = NULL, *high = NULL;
- auto kind
- = (enum range_flag) longest_to_int (exp->elts[*pos + 1].longconst);
- *pos += 3;
-
- if (!(kind & RANGE_LOW_BOUND_DEFAULT))
- low = evaluate_subexp (nullptr, exp, pos, noside);
- if (!(kind & RANGE_HIGH_BOUND_DEFAULT))
- high = evaluate_subexp (nullptr, exp, pos, noside);
+ addrval = value_allocate_space_in_inferior (type->length ());
+ addr = value_as_long (addrval);
+ result = value_at_lazy (type, addr);
+ }
- result = rust_range (expect_type, exp, noside, kind, low, high);
- }
- break;
+ if (std::get<1> (m_storage) != nullptr)
+ {
+ struct value *init = std::get<1> (m_storage)->evaluate (nullptr, exp,
+ noside);
- 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)
+ if (noside == EVAL_NORMAL)
{
- ++*pos;
- ++*pos;
- struct value *lhs = evaluate_subexp (nullptr, exp, pos, noside);
- struct value *rhs = evaluate_subexp (nullptr, exp, pos, noside);
-
- result = rust_subscript (expect_type, exp, noside, true, lhs, rhs);
- break;
+ /* 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);
}
- /* Fall through. */
- default:
- result = evaluate_subexp_standard (expect_type, exp, pos, noside);
- break;
}
- return result;
-}
-
-/* operator_length implementation for Rust. */
-
-static void
-rust_operator_length (const struct expression *exp, int pc, int *oplenp,
- int *argsp)
-{
- int oplen = 1;
- int args = 0;
-
- switch (exp->elts[pc - 1].opcode)
+ for (const auto &item : std::get<2> (m_storage))
{
- 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;
-
- 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;
+ 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, {}, fieldname,
+ nullptr, "structure");
+ value_assign (field, val);
+ }
}
- *oplenp = oplen;
- *argsp = args;
-}
-
-/* dump_subexp_body implementation for Rust. */
-
-static int
-rust_dump_subexp_body (struct expression *exp, struct ui_file *stream,
- int elt)
-{
- 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;
-
- 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;
-
- case STRUCTOP_ANONYMOUS:
- {
- int field_number;
-
- field_number = longest_to_int (exp->elts[elt + 1].longconst);
-
- fprintf_filtered (stream, "Field number: %d", field_number);
- elt = dump_subexp (exp, stream, elt + 3);
- }
- break;
-
- case OP_RUST_ARRAY:
- ++elt;
- break;
-
- default:
- elt = dump_subexp_body_standard (exp, stream, elt);
- break;
- }
+ if (noside == EVAL_AVOID_SIDE_EFFECTS)
+ result = value::allocate (type);
+ else
+ result = value_at_lazy (type, addr);
- return elt;
+ return result;
}
-/* print_subexp implementation for Rust. */
-
-static void
-rust_print_subexp (struct expression *exp, int *pos, struct ui_file *stream,
- enum precedence prec)
+value *
+rust_structop::evaluate_funcall (struct type *expect_type,
+ struct expression *exp,
+ enum noside noside,
+ const std::vector<operation_up> &ops)
{
- switch (exp->elts[*pos].opcode)
- {
- case OP_AGGREGATE:
- {
- int length = longest_to_int (exp->elts[*pos + 2].longconst);
- int i;
+ std::vector<struct value *> args (ops.size () + 1);
- type_print (exp->elts[*pos + 1].type, "", stream, 0);
- fputs_filtered (" { ", stream);
+ /* 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 (args[0]->type ()->code () == TYPE_CODE_PTR)
+ args[0] = value_ind (args[0]);
- *pos += 4;
- for (i = 0; i < length; ++i)
- {
- rust_print_subexp (exp, pos, stream, prec);
- fputs_filtered (", ", stream);
- }
- fputs_filtered (" }", stream);
- }
- break;
+ struct type *type = args[0]->type ();
+ 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"));
- case OP_NAME:
- {
- LONGEST len = exp->elts[*pos + 1].longconst;
+ std::string name = (std::string (type->name ()) + "::"
+ + std::get<1> (m_storage));
- fputs_filtered (&exp->elts[*pos + 2].string, stream);
- *pos += 4 + BYTES_TO_EXP_ELEM (len + 1);
- }
- break;
+ 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 ());
- case OP_OTHERS:
- {
- fputs_filtered ("<<others>> (", stream);
- ++*pos;
- rust_print_subexp (exp, pos, stream, prec);
- fputs_filtered (")", stream);
- }
- break;
+ struct type *fn_type = sym.symbol->type ();
+ if (fn_type->num_fields () == 0)
+ error (_("Function '%s' takes no arguments"), name.c_str ());
- case STRUCTOP_ANONYMOUS:
- {
- int tem = longest_to_int (exp->elts[*pos + 1].longconst);
+ if (fn_type->field (0).type ()->code () == TYPE_CODE_PTR)
+ args[0] = value_addr (args[0]);
- (*pos) += 3;
- print_subexp (exp, pos, stream, PREC_SUFFIX);
- fprintf_filtered (stream, ".%d", tem);
- }
- break;
+ value *function = address_of_variable (sym.symbol, block);
- 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;
+ for (int i = 0; i < ops.size (); ++i)
+ args[i + 1] = ops[i]->evaluate (nullptr, exp, noside);
- default:
- print_subexp_standard (exp, pos, stream, prec);
- break;
- }
+ if (noside == EVAL_AVOID_SIDE_EFFECTS)
+ return value::zero (fn_type->target_type (), not_lval);
+ return call_function_by_hand (function, NULL, args);
}
-/* 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)
-{
- switch (exp->elts[pos].opcode)
- {
- case OP_AGGREGATE:
- {
- struct type *type = exp->elts[pos + 1].type;
- struct objfile *objfile = type->objfile_owner ();
-
- if (objfile != NULL && (*objfile_func) (objfile, data))
- return 1;
- }
- break;
-
- case OP_OTHERS:
- case OP_NAME:
- case OP_RUST_ARRAY:
- break;
-
- default:
- return operator_check_standard (exp, pos, objfile_func, data);
- }
-
- return 0;
}
\f
-const struct exp_descriptor rust_language::exp_descriptor_tab =
-{
- rust_print_subexp,
- rust_operator_length,
- rust_operator_check,
- rust_dump_subexp_body,
- rust_evaluate_subexp
-};
-
/* See language.h. */
void
return t;
};
+ type_allocator alloc (gdbarch);
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"));
+ = add (init_boolean_type (alloc, 8, 1, "bool"));
+ add (init_character_type (alloc, 32, 1, "char"));
+ add (init_integer_type (alloc, 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"));
+ = add (init_integer_type (alloc, 8, 1, "u8"));
+ add (init_integer_type (alloc, 16, 0, "i16"));
+ add (init_integer_type (alloc, 16, 1, "u16"));
+ add (init_integer_type (alloc, 32, 0, "i32"));
+ add (init_integer_type (alloc, 32, 1, "u32"));
+ add (init_integer_type (alloc, 64, 0, "i64"));
+ add (init_integer_type (alloc, 64, 1, "u64"));
+ add (init_integer_type (alloc, 128, 0, "i128"));
+ add (init_integer_type (alloc, 128, 1, "u128"));
+
+ unsigned int length = 8 * builtin->builtin_data_ptr->length ();
+ add (init_integer_type (alloc, length, 0, "isize"));
struct type *usize_type
- = add (arch_integer_type (gdbarch, length, 1, "usize"));
+ = add (init_integer_type (alloc, 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, "()"));
+ add (init_float_type (alloc, 32, "f32", floatformats_ieee_single));
+ add (init_float_type (alloc, 64, "f64", floatformats_ieee_double));
+ add (init_integer_type (alloc, 0, 1, "()"));
struct type *tem = make_cv_type (1, 0, u8_type, NULL);
add (rust_slice_type ("&str", tem, usize_type));
struct ui_file *stream, int show, int level,
const struct type_print_options *flags) const
{
- print_offset_data podata;
+ print_offset_data podata (flags);
rust_internal_print_type (type, varstring, stream, show, level,
flags, false, &podata);
}
generic_emit_char (ch, chtype, stream, quoter,
target_charset (chtype->arch ()));
else if (ch == '\\' || ch == quoter)
- fprintf_filtered (stream, "\\%c", ch);
+ gdb_printf (stream, "\\%c", ch);
else if (ch == '\n')
- fputs_filtered ("\\n", stream);
+ gdb_puts ("\\n", stream);
else if (ch == '\r')
- fputs_filtered ("\\r", stream);
+ gdb_puts ("\\r", stream);
else if (ch == '\t')
- fputs_filtered ("\\t", stream);
+ gdb_puts ("\\t", stream);
else if (ch == '\0')
- fputs_filtered ("\\0", stream);
+ gdb_puts ("\\0", stream);
else if (ch >= 32 && ch <= 127 && isprint (ch))
- fputc_filtered (ch, stream);
+ gdb_putc (ch, stream);
else if (ch <= 255)
- fprintf_filtered (stream, "\\x%02x", ch);
+ gdb_printf (stream, "\\x%02x", ch);
else
- fprintf_filtered (stream, "\\u{%06x}", ch);
+ gdb_printf (stream, "\\u{%06x}", ch);
}
/* See language.h. */
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,
+ && (type->target_type ()->code () == TYPE_CODE_ARRAY
+ && rust_u8_type_p (type->target_type ()->target_type ())
+ && get_array_bounds (type->target_type (), &low_bound,
&high_bound)))
|| (type->code () == TYPE_CODE_STRUCT
&& !rust_enum_p (type)
&& strcmp (type->name (), "&str") == 0));
}
+/* See language.h. */
+
+struct block_symbol
+rust_language::lookup_symbol_nonlocal
+ (const char *name, const struct block *block,
+ const domain_enum domain) const
+{
+ struct block_symbol result = {};
+
+ const char *scope = block == nullptr ? "" : block->scope ();
+ symbol_lookup_debug_printf
+ ("rust_lookup_symbol_non_local (%s, %s (scope %s), %s)",
+ name, host_address_to_string (block), scope,
+ domain_name (domain));
+
+ /* Look up bare names in the block's scope. */
+ std::string scopedname;
+ if (name[cp_find_first_component (name)] == '\0')
+ {
+ if (scope[0] != '\0')
+ {
+ scopedname = std::string (scope) + "::" + name;
+ name = scopedname.c_str ();
+ }
+ else
+ name = NULL;
+ }
+
+ 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;
+}
+
/* Single instance of the Rust language class. */
static rust_language rust_language_defn;