1 /* Rust language support routines for GDB, the GNU debugger.
3 Copyright (C) 2016-2019 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
27 #include "cp-support.h"
33 #include "rust-lang.h"
34 #include "typeprint.h"
41 /* See rust-lang.h. */
44 rust_last_path_segment (const char *path
)
46 const char *result
= strrchr (path
, ':');
53 /* See rust-lang.h. */
56 rust_crate_for_block (const struct block
*block
)
58 const char *scope
= block_scope (block
);
61 return std::string ();
63 return std::string (scope
, cp_find_first_component (scope
));
66 /* Return true if TYPE, which must be a struct type, represents a Rust
70 rust_enum_p (const struct type
*type
)
72 return (TYPE_CODE (type
) == TYPE_CODE_STRUCT
73 && TYPE_NFIELDS (type
) == 1
74 && TYPE_FLAG_DISCRIMINATED_UNION (TYPE_FIELD_TYPE (type
, 0)));
77 /* Return true if TYPE, which must be an enum type, has no
81 rust_empty_enum_p (const struct type
*type
)
83 gdb_assert (rust_enum_p (type
));
84 /* In Rust the enum always fills the containing structure. */
85 gdb_assert (TYPE_FIELD_BITPOS (type
, 0) == 0);
87 return TYPE_NFIELDS (TYPE_FIELD_TYPE (type
, 0)) == 0;
90 /* Given an enum type and contents, find which variant is active. */
93 rust_enum_variant (struct type
*type
, const gdb_byte
*contents
)
95 /* In Rust the enum always fills the containing structure. */
96 gdb_assert (TYPE_FIELD_BITPOS (type
, 0) == 0);
98 struct type
*union_type
= TYPE_FIELD_TYPE (type
, 0);
100 int fieldno
= value_union_variant (union_type
, contents
);
101 return &TYPE_FIELD (union_type
, fieldno
);
104 /* See rust-lang.h. */
107 rust_tuple_type_p (struct type
*type
)
109 /* The current implementation is a bit of a hack, but there's
110 nothing else in the debuginfo to distinguish a tuple from a
112 return (TYPE_CODE (type
) == TYPE_CODE_STRUCT
113 && TYPE_NAME (type
) != NULL
114 && TYPE_NAME (type
)[0] == '(');
117 /* Return true if all non-static fields of a structlike type are in a
118 sequence like __0, __1, __2. */
121 rust_underscore_fields (struct type
*type
)
127 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
)
129 for (i
= 0; i
< TYPE_NFIELDS (type
); ++i
)
131 if (!field_is_static (&TYPE_FIELD (type
, i
)))
135 xsnprintf (buf
, sizeof (buf
), "__%d", field_number
);
136 if (strcmp (buf
, TYPE_FIELD_NAME (type
, i
)) != 0)
144 /* See rust-lang.h. */
147 rust_tuple_struct_type_p (struct type
*type
)
149 /* This is just an approximation until DWARF can represent Rust more
150 precisely. We exclude zero-length structs because they may not
151 be tuple structs, and there's no way to tell. */
152 return TYPE_NFIELDS (type
) > 0 && rust_underscore_fields (type
);
155 /* Return true if TYPE is a slice type, otherwise false. */
158 rust_slice_type_p (struct type
*type
)
160 return (TYPE_CODE (type
) == TYPE_CODE_STRUCT
161 && TYPE_NAME (type
) != NULL
162 && (strncmp (TYPE_NAME (type
), "&[", 2) == 0
163 || strcmp (TYPE_NAME (type
), "&str") == 0));
166 /* Return true if TYPE is a range type, otherwise false. */
169 rust_range_type_p (struct type
*type
)
173 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
174 || TYPE_NFIELDS (type
) > 2
175 || TYPE_NAME (type
) == NULL
176 || strstr (TYPE_NAME (type
), "::Range") == NULL
)
179 if (TYPE_NFIELDS (type
) == 0)
183 if (strcmp (TYPE_FIELD_NAME (type
, 0), "start") == 0)
185 if (TYPE_NFIELDS (type
) == 1)
189 else if (TYPE_NFIELDS (type
) == 2)
191 /* First field had to be "start". */
195 return strcmp (TYPE_FIELD_NAME (type
, i
), "end") == 0;
198 /* Return true if TYPE is an inclusive range type, otherwise false.
199 This is only valid for types which are already known to be range
203 rust_inclusive_range_type_p (struct type
*type
)
205 return (strstr (TYPE_NAME (type
), "::RangeInclusive") != NULL
206 || strstr (TYPE_NAME (type
), "::RangeToInclusive") != NULL
);
209 /* Return true if TYPE seems to be the type "u8", otherwise false. */
212 rust_u8_type_p (struct type
*type
)
214 return (TYPE_CODE (type
) == TYPE_CODE_INT
215 && TYPE_UNSIGNED (type
)
216 && TYPE_LENGTH (type
) == 1);
219 /* Return true if TYPE is a Rust character type. */
222 rust_chartype_p (struct type
*type
)
224 return (TYPE_CODE (type
) == TYPE_CODE_CHAR
225 && TYPE_LENGTH (type
) == 4
226 && TYPE_UNSIGNED (type
));
229 /* Return true if TYPE is a string type. */
232 rust_is_string_type_p (struct type
*type
)
234 LONGEST low_bound
, high_bound
;
236 type
= check_typedef (type
);
237 return ((TYPE_CODE (type
) == TYPE_CODE_STRING
)
238 || (TYPE_CODE (type
) == TYPE_CODE_PTR
239 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_ARRAY
240 && rust_u8_type_p (TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (type
)))
241 && get_array_bounds (TYPE_TARGET_TYPE (type
), &low_bound
,
243 || (TYPE_CODE (type
) == TYPE_CODE_STRUCT
244 && !rust_enum_p (type
)
245 && rust_slice_type_p (type
)
246 && strcmp (TYPE_NAME (type
), "&str") == 0));
249 /* If VALUE represents a trait object pointer, return the underlying
250 pointer with the correct (i.e., runtime) type. Otherwise, return
253 static struct value
*
254 rust_get_trait_object_pointer (struct value
*value
)
256 struct type
*type
= check_typedef (value_type (value
));
258 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
|| TYPE_NFIELDS (type
) != 2)
261 /* Try to be a bit resilient if the ABI changes. */
262 int vtable_field
= 0;
263 for (int i
= 0; i
< 2; ++i
)
265 if (strcmp (TYPE_FIELD_NAME (type
, i
), "vtable") == 0)
267 else if (strcmp (TYPE_FIELD_NAME (type
, i
), "pointer") != 0)
271 CORE_ADDR vtable
= value_as_address (value_field (value
, vtable_field
));
272 struct symbol
*symbol
= find_symbol_at_address (vtable
);
273 if (symbol
== NULL
|| symbol
->subclass
!= SYMBOL_RUST_VTABLE
)
276 struct rust_vtable_symbol
*vtable_sym
277 = static_cast<struct rust_vtable_symbol
*> (symbol
);
278 struct type
*pointer_type
= lookup_pointer_type (vtable_sym
->concrete_type
);
279 return value_cast (pointer_type
, value_field (value
, 1 - vtable_field
));
284 /* la_emitchar implementation for Rust. */
287 rust_emitchar (int c
, struct type
*type
, struct ui_file
*stream
, int quoter
)
289 if (!rust_chartype_p (type
))
290 generic_emit_char (c
, type
, stream
, quoter
,
291 target_charset (get_type_arch (type
)));
292 else if (c
== '\\' || c
== quoter
)
293 fprintf_filtered (stream
, "\\%c", c
);
295 fputs_filtered ("\\n", stream
);
297 fputs_filtered ("\\r", stream
);
299 fputs_filtered ("\\t", stream
);
301 fputs_filtered ("\\0", stream
);
302 else if (c
>= 32 && c
<= 127 && isprint (c
))
303 fputc_filtered (c
, stream
);
305 fprintf_filtered (stream
, "\\x%02x", c
);
307 fprintf_filtered (stream
, "\\u{%06x}", c
);
310 /* la_printchar implementation for Rust. */
313 rust_printchar (int c
, struct type
*type
, struct ui_file
*stream
)
315 fputs_filtered ("'", stream
);
316 LA_EMIT_CHAR (c
, type
, stream
, '\'');
317 fputs_filtered ("'", stream
);
320 /* la_printstr implementation for Rust. */
323 rust_printstr (struct ui_file
*stream
, struct type
*type
,
324 const gdb_byte
*string
, unsigned int length
,
325 const char *user_encoding
, int force_ellipses
,
326 const struct value_print_options
*options
)
328 /* Rust always uses UTF-8, but let the caller override this if need
330 const char *encoding
= user_encoding
;
331 if (user_encoding
== NULL
|| !*user_encoding
)
333 /* In Rust strings, characters are "u8". */
334 if (rust_u8_type_p (type
))
338 /* This is probably some C string, so let's let C deal with
340 c_printstr (stream
, type
, string
, length
, user_encoding
,
341 force_ellipses
, options
);
346 /* This is not ideal as it doesn't use our character printer. */
347 generic_printstr (stream
, type
, string
, length
, encoding
, force_ellipses
,
353 /* Helper function to print a string slice. */
356 rust_val_print_str (struct ui_file
*stream
, struct value
*val
,
357 const struct value_print_options
*options
)
359 struct value
*base
= value_struct_elt (&val
, NULL
, "data_ptr", NULL
,
361 struct value
*len
= value_struct_elt (&val
, NULL
, "length", NULL
, "slice");
363 val_print_string (TYPE_TARGET_TYPE (value_type (base
)), "UTF-8",
364 value_as_address (base
), value_as_long (len
), stream
,
368 /* rust_val_print helper for structs and untagged unions. */
371 val_print_struct (struct type
*type
, int embedded_offset
,
372 CORE_ADDR address
, struct ui_file
*stream
,
373 int recurse
, struct value
*val
,
374 const struct value_print_options
*options
)
379 if (rust_slice_type_p (type
) && strcmp (TYPE_NAME (type
), "&str") == 0)
381 rust_val_print_str (stream
, val
, options
);
385 bool is_tuple
= rust_tuple_type_p (type
);
386 bool is_tuple_struct
= !is_tuple
&& rust_tuple_struct_type_p (type
);
387 struct value_print_options opts
;
391 if (TYPE_NAME (type
) != NULL
)
392 fprintf_filtered (stream
, "%s", TYPE_NAME (type
));
394 if (TYPE_NFIELDS (type
) == 0)
397 if (TYPE_NAME (type
) != NULL
)
398 fputs_filtered (" ", stream
);
401 if (is_tuple
|| is_tuple_struct
)
402 fputs_filtered ("(", stream
);
404 fputs_filtered ("{", stream
);
410 for (i
= 0; i
< TYPE_NFIELDS (type
); ++i
)
412 if (field_is_static (&TYPE_FIELD (type
, i
)))
416 fputs_filtered (",", stream
);
418 if (options
->prettyformat
)
420 fputs_filtered ("\n", stream
);
421 print_spaces_filtered (2 + 2 * recurse
, stream
);
423 else if (!first_field
)
424 fputs_filtered (" ", stream
);
428 if (!is_tuple
&& !is_tuple_struct
)
430 fputs_filtered (TYPE_FIELD_NAME (type
, i
), stream
);
431 fputs_filtered (": ", stream
);
434 val_print (TYPE_FIELD_TYPE (type
, i
),
435 embedded_offset
+ TYPE_FIELD_BITPOS (type
, i
) / 8,
437 stream
, recurse
+ 1, val
, &opts
,
441 if (options
->prettyformat
)
443 fputs_filtered ("\n", stream
);
444 print_spaces_filtered (2 * recurse
, stream
);
447 if (is_tuple
|| is_tuple_struct
)
448 fputs_filtered (")", stream
);
450 fputs_filtered ("}", stream
);
453 /* rust_val_print helper for discriminated unions (Rust enums). */
456 rust_print_enum (struct type
*type
, int embedded_offset
,
457 CORE_ADDR address
, struct ui_file
*stream
,
458 int recurse
, struct value
*val
,
459 const struct value_print_options
*options
)
461 struct value_print_options opts
= *options
;
465 if (rust_empty_enum_p (type
))
467 /* Print the enum type name here to be more clear. */
468 fprintf_filtered (stream
, _("%s {<No data fields>}"), TYPE_NAME (type
));
472 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
473 struct field
*variant_field
= rust_enum_variant (type
, valaddr
);
474 embedded_offset
+= FIELD_BITPOS (*variant_field
) / 8;
475 struct type
*variant_type
= FIELD_TYPE (*variant_field
);
477 int nfields
= TYPE_NFIELDS (variant_type
);
479 bool is_tuple
= rust_tuple_struct_type_p (variant_type
);
481 fprintf_filtered (stream
, "%s", TYPE_NAME (variant_type
));
484 /* In case of a nullary variant like 'None', just output
489 /* In case of a non-nullary variant, we output 'Foo(x,y,z)'. */
491 fprintf_filtered (stream
, "(");
494 /* struct variant. */
495 fprintf_filtered (stream
, "{");
498 bool first_field
= true;
499 for (int j
= 0; j
< TYPE_NFIELDS (variant_type
); j
++)
502 fputs_filtered (", ", stream
);
506 fprintf_filtered (stream
, "%s: ",
507 TYPE_FIELD_NAME (variant_type
, j
));
509 val_print (TYPE_FIELD_TYPE (variant_type
, j
),
511 + TYPE_FIELD_BITPOS (variant_type
, j
) / 8),
513 stream
, recurse
+ 1, val
, &opts
,
518 fputs_filtered (")", stream
);
520 fputs_filtered ("}", stream
);
523 static const struct generic_val_print_decorations rust_decorations
=
525 /* Complex isn't used in Rust, but we provide C-ish values just in
537 /* la_val_print implementation for Rust. */
540 rust_val_print (struct type
*type
, int embedded_offset
,
541 CORE_ADDR address
, struct ui_file
*stream
, int recurse
,
543 const struct value_print_options
*options
)
545 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
547 type
= check_typedef (type
);
548 switch (TYPE_CODE (type
))
552 LONGEST low_bound
, high_bound
;
554 if (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_ARRAY
555 && rust_u8_type_p (TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (type
)))
556 && get_array_bounds (TYPE_TARGET_TYPE (type
), &low_bound
,
558 /* We have a pointer to a byte string, so just print
560 struct type
*elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
562 struct gdbarch
*arch
= get_type_arch (type
);
563 int unit_size
= gdbarch_addressable_memory_unit_size (arch
);
565 addr
= unpack_pointer (type
, valaddr
+ embedded_offset
* unit_size
);
566 if (options
->addressprint
)
568 fputs_filtered (paddress (arch
, addr
), stream
);
569 fputs_filtered (" ", stream
);
572 fputs_filtered ("b", stream
);
573 val_print_string (TYPE_TARGET_TYPE (elttype
), "ASCII", addr
,
574 high_bound
- low_bound
+ 1, stream
,
581 case TYPE_CODE_METHODPTR
:
582 case TYPE_CODE_MEMBERPTR
:
583 c_val_print (type
, embedded_offset
, address
, stream
,
584 recurse
, val
, options
);
588 /* Recognize the unit type. */
589 if (TYPE_UNSIGNED (type
) && TYPE_LENGTH (type
) == 0
590 && TYPE_NAME (type
) != NULL
&& strcmp (TYPE_NAME (type
), "()") == 0)
592 fputs_filtered ("()", stream
);
597 case TYPE_CODE_STRING
:
599 struct gdbarch
*arch
= get_type_arch (type
);
600 int unit_size
= gdbarch_addressable_memory_unit_size (arch
);
601 LONGEST low_bound
, high_bound
;
603 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
604 error (_("Could not determine the array bounds"));
606 /* If we see a plain TYPE_CODE_STRING, then we're printing a
607 byte string, hence the choice of "ASCII" as the
609 fputs_filtered ("b", stream
);
610 rust_printstr (stream
, TYPE_TARGET_TYPE (type
),
611 valaddr
+ embedded_offset
* unit_size
,
612 high_bound
- low_bound
+ 1, "ASCII", 0, options
);
616 case TYPE_CODE_ARRAY
:
618 LONGEST low_bound
, high_bound
;
620 if (get_array_bounds (type
, &low_bound
, &high_bound
)
621 && high_bound
- low_bound
+ 1 == 0)
622 fputs_filtered ("[]", stream
);
628 case TYPE_CODE_UNION
:
629 /* Untagged unions are printed as if they are structs. Since
630 the field bit positions overlap in the debuginfo, the code
631 for printing a union is same as that for a struct, the only
632 difference is that the input type will have overlapping
634 val_print_struct (type
, embedded_offset
, address
, stream
,
635 recurse
, val
, options
);
638 case TYPE_CODE_STRUCT
:
639 if (rust_enum_p (type
))
640 rust_print_enum (type
, embedded_offset
, address
, stream
,
641 recurse
, val
, options
);
643 val_print_struct (type
, embedded_offset
, address
, stream
,
644 recurse
, val
, options
);
649 /* Nothing special yet. */
650 generic_val_print (type
, embedded_offset
, address
, stream
,
651 recurse
, val
, options
, &rust_decorations
);
658 rust_internal_print_type (struct type
*type
, const char *varstring
,
659 struct ui_file
*stream
, int show
, int level
,
660 const struct type_print_options
*flags
,
661 bool for_rust_enum
, print_offset_data
*podata
);
663 /* Print a struct or union typedef. */
665 rust_print_struct_def (struct type
*type
, const char *varstring
,
666 struct ui_file
*stream
, int show
, int level
,
667 const struct type_print_options
*flags
,
668 bool for_rust_enum
, print_offset_data
*podata
)
670 /* Print a tuple type simply. */
671 if (rust_tuple_type_p (type
))
673 fputs_filtered (TYPE_NAME (type
), stream
);
677 /* If we see a base class, delegate to C. */
678 if (TYPE_N_BASECLASSES (type
) > 0)
679 c_print_type (type
, varstring
, stream
, show
, level
, flags
);
681 if (flags
->print_offsets
)
683 /* Temporarily bump the level so that the output lines up
688 /* Compute properties of TYPE here because, in the enum case, the
689 rest of the code ends up looking only at the variant part. */
690 const char *tagname
= TYPE_NAME (type
);
691 bool is_tuple_struct
= rust_tuple_struct_type_p (type
);
692 bool is_tuple
= rust_tuple_type_p (type
);
693 bool is_enum
= rust_enum_p (type
);
695 int enum_discriminant_index
= -1;
699 /* Already printing an outer enum, so nothing to print here. */
703 /* This code path is also used by unions and enums. */
706 fputs_filtered ("enum ", stream
);
708 if (rust_empty_enum_p (type
))
712 fputs_filtered (tagname
, stream
);
713 fputs_filtered (" ", stream
);
715 fputs_filtered ("{}", stream
);
719 type
= TYPE_FIELD_TYPE (type
, 0);
721 struct dynamic_prop
*discriminant_prop
722 = get_dyn_prop (DYN_PROP_DISCRIMINATED
, type
);
723 struct discriminant_info
*info
724 = (struct discriminant_info
*) discriminant_prop
->data
.baton
;
725 enum_discriminant_index
= info
->discriminant_index
;
727 else if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
728 fputs_filtered ("struct ", stream
);
730 fputs_filtered ("union ", stream
);
733 fputs_filtered (tagname
, stream
);
736 if (TYPE_NFIELDS (type
) == 0 && !is_tuple
)
738 if (for_rust_enum
&& !flags
->print_offsets
)
739 fputs_filtered (is_tuple_struct
? "(" : "{", stream
);
741 fputs_filtered (is_tuple_struct
? " (\n" : " {\n", stream
);
743 /* When printing offsets, we rearrange the fields into storage
744 order. This lets us show holes more clearly. We work using
745 field indices here because it simplifies calls to
746 print_offset_data::update below. */
747 std::vector
<int> fields
;
748 for (int i
= 0; i
< TYPE_NFIELDS (type
); ++i
)
750 if (field_is_static (&TYPE_FIELD (type
, i
)))
752 if (is_enum
&& i
== enum_discriminant_index
)
754 fields
.push_back (i
);
756 if (flags
->print_offsets
)
757 std::sort (fields
.begin (), fields
.end (),
760 return (TYPE_FIELD_BITPOS (type
, a
)
761 < TYPE_FIELD_BITPOS (type
, b
));
768 gdb_assert (!field_is_static (&TYPE_FIELD (type
, i
)));
769 gdb_assert (! (is_enum
&& i
== enum_discriminant_index
));
771 if (flags
->print_offsets
)
772 podata
->update (type
, i
, stream
);
774 /* We'd like to print "pub" here as needed, but rustc
775 doesn't emit the debuginfo, and our types don't have
776 cplus_struct_type attached. */
778 /* For a tuple struct we print the type but nothing
780 if (!for_rust_enum
|| flags
->print_offsets
)
781 print_spaces_filtered (level
+ 2, stream
);
783 fputs_filtered (TYPE_FIELD_NAME (type
, i
), stream
);
784 else if (!is_tuple_struct
)
785 fprintf_filtered (stream
, "%s: ", TYPE_FIELD_NAME (type
, i
));
787 rust_internal_print_type (TYPE_FIELD_TYPE (type
, i
), NULL
,
788 stream
, (is_enum
? show
: show
- 1),
789 level
+ 2, flags
, is_enum
, podata
);
790 if (!for_rust_enum
|| flags
->print_offsets
)
791 fputs_filtered (",\n", stream
);
792 /* Note that this check of "I" is ok because we only sorted the
793 fields by offset when print_offsets was set, so we won't take
794 this branch in that case. */
795 else if (i
+ 1 < TYPE_NFIELDS (type
))
796 fputs_filtered (", ", stream
);
799 if (flags
->print_offsets
)
801 /* Undo the temporary level increase we did above. */
803 podata
->finish (type
, level
, stream
);
804 print_spaces_filtered (print_offset_data::indentation
, stream
);
806 print_spaces_filtered (2, stream
);
808 if (!for_rust_enum
|| flags
->print_offsets
)
809 print_spaces_filtered (level
, stream
);
810 fputs_filtered (is_tuple_struct
? ")" : "}", stream
);
813 /* la_print_typedef implementation for Rust. */
816 rust_print_typedef (struct type
*type
,
817 struct symbol
*new_symbol
,
818 struct ui_file
*stream
)
820 type
= check_typedef (type
);
821 fprintf_filtered (stream
, "type %s = ", SYMBOL_PRINT_NAME (new_symbol
));
822 type_print (type
, "", stream
, 0);
823 fprintf_filtered (stream
, ";\n");
826 /* la_print_type implementation for Rust. */
829 rust_internal_print_type (struct type
*type
, const char *varstring
,
830 struct ui_file
*stream
, int show
, int level
,
831 const struct type_print_options
*flags
,
832 bool for_rust_enum
, print_offset_data
*podata
)
836 && TYPE_NAME (type
) != NULL
)
838 /* Rust calls the unit type "void" in its debuginfo,
839 but we don't want to print it as that. */
840 if (TYPE_CODE (type
) == TYPE_CODE_VOID
)
841 fputs_filtered ("()", stream
);
843 fputs_filtered (TYPE_NAME (type
), stream
);
847 type
= check_typedef (type
);
848 switch (TYPE_CODE (type
))
851 /* If we have an enum, we've already printed the type's
852 unqualified name, and there is nothing else to print
855 fputs_filtered ("()", stream
);
859 /* Delegate varargs to the C printer. */
860 if (TYPE_VARARGS (type
))
863 fputs_filtered ("fn ", stream
);
864 if (varstring
!= NULL
)
865 fputs_filtered (varstring
, stream
);
866 fputs_filtered ("(", stream
);
867 for (int i
= 0; i
< TYPE_NFIELDS (type
); ++i
)
871 fputs_filtered (", ", stream
);
872 rust_internal_print_type (TYPE_FIELD_TYPE (type
, i
), "", stream
,
873 -1, 0, flags
, false, podata
);
875 fputs_filtered (")", stream
);
876 /* If it returns unit, we can omit the return type. */
877 if (TYPE_CODE (TYPE_TARGET_TYPE (type
)) != TYPE_CODE_VOID
)
879 fputs_filtered (" -> ", stream
);
880 rust_internal_print_type (TYPE_TARGET_TYPE (type
), "", stream
,
881 -1, 0, flags
, false, podata
);
885 case TYPE_CODE_ARRAY
:
887 LONGEST low_bound
, high_bound
;
889 fputs_filtered ("[", stream
);
890 rust_internal_print_type (TYPE_TARGET_TYPE (type
), NULL
,
891 stream
, show
- 1, level
, flags
, false,
894 if (TYPE_HIGH_BOUND_KIND (TYPE_INDEX_TYPE (type
)) == PROP_LOCEXPR
895 || TYPE_HIGH_BOUND_KIND (TYPE_INDEX_TYPE (type
)) == PROP_LOCLIST
)
896 fprintf_filtered (stream
, "; variable length");
897 else if (get_array_bounds (type
, &low_bound
, &high_bound
))
898 fprintf_filtered (stream
, "; %s",
899 plongest (high_bound
- low_bound
+ 1));
900 fputs_filtered ("]", stream
);
904 case TYPE_CODE_UNION
:
905 case TYPE_CODE_STRUCT
:
906 rust_print_struct_def (type
, varstring
, stream
, show
, level
, flags
,
907 for_rust_enum
, podata
);
914 fputs_filtered ("enum ", stream
);
915 if (TYPE_NAME (type
) != NULL
)
917 fputs_filtered (TYPE_NAME (type
), stream
);
918 fputs_filtered (" ", stream
);
919 len
= strlen (TYPE_NAME (type
));
921 fputs_filtered ("{\n", stream
);
923 for (int i
= 0; i
< TYPE_NFIELDS (type
); ++i
)
925 const char *name
= TYPE_FIELD_NAME (type
, i
);
930 && strncmp (name
, TYPE_NAME (type
), len
) == 0
932 && name
[len
+ 1] == ':')
934 fprintfi_filtered (level
+ 2, stream
, "%s,\n", name
);
937 fputs_filtered ("}", stream
);
943 if (TYPE_NAME (type
) != nullptr)
944 fputs_filtered (TYPE_NAME (type
), stream
);
947 /* We currently can't distinguish between pointers and
949 fputs_filtered ("*mut ", stream
);
950 type_print (TYPE_TARGET_TYPE (type
), "", stream
, 0);
957 c_print_type (type
, varstring
, stream
, show
, level
, flags
);
962 rust_print_type (struct type
*type
, const char *varstring
,
963 struct ui_file
*stream
, int show
, int level
,
964 const struct type_print_options
*flags
)
966 print_offset_data podata
;
967 rust_internal_print_type (type
, varstring
, stream
, show
, level
,
968 flags
, false, &podata
);
973 /* Like arch_composite_type, but uses TYPE to decide how to allocate
974 -- either on an obstack or on a gdbarch. */
977 rust_composite_type (struct type
*original
,
979 const char *field1
, struct type
*type1
,
980 const char *field2
, struct type
*type2
)
982 struct type
*result
= alloc_type_copy (original
);
983 int i
, nfields
, bitpos
;
991 TYPE_CODE (result
) = TYPE_CODE_STRUCT
;
992 TYPE_NAME (result
) = name
;
994 TYPE_NFIELDS (result
) = nfields
;
996 = (struct field
*) TYPE_ZALLOC (result
, nfields
* sizeof (struct field
));
1002 struct field
*field
= &TYPE_FIELD (result
, i
);
1004 SET_FIELD_BITPOS (*field
, bitpos
);
1005 bitpos
+= TYPE_LENGTH (type1
) * TARGET_CHAR_BIT
;
1007 FIELD_NAME (*field
) = field1
;
1008 FIELD_TYPE (*field
) = type1
;
1013 struct field
*field
= &TYPE_FIELD (result
, i
);
1014 unsigned align
= type_align (type2
);
1020 align
*= TARGET_CHAR_BIT
;
1021 delta
= bitpos
% align
;
1023 bitpos
+= align
- delta
;
1025 SET_FIELD_BITPOS (*field
, bitpos
);
1027 FIELD_NAME (*field
) = field2
;
1028 FIELD_TYPE (*field
) = type2
;
1033 TYPE_LENGTH (result
)
1034 = (TYPE_FIELD_BITPOS (result
, i
- 1) / TARGET_CHAR_BIT
+
1035 TYPE_LENGTH (TYPE_FIELD_TYPE (result
, i
- 1)));
1039 /* See rust-lang.h. */
1042 rust_slice_type (const char *name
, struct type
*elt_type
,
1043 struct type
*usize_type
)
1047 elt_type
= lookup_pointer_type (elt_type
);
1048 type
= rust_composite_type (elt_type
, name
,
1049 "data_ptr", elt_type
,
1050 "length", usize_type
);
1055 enum rust_primitive_types
1057 rust_primitive_bool
,
1058 rust_primitive_char
,
1067 rust_primitive_isize
,
1068 rust_primitive_usize
,
1071 rust_primitive_unit
,
1073 nr_rust_primitive_types
1076 /* la_language_arch_info implementation for Rust. */
1079 rust_language_arch_info (struct gdbarch
*gdbarch
,
1080 struct language_arch_info
*lai
)
1082 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
1084 struct type
**types
;
1085 unsigned int length
;
1087 types
= GDBARCH_OBSTACK_CALLOC (gdbarch
, nr_rust_primitive_types
+ 1,
1090 types
[rust_primitive_bool
] = arch_boolean_type (gdbarch
, 8, 1, "bool");
1091 types
[rust_primitive_char
] = arch_character_type (gdbarch
, 32, 1, "char");
1092 types
[rust_primitive_i8
] = arch_integer_type (gdbarch
, 8, 0, "i8");
1093 types
[rust_primitive_u8
] = arch_integer_type (gdbarch
, 8, 1, "u8");
1094 types
[rust_primitive_i16
] = arch_integer_type (gdbarch
, 16, 0, "i16");
1095 types
[rust_primitive_u16
] = arch_integer_type (gdbarch
, 16, 1, "u16");
1096 types
[rust_primitive_i32
] = arch_integer_type (gdbarch
, 32, 0, "i32");
1097 types
[rust_primitive_u32
] = arch_integer_type (gdbarch
, 32, 1, "u32");
1098 types
[rust_primitive_i64
] = arch_integer_type (gdbarch
, 64, 0, "i64");
1099 types
[rust_primitive_u64
] = arch_integer_type (gdbarch
, 64, 1, "u64");
1101 length
= 8 * TYPE_LENGTH (builtin
->builtin_data_ptr
);
1102 types
[rust_primitive_isize
] = arch_integer_type (gdbarch
, length
, 0, "isize");
1103 types
[rust_primitive_usize
] = arch_integer_type (gdbarch
, length
, 1, "usize");
1105 types
[rust_primitive_f32
] = arch_float_type (gdbarch
, 32, "f32",
1106 floatformats_ieee_single
);
1107 types
[rust_primitive_f64
] = arch_float_type (gdbarch
, 64, "f64",
1108 floatformats_ieee_double
);
1110 types
[rust_primitive_unit
] = arch_integer_type (gdbarch
, 0, 1, "()");
1112 tem
= make_cv_type (1, 0, types
[rust_primitive_u8
], NULL
);
1113 types
[rust_primitive_str
] = rust_slice_type ("&str", tem
,
1114 types
[rust_primitive_usize
]);
1116 lai
->primitive_type_vector
= types
;
1117 lai
->bool_type_default
= types
[rust_primitive_bool
];
1118 lai
->string_char_type
= types
[rust_primitive_u8
];
1123 /* A helper for rust_evaluate_subexp that handles OP_FUNCALL. */
1125 static struct value
*
1126 rust_evaluate_funcall (struct expression
*exp
, int *pos
, enum noside noside
)
1129 int num_args
= exp
->elts
[*pos
+ 1].longconst
;
1131 struct value
*function
, *result
, *arg0
;
1132 struct type
*type
, *fn_type
;
1133 const struct block
*block
;
1134 struct block_symbol sym
;
1136 /* For an ordinary function call we can simply defer to the
1137 generic implementation. */
1138 if (exp
->elts
[*pos
+ 3].opcode
!= STRUCTOP_STRUCT
)
1139 return evaluate_subexp_standard (NULL
, exp
, pos
, noside
);
1141 /* Skip over the OP_FUNCALL and the STRUCTOP_STRUCT. */
1143 method
= &exp
->elts
[*pos
+ 1].string
;
1144 *pos
+= 3 + BYTES_TO_EXP_ELEM (exp
->elts
[*pos
].longconst
+ 1);
1146 /* Evaluate the argument to STRUCTOP_STRUCT, then find its
1147 type in order to look up the method. */
1148 arg0
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1150 if (noside
== EVAL_SKIP
)
1152 for (i
= 0; i
< num_args
; ++i
)
1153 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1157 std::vector
<struct value
*> args (num_args
+ 1);
1160 /* We don't yet implement real Deref semantics. */
1161 while (TYPE_CODE (value_type (args
[0])) == TYPE_CODE_PTR
)
1162 args
[0] = value_ind (args
[0]);
1164 type
= value_type (args
[0]);
1165 if ((TYPE_CODE (type
) != TYPE_CODE_STRUCT
1166 && TYPE_CODE (type
) != TYPE_CODE_UNION
1167 && TYPE_CODE (type
) != TYPE_CODE_ENUM
)
1168 || rust_tuple_type_p (type
))
1169 error (_("Method calls only supported on struct or enum types"));
1170 if (TYPE_NAME (type
) == NULL
)
1171 error (_("Method call on nameless type"));
1173 std::string name
= std::string (TYPE_NAME (type
)) + "::" + method
;
1175 block
= get_selected_block (0);
1176 sym
= lookup_symbol (name
.c_str (), block
, VAR_DOMAIN
, NULL
);
1177 if (sym
.symbol
== NULL
)
1178 error (_("Could not find function named '%s'"), name
.c_str ());
1180 fn_type
= SYMBOL_TYPE (sym
.symbol
);
1181 if (TYPE_NFIELDS (fn_type
) == 0)
1182 error (_("Function '%s' takes no arguments"), name
.c_str ());
1184 if (TYPE_CODE (TYPE_FIELD_TYPE (fn_type
, 0)) == TYPE_CODE_PTR
)
1185 args
[0] = value_addr (args
[0]);
1187 function
= address_of_variable (sym
.symbol
, block
);
1189 for (i
= 0; i
< num_args
; ++i
)
1190 args
[i
+ 1] = evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1192 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1193 result
= value_zero (TYPE_TARGET_TYPE (fn_type
), not_lval
);
1195 result
= call_function_by_hand (function
, NULL
, args
);
1199 /* A helper for rust_evaluate_subexp that handles OP_RANGE. */
1201 static struct value
*
1202 rust_range (struct expression
*exp
, int *pos
, enum noside noside
)
1204 enum range_type kind
;
1205 struct value
*low
= NULL
, *high
= NULL
;
1206 struct value
*addrval
, *result
;
1208 struct type
*range_type
;
1209 struct type
*index_type
;
1210 struct type
*temp_type
;
1213 kind
= (enum range_type
) longest_to_int (exp
->elts
[*pos
+ 1].longconst
);
1216 if (kind
== HIGH_BOUND_DEFAULT
|| kind
== NONE_BOUND_DEFAULT
1217 || kind
== NONE_BOUND_DEFAULT_EXCLUSIVE
)
1218 low
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1219 if (kind
== LOW_BOUND_DEFAULT
|| kind
== LOW_BOUND_DEFAULT_EXCLUSIVE
1220 || kind
== NONE_BOUND_DEFAULT
|| kind
== NONE_BOUND_DEFAULT_EXCLUSIVE
)
1221 high
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1222 bool inclusive
= (kind
== NONE_BOUND_DEFAULT
|| kind
== LOW_BOUND_DEFAULT
);
1224 if (noside
== EVAL_SKIP
)
1225 return value_from_longest (builtin_type (exp
->gdbarch
)->builtin_int
, 1);
1232 name
= "std::ops::RangeFull";
1236 index_type
= value_type (high
);
1238 ? "std::ops::RangeToInclusive" : "std::ops::RangeTo");
1245 index_type
= value_type (low
);
1246 name
= "std::ops::RangeFrom";
1250 if (!types_equal (value_type (low
), value_type (high
)))
1251 error (_("Range expression with different types"));
1252 index_type
= value_type (low
);
1253 name
= inclusive
? "std::ops::RangeInclusive" : "std::ops::Range";
1257 /* If we don't have an index type, just allocate this on the
1258 arch. Here any type will do. */
1259 temp_type
= (index_type
== NULL
1260 ? language_bool_type (exp
->language_defn
, exp
->gdbarch
)
1262 /* It would be nicer to cache the range type. */
1263 range_type
= rust_composite_type (temp_type
, name
,
1264 low
== NULL
? NULL
: "start", index_type
,
1265 high
== NULL
? NULL
: "end", index_type
);
1267 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1268 return value_zero (range_type
, lval_memory
);
1270 addrval
= value_allocate_space_in_inferior (TYPE_LENGTH (range_type
));
1271 addr
= value_as_long (addrval
);
1272 result
= value_at_lazy (range_type
, addr
);
1276 struct value
*start
= value_struct_elt (&result
, NULL
, "start", NULL
,
1279 value_assign (start
, low
);
1284 struct value
*end
= value_struct_elt (&result
, NULL
, "end", NULL
,
1287 value_assign (end
, high
);
1290 result
= value_at_lazy (range_type
, addr
);
1294 /* A helper function to compute the range and kind given a range
1295 value. TYPE is the type of the range value. RANGE is the range
1296 value. LOW, HIGH, and KIND are out parameters. The LOW and HIGH
1297 parameters might be filled in, or might not be, depending on the
1298 kind of range this is. KIND will always be set to the appropriate
1299 value describing the kind of range, and this can be used to
1300 determine whether LOW or HIGH are valid. */
1303 rust_compute_range (struct type
*type
, struct value
*range
,
1304 LONGEST
*low
, LONGEST
*high
,
1305 enum range_type
*kind
)
1311 *kind
= BOTH_BOUND_DEFAULT
;
1313 if (TYPE_NFIELDS (type
) == 0)
1317 if (strcmp (TYPE_FIELD_NAME (type
, 0), "start") == 0)
1319 *kind
= HIGH_BOUND_DEFAULT
;
1320 *low
= value_as_long (value_field (range
, 0));
1323 if (TYPE_NFIELDS (type
) > i
1324 && strcmp (TYPE_FIELD_NAME (type
, i
), "end") == 0)
1326 *kind
= (*kind
== BOTH_BOUND_DEFAULT
1327 ? LOW_BOUND_DEFAULT
: NONE_BOUND_DEFAULT
);
1328 *high
= value_as_long (value_field (range
, i
));
1330 if (rust_inclusive_range_type_p (type
))
1335 /* A helper for rust_evaluate_subexp that handles BINOP_SUBSCRIPT. */
1337 static struct value
*
1338 rust_subscript (struct expression
*exp
, int *pos
, enum noside noside
,
1341 struct value
*lhs
, *rhs
, *result
;
1342 struct type
*rhstype
;
1343 LONGEST low
, high_bound
;
1344 /* Initialized to appease the compiler. */
1345 enum range_type kind
= BOTH_BOUND_DEFAULT
;
1350 lhs
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1351 rhs
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1353 if (noside
== EVAL_SKIP
)
1356 rhstype
= check_typedef (value_type (rhs
));
1357 if (rust_range_type_p (rhstype
))
1360 error (_("Can't take slice of array without '&'"));
1361 rust_compute_range (rhstype
, rhs
, &low
, &high
, &kind
);
1365 low
= value_as_long (rhs
);
1367 struct type
*type
= check_typedef (value_type (lhs
));
1368 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1370 struct type
*base_type
= nullptr;
1371 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
1372 base_type
= TYPE_TARGET_TYPE (type
);
1373 else if (rust_slice_type_p (type
))
1375 for (int i
= 0; i
< TYPE_NFIELDS (type
); ++i
)
1377 if (strcmp (TYPE_FIELD_NAME (type
, i
), "data_ptr") == 0)
1379 base_type
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type
, i
));
1383 if (base_type
== nullptr)
1384 error (_("Could not find 'data_ptr' in slice type"));
1386 else if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
1387 base_type
= TYPE_TARGET_TYPE (type
);
1389 error (_("Cannot subscript non-array type"));
1391 struct type
*new_type
;
1394 if (rust_slice_type_p (type
))
1399 = language_lookup_primitive_type (exp
->language_defn
,
1402 new_type
= rust_slice_type ("&[*gdb*]", base_type
, usize
);
1406 new_type
= base_type
;
1408 return value_zero (new_type
, VALUE_LVAL (lhs
));
1415 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
1418 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
1419 error (_("Can't compute array bounds"));
1421 error (_("Found array with non-zero lower bound"));
1424 else if (rust_slice_type_p (type
))
1428 base
= value_struct_elt (&lhs
, NULL
, "data_ptr", NULL
, "slice");
1429 len
= value_struct_elt (&lhs
, NULL
, "length", NULL
, "slice");
1431 high_bound
= value_as_long (len
);
1433 else if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
1437 high_bound
= LONGEST_MAX
;
1440 error (_("Cannot subscript non-array type"));
1443 && (kind
== BOTH_BOUND_DEFAULT
|| kind
== LOW_BOUND_DEFAULT
))
1446 error (_("Index less than zero"));
1447 if (low
> high_bound
)
1448 error (_("Index greater than length"));
1450 result
= value_subscript (base
, low
);
1457 struct type
*usize
, *slice
;
1459 struct value
*addrval
, *tem
;
1461 if (kind
== BOTH_BOUND_DEFAULT
|| kind
== HIGH_BOUND_DEFAULT
)
1464 error (_("High index less than zero"));
1466 error (_("Low index greater than high index"));
1467 if (high
> high_bound
)
1468 error (_("High index greater than length"));
1470 usize
= language_lookup_primitive_type (exp
->language_defn
,
1473 const char *new_name
= ((type
!= nullptr
1474 && rust_slice_type_p (type
))
1475 ? TYPE_NAME (type
) : "&[*gdb*]");
1477 slice
= rust_slice_type (new_name
, value_type (result
), usize
);
1479 addrval
= value_allocate_space_in_inferior (TYPE_LENGTH (slice
));
1480 addr
= value_as_long (addrval
);
1481 tem
= value_at_lazy (slice
, addr
);
1483 value_assign (value_field (tem
, 0), value_addr (result
));
1484 value_assign (value_field (tem
, 1),
1485 value_from_longest (usize
, high
- low
));
1487 result
= value_at_lazy (slice
, addr
);
1490 result
= value_addr (result
);
1496 /* evaluate_exp implementation for Rust. */
1498 static struct value
*
1499 rust_evaluate_subexp (struct type
*expect_type
, struct expression
*exp
,
1500 int *pos
, enum noside noside
)
1502 struct value
*result
;
1504 switch (exp
->elts
[*pos
].opcode
)
1508 if (noside
!= EVAL_NORMAL
)
1509 result
= evaluate_subexp_standard (expect_type
, exp
, pos
, noside
);
1513 struct value
*value
= evaluate_subexp (expect_type
, exp
, pos
,
1516 struct value
*trait_ptr
= rust_get_trait_object_pointer (value
);
1517 if (trait_ptr
!= NULL
)
1520 result
= value_ind (value
);
1525 case UNOP_COMPLEMENT
:
1527 struct value
*value
;
1530 value
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1531 if (noside
== EVAL_SKIP
)
1533 /* Preserving the type is enough. */
1536 if (TYPE_CODE (value_type (value
)) == TYPE_CODE_BOOL
)
1537 result
= value_from_longest (value_type (value
),
1538 value_logical_not (value
));
1540 result
= value_complement (value
);
1544 case BINOP_SUBSCRIPT
:
1545 result
= rust_subscript (exp
, pos
, noside
, 0);
1549 result
= rust_evaluate_funcall (exp
, pos
, noside
);
1555 struct type
*type
= exp
->elts
[pc
+ 1].type
;
1556 int arglen
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
1559 struct value
*addrval
= NULL
;
1563 if (noside
== EVAL_NORMAL
)
1565 addrval
= value_allocate_space_in_inferior (TYPE_LENGTH (type
));
1566 addr
= value_as_long (addrval
);
1567 result
= value_at_lazy (type
, addr
);
1570 if (arglen
> 0 && exp
->elts
[*pos
].opcode
== OP_OTHERS
)
1575 init
= rust_evaluate_subexp (NULL
, exp
, pos
, noside
);
1576 if (noside
== EVAL_NORMAL
)
1578 /* This isn't quite right but will do for the time
1579 being, seeing that we can't implement the Copy
1581 value_assign (result
, init
);
1587 gdb_assert (arglen
% 2 == 0);
1588 for (i
= 0; i
< arglen
; i
+= 2)
1591 const char *fieldname
;
1592 struct value
*value
, *field
;
1594 gdb_assert (exp
->elts
[*pos
].opcode
== OP_NAME
);
1596 len
= longest_to_int (exp
->elts
[*pos
].longconst
);
1598 fieldname
= &exp
->elts
[*pos
].string
;
1599 *pos
+= 2 + BYTES_TO_EXP_ELEM (len
+ 1);
1601 value
= rust_evaluate_subexp (NULL
, exp
, pos
, noside
);
1602 if (noside
== EVAL_NORMAL
)
1604 field
= value_struct_elt (&result
, NULL
, fieldname
, NULL
,
1606 value_assign (field
, value
);
1610 if (noside
== EVAL_SKIP
)
1611 return value_from_longest (builtin_type (exp
->gdbarch
)->builtin_int
,
1613 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1614 result
= allocate_value (type
);
1616 result
= value_at_lazy (type
, addr
);
1625 struct value
*ncopies
;
1627 elt
= rust_evaluate_subexp (NULL
, exp
, pos
, noside
);
1628 ncopies
= rust_evaluate_subexp (NULL
, exp
, pos
, noside
);
1629 copies
= value_as_long (ncopies
);
1631 error (_("Array with negative number of elements"));
1633 if (noside
== EVAL_NORMAL
)
1636 std::vector
<struct value
*> eltvec (copies
);
1638 for (i
= 0; i
< copies
; ++i
)
1640 result
= value_array (0, copies
- 1, eltvec
.data ());
1644 struct type
*arraytype
1645 = lookup_array_range_type (value_type (elt
), 0, copies
- 1);
1646 result
= allocate_value (arraytype
);
1651 case STRUCTOP_ANONYMOUS
:
1653 /* Anonymous field access, i.e. foo.1. */
1655 int pc
, field_number
, nfields
;
1659 field_number
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1661 lhs
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1663 type
= value_type (lhs
);
1665 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
1667 struct type
*outer_type
= NULL
;
1669 if (rust_enum_p (type
))
1671 if (rust_empty_enum_p (type
))
1672 error (_("Cannot access field %d of empty enum %s"),
1673 field_number
, TYPE_NAME (type
));
1675 const gdb_byte
*valaddr
= value_contents (lhs
);
1676 struct field
*variant_field
= rust_enum_variant (type
, valaddr
);
1678 struct value
*union_value
= value_primitive_field (lhs
, 0, 0,
1681 int fieldno
= (variant_field
1682 - &TYPE_FIELD (value_type (union_value
), 0));
1683 lhs
= value_primitive_field (union_value
, 0, fieldno
,
1684 value_type (union_value
));
1686 type
= value_type (lhs
);
1689 /* Tuples and tuple structs */
1690 nfields
= TYPE_NFIELDS (type
);
1692 if (field_number
>= nfields
|| field_number
< 0)
1694 if (outer_type
!= NULL
)
1695 error(_("Cannot access field %d of variant %s::%s, "
1696 "there are only %d fields"),
1697 field_number
, TYPE_NAME (outer_type
),
1698 rust_last_path_segment (TYPE_NAME (type
)),
1701 error(_("Cannot access field %d of %s, "
1702 "there are only %d fields"),
1703 field_number
, TYPE_NAME (type
), nfields
);
1706 /* Tuples are tuple structs too. */
1707 if (!rust_tuple_struct_type_p (type
))
1709 if (outer_type
!= NULL
)
1710 error(_("Variant %s::%s is not a tuple variant"),
1711 TYPE_NAME (outer_type
),
1712 rust_last_path_segment (TYPE_NAME (type
)));
1714 error(_("Attempting to access anonymous field %d "
1715 "of %s, which is not a tuple, tuple struct, or "
1716 "tuple-like variant"),
1717 field_number
, TYPE_NAME (type
));
1720 result
= value_primitive_field (lhs
, 0, field_number
, type
);
1723 error(_("Anonymous field access is only allowed on tuples, \
1724 tuple structs, and tuple-like enum variants"));
1728 case STRUCTOP_STRUCT
:
1735 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1736 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1737 lhs
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1739 const char *field_name
= &exp
->elts
[pc
+ 2].string
;
1740 type
= value_type (lhs
);
1741 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
&& rust_enum_p (type
))
1743 if (rust_empty_enum_p (type
))
1744 error (_("Cannot access field %s of empty enum %s"),
1745 field_name
, TYPE_NAME (type
));
1747 const gdb_byte
*valaddr
= value_contents (lhs
);
1748 struct field
*variant_field
= rust_enum_variant (type
, valaddr
);
1750 struct value
*union_value
= value_primitive_field (lhs
, 0, 0,
1753 int fieldno
= (variant_field
1754 - &TYPE_FIELD (value_type (union_value
), 0));
1755 lhs
= value_primitive_field (union_value
, 0, fieldno
,
1756 value_type (union_value
));
1758 struct type
*outer_type
= type
;
1759 type
= value_type (lhs
);
1760 if (rust_tuple_type_p (type
) || rust_tuple_struct_type_p (type
))
1761 error (_("Attempting to access named field %s of tuple "
1762 "variant %s::%s, which has only anonymous fields"),
1763 field_name
, TYPE_NAME (outer_type
),
1764 rust_last_path_segment (TYPE_NAME (type
)));
1768 result
= value_struct_elt (&lhs
, NULL
, field_name
,
1771 catch (const gdb_exception_error
&except
)
1773 error (_("Could not find field %s of struct variant %s::%s"),
1774 field_name
, TYPE_NAME (outer_type
),
1775 rust_last_path_segment (TYPE_NAME (type
)));
1779 result
= value_struct_elt (&lhs
, NULL
, field_name
, NULL
, "structure");
1780 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1781 result
= value_zero (value_type (result
), VALUE_LVAL (result
));
1786 result
= rust_range (exp
, pos
, noside
);
1790 /* We might have &array[range], in which case we need to make a
1792 if (exp
->elts
[*pos
+ 1].opcode
== BINOP_SUBSCRIPT
)
1795 result
= rust_subscript (exp
, pos
, noside
, 1);
1800 result
= evaluate_subexp_standard (expect_type
, exp
, pos
, noside
);
1807 /* operator_length implementation for Rust. */
1810 rust_operator_length (const struct expression
*exp
, int pc
, int *oplenp
,
1816 switch (exp
->elts
[pc
- 1].opcode
)
1819 /* We handle aggregate as a type and argument count. The first
1820 argument might be OP_OTHERS. After that the arguments
1821 alternate: first an OP_NAME, then an expression. */
1823 args
= longest_to_int (exp
->elts
[pc
- 2].longconst
);
1831 case STRUCTOP_ANONYMOUS
:
1842 operator_length_standard (exp
, pc
, oplenp
, argsp
);
1850 /* op_name implementation for Rust. */
1853 rust_op_name (enum exp_opcode opcode
)
1858 return "OP_AGGREGATE";
1862 return op_name_standard (opcode
);
1866 /* dump_subexp_body implementation for Rust. */
1869 rust_dump_subexp_body (struct expression
*exp
, struct ui_file
*stream
,
1872 switch (exp
->elts
[elt
].opcode
)
1876 int length
= longest_to_int (exp
->elts
[elt
+ 2].longconst
);
1879 fprintf_filtered (stream
, "Type @");
1880 gdb_print_host_address (exp
->elts
[elt
+ 1].type
, stream
);
1881 fprintf_filtered (stream
, " (");
1882 type_print (exp
->elts
[elt
+ 1].type
, NULL
, stream
, 0);
1883 fprintf_filtered (stream
, "), length %d", length
);
1886 for (i
= 0; i
< length
; ++i
)
1887 elt
= dump_subexp (exp
, stream
, elt
);
1894 LONGEST len
= exp
->elts
[elt
+ 1].longconst
;
1896 fprintf_filtered (stream
, "%s: %s",
1897 (exp
->elts
[elt
].opcode
== OP_STRING
1898 ? "string" : "name"),
1899 &exp
->elts
[elt
+ 2].string
);
1900 elt
+= 4 + BYTES_TO_EXP_ELEM (len
+ 1);
1905 elt
= dump_subexp (exp
, stream
, elt
+ 1);
1908 case STRUCTOP_ANONYMOUS
:
1912 field_number
= longest_to_int (exp
->elts
[elt
+ 1].longconst
);
1914 fprintf_filtered (stream
, "Field number: %d", field_number
);
1915 elt
= dump_subexp (exp
, stream
, elt
+ 3);
1924 elt
= dump_subexp_body_standard (exp
, stream
, elt
);
1931 /* print_subexp implementation for Rust. */
1934 rust_print_subexp (struct expression
*exp
, int *pos
, struct ui_file
*stream
,
1935 enum precedence prec
)
1937 switch (exp
->elts
[*pos
].opcode
)
1941 int length
= longest_to_int (exp
->elts
[*pos
+ 2].longconst
);
1944 type_print (exp
->elts
[*pos
+ 1].type
, "", stream
, 0);
1945 fputs_filtered (" { ", stream
);
1948 for (i
= 0; i
< length
; ++i
)
1950 rust_print_subexp (exp
, pos
, stream
, prec
);
1951 fputs_filtered (", ", stream
);
1953 fputs_filtered (" }", stream
);
1959 LONGEST len
= exp
->elts
[*pos
+ 1].longconst
;
1961 fputs_filtered (&exp
->elts
[*pos
+ 2].string
, stream
);
1962 *pos
+= 4 + BYTES_TO_EXP_ELEM (len
+ 1);
1968 fputs_filtered ("<<others>> (", stream
);
1970 rust_print_subexp (exp
, pos
, stream
, prec
);
1971 fputs_filtered (")", stream
);
1975 case STRUCTOP_ANONYMOUS
:
1977 int tem
= longest_to_int (exp
->elts
[*pos
+ 1].longconst
);
1980 print_subexp (exp
, pos
, stream
, PREC_SUFFIX
);
1981 fprintf_filtered (stream
, ".%d", tem
);
1987 fprintf_filtered (stream
, "[");
1988 rust_print_subexp (exp
, pos
, stream
, prec
);
1989 fprintf_filtered (stream
, "; ");
1990 rust_print_subexp (exp
, pos
, stream
, prec
);
1991 fprintf_filtered (stream
, "]");
1995 print_subexp_standard (exp
, pos
, stream
, prec
);
2000 /* operator_check implementation for Rust. */
2003 rust_operator_check (struct expression
*exp
, int pos
,
2004 int (*objfile_func
) (struct objfile
*objfile
,
2008 switch (exp
->elts
[pos
].opcode
)
2012 struct type
*type
= exp
->elts
[pos
+ 1].type
;
2013 struct objfile
*objfile
= TYPE_OBJFILE (type
);
2015 if (objfile
!= NULL
&& (*objfile_func
) (objfile
, data
))
2026 return operator_check_standard (exp
, pos
, objfile_func
, data
);
2034 /* Implementation of la_lookup_symbol_nonlocal for Rust. */
2036 static struct block_symbol
2037 rust_lookup_symbol_nonlocal (const struct language_defn
*langdef
,
2039 const struct block
*block
,
2040 const domain_enum domain
)
2042 struct block_symbol result
= {};
2044 if (symbol_lookup_debug
)
2046 fprintf_unfiltered (gdb_stdlog
,
2047 "rust_lookup_symbol_non_local"
2048 " (%s, %s (scope %s), %s)\n",
2049 name
, host_address_to_string (block
),
2050 block_scope (block
), domain_name (domain
));
2053 /* Look up bare names in the block's scope. */
2054 std::string scopedname
;
2055 if (name
[cp_find_first_component (name
)] == '\0')
2057 const char *scope
= block_scope (block
);
2059 if (scope
[0] != '\0')
2061 scopedname
= std::string (scope
) + "::" + name
;
2062 name
= scopedname
.c_str ();
2070 result
= lookup_symbol_in_static_block (name
, block
, domain
);
2071 if (result
.symbol
== NULL
)
2072 result
= lookup_global_symbol (name
, block
, domain
);
2079 /* la_sniff_from_mangled_name for Rust. */
2082 rust_sniff_from_mangled_name (const char *mangled
, char **demangled
)
2084 *demangled
= gdb_demangle (mangled
, DMGL_PARAMS
| DMGL_ANSI
);
2085 return *demangled
!= NULL
;
2090 /* la_watch_location_expression for Rust. */
2092 static gdb::unique_xmalloc_ptr
<char>
2093 rust_watch_location_expression (struct type
*type
, CORE_ADDR addr
)
2095 type
= check_typedef (TYPE_TARGET_TYPE (check_typedef (type
)));
2096 std::string name
= type_to_string (type
);
2097 return gdb::unique_xmalloc_ptr
<char>
2098 (xstrprintf ("*(%s as *mut %s)", core_addr_to_string (addr
),
2104 static const struct exp_descriptor exp_descriptor_rust
=
2107 rust_operator_length
,
2108 rust_operator_check
,
2110 rust_dump_subexp_body
,
2111 rust_evaluate_subexp
2114 static const char *rust_extensions
[] =
2119 extern const struct language_defn rust_language_defn
=
2129 &exp_descriptor_rust
,
2132 rust_printchar
, /* Print a character constant */
2133 rust_printstr
, /* Function to print string constant */
2134 rust_emitchar
, /* Print a single char */
2135 rust_print_type
, /* Print a type using appropriate syntax */
2136 rust_print_typedef
, /* Print a typedef using appropriate syntax */
2137 rust_val_print
, /* Print a value using appropriate syntax */
2138 c_value_print
, /* Print a top-level value */
2139 default_read_var_value
, /* la_read_var_value */
2140 NULL
, /* Language specific skip_trampoline */
2141 NULL
, /* name_of_this */
2142 false, /* la_store_sym_names_in_linkage_form_p */
2143 rust_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
2144 basic_lookup_transparent_type
,/* lookup_transparent_type */
2145 gdb_demangle
, /* Language specific symbol demangler */
2146 rust_sniff_from_mangled_name
,
2147 NULL
, /* Language specific
2148 class_name_from_physname */
2149 c_op_print_tab
, /* expression operators for printing */
2150 1, /* c-style arrays */
2151 0, /* String lower bound */
2152 default_word_break_characters
,
2153 default_collect_symbol_completion_matches
,
2154 rust_language_arch_info
,
2155 default_print_array_index
,
2156 default_pass_by_reference
,
2158 rust_watch_location_expression
,
2159 NULL
, /* la_get_symbol_name_matcher */
2160 iterate_over_symbols
,
2161 default_search_name_hash
,
2162 &default_varobj_ops
,
2165 rust_is_string_type_p
,
2166 "{...}" /* la_struct_too_deep_ellipsis */