1 /* Rust language support routines for GDB, the GNU debugger.
3 Copyright (C) 2016-2018 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
27 #include "cp-support.h"
33 #include "rust-lang.h"
34 #include "typeprint.h"
41 /* See rust-lang.h. */
44 rust_last_path_segment (const char *path)
46 const char *result = strrchr (path, ':');
53 /* See rust-lang.h. */
56 rust_crate_for_block (const struct block *block)
58 const char *scope = block_scope (block);
61 return std::string ();
63 return std::string (scope, cp_find_first_component (scope));
66 /* Return true if TYPE, which must be a struct type, represents a Rust
70 rust_enum_p (const struct type *type)
72 return (TYPE_CODE (type) == TYPE_CODE_STRUCT
73 && TYPE_NFIELDS (type) == 1
74 && TYPE_FLAG_DISCRIMINATED_UNION (TYPE_FIELD_TYPE (type, 0)));
77 /* Return true if TYPE, which must be an enum type, has no
81 rust_empty_enum_p (const struct type *type)
83 gdb_assert (rust_enum_p (type));
84 /* In Rust the enum always fills the containing structure. */
85 gdb_assert (TYPE_FIELD_BITPOS (type, 0) == 0);
87 return TYPE_NFIELDS (TYPE_FIELD_TYPE (type, 0)) == 0;
90 /* Given an enum type and contents, find which variant is active. */
93 rust_enum_variant (struct type *type, const gdb_byte *contents)
95 /* In Rust the enum always fills the containing structure. */
96 gdb_assert (TYPE_FIELD_BITPOS (type, 0) == 0);
98 struct type *union_type = TYPE_FIELD_TYPE (type, 0);
100 int fieldno = value_union_variant (union_type, contents);
101 return &TYPE_FIELD (union_type, fieldno);
104 /* See rust-lang.h. */
107 rust_tuple_type_p (struct type *type)
109 /* The current implementation is a bit of a hack, but there's
110 nothing else in the debuginfo to distinguish a tuple from a
112 return (TYPE_CODE (type) == TYPE_CODE_STRUCT
113 && TYPE_NAME (type) != NULL
114 && TYPE_NAME (type)[0] == '(');
117 /* Return true if all non-static fields of a structlike type are in a
118 sequence like __0, __1, __2. */
121 rust_underscore_fields (struct type *type)
127 if (TYPE_CODE (type) != TYPE_CODE_STRUCT)
129 for (i = 0; i < TYPE_NFIELDS (type); ++i)
131 if (!field_is_static (&TYPE_FIELD (type, i)))
135 xsnprintf (buf, sizeof (buf), "__%d", field_number);
136 if (strcmp (buf, TYPE_FIELD_NAME (type, i)) != 0)
144 /* See rust-lang.h. */
147 rust_tuple_struct_type_p (struct type *type)
149 /* This is just an approximation until DWARF can represent Rust more
150 precisely. We exclude zero-length structs because they may not
151 be tuple structs, and there's no way to tell. */
152 return TYPE_NFIELDS (type) > 0 && rust_underscore_fields (type);
155 /* Return true if TYPE is a slice type, otherwise false. */
158 rust_slice_type_p (struct type *type)
160 return (TYPE_CODE (type) == TYPE_CODE_STRUCT
161 && TYPE_NAME (type) != NULL
162 && (strncmp (TYPE_NAME (type), "&[", 2) == 0
163 || strcmp (TYPE_NAME (type), "&str") == 0));
166 /* Return true if TYPE is a range type, otherwise false. */
169 rust_range_type_p (struct type *type)
173 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
174 || TYPE_NFIELDS (type) > 2
175 || TYPE_NAME (type) == NULL
176 || strstr (TYPE_NAME (type), "::Range") == NULL)
179 if (TYPE_NFIELDS (type) == 0)
183 if (strcmp (TYPE_FIELD_NAME (type, 0), "start") == 0)
185 if (TYPE_NFIELDS (type) == 1)
189 else if (TYPE_NFIELDS (type) == 2)
191 /* First field had to be "start". */
195 return strcmp (TYPE_FIELD_NAME (type, i), "end") == 0;
198 /* Return true if TYPE is an inclusive range type, otherwise false.
199 This is only valid for types which are already known to be range
203 rust_inclusive_range_type_p (struct type *type)
205 return (strstr (TYPE_NAME (type), "::RangeInclusive") != NULL
206 || strstr (TYPE_NAME (type), "::RangeToInclusive") != NULL);
209 /* Return true if TYPE seems to be the type "u8", otherwise false. */
212 rust_u8_type_p (struct type *type)
214 return (TYPE_CODE (type) == TYPE_CODE_INT
215 && TYPE_UNSIGNED (type)
216 && TYPE_LENGTH (type) == 1);
219 /* Return true if TYPE is a Rust character type. */
222 rust_chartype_p (struct type *type)
224 return (TYPE_CODE (type) == TYPE_CODE_CHAR
225 && TYPE_LENGTH (type) == 4
226 && TYPE_UNSIGNED (type));
229 /* If VALUE represents a trait object pointer, return the underlying
230 pointer with the correct (i.e., runtime) type. Otherwise, return
233 static struct value *
234 rust_get_trait_object_pointer (struct value *value)
236 struct type *type = check_typedef (value_type (value));
238 if (TYPE_CODE (type) != TYPE_CODE_STRUCT || TYPE_NFIELDS (type) != 2)
241 /* Try to be a bit resilient if the ABI changes. */
242 int vtable_field = 0;
243 for (int i = 0; i < 2; ++i)
245 if (strcmp (TYPE_FIELD_NAME (type, i), "vtable") == 0)
247 else if (strcmp (TYPE_FIELD_NAME (type, i), "pointer") != 0)
251 CORE_ADDR vtable = value_as_address (value_field (value, vtable_field));
252 struct symbol *symbol = find_symbol_at_address (vtable);
253 if (symbol == NULL || symbol->subclass != SYMBOL_RUST_VTABLE)
256 struct rust_vtable_symbol *vtable_sym
257 = static_cast<struct rust_vtable_symbol *> (symbol);
258 struct type *pointer_type = lookup_pointer_type (vtable_sym->concrete_type);
259 return value_cast (pointer_type, value_field (value, 1 - vtable_field));
264 /* la_emitchar implementation for Rust. */
267 rust_emitchar (int c, struct type *type, struct ui_file *stream, int quoter)
269 if (!rust_chartype_p (type))
270 generic_emit_char (c, type, stream, quoter,
271 target_charset (get_type_arch (type)));
272 else if (c == '\\' || c == quoter)
273 fprintf_filtered (stream, "\\%c", c);
275 fputs_filtered ("\\n", stream);
277 fputs_filtered ("\\r", stream);
279 fputs_filtered ("\\t", stream);
281 fputs_filtered ("\\0", stream);
282 else if (c >= 32 && c <= 127 && isprint (c))
283 fputc_filtered (c, stream);
285 fprintf_filtered (stream, "\\x%02x", c);
287 fprintf_filtered (stream, "\\u{%06x}", c);
290 /* la_printchar implementation for Rust. */
293 rust_printchar (int c, struct type *type, struct ui_file *stream)
295 fputs_filtered ("'", stream);
296 LA_EMIT_CHAR (c, type, stream, '\'');
297 fputs_filtered ("'", stream);
300 /* la_printstr implementation for Rust. */
303 rust_printstr (struct ui_file *stream, struct type *type,
304 const gdb_byte *string, unsigned int length,
305 const char *user_encoding, int force_ellipses,
306 const struct value_print_options *options)
308 /* Rust always uses UTF-8, but let the caller override this if need
310 const char *encoding = user_encoding;
311 if (user_encoding == NULL || !*user_encoding)
313 /* In Rust strings, characters are "u8". */
314 if (rust_u8_type_p (type))
318 /* This is probably some C string, so let's let C deal with
320 c_printstr (stream, type, string, length, user_encoding,
321 force_ellipses, options);
326 /* This is not ideal as it doesn't use our character printer. */
327 generic_printstr (stream, type, string, length, encoding, force_ellipses,
333 /* Helper function to print a string slice. */
336 rust_val_print_str (struct ui_file *stream, struct value *val,
337 const struct value_print_options *options)
339 struct value *base = value_struct_elt (&val, NULL, "data_ptr", NULL,
341 struct value *len = value_struct_elt (&val, NULL, "length", NULL, "slice");
343 val_print_string (TYPE_TARGET_TYPE (value_type (base)), "UTF-8",
344 value_as_address (base), value_as_long (len), stream,
348 /* rust_val_print helper for structs and untagged unions. */
351 val_print_struct (struct type *type, int embedded_offset,
352 CORE_ADDR address, struct ui_file *stream,
353 int recurse, struct value *val,
354 const struct value_print_options *options)
359 if (rust_slice_type_p (type) && strcmp (TYPE_NAME (type), "&str") == 0)
361 rust_val_print_str (stream, val, options);
365 bool is_tuple = rust_tuple_type_p (type);
366 bool is_tuple_struct = !is_tuple && rust_tuple_struct_type_p (type);
367 struct value_print_options opts;
371 if (TYPE_NAME (type) != NULL)
372 fprintf_filtered (stream, "%s", TYPE_NAME (type));
374 if (TYPE_NFIELDS (type) == 0)
377 if (TYPE_NAME (type) != NULL)
378 fputs_filtered (" ", stream);
381 if (is_tuple || is_tuple_struct)
382 fputs_filtered ("(", stream);
384 fputs_filtered ("{", stream);
390 for (i = 0; i < TYPE_NFIELDS (type); ++i)
392 if (field_is_static (&TYPE_FIELD (type, i)))
396 fputs_filtered (",", stream);
398 if (options->prettyformat)
400 fputs_filtered ("\n", stream);
401 print_spaces_filtered (2 + 2 * recurse, stream);
403 else if (!first_field)
404 fputs_filtered (" ", stream);
408 if (!is_tuple && !is_tuple_struct)
410 fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
411 fputs_filtered (": ", stream);
414 val_print (TYPE_FIELD_TYPE (type, i),
415 embedded_offset + TYPE_FIELD_BITPOS (type, i) / 8,
417 stream, recurse + 1, val, &opts,
421 if (options->prettyformat)
423 fputs_filtered ("\n", stream);
424 print_spaces_filtered (2 * recurse, stream);
427 if (is_tuple || is_tuple_struct)
428 fputs_filtered (")", stream);
430 fputs_filtered ("}", stream);
433 /* rust_val_print helper for discriminated unions (Rust enums). */
436 rust_print_enum (struct type *type, int embedded_offset,
437 CORE_ADDR address, struct ui_file *stream,
438 int recurse, struct value *val,
439 const struct value_print_options *options)
441 struct value_print_options opts = *options;
445 if (rust_empty_enum_p (type))
447 /* Print the enum type name here to be more clear. */
448 fprintf_filtered (stream, _("%s {<No data fields>}"), TYPE_NAME (type));
452 const gdb_byte *valaddr = value_contents_for_printing (val);
453 struct field *variant_field = rust_enum_variant (type, valaddr);
454 embedded_offset += FIELD_BITPOS (*variant_field) / 8;
455 struct type *variant_type = FIELD_TYPE (*variant_field);
457 int nfields = TYPE_NFIELDS (variant_type);
459 bool is_tuple = rust_tuple_struct_type_p (variant_type);
461 fprintf_filtered (stream, "%s", TYPE_NAME (variant_type));
464 /* In case of a nullary variant like 'None', just output
469 /* In case of a non-nullary variant, we output 'Foo(x,y,z)'. */
471 fprintf_filtered (stream, "(");
474 /* struct variant. */
475 fprintf_filtered (stream, "{");
478 bool first_field = true;
479 for (int j = 0; j < TYPE_NFIELDS (variant_type); j++)
482 fputs_filtered (", ", stream);
486 fprintf_filtered (stream, "%s: ",
487 TYPE_FIELD_NAME (variant_type, j));
489 val_print (TYPE_FIELD_TYPE (variant_type, j),
491 + TYPE_FIELD_BITPOS (variant_type, j) / 8),
493 stream, recurse + 1, val, &opts,
498 fputs_filtered (")", stream);
500 fputs_filtered ("}", stream);
503 static const struct generic_val_print_decorations rust_decorations =
505 /* Complex isn't used in Rust, but we provide C-ish values just in
517 /* la_val_print implementation for Rust. */
520 rust_val_print (struct type *type, int embedded_offset,
521 CORE_ADDR address, struct ui_file *stream, int recurse,
523 const struct value_print_options *options)
525 const gdb_byte *valaddr = value_contents_for_printing (val);
527 type = check_typedef (type);
528 switch (TYPE_CODE (type))
532 LONGEST low_bound, high_bound;
534 if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_ARRAY
535 && rust_u8_type_p (TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (type)))
536 && get_array_bounds (TYPE_TARGET_TYPE (type), &low_bound,
538 /* We have a pointer to a byte string, so just print
540 struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));
542 struct gdbarch *arch = get_type_arch (type);
543 int unit_size = gdbarch_addressable_memory_unit_size (arch);
545 addr = unpack_pointer (type, valaddr + embedded_offset * unit_size);
546 if (options->addressprint)
548 fputs_filtered (paddress (arch, addr), stream);
549 fputs_filtered (" ", stream);
552 fputs_filtered ("b", stream);
553 val_print_string (TYPE_TARGET_TYPE (elttype), "ASCII", addr,
554 high_bound - low_bound + 1, stream,
561 case TYPE_CODE_METHODPTR:
562 case TYPE_CODE_MEMBERPTR:
563 c_val_print (type, embedded_offset, address, stream,
564 recurse, val, options);
568 /* Recognize the unit type. */
569 if (TYPE_UNSIGNED (type) && TYPE_LENGTH (type) == 0
570 && TYPE_NAME (type) != NULL && strcmp (TYPE_NAME (type), "()") == 0)
572 fputs_filtered ("()", stream);
577 case TYPE_CODE_STRING:
579 struct gdbarch *arch = get_type_arch (type);
580 int unit_size = gdbarch_addressable_memory_unit_size (arch);
581 LONGEST low_bound, high_bound;
583 if (!get_array_bounds (type, &low_bound, &high_bound))
584 error (_("Could not determine the array bounds"));
586 /* If we see a plain TYPE_CODE_STRING, then we're printing a
587 byte string, hence the choice of "ASCII" as the
589 fputs_filtered ("b", stream);
590 rust_printstr (stream, TYPE_TARGET_TYPE (type),
591 valaddr + embedded_offset * unit_size,
592 high_bound - low_bound + 1, "ASCII", 0, options);
596 case TYPE_CODE_ARRAY:
598 LONGEST low_bound, high_bound;
600 if (get_array_bounds (type, &low_bound, &high_bound)
601 && high_bound - low_bound + 1 == 0)
602 fputs_filtered ("[]", stream);
608 case TYPE_CODE_UNION:
609 /* Untagged unions are printed as if they are structs. Since
610 the field bit positions overlap in the debuginfo, the code
611 for printing a union is same as that for a struct, the only
612 difference is that the input type will have overlapping
614 val_print_struct (type, embedded_offset, address, stream,
615 recurse, val, options);
618 case TYPE_CODE_STRUCT:
619 if (rust_enum_p (type))
620 rust_print_enum (type, embedded_offset, address, stream,
621 recurse, val, options);
623 val_print_struct (type, embedded_offset, address, stream,
624 recurse, val, options);
629 /* Nothing special yet. */
630 generic_val_print (type, embedded_offset, address, stream,
631 recurse, val, options, &rust_decorations);
638 rust_internal_print_type (struct type *type, const char *varstring,
639 struct ui_file *stream, int show, int level,
640 const struct type_print_options *flags,
641 bool for_rust_enum, print_offset_data *podata);
643 /* Print a struct or union typedef. */
645 rust_print_struct_def (struct type *type, const char *varstring,
646 struct ui_file *stream, int show, int level,
647 const struct type_print_options *flags,
648 bool for_rust_enum, print_offset_data *podata)
650 /* Print a tuple type simply. */
651 if (rust_tuple_type_p (type))
653 fputs_filtered (TYPE_NAME (type), stream);
657 /* If we see a base class, delegate to C. */
658 if (TYPE_N_BASECLASSES (type) > 0)
659 c_print_type (type, varstring, stream, show, level, flags);
661 if (flags->print_offsets)
663 /* Temporarily bump the level so that the output lines up
668 /* Compute properties of TYPE here because, in the enum case, the
669 rest of the code ends up looking only at the variant part. */
670 const char *tagname = TYPE_NAME (type);
671 bool is_tuple_struct = rust_tuple_struct_type_p (type);
672 bool is_tuple = rust_tuple_type_p (type);
673 bool is_enum = rust_enum_p (type);
675 int enum_discriminant_index = -1;
679 /* Already printing an outer enum, so nothing to print here. */
683 /* This code path is also used by unions and enums. */
686 fputs_filtered ("enum ", stream);
688 if (rust_empty_enum_p (type))
692 fputs_filtered (tagname, stream);
693 fputs_filtered (" ", stream);
695 fputs_filtered ("{}", stream);
699 type = TYPE_FIELD_TYPE (type, 0);
701 struct dynamic_prop *discriminant_prop
702 = get_dyn_prop (DYN_PROP_DISCRIMINATED, type);
703 struct discriminant_info *info
704 = (struct discriminant_info *) discriminant_prop->data.baton;
705 enum_discriminant_index = info->discriminant_index;
707 else if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
708 fputs_filtered ("struct ", stream);
710 fputs_filtered ("union ", stream);
713 fputs_filtered (tagname, stream);
716 if (TYPE_NFIELDS (type) == 0 && !is_tuple)
718 if (for_rust_enum && !flags->print_offsets)
719 fputs_filtered (is_tuple_struct ? "(" : "{", stream);
721 fputs_filtered (is_tuple_struct ? " (\n" : " {\n", stream);
723 /* When printing offsets, we rearrange the fields into storage
724 order. This lets us show holes more clearly. We work using
725 field indices here because it simplifies calls to
726 print_offset_data::update below. */
727 std::vector<int> fields;
728 for (int i = 0; i < TYPE_NFIELDS (type); ++i)
730 if (field_is_static (&TYPE_FIELD (type, i)))
732 if (is_enum && i == enum_discriminant_index)
734 fields.push_back (i);
736 if (flags->print_offsets)
737 std::sort (fields.begin (), fields.end (),
740 return (TYPE_FIELD_BITPOS (type, a)
741 < TYPE_FIELD_BITPOS (type, b));
748 gdb_assert (!field_is_static (&TYPE_FIELD (type, i)));
749 gdb_assert (! (is_enum && i == enum_discriminant_index));
751 if (flags->print_offsets)
752 podata->update (type, i, stream);
754 /* We'd like to print "pub" here as needed, but rustc
755 doesn't emit the debuginfo, and our types don't have
756 cplus_struct_type attached. */
758 /* For a tuple struct we print the type but nothing
760 if (!for_rust_enum || flags->print_offsets)
761 print_spaces_filtered (level + 2, stream);
763 fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
764 else if (!is_tuple_struct)
765 fprintf_filtered (stream, "%s: ", TYPE_FIELD_NAME (type, i));
767 rust_internal_print_type (TYPE_FIELD_TYPE (type, i), NULL,
768 stream, (is_enum ? show : show - 1),
769 level + 2, flags, is_enum, podata);
770 if (!for_rust_enum || flags->print_offsets)
771 fputs_filtered (",\n", stream);
772 /* Note that this check of "I" is ok because we only sorted the
773 fields by offset when print_offsets was set, so we won't take
774 this branch in that case. */
775 else if (i + 1 < TYPE_NFIELDS (type))
776 fputs_filtered (", ", stream);
779 if (flags->print_offsets)
781 /* Undo the temporary level increase we did above. */
783 podata->finish (type, level, stream);
784 print_spaces_filtered (print_offset_data::indentation, stream);
786 print_spaces_filtered (2, stream);
788 if (!for_rust_enum || flags->print_offsets)
789 print_spaces_filtered (level, stream);
790 fputs_filtered (is_tuple_struct ? ")" : "}", stream);
793 /* la_print_typedef implementation for Rust. */
796 rust_print_typedef (struct type *type,
797 struct symbol *new_symbol,
798 struct ui_file *stream)
800 type = check_typedef (type);
801 fprintf_filtered (stream, "type %s = ", SYMBOL_PRINT_NAME (new_symbol));
802 type_print (type, "", stream, 0);
803 fprintf_filtered (stream, ";\n");
806 /* la_print_type implementation for Rust. */
809 rust_internal_print_type (struct type *type, const char *varstring,
810 struct ui_file *stream, int show, int level,
811 const struct type_print_options *flags,
812 bool for_rust_enum, print_offset_data *podata)
818 && TYPE_NAME (type) != NULL)
820 /* Rust calls the unit type "void" in its debuginfo,
821 but we don't want to print it as that. */
822 if (TYPE_CODE (type) == TYPE_CODE_VOID)
823 fputs_filtered ("()", stream);
825 fputs_filtered (TYPE_NAME (type), stream);
829 type = check_typedef (type);
830 switch (TYPE_CODE (type))
833 /* If we have an enum, we've already printed the type's
834 unqualified name, and there is nothing else to print
837 fputs_filtered ("()", stream);
841 /* Delegate varargs to the C printer. */
842 if (TYPE_VARARGS (type))
845 fputs_filtered ("fn ", stream);
846 if (varstring != NULL)
847 fputs_filtered (varstring, stream);
848 fputs_filtered ("(", stream);
849 for (i = 0; i < TYPE_NFIELDS (type); ++i)
853 fputs_filtered (", ", stream);
854 rust_internal_print_type (TYPE_FIELD_TYPE (type, i), "", stream,
855 -1, 0, flags, false, podata);
857 fputs_filtered (")", stream);
858 /* If it returns unit, we can omit the return type. */
859 if (TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_VOID)
861 fputs_filtered (" -> ", stream);
862 rust_internal_print_type (TYPE_TARGET_TYPE (type), "", stream,
863 -1, 0, flags, false, podata);
867 case TYPE_CODE_ARRAY:
869 LONGEST low_bound, high_bound;
871 fputs_filtered ("[", stream);
872 rust_internal_print_type (TYPE_TARGET_TYPE (type), NULL,
873 stream, show - 1, level, flags, false,
876 if (TYPE_HIGH_BOUND_KIND (TYPE_INDEX_TYPE (type)) == PROP_LOCEXPR
877 || TYPE_HIGH_BOUND_KIND (TYPE_INDEX_TYPE (type)) == PROP_LOCLIST)
878 fprintf_filtered (stream, "; variable length");
879 else if (get_array_bounds (type, &low_bound, &high_bound))
880 fprintf_filtered (stream, "; %s",
881 plongest (high_bound - low_bound + 1));
882 fputs_filtered ("]", stream);
886 case TYPE_CODE_UNION:
887 case TYPE_CODE_STRUCT:
888 rust_print_struct_def (type, varstring, stream, show, level, flags,
889 for_rust_enum, podata);
896 fputs_filtered ("enum ", stream);
897 if (TYPE_NAME (type) != NULL)
899 fputs_filtered (TYPE_NAME (type), stream);
900 fputs_filtered (" ", stream);
901 len = strlen (TYPE_NAME (type));
903 fputs_filtered ("{\n", stream);
905 for (i = 0; i < TYPE_NFIELDS (type); ++i)
907 const char *name = TYPE_FIELD_NAME (type, i);
912 && strncmp (name, TYPE_NAME (type), len) == 0
914 && name[len + 1] == ':')
916 fprintfi_filtered (level + 2, stream, "%s,\n", name);
919 fputs_filtered ("}", stream);
925 c_print_type (type, varstring, stream, show, level, flags);
930 rust_print_type (struct type *type, const char *varstring,
931 struct ui_file *stream, int show, int level,
932 const struct type_print_options *flags)
934 print_offset_data podata;
935 rust_internal_print_type (type, varstring, stream, show, level,
936 flags, false, &podata);
941 /* Like arch_composite_type, but uses TYPE to decide how to allocate
942 -- either on an obstack or on a gdbarch. */
945 rust_composite_type (struct type *original,
947 const char *field1, struct type *type1,
948 const char *field2, struct type *type2)
950 struct type *result = alloc_type_copy (original);
951 int i, nfields, bitpos;
959 TYPE_CODE (result) = TYPE_CODE_STRUCT;
960 TYPE_NAME (result) = name;
962 TYPE_NFIELDS (result) = nfields;
964 = (struct field *) TYPE_ZALLOC (result, nfields * sizeof (struct field));
970 struct field *field = &TYPE_FIELD (result, i);
972 SET_FIELD_BITPOS (*field, bitpos);
973 bitpos += TYPE_LENGTH (type1) * TARGET_CHAR_BIT;
975 FIELD_NAME (*field) = field1;
976 FIELD_TYPE (*field) = type1;
981 struct field *field = &TYPE_FIELD (result, i);
982 unsigned align = type_align (type2);
988 align *= TARGET_CHAR_BIT;
989 delta = bitpos % align;
991 bitpos += align - delta;
993 SET_FIELD_BITPOS (*field, bitpos);
995 FIELD_NAME (*field) = field2;
996 FIELD_TYPE (*field) = type2;
1001 TYPE_LENGTH (result)
1002 = (TYPE_FIELD_BITPOS (result, i - 1) / TARGET_CHAR_BIT +
1003 TYPE_LENGTH (TYPE_FIELD_TYPE (result, i - 1)));
1007 /* See rust-lang.h. */
1010 rust_slice_type (const char *name, struct type *elt_type,
1011 struct type *usize_type)
1015 elt_type = lookup_pointer_type (elt_type);
1016 type = rust_composite_type (elt_type, name,
1017 "data_ptr", elt_type,
1018 "length", usize_type);
1023 enum rust_primitive_types
1025 rust_primitive_bool,
1026 rust_primitive_char,
1035 rust_primitive_isize,
1036 rust_primitive_usize,
1039 rust_primitive_unit,
1041 nr_rust_primitive_types
1044 /* la_language_arch_info implementation for Rust. */
1047 rust_language_arch_info (struct gdbarch *gdbarch,
1048 struct language_arch_info *lai)
1050 const struct builtin_type *builtin = builtin_type (gdbarch);
1052 struct type **types;
1053 unsigned int length;
1055 types = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_rust_primitive_types + 1,
1058 types[rust_primitive_bool] = arch_boolean_type (gdbarch, 8, 1, "bool");
1059 types[rust_primitive_char] = arch_character_type (gdbarch, 32, 1, "char");
1060 types[rust_primitive_i8] = arch_integer_type (gdbarch, 8, 0, "i8");
1061 types[rust_primitive_u8] = arch_integer_type (gdbarch, 8, 1, "u8");
1062 types[rust_primitive_i16] = arch_integer_type (gdbarch, 16, 0, "i16");
1063 types[rust_primitive_u16] = arch_integer_type (gdbarch, 16, 1, "u16");
1064 types[rust_primitive_i32] = arch_integer_type (gdbarch, 32, 0, "i32");
1065 types[rust_primitive_u32] = arch_integer_type (gdbarch, 32, 1, "u32");
1066 types[rust_primitive_i64] = arch_integer_type (gdbarch, 64, 0, "i64");
1067 types[rust_primitive_u64] = arch_integer_type (gdbarch, 64, 1, "u64");
1069 length = 8 * TYPE_LENGTH (builtin->builtin_data_ptr);
1070 types[rust_primitive_isize] = arch_integer_type (gdbarch, length, 0, "isize");
1071 types[rust_primitive_usize] = arch_integer_type (gdbarch, length, 1, "usize");
1073 types[rust_primitive_f32] = arch_float_type (gdbarch, 32, "f32",
1074 floatformats_ieee_single);
1075 types[rust_primitive_f64] = arch_float_type (gdbarch, 64, "f64",
1076 floatformats_ieee_double);
1078 types[rust_primitive_unit] = arch_integer_type (gdbarch, 0, 1, "()");
1080 tem = make_cv_type (1, 0, types[rust_primitive_u8], NULL);
1081 types[rust_primitive_str] = rust_slice_type ("&str", tem,
1082 types[rust_primitive_usize]);
1084 lai->primitive_type_vector = types;
1085 lai->bool_type_default = types[rust_primitive_bool];
1086 lai->string_char_type = types[rust_primitive_u8];
1091 /* A helper for rust_evaluate_subexp that handles OP_FUNCALL. */
1093 static struct value *
1094 rust_evaluate_funcall (struct expression *exp, int *pos, enum noside noside)
1097 int num_args = exp->elts[*pos + 1].longconst;
1099 struct value *function, *result, *arg0;
1100 struct type *type, *fn_type;
1101 const struct block *block;
1102 struct block_symbol sym;
1104 /* For an ordinary function call we can simply defer to the
1105 generic implementation. */
1106 if (exp->elts[*pos + 3].opcode != STRUCTOP_STRUCT)
1107 return evaluate_subexp_standard (NULL, exp, pos, noside);
1109 /* Skip over the OP_FUNCALL and the STRUCTOP_STRUCT. */
1111 method = &exp->elts[*pos + 1].string;
1112 *pos += 3 + BYTES_TO_EXP_ELEM (exp->elts[*pos].longconst + 1);
1114 /* Evaluate the argument to STRUCTOP_STRUCT, then find its
1115 type in order to look up the method. */
1116 arg0 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1118 if (noside == EVAL_SKIP)
1120 for (i = 0; i < num_args; ++i)
1121 evaluate_subexp (NULL_TYPE, exp, pos, noside);
1125 std::vector<struct value *> args (num_args + 1);
1128 /* We don't yet implement real Deref semantics. */
1129 while (TYPE_CODE (value_type (args[0])) == TYPE_CODE_PTR)
1130 args[0] = value_ind (args[0]);
1132 type = value_type (args[0]);
1133 if ((TYPE_CODE (type) != TYPE_CODE_STRUCT
1134 && TYPE_CODE (type) != TYPE_CODE_UNION
1135 && TYPE_CODE (type) != TYPE_CODE_ENUM)
1136 || rust_tuple_type_p (type))
1137 error (_("Method calls only supported on struct or enum types"));
1138 if (TYPE_NAME (type) == NULL)
1139 error (_("Method call on nameless type"));
1141 std::string name = std::string (TYPE_NAME (type)) + "::" + method;
1143 block = get_selected_block (0);
1144 sym = lookup_symbol (name.c_str (), block, VAR_DOMAIN, NULL);
1145 if (sym.symbol == NULL)
1146 error (_("Could not find function named '%s'"), name.c_str ());
1148 fn_type = SYMBOL_TYPE (sym.symbol);
1149 if (TYPE_NFIELDS (fn_type) == 0)
1150 error (_("Function '%s' takes no arguments"), name.c_str ());
1152 if (TYPE_CODE (TYPE_FIELD_TYPE (fn_type, 0)) == TYPE_CODE_PTR)
1153 args[0] = value_addr (args[0]);
1155 function = address_of_variable (sym.symbol, block);
1157 for (i = 0; i < num_args; ++i)
1158 args[i + 1] = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1160 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1161 result = value_zero (TYPE_TARGET_TYPE (fn_type), not_lval);
1163 result = call_function_by_hand (function, NULL, num_args + 1, args.data ());
1167 /* A helper for rust_evaluate_subexp that handles OP_RANGE. */
1169 static struct value *
1170 rust_range (struct expression *exp, int *pos, enum noside noside)
1172 enum range_type kind;
1173 struct value *low = NULL, *high = NULL;
1174 struct value *addrval, *result;
1176 struct type *range_type;
1177 struct type *index_type;
1178 struct type *temp_type;
1181 kind = (enum range_type) longest_to_int (exp->elts[*pos + 1].longconst);
1184 if (kind == HIGH_BOUND_DEFAULT || kind == NONE_BOUND_DEFAULT
1185 || kind == NONE_BOUND_DEFAULT_EXCLUSIVE)
1186 low = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1187 if (kind == LOW_BOUND_DEFAULT || kind == LOW_BOUND_DEFAULT_EXCLUSIVE
1188 || kind == NONE_BOUND_DEFAULT || kind == NONE_BOUND_DEFAULT_EXCLUSIVE)
1189 high = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1190 bool inclusive = (kind == NONE_BOUND_DEFAULT || kind == LOW_BOUND_DEFAULT);
1192 if (noside == EVAL_SKIP)
1193 return value_from_longest (builtin_type (exp->gdbarch)->builtin_int, 1);
1200 name = "std::ops::RangeFull";
1204 index_type = value_type (high);
1206 ? "std::ops::RangeToInclusive" : "std::ops::RangeTo");
1213 index_type = value_type (low);
1214 name = "std::ops::RangeFrom";
1218 if (!types_equal (value_type (low), value_type (high)))
1219 error (_("Range expression with different types"));
1220 index_type = value_type (low);
1221 name = inclusive ? "std::ops::RangeInclusive" : "std::ops::Range";
1225 /* If we don't have an index type, just allocate this on the
1226 arch. Here any type will do. */
1227 temp_type = (index_type == NULL
1228 ? language_bool_type (exp->language_defn, exp->gdbarch)
1230 /* It would be nicer to cache the range type. */
1231 range_type = rust_composite_type (temp_type, name,
1232 low == NULL ? NULL : "start", index_type,
1233 high == NULL ? NULL : "end", index_type);
1235 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1236 return value_zero (range_type, lval_memory);
1238 addrval = value_allocate_space_in_inferior (TYPE_LENGTH (range_type));
1239 addr = value_as_long (addrval);
1240 result = value_at_lazy (range_type, addr);
1244 struct value *start = value_struct_elt (&result, NULL, "start", NULL,
1247 value_assign (start, low);
1252 struct value *end = value_struct_elt (&result, NULL, "end", NULL,
1255 value_assign (end, high);
1258 result = value_at_lazy (range_type, addr);
1262 /* A helper function to compute the range and kind given a range
1263 value. TYPE is the type of the range value. RANGE is the range
1264 value. LOW, HIGH, and KIND are out parameters. The LOW and HIGH
1265 parameters might be filled in, or might not be, depending on the
1266 kind of range this is. KIND will always be set to the appropriate
1267 value describing the kind of range, and this can be used to
1268 determine whether LOW or HIGH are valid. */
1271 rust_compute_range (struct type *type, struct value *range,
1272 LONGEST *low, LONGEST *high,
1273 enum range_type *kind)
1279 *kind = BOTH_BOUND_DEFAULT;
1281 if (TYPE_NFIELDS (type) == 0)
1285 if (strcmp (TYPE_FIELD_NAME (type, 0), "start") == 0)
1287 *kind = HIGH_BOUND_DEFAULT;
1288 *low = value_as_long (value_field (range, 0));
1291 if (TYPE_NFIELDS (type) > i
1292 && strcmp (TYPE_FIELD_NAME (type, i), "end") == 0)
1294 *kind = (*kind == BOTH_BOUND_DEFAULT
1295 ? LOW_BOUND_DEFAULT : NONE_BOUND_DEFAULT);
1296 *high = value_as_long (value_field (range, i));
1298 if (rust_inclusive_range_type_p (type))
1303 /* A helper for rust_evaluate_subexp that handles BINOP_SUBSCRIPT. */
1305 static struct value *
1306 rust_subscript (struct expression *exp, int *pos, enum noside noside,
1309 struct value *lhs, *rhs, *result;
1310 struct type *rhstype;
1311 LONGEST low, high_bound;
1312 /* Initialized to appease the compiler. */
1313 enum range_type kind = BOTH_BOUND_DEFAULT;
1318 lhs = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1319 rhs = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1321 if (noside == EVAL_SKIP)
1324 rhstype = check_typedef (value_type (rhs));
1325 if (rust_range_type_p (rhstype))
1328 error (_("Can't take slice of array without '&'"));
1329 rust_compute_range (rhstype, rhs, &low, &high, &kind);
1333 low = value_as_long (rhs);
1335 struct type *type = check_typedef (value_type (lhs));
1336 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1338 struct type *base_type = nullptr;
1339 if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
1340 base_type = TYPE_TARGET_TYPE (type);
1341 else if (rust_slice_type_p (type))
1343 for (int i = 0; i < TYPE_NFIELDS (type); ++i)
1345 if (strcmp (TYPE_FIELD_NAME (type, i), "data_ptr") == 0)
1347 base_type = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type, i));
1351 if (base_type == nullptr)
1352 error (_("Could not find 'data_ptr' in slice type"));
1354 else if (TYPE_CODE (type) == TYPE_CODE_PTR)
1355 base_type = TYPE_TARGET_TYPE (type);
1357 error (_("Cannot subscript non-array type"));
1359 struct type *new_type;
1362 if (rust_slice_type_p (type))
1367 = language_lookup_primitive_type (exp->language_defn,
1370 new_type = rust_slice_type ("&[*gdb*]", base_type, usize);
1374 new_type = base_type;
1376 return value_zero (new_type, VALUE_LVAL (lhs));
1383 if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
1386 if (!get_array_bounds (type, &low_bound, &high_bound))
1387 error (_("Can't compute array bounds"));
1389 error (_("Found array with non-zero lower bound"));
1392 else if (rust_slice_type_p (type))
1396 base = value_struct_elt (&lhs, NULL, "data_ptr", NULL, "slice");
1397 len = value_struct_elt (&lhs, NULL, "length", NULL, "slice");
1399 high_bound = value_as_long (len);
1401 else if (TYPE_CODE (type) == TYPE_CODE_PTR)
1405 high_bound = LONGEST_MAX;
1408 error (_("Cannot subscript non-array type"));
1411 && (kind == BOTH_BOUND_DEFAULT || kind == LOW_BOUND_DEFAULT))
1414 error (_("Index less than zero"));
1415 if (low > high_bound)
1416 error (_("Index greater than length"));
1418 result = value_subscript (base, low);
1425 struct type *usize, *slice;
1427 struct value *addrval, *tem;
1429 if (kind == BOTH_BOUND_DEFAULT || kind == HIGH_BOUND_DEFAULT)
1432 error (_("High index less than zero"));
1434 error (_("Low index greater than high index"));
1435 if (high > high_bound)
1436 error (_("High index greater than length"));
1438 usize = language_lookup_primitive_type (exp->language_defn,
1441 const char *new_name = ((type != nullptr
1442 && rust_slice_type_p (type))
1443 ? TYPE_NAME (type) : "&[*gdb*]");
1445 slice = rust_slice_type (new_name, value_type (result), usize);
1447 addrval = value_allocate_space_in_inferior (TYPE_LENGTH (slice));
1448 addr = value_as_long (addrval);
1449 tem = value_at_lazy (slice, addr);
1451 value_assign (value_field (tem, 0), value_addr (result));
1452 value_assign (value_field (tem, 1),
1453 value_from_longest (usize, high - low));
1455 result = value_at_lazy (slice, addr);
1458 result = value_addr (result);
1464 /* evaluate_exp implementation for Rust. */
1466 static struct value *
1467 rust_evaluate_subexp (struct type *expect_type, struct expression *exp,
1468 int *pos, enum noside noside)
1470 struct value *result;
1472 switch (exp->elts[*pos].opcode)
1476 if (noside != EVAL_NORMAL)
1477 result = evaluate_subexp_standard (expect_type, exp, pos, noside);
1481 struct value *value = evaluate_subexp (expect_type, exp, pos,
1484 struct value *trait_ptr = rust_get_trait_object_pointer (value);
1485 if (trait_ptr != NULL)
1488 result = value_ind (value);
1493 case UNOP_COMPLEMENT:
1495 struct value *value;
1498 value = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1499 if (noside == EVAL_SKIP)
1501 /* Preserving the type is enough. */
1504 if (TYPE_CODE (value_type (value)) == TYPE_CODE_BOOL)
1505 result = value_from_longest (value_type (value),
1506 value_logical_not (value));
1508 result = value_complement (value);
1512 case BINOP_SUBSCRIPT:
1513 result = rust_subscript (exp, pos, noside, 0);
1517 result = rust_evaluate_funcall (exp, pos, noside);
1523 struct type *type = exp->elts[pc + 1].type;
1524 int arglen = longest_to_int (exp->elts[pc + 2].longconst);
1527 struct value *addrval = NULL;
1531 if (noside == EVAL_NORMAL)
1533 addrval = value_allocate_space_in_inferior (TYPE_LENGTH (type));
1534 addr = value_as_long (addrval);
1535 result = value_at_lazy (type, addr);
1538 if (arglen > 0 && exp->elts[*pos].opcode == OP_OTHERS)
1543 init = rust_evaluate_subexp (NULL, exp, pos, noside);
1544 if (noside == EVAL_NORMAL)
1546 /* This isn't quite right but will do for the time
1547 being, seeing that we can't implement the Copy
1549 value_assign (result, init);
1555 gdb_assert (arglen % 2 == 0);
1556 for (i = 0; i < arglen; i += 2)
1559 const char *fieldname;
1560 struct value *value, *field;
1562 gdb_assert (exp->elts[*pos].opcode == OP_NAME);
1564 len = longest_to_int (exp->elts[*pos].longconst);
1566 fieldname = &exp->elts[*pos].string;
1567 *pos += 2 + BYTES_TO_EXP_ELEM (len + 1);
1569 value = rust_evaluate_subexp (NULL, exp, pos, noside);
1570 if (noside == EVAL_NORMAL)
1572 field = value_struct_elt (&result, NULL, fieldname, NULL,
1574 value_assign (field, value);
1578 if (noside == EVAL_SKIP)
1579 return value_from_longest (builtin_type (exp->gdbarch)->builtin_int,
1581 else if (noside == EVAL_AVOID_SIDE_EFFECTS)
1582 result = allocate_value (type);
1584 result = value_at_lazy (type, addr);
1593 struct value *ncopies;
1595 elt = rust_evaluate_subexp (NULL, exp, pos, noside);
1596 ncopies = rust_evaluate_subexp (NULL, exp, pos, noside);
1597 copies = value_as_long (ncopies);
1599 error (_("Array with negative number of elements"));
1601 if (noside == EVAL_NORMAL)
1604 std::vector<struct value *> eltvec (copies);
1606 for (i = 0; i < copies; ++i)
1608 result = value_array (0, copies - 1, eltvec.data ());
1612 struct type *arraytype
1613 = lookup_array_range_type (value_type (elt), 0, copies - 1);
1614 result = allocate_value (arraytype);
1619 case STRUCTOP_ANONYMOUS:
1621 /* Anonymous field access, i.e. foo.1. */
1623 int pc, field_number, nfields;
1627 field_number = longest_to_int (exp->elts[pc + 1].longconst);
1629 lhs = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1631 type = value_type (lhs);
1633 if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
1635 struct type *outer_type = NULL;
1637 if (rust_enum_p (type))
1639 if (rust_empty_enum_p (type))
1640 error (_("Cannot access field %d of empty enum %s"),
1641 field_number, TYPE_NAME (type));
1643 const gdb_byte *valaddr = value_contents (lhs);
1644 struct field *variant_field = rust_enum_variant (type, valaddr);
1646 struct value *union_value = value_primitive_field (lhs, 0, 0,
1649 int fieldno = (variant_field
1650 - &TYPE_FIELD (value_type (union_value), 0));
1651 lhs = value_primitive_field (union_value, 0, fieldno,
1652 value_type (union_value));
1654 type = value_type (lhs);
1657 /* Tuples and tuple structs */
1658 nfields = TYPE_NFIELDS (type);
1660 if (field_number >= nfields || field_number < 0)
1662 if (outer_type != NULL)
1663 error(_("Cannot access field %d of variant %s::%s, "
1664 "there are only %d fields"),
1665 field_number, TYPE_NAME (outer_type),
1666 rust_last_path_segment (TYPE_NAME (type)),
1669 error(_("Cannot access field %d of %s, "
1670 "there are only %d fields"),
1671 field_number, TYPE_NAME (type), nfields);
1674 /* Tuples are tuple structs too. */
1675 if (!rust_tuple_struct_type_p (type))
1677 if (outer_type != NULL)
1678 error(_("Variant %s::%s is not a tuple variant"),
1679 TYPE_NAME (outer_type),
1680 rust_last_path_segment (TYPE_NAME (type)));
1682 error(_("Attempting to access anonymous field %d "
1683 "of %s, which is not a tuple, tuple struct, or "
1684 "tuple-like variant"),
1685 field_number, TYPE_NAME (type));
1688 result = value_primitive_field (lhs, 0, field_number, type);
1691 error(_("Anonymous field access is only allowed on tuples, \
1692 tuple structs, and tuple-like enum variants"));
1696 case STRUCTOP_STRUCT:
1703 tem = longest_to_int (exp->elts[pc + 1].longconst);
1704 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
1705 lhs = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1707 const char *field_name = &exp->elts[pc + 2].string;
1708 type = value_type (lhs);
1709 if (TYPE_CODE (type) == TYPE_CODE_STRUCT && rust_enum_p (type))
1711 if (rust_empty_enum_p (type))
1712 error (_("Cannot access field %s of empty enum %s"),
1713 field_name, TYPE_NAME (type));
1715 const gdb_byte *valaddr = value_contents (lhs);
1716 struct field *variant_field = rust_enum_variant (type, valaddr);
1718 struct value *union_value = value_primitive_field (lhs, 0, 0,
1721 int fieldno = (variant_field
1722 - &TYPE_FIELD (value_type (union_value), 0));
1723 lhs = value_primitive_field (union_value, 0, fieldno,
1724 value_type (union_value));
1726 struct type *outer_type = type;
1727 type = value_type (lhs);
1728 if (rust_tuple_type_p (type) || rust_tuple_struct_type_p (type))
1729 error (_("Attempting to access named field %s of tuple "
1730 "variant %s::%s, which has only anonymous fields"),
1731 field_name, TYPE_NAME (outer_type),
1732 rust_last_path_segment (TYPE_NAME (type)));
1736 result = value_struct_elt (&lhs, NULL, field_name,
1739 CATCH (except, RETURN_MASK_ERROR)
1741 error (_("Could not find field %s of struct variant %s::%s"),
1742 field_name, TYPE_NAME (outer_type),
1743 rust_last_path_segment (TYPE_NAME (type)));
1748 result = value_struct_elt (&lhs, NULL, field_name, NULL, "structure");
1749 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1750 result = value_zero (value_type (result), VALUE_LVAL (result));
1755 result = rust_range (exp, pos, noside);
1759 /* We might have &array[range], in which case we need to make a
1761 if (exp->elts[*pos + 1].opcode == BINOP_SUBSCRIPT)
1764 result = rust_subscript (exp, pos, noside, 1);
1769 result = evaluate_subexp_standard (expect_type, exp, pos, noside);
1776 /* operator_length implementation for Rust. */
1779 rust_operator_length (const struct expression *exp, int pc, int *oplenp,
1785 switch (exp->elts[pc - 1].opcode)
1788 /* We handle aggregate as a type and argument count. The first
1789 argument might be OP_OTHERS. After that the arguments
1790 alternate: first an OP_NAME, then an expression. */
1792 args = longest_to_int (exp->elts[pc - 2].longconst);
1800 case STRUCTOP_ANONYMOUS:
1811 operator_length_standard (exp, pc, oplenp, argsp);
1819 /* op_name implementation for Rust. */
1822 rust_op_name (enum exp_opcode opcode)
1827 return "OP_AGGREGATE";
1831 return op_name_standard (opcode);
1835 /* dump_subexp_body implementation for Rust. */
1838 rust_dump_subexp_body (struct expression *exp, struct ui_file *stream,
1841 switch (exp->elts[elt].opcode)
1845 int length = longest_to_int (exp->elts[elt + 2].longconst);
1848 fprintf_filtered (stream, "Type @");
1849 gdb_print_host_address (exp->elts[elt + 1].type, stream);
1850 fprintf_filtered (stream, " (");
1851 type_print (exp->elts[elt + 1].type, NULL, stream, 0);
1852 fprintf_filtered (stream, "), length %d", length);
1855 for (i = 0; i < length; ++i)
1856 elt = dump_subexp (exp, stream, elt);
1863 LONGEST len = exp->elts[elt + 1].longconst;
1865 fprintf_filtered (stream, "%s: %s",
1866 (exp->elts[elt].opcode == OP_STRING
1867 ? "string" : "name"),
1868 &exp->elts[elt + 2].string);
1869 elt += 4 + BYTES_TO_EXP_ELEM (len + 1);
1874 elt = dump_subexp (exp, stream, elt + 1);
1877 case STRUCTOP_ANONYMOUS:
1881 field_number = longest_to_int (exp->elts[elt + 1].longconst);
1883 fprintf_filtered (stream, "Field number: %d", field_number);
1884 elt = dump_subexp (exp, stream, elt + 3);
1893 elt = dump_subexp_body_standard (exp, stream, elt);
1900 /* print_subexp implementation for Rust. */
1903 rust_print_subexp (struct expression *exp, int *pos, struct ui_file *stream,
1904 enum precedence prec)
1906 switch (exp->elts[*pos].opcode)
1910 int length = longest_to_int (exp->elts[*pos + 2].longconst);
1913 type_print (exp->elts[*pos + 1].type, "", stream, 0);
1914 fputs_filtered (" { ", stream);
1917 for (i = 0; i < length; ++i)
1919 rust_print_subexp (exp, pos, stream, prec);
1920 fputs_filtered (", ", stream);
1922 fputs_filtered (" }", stream);
1928 LONGEST len = exp->elts[*pos + 1].longconst;
1930 fputs_filtered (&exp->elts[*pos + 2].string, stream);
1931 *pos += 4 + BYTES_TO_EXP_ELEM (len + 1);
1937 fputs_filtered ("<<others>> (", stream);
1939 rust_print_subexp (exp, pos, stream, prec);
1940 fputs_filtered (")", stream);
1944 case STRUCTOP_ANONYMOUS:
1946 int tem = longest_to_int (exp->elts[*pos + 1].longconst);
1949 print_subexp (exp, pos, stream, PREC_SUFFIX);
1950 fprintf_filtered (stream, ".%d", tem);
1956 fprintf_filtered (stream, "[");
1957 rust_print_subexp (exp, pos, stream, prec);
1958 fprintf_filtered (stream, "; ");
1959 rust_print_subexp (exp, pos, stream, prec);
1960 fprintf_filtered (stream, "]");
1964 print_subexp_standard (exp, pos, stream, prec);
1969 /* operator_check implementation for Rust. */
1972 rust_operator_check (struct expression *exp, int pos,
1973 int (*objfile_func) (struct objfile *objfile,
1977 switch (exp->elts[pos].opcode)
1981 struct type *type = exp->elts[pos + 1].type;
1982 struct objfile *objfile = TYPE_OBJFILE (type);
1984 if (objfile != NULL && (*objfile_func) (objfile, data))
1995 return operator_check_standard (exp, pos, objfile_func, data);
2003 /* Implementation of la_lookup_symbol_nonlocal for Rust. */
2005 static struct block_symbol
2006 rust_lookup_symbol_nonlocal (const struct language_defn *langdef,
2008 const struct block *block,
2009 const domain_enum domain)
2011 struct block_symbol result = {NULL, NULL};
2013 if (symbol_lookup_debug)
2015 fprintf_unfiltered (gdb_stdlog,
2016 "rust_lookup_symbol_non_local"
2017 " (%s, %s (scope %s), %s)\n",
2018 name, host_address_to_string (block),
2019 block_scope (block), domain_name (domain));
2022 /* Look up bare names in the block's scope. */
2023 std::string scopedname;
2024 if (name[cp_find_first_component (name)] == '\0')
2026 const char *scope = block_scope (block);
2028 if (scope[0] != '\0')
2030 scopedname = std::string (scope) + "::" + name;
2031 name = scopedname.c_str ();
2039 result = lookup_symbol_in_static_block (name, block, domain);
2040 if (result.symbol == NULL)
2041 result = lookup_global_symbol (name, block, domain);
2048 /* la_sniff_from_mangled_name for Rust. */
2051 rust_sniff_from_mangled_name (const char *mangled, char **demangled)
2053 *demangled = gdb_demangle (mangled, DMGL_PARAMS | DMGL_ANSI);
2054 return *demangled != NULL;
2059 /* la_watch_location_expression for Rust. */
2061 static gdb::unique_xmalloc_ptr<char>
2062 rust_watch_location_expression (struct type *type, CORE_ADDR addr)
2064 type = check_typedef (TYPE_TARGET_TYPE (check_typedef (type)));
2065 std::string name = type_to_string (type);
2066 return gdb::unique_xmalloc_ptr<char>
2067 (xstrprintf ("*(%s as *mut %s)", core_addr_to_string (addr),
2073 static const struct exp_descriptor exp_descriptor_rust =
2076 rust_operator_length,
2077 rust_operator_check,
2079 rust_dump_subexp_body,
2080 rust_evaluate_subexp
2083 static const char *rust_extensions[] =
2088 extern const struct language_defn rust_language_defn =
2098 &exp_descriptor_rust,
2101 rust_printchar, /* Print a character constant */
2102 rust_printstr, /* Function to print string constant */
2103 rust_emitchar, /* Print a single char */
2104 rust_print_type, /* Print a type using appropriate syntax */
2105 rust_print_typedef, /* Print a typedef using appropriate syntax */
2106 rust_val_print, /* Print a value using appropriate syntax */
2107 c_value_print, /* Print a top-level value */
2108 default_read_var_value, /* la_read_var_value */
2109 NULL, /* Language specific skip_trampoline */
2110 NULL, /* name_of_this */
2111 false, /* la_store_sym_names_in_linkage_form_p */
2112 rust_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
2113 basic_lookup_transparent_type,/* lookup_transparent_type */
2114 gdb_demangle, /* Language specific symbol demangler */
2115 rust_sniff_from_mangled_name,
2116 NULL, /* Language specific
2117 class_name_from_physname */
2118 c_op_print_tab, /* expression operators for printing */
2119 1, /* c-style arrays */
2120 0, /* String lower bound */
2121 default_word_break_characters,
2122 default_collect_symbol_completion_matches,
2123 rust_language_arch_info,
2124 default_print_array_index,
2125 default_pass_by_reference,
2127 rust_watch_location_expression,
2128 NULL, /* la_get_symbol_name_matcher */
2129 iterate_over_symbols,
2130 default_search_name_hash,
2131 &default_varobj_ops,