/* Rust language support routines for GDB, the GNU debugger.
- Copyright (C) 2016 Free Software Foundation, Inc.
+ Copyright (C) 2016-2017 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 "valprint.h"
#include "varobj.h"
#include <string>
#include <vector>
-extern initialize_file_ftype _initialize_rust_language;
-
/* Returns the last segment of a Rust path like foo::bar::baz. Will
not handle cases where the last segment contains generics. This
will return NULL if the last segment cannot be found. */
return result + 1;
}
-/* Find the Rust crate for BLOCK. If no crate can be found, returns
- NULL. Otherwise, returns a newly allocated string that the caller
- is responsible for freeing. */
+/* See rust-lang.h. */
-char *
+std::string
rust_crate_for_block (const struct block *block)
{
const char *scope = block_scope (block);
if (scope[0] == '\0')
- return NULL;
+ return std::string ();
- return xstrndup (scope, cp_find_first_component (scope));
+ return std::string (scope, cp_find_first_component (scope));
}
/* Information about the discriminant/variant of an enum */
if (TYPE_NFIELDS (type) == 0)
return false;
/* If the first field is named, but the name has the rust enum prefix,
- it is an enum. */
+ it is an enum. */
if (strncmp (TYPE_FIELD_NAME (type, 0), RUST_ENUM_PREFIX,
strlen (RUST_ENUM_PREFIX)) == 0)
return false;
int i;
struct disr_info ret;
struct type *disr_type;
- struct ui_file *temp_file;
struct value_print_options opts;
- struct cleanup *cleanup;
const char *name_segment;
get_no_prettyformat_print_options (&opts);
/* Optimized enums have only one field. */
member_type = TYPE_FIELD_TYPE (type, 0);
- gdb::unique_xmalloc_ptr<char> name (xstrdup (TYPE_FIELD_NAME (type, 0)));
- tail = name.get () + strlen (RUST_ENUM_PREFIX);
+ std::string name (TYPE_FIELD_NAME (type, 0));
+ tail = &name[0] + strlen (RUST_ENUM_PREFIX);
/* The location of the value that doubles as a discriminant is
stored in the name of the field, as
if (strcmp (TYPE_FIELD_NAME (disr_type, 0), "RUST$ENUM$DISR") != 0)
error (_("Rust debug format has changed"));
- temp_file = mem_fileopen ();
- cleanup = make_cleanup_ui_file_delete (temp_file);
+ string_file temp_file;
/* The first value of the first field (or any field)
is the discriminant value. */
c_val_print (TYPE_FIELD_TYPE (disr_type, 0),
(embedded_offset + TYPE_FIELD_BITPOS (type, 0) / 8
+ TYPE_FIELD_BITPOS (disr_type, 0) / 8),
- address, temp_file,
+ address, &temp_file,
0, val, &opts);
- ret.name = ui_file_as_string (temp_file);
+ ret.name = std::move (temp_file.string ());
name_segment = rust_last_path_segment (ret.name.c_str ());
if (name_segment != NULL)
{
TYPE_TAG_NAME (type), ret.name.c_str ());
}
- do_cleanups (cleanup);
return ret;
}
/* See rust-lang.h. */
-int
+bool
rust_tuple_type_p (struct type *type)
{
/* The current implementation is a bit of a hack, but there's
/* Return true if all non-static fields of a structlike type are in a
sequence like __0, __1, __2. OFFSET lets us skip fields. */
-static int
+static bool
rust_underscore_fields (struct type *type, int offset)
{
int i, field_number;
field_number = 0;
if (TYPE_CODE (type) != TYPE_CODE_STRUCT)
- return 0;
+ return false;
for (i = 0; i < TYPE_NFIELDS (type); ++i)
{
if (!field_is_static (&TYPE_FIELD (type, i)))
xsnprintf (buf, sizeof (buf), "__%d", field_number);
if (strcmp (buf, TYPE_FIELD_NAME (type, i)) != 0)
- return 0;
+ return false;
field_number++;
}
}
}
- return 1;
+ return true;
}
/* See rust-lang.h. */
-int
+bool
rust_tuple_struct_type_p (struct type *type)
{
/* This is just an approximation until DWARF can represent Rust more
/* Return true if a variant TYPE is a tuple variant, false otherwise. */
-static int
+static bool
rust_tuple_variant_type_p (struct type *type)
{
/* First field is discriminant */
/* Return true if TYPE is a slice type, otherwise false. */
-static int
+static bool
rust_slice_type_p (struct type *type)
{
return (TYPE_CODE (type) == TYPE_CODE_STRUCT
&& TYPE_TAG_NAME (type) != NULL
- && strncmp (TYPE_TAG_NAME (type), "&[", 2) == 0);
+ && (strncmp (TYPE_TAG_NAME (type), "&[", 2) == 0
+ || strcmp (TYPE_TAG_NAME (type), "&str") == 0));
}
/* Return true if TYPE is a range type, otherwise false. */
-static int
+static bool
rust_range_type_p (struct type *type)
{
int i;
|| TYPE_NFIELDS (type) > 2
|| TYPE_TAG_NAME (type) == NULL
|| strstr (TYPE_TAG_NAME (type), "::Range") == NULL)
- return 0;
+ return false;
if (TYPE_NFIELDS (type) == 0)
- return 1;
+ return true;
i = 0;
if (strcmp (TYPE_FIELD_NAME (type, 0), "start") == 0)
{
if (TYPE_NFIELDS (type) == 1)
- return 1;
+ return true;
i = 1;
}
else if (TYPE_NFIELDS (type) == 2)
{
/* First field had to be "start". */
- return 0;
+ return false;
}
return strcmp (TYPE_FIELD_NAME (type, i), "end") == 0;
/* Return true if TYPE seems to be the type "u8", otherwise false. */
-static int
+static bool
rust_u8_type_p (struct type *type)
{
return (TYPE_CODE (type) == TYPE_CODE_INT
/* Return true if TYPE is a Rust character type. */
-static int
+static bool
rust_chartype_p (struct type *type)
{
return (TYPE_CODE (type) == TYPE_CODE_CHAR
&& TYPE_UNSIGNED (type));
}
+/* If VALUE represents a trait object pointer, return the underlying
+ pointer with the correct (i.e., runtime) type. Otherwise, return
+ NULL. */
+
+static struct value *
+rust_get_trait_object_pointer (struct value *value)
+{
+ struct type *type = check_typedef (value_type (value));
+
+ if (TYPE_CODE (type) != TYPE_CODE_STRUCT || TYPE_NFIELDS (type) != 2)
+ return NULL;
+
+ /* Try to be a bit resilient if the ABI changes. */
+ int vtable_field = 0;
+ for (int i = 0; i < 2; ++i)
+ {
+ if (strcmp (TYPE_FIELD_NAME (type, i), "vtable") == 0)
+ vtable_field = i;
+ else if (strcmp (TYPE_FIELD_NAME (type, i), "pointer") != 0)
+ return NULL;
+ }
+
+ CORE_ADDR vtable = value_as_address (value_field (value, vtable_field));
+ struct symbol *symbol = find_symbol_at_address (vtable);
+ if (symbol == NULL || symbol->subclass != SYMBOL_RUST_VTABLE)
+ return NULL;
+
+ struct rust_vtable_symbol *vtable_sym
+ = static_cast<struct rust_vtable_symbol *> (symbol);
+ struct type *pointer_type = lookup_pointer_type (vtable_sym->concrete_type);
+ return value_cast (pointer_type, value_field (value, 1 - vtable_field));
+}
+
\f
/* la_emitchar implementation for Rust. */
\f
+/* Helper function to print a string slice. */
+
+static void
+rust_val_print_str (struct ui_file *stream, struct value *val,
+ const struct value_print_options *options)
+{
+ struct value *base = value_struct_elt (&val, NULL, "data_ptr", NULL,
+ "slice");
+ struct value *len = value_struct_elt (&val, NULL, "length", NULL, "slice");
+
+ val_print_string (TYPE_TARGET_TYPE (value_type (base)), "UTF-8",
+ value_as_address (base), value_as_long (len), stream,
+ options);
+}
+
/* rust_print_type branch for structs and untagged unions. */
static void
{
int i;
int first_field;
- int is_tuple = rust_tuple_type_p (type);
- int is_tuple_struct = !is_tuple && rust_tuple_struct_type_p (type);
+
+ if (rust_slice_type_p (type) && strcmp (TYPE_NAME (type), "&str") == 0)
+ {
+ rust_val_print_str (stream, val, options);
+ return;
+ }
+
+ bool is_tuple = rust_tuple_type_p (type);
+ bool is_tuple_struct = !is_tuple && rust_tuple_struct_type_p (type);
struct value_print_options opts;
if (!is_tuple)
if (options->prettyformat)
{
- fputs_filtered ("\n", stream);
- print_spaces_filtered (2 + 2 * recurse, stream);
+ fputs_filtered ("\n", stream);
+ print_spaces_filtered (2 + 2 * recurse, stream);
}
else if (!first_field)
fputs_filtered (" ", stream);
if (!is_tuple && !is_tuple_struct)
{
- fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
- fputs_filtered (": ", stream);
+ fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
+ fputs_filtered (": ", stream);
}
val_print (TYPE_FIELD_TYPE (type, i),
- embedded_offset + TYPE_FIELD_BITPOS (type, i) / 8,
- address,
- stream, recurse + 1, val, &opts,
- current_language);
+ embedded_offset + TYPE_FIELD_BITPOS (type, i) / 8,
+ address,
+ stream, recurse + 1, val, &opts,
+ current_language);
}
if (options->prettyformat)
struct disr_info disr;
struct value_print_options opts;
- /* Untagged unions are printed as if they are structs.
- Since the field bit positions overlap in the debuginfo,
- the code for printing a union is same as that for a struct,
- the only difference is that the input type will have overlapping
- fields. */
- if (rust_union_is_untagged (type))
- {
- val_print_struct (type, embedded_offset, address, stream,
- recurse, val, options);
- break;
- }
+ /* Untagged unions are printed as if they are structs.
+ Since the field bit positions overlap in the debuginfo,
+ the code for printing a union is same as that for a struct,
+ the only difference is that the input type will have overlapping
+ fields. */
+ if (rust_union_is_untagged (type))
+ {
+ val_print_struct (type, embedded_offset, address, stream,
+ recurse, val, options);
+ break;
+ }
opts = *options;
opts.deref_ref = 0;
/* Print a struct or union typedef. */
static void
rust_print_struct_def (struct type *type, const char *varstring,
- struct ui_file *stream, int show, int level,
- const struct type_print_options *flags)
+ struct ui_file *stream, int show, int level,
+ const struct type_print_options *flags)
{
- int is_tuple_struct, i;
+ bool is_tuple_struct;
+ int i;
- /* Print a tuple type simply. */
- if (rust_tuple_type_p (type))
- {
- fputs_filtered (TYPE_TAG_NAME (type), stream);
- return;
- }
+ /* Print a tuple type simply. */
+ if (rust_tuple_type_p (type))
+ {
+ fputs_filtered (TYPE_TAG_NAME (type), 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);
+ /* If we see a base class, delegate to C. */
+ if (TYPE_N_BASECLASSES (type) > 0)
+ c_print_type (type, varstring, stream, show, level, flags);
/* This code path is also used by unions. */
if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
- fputs_filtered ("struct ", stream);
+ fputs_filtered ("struct ", stream);
else
- fputs_filtered ("union ", stream);
+ fputs_filtered ("union ", stream);
- if (TYPE_TAG_NAME (type) != NULL)
- fputs_filtered (TYPE_TAG_NAME (type), stream);
-
- is_tuple_struct = rust_tuple_struct_type_p (type);
+ if (TYPE_TAG_NAME (type) != NULL)
+ fputs_filtered (TYPE_TAG_NAME (type), stream);
- if (TYPE_NFIELDS (type) == 0 && !rust_tuple_type_p (type))
- return;
- fputs_filtered (is_tuple_struct ? " (\n" : " {\n", stream);
+ is_tuple_struct = rust_tuple_struct_type_p (type);
- for (i = 0; i < TYPE_NFIELDS (type); ++i)
- {
- const char *name;
+ if (TYPE_NFIELDS (type) == 0 && !rust_tuple_type_p (type))
+ return;
+ fputs_filtered (is_tuple_struct ? " (\n" : " {\n", stream);
- QUIT;
- if (field_is_static (&TYPE_FIELD (type, i)))
- continue;
-
- /* We'd like to print "pub" here as needed, but rustc
- doesn't emit the debuginfo, and our types don't have
- cplus_struct_type attached. */
-
- /* For a tuple struct we print the type but nothing
- else. */
- print_spaces_filtered (level + 2, stream);
- if (!is_tuple_struct)
- fprintf_filtered (stream, "%s: ", TYPE_FIELD_NAME (type, i));
-
- rust_print_type (TYPE_FIELD_TYPE (type, i), NULL,
- stream, show - 1, level + 2,
- flags);
- fputs_filtered (",\n", stream);
- }
+ for (i = 0; i < TYPE_NFIELDS (type); ++i)
+ {
+ QUIT;
+ if (field_is_static (&TYPE_FIELD (type, i)))
+ continue;
+
+ /* We'd like to print "pub" here as needed, but rustc
+ doesn't emit the debuginfo, and our types don't have
+ cplus_struct_type attached. */
+
+ /* For a tuple struct we print the type but nothing
+ else. */
+ print_spaces_filtered (level + 2, stream);
+ if (!is_tuple_struct)
+ fprintf_filtered (stream, "%s: ", TYPE_FIELD_NAME (type, i));
+
+ rust_print_type (TYPE_FIELD_TYPE (type, i), NULL,
+ stream, show - 1, level + 2,
+ flags);
+ fputs_filtered (",\n", stream);
+ }
- fprintfi_filtered (level, stream, is_tuple_struct ? ")" : "}");
+ fprintfi_filtered (level, stream, is_tuple_struct ? ")" : "}");
}
/* la_print_typedef implementation for Rust. */
fputs_filtered ("[", stream);
rust_print_type (TYPE_TARGET_TYPE (type), NULL,
stream, show - 1, level, flags);
- fputs_filtered ("; ", stream);
if (TYPE_HIGH_BOUND_KIND (TYPE_INDEX_TYPE (type)) == PROP_LOCEXPR
|| TYPE_HIGH_BOUND_KIND (TYPE_INDEX_TYPE (type)) == PROP_LOCLIST)
- fprintf_filtered (stream, "variable length");
+ fprintf_filtered (stream, "; variable length");
else if (get_array_bounds (type, &low_bound, &high_bound))
- fprintf_filtered (stream, "%s",
+ fprintf_filtered (stream, "; %s",
plongest (high_bound - low_bound + 1));
fputs_filtered ("]", stream);
}
break;
case TYPE_CODE_STRUCT:
- rust_print_struct_def (type, varstring, stream, show, level, flags);
+ rust_print_struct_def (type, varstring, stream, show, level, flags);
break;
case TYPE_CODE_ENUM:
case TYPE_CODE_UNION:
{
/* ADT enums. */
- int i, len = 0;
+ int i;
/* Skip the discriminant field. */
int skip_to = 1;
- /* Unions and structs have the same syntax in Rust,
- the only difference is that structs are declared with `struct`
- and union with `union`. This difference is handled in the struct
- printer. */
- if (rust_union_is_untagged (type))
- {
- rust_print_struct_def (type, varstring, stream, show, level, flags);
- break;
- }
+ /* Unions and structs have the same syntax in Rust,
+ the only difference is that structs are declared with `struct`
+ and union with `union`. This difference is handled in the struct
+ printer. */
+ if (rust_union_is_untagged (type))
+ {
+ rust_print_struct_def (type, varstring, stream, show, level, flags);
+ break;
+ }
fputs_filtered ("enum ", stream);
if (TYPE_TAG_NAME (type) != NULL)
skip_to = 0;
}
}
+ else if (TYPE_NFIELDS (type) == 1)
+ skip_to = 0;
for (i = 0; i < TYPE_NFIELDS (type); ++i)
{
if (TYPE_NFIELDS (variant_type) > skip_to)
{
int first = 1;
- int is_tuple = rust_tuple_variant_type_p (variant_type);
+ bool is_tuple = (TYPE_NFIELDS (type) == 1
+ ? rust_tuple_struct_type_p (variant_type)
+ : rust_tuple_variant_type_p (variant_type));
int j;
fputs_filtered (is_tuple ? "(" : "{", stream);
if (noside == EVAL_AVOID_SIDE_EFFECTS)
result = value_zero (TYPE_TARGET_TYPE (fn_type), not_lval);
else
- result = call_function_by_hand (function, num_args + 1, args.data ());
+ result = call_function_by_hand (function, NULL, num_args + 1, args.data ());
return result;
}
else
low = value_as_long (rhs);
+ struct type *type = check_typedef (value_type (lhs));
if (noside == EVAL_AVOID_SIDE_EFFECTS)
{
- struct type *type = check_typedef (value_type (lhs));
+ struct type *base_type = nullptr;
+ if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
+ base_type = TYPE_TARGET_TYPE (type);
+ else if (rust_slice_type_p (type))
+ {
+ for (int i = 0; i < TYPE_NFIELDS (type); ++i)
+ {
+ if (strcmp (TYPE_FIELD_NAME (type, i), "data_ptr") == 0)
+ {
+ base_type = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type, i));
+ break;
+ }
+ }
+ if (base_type == nullptr)
+ error (_("Could not find 'data_ptr' in slice type"));
+ }
+ else if (TYPE_CODE (type) == TYPE_CODE_PTR)
+ base_type = TYPE_TARGET_TYPE (type);
+ else
+ error (_("Cannot subscript non-array type"));
+
+ struct type *new_type;
+ if (want_slice)
+ {
+ if (rust_slice_type_p (type))
+ new_type = type;
+ else
+ {
+ struct type *usize
+ = language_lookup_primitive_type (exp->language_defn,
+ exp->gdbarch,
+ "usize");
+ new_type = rust_slice_type ("&[*gdb*]", base_type, usize);
+ }
+ }
+ else
+ new_type = base_type;
- result = value_zero (TYPE_TARGET_TYPE (type), VALUE_LVAL (lhs));
+ return value_zero (new_type, VALUE_LVAL (lhs));
}
else
{
LONGEST low_bound;
struct value *base;
- struct type *type = check_typedef (value_type (lhs));
if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
{
usize = language_lookup_primitive_type (exp->language_defn,
exp->gdbarch,
"usize");
- slice = rust_slice_type ("&[*gdb*]", value_type (result),
- usize);
+ const char *new_name = ((type != nullptr
+ && rust_slice_type_p (type))
+ ? TYPE_NAME (type) : "&[*gdb*]");
+
+ slice = rust_slice_type (new_name, value_type (result), usize);
addrval = value_allocate_space_in_inferior (TYPE_LENGTH (slice));
addr = value_as_long (addrval);
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;
if (noside == EVAL_NORMAL)
{
- CORE_ADDR addr;
int i;
std::vector<struct value *> eltvec (copies);
case STRUCTOP_STRUCT:
{
- struct value* lhs;
+ struct value *lhs;
struct type *type;
int tem, pc;
(*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
lhs = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+ const char *field_name = &exp->elts[pc + 2].string;
type = value_type (lhs);
if (TYPE_CODE (type) == TYPE_CODE_UNION
&& !rust_union_is_untagged (type))
{
int i, start;
struct disr_info disr;
- struct type* variant_type;
- char* field_name;
-
- field_name = &exp->elts[pc + 2].string;
+ struct type *variant_type;
disr = rust_get_disr_info (type, value_contents (lhs),
value_embedded_offset (lhs),
}
else
{
- /* Field access in structs and untagged unions works like C. */
- *pos = pc;
- result = evaluate_subexp_standard (expect_type, exp, pos, noside);
+ 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;
/* op_name implementation for Rust. */
-static char *
+static const char *
rust_op_name (enum exp_opcode opcode)
{
switch (opcode)
{
int field_number;
- field_number = longest_to_int (exp->elts[elt].longconst);
+ field_number = longest_to_int (exp->elts[elt + 1].longconst);
fprintf_filtered (stream, "Field number: %d", field_number);
- elt = dump_subexp (exp, stream, elt + 2);
+ elt = dump_subexp (exp, stream, elt + 3);
}
break;
case OP_RUST_ARRAY:
+ ++elt;
break;
default:
print_subexp (exp, pos, stream, PREC_SUFFIX);
fprintf_filtered (stream, ".%d", tem);
}
- return;
+ break;
case OP_RUST_ARRAY:
++*pos;
\f
+/* la_watch_location_expression for Rust. */
+
+static gdb::unique_xmalloc_ptr<char>
+rust_watch_location_expression (struct type *type, CORE_ADDR addr)
+{
+ 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 ()));
+}
+
+\f
+
static const struct exp_descriptor exp_descriptor_rust =
{
rust_print_subexp,
".rs", NULL
};
-static const struct language_defn rust_language_defn =
+extern const struct language_defn rust_language_defn =
{
"rust",
"Rust",
1, /* c-style arrays */
0, /* String lower bound */
default_word_break_characters,
- default_make_symbol_completion_list,
+ default_collect_symbol_completion_matches,
rust_language_arch_info,
default_print_array_index,
default_pass_by_reference,
c_get_string,
- NULL, /* la_get_symbol_name_cmp */
+ rust_watch_location_expression,
+ NULL, /* la_get_symbol_name_matcher */
iterate_over_symbols,
+ default_search_name_hash,
&default_varobj_ops,
NULL,
NULL,
LANG_MAGIC
};
-
-void
-_initialize_rust_language (void)
-{
- add_language (&rust_language_defn);
-}
projects / deliverable / binutils-gdb.git / blobdiff