1 /* Rust language support routines for GDB, the GNU debugger.
3 Copyright (C) 2016-2017 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"
32 #include "rust-lang.h"
38 extern initialize_file_ftype _initialize_rust_language
;
40 /* Returns the last segment of a Rust path like foo::bar::baz. Will
41 not handle cases where the last segment contains generics. This
42 will return NULL if the last segment cannot be found. */
45 rust_last_path_segment (const char * path
)
47 const char *result
= strrchr (path
, ':');
54 /* Find the Rust crate for BLOCK. If no crate can be found, returns
55 NULL. Otherwise, returns a newly allocated string that the caller
56 is responsible for freeing. */
59 rust_crate_for_block (const struct block
*block
)
61 const char *scope
= block_scope (block
);
66 return xstrndup (scope
, cp_find_first_component (scope
));
69 /* Information about the discriminant/variant of an enum */
75 /* Field number in union. Negative on error. For an encoded enum,
76 the "hidden" member will always be field 1, and the "real" member
77 will always be field 0. */
79 /* True if this is an encoded enum that has a single "real" member
80 and a single "hidden" member. */
81 unsigned int is_encoded
: 1;
84 /* The prefix of a specially-encoded enum. */
86 #define RUST_ENUM_PREFIX "RUST$ENCODED$ENUM$"
88 /* The number of the real field. */
90 #define RUST_ENCODED_ENUM_REAL 0
92 /* The number of the hidden field. */
94 #define RUST_ENCODED_ENUM_HIDDEN 1
96 /* Whether or not a TYPE_CODE_UNION value is an untagged union
97 as opposed to being a regular Rust enum. */
99 rust_union_is_untagged (struct type
*type
)
101 /* Unions must have at least one field. */
102 if (TYPE_NFIELDS (type
) == 0)
104 /* If the first field is named, but the name has the rust enum prefix,
106 if (strncmp (TYPE_FIELD_NAME (type
, 0), RUST_ENUM_PREFIX
,
107 strlen (RUST_ENUM_PREFIX
)) == 0)
109 /* Unions only have named fields. */
110 for (int i
= 0; i
< TYPE_NFIELDS (type
); ++i
)
112 if (strlen (TYPE_FIELD_NAME (type
, i
)) == 0)
118 /* Utility function to get discriminant info for a given value. */
120 static struct disr_info
121 rust_get_disr_info (struct type
*type
, const gdb_byte
*valaddr
,
122 int embedded_offset
, CORE_ADDR address
,
126 struct disr_info ret
;
127 struct type
*disr_type
;
128 struct value_print_options opts
;
129 struct cleanup
*cleanup
;
130 const char *name_segment
;
132 get_no_prettyformat_print_options (&opts
);
137 if (TYPE_NFIELDS (type
) == 0)
138 error (_("Encountered void enum value"));
140 /* If an enum has two values where one is empty and the other holds
141 a pointer that cannot be zero; then the Rust compiler optimizes
142 away the discriminant and instead uses a zero value in the
143 pointer field to indicate the empty variant. */
144 if (strncmp (TYPE_FIELD_NAME (type
, 0), RUST_ENUM_PREFIX
,
145 strlen (RUST_ENUM_PREFIX
)) == 0)
147 char *tail
, *token
, *saveptr
= NULL
;
148 unsigned long fieldno
;
149 struct type
*member_type
;
154 if (TYPE_NFIELDS (type
) != 1)
155 error (_("Only expected one field in %s type"), RUST_ENUM_PREFIX
);
157 /* Optimized enums have only one field. */
158 member_type
= TYPE_FIELD_TYPE (type
, 0);
160 gdb::unique_xmalloc_ptr
<char> name (xstrdup (TYPE_FIELD_NAME (type
, 0)));
161 tail
= name
.get () + strlen (RUST_ENUM_PREFIX
);
163 /* The location of the value that doubles as a discriminant is
164 stored in the name of the field, as
165 RUST$ENCODED$ENUM$<fieldno>$<fieldno>$...$<variantname>
166 where the fieldnos are the indices of the fields that should be
167 traversed in order to find the field (which may be several fields deep)
168 and the variantname is the name of the variant of the case when the
170 for (token
= strtok_r (tail
, "$", &saveptr
);
172 token
= strtok_r (NULL
, "$", &saveptr
))
174 if (sscanf (token
, "%lu", &fieldno
) != 1)
176 /* We have reached the enum name, which cannot start
180 if (fieldno
>= TYPE_NFIELDS (member_type
))
181 error (_("%s refers to field after end of member type"),
184 embedded_offset
+= TYPE_FIELD_BITPOS (member_type
, fieldno
) / 8;
185 member_type
= TYPE_FIELD_TYPE (member_type
, fieldno
);
189 error (_("Invalid form for %s"), RUST_ENUM_PREFIX
);
190 value
= unpack_long (member_type
, valaddr
+ embedded_offset
);
194 ret
.field_no
= RUST_ENCODED_ENUM_HIDDEN
;
195 ret
.name
= std::string (TYPE_NAME (type
)) + "::" + token
;
199 ret
.field_no
= RUST_ENCODED_ENUM_REAL
;
200 ret
.name
= (std::string (TYPE_NAME (type
)) + "::"
201 + rust_last_path_segment (TYPE_NAME (TYPE_FIELD_TYPE (type
, 0))));
207 disr_type
= TYPE_FIELD_TYPE (type
, 0);
209 if (TYPE_NFIELDS (disr_type
) == 0)
211 /* This is a bounds check and should never be hit unless Rust
212 has changed its debuginfo format. */
213 error (_("Could not find enum discriminant field"));
215 else if (TYPE_NFIELDS (type
) == 1)
217 /* Sometimes univariant enums are encoded without a
218 discriminant. In that case, treating it as an encoded enum
219 with the first field being the actual type works. */
220 const char *field_name
= TYPE_NAME (TYPE_FIELD_TYPE (type
, 0));
221 const char *last
= rust_last_path_segment (field_name
);
222 ret
.name
= std::string (TYPE_NAME (type
)) + "::" + last
;
223 ret
.field_no
= RUST_ENCODED_ENUM_REAL
;
228 if (strcmp (TYPE_FIELD_NAME (disr_type
, 0), "RUST$ENUM$DISR") != 0)
229 error (_("Rust debug format has changed"));
231 string_file temp_file
;
232 /* The first value of the first field (or any field)
233 is the discriminant value. */
234 c_val_print (TYPE_FIELD_TYPE (disr_type
, 0),
235 (embedded_offset
+ TYPE_FIELD_BITPOS (type
, 0) / 8
236 + TYPE_FIELD_BITPOS (disr_type
, 0) / 8),
240 ret
.name
= std::move (temp_file
.string ());
241 name_segment
= rust_last_path_segment (ret
.name
.c_str ());
242 if (name_segment
!= NULL
)
244 for (i
= 0; i
< TYPE_NFIELDS (type
); ++i
)
246 /* Sadly, the discriminant value paths do not match the type
247 field name paths ('core::option::Option::Some' vs
248 'core::option::Some'). However, enum variant names are
249 unique in the last path segment and the generics are not
250 part of this path, so we can just compare those. This is
251 hackish and would be better fixed by improving rustc's
252 metadata for enums. */
253 const char *field_type
= TYPE_NAME (TYPE_FIELD_TYPE (type
, i
));
255 if (field_type
!= NULL
256 && strcmp (name_segment
,
257 rust_last_path_segment (field_type
)) == 0)
265 if (ret
.field_no
== -1 && !ret
.name
.empty ())
267 /* Somehow the discriminant wasn't found. */
268 error (_("Could not find variant of %s with discriminant %s"),
269 TYPE_TAG_NAME (type
), ret
.name
.c_str ());
275 /* See rust-lang.h. */
278 rust_tuple_type_p (struct type
*type
)
280 /* The current implementation is a bit of a hack, but there's
281 nothing else in the debuginfo to distinguish a tuple from a
283 return (TYPE_CODE (type
) == TYPE_CODE_STRUCT
284 && TYPE_TAG_NAME (type
) != NULL
285 && TYPE_TAG_NAME (type
)[0] == '(');
289 /* Return true if all non-static fields of a structlike type are in a
290 sequence like __0, __1, __2. OFFSET lets us skip fields. */
293 rust_underscore_fields (struct type
*type
, int offset
)
299 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
)
301 for (i
= 0; i
< TYPE_NFIELDS (type
); ++i
)
303 if (!field_is_static (&TYPE_FIELD (type
, i
)))
311 xsnprintf (buf
, sizeof (buf
), "__%d", field_number
);
312 if (strcmp (buf
, TYPE_FIELD_NAME (type
, i
)) != 0)
321 /* See rust-lang.h. */
324 rust_tuple_struct_type_p (struct type
*type
)
326 /* This is just an approximation until DWARF can represent Rust more
327 precisely. We exclude zero-length structs because they may not
328 be tuple structs, and there's no way to tell. */
329 return TYPE_NFIELDS (type
) > 0 && rust_underscore_fields (type
, 0);
332 /* Return true if a variant TYPE is a tuple variant, false otherwise. */
335 rust_tuple_variant_type_p (struct type
*type
)
337 /* First field is discriminant */
338 return rust_underscore_fields (type
, 1);
341 /* Return true if TYPE is a slice type, otherwise false. */
344 rust_slice_type_p (struct type
*type
)
346 return (TYPE_CODE (type
) == TYPE_CODE_STRUCT
347 && TYPE_TAG_NAME (type
) != NULL
348 && strncmp (TYPE_TAG_NAME (type
), "&[", 2) == 0);
351 /* Return true if TYPE is a range type, otherwise false. */
354 rust_range_type_p (struct type
*type
)
358 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
359 || TYPE_NFIELDS (type
) > 2
360 || TYPE_TAG_NAME (type
) == NULL
361 || strstr (TYPE_TAG_NAME (type
), "::Range") == NULL
)
364 if (TYPE_NFIELDS (type
) == 0)
368 if (strcmp (TYPE_FIELD_NAME (type
, 0), "start") == 0)
370 if (TYPE_NFIELDS (type
) == 1)
374 else if (TYPE_NFIELDS (type
) == 2)
376 /* First field had to be "start". */
380 return strcmp (TYPE_FIELD_NAME (type
, i
), "end") == 0;
383 /* Return true if TYPE seems to be the type "u8", otherwise false. */
386 rust_u8_type_p (struct type
*type
)
388 return (TYPE_CODE (type
) == TYPE_CODE_INT
389 && TYPE_UNSIGNED (type
)
390 && TYPE_LENGTH (type
) == 1);
393 /* Return true if TYPE is a Rust character type. */
396 rust_chartype_p (struct type
*type
)
398 return (TYPE_CODE (type
) == TYPE_CODE_CHAR
399 && TYPE_LENGTH (type
) == 4
400 && TYPE_UNSIGNED (type
));
405 /* la_emitchar implementation for Rust. */
408 rust_emitchar (int c
, struct type
*type
, struct ui_file
*stream
, int quoter
)
410 if (!rust_chartype_p (type
))
411 generic_emit_char (c
, type
, stream
, quoter
,
412 target_charset (get_type_arch (type
)));
413 else if (c
== '\\' || c
== quoter
)
414 fprintf_filtered (stream
, "\\%c", c
);
416 fputs_filtered ("\\n", stream
);
418 fputs_filtered ("\\r", stream
);
420 fputs_filtered ("\\t", stream
);
422 fputs_filtered ("\\0", stream
);
423 else if (c
>= 32 && c
<= 127 && isprint (c
))
424 fputc_filtered (c
, stream
);
426 fprintf_filtered (stream
, "\\x%02x", c
);
428 fprintf_filtered (stream
, "\\u{%06x}", c
);
431 /* la_printchar implementation for Rust. */
434 rust_printchar (int c
, struct type
*type
, struct ui_file
*stream
)
436 fputs_filtered ("'", stream
);
437 LA_EMIT_CHAR (c
, type
, stream
, '\'');
438 fputs_filtered ("'", stream
);
441 /* la_printstr implementation for Rust. */
444 rust_printstr (struct ui_file
*stream
, struct type
*type
,
445 const gdb_byte
*string
, unsigned int length
,
446 const char *user_encoding
, int force_ellipses
,
447 const struct value_print_options
*options
)
449 /* Rust always uses UTF-8, but let the caller override this if need
451 const char *encoding
= user_encoding
;
452 if (user_encoding
== NULL
|| !*user_encoding
)
454 /* In Rust strings, characters are "u8". */
455 if (rust_u8_type_p (type
))
459 /* This is probably some C string, so let's let C deal with
461 c_printstr (stream
, type
, string
, length
, user_encoding
,
462 force_ellipses
, options
);
467 /* This is not ideal as it doesn't use our character printer. */
468 generic_printstr (stream
, type
, string
, length
, encoding
, force_ellipses
,
474 /* rust_print_type branch for structs and untagged unions. */
477 val_print_struct (struct type
*type
, int embedded_offset
,
478 CORE_ADDR address
, struct ui_file
*stream
,
479 int recurse
, struct value
*val
,
480 const struct value_print_options
*options
)
484 int is_tuple
= rust_tuple_type_p (type
);
485 int is_tuple_struct
= !is_tuple
&& rust_tuple_struct_type_p (type
);
486 struct value_print_options opts
;
490 if (TYPE_TAG_NAME (type
) != NULL
)
491 fprintf_filtered (stream
, "%s", TYPE_TAG_NAME (type
));
493 if (TYPE_NFIELDS (type
) == 0)
496 if (TYPE_TAG_NAME (type
) != NULL
)
497 fputs_filtered (" ", stream
);
500 if (is_tuple
|| is_tuple_struct
)
501 fputs_filtered ("(", stream
);
503 fputs_filtered ("{", stream
);
509 for (i
= 0; i
< TYPE_NFIELDS (type
); ++i
)
511 if (field_is_static (&TYPE_FIELD (type
, i
)))
515 fputs_filtered (",", stream
);
517 if (options
->prettyformat
)
519 fputs_filtered ("\n", stream
);
520 print_spaces_filtered (2 + 2 * recurse
, stream
);
522 else if (!first_field
)
523 fputs_filtered (" ", stream
);
527 if (!is_tuple
&& !is_tuple_struct
)
529 fputs_filtered (TYPE_FIELD_NAME (type
, i
), stream
);
530 fputs_filtered (": ", stream
);
533 val_print (TYPE_FIELD_TYPE (type
, i
),
534 embedded_offset
+ TYPE_FIELD_BITPOS (type
, i
) / 8,
536 stream
, recurse
+ 1, val
, &opts
,
540 if (options
->prettyformat
)
542 fputs_filtered ("\n", stream
);
543 print_spaces_filtered (2 * recurse
, stream
);
546 if (is_tuple
|| is_tuple_struct
)
547 fputs_filtered (")", stream
);
549 fputs_filtered ("}", stream
);
552 static const struct generic_val_print_decorations rust_decorations
=
554 /* Complex isn't used in Rust, but we provide C-ish values just in
566 /* la_val_print implementation for Rust. */
569 rust_val_print (struct type
*type
, int embedded_offset
,
570 CORE_ADDR address
, struct ui_file
*stream
, int recurse
,
572 const struct value_print_options
*options
)
574 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
576 type
= check_typedef (type
);
577 switch (TYPE_CODE (type
))
581 LONGEST low_bound
, high_bound
;
583 if (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_ARRAY
584 && rust_u8_type_p (TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (type
)))
585 && get_array_bounds (TYPE_TARGET_TYPE (type
), &low_bound
,
587 /* We have a pointer to a byte string, so just print
589 struct type
*elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
591 struct gdbarch
*arch
= get_type_arch (type
);
592 int unit_size
= gdbarch_addressable_memory_unit_size (arch
);
594 addr
= unpack_pointer (type
, valaddr
+ embedded_offset
* unit_size
);
595 if (options
->addressprint
)
597 fputs_filtered (paddress (arch
, addr
), stream
);
598 fputs_filtered (" ", stream
);
601 fputs_filtered ("b", stream
);
602 val_print_string (TYPE_TARGET_TYPE (elttype
), "ASCII", addr
,
603 high_bound
- low_bound
+ 1, stream
,
610 case TYPE_CODE_METHODPTR
:
611 case TYPE_CODE_MEMBERPTR
:
612 c_val_print (type
, embedded_offset
, address
, stream
,
613 recurse
, val
, options
);
617 /* Recognize the unit type. */
618 if (TYPE_UNSIGNED (type
) && TYPE_LENGTH (type
) == 0
619 && TYPE_NAME (type
) != NULL
&& strcmp (TYPE_NAME (type
), "()") == 0)
621 fputs_filtered ("()", stream
);
626 case TYPE_CODE_STRING
:
628 struct gdbarch
*arch
= get_type_arch (type
);
629 int unit_size
= gdbarch_addressable_memory_unit_size (arch
);
630 LONGEST low_bound
, high_bound
;
632 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
633 error (_("Could not determine the array bounds"));
635 /* If we see a plain TYPE_CODE_STRING, then we're printing a
636 byte string, hence the choice of "ASCII" as the
638 fputs_filtered ("b", stream
);
639 rust_printstr (stream
, TYPE_TARGET_TYPE (type
),
640 valaddr
+ embedded_offset
* unit_size
,
641 high_bound
- low_bound
+ 1, "ASCII", 0, options
);
645 case TYPE_CODE_ARRAY
:
647 LONGEST low_bound
, high_bound
;
649 if (get_array_bounds (type
, &low_bound
, &high_bound
)
650 && high_bound
- low_bound
+ 1 == 0)
651 fputs_filtered ("[]", stream
);
657 case TYPE_CODE_UNION
:
659 int j
, nfields
, first_field
, is_tuple
, start
;
660 struct type
*variant_type
;
661 struct disr_info disr
;
662 struct value_print_options opts
;
664 /* Untagged unions are printed as if they are structs.
665 Since the field bit positions overlap in the debuginfo,
666 the code for printing a union is same as that for a struct,
667 the only difference is that the input type will have overlapping
669 if (rust_union_is_untagged (type
))
671 val_print_struct (type
, embedded_offset
, address
, stream
,
672 recurse
, val
, options
);
679 disr
= rust_get_disr_info (type
, valaddr
, embedded_offset
, address
,
682 if (disr
.is_encoded
&& disr
.field_no
== RUST_ENCODED_ENUM_HIDDEN
)
684 fprintf_filtered (stream
, "%s", disr
.name
.c_str ());
689 variant_type
= TYPE_FIELD_TYPE (type
, disr
.field_no
);
690 nfields
= TYPE_NFIELDS (variant_type
);
692 is_tuple
= (disr
.is_encoded
693 ? rust_tuple_struct_type_p (variant_type
)
694 : rust_tuple_variant_type_p (variant_type
));
695 start
= disr
.is_encoded
? 0 : 1;
699 /* In case of a non-nullary variant, we output 'Foo(x,y,z)'. */
701 fprintf_filtered (stream
, "%s(", disr
.name
.c_str ());
704 /* struct variant. */
705 fprintf_filtered (stream
, "%s{", disr
.name
.c_str ());
710 /* In case of a nullary variant like 'None', just output
712 fprintf_filtered (stream
, "%s", disr
.name
.c_str ());
716 for (j
= start
; j
< TYPE_NFIELDS (variant_type
); j
++)
719 fputs_filtered (", ", stream
);
723 fprintf_filtered (stream
, "%s: ",
724 TYPE_FIELD_NAME (variant_type
, j
));
726 val_print (TYPE_FIELD_TYPE (variant_type
, j
),
728 + TYPE_FIELD_BITPOS (type
, disr
.field_no
) / 8
729 + TYPE_FIELD_BITPOS (variant_type
, j
) / 8),
731 stream
, recurse
+ 1, val
, &opts
,
736 fputs_filtered (")", stream
);
738 fputs_filtered ("}", stream
);
742 case TYPE_CODE_STRUCT
:
743 val_print_struct (type
, embedded_offset
, address
, stream
,
744 recurse
, val
, options
);
749 /* Nothing special yet. */
750 generic_val_print (type
, embedded_offset
, address
, stream
,
751 recurse
, val
, options
, &rust_decorations
);
758 rust_print_type (struct type
*type
, const char *varstring
,
759 struct ui_file
*stream
, int show
, int level
,
760 const struct type_print_options
*flags
);
762 /* Print a struct or union typedef. */
764 rust_print_struct_def (struct type
*type
, const char *varstring
,
765 struct ui_file
*stream
, int show
, int level
,
766 const struct type_print_options
*flags
)
768 int is_tuple_struct
, i
;
770 /* Print a tuple type simply. */
771 if (rust_tuple_type_p (type
))
773 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
777 /* If we see a base class, delegate to C. */
778 if (TYPE_N_BASECLASSES (type
) > 0)
779 c_print_type (type
, varstring
, stream
, show
, level
, flags
);
781 /* This code path is also used by unions. */
782 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
783 fputs_filtered ("struct ", stream
);
785 fputs_filtered ("union ", stream
);
787 if (TYPE_TAG_NAME (type
) != NULL
)
788 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
790 is_tuple_struct
= rust_tuple_struct_type_p (type
);
792 if (TYPE_NFIELDS (type
) == 0 && !rust_tuple_type_p (type
))
794 fputs_filtered (is_tuple_struct
? " (\n" : " {\n", stream
);
796 for (i
= 0; i
< TYPE_NFIELDS (type
); ++i
)
801 if (field_is_static (&TYPE_FIELD (type
, i
)))
804 /* We'd like to print "pub" here as needed, but rustc
805 doesn't emit the debuginfo, and our types don't have
806 cplus_struct_type attached. */
808 /* For a tuple struct we print the type but nothing
810 print_spaces_filtered (level
+ 2, stream
);
811 if (!is_tuple_struct
)
812 fprintf_filtered (stream
, "%s: ", TYPE_FIELD_NAME (type
, i
));
814 rust_print_type (TYPE_FIELD_TYPE (type
, i
), NULL
,
815 stream
, show
- 1, level
+ 2,
817 fputs_filtered (",\n", stream
);
820 fprintfi_filtered (level
, stream
, is_tuple_struct
? ")" : "}");
823 /* la_print_typedef implementation for Rust. */
826 rust_print_typedef (struct type
*type
,
827 struct symbol
*new_symbol
,
828 struct ui_file
*stream
)
830 type
= check_typedef (type
);
831 fprintf_filtered (stream
, "type %s = ", SYMBOL_PRINT_NAME (new_symbol
));
832 type_print (type
, "", stream
, 0);
833 fprintf_filtered (stream
, ";\n");
836 /* la_print_type implementation for Rust. */
839 rust_print_type (struct type
*type
, const char *varstring
,
840 struct ui_file
*stream
, int show
, int level
,
841 const struct type_print_options
*flags
)
847 && TYPE_NAME (type
) != NULL
)
849 /* Rust calls the unit type "void" in its debuginfo,
850 but we don't want to print it as that. */
851 if (TYPE_CODE (type
) == TYPE_CODE_VOID
)
852 fputs_filtered ("()", stream
);
854 fputs_filtered (TYPE_NAME (type
), stream
);
858 type
= check_typedef (type
);
859 switch (TYPE_CODE (type
))
862 fputs_filtered ("()", stream
);
866 /* Delegate varargs to the C printer. */
867 if (TYPE_VARARGS (type
))
870 fputs_filtered ("fn ", stream
);
871 if (varstring
!= NULL
)
872 fputs_filtered (varstring
, stream
);
873 fputs_filtered ("(", stream
);
874 for (i
= 0; i
< TYPE_NFIELDS (type
); ++i
)
878 fputs_filtered (", ", stream
);
879 rust_print_type (TYPE_FIELD_TYPE (type
, i
), "", stream
, -1, 0,
882 fputs_filtered (")", stream
);
883 /* If it returns unit, we can omit the return type. */
884 if (TYPE_CODE (TYPE_TARGET_TYPE (type
)) != TYPE_CODE_VOID
)
886 fputs_filtered (" -> ", stream
);
887 rust_print_type (TYPE_TARGET_TYPE (type
), "", stream
, -1, 0, flags
);
891 case TYPE_CODE_ARRAY
:
893 LONGEST low_bound
, high_bound
;
895 fputs_filtered ("[", stream
);
896 rust_print_type (TYPE_TARGET_TYPE (type
), NULL
,
897 stream
, show
- 1, level
, flags
);
898 fputs_filtered ("; ", stream
);
900 if (TYPE_HIGH_BOUND_KIND (TYPE_INDEX_TYPE (type
)) == PROP_LOCEXPR
901 || TYPE_HIGH_BOUND_KIND (TYPE_INDEX_TYPE (type
)) == PROP_LOCLIST
)
902 fprintf_filtered (stream
, "variable length");
903 else if (get_array_bounds (type
, &low_bound
, &high_bound
))
904 fprintf_filtered (stream
, "%s",
905 plongest (high_bound
- low_bound
+ 1));
906 fputs_filtered ("]", stream
);
910 case TYPE_CODE_STRUCT
:
911 rust_print_struct_def (type
, varstring
, stream
, show
, level
, flags
);
918 fputs_filtered ("enum ", stream
);
919 if (TYPE_TAG_NAME (type
) != NULL
)
921 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
922 fputs_filtered (" ", stream
);
923 len
= strlen (TYPE_TAG_NAME (type
));
925 fputs_filtered ("{\n", stream
);
927 for (i
= 0; i
< TYPE_NFIELDS (type
); ++i
)
929 const char *name
= TYPE_FIELD_NAME (type
, i
);
934 && strncmp (name
, TYPE_TAG_NAME (type
), len
) == 0
936 && name
[len
+ 1] == ':')
938 fprintfi_filtered (level
+ 2, stream
, "%s,\n", name
);
941 fputs_filtered ("}", stream
);
945 case TYPE_CODE_UNION
:
949 /* Skip the discriminant field. */
952 /* Unions and structs have the same syntax in Rust,
953 the only difference is that structs are declared with `struct`
954 and union with `union`. This difference is handled in the struct
956 if (rust_union_is_untagged (type
))
958 rust_print_struct_def (type
, varstring
, stream
, show
, level
, flags
);
962 fputs_filtered ("enum ", stream
);
963 if (TYPE_TAG_NAME (type
) != NULL
)
965 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
966 fputs_filtered (" ", stream
);
968 fputs_filtered ("{\n", stream
);
970 if (strncmp (TYPE_FIELD_NAME (type
, 0), RUST_ENUM_PREFIX
,
971 strlen (RUST_ENUM_PREFIX
)) == 0)
973 const char *zero_field
= strrchr (TYPE_FIELD_NAME (type
, 0), '$');
974 if (zero_field
!= NULL
&& strlen (zero_field
) > 1)
976 fprintfi_filtered (level
+ 2, stream
, "%s,\n", zero_field
+ 1);
977 /* There is no explicit discriminant field, skip nothing. */
982 for (i
= 0; i
< TYPE_NFIELDS (type
); ++i
)
984 struct type
*variant_type
= TYPE_FIELD_TYPE (type
, i
);
986 = rust_last_path_segment (TYPE_NAME (variant_type
));
988 fprintfi_filtered (level
+ 2, stream
, "%s", name
);
990 if (TYPE_NFIELDS (variant_type
) > skip_to
)
993 int is_tuple
= rust_tuple_variant_type_p (variant_type
);
996 fputs_filtered (is_tuple
? "(" : "{", stream
);
997 for (j
= skip_to
; j
< TYPE_NFIELDS (variant_type
); j
++)
1002 fputs_filtered (", ", stream
);
1005 fprintf_filtered (stream
, "%s: ",
1006 TYPE_FIELD_NAME (variant_type
, j
));
1008 rust_print_type (TYPE_FIELD_TYPE (variant_type
, j
), NULL
,
1009 stream
, show
- 1, level
+ 2,
1012 fputs_filtered (is_tuple
? ")" : "}", stream
);
1015 fputs_filtered (",\n", stream
);
1018 fputs_filtered ("}", stream
);
1024 c_print_type (type
, varstring
, stream
, show
, level
, flags
);
1030 /* Compute the alignment of the type T. */
1033 rust_type_alignment (struct type
*t
)
1035 t
= check_typedef (t
);
1036 switch (TYPE_CODE (t
))
1039 error (_("Could not compute alignment of type"));
1042 case TYPE_CODE_ENUM
:
1046 case TYPE_CODE_CHAR
:
1047 case TYPE_CODE_BOOL
:
1048 return TYPE_LENGTH (t
);
1050 case TYPE_CODE_ARRAY
:
1051 case TYPE_CODE_COMPLEX
:
1052 return rust_type_alignment (TYPE_TARGET_TYPE (t
));
1054 case TYPE_CODE_STRUCT
:
1055 case TYPE_CODE_UNION
:
1060 for (i
= 0; i
< TYPE_NFIELDS (t
); ++i
)
1062 int a
= rust_type_alignment (TYPE_FIELD_TYPE (t
, i
));
1071 /* Like arch_composite_type, but uses TYPE to decide how to allocate
1072 -- either on an obstack or on a gdbarch. */
1074 static struct type
*
1075 rust_composite_type (struct type
*original
,
1077 const char *field1
, struct type
*type1
,
1078 const char *field2
, struct type
*type2
)
1080 struct type
*result
= alloc_type_copy (original
);
1081 int i
, nfields
, bitpos
;
1089 TYPE_CODE (result
) = TYPE_CODE_STRUCT
;
1090 TYPE_NAME (result
) = name
;
1091 TYPE_TAG_NAME (result
) = name
;
1093 TYPE_NFIELDS (result
) = nfields
;
1094 TYPE_FIELDS (result
)
1095 = (struct field
*) TYPE_ZALLOC (result
, nfields
* sizeof (struct field
));
1101 struct field
*field
= &TYPE_FIELD (result
, i
);
1103 SET_FIELD_BITPOS (*field
, bitpos
);
1104 bitpos
+= TYPE_LENGTH (type1
) * TARGET_CHAR_BIT
;
1106 FIELD_NAME (*field
) = field1
;
1107 FIELD_TYPE (*field
) = type1
;
1112 struct field
*field
= &TYPE_FIELD (result
, i
);
1113 int align
= rust_type_alignment (type2
);
1119 align
*= TARGET_CHAR_BIT
;
1120 delta
= bitpos
% align
;
1122 bitpos
+= align
- delta
;
1124 SET_FIELD_BITPOS (*field
, bitpos
);
1126 FIELD_NAME (*field
) = field2
;
1127 FIELD_TYPE (*field
) = type2
;
1132 TYPE_LENGTH (result
)
1133 = (TYPE_FIELD_BITPOS (result
, i
- 1) / TARGET_CHAR_BIT
+
1134 TYPE_LENGTH (TYPE_FIELD_TYPE (result
, i
- 1)));
1138 /* See rust-lang.h. */
1141 rust_slice_type (const char *name
, struct type
*elt_type
,
1142 struct type
*usize_type
)
1146 elt_type
= lookup_pointer_type (elt_type
);
1147 type
= rust_composite_type (elt_type
, name
,
1148 "data_ptr", elt_type
,
1149 "length", usize_type
);
1154 enum rust_primitive_types
1156 rust_primitive_bool
,
1157 rust_primitive_char
,
1166 rust_primitive_isize
,
1167 rust_primitive_usize
,
1170 rust_primitive_unit
,
1172 nr_rust_primitive_types
1175 /* la_language_arch_info implementation for Rust. */
1178 rust_language_arch_info (struct gdbarch
*gdbarch
,
1179 struct language_arch_info
*lai
)
1181 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
1183 struct type
**types
;
1184 unsigned int length
;
1186 types
= GDBARCH_OBSTACK_CALLOC (gdbarch
, nr_rust_primitive_types
+ 1,
1189 types
[rust_primitive_bool
] = arch_boolean_type (gdbarch
, 8, 1, "bool");
1190 types
[rust_primitive_char
] = arch_character_type (gdbarch
, 32, 1, "char");
1191 types
[rust_primitive_i8
] = arch_integer_type (gdbarch
, 8, 0, "i8");
1192 types
[rust_primitive_u8
] = arch_integer_type (gdbarch
, 8, 1, "u8");
1193 types
[rust_primitive_i16
] = arch_integer_type (gdbarch
, 16, 0, "i16");
1194 types
[rust_primitive_u16
] = arch_integer_type (gdbarch
, 16, 1, "u16");
1195 types
[rust_primitive_i32
] = arch_integer_type (gdbarch
, 32, 0, "i32");
1196 types
[rust_primitive_u32
] = arch_integer_type (gdbarch
, 32, 1, "u32");
1197 types
[rust_primitive_i64
] = arch_integer_type (gdbarch
, 64, 0, "i64");
1198 types
[rust_primitive_u64
] = arch_integer_type (gdbarch
, 64, 1, "u64");
1200 length
= 8 * TYPE_LENGTH (builtin
->builtin_data_ptr
);
1201 types
[rust_primitive_isize
] = arch_integer_type (gdbarch
, length
, 0, "isize");
1202 types
[rust_primitive_usize
] = arch_integer_type (gdbarch
, length
, 1, "usize");
1204 types
[rust_primitive_f32
] = arch_float_type (gdbarch
, 32, "f32",
1205 floatformats_ieee_single
);
1206 types
[rust_primitive_f64
] = arch_float_type (gdbarch
, 64, "f64",
1207 floatformats_ieee_double
);
1209 types
[rust_primitive_unit
] = arch_integer_type (gdbarch
, 0, 1, "()");
1211 tem
= make_cv_type (1, 0, types
[rust_primitive_u8
], NULL
);
1212 types
[rust_primitive_str
] = rust_slice_type ("&str", tem
,
1213 types
[rust_primitive_usize
]);
1215 lai
->primitive_type_vector
= types
;
1216 lai
->bool_type_default
= types
[rust_primitive_bool
];
1217 lai
->string_char_type
= types
[rust_primitive_u8
];
1222 /* A helper for rust_evaluate_subexp that handles OP_FUNCALL. */
1224 static struct value
*
1225 rust_evaluate_funcall (struct expression
*exp
, int *pos
, enum noside noside
)
1228 int num_args
= exp
->elts
[*pos
+ 1].longconst
;
1230 struct value
*function
, *result
, *arg0
;
1231 struct type
*type
, *fn_type
;
1232 const struct block
*block
;
1233 struct block_symbol sym
;
1235 /* For an ordinary function call we can simply defer to the
1236 generic implementation. */
1237 if (exp
->elts
[*pos
+ 3].opcode
!= STRUCTOP_STRUCT
)
1238 return evaluate_subexp_standard (NULL
, exp
, pos
, noside
);
1240 /* Skip over the OP_FUNCALL and the STRUCTOP_STRUCT. */
1242 method
= &exp
->elts
[*pos
+ 1].string
;
1243 *pos
+= 3 + BYTES_TO_EXP_ELEM (exp
->elts
[*pos
].longconst
+ 1);
1245 /* Evaluate the argument to STRUCTOP_STRUCT, then find its
1246 type in order to look up the method. */
1247 arg0
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1249 if (noside
== EVAL_SKIP
)
1251 for (i
= 0; i
< num_args
; ++i
)
1252 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1256 std::vector
<struct value
*> args (num_args
+ 1);
1259 /* We don't yet implement real Deref semantics. */
1260 while (TYPE_CODE (value_type (args
[0])) == TYPE_CODE_PTR
)
1261 args
[0] = value_ind (args
[0]);
1263 type
= value_type (args
[0]);
1264 if ((TYPE_CODE (type
) != TYPE_CODE_STRUCT
1265 && TYPE_CODE (type
) != TYPE_CODE_UNION
1266 && TYPE_CODE (type
) != TYPE_CODE_ENUM
)
1267 || rust_tuple_type_p (type
))
1268 error (_("Method calls only supported on struct or enum types"));
1269 if (TYPE_TAG_NAME (type
) == NULL
)
1270 error (_("Method call on nameless type"));
1272 std::string name
= std::string (TYPE_TAG_NAME (type
)) + "::" + method
;
1274 block
= get_selected_block (0);
1275 sym
= lookup_symbol (name
.c_str (), block
, VAR_DOMAIN
, NULL
);
1276 if (sym
.symbol
== NULL
)
1277 error (_("Could not find function named '%s'"), name
.c_str ());
1279 fn_type
= SYMBOL_TYPE (sym
.symbol
);
1280 if (TYPE_NFIELDS (fn_type
) == 0)
1281 error (_("Function '%s' takes no arguments"), name
.c_str ());
1283 if (TYPE_CODE (TYPE_FIELD_TYPE (fn_type
, 0)) == TYPE_CODE_PTR
)
1284 args
[0] = value_addr (args
[0]);
1286 function
= address_of_variable (sym
.symbol
, block
);
1288 for (i
= 0; i
< num_args
; ++i
)
1289 args
[i
+ 1] = evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1291 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1292 result
= value_zero (TYPE_TARGET_TYPE (fn_type
), not_lval
);
1294 result
= call_function_by_hand (function
, num_args
+ 1, args
.data ());
1298 /* A helper for rust_evaluate_subexp that handles OP_RANGE. */
1300 static struct value
*
1301 rust_range (struct expression
*exp
, int *pos
, enum noside noside
)
1303 enum range_type kind
;
1304 struct value
*low
= NULL
, *high
= NULL
;
1305 struct value
*addrval
, *result
;
1307 struct type
*range_type
;
1308 struct type
*index_type
;
1309 struct type
*temp_type
;
1312 kind
= (enum range_type
) longest_to_int (exp
->elts
[*pos
+ 1].longconst
);
1315 if (kind
== HIGH_BOUND_DEFAULT
|| kind
== NONE_BOUND_DEFAULT
)
1316 low
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1317 if (kind
== LOW_BOUND_DEFAULT
|| kind
== NONE_BOUND_DEFAULT
)
1318 high
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1320 if (noside
== EVAL_SKIP
)
1321 return value_from_longest (builtin_type (exp
->gdbarch
)->builtin_int
, 1);
1328 name
= "std::ops::RangeFull";
1332 index_type
= value_type (high
);
1333 name
= "std::ops::RangeTo";
1340 index_type
= value_type (low
);
1341 name
= "std::ops::RangeFrom";
1345 if (!types_equal (value_type (low
), value_type (high
)))
1346 error (_("Range expression with different types"));
1347 index_type
= value_type (low
);
1348 name
= "std::ops::Range";
1352 /* If we don't have an index type, just allocate this on the
1353 arch. Here any type will do. */
1354 temp_type
= (index_type
== NULL
1355 ? language_bool_type (exp
->language_defn
, exp
->gdbarch
)
1357 /* It would be nicer to cache the range type. */
1358 range_type
= rust_composite_type (temp_type
, name
,
1359 low
== NULL
? NULL
: "start", index_type
,
1360 high
== NULL
? NULL
: "end", index_type
);
1362 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1363 return value_zero (range_type
, lval_memory
);
1365 addrval
= value_allocate_space_in_inferior (TYPE_LENGTH (range_type
));
1366 addr
= value_as_long (addrval
);
1367 result
= value_at_lazy (range_type
, addr
);
1371 struct value
*start
= value_struct_elt (&result
, NULL
, "start", NULL
,
1374 value_assign (start
, low
);
1379 struct value
*end
= value_struct_elt (&result
, NULL
, "end", NULL
,
1382 value_assign (end
, high
);
1385 result
= value_at_lazy (range_type
, addr
);
1389 /* A helper function to compute the range and kind given a range
1390 value. TYPE is the type of the range value. RANGE is the range
1391 value. LOW, HIGH, and KIND are out parameters. The LOW and HIGH
1392 parameters might be filled in, or might not be, depending on the
1393 kind of range this is. KIND will always be set to the appropriate
1394 value describing the kind of range, and this can be used to
1395 determine whether LOW or HIGH are valid. */
1398 rust_compute_range (struct type
*type
, struct value
*range
,
1399 LONGEST
*low
, LONGEST
*high
,
1400 enum range_type
*kind
)
1406 *kind
= BOTH_BOUND_DEFAULT
;
1408 if (TYPE_NFIELDS (type
) == 0)
1412 if (strcmp (TYPE_FIELD_NAME (type
, 0), "start") == 0)
1414 *kind
= HIGH_BOUND_DEFAULT
;
1415 *low
= value_as_long (value_field (range
, 0));
1418 if (TYPE_NFIELDS (type
) > i
1419 && strcmp (TYPE_FIELD_NAME (type
, i
), "end") == 0)
1421 *kind
= (*kind
== BOTH_BOUND_DEFAULT
1422 ? LOW_BOUND_DEFAULT
: NONE_BOUND_DEFAULT
);
1423 *high
= value_as_long (value_field (range
, i
));
1427 /* A helper for rust_evaluate_subexp that handles BINOP_SUBSCRIPT. */
1429 static struct value
*
1430 rust_subscript (struct expression
*exp
, int *pos
, enum noside noside
,
1433 struct value
*lhs
, *rhs
, *result
;
1434 struct type
*rhstype
;
1435 LONGEST low
, high_bound
;
1436 /* Initialized to appease the compiler. */
1437 enum range_type kind
= BOTH_BOUND_DEFAULT
;
1442 lhs
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1443 rhs
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1445 if (noside
== EVAL_SKIP
)
1448 rhstype
= check_typedef (value_type (rhs
));
1449 if (rust_range_type_p (rhstype
))
1452 error (_("Can't take slice of array without '&'"));
1453 rust_compute_range (rhstype
, rhs
, &low
, &high
, &kind
);
1457 low
= value_as_long (rhs
);
1459 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1461 struct type
*type
= check_typedef (value_type (lhs
));
1463 result
= value_zero (TYPE_TARGET_TYPE (type
), VALUE_LVAL (lhs
));
1469 struct type
*type
= check_typedef (value_type (lhs
));
1471 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
1474 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
1475 error (_("Can't compute array bounds"));
1477 error (_("Found array with non-zero lower bound"));
1480 else if (rust_slice_type_p (type
))
1484 base
= value_struct_elt (&lhs
, NULL
, "data_ptr", NULL
, "slice");
1485 len
= value_struct_elt (&lhs
, NULL
, "length", NULL
, "slice");
1487 high_bound
= value_as_long (len
);
1489 else if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
1493 high_bound
= LONGEST_MAX
;
1496 error (_("Cannot subscript non-array type"));
1499 && (kind
== BOTH_BOUND_DEFAULT
|| kind
== LOW_BOUND_DEFAULT
))
1502 error (_("Index less than zero"));
1503 if (low
> high_bound
)
1504 error (_("Index greater than length"));
1506 result
= value_subscript (base
, low
);
1513 struct type
*usize
, *slice
;
1515 struct value
*addrval
, *tem
;
1517 if (kind
== BOTH_BOUND_DEFAULT
|| kind
== HIGH_BOUND_DEFAULT
)
1520 error (_("High index less than zero"));
1522 error (_("Low index greater than high index"));
1523 if (high
> high_bound
)
1524 error (_("High index greater than length"));
1526 usize
= language_lookup_primitive_type (exp
->language_defn
,
1529 slice
= rust_slice_type ("&[*gdb*]", value_type (result
),
1532 addrval
= value_allocate_space_in_inferior (TYPE_LENGTH (slice
));
1533 addr
= value_as_long (addrval
);
1534 tem
= value_at_lazy (slice
, addr
);
1536 value_assign (value_field (tem
, 0), value_addr (result
));
1537 value_assign (value_field (tem
, 1),
1538 value_from_longest (usize
, high
- low
));
1540 result
= value_at_lazy (slice
, addr
);
1543 result
= value_addr (result
);
1549 /* evaluate_exp implementation for Rust. */
1551 static struct value
*
1552 rust_evaluate_subexp (struct type
*expect_type
, struct expression
*exp
,
1553 int *pos
, enum noside noside
)
1555 struct value
*result
;
1557 switch (exp
->elts
[*pos
].opcode
)
1559 case UNOP_COMPLEMENT
:
1561 struct value
*value
;
1564 value
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1565 if (noside
== EVAL_SKIP
)
1567 /* Preserving the type is enough. */
1570 if (TYPE_CODE (value_type (value
)) == TYPE_CODE_BOOL
)
1571 result
= value_from_longest (value_type (value
),
1572 value_logical_not (value
));
1574 result
= value_complement (value
);
1578 case BINOP_SUBSCRIPT
:
1579 result
= rust_subscript (exp
, pos
, noside
, 0);
1583 result
= rust_evaluate_funcall (exp
, pos
, noside
);
1589 struct type
*type
= exp
->elts
[pc
+ 1].type
;
1590 int arglen
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
1593 struct value
*addrval
= NULL
;
1597 if (noside
== EVAL_NORMAL
)
1599 addrval
= value_allocate_space_in_inferior (TYPE_LENGTH (type
));
1600 addr
= value_as_long (addrval
);
1601 result
= value_at_lazy (type
, addr
);
1604 if (arglen
> 0 && exp
->elts
[*pos
].opcode
== OP_OTHERS
)
1609 init
= rust_evaluate_subexp (NULL
, exp
, pos
, noside
);
1610 if (noside
== EVAL_NORMAL
)
1612 /* This isn't quite right but will do for the time
1613 being, seeing that we can't implement the Copy
1615 value_assign (result
, init
);
1621 gdb_assert (arglen
% 2 == 0);
1622 for (i
= 0; i
< arglen
; i
+= 2)
1625 const char *fieldname
;
1626 struct value
*value
, *field
;
1628 gdb_assert (exp
->elts
[*pos
].opcode
== OP_NAME
);
1630 len
= longest_to_int (exp
->elts
[*pos
].longconst
);
1632 fieldname
= &exp
->elts
[*pos
].string
;
1633 *pos
+= 2 + BYTES_TO_EXP_ELEM (len
+ 1);
1635 value
= rust_evaluate_subexp (NULL
, exp
, pos
, noside
);
1636 if (noside
== EVAL_NORMAL
)
1638 field
= value_struct_elt (&result
, NULL
, fieldname
, NULL
,
1640 value_assign (field
, value
);
1644 if (noside
== EVAL_SKIP
)
1645 return value_from_longest (builtin_type (exp
->gdbarch
)->builtin_int
,
1647 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1648 result
= allocate_value (type
);
1650 result
= value_at_lazy (type
, addr
);
1659 struct value
*ncopies
;
1661 elt
= rust_evaluate_subexp (NULL
, exp
, pos
, noside
);
1662 ncopies
= rust_evaluate_subexp (NULL
, exp
, pos
, noside
);
1663 copies
= value_as_long (ncopies
);
1665 error (_("Array with negative number of elements"));
1667 if (noside
== EVAL_NORMAL
)
1671 std::vector
<struct value
*> eltvec (copies
);
1673 for (i
= 0; i
< copies
; ++i
)
1675 result
= value_array (0, copies
- 1, eltvec
.data ());
1679 struct type
*arraytype
1680 = lookup_array_range_type (value_type (elt
), 0, copies
- 1);
1681 result
= allocate_value (arraytype
);
1686 case STRUCTOP_ANONYMOUS
:
1688 /* Anonymous field access, i.e. foo.1. */
1690 int pc
, field_number
, nfields
;
1691 struct type
*type
, *variant_type
;
1692 struct disr_info disr
;
1695 field_number
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1697 lhs
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1699 type
= value_type (lhs
);
1700 /* Untagged unions can't have anonymous field access since
1701 they can only have named fields. */
1702 if (TYPE_CODE (type
) == TYPE_CODE_UNION
1703 && !rust_union_is_untagged (type
))
1705 disr
= rust_get_disr_info (type
, value_contents (lhs
),
1706 value_embedded_offset (lhs
),
1707 value_address (lhs
), lhs
);
1709 if (disr
.is_encoded
&& disr
.field_no
== RUST_ENCODED_ENUM_HIDDEN
)
1711 variant_type
= NULL
;
1716 variant_type
= TYPE_FIELD_TYPE (type
, disr
.field_no
);
1717 nfields
= TYPE_NFIELDS (variant_type
);
1720 if (!disr
.is_encoded
)
1723 if (field_number
>= nfields
|| field_number
< 0)
1724 error(_("Cannot access field %d of variant %s, \
1725 there are only %d fields"),
1726 disr
.is_encoded
? field_number
: field_number
- 1,
1728 disr
.is_encoded
? nfields
: nfields
- 1);
1730 if (!(disr
.is_encoded
1731 ? rust_tuple_struct_type_p (variant_type
)
1732 : rust_tuple_variant_type_p (variant_type
)))
1733 error(_("Variant %s is not a tuple variant"), disr
.name
.c_str ());
1735 result
= value_primitive_field (lhs
, 0, field_number
,
1738 else if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
1740 /* Tuples and tuple structs */
1741 nfields
= TYPE_NFIELDS(type
);
1743 if (field_number
>= nfields
|| field_number
< 0)
1744 error(_("Cannot access field %d of %s, there are only %d fields"),
1745 field_number
, TYPE_TAG_NAME (type
), nfields
);
1747 /* Tuples are tuple structs too. */
1748 if (!rust_tuple_struct_type_p (type
))
1749 error(_("Attempting to access anonymous field %d of %s, which is \
1750 not a tuple, tuple struct, or tuple-like variant"),
1751 field_number
, TYPE_TAG_NAME (type
));
1753 result
= value_primitive_field (lhs
, 0, field_number
, type
);
1756 error(_("Anonymous field access is only allowed on tuples, \
1757 tuple structs, and tuple-like enum variants"));
1761 case STRUCTOP_STRUCT
:
1768 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1769 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1770 lhs
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1772 type
= value_type (lhs
);
1773 if (TYPE_CODE (type
) == TYPE_CODE_UNION
1774 && !rust_union_is_untagged (type
))
1777 struct disr_info disr
;
1778 struct type
* variant_type
;
1781 field_name
= &exp
->elts
[pc
+ 2].string
;
1783 disr
= rust_get_disr_info (type
, value_contents (lhs
),
1784 value_embedded_offset (lhs
),
1785 value_address (lhs
), lhs
);
1787 if (disr
.is_encoded
&& disr
.field_no
== RUST_ENCODED_ENUM_HIDDEN
)
1788 error(_("Could not find field %s of struct variant %s"),
1789 field_name
, disr
.name
.c_str ());
1791 variant_type
= TYPE_FIELD_TYPE (type
, disr
.field_no
);
1793 if (variant_type
== NULL
1795 ? rust_tuple_struct_type_p (variant_type
)
1796 : rust_tuple_variant_type_p (variant_type
)))
1797 error(_("Attempting to access named field %s of tuple variant %s, \
1798 which has only anonymous fields"),
1799 field_name
, disr
.name
.c_str ());
1801 start
= disr
.is_encoded
? 0 : 1;
1802 for (i
= start
; i
< TYPE_NFIELDS (variant_type
); i
++)
1804 if (strcmp (TYPE_FIELD_NAME (variant_type
, i
),
1806 result
= value_primitive_field (lhs
, 0, i
, variant_type
);
1811 if (i
== TYPE_NFIELDS (variant_type
))
1812 /* We didn't find it. */
1813 error(_("Could not find field %s of struct variant %s"),
1814 field_name
, disr
.name
.c_str ());
1818 /* Field access in structs and untagged unions works like C. */
1820 result
= evaluate_subexp_standard (expect_type
, exp
, pos
, noside
);
1826 result
= rust_range (exp
, pos
, noside
);
1830 /* We might have &array[range], in which case we need to make a
1832 if (exp
->elts
[*pos
+ 1].opcode
== BINOP_SUBSCRIPT
)
1835 result
= rust_subscript (exp
, pos
, noside
, 1);
1840 result
= evaluate_subexp_standard (expect_type
, exp
, pos
, noside
);
1847 /* operator_length implementation for Rust. */
1850 rust_operator_length (const struct expression
*exp
, int pc
, int *oplenp
,
1856 switch (exp
->elts
[pc
- 1].opcode
)
1859 /* We handle aggregate as a type and argument count. The first
1860 argument might be OP_OTHERS. After that the arguments
1861 alternate: first an OP_NAME, then an expression. */
1863 args
= longest_to_int (exp
->elts
[pc
- 2].longconst
);
1871 case STRUCTOP_ANONYMOUS
:
1882 operator_length_standard (exp
, pc
, oplenp
, argsp
);
1890 /* op_name implementation for Rust. */
1893 rust_op_name (enum exp_opcode opcode
)
1898 return "OP_AGGREGATE";
1902 return op_name_standard (opcode
);
1906 /* dump_subexp_body implementation for Rust. */
1909 rust_dump_subexp_body (struct expression
*exp
, struct ui_file
*stream
,
1912 switch (exp
->elts
[elt
].opcode
)
1916 int length
= longest_to_int (exp
->elts
[elt
+ 2].longconst
);
1919 fprintf_filtered (stream
, "Type @");
1920 gdb_print_host_address (exp
->elts
[elt
+ 1].type
, stream
);
1921 fprintf_filtered (stream
, " (");
1922 type_print (exp
->elts
[elt
+ 1].type
, NULL
, stream
, 0);
1923 fprintf_filtered (stream
, "), length %d", length
);
1926 for (i
= 0; i
< length
; ++i
)
1927 elt
= dump_subexp (exp
, stream
, elt
);
1934 LONGEST len
= exp
->elts
[elt
+ 1].longconst
;
1936 fprintf_filtered (stream
, "%s: %s",
1937 (exp
->elts
[elt
].opcode
== OP_STRING
1938 ? "string" : "name"),
1939 &exp
->elts
[elt
+ 2].string
);
1940 elt
+= 4 + BYTES_TO_EXP_ELEM (len
+ 1);
1945 elt
= dump_subexp (exp
, stream
, elt
+ 1);
1948 case STRUCTOP_ANONYMOUS
:
1952 field_number
= longest_to_int (exp
->elts
[elt
].longconst
);
1954 fprintf_filtered (stream
, "Field number: %d", field_number
);
1955 elt
= dump_subexp (exp
, stream
, elt
+ 2);
1963 elt
= dump_subexp_body_standard (exp
, stream
, elt
);
1970 /* print_subexp implementation for Rust. */
1973 rust_print_subexp (struct expression
*exp
, int *pos
, struct ui_file
*stream
,
1974 enum precedence prec
)
1976 switch (exp
->elts
[*pos
].opcode
)
1980 int length
= longest_to_int (exp
->elts
[*pos
+ 2].longconst
);
1983 type_print (exp
->elts
[*pos
+ 1].type
, "", stream
, 0);
1984 fputs_filtered (" { ", stream
);
1987 for (i
= 0; i
< length
; ++i
)
1989 rust_print_subexp (exp
, pos
, stream
, prec
);
1990 fputs_filtered (", ", stream
);
1992 fputs_filtered (" }", stream
);
1998 LONGEST len
= exp
->elts
[*pos
+ 1].longconst
;
2000 fputs_filtered (&exp
->elts
[*pos
+ 2].string
, stream
);
2001 *pos
+= 4 + BYTES_TO_EXP_ELEM (len
+ 1);
2007 fputs_filtered ("<<others>> (", stream
);
2009 rust_print_subexp (exp
, pos
, stream
, prec
);
2010 fputs_filtered (")", stream
);
2014 case STRUCTOP_ANONYMOUS
:
2016 int tem
= longest_to_int (exp
->elts
[*pos
+ 1].longconst
);
2019 print_subexp (exp
, pos
, stream
, PREC_SUFFIX
);
2020 fprintf_filtered (stream
, ".%d", tem
);
2026 fprintf_filtered (stream
, "[");
2027 rust_print_subexp (exp
, pos
, stream
, prec
);
2028 fprintf_filtered (stream
, "; ");
2029 rust_print_subexp (exp
, pos
, stream
, prec
);
2030 fprintf_filtered (stream
, "]");
2034 print_subexp_standard (exp
, pos
, stream
, prec
);
2039 /* operator_check implementation for Rust. */
2042 rust_operator_check (struct expression
*exp
, int pos
,
2043 int (*objfile_func
) (struct objfile
*objfile
,
2047 switch (exp
->elts
[pos
].opcode
)
2051 struct type
*type
= exp
->elts
[pos
+ 1].type
;
2052 struct objfile
*objfile
= TYPE_OBJFILE (type
);
2054 if (objfile
!= NULL
&& (*objfile_func
) (objfile
, data
))
2065 return operator_check_standard (exp
, pos
, objfile_func
, data
);
2073 /* Implementation of la_lookup_symbol_nonlocal for Rust. */
2075 static struct block_symbol
2076 rust_lookup_symbol_nonlocal (const struct language_defn
*langdef
,
2078 const struct block
*block
,
2079 const domain_enum domain
)
2081 struct block_symbol result
= {NULL
, NULL
};
2083 if (symbol_lookup_debug
)
2085 fprintf_unfiltered (gdb_stdlog
,
2086 "rust_lookup_symbol_non_local"
2087 " (%s, %s (scope %s), %s)\n",
2088 name
, host_address_to_string (block
),
2089 block_scope (block
), domain_name (domain
));
2092 /* Look up bare names in the block's scope. */
2093 if (name
[cp_find_first_component (name
)] == '\0')
2095 const char *scope
= block_scope (block
);
2097 if (scope
[0] != '\0')
2099 std::string scopedname
= std::string (scope
) + "::" + name
;
2101 result
= lookup_symbol_in_static_block (scopedname
.c_str (), block
,
2103 if (result
.symbol
== NULL
)
2104 result
= lookup_global_symbol (scopedname
.c_str (), block
, domain
);
2112 /* la_sniff_from_mangled_name for Rust. */
2115 rust_sniff_from_mangled_name (const char *mangled
, char **demangled
)
2117 *demangled
= gdb_demangle (mangled
, DMGL_PARAMS
| DMGL_ANSI
);
2118 return *demangled
!= NULL
;
2123 static const struct exp_descriptor exp_descriptor_rust
=
2126 rust_operator_length
,
2127 rust_operator_check
,
2129 rust_dump_subexp_body
,
2130 rust_evaluate_subexp
2133 static const char *rust_extensions
[] =
2138 static const struct language_defn rust_language_defn
=
2148 &exp_descriptor_rust
,
2152 rust_printchar
, /* Print a character constant */
2153 rust_printstr
, /* Function to print string constant */
2154 rust_emitchar
, /* Print a single char */
2155 rust_print_type
, /* Print a type using appropriate syntax */
2156 rust_print_typedef
, /* Print a typedef using appropriate syntax */
2157 rust_val_print
, /* Print a value using appropriate syntax */
2158 c_value_print
, /* Print a top-level value */
2159 default_read_var_value
, /* la_read_var_value */
2160 NULL
, /* Language specific skip_trampoline */
2161 NULL
, /* name_of_this */
2162 rust_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
2163 basic_lookup_transparent_type
,/* lookup_transparent_type */
2164 gdb_demangle
, /* Language specific symbol demangler */
2165 rust_sniff_from_mangled_name
,
2166 NULL
, /* Language specific
2167 class_name_from_physname */
2168 c_op_print_tab
, /* expression operators for printing */
2169 1, /* c-style arrays */
2170 0, /* String lower bound */
2171 default_word_break_characters
,
2172 default_make_symbol_completion_list
,
2173 rust_language_arch_info
,
2174 default_print_array_index
,
2175 default_pass_by_reference
,
2177 NULL
, /* la_get_symbol_name_cmp */
2178 iterate_over_symbols
,
2179 &default_varobj_ops
,
2186 _initialize_rust_language (void)
2188 add_language (&rust_language_defn
);