1 /* Rust language support routines for GDB, the GNU debugger.
3 Copyright (C) 2016-2020 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"
42 /* See rust-lang.h. */
45 rust_last_path_segment (const char *path
)
47 const char *result
= strrchr (path
, ':');
54 /* See rust-lang.h. */
57 rust_crate_for_block (const struct block
*block
)
59 const char *scope
= block_scope (block
);
62 return std::string ();
64 return std::string (scope
, cp_find_first_component (scope
));
67 /* Return true if TYPE, which must be a struct type, represents a Rust
71 rust_enum_p (struct type
*type
)
73 /* is_dynamic_type will return true if any field has a dynamic
74 attribute -- but we only want to check the top level. */
75 return TYPE_HAS_VARIANT_PARTS (type
);
78 /* Return true if TYPE, which must be an already-resolved enum type,
82 rust_empty_enum_p (const struct type
*type
)
84 return type
->num_fields () == 0;
87 /* Given an already-resolved enum type and contents, find which
91 rust_enum_variant (struct type
*type
)
93 /* The active variant is simply the first non-artificial field. */
94 for (int i
= 0; i
< type
->num_fields (); ++i
)
95 if (!TYPE_FIELD_ARTIFICIAL (type
, i
))
98 /* Perhaps we could get here by trying to print an Ada variant
99 record in Rust mode. Unlikely, but an error is safer than an
101 error (_("Could not find active enum variant"));
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_CODE_STRUCT
113 && type
->name () != NULL
114 && type
->name ()[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_CODE_STRUCT
)
129 for (i
= 0; i
< type
->num_fields (); ++i
)
131 if (!field_is_static (&type
->field (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
->num_fields () > 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_CODE_STRUCT
161 && type
->name () != NULL
162 && (strncmp (type
->name (), "&[", 2) == 0
163 || strcmp (type
->name (), "&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_CODE_STRUCT
174 || type
->num_fields () > 2
175 || type
->name () == NULL
176 || strstr (type
->name (), "::Range") == NULL
)
179 if (type
->num_fields () == 0)
183 if (strcmp (TYPE_FIELD_NAME (type
, 0), "start") == 0)
185 if (type
->num_fields () == 1)
189 else if (type
->num_fields () == 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 (), "::RangeInclusive") != NULL
206 || strstr (type
->name (), "::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_CODE_INT
215 && type
->is_unsigned ()
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_CODE_CHAR
225 && TYPE_LENGTH (type
) == 4
226 && type
->is_unsigned ());
229 /* If VALUE represents a trait object pointer, return the underlying
230 pointer with the correct (i.e., runtime) type. Otherwise, return
233 static struct value
*
234 rust_get_trait_object_pointer (struct value
*value
)
236 struct type
*type
= check_typedef (value_type (value
));
238 if (type
->code () != TYPE_CODE_STRUCT
|| type
->num_fields () != 2)
241 /* Try to be a bit resilient if the ABI changes. */
242 int vtable_field
= 0;
243 for (int i
= 0; i
< 2; ++i
)
245 if (strcmp (TYPE_FIELD_NAME (type
, i
), "vtable") == 0)
247 else if (strcmp (TYPE_FIELD_NAME (type
, i
), "pointer") != 0)
251 CORE_ADDR vtable
= value_as_address (value_field (value
, vtable_field
));
252 struct symbol
*symbol
= find_symbol_at_address (vtable
);
253 if (symbol
== NULL
|| symbol
->subclass
!= SYMBOL_RUST_VTABLE
)
256 struct rust_vtable_symbol
*vtable_sym
257 = static_cast<struct rust_vtable_symbol
*> (symbol
);
258 struct type
*pointer_type
= lookup_pointer_type (vtable_sym
->concrete_type
);
259 return value_cast (pointer_type
, value_field (value
, 1 - vtable_field
));
264 /* language_defn::printstr implementation for Rust. */
267 rust_printstr (struct ui_file
*stream
, struct type
*type
,
268 const gdb_byte
*string
, unsigned int length
,
269 const char *user_encoding
, int force_ellipses
,
270 const struct value_print_options
*options
)
272 /* Rust always uses UTF-8, but let the caller override this if need
274 const char *encoding
= user_encoding
;
275 if (user_encoding
== NULL
|| !*user_encoding
)
277 /* In Rust strings, characters are "u8". */
278 if (rust_u8_type_p (type
))
282 /* This is probably some C string, so let's let C deal with
284 c_printstr (stream
, type
, string
, length
, user_encoding
,
285 force_ellipses
, options
);
290 /* This is not ideal as it doesn't use our character printer. */
291 generic_printstr (stream
, type
, string
, length
, encoding
, force_ellipses
,
297 static void rust_value_print_inner (struct value
*val
, struct ui_file
*stream
,
299 const struct value_print_options
*options
);
301 /* Helper function to print a string slice. */
304 rust_val_print_str (struct ui_file
*stream
, struct value
*val
,
305 const struct value_print_options
*options
)
307 struct value
*base
= value_struct_elt (&val
, NULL
, "data_ptr", NULL
,
309 struct value
*len
= value_struct_elt (&val
, NULL
, "length", NULL
, "slice");
311 val_print_string (TYPE_TARGET_TYPE (value_type (base
)), "UTF-8",
312 value_as_address (base
), value_as_long (len
), stream
,
316 /* rust_val_print helper for structs and untagged unions. */
319 val_print_struct (struct value
*val
, struct ui_file
*stream
, int recurse
,
320 const struct value_print_options
*options
)
324 struct type
*type
= check_typedef (value_type (val
));
326 if (rust_slice_type_p (type
) && strcmp (type
->name (), "&str") == 0)
328 /* If what we are printing here is actually a string within a
329 structure then VAL will be the original parent value, while TYPE
330 will be the type of the structure representing the string we want
332 However, RUST_VAL_PRINT_STR looks up the fields of the string
333 inside VAL, assuming that VAL is the string.
334 So, recreate VAL as a value representing just the string. */
335 val
= value_at_lazy (type
, value_address (val
));
336 rust_val_print_str (stream
, val
, options
);
340 bool is_tuple
= rust_tuple_type_p (type
);
341 bool is_tuple_struct
= !is_tuple
&& rust_tuple_struct_type_p (type
);
342 struct value_print_options opts
;
346 if (type
->name () != NULL
)
347 fprintf_filtered (stream
, "%s", type
->name ());
349 if (type
->num_fields () == 0)
352 if (type
->name () != NULL
)
353 fputs_filtered (" ", stream
);
356 if (is_tuple
|| is_tuple_struct
)
357 fputs_filtered ("(", stream
);
359 fputs_filtered ("{", stream
);
365 for (i
= 0; i
< type
->num_fields (); ++i
)
367 if (field_is_static (&type
->field (i
)))
371 fputs_filtered (",", stream
);
373 if (options
->prettyformat
)
375 fputs_filtered ("\n", stream
);
376 print_spaces_filtered (2 + 2 * recurse
, stream
);
378 else if (!first_field
)
379 fputs_filtered (" ", stream
);
383 if (!is_tuple
&& !is_tuple_struct
)
385 fputs_styled (TYPE_FIELD_NAME (type
, i
),
386 variable_name_style
.style (), stream
);
387 fputs_filtered (": ", stream
);
390 rust_value_print_inner (value_field (val
, i
), stream
, recurse
+ 1,
394 if (options
->prettyformat
)
396 fputs_filtered ("\n", stream
);
397 print_spaces_filtered (2 * recurse
, stream
);
400 if (is_tuple
|| is_tuple_struct
)
401 fputs_filtered (")", stream
);
403 fputs_filtered ("}", stream
);
406 /* rust_val_print helper for discriminated unions (Rust enums). */
409 rust_print_enum (struct value
*val
, struct ui_file
*stream
, int recurse
,
410 const struct value_print_options
*options
)
412 struct value_print_options opts
= *options
;
413 struct type
*type
= check_typedef (value_type (val
));
417 gdb_assert (rust_enum_p (type
));
418 gdb::array_view
<const gdb_byte
> view (value_contents_for_printing (val
),
419 TYPE_LENGTH (value_type (val
)));
420 type
= resolve_dynamic_type (type
, view
, value_address (val
));
422 if (rust_empty_enum_p (type
))
424 /* Print the enum type name here to be more clear. */
425 fprintf_filtered (stream
, _("%s {%p[<No data fields>%p]}"),
427 metadata_style
.style ().ptr (), nullptr);
431 int variant_fieldno
= rust_enum_variant (type
);
432 val
= value_field (val
, variant_fieldno
);
433 struct type
*variant_type
= type
->field (variant_fieldno
).type ();
435 int nfields
= variant_type
->num_fields ();
437 bool is_tuple
= rust_tuple_struct_type_p (variant_type
);
439 fprintf_filtered (stream
, "%s", variant_type
->name ());
442 /* In case of a nullary variant like 'None', just output
447 /* In case of a non-nullary variant, we output 'Foo(x,y,z)'. */
449 fprintf_filtered (stream
, "(");
452 /* struct variant. */
453 fprintf_filtered (stream
, "{");
456 bool first_field
= true;
457 for (int j
= 0; j
< variant_type
->num_fields (); j
++)
460 fputs_filtered (", ", stream
);
464 fprintf_filtered (stream
, "%ps: ",
465 styled_string (variable_name_style
.style (),
466 TYPE_FIELD_NAME (variant_type
, j
)));
468 rust_value_print_inner (value_field (val
, j
), stream
, recurse
+ 1,
473 fputs_filtered (")", stream
);
475 fputs_filtered ("}", stream
);
478 static const struct generic_val_print_decorations rust_decorations
=
480 /* Complex isn't used in Rust, but we provide C-ish values just in
492 /* la_value_print_inner implementation for Rust. */
494 rust_value_print_inner (struct value
*val
, struct ui_file
*stream
,
496 const struct value_print_options
*options
)
498 struct value_print_options opts
= *options
;
501 if (opts
.prettyformat
== Val_prettyformat_default
)
502 opts
.prettyformat
= (opts
.prettyformat_structs
503 ? Val_prettyformat
: Val_no_prettyformat
);
505 struct type
*type
= check_typedef (value_type (val
));
506 switch (type
->code ())
510 LONGEST low_bound
, high_bound
;
512 if (TYPE_TARGET_TYPE (type
)->code () == TYPE_CODE_ARRAY
513 && rust_u8_type_p (TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (type
)))
514 && get_array_bounds (TYPE_TARGET_TYPE (type
), &low_bound
,
517 /* We have a pointer to a byte string, so just print
519 struct type
*elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
520 CORE_ADDR addr
= value_as_address (val
);
521 struct gdbarch
*arch
= get_type_arch (type
);
523 if (opts
.addressprint
)
525 fputs_filtered (paddress (arch
, addr
), stream
);
526 fputs_filtered (" ", stream
);
529 fputs_filtered ("b", stream
);
530 val_print_string (TYPE_TARGET_TYPE (elttype
), "ASCII", addr
,
531 high_bound
- low_bound
+ 1, stream
,
539 /* Recognize the unit type. */
540 if (type
->is_unsigned () && TYPE_LENGTH (type
) == 0
541 && type
->name () != NULL
&& strcmp (type
->name (), "()") == 0)
543 fputs_filtered ("()", stream
);
548 case TYPE_CODE_STRING
:
550 LONGEST low_bound
, high_bound
;
552 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
553 error (_("Could not determine the array bounds"));
555 /* If we see a plain TYPE_CODE_STRING, then we're printing a
556 byte string, hence the choice of "ASCII" as the
558 fputs_filtered ("b", stream
);
559 rust_printstr (stream
, TYPE_TARGET_TYPE (type
),
560 value_contents_for_printing (val
),
561 high_bound
- low_bound
+ 1, "ASCII", 0, &opts
);
565 case TYPE_CODE_ARRAY
:
567 LONGEST low_bound
, high_bound
;
569 if (get_array_bounds (type
, &low_bound
, &high_bound
)
570 && high_bound
- low_bound
+ 1 == 0)
571 fputs_filtered ("[]", stream
);
577 case TYPE_CODE_UNION
:
578 /* Untagged unions are printed as if they are structs. Since
579 the field bit positions overlap in the debuginfo, the code
580 for printing a union is same as that for a struct, the only
581 difference is that the input type will have overlapping
583 val_print_struct (val
, stream
, recurse
, &opts
);
586 case TYPE_CODE_STRUCT
:
587 if (rust_enum_p (type
))
588 rust_print_enum (val
, stream
, recurse
, &opts
);
590 val_print_struct (val
, stream
, recurse
, &opts
);
595 /* Nothing special yet. */
596 generic_value_print (val
, stream
, recurse
, &opts
, &rust_decorations
);
603 rust_internal_print_type (struct type
*type
, const char *varstring
,
604 struct ui_file
*stream
, int show
, int level
,
605 const struct type_print_options
*flags
,
606 bool for_rust_enum
, print_offset_data
*podata
);
608 /* Print a struct or union typedef. */
610 rust_print_struct_def (struct type
*type
, const char *varstring
,
611 struct ui_file
*stream
, int show
, int level
,
612 const struct type_print_options
*flags
,
613 bool for_rust_enum
, print_offset_data
*podata
)
615 /* Print a tuple type simply. */
616 if (rust_tuple_type_p (type
))
618 fputs_filtered (type
->name (), stream
);
622 /* If we see a base class, delegate to C. */
623 if (TYPE_N_BASECLASSES (type
) > 0)
624 c_print_type (type
, varstring
, stream
, show
, level
, flags
);
626 if (flags
->print_offsets
)
628 /* Temporarily bump the level so that the output lines up
633 /* Compute properties of TYPE here because, in the enum case, the
634 rest of the code ends up looking only at the variant part. */
635 const char *tagname
= type
->name ();
636 bool is_tuple_struct
= rust_tuple_struct_type_p (type
);
637 bool is_tuple
= rust_tuple_type_p (type
);
638 bool is_enum
= rust_enum_p (type
);
642 /* Already printing an outer enum, so nothing to print here. */
646 /* This code path is also used by unions and enums. */
649 fputs_filtered ("enum ", stream
);
650 dynamic_prop
*prop
= type
->dyn_prop (DYN_PROP_VARIANT_PARTS
);
651 if (prop
!= nullptr && prop
->kind () == PROP_TYPE
)
652 type
= prop
->original_type ();
654 else if (type
->code () == TYPE_CODE_STRUCT
)
655 fputs_filtered ("struct ", stream
);
657 fputs_filtered ("union ", stream
);
660 fputs_filtered (tagname
, stream
);
663 if (type
->num_fields () == 0 && !is_tuple
)
665 if (for_rust_enum
&& !flags
->print_offsets
)
666 fputs_filtered (is_tuple_struct
? "(" : "{", stream
);
668 fputs_filtered (is_tuple_struct
? " (\n" : " {\n", stream
);
670 /* When printing offsets, we rearrange the fields into storage
671 order. This lets us show holes more clearly. We work using
672 field indices here because it simplifies calls to
673 print_offset_data::update below. */
674 std::vector
<int> fields
;
675 for (int i
= 0; i
< type
->num_fields (); ++i
)
677 if (field_is_static (&type
->field (i
)))
679 if (is_enum
&& TYPE_FIELD_ARTIFICIAL (type
, i
))
681 fields
.push_back (i
);
683 if (flags
->print_offsets
)
684 std::sort (fields
.begin (), fields
.end (),
687 return (TYPE_FIELD_BITPOS (type
, a
)
688 < TYPE_FIELD_BITPOS (type
, b
));
695 gdb_assert (!field_is_static (&type
->field (i
)));
696 gdb_assert (! (is_enum
&& TYPE_FIELD_ARTIFICIAL (type
, i
)));
698 if (flags
->print_offsets
)
699 podata
->update (type
, i
, stream
);
701 /* We'd like to print "pub" here as needed, but rustc
702 doesn't emit the debuginfo, and our types don't have
703 cplus_struct_type attached. */
705 /* For a tuple struct we print the type but nothing
707 if (!for_rust_enum
|| flags
->print_offsets
)
708 print_spaces_filtered (level
+ 2, stream
);
710 fputs_styled (TYPE_FIELD_NAME (type
, i
), variable_name_style
.style (),
712 else if (!is_tuple_struct
)
713 fprintf_filtered (stream
, "%ps: ",
714 styled_string (variable_name_style
.style (),
715 TYPE_FIELD_NAME (type
, i
)));
717 rust_internal_print_type (type
->field (i
).type (), NULL
,
718 stream
, (is_enum
? show
: show
- 1),
719 level
+ 2, flags
, is_enum
, podata
);
720 if (!for_rust_enum
|| flags
->print_offsets
)
721 fputs_filtered (",\n", stream
);
722 /* Note that this check of "I" is ok because we only sorted the
723 fields by offset when print_offsets was set, so we won't take
724 this branch in that case. */
725 else if (i
+ 1 < type
->num_fields ())
726 fputs_filtered (", ", stream
);
729 if (flags
->print_offsets
)
731 /* Undo the temporary level increase we did above. */
733 podata
->finish (type
, level
, stream
);
734 print_spaces_filtered (print_offset_data::indentation
, stream
);
736 print_spaces_filtered (2, stream
);
738 if (!for_rust_enum
|| flags
->print_offsets
)
739 print_spaces_filtered (level
, stream
);
740 fputs_filtered (is_tuple_struct
? ")" : "}", stream
);
743 /* la_print_type implementation for Rust. */
746 rust_internal_print_type (struct type
*type
, const char *varstring
,
747 struct ui_file
*stream
, int show
, int level
,
748 const struct type_print_options
*flags
,
749 bool for_rust_enum
, print_offset_data
*podata
)
753 && type
->name () != NULL
)
755 /* Rust calls the unit type "void" in its debuginfo,
756 but we don't want to print it as that. */
757 if (type
->code () == TYPE_CODE_VOID
)
758 fputs_filtered ("()", stream
);
760 fputs_filtered (type
->name (), stream
);
764 type
= check_typedef (type
);
765 switch (type
->code ())
768 /* If we have an enum, we've already printed the type's
769 unqualified name, and there is nothing else to print
772 fputs_filtered ("()", stream
);
776 /* Delegate varargs to the C printer. */
777 if (type
->has_varargs ())
780 fputs_filtered ("fn ", stream
);
781 if (varstring
!= NULL
)
782 fputs_filtered (varstring
, stream
);
783 fputs_filtered ("(", stream
);
784 for (int i
= 0; i
< type
->num_fields (); ++i
)
788 fputs_filtered (", ", stream
);
789 rust_internal_print_type (type
->field (i
).type (), "", stream
,
790 -1, 0, flags
, false, podata
);
792 fputs_filtered (")", stream
);
793 /* If it returns unit, we can omit the return type. */
794 if (TYPE_TARGET_TYPE (type
)->code () != TYPE_CODE_VOID
)
796 fputs_filtered (" -> ", stream
);
797 rust_internal_print_type (TYPE_TARGET_TYPE (type
), "", stream
,
798 -1, 0, flags
, false, podata
);
802 case TYPE_CODE_ARRAY
:
804 LONGEST low_bound
, high_bound
;
806 fputs_filtered ("[", stream
);
807 rust_internal_print_type (TYPE_TARGET_TYPE (type
), NULL
,
808 stream
, show
- 1, level
, flags
, false,
811 if (type
->bounds ()->high
.kind () == PROP_LOCEXPR
812 || type
->bounds ()->high
.kind () == PROP_LOCLIST
)
813 fprintf_filtered (stream
, "; variable length");
814 else if (get_array_bounds (type
, &low_bound
, &high_bound
))
815 fprintf_filtered (stream
, "; %s",
816 plongest (high_bound
- low_bound
+ 1));
817 fputs_filtered ("]", stream
);
821 case TYPE_CODE_UNION
:
822 case TYPE_CODE_STRUCT
:
823 rust_print_struct_def (type
, varstring
, stream
, show
, level
, flags
,
824 for_rust_enum
, podata
);
831 fputs_filtered ("enum ", stream
);
832 if (type
->name () != NULL
)
834 fputs_filtered (type
->name (), stream
);
835 fputs_filtered (" ", stream
);
836 len
= strlen (type
->name ());
838 fputs_filtered ("{\n", stream
);
840 for (int i
= 0; i
< type
->num_fields (); ++i
)
842 const char *name
= TYPE_FIELD_NAME (type
, i
);
847 && strncmp (name
, type
->name (), len
) == 0
849 && name
[len
+ 1] == ':')
851 fprintfi_filtered (level
+ 2, stream
, "%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
);
964 enum rust_primitive_types
976 rust_primitive_isize
,
977 rust_primitive_usize
,
982 nr_rust_primitive_types
987 /* A helper for rust_evaluate_subexp that handles OP_FUNCALL. */
989 static struct value
*
990 rust_evaluate_funcall (struct expression
*exp
, int *pos
, enum noside noside
)
993 int num_args
= exp
->elts
[*pos
+ 1].longconst
;
995 struct value
*function
, *result
, *arg0
;
996 struct type
*type
, *fn_type
;
997 const struct block
*block
;
998 struct block_symbol sym
;
1000 /* For an ordinary function call we can simply defer to the
1001 generic implementation. */
1002 if (exp
->elts
[*pos
+ 3].opcode
!= STRUCTOP_STRUCT
)
1003 return evaluate_subexp_standard (NULL
, exp
, pos
, noside
);
1005 /* Skip over the OP_FUNCALL and the STRUCTOP_STRUCT. */
1007 method
= &exp
->elts
[*pos
+ 1].string
;
1008 *pos
+= 3 + BYTES_TO_EXP_ELEM (exp
->elts
[*pos
].longconst
+ 1);
1010 /* Evaluate the argument to STRUCTOP_STRUCT, then find its
1011 type in order to look up the method. */
1012 arg0
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1014 if (noside
== EVAL_SKIP
)
1016 for (i
= 0; i
< num_args
; ++i
)
1017 evaluate_subexp (nullptr, exp
, pos
, noside
);
1021 std::vector
<struct value
*> args (num_args
+ 1);
1024 /* We don't yet implement real Deref semantics. */
1025 while (value_type (args
[0])->code () == TYPE_CODE_PTR
)
1026 args
[0] = value_ind (args
[0]);
1028 type
= value_type (args
[0]);
1029 if ((type
->code () != TYPE_CODE_STRUCT
1030 && type
->code () != TYPE_CODE_UNION
1031 && type
->code () != TYPE_CODE_ENUM
)
1032 || rust_tuple_type_p (type
))
1033 error (_("Method calls only supported on struct or enum types"));
1034 if (type
->name () == NULL
)
1035 error (_("Method call on nameless type"));
1037 std::string name
= std::string (type
->name ()) + "::" + method
;
1039 block
= get_selected_block (0);
1040 sym
= lookup_symbol (name
.c_str (), block
, VAR_DOMAIN
, NULL
);
1041 if (sym
.symbol
== NULL
)
1042 error (_("Could not find function named '%s'"), name
.c_str ());
1044 fn_type
= SYMBOL_TYPE (sym
.symbol
);
1045 if (fn_type
->num_fields () == 0)
1046 error (_("Function '%s' takes no arguments"), name
.c_str ());
1048 if (fn_type
->field (0).type ()->code () == TYPE_CODE_PTR
)
1049 args
[0] = value_addr (args
[0]);
1051 function
= address_of_variable (sym
.symbol
, block
);
1053 for (i
= 0; i
< num_args
; ++i
)
1054 args
[i
+ 1] = evaluate_subexp (nullptr, exp
, pos
, noside
);
1056 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1057 result
= value_zero (TYPE_TARGET_TYPE (fn_type
), not_lval
);
1059 result
= call_function_by_hand (function
, NULL
, args
);
1063 /* A helper for rust_evaluate_subexp that handles OP_RANGE. */
1065 static struct value
*
1066 rust_range (struct expression
*exp
, int *pos
, enum noside noside
)
1068 struct value
*low
= NULL
, *high
= NULL
;
1069 struct value
*addrval
, *result
;
1071 struct type
*range_type
;
1072 struct type
*index_type
;
1073 struct type
*temp_type
;
1077 = (enum range_flag
) longest_to_int (exp
->elts
[*pos
+ 1].longconst
);
1080 if (!(kind
& RANGE_LOW_BOUND_DEFAULT
))
1081 low
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1082 if (!(kind
& RANGE_HIGH_BOUND_DEFAULT
))
1083 high
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1084 bool inclusive
= !(kind
& RANGE_HIGH_BOUND_EXCLUSIVE
);
1086 if (noside
== EVAL_SKIP
)
1087 return value_from_longest (builtin_type (exp
->gdbarch
)->builtin_int
, 1);
1094 name
= "std::ops::RangeFull";
1098 index_type
= value_type (high
);
1100 ? "std::ops::RangeToInclusive" : "std::ops::RangeTo");
1107 index_type
= value_type (low
);
1108 name
= "std::ops::RangeFrom";
1112 if (!types_equal (value_type (low
), value_type (high
)))
1113 error (_("Range expression with different types"));
1114 index_type
= value_type (low
);
1115 name
= inclusive
? "std::ops::RangeInclusive" : "std::ops::Range";
1119 /* If we don't have an index type, just allocate this on the
1120 arch. Here any type will do. */
1121 temp_type
= (index_type
== NULL
1122 ? language_bool_type (exp
->language_defn
, exp
->gdbarch
)
1124 /* It would be nicer to cache the range type. */
1125 range_type
= rust_composite_type (temp_type
, name
,
1126 low
== NULL
? NULL
: "start", index_type
,
1127 high
== NULL
? NULL
: "end", index_type
);
1129 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1130 return value_zero (range_type
, lval_memory
);
1132 addrval
= value_allocate_space_in_inferior (TYPE_LENGTH (range_type
));
1133 addr
= value_as_long (addrval
);
1134 result
= value_at_lazy (range_type
, addr
);
1138 struct value
*start
= value_struct_elt (&result
, NULL
, "start", NULL
,
1141 value_assign (start
, low
);
1146 struct value
*end
= value_struct_elt (&result
, NULL
, "end", NULL
,
1149 value_assign (end
, high
);
1152 result
= value_at_lazy (range_type
, addr
);
1156 /* A helper function to compute the range and kind given a range
1157 value. TYPE is the type of the range value. RANGE is the range
1158 value. LOW, HIGH, and KIND are out parameters. The LOW and HIGH
1159 parameters might be filled in, or might not be, depending on the
1160 kind of range this is. KIND will always be set to the appropriate
1161 value describing the kind of range, and this can be used to
1162 determine whether LOW or HIGH are valid. */
1165 rust_compute_range (struct type
*type
, struct value
*range
,
1166 LONGEST
*low
, LONGEST
*high
,
1173 *kind
= RANGE_LOW_BOUND_DEFAULT
| RANGE_HIGH_BOUND_DEFAULT
;
1175 if (type
->num_fields () == 0)
1179 if (strcmp (TYPE_FIELD_NAME (type
, 0), "start") == 0)
1181 *kind
= RANGE_HIGH_BOUND_DEFAULT
;
1182 *low
= value_as_long (value_field (range
, 0));
1185 if (type
->num_fields () > i
1186 && strcmp (TYPE_FIELD_NAME (type
, i
), "end") == 0)
1188 *kind
= (*kind
== (RANGE_LOW_BOUND_DEFAULT
| RANGE_HIGH_BOUND_DEFAULT
)
1189 ? RANGE_LOW_BOUND_DEFAULT
: RANGE_STANDARD
);
1190 *high
= value_as_long (value_field (range
, i
));
1192 if (rust_inclusive_range_type_p (type
))
1197 /* A helper for rust_evaluate_subexp that handles BINOP_SUBSCRIPT. */
1199 static struct value
*
1200 rust_subscript (struct expression
*exp
, int *pos
, enum noside noside
,
1203 struct value
*lhs
, *rhs
, *result
;
1204 struct type
*rhstype
;
1205 LONGEST low
, high_bound
;
1206 /* Initialized to appease the compiler. */
1207 range_flags kind
= RANGE_LOW_BOUND_DEFAULT
| RANGE_HIGH_BOUND_DEFAULT
;
1212 lhs
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1213 rhs
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1215 if (noside
== EVAL_SKIP
)
1218 rhstype
= check_typedef (value_type (rhs
));
1219 if (rust_range_type_p (rhstype
))
1222 error (_("Can't take slice of array without '&'"));
1223 rust_compute_range (rhstype
, rhs
, &low
, &high
, &kind
);
1227 low
= value_as_long (rhs
);
1229 struct type
*type
= check_typedef (value_type (lhs
));
1230 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1232 struct type
*base_type
= nullptr;
1233 if (type
->code () == TYPE_CODE_ARRAY
)
1234 base_type
= TYPE_TARGET_TYPE (type
);
1235 else if (rust_slice_type_p (type
))
1237 for (int i
= 0; i
< type
->num_fields (); ++i
)
1239 if (strcmp (TYPE_FIELD_NAME (type
, i
), "data_ptr") == 0)
1241 base_type
= TYPE_TARGET_TYPE (type
->field (i
).type ());
1245 if (base_type
== nullptr)
1246 error (_("Could not find 'data_ptr' in slice type"));
1248 else if (type
->code () == TYPE_CODE_PTR
)
1249 base_type
= TYPE_TARGET_TYPE (type
);
1251 error (_("Cannot subscript non-array type"));
1253 struct type
*new_type
;
1256 if (rust_slice_type_p (type
))
1261 = language_lookup_primitive_type (exp
->language_defn
,
1264 new_type
= rust_slice_type ("&[*gdb*]", base_type
, usize
);
1268 new_type
= base_type
;
1270 return value_zero (new_type
, VALUE_LVAL (lhs
));
1277 if (type
->code () == TYPE_CODE_ARRAY
)
1280 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
1281 error (_("Can't compute array bounds"));
1283 error (_("Found array with non-zero lower bound"));
1286 else if (rust_slice_type_p (type
))
1290 base
= value_struct_elt (&lhs
, NULL
, "data_ptr", NULL
, "slice");
1291 len
= value_struct_elt (&lhs
, NULL
, "length", NULL
, "slice");
1293 high_bound
= value_as_long (len
);
1295 else if (type
->code () == TYPE_CODE_PTR
)
1299 high_bound
= LONGEST_MAX
;
1302 error (_("Cannot subscript non-array type"));
1304 if (want_slice
&& (kind
& RANGE_LOW_BOUND_DEFAULT
))
1307 error (_("Index less than zero"));
1308 if (low
> high_bound
)
1309 error (_("Index greater than length"));
1311 result
= value_subscript (base
, low
);
1318 struct type
*usize
, *slice
;
1320 struct value
*addrval
, *tem
;
1322 if (kind
& RANGE_HIGH_BOUND_DEFAULT
)
1325 error (_("High index less than zero"));
1327 error (_("Low index greater than high index"));
1328 if (high
> high_bound
)
1329 error (_("High index greater than length"));
1331 usize
= language_lookup_primitive_type (exp
->language_defn
,
1334 const char *new_name
= ((type
!= nullptr
1335 && rust_slice_type_p (type
))
1336 ? type
->name () : "&[*gdb*]");
1338 slice
= rust_slice_type (new_name
, value_type (result
), usize
);
1340 addrval
= value_allocate_space_in_inferior (TYPE_LENGTH (slice
));
1341 addr
= value_as_long (addrval
);
1342 tem
= value_at_lazy (slice
, addr
);
1344 value_assign (value_field (tem
, 0), value_addr (result
));
1345 value_assign (value_field (tem
, 1),
1346 value_from_longest (usize
, high
- low
));
1348 result
= value_at_lazy (slice
, addr
);
1351 result
= value_addr (result
);
1357 /* evaluate_exp implementation for Rust. */
1359 static struct value
*
1360 rust_evaluate_subexp (struct type
*expect_type
, struct expression
*exp
,
1361 int *pos
, enum noside noside
)
1363 struct value
*result
;
1365 switch (exp
->elts
[*pos
].opcode
)
1369 if (noside
!= EVAL_NORMAL
)
1370 result
= evaluate_subexp_standard (expect_type
, exp
, pos
, noside
);
1374 struct value
*value
= evaluate_subexp (expect_type
, exp
, pos
,
1377 struct value
*trait_ptr
= rust_get_trait_object_pointer (value
);
1378 if (trait_ptr
!= NULL
)
1381 result
= value_ind (value
);
1386 case UNOP_COMPLEMENT
:
1388 struct value
*value
;
1391 value
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1392 if (noside
== EVAL_SKIP
)
1394 /* Preserving the type is enough. */
1397 if (value_type (value
)->code () == TYPE_CODE_BOOL
)
1398 result
= value_from_longest (value_type (value
),
1399 value_logical_not (value
));
1401 result
= value_complement (value
);
1405 case BINOP_SUBSCRIPT
:
1406 result
= rust_subscript (exp
, pos
, noside
, 0);
1410 result
= rust_evaluate_funcall (exp
, pos
, noside
);
1416 struct type
*type
= exp
->elts
[pc
+ 1].type
;
1417 int arglen
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
1420 struct value
*addrval
= NULL
;
1424 if (noside
== EVAL_NORMAL
)
1426 addrval
= value_allocate_space_in_inferior (TYPE_LENGTH (type
));
1427 addr
= value_as_long (addrval
);
1428 result
= value_at_lazy (type
, addr
);
1431 if (arglen
> 0 && exp
->elts
[*pos
].opcode
== OP_OTHERS
)
1436 init
= rust_evaluate_subexp (NULL
, exp
, pos
, noside
);
1437 if (noside
== EVAL_NORMAL
)
1439 /* This isn't quite right but will do for the time
1440 being, seeing that we can't implement the Copy
1442 value_assign (result
, init
);
1448 gdb_assert (arglen
% 2 == 0);
1449 for (i
= 0; i
< arglen
; i
+= 2)
1452 const char *fieldname
;
1453 struct value
*value
, *field
;
1455 gdb_assert (exp
->elts
[*pos
].opcode
== OP_NAME
);
1457 len
= longest_to_int (exp
->elts
[*pos
].longconst
);
1459 fieldname
= &exp
->elts
[*pos
].string
;
1460 *pos
+= 2 + BYTES_TO_EXP_ELEM (len
+ 1);
1462 value
= rust_evaluate_subexp (NULL
, exp
, pos
, noside
);
1463 if (noside
== EVAL_NORMAL
)
1465 field
= value_struct_elt (&result
, NULL
, fieldname
, NULL
,
1467 value_assign (field
, value
);
1471 if (noside
== EVAL_SKIP
)
1472 return value_from_longest (builtin_type (exp
->gdbarch
)->builtin_int
,
1474 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1475 result
= allocate_value (type
);
1477 result
= value_at_lazy (type
, addr
);
1486 struct value
*ncopies
;
1488 elt
= rust_evaluate_subexp (NULL
, exp
, pos
, noside
);
1489 ncopies
= rust_evaluate_subexp (NULL
, exp
, pos
, noside
);
1490 copies
= value_as_long (ncopies
);
1492 error (_("Array with negative number of elements"));
1494 if (noside
== EVAL_NORMAL
)
1497 std::vector
<struct value
*> eltvec (copies
);
1499 for (i
= 0; i
< copies
; ++i
)
1501 result
= value_array (0, copies
- 1, eltvec
.data ());
1505 struct type
*arraytype
1506 = lookup_array_range_type (value_type (elt
), 0, copies
- 1);
1507 result
= allocate_value (arraytype
);
1512 case STRUCTOP_ANONYMOUS
:
1514 /* Anonymous field access, i.e. foo.1. */
1516 int pc
, field_number
, nfields
;
1520 field_number
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1522 lhs
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1524 type
= value_type (lhs
);
1526 if (type
->code () == TYPE_CODE_STRUCT
)
1528 struct type
*outer_type
= NULL
;
1530 if (rust_enum_p (type
))
1532 gdb::array_view
<const gdb_byte
> view (value_contents (lhs
),
1533 TYPE_LENGTH (type
));
1534 type
= resolve_dynamic_type (type
, view
, value_address (lhs
));
1536 if (rust_empty_enum_p (type
))
1537 error (_("Cannot access field %d of empty enum %s"),
1538 field_number
, type
->name ());
1540 int fieldno
= rust_enum_variant (type
);
1541 lhs
= value_primitive_field (lhs
, 0, fieldno
, type
);
1543 type
= value_type (lhs
);
1546 /* Tuples and tuple structs */
1547 nfields
= type
->num_fields ();
1549 if (field_number
>= nfields
|| field_number
< 0)
1551 if (outer_type
!= NULL
)
1552 error(_("Cannot access field %d of variant %s::%s, "
1553 "there are only %d fields"),
1554 field_number
, outer_type
->name (),
1555 rust_last_path_segment (type
->name ()),
1558 error(_("Cannot access field %d of %s, "
1559 "there are only %d fields"),
1560 field_number
, type
->name (), nfields
);
1563 /* Tuples are tuple structs too. */
1564 if (!rust_tuple_struct_type_p (type
))
1566 if (outer_type
!= NULL
)
1567 error(_("Variant %s::%s is not a tuple variant"),
1568 outer_type
->name (),
1569 rust_last_path_segment (type
->name ()));
1571 error(_("Attempting to access anonymous field %d "
1572 "of %s, which is not a tuple, tuple struct, or "
1573 "tuple-like variant"),
1574 field_number
, type
->name ());
1577 result
= value_primitive_field (lhs
, 0, field_number
, type
);
1580 error(_("Anonymous field access is only allowed on tuples, \
1581 tuple structs, and tuple-like enum variants"));
1585 case STRUCTOP_STRUCT
:
1592 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1593 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1594 lhs
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1596 const char *field_name
= &exp
->elts
[pc
+ 2].string
;
1597 type
= value_type (lhs
);
1598 if (type
->code () == TYPE_CODE_STRUCT
&& rust_enum_p (type
))
1600 gdb::array_view
<const gdb_byte
> view (value_contents (lhs
),
1601 TYPE_LENGTH (type
));
1602 type
= resolve_dynamic_type (type
, view
, value_address (lhs
));
1604 if (rust_empty_enum_p (type
))
1605 error (_("Cannot access field %s of empty enum %s"),
1606 field_name
, type
->name ());
1608 int fieldno
= rust_enum_variant (type
);
1609 lhs
= value_primitive_field (lhs
, 0, fieldno
, type
);
1611 struct type
*outer_type
= type
;
1612 type
= value_type (lhs
);
1613 if (rust_tuple_type_p (type
) || rust_tuple_struct_type_p (type
))
1614 error (_("Attempting to access named field %s of tuple "
1615 "variant %s::%s, which has only anonymous fields"),
1616 field_name
, outer_type
->name (),
1617 rust_last_path_segment (type
->name ()));
1621 result
= value_struct_elt (&lhs
, NULL
, field_name
,
1624 catch (const gdb_exception_error
&except
)
1626 error (_("Could not find field %s of struct variant %s::%s"),
1627 field_name
, outer_type
->name (),
1628 rust_last_path_segment (type
->name ()));
1632 result
= value_struct_elt (&lhs
, NULL
, field_name
, NULL
, "structure");
1633 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1634 result
= value_zero (value_type (result
), VALUE_LVAL (result
));
1639 result
= rust_range (exp
, pos
, noside
);
1643 /* We might have &array[range], in which case we need to make a
1645 if (exp
->elts
[*pos
+ 1].opcode
== BINOP_SUBSCRIPT
)
1648 result
= rust_subscript (exp
, pos
, noside
, 1);
1653 result
= evaluate_subexp_standard (expect_type
, exp
, pos
, noside
);
1660 /* operator_length implementation for Rust. */
1663 rust_operator_length (const struct expression
*exp
, int pc
, int *oplenp
,
1669 switch (exp
->elts
[pc
- 1].opcode
)
1672 /* We handle aggregate as a type and argument count. The first
1673 argument might be OP_OTHERS. After that the arguments
1674 alternate: first an OP_NAME, then an expression. */
1676 args
= longest_to_int (exp
->elts
[pc
- 2].longconst
);
1684 case STRUCTOP_ANONYMOUS
:
1695 operator_length_standard (exp
, pc
, oplenp
, argsp
);
1703 /* op_name implementation for Rust. */
1706 rust_op_name (enum exp_opcode opcode
)
1711 return "OP_AGGREGATE";
1715 return op_name_standard (opcode
);
1719 /* dump_subexp_body implementation for Rust. */
1722 rust_dump_subexp_body (struct expression
*exp
, struct ui_file
*stream
,
1725 switch (exp
->elts
[elt
].opcode
)
1729 int length
= longest_to_int (exp
->elts
[elt
+ 2].longconst
);
1732 fprintf_filtered (stream
, "Type @");
1733 gdb_print_host_address (exp
->elts
[elt
+ 1].type
, stream
);
1734 fprintf_filtered (stream
, " (");
1735 type_print (exp
->elts
[elt
+ 1].type
, NULL
, stream
, 0);
1736 fprintf_filtered (stream
, "), length %d", length
);
1739 for (i
= 0; i
< length
; ++i
)
1740 elt
= dump_subexp (exp
, stream
, elt
);
1747 LONGEST len
= exp
->elts
[elt
+ 1].longconst
;
1749 fprintf_filtered (stream
, "%s: %s",
1750 (exp
->elts
[elt
].opcode
== OP_STRING
1751 ? "string" : "name"),
1752 &exp
->elts
[elt
+ 2].string
);
1753 elt
+= 4 + BYTES_TO_EXP_ELEM (len
+ 1);
1758 elt
= dump_subexp (exp
, stream
, elt
+ 1);
1761 case STRUCTOP_ANONYMOUS
:
1765 field_number
= longest_to_int (exp
->elts
[elt
+ 1].longconst
);
1767 fprintf_filtered (stream
, "Field number: %d", field_number
);
1768 elt
= dump_subexp (exp
, stream
, elt
+ 3);
1777 elt
= dump_subexp_body_standard (exp
, stream
, elt
);
1784 /* print_subexp implementation for Rust. */
1787 rust_print_subexp (struct expression
*exp
, int *pos
, struct ui_file
*stream
,
1788 enum precedence prec
)
1790 switch (exp
->elts
[*pos
].opcode
)
1794 int length
= longest_to_int (exp
->elts
[*pos
+ 2].longconst
);
1797 type_print (exp
->elts
[*pos
+ 1].type
, "", stream
, 0);
1798 fputs_filtered (" { ", stream
);
1801 for (i
= 0; i
< length
; ++i
)
1803 rust_print_subexp (exp
, pos
, stream
, prec
);
1804 fputs_filtered (", ", stream
);
1806 fputs_filtered (" }", stream
);
1812 LONGEST len
= exp
->elts
[*pos
+ 1].longconst
;
1814 fputs_filtered (&exp
->elts
[*pos
+ 2].string
, stream
);
1815 *pos
+= 4 + BYTES_TO_EXP_ELEM (len
+ 1);
1821 fputs_filtered ("<<others>> (", stream
);
1823 rust_print_subexp (exp
, pos
, stream
, prec
);
1824 fputs_filtered (")", stream
);
1828 case STRUCTOP_ANONYMOUS
:
1830 int tem
= longest_to_int (exp
->elts
[*pos
+ 1].longconst
);
1833 print_subexp (exp
, pos
, stream
, PREC_SUFFIX
);
1834 fprintf_filtered (stream
, ".%d", tem
);
1840 fprintf_filtered (stream
, "[");
1841 rust_print_subexp (exp
, pos
, stream
, prec
);
1842 fprintf_filtered (stream
, "; ");
1843 rust_print_subexp (exp
, pos
, stream
, prec
);
1844 fprintf_filtered (stream
, "]");
1848 print_subexp_standard (exp
, pos
, stream
, prec
);
1853 /* operator_check implementation for Rust. */
1856 rust_operator_check (struct expression
*exp
, int pos
,
1857 int (*objfile_func
) (struct objfile
*objfile
,
1861 switch (exp
->elts
[pos
].opcode
)
1865 struct type
*type
= exp
->elts
[pos
+ 1].type
;
1866 struct objfile
*objfile
= TYPE_OBJFILE (type
);
1868 if (objfile
!= NULL
&& (*objfile_func
) (objfile
, data
))
1879 return operator_check_standard (exp
, pos
, objfile_func
, data
);
1887 static const struct exp_descriptor exp_descriptor_rust
=
1890 rust_operator_length
,
1891 rust_operator_check
,
1893 rust_dump_subexp_body
,
1894 rust_evaluate_subexp
1897 /* Class representing the Rust language. */
1899 class rust_language
: public language_defn
1903 : language_defn (language_rust
)
1906 /* See language.h. */
1908 const char *name () const override
1911 /* See language.h. */
1913 const char *natural_name () const override
1916 /* See language.h. */
1918 const std::vector
<const char *> &filename_extensions () const override
1920 static const std::vector
<const char *> extensions
= { ".rs" };
1924 /* See language.h. */
1925 void language_arch_info (struct gdbarch
*gdbarch
,
1926 struct language_arch_info
*lai
) const override
1928 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
1931 = GDBARCH_OBSTACK_CALLOC (gdbarch
, nr_rust_primitive_types
+ 1,
1934 types
[rust_primitive_bool
] = arch_boolean_type (gdbarch
, 8, 1, "bool");
1935 types
[rust_primitive_char
] = arch_character_type (gdbarch
, 32, 1, "char");
1936 types
[rust_primitive_i8
] = arch_integer_type (gdbarch
, 8, 0, "i8");
1937 types
[rust_primitive_u8
] = arch_integer_type (gdbarch
, 8, 1, "u8");
1938 types
[rust_primitive_i16
] = arch_integer_type (gdbarch
, 16, 0, "i16");
1939 types
[rust_primitive_u16
] = arch_integer_type (gdbarch
, 16, 1, "u16");
1940 types
[rust_primitive_i32
] = arch_integer_type (gdbarch
, 32, 0, "i32");
1941 types
[rust_primitive_u32
] = arch_integer_type (gdbarch
, 32, 1, "u32");
1942 types
[rust_primitive_i64
] = arch_integer_type (gdbarch
, 64, 0, "i64");
1943 types
[rust_primitive_u64
] = arch_integer_type (gdbarch
, 64, 1, "u64");
1945 unsigned int length
= 8 * TYPE_LENGTH (builtin
->builtin_data_ptr
);
1946 types
[rust_primitive_isize
] = arch_integer_type (gdbarch
, length
, 0, "isize");
1947 types
[rust_primitive_usize
] = arch_integer_type (gdbarch
, length
, 1, "usize");
1949 types
[rust_primitive_f32
] = arch_float_type (gdbarch
, 32, "f32",
1950 floatformats_ieee_single
);
1951 types
[rust_primitive_f64
] = arch_float_type (gdbarch
, 64, "f64",
1952 floatformats_ieee_double
);
1954 types
[rust_primitive_unit
] = arch_integer_type (gdbarch
, 0, 1, "()");
1956 struct type
*tem
= make_cv_type (1, 0, types
[rust_primitive_u8
], NULL
);
1957 types
[rust_primitive_str
] = rust_slice_type ("&str", tem
,
1958 types
[rust_primitive_usize
]);
1960 lai
->primitive_type_vector
= types
;
1961 lai
->bool_type_default
= types
[rust_primitive_bool
];
1962 lai
->string_char_type
= types
[rust_primitive_u8
];
1965 /* See language.h. */
1966 bool sniff_from_mangled_name (const char *mangled
,
1967 char **demangled
) const override
1969 *demangled
= gdb_demangle (mangled
, DMGL_PARAMS
| DMGL_ANSI
);
1970 return *demangled
!= NULL
;
1973 /* See language.h. */
1975 char *demangle_symbol (const char *mangled
, int options
) const override
1977 return gdb_demangle (mangled
, options
);
1980 /* See language.h. */
1982 void print_type (struct type
*type
, const char *varstring
,
1983 struct ui_file
*stream
, int show
, int level
,
1984 const struct type_print_options
*flags
) const override
1986 print_offset_data podata
;
1987 rust_internal_print_type (type
, varstring
, stream
, show
, level
,
1988 flags
, false, &podata
);
1991 /* See language.h. */
1993 gdb::unique_xmalloc_ptr
<char> watch_location_expression
1994 (struct type
*type
, CORE_ADDR addr
) const override
1996 type
= check_typedef (TYPE_TARGET_TYPE (check_typedef (type
)));
1997 std::string name
= type_to_string (type
);
1998 return gdb::unique_xmalloc_ptr
<char>
1999 (xstrprintf ("*(%s as *mut %s)", core_addr_to_string (addr
),
2003 /* See language.h. */
2005 void value_print_inner
2006 (struct value
*val
, struct ui_file
*stream
, int recurse
,
2007 const struct value_print_options
*options
) const override
2009 return rust_value_print_inner (val
, stream
, recurse
, options
);
2012 /* See language.h. */
2014 struct block_symbol lookup_symbol_nonlocal
2015 (const char *name
, const struct block
*block
,
2016 const domain_enum domain
) const override
2018 struct block_symbol result
= {};
2020 if (symbol_lookup_debug
)
2022 fprintf_unfiltered (gdb_stdlog
,
2023 "rust_lookup_symbol_non_local"
2024 " (%s, %s (scope %s), %s)\n",
2025 name
, host_address_to_string (block
),
2026 block_scope (block
), domain_name (domain
));
2029 /* Look up bare names in the block's scope. */
2030 std::string scopedname
;
2031 if (name
[cp_find_first_component (name
)] == '\0')
2033 const char *scope
= block_scope (block
);
2035 if (scope
[0] != '\0')
2037 scopedname
= std::string (scope
) + "::" + name
;
2038 name
= scopedname
.c_str ();
2046 result
= lookup_symbol_in_static_block (name
, block
, domain
);
2047 if (result
.symbol
== NULL
)
2048 result
= lookup_global_symbol (name
, block
, domain
);
2053 /* See language.h. */
2055 int parser (struct parser_state
*ps
) const override
2057 return rust_parse (ps
);
2060 /* See language.h. */
2062 void emitchar (int ch
, struct type
*chtype
,
2063 struct ui_file
*stream
, int quoter
) const override
2065 if (!rust_chartype_p (chtype
))
2066 generic_emit_char (ch
, chtype
, stream
, quoter
,
2067 target_charset (get_type_arch (chtype
)));
2068 else if (ch
== '\\' || ch
== quoter
)
2069 fprintf_filtered (stream
, "\\%c", ch
);
2070 else if (ch
== '\n')
2071 fputs_filtered ("\\n", stream
);
2072 else if (ch
== '\r')
2073 fputs_filtered ("\\r", stream
);
2074 else if (ch
== '\t')
2075 fputs_filtered ("\\t", stream
);
2076 else if (ch
== '\0')
2077 fputs_filtered ("\\0", stream
);
2078 else if (ch
>= 32 && ch
<= 127 && isprint (ch
))
2079 fputc_filtered (ch
, stream
);
2081 fprintf_filtered (stream
, "\\x%02x", ch
);
2083 fprintf_filtered (stream
, "\\u{%06x}", ch
);
2086 /* See language.h. */
2088 void printchar (int ch
, struct type
*chtype
,
2089 struct ui_file
*stream
) const override
2091 fputs_filtered ("'", stream
);
2092 LA_EMIT_CHAR (ch
, chtype
, stream
, '\'');
2093 fputs_filtered ("'", stream
);
2096 /* See language.h. */
2098 void printstr (struct ui_file
*stream
, struct type
*elttype
,
2099 const gdb_byte
*string
, unsigned int length
,
2100 const char *encoding
, int force_ellipses
,
2101 const struct value_print_options
*options
) const override
2103 rust_printstr (stream
, elttype
, string
, length
, encoding
,
2104 force_ellipses
, options
);
2107 /* See language.h. */
2109 void print_typedef (struct type
*type
, struct symbol
*new_symbol
,
2110 struct ui_file
*stream
) const override
2112 type
= check_typedef (type
);
2113 fprintf_filtered (stream
, "type %s = ", new_symbol
->print_name ());
2114 type_print (type
, "", stream
, 0);
2115 fprintf_filtered (stream
, ";");
2118 /* See language.h. */
2120 bool is_string_type_p (struct type
*type
) const override
2122 LONGEST low_bound
, high_bound
;
2124 type
= check_typedef (type
);
2125 return ((type
->code () == TYPE_CODE_STRING
)
2126 || (type
->code () == TYPE_CODE_PTR
2127 && (TYPE_TARGET_TYPE (type
)->code () == TYPE_CODE_ARRAY
2128 && rust_u8_type_p (TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (type
)))
2129 && get_array_bounds (TYPE_TARGET_TYPE (type
), &low_bound
,
2131 || (type
->code () == TYPE_CODE_STRUCT
2132 && !rust_enum_p (type
)
2133 && rust_slice_type_p (type
)
2134 && strcmp (type
->name (), "&str") == 0));
2137 /* See language.h. */
2139 bool range_checking_on_by_default () const override
2142 /* See language.h. */
2144 const struct exp_descriptor
*expression_ops () const override
2145 { return &exp_descriptor_rust
; }
2147 /* See language.h. */
2149 const struct op_print
*opcode_print_table () const override
2150 { return c_op_print_tab
; }
2153 /* Single instance of the Rust language class. */
2155 static rust_language rust_language_defn
;