1 /* Rust language support routines for GDB, the GNU debugger.
3 Copyright (C) 2016 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 */
73 /* Name of field. Must be freed by caller. */
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
,
123 const struct value
*val
)
126 struct disr_info ret
;
127 struct type
*disr_type
;
128 struct ui_file
*temp_file
;
129 struct value_print_options opts
;
130 struct cleanup
*cleanup
;
131 const char *name_segment
;
133 get_no_prettyformat_print_options (&opts
);
138 if (TYPE_NFIELDS (type
) == 0)
139 error (_("Encountered void enum value"));
141 /* If an enum has two values where one is empty and the other holds
142 a pointer that cannot be zero; then the Rust compiler optimizes
143 away the discriminant and instead uses a zero value in the
144 pointer field to indicate the empty variant. */
145 if (strncmp (TYPE_FIELD_NAME (type
, 0), RUST_ENUM_PREFIX
,
146 strlen (RUST_ENUM_PREFIX
)) == 0)
148 char *tail
, *token
, *name
, *saveptr
= NULL
;
149 unsigned long fieldno
;
150 struct type
*member_type
;
155 if (TYPE_NFIELDS (type
) != 1)
156 error (_("Only expected one field in %s type"), RUST_ENUM_PREFIX
);
158 /* Optimized enums have only one field. */
159 member_type
= TYPE_FIELD_TYPE (type
, 0);
161 name
= xstrdup (TYPE_FIELD_NAME (type
, 0));
162 cleanup
= make_cleanup (xfree
, name
);
163 tail
= name
+ strlen (RUST_ENUM_PREFIX
);
165 /* The location of the value that doubles as a discriminant is
166 stored in the name of the field, as
167 RUST$ENCODED$ENUM$<fieldno>$<fieldno>$...$<variantname>
168 where the fieldnos are the indices of the fields that should be
169 traversed in order to find the field (which may be several fields deep)
170 and the variantname is the name of the variant of the case when the
172 for (token
= strtok_r (tail
, "$", &saveptr
);
174 token
= strtok_r (NULL
, "$", &saveptr
))
176 if (sscanf (token
, "%lu", &fieldno
) != 1)
178 /* We have reached the enum name, which cannot start
182 if (fieldno
>= TYPE_NFIELDS (member_type
))
183 error (_("%s refers to field after end of member type"),
186 embedded_offset
+= TYPE_FIELD_BITPOS (member_type
, fieldno
) / 8;
187 member_type
= TYPE_FIELD_TYPE (member_type
, fieldno
);
191 error (_("Invalid form for %s"), RUST_ENUM_PREFIX
);
192 value
= unpack_long (member_type
, valaddr
+ embedded_offset
);
196 ret
.field_no
= RUST_ENCODED_ENUM_HIDDEN
;
197 ret
.name
= concat (TYPE_NAME (type
), "::", token
, (char *) NULL
);
201 ret
.field_no
= RUST_ENCODED_ENUM_REAL
;
202 ret
.name
= concat (TYPE_NAME (type
), "::",
203 rust_last_path_segment (TYPE_NAME (TYPE_FIELD_TYPE (type
, 0))),
207 do_cleanups (cleanup
);
211 disr_type
= TYPE_FIELD_TYPE (type
, 0);
213 if (TYPE_NFIELDS (disr_type
) == 0)
215 /* This is a bounds check and should never be hit unless Rust
216 has changed its debuginfo format. */
217 error (_("Could not find enum discriminant field"));
219 else if (TYPE_NFIELDS (type
) == 1)
221 /* Sometimes univariant enums are encoded without a
222 discriminant. In that case, treating it as an encoded enum
223 with the first field being the actual type works. */
224 const char *field_name
= TYPE_NAME (TYPE_FIELD_TYPE (type
, 0));
225 const char *last
= rust_last_path_segment (field_name
);
226 ret
.name
= concat (TYPE_NAME (type
), "::", last
, (char *) NULL
);
227 ret
.field_no
= RUST_ENCODED_ENUM_REAL
;
232 if (strcmp (TYPE_FIELD_NAME (disr_type
, 0), "RUST$ENUM$DISR") != 0)
233 error (_("Rust debug format has changed"));
235 temp_file
= mem_fileopen ();
236 cleanup
= make_cleanup_ui_file_delete (temp_file
);
237 /* The first value of the first field (or any field)
238 is the discriminant value. */
239 c_val_print (TYPE_FIELD_TYPE (disr_type
, 0), valaddr
,
240 (embedded_offset
+ TYPE_FIELD_BITPOS (type
, 0) / 8
241 + TYPE_FIELD_BITPOS (disr_type
, 0) / 8),
245 ret
.name
= ui_file_xstrdup (temp_file
, NULL
);
246 name_segment
= rust_last_path_segment (ret
.name
);
247 if (name_segment
!= NULL
)
249 for (i
= 0; i
< TYPE_NFIELDS (type
); ++i
)
251 /* Sadly, the discriminant value paths do not match the type
252 field name paths ('core::option::Option::Some' vs
253 'core::option::Some'). However, enum variant names are
254 unique in the last path segment and the generics are not
255 part of this path, so we can just compare those. This is
256 hackish and would be better fixed by improving rustc's
257 metadata for enums. */
258 const char *field_type
= TYPE_NAME (TYPE_FIELD_TYPE (type
, i
));
260 if (field_type
!= NULL
261 && strcmp (name_segment
,
262 rust_last_path_segment (field_type
)) == 0)
270 if (ret
.field_no
== -1 && ret
.name
!= NULL
)
272 /* Somehow the discriminant wasn't found. */
273 make_cleanup (xfree
, ret
.name
);
274 error (_("Could not find variant of %s with discriminant %s"),
275 TYPE_TAG_NAME (type
), ret
.name
);
278 do_cleanups (cleanup
);
282 /* See rust-lang.h. */
285 rust_tuple_type_p (struct type
*type
)
287 /* The current implementation is a bit of a hack, but there's
288 nothing else in the debuginfo to distinguish a tuple from a
290 return (TYPE_CODE (type
) == TYPE_CODE_STRUCT
291 && TYPE_TAG_NAME (type
) != NULL
292 && TYPE_TAG_NAME (type
)[0] == '(');
296 /* Return true if all non-static fields of a structlike type are in a
297 sequence like __0, __1, __2. OFFSET lets us skip fields. */
300 rust_underscore_fields (struct type
*type
, int offset
)
306 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
)
308 for (i
= 0; i
< TYPE_NFIELDS (type
); ++i
)
310 if (!field_is_static (&TYPE_FIELD (type
, i
)))
318 xsnprintf (buf
, sizeof (buf
), "__%d", field_number
);
319 if (strcmp (buf
, TYPE_FIELD_NAME (type
, i
)) != 0)
328 /* See rust-lang.h. */
331 rust_tuple_struct_type_p (struct type
*type
)
333 /* This is just an approximation until DWARF can represent Rust more
334 precisely. We exclude zero-length structs because they may not
335 be tuple structs, and there's no way to tell. */
336 return TYPE_NFIELDS (type
) > 0 && rust_underscore_fields (type
, 0);
339 /* Return true if a variant TYPE is a tuple variant, false otherwise. */
342 rust_tuple_variant_type_p (struct type
*type
)
344 /* First field is discriminant */
345 return rust_underscore_fields (type
, 1);
348 /* Return true if TYPE is a slice type, otherwise false. */
351 rust_slice_type_p (struct type
*type
)
353 return (TYPE_CODE (type
) == TYPE_CODE_STRUCT
354 && TYPE_TAG_NAME (type
) != NULL
355 && strncmp (TYPE_TAG_NAME (type
), "&[", 2) == 0);
358 /* Return true if TYPE is a range type, otherwise false. */
361 rust_range_type_p (struct type
*type
)
365 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
366 || TYPE_NFIELDS (type
) > 2
367 || TYPE_TAG_NAME (type
) == NULL
368 || strstr (TYPE_TAG_NAME (type
), "::Range") == NULL
)
371 if (TYPE_NFIELDS (type
) == 0)
375 if (strcmp (TYPE_FIELD_NAME (type
, 0), "start") == 0)
377 if (TYPE_NFIELDS (type
) == 1)
381 else if (TYPE_NFIELDS (type
) == 2)
383 /* First field had to be "start". */
387 return strcmp (TYPE_FIELD_NAME (type
, i
), "end") == 0;
390 /* Return true if TYPE seems to be the type "u8", otherwise false. */
393 rust_u8_type_p (struct type
*type
)
395 return (TYPE_CODE (type
) == TYPE_CODE_INT
396 && TYPE_UNSIGNED (type
)
397 && TYPE_LENGTH (type
) == 1);
400 /* Return true if TYPE is a Rust character type. */
403 rust_chartype_p (struct type
*type
)
405 return (TYPE_CODE (type
) == TYPE_CODE_CHAR
406 && TYPE_LENGTH (type
) == 4
407 && TYPE_UNSIGNED (type
));
412 /* la_emitchar implementation for Rust. */
415 rust_emitchar (int c
, struct type
*type
, struct ui_file
*stream
, int quoter
)
417 if (!rust_chartype_p (type
))
418 generic_emit_char (c
, type
, stream
, quoter
,
419 target_charset (get_type_arch (type
)));
420 else if (c
== '\\' || c
== quoter
)
421 fprintf_filtered (stream
, "\\%c", c
);
423 fputs_filtered ("\\n", stream
);
425 fputs_filtered ("\\r", stream
);
427 fputs_filtered ("\\t", stream
);
429 fputs_filtered ("\\0", stream
);
430 else if (c
>= 32 && c
<= 127 && isprint (c
))
431 fputc_filtered (c
, stream
);
433 fprintf_filtered (stream
, "\\x%02x", c
);
435 fprintf_filtered (stream
, "\\u{%06x}", c
);
438 /* la_printchar implementation for Rust. */
441 rust_printchar (int c
, struct type
*type
, struct ui_file
*stream
)
443 fputs_filtered ("'", stream
);
444 LA_EMIT_CHAR (c
, type
, stream
, '\'');
445 fputs_filtered ("'", stream
);
448 /* la_printstr implementation for Rust. */
451 rust_printstr (struct ui_file
*stream
, struct type
*type
,
452 const gdb_byte
*string
, unsigned int length
,
453 const char *user_encoding
, int force_ellipses
,
454 const struct value_print_options
*options
)
456 /* Rust always uses UTF-8, but let the caller override this if need
458 const char *encoding
= user_encoding
;
459 if (user_encoding
== NULL
|| !*user_encoding
)
461 /* In Rust strings, characters are "u8". */
462 if (rust_u8_type_p (type
))
466 /* This is probably some C string, so let's let C deal with
468 c_printstr (stream
, type
, string
, length
, user_encoding
,
469 force_ellipses
, options
);
474 /* This is not ideal as it doesn't use our character printer. */
475 generic_printstr (stream
, type
, string
, length
, encoding
, force_ellipses
,
481 /* rust_print_type branch for structs and untagged unions. */
484 val_print_struct (struct type
*type
, const gdb_byte
*valaddr
,
485 int embedded_offset
, CORE_ADDR address
, struct ui_file
*stream
,
486 int recurse
, const struct value
*val
,
487 const struct value_print_options
*options
)
491 int is_tuple
= rust_tuple_type_p (type
);
492 int is_tuple_struct
= !is_tuple
&& rust_tuple_struct_type_p (type
);
493 struct value_print_options opts
;
497 if (TYPE_TAG_NAME (type
) != NULL
)
498 fprintf_filtered (stream
, "%s", TYPE_TAG_NAME (type
));
500 if (TYPE_NFIELDS (type
) == 0)
503 if (TYPE_TAG_NAME (type
) != NULL
)
504 fputs_filtered (" ", stream
);
507 if (is_tuple
|| is_tuple_struct
)
508 fputs_filtered ("(", stream
);
510 fputs_filtered ("{", stream
);
516 for (i
= 0; i
< TYPE_NFIELDS (type
); ++i
)
518 if (field_is_static (&TYPE_FIELD (type
, i
)))
522 fputs_filtered (",", stream
);
524 if (options
->prettyformat
)
526 fputs_filtered ("\n", stream
);
527 print_spaces_filtered (2 + 2 * recurse
, stream
);
529 else if (!first_field
)
530 fputs_filtered (" ", stream
);
534 if (!is_tuple
&& !is_tuple_struct
)
536 fputs_filtered (TYPE_FIELD_NAME (type
, i
), stream
);
537 fputs_filtered (": ", stream
);
540 val_print (TYPE_FIELD_TYPE (type
, i
),
542 embedded_offset
+ TYPE_FIELD_BITPOS (type
, i
) / 8,
544 stream
, recurse
+ 1, val
, &opts
,
548 if (options
->prettyformat
)
550 fputs_filtered ("\n", stream
);
551 print_spaces_filtered (2 * recurse
, stream
);
554 if (is_tuple
|| is_tuple_struct
)
555 fputs_filtered (")", stream
);
557 fputs_filtered ("}", stream
);
560 static const struct generic_val_print_decorations rust_decorations
=
562 /* Complex isn't used in Rust, but we provide C-ish values just in
574 /* la_val_print implementation for Rust. */
577 rust_val_print (struct type
*type
, const gdb_byte
*valaddr
, int embedded_offset
,
578 CORE_ADDR address
, struct ui_file
*stream
, int recurse
,
579 const struct value
*val
,
580 const struct value_print_options
*options
)
582 type
= check_typedef (type
);
583 switch (TYPE_CODE (type
))
587 LONGEST low_bound
, high_bound
;
589 if (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_ARRAY
590 && rust_u8_type_p (TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (type
)))
591 && get_array_bounds (TYPE_TARGET_TYPE (type
), &low_bound
,
593 /* We have a pointer to a byte string, so just print
595 struct type
*elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
597 struct gdbarch
*arch
= get_type_arch (type
);
598 int unit_size
= gdbarch_addressable_memory_unit_size (arch
);
600 addr
= unpack_pointer (type
, valaddr
+ embedded_offset
* unit_size
);
601 if (options
->addressprint
)
603 fputs_filtered (paddress (arch
, addr
), stream
);
604 fputs_filtered (" ", stream
);
607 fputs_filtered ("b", stream
);
608 val_print_string (TYPE_TARGET_TYPE (elttype
), "ASCII", addr
,
609 high_bound
- low_bound
+ 1, stream
,
616 case TYPE_CODE_METHODPTR
:
617 case TYPE_CODE_MEMBERPTR
:
618 c_val_print (type
, valaddr
, embedded_offset
, address
, stream
,
619 recurse
, val
, options
);
623 /* Recognize the unit type. */
624 if (TYPE_UNSIGNED (type
) && TYPE_LENGTH (type
) == 0
625 && TYPE_NAME (type
) != NULL
&& strcmp (TYPE_NAME (type
), "()") == 0)
627 fputs_filtered ("()", stream
);
632 case TYPE_CODE_STRING
:
634 struct gdbarch
*arch
= get_type_arch (type
);
635 int unit_size
= gdbarch_addressable_memory_unit_size (arch
);
636 LONGEST low_bound
, high_bound
;
638 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
639 error (_("Could not determine the array bounds"));
641 /* If we see a plain TYPE_CODE_STRING, then we're printing a
642 byte string, hence the choice of "ASCII" as the
644 fputs_filtered ("b", stream
);
645 rust_printstr (stream
, TYPE_TARGET_TYPE (type
),
646 valaddr
+ embedded_offset
* unit_size
,
647 high_bound
- low_bound
+ 1, "ASCII", 0, options
);
651 case TYPE_CODE_ARRAY
:
653 LONGEST low_bound
, high_bound
;
655 if (get_array_bounds (type
, &low_bound
, &high_bound
)
656 && high_bound
- low_bound
+ 1 == 0)
657 fputs_filtered ("[]", stream
);
663 case TYPE_CODE_UNION
:
665 int j
, nfields
, first_field
, is_tuple
, start
;
666 struct type
*variant_type
;
667 struct disr_info disr
;
668 struct value_print_options opts
;
669 struct cleanup
*cleanup
;
671 /* Untagged unions are printed as if they are structs.
672 Since the field bit positions overlap in the debuginfo,
673 the code for printing a union is same as that for a struct,
674 the only difference is that the input type will have overlapping
676 if (rust_union_is_untagged (type
))
678 val_print_struct (type
, valaddr
, embedded_offset
, address
, stream
,
679 recurse
, val
, options
);
686 disr
= rust_get_disr_info (type
, valaddr
, embedded_offset
, address
,
688 cleanup
= make_cleanup (xfree
, disr
.name
);
690 if (disr
.is_encoded
&& disr
.field_no
== RUST_ENCODED_ENUM_HIDDEN
)
692 fprintf_filtered (stream
, "%s", disr
.name
);
697 variant_type
= TYPE_FIELD_TYPE (type
, disr
.field_no
);
698 nfields
= TYPE_NFIELDS (variant_type
);
700 is_tuple
= (disr
.is_encoded
701 ? rust_tuple_struct_type_p (variant_type
)
702 : rust_tuple_variant_type_p (variant_type
));
703 start
= disr
.is_encoded
? 0 : 1;
707 /* In case of a non-nullary variant, we output 'Foo(x,y,z)'. */
709 fprintf_filtered (stream
, "%s(", disr
.name
);
712 /* struct variant. */
713 fprintf_filtered (stream
, "%s{", disr
.name
);
718 /* In case of a nullary variant like 'None', just output
720 fprintf_filtered (stream
, "%s", disr
.name
);
724 for (j
= start
; j
< TYPE_NFIELDS (variant_type
); j
++)
727 fputs_filtered (", ", stream
);
731 fprintf_filtered (stream
, "%s: ",
732 TYPE_FIELD_NAME (variant_type
, j
));
734 val_print (TYPE_FIELD_TYPE (variant_type
, j
),
737 + TYPE_FIELD_BITPOS (type
, disr
.field_no
) / 8
738 + TYPE_FIELD_BITPOS (variant_type
, j
) / 8),
740 stream
, recurse
+ 1, val
, &opts
,
745 fputs_filtered (")", stream
);
747 fputs_filtered ("}", stream
);
750 do_cleanups (cleanup
);
754 case TYPE_CODE_STRUCT
:
755 val_print_struct (type
, valaddr
, embedded_offset
, address
, stream
,
756 recurse
, val
, options
);
761 /* Nothing special yet. */
762 generic_val_print (type
, valaddr
, embedded_offset
, address
, stream
,
763 recurse
, val
, options
, &rust_decorations
);
770 rust_print_type (struct type
*type
, const char *varstring
,
771 struct ui_file
*stream
, int show
, int level
,
772 const struct type_print_options
*flags
);
774 /* Print a struct or union typedef. */
776 rust_print_struct_def (struct type
*type
, const char *varstring
,
777 struct ui_file
*stream
, int show
, int level
,
778 const struct type_print_options
*flags
)
780 int is_tuple_struct
, i
;
782 /* Print a tuple type simply. */
783 if (rust_tuple_type_p (type
))
785 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
789 /* If we see a base class, delegate to C. */
790 if (TYPE_N_BASECLASSES (type
) > 0)
791 c_print_type (type
, varstring
, stream
, show
, level
, flags
);
793 /* This code path is also used by unions. */
794 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
795 fputs_filtered ("struct ", stream
);
797 fputs_filtered ("union ", stream
);
799 if (TYPE_TAG_NAME (type
) != NULL
)
800 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
802 is_tuple_struct
= rust_tuple_struct_type_p (type
);
804 if (TYPE_NFIELDS (type
) == 0 && !rust_tuple_type_p (type
))
806 fputs_filtered (is_tuple_struct
? " (\n" : " {\n", stream
);
808 for (i
= 0; i
< TYPE_NFIELDS (type
); ++i
)
813 if (field_is_static (&TYPE_FIELD (type
, i
)))
816 /* We'd like to print "pub" here as needed, but rustc
817 doesn't emit the debuginfo, and our types don't have
818 cplus_struct_type attached. */
820 /* For a tuple struct we print the type but nothing
822 print_spaces_filtered (level
+ 2, stream
);
823 if (!is_tuple_struct
)
824 fprintf_filtered (stream
, "%s: ", TYPE_FIELD_NAME (type
, i
));
826 rust_print_type (TYPE_FIELD_TYPE (type
, i
), NULL
,
827 stream
, show
- 1, level
+ 2,
829 fputs_filtered (",\n", stream
);
832 fprintfi_filtered (level
, stream
, is_tuple_struct
? ")" : "}");
835 /* la_print_typedef implementation for Rust. */
838 rust_print_typedef (struct type
*type
,
839 struct symbol
*new_symbol
,
840 struct ui_file
*stream
)
842 type
= check_typedef (type
);
843 fprintf_filtered (stream
, "type %s = ", SYMBOL_PRINT_NAME (new_symbol
));
844 type_print (type
, "", stream
, 0);
845 fprintf_filtered (stream
, ";\n");
848 /* la_print_type implementation for Rust. */
851 rust_print_type (struct type
*type
, const char *varstring
,
852 struct ui_file
*stream
, int show
, int level
,
853 const struct type_print_options
*flags
)
859 && TYPE_NAME (type
) != NULL
)
861 /* Rust calls the unit type "void" in its debuginfo,
862 but we don't want to print it as that. */
863 if (TYPE_CODE (type
) == TYPE_CODE_VOID
)
864 fputs_filtered ("()", stream
);
866 fputs_filtered (TYPE_NAME (type
), stream
);
870 type
= check_typedef (type
);
871 switch (TYPE_CODE (type
))
874 fputs_filtered ("()", stream
);
878 /* Delegate varargs to the C printer. */
879 if (TYPE_VARARGS (type
))
882 fputs_filtered ("fn ", stream
);
883 if (varstring
!= NULL
)
884 fputs_filtered (varstring
, stream
);
885 fputs_filtered ("(", stream
);
886 for (i
= 0; i
< TYPE_NFIELDS (type
); ++i
)
890 fputs_filtered (", ", stream
);
891 rust_print_type (TYPE_FIELD_TYPE (type
, i
), "", stream
, -1, 0,
894 fputs_filtered (")", stream
);
895 /* If it returns unit, we can omit the return type. */
896 if (TYPE_CODE (TYPE_TARGET_TYPE (type
)) != TYPE_CODE_VOID
)
898 fputs_filtered (" -> ", stream
);
899 rust_print_type (TYPE_TARGET_TYPE (type
), "", stream
, -1, 0, flags
);
903 case TYPE_CODE_ARRAY
:
905 LONGEST low_bound
, high_bound
;
907 fputs_filtered ("[", stream
);
908 rust_print_type (TYPE_TARGET_TYPE (type
), NULL
,
909 stream
, show
- 1, level
, flags
);
910 fputs_filtered ("; ", stream
);
912 if (TYPE_HIGH_BOUND_KIND (TYPE_INDEX_TYPE (type
)) == PROP_LOCEXPR
913 || TYPE_HIGH_BOUND_KIND (TYPE_INDEX_TYPE (type
)) == PROP_LOCLIST
)
914 fprintf_filtered (stream
, "variable length");
915 else if (get_array_bounds (type
, &low_bound
, &high_bound
))
916 fprintf_filtered (stream
, "%s",
917 plongest (high_bound
- low_bound
+ 1));
918 fputs_filtered ("]", stream
);
922 case TYPE_CODE_STRUCT
:
923 rust_print_struct_def (type
, varstring
, stream
, show
, level
, flags
);
930 fputs_filtered ("enum ", stream
);
931 if (TYPE_TAG_NAME (type
) != NULL
)
933 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
934 fputs_filtered (" ", stream
);
935 len
= strlen (TYPE_TAG_NAME (type
));
937 fputs_filtered ("{\n", stream
);
939 for (i
= 0; i
< TYPE_NFIELDS (type
); ++i
)
941 const char *name
= TYPE_FIELD_NAME (type
, i
);
946 && strncmp (name
, TYPE_TAG_NAME (type
), len
) == 0
948 && name
[len
+ 1] == ':')
950 fprintfi_filtered (level
+ 2, stream
, "%s,\n", name
);
953 fputs_filtered ("}", stream
);
957 case TYPE_CODE_UNION
:
961 /* Skip the discriminant field. */
964 /* Unions and structs have the same syntax in Rust,
965 the only difference is that structs are declared with `struct`
966 and union with `union`. This difference is handled in the struct
968 if (rust_union_is_untagged (type
))
970 rust_print_struct_def (type
, varstring
, stream
, show
, level
, flags
);
974 fputs_filtered ("enum ", stream
);
975 if (TYPE_TAG_NAME (type
) != NULL
)
977 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
978 fputs_filtered (" ", stream
);
980 fputs_filtered ("{\n", stream
);
982 if (strncmp (TYPE_FIELD_NAME (type
, 0), RUST_ENUM_PREFIX
,
983 strlen (RUST_ENUM_PREFIX
)) == 0)
985 const char *zero_field
= strrchr (TYPE_FIELD_NAME (type
, 0), '$');
986 if (zero_field
!= NULL
&& strlen (zero_field
) > 1)
988 fprintfi_filtered (level
+ 2, stream
, "%s,\n", zero_field
+ 1);
989 /* There is no explicit discriminant field, skip nothing. */
994 for (i
= 0; i
< TYPE_NFIELDS (type
); ++i
)
996 struct type
*variant_type
= TYPE_FIELD_TYPE (type
, i
);
998 = rust_last_path_segment (TYPE_NAME (variant_type
));
1000 fprintfi_filtered (level
+ 2, stream
, "%s", name
);
1002 if (TYPE_NFIELDS (variant_type
) > skip_to
)
1005 int is_tuple
= rust_tuple_variant_type_p (variant_type
);
1008 fputs_filtered (is_tuple
? "(" : "{", stream
);
1009 for (j
= skip_to
; j
< TYPE_NFIELDS (variant_type
); j
++)
1014 fputs_filtered (", ", stream
);
1017 fprintf_filtered (stream
, "%s: ",
1018 TYPE_FIELD_NAME (variant_type
, j
));
1020 rust_print_type (TYPE_FIELD_TYPE (variant_type
, j
), NULL
,
1021 stream
, show
- 1, level
+ 2,
1024 fputs_filtered (is_tuple
? ")" : "}", stream
);
1027 fputs_filtered (",\n", stream
);
1030 fputs_filtered ("}", stream
);
1036 c_print_type (type
, varstring
, stream
, show
, level
, flags
);
1042 /* Compute the alignment of the type T. */
1045 rust_type_alignment (struct type
*t
)
1047 t
= check_typedef (t
);
1048 switch (TYPE_CODE (t
))
1051 error (_("Could not compute alignment of type"));
1054 case TYPE_CODE_ENUM
:
1058 case TYPE_CODE_CHAR
:
1059 case TYPE_CODE_BOOL
:
1060 return TYPE_LENGTH (t
);
1062 case TYPE_CODE_ARRAY
:
1063 case TYPE_CODE_COMPLEX
:
1064 return rust_type_alignment (TYPE_TARGET_TYPE (t
));
1066 case TYPE_CODE_STRUCT
:
1067 case TYPE_CODE_UNION
:
1072 for (i
= 0; i
< TYPE_NFIELDS (t
); ++i
)
1074 int a
= rust_type_alignment (TYPE_FIELD_TYPE (t
, i
));
1083 /* Like arch_composite_type, but uses TYPE to decide how to allocate
1084 -- either on an obstack or on a gdbarch. */
1086 static struct type
*
1087 rust_composite_type (struct type
*original
,
1089 const char *field1
, struct type
*type1
,
1090 const char *field2
, struct type
*type2
)
1092 struct type
*result
= alloc_type_copy (original
);
1093 int i
, nfields
, bitpos
;
1101 TYPE_CODE (result
) = TYPE_CODE_STRUCT
;
1102 TYPE_NAME (result
) = name
;
1103 TYPE_TAG_NAME (result
) = name
;
1105 TYPE_NFIELDS (result
) = nfields
;
1106 TYPE_FIELDS (result
)
1107 = (struct field
*) TYPE_ZALLOC (result
, nfields
* sizeof (struct field
));
1113 struct field
*field
= &TYPE_FIELD (result
, i
);
1115 SET_FIELD_BITPOS (*field
, bitpos
);
1116 bitpos
+= TYPE_LENGTH (type1
) * TARGET_CHAR_BIT
;
1118 FIELD_NAME (*field
) = field1
;
1119 FIELD_TYPE (*field
) = type1
;
1124 struct field
*field
= &TYPE_FIELD (result
, i
);
1125 int align
= rust_type_alignment (type2
);
1131 align
*= TARGET_CHAR_BIT
;
1132 delta
= bitpos
% align
;
1134 bitpos
+= align
- delta
;
1136 SET_FIELD_BITPOS (*field
, bitpos
);
1138 FIELD_NAME (*field
) = field2
;
1139 FIELD_TYPE (*field
) = type2
;
1144 TYPE_LENGTH (result
)
1145 = (TYPE_FIELD_BITPOS (result
, i
- 1) / TARGET_CHAR_BIT
+
1146 TYPE_LENGTH (TYPE_FIELD_TYPE (result
, i
- 1)));
1150 /* See rust-lang.h. */
1153 rust_slice_type (const char *name
, struct type
*elt_type
,
1154 struct type
*usize_type
)
1158 elt_type
= lookup_pointer_type (elt_type
);
1159 type
= rust_composite_type (elt_type
, name
,
1160 "data_ptr", elt_type
,
1161 "length", usize_type
);
1166 enum rust_primitive_types
1168 rust_primitive_bool
,
1169 rust_primitive_char
,
1178 rust_primitive_isize
,
1179 rust_primitive_usize
,
1182 rust_primitive_unit
,
1184 nr_rust_primitive_types
1187 /* la_language_arch_info implementation for Rust. */
1190 rust_language_arch_info (struct gdbarch
*gdbarch
,
1191 struct language_arch_info
*lai
)
1193 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
1195 struct type
**types
;
1196 unsigned int length
;
1198 types
= GDBARCH_OBSTACK_CALLOC (gdbarch
, nr_rust_primitive_types
+ 1,
1201 types
[rust_primitive_bool
] = arch_boolean_type (gdbarch
, 8, 1, "bool");
1202 types
[rust_primitive_char
] = arch_character_type (gdbarch
, 32, 1, "char");
1203 types
[rust_primitive_i8
] = arch_integer_type (gdbarch
, 8, 0, "i8");
1204 types
[rust_primitive_u8
] = arch_integer_type (gdbarch
, 8, 1, "u8");
1205 types
[rust_primitive_i16
] = arch_integer_type (gdbarch
, 16, 0, "i16");
1206 types
[rust_primitive_u16
] = arch_integer_type (gdbarch
, 16, 1, "u16");
1207 types
[rust_primitive_i32
] = arch_integer_type (gdbarch
, 32, 0, "i32");
1208 types
[rust_primitive_u32
] = arch_integer_type (gdbarch
, 32, 1, "u32");
1209 types
[rust_primitive_i64
] = arch_integer_type (gdbarch
, 64, 0, "i64");
1210 types
[rust_primitive_u64
] = arch_integer_type (gdbarch
, 64, 1, "u64");
1212 length
= 8 * TYPE_LENGTH (builtin
->builtin_data_ptr
);
1213 types
[rust_primitive_isize
] = arch_integer_type (gdbarch
, length
, 0, "isize");
1214 types
[rust_primitive_usize
] = arch_integer_type (gdbarch
, length
, 1, "usize");
1216 types
[rust_primitive_f32
] = arch_float_type (gdbarch
, 32, "f32",
1217 floatformats_ieee_single
);
1218 types
[rust_primitive_f64
] = arch_float_type (gdbarch
, 64, "f64",
1219 floatformats_ieee_double
);
1221 types
[rust_primitive_unit
] = arch_integer_type (gdbarch
, 0, 1, "()");
1223 tem
= make_cv_type (1, 0, types
[rust_primitive_u8
], NULL
);
1224 types
[rust_primitive_str
] = rust_slice_type ("&str", tem
,
1225 types
[rust_primitive_usize
]);
1227 lai
->primitive_type_vector
= types
;
1228 lai
->bool_type_default
= types
[rust_primitive_bool
];
1229 lai
->string_char_type
= types
[rust_primitive_u8
];
1234 /* A helper for rust_evaluate_subexp that handles OP_FUNCALL. */
1236 static struct value
*
1237 rust_evaluate_funcall (struct expression
*exp
, int *pos
, enum noside noside
)
1240 int num_args
= exp
->elts
[*pos
+ 1].longconst
;
1242 struct value
*function
, *result
, *arg0
;
1243 struct type
*type
, *fn_type
;
1244 const struct block
*block
;
1245 struct block_symbol sym
;
1247 /* For an ordinary function call we can simply defer to the
1248 generic implementation. */
1249 if (exp
->elts
[*pos
+ 3].opcode
!= STRUCTOP_STRUCT
)
1250 return evaluate_subexp_standard (NULL
, exp
, pos
, noside
);
1252 /* Skip over the OP_FUNCALL and the STRUCTOP_STRUCT. */
1254 method
= &exp
->elts
[*pos
+ 1].string
;
1255 *pos
+= 3 + BYTES_TO_EXP_ELEM (exp
->elts
[*pos
].longconst
+ 1);
1257 /* Evaluate the argument to STRUCTOP_STRUCT, then find its
1258 type in order to look up the method. */
1259 arg0
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1261 if (noside
== EVAL_SKIP
)
1263 for (i
= 0; i
< num_args
; ++i
)
1264 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1268 std::vector
<struct value
*> args (num_args
+ 1);
1271 /* We don't yet implement real Deref semantics. */
1272 while (TYPE_CODE (value_type (args
[0])) == TYPE_CODE_PTR
)
1273 args
[0] = value_ind (args
[0]);
1275 type
= value_type (args
[0]);
1276 if ((TYPE_CODE (type
) != TYPE_CODE_STRUCT
1277 && TYPE_CODE (type
) != TYPE_CODE_UNION
1278 && TYPE_CODE (type
) != TYPE_CODE_ENUM
)
1279 || rust_tuple_type_p (type
))
1280 error (_("Method calls only supported on struct or enum types"));
1281 if (TYPE_TAG_NAME (type
) == NULL
)
1282 error (_("Method call on nameless type"));
1284 std::string name
= std::string (TYPE_TAG_NAME (type
)) + "::" + method
;
1286 block
= get_selected_block (0);
1287 sym
= lookup_symbol (name
.c_str (), block
, VAR_DOMAIN
, NULL
);
1288 if (sym
.symbol
== NULL
)
1289 error (_("Could not find function named '%s'"), name
.c_str ());
1291 fn_type
= SYMBOL_TYPE (sym
.symbol
);
1292 if (TYPE_NFIELDS (fn_type
) == 0)
1293 error (_("Function '%s' takes no arguments"), name
.c_str ());
1295 if (TYPE_CODE (TYPE_FIELD_TYPE (fn_type
, 0)) == TYPE_CODE_PTR
)
1296 args
[0] = value_addr (args
[0]);
1298 function
= address_of_variable (sym
.symbol
, block
);
1300 for (i
= 0; i
< num_args
; ++i
)
1301 args
[i
+ 1] = evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1303 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1304 result
= value_zero (TYPE_TARGET_TYPE (fn_type
), not_lval
);
1306 result
= call_function_by_hand (function
, num_args
+ 1, args
.data ());
1310 /* A helper for rust_evaluate_subexp that handles OP_RANGE. */
1312 static struct value
*
1313 rust_range (struct expression
*exp
, int *pos
, enum noside noside
)
1315 enum range_type kind
;
1316 struct value
*low
= NULL
, *high
= NULL
;
1317 struct value
*addrval
, *result
;
1319 struct type
*range_type
;
1320 struct type
*index_type
;
1321 struct type
*temp_type
;
1324 kind
= (enum range_type
) longest_to_int (exp
->elts
[*pos
+ 1].longconst
);
1327 if (kind
== HIGH_BOUND_DEFAULT
|| kind
== NONE_BOUND_DEFAULT
)
1328 low
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1329 if (kind
== LOW_BOUND_DEFAULT
|| kind
== NONE_BOUND_DEFAULT
)
1330 high
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1332 if (noside
== EVAL_SKIP
)
1333 return value_from_longest (builtin_type (exp
->gdbarch
)->builtin_int
, 1);
1340 name
= "std::ops::RangeFull";
1344 index_type
= value_type (high
);
1345 name
= "std::ops::RangeTo";
1352 index_type
= value_type (low
);
1353 name
= "std::ops::RangeFrom";
1357 if (!types_equal (value_type (low
), value_type (high
)))
1358 error (_("Range expression with different types"));
1359 index_type
= value_type (low
);
1360 name
= "std::ops::Range";
1364 /* If we don't have an index type, just allocate this on the
1365 arch. Here any type will do. */
1366 temp_type
= (index_type
== NULL
1367 ? language_bool_type (exp
->language_defn
, exp
->gdbarch
)
1369 /* It would be nicer to cache the range type. */
1370 range_type
= rust_composite_type (temp_type
, name
,
1371 low
== NULL
? NULL
: "start", index_type
,
1372 high
== NULL
? NULL
: "end", index_type
);
1374 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1375 return value_zero (range_type
, lval_memory
);
1377 addrval
= value_allocate_space_in_inferior (TYPE_LENGTH (range_type
));
1378 addr
= value_as_long (addrval
);
1379 result
= value_at_lazy (range_type
, addr
);
1383 struct value
*start
= value_struct_elt (&result
, NULL
, "start", NULL
,
1386 value_assign (start
, low
);
1391 struct value
*end
= value_struct_elt (&result
, NULL
, "end", NULL
,
1394 value_assign (end
, high
);
1397 result
= value_at_lazy (range_type
, addr
);
1401 /* A helper function to compute the range and kind given a range
1402 value. TYPE is the type of the range value. RANGE is the range
1403 value. LOW, HIGH, and KIND are out parameters. The LOW and HIGH
1404 parameters might be filled in, or might not be, depending on the
1405 kind of range this is. KIND will always be set to the appropriate
1406 value describing the kind of range, and this can be used to
1407 determine whether LOW or HIGH are valid. */
1410 rust_compute_range (struct type
*type
, struct value
*range
,
1411 LONGEST
*low
, LONGEST
*high
,
1412 enum range_type
*kind
)
1418 *kind
= BOTH_BOUND_DEFAULT
;
1420 if (TYPE_NFIELDS (type
) == 0)
1424 if (strcmp (TYPE_FIELD_NAME (type
, 0), "start") == 0)
1426 *kind
= HIGH_BOUND_DEFAULT
;
1427 *low
= value_as_long (value_field (range
, 0));
1430 if (TYPE_NFIELDS (type
) > i
1431 && strcmp (TYPE_FIELD_NAME (type
, i
), "end") == 0)
1433 *kind
= (*kind
== BOTH_BOUND_DEFAULT
1434 ? LOW_BOUND_DEFAULT
: NONE_BOUND_DEFAULT
);
1435 *high
= value_as_long (value_field (range
, i
));
1439 /* A helper for rust_evaluate_subexp that handles BINOP_SUBSCRIPT. */
1441 static struct value
*
1442 rust_subscript (struct expression
*exp
, int *pos
, enum noside noside
,
1445 struct value
*lhs
, *rhs
, *result
;
1446 struct type
*rhstype
;
1447 LONGEST low
, high_bound
;
1448 /* Initialized to appease the compiler. */
1449 enum range_type kind
= BOTH_BOUND_DEFAULT
;
1454 lhs
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1455 rhs
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1457 if (noside
== EVAL_SKIP
)
1460 rhstype
= check_typedef (value_type (rhs
));
1461 if (rust_range_type_p (rhstype
))
1464 error (_("Can't take slice of array without '&'"));
1465 rust_compute_range (rhstype
, rhs
, &low
, &high
, &kind
);
1469 low
= value_as_long (rhs
);
1471 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1473 struct type
*type
= check_typedef (value_type (lhs
));
1475 result
= value_zero (TYPE_TARGET_TYPE (type
), VALUE_LVAL (lhs
));
1481 struct type
*type
= check_typedef (value_type (lhs
));
1483 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
1486 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
1487 error (_("Can't compute array bounds"));
1489 error (_("Found array with non-zero lower bound"));
1492 else if (rust_slice_type_p (type
))
1496 base
= value_struct_elt (&lhs
, NULL
, "data_ptr", NULL
, "slice");
1497 len
= value_struct_elt (&lhs
, NULL
, "length", NULL
, "slice");
1499 high_bound
= value_as_long (len
);
1501 else if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
1505 high_bound
= LONGEST_MAX
;
1508 error (_("Cannot subscript non-array type"));
1511 && (kind
== BOTH_BOUND_DEFAULT
|| kind
== LOW_BOUND_DEFAULT
))
1514 error (_("Index less than zero"));
1515 if (low
> high_bound
)
1516 error (_("Index greater than length"));
1518 result
= value_subscript (base
, low
);
1525 struct type
*usize
, *slice
;
1527 struct value
*addrval
, *tem
;
1529 if (kind
== BOTH_BOUND_DEFAULT
|| kind
== HIGH_BOUND_DEFAULT
)
1532 error (_("High index less than zero"));
1534 error (_("Low index greater than high index"));
1535 if (high
> high_bound
)
1536 error (_("High index greater than length"));
1538 usize
= language_lookup_primitive_type (exp
->language_defn
,
1541 slice
= rust_slice_type ("&[*gdb*]", value_type (result
),
1544 addrval
= value_allocate_space_in_inferior (TYPE_LENGTH (slice
));
1545 addr
= value_as_long (addrval
);
1546 tem
= value_at_lazy (slice
, addr
);
1548 value_assign (value_field (tem
, 0), value_addr (result
));
1549 value_assign (value_field (tem
, 1),
1550 value_from_longest (usize
, high
- low
));
1552 result
= value_at_lazy (slice
, addr
);
1555 result
= value_addr (result
);
1561 /* evaluate_exp implementation for Rust. */
1563 static struct value
*
1564 rust_evaluate_subexp (struct type
*expect_type
, struct expression
*exp
,
1565 int *pos
, enum noside noside
)
1567 struct value
*result
;
1569 switch (exp
->elts
[*pos
].opcode
)
1571 case UNOP_COMPLEMENT
:
1573 struct value
*value
;
1576 value
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1577 if (noside
== EVAL_SKIP
)
1579 /* Preserving the type is enough. */
1582 if (TYPE_CODE (value_type (value
)) == TYPE_CODE_BOOL
)
1583 result
= value_from_longest (value_type (value
),
1584 value_logical_not (value
));
1586 result
= value_complement (value
);
1590 case BINOP_SUBSCRIPT
:
1591 result
= rust_subscript (exp
, pos
, noside
, 0);
1595 result
= rust_evaluate_funcall (exp
, pos
, noside
);
1601 struct type
*type
= exp
->elts
[pc
+ 1].type
;
1602 int arglen
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
1605 struct value
*addrval
= NULL
;
1609 if (noside
== EVAL_NORMAL
)
1611 addrval
= value_allocate_space_in_inferior (TYPE_LENGTH (type
));
1612 addr
= value_as_long (addrval
);
1613 result
= value_at_lazy (type
, addr
);
1616 if (arglen
> 0 && exp
->elts
[*pos
].opcode
== OP_OTHERS
)
1621 init
= rust_evaluate_subexp (NULL
, exp
, pos
, noside
);
1622 if (noside
== EVAL_NORMAL
)
1624 /* This isn't quite right but will do for the time
1625 being, seeing that we can't implement the Copy
1627 value_assign (result
, init
);
1633 gdb_assert (arglen
% 2 == 0);
1634 for (i
= 0; i
< arglen
; i
+= 2)
1637 const char *fieldname
;
1638 struct value
*value
, *field
;
1640 gdb_assert (exp
->elts
[*pos
].opcode
== OP_NAME
);
1642 len
= longest_to_int (exp
->elts
[*pos
].longconst
);
1644 fieldname
= &exp
->elts
[*pos
].string
;
1645 *pos
+= 2 + BYTES_TO_EXP_ELEM (len
+ 1);
1647 value
= rust_evaluate_subexp (NULL
, exp
, pos
, noside
);
1648 if (noside
== EVAL_NORMAL
)
1650 field
= value_struct_elt (&result
, NULL
, fieldname
, NULL
,
1652 value_assign (field
, value
);
1656 if (noside
== EVAL_SKIP
)
1657 return value_from_longest (builtin_type (exp
->gdbarch
)->builtin_int
,
1659 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1660 result
= allocate_value (type
);
1662 result
= value_at_lazy (type
, addr
);
1671 struct value
*ncopies
;
1673 elt
= rust_evaluate_subexp (NULL
, exp
, pos
, noside
);
1674 ncopies
= rust_evaluate_subexp (NULL
, exp
, pos
, noside
);
1675 copies
= value_as_long (ncopies
);
1677 error (_("Array with negative number of elements"));
1679 if (noside
== EVAL_NORMAL
)
1683 std::vector
<struct value
*> eltvec (copies
);
1685 for (i
= 0; i
< copies
; ++i
)
1687 result
= value_array (0, copies
- 1, eltvec
.data ());
1691 struct type
*arraytype
1692 = lookup_array_range_type (value_type (elt
), 0, copies
- 1);
1693 result
= allocate_value (arraytype
);
1698 case STRUCTOP_ANONYMOUS
:
1700 /* Anonymous field access, i.e. foo.1. */
1702 int pc
, field_number
, nfields
;
1703 struct type
*type
, *variant_type
;
1704 struct disr_info disr
;
1707 field_number
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1709 lhs
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1711 type
= value_type (lhs
);
1712 /* Untagged unions can't have anonymous field access since
1713 they can only have named fields. */
1714 if (TYPE_CODE (type
) == TYPE_CODE_UNION
1715 && !rust_union_is_untagged (type
))
1717 struct cleanup
*cleanup
;
1719 disr
= rust_get_disr_info (type
, value_contents (lhs
),
1720 value_embedded_offset (lhs
),
1721 value_address (lhs
), lhs
);
1723 cleanup
= make_cleanup (xfree
, disr
.name
);
1725 if (disr
.is_encoded
&& disr
.field_no
== RUST_ENCODED_ENUM_HIDDEN
)
1727 variant_type
= NULL
;
1732 variant_type
= TYPE_FIELD_TYPE (type
, disr
.field_no
);
1733 nfields
= TYPE_NFIELDS (variant_type
);
1736 if (!disr
.is_encoded
)
1739 if (field_number
>= nfields
|| field_number
< 0)
1740 error(_("Cannot access field %d of variant %s, \
1741 there are only %d fields"),
1742 disr
.is_encoded
? field_number
: field_number
- 1,
1744 disr
.is_encoded
? nfields
: nfields
- 1);
1746 if (!(disr
.is_encoded
1747 ? rust_tuple_struct_type_p (variant_type
)
1748 : rust_tuple_variant_type_p (variant_type
)))
1749 error(_("Variant %s is not a tuple variant"), disr
.name
);
1751 result
= value_primitive_field (lhs
, 0, field_number
,
1753 do_cleanups (cleanup
);
1755 else if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
1757 /* Tuples and tuple structs */
1758 nfields
= TYPE_NFIELDS(type
);
1760 if (field_number
>= nfields
|| field_number
< 0)
1761 error(_("Cannot access field %d of %s, there are only %d fields"),
1762 field_number
, TYPE_TAG_NAME (type
), nfields
);
1764 /* Tuples are tuple structs too. */
1765 if (!rust_tuple_struct_type_p (type
))
1766 error(_("Attempting to access anonymous field %d of %s, which is \
1767 not a tuple, tuple struct, or tuple-like variant"),
1768 field_number
, TYPE_TAG_NAME (type
));
1770 result
= value_primitive_field (lhs
, 0, field_number
, type
);
1773 error(_("Anonymous field access is only allowed on tuples, \
1774 tuple structs, and tuple-like enum variants"));
1778 case STRUCTOP_STRUCT
:
1785 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1786 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1787 lhs
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1789 type
= value_type (lhs
);
1790 if (TYPE_CODE (type
) == TYPE_CODE_UNION
1791 && !rust_union_is_untagged (type
))
1794 struct disr_info disr
;
1795 struct cleanup
* cleanup
;
1796 struct type
* variant_type
;
1799 field_name
= &exp
->elts
[pc
+ 2].string
;
1801 disr
= rust_get_disr_info (type
, value_contents (lhs
),
1802 value_embedded_offset (lhs
),
1803 value_address (lhs
), lhs
);
1805 cleanup
= make_cleanup (xfree
, disr
.name
);
1807 if (disr
.is_encoded
&& disr
.field_no
== RUST_ENCODED_ENUM_HIDDEN
)
1808 error(_("Could not find field %s of struct variant %s"),
1809 field_name
, disr
.name
);
1811 variant_type
= TYPE_FIELD_TYPE (type
, disr
.field_no
);
1813 if (variant_type
== NULL
1815 ? rust_tuple_struct_type_p (variant_type
)
1816 : rust_tuple_variant_type_p (variant_type
)))
1817 error(_("Attempting to access named field %s of tuple variant %s, \
1818 which has only anonymous fields"),
1819 field_name
, disr
.name
);
1821 start
= disr
.is_encoded
? 0 : 1;
1822 for (i
= start
; i
< TYPE_NFIELDS (variant_type
); i
++)
1824 if (strcmp (TYPE_FIELD_NAME (variant_type
, i
),
1826 result
= value_primitive_field (lhs
, 0, i
, variant_type
);
1831 if (i
== TYPE_NFIELDS (variant_type
))
1832 /* We didn't find it. */
1833 error(_("Could not find field %s of struct variant %s"),
1834 field_name
, disr
.name
);
1836 do_cleanups (cleanup
);
1840 /* Field access in structs and untagged unions works like C. */
1842 result
= evaluate_subexp_standard (expect_type
, exp
, pos
, noside
);
1848 result
= rust_range (exp
, pos
, noside
);
1852 /* We might have &array[range], in which case we need to make a
1854 if (exp
->elts
[*pos
+ 1].opcode
== BINOP_SUBSCRIPT
)
1857 result
= rust_subscript (exp
, pos
, noside
, 1);
1862 result
= evaluate_subexp_standard (expect_type
, exp
, pos
, noside
);
1869 /* operator_length implementation for Rust. */
1872 rust_operator_length (const struct expression
*exp
, int pc
, int *oplenp
,
1878 switch (exp
->elts
[pc
- 1].opcode
)
1881 /* We handle aggregate as a type and argument count. The first
1882 argument might be OP_OTHERS. After that the arguments
1883 alternate: first an OP_NAME, then an expression. */
1885 args
= longest_to_int (exp
->elts
[pc
- 2].longconst
);
1893 case STRUCTOP_ANONYMOUS
:
1904 operator_length_standard (exp
, pc
, oplenp
, argsp
);
1912 /* op_name implementation for Rust. */
1915 rust_op_name (enum exp_opcode opcode
)
1920 return "OP_AGGREGATE";
1924 return op_name_standard (opcode
);
1928 /* dump_subexp_body implementation for Rust. */
1931 rust_dump_subexp_body (struct expression
*exp
, struct ui_file
*stream
,
1934 switch (exp
->elts
[elt
].opcode
)
1938 int length
= longest_to_int (exp
->elts
[elt
+ 2].longconst
);
1941 fprintf_filtered (stream
, "Type @");
1942 gdb_print_host_address (exp
->elts
[elt
+ 1].type
, stream
);
1943 fprintf_filtered (stream
, " (");
1944 type_print (exp
->elts
[elt
+ 1].type
, NULL
, stream
, 0);
1945 fprintf_filtered (stream
, "), length %d", length
);
1948 for (i
= 0; i
< length
; ++i
)
1949 elt
= dump_subexp (exp
, stream
, elt
);
1956 LONGEST len
= exp
->elts
[elt
+ 1].longconst
;
1958 fprintf_filtered (stream
, "%s: %s",
1959 (exp
->elts
[elt
].opcode
== OP_STRING
1960 ? "string" : "name"),
1961 &exp
->elts
[elt
+ 2].string
);
1962 elt
+= 4 + BYTES_TO_EXP_ELEM (len
+ 1);
1967 elt
= dump_subexp (exp
, stream
, elt
+ 1);
1970 case STRUCTOP_ANONYMOUS
:
1974 field_number
= longest_to_int (exp
->elts
[elt
].longconst
);
1976 fprintf_filtered (stream
, "Field number: %d", field_number
);
1977 elt
= dump_subexp (exp
, stream
, elt
+ 2);
1985 elt
= dump_subexp_body_standard (exp
, stream
, elt
);
1992 /* print_subexp implementation for Rust. */
1995 rust_print_subexp (struct expression
*exp
, int *pos
, struct ui_file
*stream
,
1996 enum precedence prec
)
1998 switch (exp
->elts
[*pos
].opcode
)
2002 int length
= longest_to_int (exp
->elts
[*pos
+ 2].longconst
);
2005 type_print (exp
->elts
[*pos
+ 1].type
, "", stream
, 0);
2006 fputs_filtered (" { ", stream
);
2009 for (i
= 0; i
< length
; ++i
)
2011 rust_print_subexp (exp
, pos
, stream
, prec
);
2012 fputs_filtered (", ", stream
);
2014 fputs_filtered (" }", stream
);
2020 LONGEST len
= exp
->elts
[*pos
+ 1].longconst
;
2022 fputs_filtered (&exp
->elts
[*pos
+ 2].string
, stream
);
2023 *pos
+= 4 + BYTES_TO_EXP_ELEM (len
+ 1);
2029 fputs_filtered ("<<others>> (", stream
);
2031 rust_print_subexp (exp
, pos
, stream
, prec
);
2032 fputs_filtered (")", stream
);
2036 case STRUCTOP_ANONYMOUS
:
2038 int tem
= longest_to_int (exp
->elts
[*pos
+ 1].longconst
);
2041 print_subexp (exp
, pos
, stream
, PREC_SUFFIX
);
2042 fprintf_filtered (stream
, ".%d", tem
);
2048 fprintf_filtered (stream
, "[");
2049 rust_print_subexp (exp
, pos
, stream
, prec
);
2050 fprintf_filtered (stream
, "; ");
2051 rust_print_subexp (exp
, pos
, stream
, prec
);
2052 fprintf_filtered (stream
, "]");
2056 print_subexp_standard (exp
, pos
, stream
, prec
);
2061 /* operator_check implementation for Rust. */
2064 rust_operator_check (struct expression
*exp
, int pos
,
2065 int (*objfile_func
) (struct objfile
*objfile
,
2069 switch (exp
->elts
[pos
].opcode
)
2073 struct type
*type
= exp
->elts
[pos
+ 1].type
;
2074 struct objfile
*objfile
= TYPE_OBJFILE (type
);
2076 if (objfile
!= NULL
&& (*objfile_func
) (objfile
, data
))
2087 return operator_check_standard (exp
, pos
, objfile_func
, data
);
2095 /* Implementation of la_lookup_symbol_nonlocal for Rust. */
2097 static struct block_symbol
2098 rust_lookup_symbol_nonlocal (const struct language_defn
*langdef
,
2100 const struct block
*block
,
2101 const domain_enum domain
)
2103 struct block_symbol result
= {NULL
, NULL
};
2105 if (symbol_lookup_debug
)
2107 fprintf_unfiltered (gdb_stdlog
,
2108 "rust_lookup_symbol_non_local"
2109 " (%s, %s (scope %s), %s)\n",
2110 name
, host_address_to_string (block
),
2111 block_scope (block
), domain_name (domain
));
2114 /* Look up bare names in the block's scope. */
2115 if (name
[cp_find_first_component (name
)] == '\0')
2117 const char *scope
= block_scope (block
);
2119 if (scope
[0] != '\0')
2121 std::string scopedname
= std::string (scope
) + "::" + name
;
2123 result
= lookup_symbol_in_static_block (scopedname
.c_str (), block
,
2125 if (result
.symbol
== NULL
)
2126 result
= lookup_global_symbol (scopedname
.c_str (), block
, domain
);
2134 /* la_sniff_from_mangled_name for Rust. */
2137 rust_sniff_from_mangled_name (const char *mangled
, char **demangled
)
2139 *demangled
= gdb_demangle (mangled
, DMGL_PARAMS
| DMGL_ANSI
);
2140 return *demangled
!= NULL
;
2145 static const struct exp_descriptor exp_descriptor_rust
=
2148 rust_operator_length
,
2149 rust_operator_check
,
2151 rust_dump_subexp_body
,
2152 rust_evaluate_subexp
2155 static const char *rust_extensions
[] =
2160 static const struct language_defn rust_language_defn
=
2170 &exp_descriptor_rust
,
2174 rust_printchar
, /* Print a character constant */
2175 rust_printstr
, /* Function to print string constant */
2176 rust_emitchar
, /* Print a single char */
2177 rust_print_type
, /* Print a type using appropriate syntax */
2178 rust_print_typedef
, /* Print a typedef using appropriate syntax */
2179 rust_val_print
, /* Print a value using appropriate syntax */
2180 c_value_print
, /* Print a top-level value */
2181 default_read_var_value
, /* la_read_var_value */
2182 NULL
, /* Language specific skip_trampoline */
2183 NULL
, /* name_of_this */
2184 rust_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
2185 basic_lookup_transparent_type
,/* lookup_transparent_type */
2186 gdb_demangle
, /* Language specific symbol demangler */
2187 rust_sniff_from_mangled_name
,
2188 NULL
, /* Language specific
2189 class_name_from_physname */
2190 c_op_print_tab
, /* expression operators for printing */
2191 1, /* c-style arrays */
2192 0, /* String lower bound */
2193 default_word_break_characters
,
2194 default_make_symbol_completion_list
,
2195 rust_language_arch_info
,
2196 default_print_array_index
,
2197 default_pass_by_reference
,
2199 NULL
, /* la_get_symbol_name_cmp */
2200 iterate_over_symbols
,
2201 &default_varobj_ops
,
2208 _initialize_rust_language (void)
2210 add_language (&rust_language_defn
);