1 /* Rust language support routines for GDB, the GNU debugger.
3 Copyright (C) 2016-2021 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"
40 #include "cli/cli-style.h"
41 #include "parser-defs.h"
44 /* See rust-lang.h. */
47 rust_last_path_segment (const char *path
)
49 const char *result
= strrchr (path
, ':');
56 /* See rust-lang.h. */
59 rust_crate_for_block (const struct block
*block
)
61 const char *scope
= block_scope (block
);
64 return std::string ();
66 return std::string (scope
, cp_find_first_component (scope
));
69 /* Return true if TYPE, which must be a struct type, represents a Rust
73 rust_enum_p (struct type
*type
)
75 /* is_dynamic_type will return true if any field has a dynamic
76 attribute -- but we only want to check the top level. */
77 return TYPE_HAS_VARIANT_PARTS (type
);
80 /* Return true if TYPE, which must be an already-resolved enum type,
84 rust_empty_enum_p (const struct type
*type
)
86 return type
->num_fields () == 0;
89 /* Given an already-resolved enum type and contents, find which
93 rust_enum_variant (struct type
*type
)
95 /* The active variant is simply the first non-artificial field. */
96 for (int i
= 0; i
< type
->num_fields (); ++i
)
97 if (!TYPE_FIELD_ARTIFICIAL (type
, i
))
100 /* Perhaps we could get here by trying to print an Ada variant
101 record in Rust mode. Unlikely, but an error is safer than an
103 error (_("Could not find active enum variant"));
106 /* See rust-lang.h. */
109 rust_tuple_type_p (struct type
*type
)
111 /* The current implementation is a bit of a hack, but there's
112 nothing else in the debuginfo to distinguish a tuple from a
114 return (type
->code () == TYPE_CODE_STRUCT
115 && type
->name () != NULL
116 && type
->name ()[0] == '(');
119 /* Return true if all non-static fields of a structlike type are in a
120 sequence like __0, __1, __2. */
123 rust_underscore_fields (struct type
*type
)
129 if (type
->code () != TYPE_CODE_STRUCT
)
131 for (i
= 0; i
< type
->num_fields (); ++i
)
133 if (!field_is_static (&type
->field (i
)))
137 xsnprintf (buf
, sizeof (buf
), "__%d", field_number
);
138 if (strcmp (buf
, TYPE_FIELD_NAME (type
, i
)) != 0)
146 /* See rust-lang.h. */
149 rust_tuple_struct_type_p (struct type
*type
)
151 /* This is just an approximation until DWARF can represent Rust more
152 precisely. We exclude zero-length structs because they may not
153 be tuple structs, and there's no way to tell. */
154 return type
->num_fields () > 0 && rust_underscore_fields (type
);
157 /* Return true if TYPE is a slice type, otherwise false. */
160 rust_slice_type_p (struct type
*type
)
162 return (type
->code () == TYPE_CODE_STRUCT
163 && type
->name () != NULL
164 && (strncmp (type
->name (), "&[", 2) == 0
165 || strcmp (type
->name (), "&str") == 0));
168 /* Return true if TYPE is a range type, otherwise false. */
171 rust_range_type_p (struct type
*type
)
175 if (type
->code () != TYPE_CODE_STRUCT
176 || type
->num_fields () > 2
177 || type
->name () == NULL
178 || strstr (type
->name (), "::Range") == NULL
)
181 if (type
->num_fields () == 0)
185 if (strcmp (TYPE_FIELD_NAME (type
, 0), "start") == 0)
187 if (type
->num_fields () == 1)
191 else if (type
->num_fields () == 2)
193 /* First field had to be "start". */
197 return strcmp (TYPE_FIELD_NAME (type
, i
), "end") == 0;
200 /* Return true if TYPE is an inclusive range type, otherwise false.
201 This is only valid for types which are already known to be range
205 rust_inclusive_range_type_p (struct type
*type
)
207 return (strstr (type
->name (), "::RangeInclusive") != NULL
208 || strstr (type
->name (), "::RangeToInclusive") != NULL
);
211 /* Return true if TYPE seems to be the type "u8", otherwise false. */
214 rust_u8_type_p (struct type
*type
)
216 return (type
->code () == TYPE_CODE_INT
217 && type
->is_unsigned ()
218 && TYPE_LENGTH (type
) == 1);
221 /* Return true if TYPE is a Rust character type. */
224 rust_chartype_p (struct type
*type
)
226 return (type
->code () == TYPE_CODE_CHAR
227 && TYPE_LENGTH (type
) == 4
228 && type
->is_unsigned ());
231 /* If VALUE represents a trait object pointer, return the underlying
232 pointer with the correct (i.e., runtime) type. Otherwise, return
235 static struct value
*
236 rust_get_trait_object_pointer (struct value
*value
)
238 struct type
*type
= check_typedef (value_type (value
));
240 if (type
->code () != TYPE_CODE_STRUCT
|| type
->num_fields () != 2)
243 /* Try to be a bit resilient if the ABI changes. */
244 int vtable_field
= 0;
245 for (int i
= 0; i
< 2; ++i
)
247 if (strcmp (TYPE_FIELD_NAME (type
, i
), "vtable") == 0)
249 else if (strcmp (TYPE_FIELD_NAME (type
, i
), "pointer") != 0)
253 CORE_ADDR vtable
= value_as_address (value_field (value
, vtable_field
));
254 struct symbol
*symbol
= find_symbol_at_address (vtable
);
255 if (symbol
== NULL
|| symbol
->subclass
!= SYMBOL_RUST_VTABLE
)
258 struct rust_vtable_symbol
*vtable_sym
259 = static_cast<struct rust_vtable_symbol
*> (symbol
);
260 struct type
*pointer_type
= lookup_pointer_type (vtable_sym
->concrete_type
);
261 return value_cast (pointer_type
, value_field (value
, 1 - vtable_field
));
266 /* See language.h. */
269 rust_language::printstr (struct ui_file
*stream
, struct type
*type
,
270 const gdb_byte
*string
, unsigned int length
,
271 const char *user_encoding
, int force_ellipses
,
272 const struct value_print_options
*options
) const
274 /* Rust always uses UTF-8, but let the caller override this if need
276 const char *encoding
= user_encoding
;
277 if (user_encoding
== NULL
|| !*user_encoding
)
279 /* In Rust strings, characters are "u8". */
280 if (rust_u8_type_p (type
))
284 /* This is probably some C string, so let's let C deal with
286 c_printstr (stream
, type
, string
, length
, user_encoding
,
287 force_ellipses
, options
);
292 /* This is not ideal as it doesn't use our character printer. */
293 generic_printstr (stream
, type
, string
, length
, encoding
, force_ellipses
,
299 /* Helper function to print a string slice. */
302 rust_val_print_str (struct ui_file
*stream
, struct value
*val
,
303 const struct value_print_options
*options
)
305 struct value
*base
= value_struct_elt (&val
, NULL
, "data_ptr", NULL
,
307 struct value
*len
= value_struct_elt (&val
, NULL
, "length", NULL
, "slice");
309 val_print_string (TYPE_TARGET_TYPE (value_type (base
)), "UTF-8",
310 value_as_address (base
), value_as_long (len
), stream
,
314 /* See rust-lang.h. */
317 rust_language::val_print_struct
318 (struct value
*val
, struct ui_file
*stream
, int recurse
,
319 const struct value_print_options
*options
) const
323 struct type
*type
= check_typedef (value_type (val
));
325 if (rust_slice_type_p (type
) && strcmp (type
->name (), "&str") == 0)
327 /* If what we are printing here is actually a string within a
328 structure then VAL will be the original parent value, while TYPE
329 will be the type of the structure representing the string we want
331 However, RUST_VAL_PRINT_STR looks up the fields of the string
332 inside VAL, assuming that VAL is the string.
333 So, recreate VAL as a value representing just the string. */
334 val
= value_at_lazy (type
, value_address (val
));
335 rust_val_print_str (stream
, val
, options
);
339 bool is_tuple
= rust_tuple_type_p (type
);
340 bool is_tuple_struct
= !is_tuple
&& rust_tuple_struct_type_p (type
);
341 struct value_print_options opts
;
345 if (type
->name () != NULL
)
346 fprintf_filtered (stream
, "%s", type
->name ());
348 if (type
->num_fields () == 0)
351 if (type
->name () != NULL
)
352 fputs_filtered (" ", stream
);
355 if (is_tuple
|| is_tuple_struct
)
356 fputs_filtered ("(", stream
);
358 fputs_filtered ("{", stream
);
364 for (i
= 0; i
< type
->num_fields (); ++i
)
366 if (field_is_static (&type
->field (i
)))
370 fputs_filtered (",", stream
);
372 if (options
->prettyformat
)
374 fputs_filtered ("\n", stream
);
375 print_spaces_filtered (2 + 2 * recurse
, stream
);
377 else if (!first_field
)
378 fputs_filtered (" ", stream
);
382 if (!is_tuple
&& !is_tuple_struct
)
384 fputs_styled (TYPE_FIELD_NAME (type
, i
),
385 variable_name_style
.style (), stream
);
386 fputs_filtered (": ", stream
);
389 value_print_inner (value_field (val
, i
), stream
, recurse
+ 1, &opts
);
392 if (options
->prettyformat
)
394 fputs_filtered ("\n", stream
);
395 print_spaces_filtered (2 * recurse
, stream
);
398 if (is_tuple
|| is_tuple_struct
)
399 fputs_filtered (")", stream
);
401 fputs_filtered ("}", stream
);
404 /* See rust-lang.h. */
407 rust_language::print_enum (struct value
*val
, struct ui_file
*stream
,
409 const struct value_print_options
*options
) const
411 struct value_print_options opts
= *options
;
412 struct type
*type
= check_typedef (value_type (val
));
416 gdb_assert (rust_enum_p (type
));
417 gdb::array_view
<const gdb_byte
> view (value_contents_for_printing (val
),
418 TYPE_LENGTH (value_type (val
)));
419 type
= resolve_dynamic_type (type
, view
, value_address (val
));
421 if (rust_empty_enum_p (type
))
423 /* Print the enum type name here to be more clear. */
424 fprintf_filtered (stream
, _("%s {%p[<No data fields>%p]}"),
426 metadata_style
.style ().ptr (), nullptr);
430 int variant_fieldno
= rust_enum_variant (type
);
431 val
= value_field (val
, variant_fieldno
);
432 struct type
*variant_type
= type
->field (variant_fieldno
).type ();
434 int nfields
= variant_type
->num_fields ();
436 bool is_tuple
= rust_tuple_struct_type_p (variant_type
);
438 fprintf_filtered (stream
, "%s", variant_type
->name ());
441 /* In case of a nullary variant like 'None', just output
446 /* In case of a non-nullary variant, we output 'Foo(x,y,z)'. */
448 fprintf_filtered (stream
, "(");
451 /* struct variant. */
452 fprintf_filtered (stream
, "{");
455 bool first_field
= true;
456 for (int j
= 0; j
< variant_type
->num_fields (); j
++)
459 fputs_filtered (", ", stream
);
463 fprintf_filtered (stream
, "%ps: ",
464 styled_string (variable_name_style
.style (),
465 TYPE_FIELD_NAME (variant_type
, j
)));
467 value_print_inner (value_field (val
, j
), stream
, recurse
+ 1, &opts
);
471 fputs_filtered (")", stream
);
473 fputs_filtered ("}", stream
);
476 static const struct generic_val_print_decorations rust_decorations
=
478 /* Complex isn't used in Rust, but we provide C-ish values just in
490 /* See language.h. */
493 rust_language::value_print_inner
494 (struct value
*val
, struct ui_file
*stream
, int recurse
,
495 const struct value_print_options
*options
) const
497 struct value_print_options opts
= *options
;
500 if (opts
.prettyformat
== Val_prettyformat_default
)
501 opts
.prettyformat
= (opts
.prettyformat_structs
502 ? Val_prettyformat
: Val_no_prettyformat
);
504 struct type
*type
= check_typedef (value_type (val
));
505 switch (type
->code ())
509 LONGEST low_bound
, high_bound
;
511 if (TYPE_TARGET_TYPE (type
)->code () == TYPE_CODE_ARRAY
512 && rust_u8_type_p (TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (type
)))
513 && get_array_bounds (TYPE_TARGET_TYPE (type
), &low_bound
,
516 /* We have a pointer to a byte string, so just print
518 struct type
*elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
519 CORE_ADDR addr
= value_as_address (val
);
520 struct gdbarch
*arch
= type
->arch ();
522 if (opts
.addressprint
)
524 fputs_filtered (paddress (arch
, addr
), stream
);
525 fputs_filtered (" ", stream
);
528 fputs_filtered ("b", stream
);
529 val_print_string (TYPE_TARGET_TYPE (elttype
), "ASCII", addr
,
530 high_bound
- low_bound
+ 1, stream
,
538 /* Recognize the unit type. */
539 if (type
->is_unsigned () && TYPE_LENGTH (type
) == 0
540 && type
->name () != NULL
&& strcmp (type
->name (), "()") == 0)
542 fputs_filtered ("()", stream
);
547 case TYPE_CODE_STRING
:
549 LONGEST low_bound
, high_bound
;
551 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
552 error (_("Could not determine the array bounds"));
554 /* If we see a plain TYPE_CODE_STRING, then we're printing a
555 byte string, hence the choice of "ASCII" as the
557 fputs_filtered ("b", stream
);
558 printstr (stream
, TYPE_TARGET_TYPE (type
),
559 value_contents_for_printing (val
),
560 high_bound
- low_bound
+ 1, "ASCII", 0, &opts
);
564 case TYPE_CODE_ARRAY
:
566 LONGEST low_bound
, high_bound
;
568 if (get_array_bounds (type
, &low_bound
, &high_bound
)
569 && high_bound
- low_bound
+ 1 == 0)
570 fputs_filtered ("[]", stream
);
576 case TYPE_CODE_UNION
:
577 /* Untagged unions are printed as if they are structs. Since
578 the field bit positions overlap in the debuginfo, the code
579 for printing a union is same as that for a struct, the only
580 difference is that the input type will have overlapping
582 val_print_struct (val
, stream
, recurse
, &opts
);
585 case TYPE_CODE_STRUCT
:
586 if (rust_enum_p (type
))
587 print_enum (val
, stream
, recurse
, &opts
);
589 val_print_struct (val
, stream
, recurse
, &opts
);
594 /* Nothing special yet. */
595 generic_value_print (val
, stream
, recurse
, &opts
, &rust_decorations
);
602 rust_internal_print_type (struct type
*type
, const char *varstring
,
603 struct ui_file
*stream
, int show
, int level
,
604 const struct type_print_options
*flags
,
605 bool for_rust_enum
, print_offset_data
*podata
);
607 /* Print a struct or union typedef. */
609 rust_print_struct_def (struct type
*type
, const char *varstring
,
610 struct ui_file
*stream
, int show
, int level
,
611 const struct type_print_options
*flags
,
612 bool for_rust_enum
, print_offset_data
*podata
)
614 /* Print a tuple type simply. */
615 if (rust_tuple_type_p (type
))
617 fputs_filtered (type
->name (), stream
);
621 /* If we see a base class, delegate to C. */
622 if (TYPE_N_BASECLASSES (type
) > 0)
623 c_print_type (type
, varstring
, stream
, show
, level
, flags
);
625 if (flags
->print_offsets
)
627 /* Temporarily bump the level so that the output lines up
632 /* Compute properties of TYPE here because, in the enum case, the
633 rest of the code ends up looking only at the variant part. */
634 const char *tagname
= type
->name ();
635 bool is_tuple_struct
= rust_tuple_struct_type_p (type
);
636 bool is_tuple
= rust_tuple_type_p (type
);
637 bool is_enum
= rust_enum_p (type
);
641 /* Already printing an outer enum, so nothing to print here. */
645 /* This code path is also used by unions and enums. */
648 fputs_filtered ("enum ", stream
);
649 dynamic_prop
*prop
= type
->dyn_prop (DYN_PROP_VARIANT_PARTS
);
650 if (prop
!= nullptr && prop
->kind () == PROP_TYPE
)
651 type
= prop
->original_type ();
653 else if (type
->code () == TYPE_CODE_STRUCT
)
654 fputs_filtered ("struct ", stream
);
656 fputs_filtered ("union ", stream
);
659 fputs_filtered (tagname
, stream
);
662 if (type
->num_fields () == 0 && !is_tuple
)
664 if (for_rust_enum
&& !flags
->print_offsets
)
665 fputs_filtered (is_tuple_struct
? "(" : "{", stream
);
667 fputs_filtered (is_tuple_struct
? " (\n" : " {\n", stream
);
669 /* When printing offsets, we rearrange the fields into storage
670 order. This lets us show holes more clearly. We work using
671 field indices here because it simplifies calls to
672 print_offset_data::update below. */
673 std::vector
<int> fields
;
674 for (int i
= 0; i
< type
->num_fields (); ++i
)
676 if (field_is_static (&type
->field (i
)))
678 if (is_enum
&& TYPE_FIELD_ARTIFICIAL (type
, i
))
680 fields
.push_back (i
);
682 if (flags
->print_offsets
)
683 std::sort (fields
.begin (), fields
.end (),
686 return (TYPE_FIELD_BITPOS (type
, a
)
687 < TYPE_FIELD_BITPOS (type
, b
));
694 gdb_assert (!field_is_static (&type
->field (i
)));
695 gdb_assert (! (is_enum
&& TYPE_FIELD_ARTIFICIAL (type
, i
)));
697 if (flags
->print_offsets
)
698 podata
->update (type
, i
, stream
);
700 /* We'd like to print "pub" here as needed, but rustc
701 doesn't emit the debuginfo, and our types don't have
702 cplus_struct_type attached. */
704 /* For a tuple struct we print the type but nothing
706 if (!for_rust_enum
|| flags
->print_offsets
)
707 print_spaces_filtered (level
+ 2, stream
);
709 fputs_styled (TYPE_FIELD_NAME (type
, i
), variable_name_style
.style (),
711 else if (!is_tuple_struct
)
712 fprintf_filtered (stream
, "%ps: ",
713 styled_string (variable_name_style
.style (),
714 TYPE_FIELD_NAME (type
, i
)));
716 rust_internal_print_type (type
->field (i
).type (), NULL
,
717 stream
, (is_enum
? show
: show
- 1),
718 level
+ 2, flags
, is_enum
, podata
);
719 if (!for_rust_enum
|| flags
->print_offsets
)
720 fputs_filtered (",\n", stream
);
721 /* Note that this check of "I" is ok because we only sorted the
722 fields by offset when print_offsets was set, so we won't take
723 this branch in that case. */
724 else if (i
+ 1 < type
->num_fields ())
725 fputs_filtered (", ", stream
);
728 if (flags
->print_offsets
)
730 /* Undo the temporary level increase we did above. */
732 podata
->finish (type
, level
, stream
);
733 print_spaces_filtered (print_offset_data::indentation
, stream
);
735 print_spaces_filtered (2, stream
);
737 if (!for_rust_enum
|| flags
->print_offsets
)
738 print_spaces_filtered (level
, stream
);
739 fputs_filtered (is_tuple_struct
? ")" : "}", stream
);
742 /* la_print_type implementation for Rust. */
745 rust_internal_print_type (struct type
*type
, const char *varstring
,
746 struct ui_file
*stream
, int show
, int level
,
747 const struct type_print_options
*flags
,
748 bool for_rust_enum
, print_offset_data
*podata
)
752 && type
->name () != NULL
)
754 /* Rust calls the unit type "void" in its debuginfo,
755 but we don't want to print it as that. */
756 if (type
->code () == TYPE_CODE_VOID
)
757 fputs_filtered ("()", stream
);
759 fputs_filtered (type
->name (), stream
);
763 type
= check_typedef (type
);
764 switch (type
->code ())
767 /* If we have an enum, we've already printed the type's
768 unqualified name, and there is nothing else to print
771 fputs_filtered ("()", stream
);
775 /* Delegate varargs to the C printer. */
776 if (type
->has_varargs ())
779 fputs_filtered ("fn ", stream
);
780 if (varstring
!= NULL
)
781 fputs_filtered (varstring
, stream
);
782 fputs_filtered ("(", stream
);
783 for (int i
= 0; i
< type
->num_fields (); ++i
)
787 fputs_filtered (", ", stream
);
788 rust_internal_print_type (type
->field (i
).type (), "", stream
,
789 -1, 0, flags
, false, podata
);
791 fputs_filtered (")", stream
);
792 /* If it returns unit, we can omit the return type. */
793 if (TYPE_TARGET_TYPE (type
)->code () != TYPE_CODE_VOID
)
795 fputs_filtered (" -> ", stream
);
796 rust_internal_print_type (TYPE_TARGET_TYPE (type
), "", stream
,
797 -1, 0, flags
, false, podata
);
801 case TYPE_CODE_ARRAY
:
803 LONGEST low_bound
, high_bound
;
805 fputs_filtered ("[", stream
);
806 rust_internal_print_type (TYPE_TARGET_TYPE (type
), NULL
,
807 stream
, show
- 1, level
, flags
, false,
810 if (type
->bounds ()->high
.kind () == PROP_LOCEXPR
811 || type
->bounds ()->high
.kind () == PROP_LOCLIST
)
812 fprintf_filtered (stream
, "; variable length");
813 else if (get_array_bounds (type
, &low_bound
, &high_bound
))
814 fprintf_filtered (stream
, "; %s",
815 plongest (high_bound
- low_bound
+ 1));
816 fputs_filtered ("]", stream
);
820 case TYPE_CODE_UNION
:
821 case TYPE_CODE_STRUCT
:
822 rust_print_struct_def (type
, varstring
, stream
, show
, level
, flags
,
823 for_rust_enum
, podata
);
830 fputs_filtered ("enum ", stream
);
831 if (type
->name () != NULL
)
833 fputs_filtered (type
->name (), stream
);
834 fputs_filtered (" ", stream
);
835 len
= strlen (type
->name ());
837 fputs_filtered ("{\n", stream
);
839 for (int i
= 0; i
< type
->num_fields (); ++i
)
841 const char *name
= TYPE_FIELD_NAME (type
, i
);
846 && strncmp (name
, type
->name (), len
) == 0
848 && name
[len
+ 1] == ':')
850 fprintf_filtered (stream
, "%*s%ps,\n",
852 styled_string (variable_name_style
.style (),
856 fputs_filtered ("}", stream
);
862 if (type
->name () != nullptr)
863 fputs_filtered (type
->name (), stream
);
866 /* We currently can't distinguish between pointers and
868 fputs_filtered ("*mut ", stream
);
869 type_print (TYPE_TARGET_TYPE (type
), "", stream
, 0);
876 c_print_type (type
, varstring
, stream
, show
, level
, flags
);
882 /* Like arch_composite_type, but uses TYPE to decide how to allocate
883 -- either on an obstack or on a gdbarch. */
886 rust_composite_type (struct type
*original
,
888 const char *field1
, struct type
*type1
,
889 const char *field2
, struct type
*type2
)
891 struct type
*result
= alloc_type_copy (original
);
892 int i
, nfields
, bitpos
;
900 result
->set_code (TYPE_CODE_STRUCT
);
901 result
->set_name (name
);
903 result
->set_num_fields (nfields
);
905 ((struct field
*) TYPE_ZALLOC (result
, nfields
* sizeof (struct field
)));
911 struct field
*field
= &result
->field (i
);
913 SET_FIELD_BITPOS (*field
, bitpos
);
914 bitpos
+= TYPE_LENGTH (type1
) * TARGET_CHAR_BIT
;
916 FIELD_NAME (*field
) = field1
;
917 field
->set_type (type1
);
922 struct field
*field
= &result
->field (i
);
923 unsigned align
= type_align (type2
);
929 align
*= TARGET_CHAR_BIT
;
930 delta
= bitpos
% align
;
932 bitpos
+= align
- delta
;
934 SET_FIELD_BITPOS (*field
, bitpos
);
936 FIELD_NAME (*field
) = field2
;
937 field
->set_type (type2
);
943 = (TYPE_FIELD_BITPOS (result
, i
- 1) / TARGET_CHAR_BIT
+
944 TYPE_LENGTH (result
->field (i
- 1).type ()));
948 /* See rust-lang.h. */
951 rust_slice_type (const char *name
, struct type
*elt_type
,
952 struct type
*usize_type
)
956 elt_type
= lookup_pointer_type (elt_type
);
957 type
= rust_composite_type (elt_type
, name
,
958 "data_ptr", elt_type
,
959 "length", usize_type
);
966 /* A helper for rust_evaluate_subexp that handles OP_RANGE. */
969 rust_range (struct type
*expect_type
, struct expression
*exp
,
970 enum noside noside
, enum range_flag kind
,
971 struct value
*low
, struct value
*high
)
973 struct value
*addrval
, *result
;
975 struct type
*range_type
;
976 struct type
*index_type
;
977 struct type
*temp_type
;
980 bool inclusive
= !(kind
& RANGE_HIGH_BOUND_EXCLUSIVE
);
987 name
= "std::ops::RangeFull";
991 index_type
= value_type (high
);
993 ? "std::ops::RangeToInclusive" : "std::ops::RangeTo");
1000 index_type
= value_type (low
);
1001 name
= "std::ops::RangeFrom";
1005 if (!types_equal (value_type (low
), value_type (high
)))
1006 error (_("Range expression with different types"));
1007 index_type
= value_type (low
);
1008 name
= inclusive
? "std::ops::RangeInclusive" : "std::ops::Range";
1012 /* If we don't have an index type, just allocate this on the
1013 arch. Here any type will do. */
1014 temp_type
= (index_type
== NULL
1015 ? language_bool_type (exp
->language_defn
, exp
->gdbarch
)
1017 /* It would be nicer to cache the range type. */
1018 range_type
= rust_composite_type (temp_type
, name
,
1019 low
== NULL
? NULL
: "start", index_type
,
1020 high
== NULL
? NULL
: "end", index_type
);
1022 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1023 return value_zero (range_type
, lval_memory
);
1025 addrval
= value_allocate_space_in_inferior (TYPE_LENGTH (range_type
));
1026 addr
= value_as_long (addrval
);
1027 result
= value_at_lazy (range_type
, addr
);
1031 struct value
*start
= value_struct_elt (&result
, NULL
, "start", NULL
,
1034 value_assign (start
, low
);
1039 struct value
*end
= value_struct_elt (&result
, NULL
, "end", NULL
,
1042 value_assign (end
, high
);
1045 result
= value_at_lazy (range_type
, addr
);
1049 /* A helper function to compute the range and kind given a range
1050 value. TYPE is the type of the range value. RANGE is the range
1051 value. LOW, HIGH, and KIND are out parameters. The LOW and HIGH
1052 parameters might be filled in, or might not be, depending on the
1053 kind of range this is. KIND will always be set to the appropriate
1054 value describing the kind of range, and this can be used to
1055 determine whether LOW or HIGH are valid. */
1058 rust_compute_range (struct type
*type
, struct value
*range
,
1059 LONGEST
*low
, LONGEST
*high
,
1066 *kind
= RANGE_LOW_BOUND_DEFAULT
| RANGE_HIGH_BOUND_DEFAULT
;
1068 if (type
->num_fields () == 0)
1072 if (strcmp (TYPE_FIELD_NAME (type
, 0), "start") == 0)
1074 *kind
= RANGE_HIGH_BOUND_DEFAULT
;
1075 *low
= value_as_long (value_field (range
, 0));
1078 if (type
->num_fields () > i
1079 && strcmp (TYPE_FIELD_NAME (type
, i
), "end") == 0)
1081 *kind
= (*kind
== (RANGE_LOW_BOUND_DEFAULT
| RANGE_HIGH_BOUND_DEFAULT
)
1082 ? RANGE_LOW_BOUND_DEFAULT
: RANGE_STANDARD
);
1083 *high
= value_as_long (value_field (range
, i
));
1085 if (rust_inclusive_range_type_p (type
))
1090 /* A helper for rust_evaluate_subexp that handles BINOP_SUBSCRIPT. */
1093 rust_subscript (struct type
*expect_type
, struct expression
*exp
,
1094 enum noside noside
, bool for_addr
,
1095 struct value
*lhs
, struct value
*rhs
)
1097 struct value
*result
;
1098 struct type
*rhstype
;
1099 LONGEST low
, high_bound
;
1100 /* Initialized to appease the compiler. */
1101 range_flags kind
= RANGE_LOW_BOUND_DEFAULT
| RANGE_HIGH_BOUND_DEFAULT
;
1105 rhstype
= check_typedef (value_type (rhs
));
1106 if (rust_range_type_p (rhstype
))
1109 error (_("Can't take slice of array without '&'"));
1110 rust_compute_range (rhstype
, rhs
, &low
, &high
, &kind
);
1114 low
= value_as_long (rhs
);
1116 struct type
*type
= check_typedef (value_type (lhs
));
1117 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1119 struct type
*base_type
= nullptr;
1120 if (type
->code () == TYPE_CODE_ARRAY
)
1121 base_type
= TYPE_TARGET_TYPE (type
);
1122 else if (rust_slice_type_p (type
))
1124 for (int i
= 0; i
< type
->num_fields (); ++i
)
1126 if (strcmp (TYPE_FIELD_NAME (type
, i
), "data_ptr") == 0)
1128 base_type
= TYPE_TARGET_TYPE (type
->field (i
).type ());
1132 if (base_type
== nullptr)
1133 error (_("Could not find 'data_ptr' in slice type"));
1135 else if (type
->code () == TYPE_CODE_PTR
)
1136 base_type
= TYPE_TARGET_TYPE (type
);
1138 error (_("Cannot subscript non-array type"));
1140 struct type
*new_type
;
1143 if (rust_slice_type_p (type
))
1148 = language_lookup_primitive_type (exp
->language_defn
,
1151 new_type
= rust_slice_type ("&[*gdb*]", base_type
, usize
);
1155 new_type
= base_type
;
1157 return value_zero (new_type
, VALUE_LVAL (lhs
));
1164 if (type
->code () == TYPE_CODE_ARRAY
)
1167 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
1168 error (_("Can't compute array bounds"));
1170 error (_("Found array with non-zero lower bound"));
1173 else if (rust_slice_type_p (type
))
1177 base
= value_struct_elt (&lhs
, NULL
, "data_ptr", NULL
, "slice");
1178 len
= value_struct_elt (&lhs
, NULL
, "length", NULL
, "slice");
1180 high_bound
= value_as_long (len
);
1182 else if (type
->code () == TYPE_CODE_PTR
)
1186 high_bound
= LONGEST_MAX
;
1189 error (_("Cannot subscript non-array type"));
1191 if (want_slice
&& (kind
& RANGE_LOW_BOUND_DEFAULT
))
1194 error (_("Index less than zero"));
1195 if (low
> high_bound
)
1196 error (_("Index greater than length"));
1198 result
= value_subscript (base
, low
);
1205 struct type
*usize
, *slice
;
1207 struct value
*addrval
, *tem
;
1209 if (kind
& RANGE_HIGH_BOUND_DEFAULT
)
1212 error (_("High index less than zero"));
1214 error (_("Low index greater than high index"));
1215 if (high
> high_bound
)
1216 error (_("High index greater than length"));
1218 usize
= language_lookup_primitive_type (exp
->language_defn
,
1221 const char *new_name
= ((type
!= nullptr
1222 && rust_slice_type_p (type
))
1223 ? type
->name () : "&[*gdb*]");
1225 slice
= rust_slice_type (new_name
, value_type (result
), usize
);
1227 addrval
= value_allocate_space_in_inferior (TYPE_LENGTH (slice
));
1228 addr
= value_as_long (addrval
);
1229 tem
= value_at_lazy (slice
, addr
);
1231 value_assign (value_field (tem
, 0), value_addr (result
));
1232 value_assign (value_field (tem
, 1),
1233 value_from_longest (usize
, high
- low
));
1235 result
= value_at_lazy (slice
, addr
);
1238 result
= value_addr (result
);
1244 /* A helper function for UNOP_IND. */
1247 eval_op_rust_ind (struct type
*expect_type
, struct expression
*exp
,
1249 enum exp_opcode opcode
,
1250 struct value
*value
)
1252 gdb_assert (noside
== EVAL_NORMAL
);
1253 struct value
*trait_ptr
= rust_get_trait_object_pointer (value
);
1254 if (trait_ptr
!= NULL
)
1257 return value_ind (value
);
1260 /* A helper function for UNOP_COMPLEMENT. */
1263 eval_op_rust_complement (struct type
*expect_type
, struct expression
*exp
,
1265 enum exp_opcode opcode
,
1266 struct value
*value
)
1268 if (value_type (value
)->code () == TYPE_CODE_BOOL
)
1269 return value_from_longest (value_type (value
), value_logical_not (value
));
1270 return value_complement (value
);
1273 /* A helper function for OP_ARRAY. */
1276 eval_op_rust_array (struct type
*expect_type
, struct expression
*exp
,
1278 enum exp_opcode opcode
,
1279 struct value
*elt
, struct value
*ncopies
)
1281 int copies
= value_as_long (ncopies
);
1283 error (_("Array with negative number of elements"));
1285 if (noside
== EVAL_NORMAL
)
1288 std::vector
<struct value
*> eltvec (copies
);
1290 for (i
= 0; i
< copies
; ++i
)
1292 return value_array (0, copies
- 1, eltvec
.data ());
1296 struct type
*arraytype
1297 = lookup_array_range_type (value_type (elt
), 0, copies
- 1);
1298 return allocate_value (arraytype
);
1302 /* A helper function for STRUCTOP_ANONYMOUS. */
1305 eval_op_rust_struct_anon (struct type
*expect_type
, struct expression
*exp
,
1307 int field_number
, struct value
*lhs
)
1309 struct type
*type
= value_type (lhs
);
1311 if (type
->code () == TYPE_CODE_STRUCT
)
1313 struct type
*outer_type
= NULL
;
1315 if (rust_enum_p (type
))
1317 gdb::array_view
<const gdb_byte
> view (value_contents (lhs
),
1318 TYPE_LENGTH (type
));
1319 type
= resolve_dynamic_type (type
, view
, value_address (lhs
));
1321 if (rust_empty_enum_p (type
))
1322 error (_("Cannot access field %d of empty enum %s"),
1323 field_number
, type
->name ());
1325 int fieldno
= rust_enum_variant (type
);
1326 lhs
= value_primitive_field (lhs
, 0, fieldno
, type
);
1328 type
= value_type (lhs
);
1331 /* Tuples and tuple structs */
1332 int nfields
= type
->num_fields ();
1334 if (field_number
>= nfields
|| field_number
< 0)
1336 if (outer_type
!= NULL
)
1337 error(_("Cannot access field %d of variant %s::%s, "
1338 "there are only %d fields"),
1339 field_number
, outer_type
->name (),
1340 rust_last_path_segment (type
->name ()),
1343 error(_("Cannot access field %d of %s, "
1344 "there are only %d fields"),
1345 field_number
, type
->name (), nfields
);
1348 /* Tuples are tuple structs too. */
1349 if (!rust_tuple_struct_type_p (type
))
1351 if (outer_type
!= NULL
)
1352 error(_("Variant %s::%s is not a tuple variant"),
1353 outer_type
->name (),
1354 rust_last_path_segment (type
->name ()));
1356 error(_("Attempting to access anonymous field %d "
1357 "of %s, which is not a tuple, tuple struct, or "
1358 "tuple-like variant"),
1359 field_number
, type
->name ());
1362 return value_primitive_field (lhs
, 0, field_number
, type
);
1365 error(_("Anonymous field access is only allowed on tuples, \
1366 tuple structs, and tuple-like enum variants"));
1369 /* A helper function for STRUCTOP_STRUCT. */
1372 eval_op_rust_structop (struct type
*expect_type
, struct expression
*exp
,
1374 struct value
*lhs
, const char *field_name
)
1376 struct value
*result
;
1377 struct type
*type
= value_type (lhs
);
1378 if (type
->code () == TYPE_CODE_STRUCT
&& rust_enum_p (type
))
1380 gdb::array_view
<const gdb_byte
> view (value_contents (lhs
),
1381 TYPE_LENGTH (type
));
1382 type
= resolve_dynamic_type (type
, view
, value_address (lhs
));
1384 if (rust_empty_enum_p (type
))
1385 error (_("Cannot access field %s of empty enum %s"),
1386 field_name
, type
->name ());
1388 int fieldno
= rust_enum_variant (type
);
1389 lhs
= value_primitive_field (lhs
, 0, fieldno
, type
);
1391 struct type
*outer_type
= type
;
1392 type
= value_type (lhs
);
1393 if (rust_tuple_type_p (type
) || rust_tuple_struct_type_p (type
))
1394 error (_("Attempting to access named field %s of tuple "
1395 "variant %s::%s, which has only anonymous fields"),
1396 field_name
, outer_type
->name (),
1397 rust_last_path_segment (type
->name ()));
1401 result
= value_struct_elt (&lhs
, NULL
, field_name
,
1404 catch (const gdb_exception_error
&except
)
1406 error (_("Could not find field %s of struct variant %s::%s"),
1407 field_name
, outer_type
->name (),
1408 rust_last_path_segment (type
->name ()));
1412 result
= value_struct_elt (&lhs
, NULL
, field_name
, NULL
, "structure");
1413 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1414 result
= value_zero (value_type (result
), VALUE_LVAL (result
));
1422 rust_aggregate_operation::evaluate (struct type
*expect_type
,
1423 struct expression
*exp
,
1426 struct type
*type
= std::get
<0> (m_storage
);
1428 struct value
*addrval
= NULL
;
1431 if (noside
== EVAL_NORMAL
)
1433 addrval
= value_allocate_space_in_inferior (TYPE_LENGTH (type
));
1434 addr
= value_as_long (addrval
);
1435 result
= value_at_lazy (type
, addr
);
1438 if (std::get
<1> (m_storage
) != nullptr)
1440 struct value
*init
= std::get
<1> (m_storage
)->evaluate (nullptr, exp
,
1443 if (noside
== EVAL_NORMAL
)
1445 /* This isn't quite right but will do for the time
1446 being, seeing that we can't implement the Copy
1448 value_assign (result
, init
);
1452 for (const auto &item
: std::get
<2> (m_storage
))
1454 value
*val
= item
.second
->evaluate (nullptr, exp
, noside
);
1455 if (noside
== EVAL_NORMAL
)
1457 const char *fieldname
= item
.first
.c_str ();
1458 value
*field
= value_struct_elt (&result
, nullptr, fieldname
,
1459 nullptr, "structure");
1460 value_assign (field
, val
);
1464 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1465 result
= allocate_value (type
);
1467 result
= value_at_lazy (type
, addr
);
1473 rust_structop::evaluate_funcall (struct type
*expect_type
,
1474 struct expression
*exp
,
1476 const std::vector
<operation_up
> &ops
)
1478 std::vector
<struct value
*> args (ops
.size () + 1);
1480 /* Evaluate the argument to STRUCTOP_STRUCT, then find its
1481 type in order to look up the method. */
1482 args
[0] = std::get
<0> (m_storage
)->evaluate (nullptr, exp
, noside
);
1483 /* We don't yet implement real Deref semantics. */
1484 while (value_type (args
[0])->code () == TYPE_CODE_PTR
)
1485 args
[0] = value_ind (args
[0]);
1487 struct type
*type
= value_type (args
[0]);
1488 if ((type
->code () != TYPE_CODE_STRUCT
1489 && type
->code () != TYPE_CODE_UNION
1490 && type
->code () != TYPE_CODE_ENUM
)
1491 || rust_tuple_type_p (type
))
1492 error (_("Method calls only supported on struct or enum types"));
1493 if (type
->name () == NULL
)
1494 error (_("Method call on nameless type"));
1496 std::string name
= (std::string (type
->name ()) + "::"
1497 + std::get
<1> (m_storage
));
1499 const struct block
*block
= get_selected_block (0);
1500 struct block_symbol sym
= lookup_symbol (name
.c_str (), block
,
1502 if (sym
.symbol
== NULL
)
1503 error (_("Could not find function named '%s'"), name
.c_str ());
1505 struct type
*fn_type
= SYMBOL_TYPE (sym
.symbol
);
1506 if (fn_type
->num_fields () == 0)
1507 error (_("Function '%s' takes no arguments"), name
.c_str ());
1509 if (fn_type
->field (0).type ()->code () == TYPE_CODE_PTR
)
1510 args
[0] = value_addr (args
[0]);
1512 value
*function
= address_of_variable (sym
.symbol
, block
);
1514 for (int i
= 0; i
< ops
.size (); ++i
)
1515 args
[i
+ 1] = ops
[i
]->evaluate (nullptr, exp
, noside
);
1517 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1518 return value_zero (TYPE_TARGET_TYPE (fn_type
), not_lval
);
1519 return call_function_by_hand (function
, NULL
, args
);
1526 /* See language.h. */
1529 rust_language::language_arch_info (struct gdbarch
*gdbarch
,
1530 struct language_arch_info
*lai
) const
1532 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
1534 /* Helper function to allow shorter lines below. */
1535 auto add
= [&] (struct type
* t
) -> struct type
*
1537 lai
->add_primitive_type (t
);
1541 struct type
*bool_type
1542 = add (arch_boolean_type (gdbarch
, 8, 1, "bool"));
1543 add (arch_character_type (gdbarch
, 32, 1, "char"));
1544 add (arch_integer_type (gdbarch
, 8, 0, "i8"));
1545 struct type
*u8_type
1546 = add (arch_integer_type (gdbarch
, 8, 1, "u8"));
1547 add (arch_integer_type (gdbarch
, 16, 0, "i16"));
1548 add (arch_integer_type (gdbarch
, 16, 1, "u16"));
1549 add (arch_integer_type (gdbarch
, 32, 0, "i32"));
1550 add (arch_integer_type (gdbarch
, 32, 1, "u32"));
1551 add (arch_integer_type (gdbarch
, 64, 0, "i64"));
1552 add (arch_integer_type (gdbarch
, 64, 1, "u64"));
1554 unsigned int length
= 8 * TYPE_LENGTH (builtin
->builtin_data_ptr
);
1555 add (arch_integer_type (gdbarch
, length
, 0, "isize"));
1556 struct type
*usize_type
1557 = add (arch_integer_type (gdbarch
, length
, 1, "usize"));
1559 add (arch_float_type (gdbarch
, 32, "f32", floatformats_ieee_single
));
1560 add (arch_float_type (gdbarch
, 64, "f64", floatformats_ieee_double
));
1561 add (arch_integer_type (gdbarch
, 0, 1, "()"));
1563 struct type
*tem
= make_cv_type (1, 0, u8_type
, NULL
);
1564 add (rust_slice_type ("&str", tem
, usize_type
));
1566 lai
->set_bool_type (bool_type
);
1567 lai
->set_string_char_type (u8_type
);
1570 /* See language.h. */
1573 rust_language::print_type (struct type
*type
, const char *varstring
,
1574 struct ui_file
*stream
, int show
, int level
,
1575 const struct type_print_options
*flags
) const
1577 print_offset_data podata
;
1578 rust_internal_print_type (type
, varstring
, stream
, show
, level
,
1579 flags
, false, &podata
);
1582 /* See language.h. */
1585 rust_language::emitchar (int ch
, struct type
*chtype
,
1586 struct ui_file
*stream
, int quoter
) const
1588 if (!rust_chartype_p (chtype
))
1589 generic_emit_char (ch
, chtype
, stream
, quoter
,
1590 target_charset (chtype
->arch ()));
1591 else if (ch
== '\\' || ch
== quoter
)
1592 fprintf_filtered (stream
, "\\%c", ch
);
1593 else if (ch
== '\n')
1594 fputs_filtered ("\\n", stream
);
1595 else if (ch
== '\r')
1596 fputs_filtered ("\\r", stream
);
1597 else if (ch
== '\t')
1598 fputs_filtered ("\\t", stream
);
1599 else if (ch
== '\0')
1600 fputs_filtered ("\\0", stream
);
1601 else if (ch
>= 32 && ch
<= 127 && isprint (ch
))
1602 fputc_filtered (ch
, stream
);
1604 fprintf_filtered (stream
, "\\x%02x", ch
);
1606 fprintf_filtered (stream
, "\\u{%06x}", ch
);
1609 /* See language.h. */
1612 rust_language::is_string_type_p (struct type
*type
) const
1614 LONGEST low_bound
, high_bound
;
1616 type
= check_typedef (type
);
1617 return ((type
->code () == TYPE_CODE_STRING
)
1618 || (type
->code () == TYPE_CODE_PTR
1619 && (TYPE_TARGET_TYPE (type
)->code () == TYPE_CODE_ARRAY
1620 && rust_u8_type_p (TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (type
)))
1621 && get_array_bounds (TYPE_TARGET_TYPE (type
), &low_bound
,
1623 || (type
->code () == TYPE_CODE_STRUCT
1624 && !rust_enum_p (type
)
1625 && rust_slice_type_p (type
)
1626 && strcmp (type
->name (), "&str") == 0));
1629 /* Single instance of the Rust language class. */
1631 static rust_language rust_language_defn
;