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 enum range_type kind
;
1069 struct value
*low
= NULL
, *high
= NULL
;
1070 struct value
*addrval
, *result
;
1072 struct type
*range_type
;
1073 struct type
*index_type
;
1074 struct type
*temp_type
;
1077 kind
= (enum range_type
) longest_to_int (exp
->elts
[*pos
+ 1].longconst
);
1080 if (kind
== HIGH_BOUND_DEFAULT
|| kind
== NONE_BOUND_DEFAULT
1081 || kind
== NONE_BOUND_DEFAULT_EXCLUSIVE
)
1082 low
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1083 if (kind
== LOW_BOUND_DEFAULT
|| kind
== LOW_BOUND_DEFAULT_EXCLUSIVE
1084 || kind
== NONE_BOUND_DEFAULT
|| kind
== NONE_BOUND_DEFAULT_EXCLUSIVE
)
1085 high
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1086 bool inclusive
= (kind
== NONE_BOUND_DEFAULT
|| kind
== LOW_BOUND_DEFAULT
);
1088 if (noside
== EVAL_SKIP
)
1089 return value_from_longest (builtin_type (exp
->gdbarch
)->builtin_int
, 1);
1096 name
= "std::ops::RangeFull";
1100 index_type
= value_type (high
);
1102 ? "std::ops::RangeToInclusive" : "std::ops::RangeTo");
1109 index_type
= value_type (low
);
1110 name
= "std::ops::RangeFrom";
1114 if (!types_equal (value_type (low
), value_type (high
)))
1115 error (_("Range expression with different types"));
1116 index_type
= value_type (low
);
1117 name
= inclusive
? "std::ops::RangeInclusive" : "std::ops::Range";
1121 /* If we don't have an index type, just allocate this on the
1122 arch. Here any type will do. */
1123 temp_type
= (index_type
== NULL
1124 ? language_bool_type (exp
->language_defn
, exp
->gdbarch
)
1126 /* It would be nicer to cache the range type. */
1127 range_type
= rust_composite_type (temp_type
, name
,
1128 low
== NULL
? NULL
: "start", index_type
,
1129 high
== NULL
? NULL
: "end", index_type
);
1131 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1132 return value_zero (range_type
, lval_memory
);
1134 addrval
= value_allocate_space_in_inferior (TYPE_LENGTH (range_type
));
1135 addr
= value_as_long (addrval
);
1136 result
= value_at_lazy (range_type
, addr
);
1140 struct value
*start
= value_struct_elt (&result
, NULL
, "start", NULL
,
1143 value_assign (start
, low
);
1148 struct value
*end
= value_struct_elt (&result
, NULL
, "end", NULL
,
1151 value_assign (end
, high
);
1154 result
= value_at_lazy (range_type
, addr
);
1158 /* A helper function to compute the range and kind given a range
1159 value. TYPE is the type of the range value. RANGE is the range
1160 value. LOW, HIGH, and KIND are out parameters. The LOW and HIGH
1161 parameters might be filled in, or might not be, depending on the
1162 kind of range this is. KIND will always be set to the appropriate
1163 value describing the kind of range, and this can be used to
1164 determine whether LOW or HIGH are valid. */
1167 rust_compute_range (struct type
*type
, struct value
*range
,
1168 LONGEST
*low
, LONGEST
*high
,
1169 enum range_type
*kind
)
1175 *kind
= BOTH_BOUND_DEFAULT
;
1177 if (type
->num_fields () == 0)
1181 if (strcmp (TYPE_FIELD_NAME (type
, 0), "start") == 0)
1183 *kind
= HIGH_BOUND_DEFAULT
;
1184 *low
= value_as_long (value_field (range
, 0));
1187 if (type
->num_fields () > i
1188 && strcmp (TYPE_FIELD_NAME (type
, i
), "end") == 0)
1190 *kind
= (*kind
== BOTH_BOUND_DEFAULT
1191 ? LOW_BOUND_DEFAULT
: NONE_BOUND_DEFAULT
);
1192 *high
= value_as_long (value_field (range
, i
));
1194 if (rust_inclusive_range_type_p (type
))
1199 /* A helper for rust_evaluate_subexp that handles BINOP_SUBSCRIPT. */
1201 static struct value
*
1202 rust_subscript (struct expression
*exp
, int *pos
, enum noside noside
,
1205 struct value
*lhs
, *rhs
, *result
;
1206 struct type
*rhstype
;
1207 LONGEST low
, high_bound
;
1208 /* Initialized to appease the compiler. */
1209 enum range_type kind
= BOTH_BOUND_DEFAULT
;
1214 lhs
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1215 rhs
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1217 if (noside
== EVAL_SKIP
)
1220 rhstype
= check_typedef (value_type (rhs
));
1221 if (rust_range_type_p (rhstype
))
1224 error (_("Can't take slice of array without '&'"));
1225 rust_compute_range (rhstype
, rhs
, &low
, &high
, &kind
);
1229 low
= value_as_long (rhs
);
1231 struct type
*type
= check_typedef (value_type (lhs
));
1232 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1234 struct type
*base_type
= nullptr;
1235 if (type
->code () == TYPE_CODE_ARRAY
)
1236 base_type
= TYPE_TARGET_TYPE (type
);
1237 else if (rust_slice_type_p (type
))
1239 for (int i
= 0; i
< type
->num_fields (); ++i
)
1241 if (strcmp (TYPE_FIELD_NAME (type
, i
), "data_ptr") == 0)
1243 base_type
= TYPE_TARGET_TYPE (type
->field (i
).type ());
1247 if (base_type
== nullptr)
1248 error (_("Could not find 'data_ptr' in slice type"));
1250 else if (type
->code () == TYPE_CODE_PTR
)
1251 base_type
= TYPE_TARGET_TYPE (type
);
1253 error (_("Cannot subscript non-array type"));
1255 struct type
*new_type
;
1258 if (rust_slice_type_p (type
))
1263 = language_lookup_primitive_type (exp
->language_defn
,
1266 new_type
= rust_slice_type ("&[*gdb*]", base_type
, usize
);
1270 new_type
= base_type
;
1272 return value_zero (new_type
, VALUE_LVAL (lhs
));
1279 if (type
->code () == TYPE_CODE_ARRAY
)
1282 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
1283 error (_("Can't compute array bounds"));
1285 error (_("Found array with non-zero lower bound"));
1288 else if (rust_slice_type_p (type
))
1292 base
= value_struct_elt (&lhs
, NULL
, "data_ptr", NULL
, "slice");
1293 len
= value_struct_elt (&lhs
, NULL
, "length", NULL
, "slice");
1295 high_bound
= value_as_long (len
);
1297 else if (type
->code () == TYPE_CODE_PTR
)
1301 high_bound
= LONGEST_MAX
;
1304 error (_("Cannot subscript non-array type"));
1307 && (kind
== BOTH_BOUND_DEFAULT
|| kind
== LOW_BOUND_DEFAULT
))
1310 error (_("Index less than zero"));
1311 if (low
> high_bound
)
1312 error (_("Index greater than length"));
1314 result
= value_subscript (base
, low
);
1321 struct type
*usize
, *slice
;
1323 struct value
*addrval
, *tem
;
1325 if (kind
== BOTH_BOUND_DEFAULT
|| kind
== HIGH_BOUND_DEFAULT
)
1328 error (_("High index less than zero"));
1330 error (_("Low index greater than high index"));
1331 if (high
> high_bound
)
1332 error (_("High index greater than length"));
1334 usize
= language_lookup_primitive_type (exp
->language_defn
,
1337 const char *new_name
= ((type
!= nullptr
1338 && rust_slice_type_p (type
))
1339 ? type
->name () : "&[*gdb*]");
1341 slice
= rust_slice_type (new_name
, value_type (result
), usize
);
1343 addrval
= value_allocate_space_in_inferior (TYPE_LENGTH (slice
));
1344 addr
= value_as_long (addrval
);
1345 tem
= value_at_lazy (slice
, addr
);
1347 value_assign (value_field (tem
, 0), value_addr (result
));
1348 value_assign (value_field (tem
, 1),
1349 value_from_longest (usize
, high
- low
));
1351 result
= value_at_lazy (slice
, addr
);
1354 result
= value_addr (result
);
1360 /* evaluate_exp implementation for Rust. */
1362 static struct value
*
1363 rust_evaluate_subexp (struct type
*expect_type
, struct expression
*exp
,
1364 int *pos
, enum noside noside
)
1366 struct value
*result
;
1368 switch (exp
->elts
[*pos
].opcode
)
1372 if (noside
!= EVAL_NORMAL
)
1373 result
= evaluate_subexp_standard (expect_type
, exp
, pos
, noside
);
1377 struct value
*value
= evaluate_subexp (expect_type
, exp
, pos
,
1380 struct value
*trait_ptr
= rust_get_trait_object_pointer (value
);
1381 if (trait_ptr
!= NULL
)
1384 result
= value_ind (value
);
1389 case UNOP_COMPLEMENT
:
1391 struct value
*value
;
1394 value
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1395 if (noside
== EVAL_SKIP
)
1397 /* Preserving the type is enough. */
1400 if (value_type (value
)->code () == TYPE_CODE_BOOL
)
1401 result
= value_from_longest (value_type (value
),
1402 value_logical_not (value
));
1404 result
= value_complement (value
);
1408 case BINOP_SUBSCRIPT
:
1409 result
= rust_subscript (exp
, pos
, noside
, 0);
1413 result
= rust_evaluate_funcall (exp
, pos
, noside
);
1419 struct type
*type
= exp
->elts
[pc
+ 1].type
;
1420 int arglen
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
1423 struct value
*addrval
= NULL
;
1427 if (noside
== EVAL_NORMAL
)
1429 addrval
= value_allocate_space_in_inferior (TYPE_LENGTH (type
));
1430 addr
= value_as_long (addrval
);
1431 result
= value_at_lazy (type
, addr
);
1434 if (arglen
> 0 && exp
->elts
[*pos
].opcode
== OP_OTHERS
)
1439 init
= rust_evaluate_subexp (NULL
, exp
, pos
, noside
);
1440 if (noside
== EVAL_NORMAL
)
1442 /* This isn't quite right but will do for the time
1443 being, seeing that we can't implement the Copy
1445 value_assign (result
, init
);
1451 gdb_assert (arglen
% 2 == 0);
1452 for (i
= 0; i
< arglen
; i
+= 2)
1455 const char *fieldname
;
1456 struct value
*value
, *field
;
1458 gdb_assert (exp
->elts
[*pos
].opcode
== OP_NAME
);
1460 len
= longest_to_int (exp
->elts
[*pos
].longconst
);
1462 fieldname
= &exp
->elts
[*pos
].string
;
1463 *pos
+= 2 + BYTES_TO_EXP_ELEM (len
+ 1);
1465 value
= rust_evaluate_subexp (NULL
, exp
, pos
, noside
);
1466 if (noside
== EVAL_NORMAL
)
1468 field
= value_struct_elt (&result
, NULL
, fieldname
, NULL
,
1470 value_assign (field
, value
);
1474 if (noside
== EVAL_SKIP
)
1475 return value_from_longest (builtin_type (exp
->gdbarch
)->builtin_int
,
1477 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1478 result
= allocate_value (type
);
1480 result
= value_at_lazy (type
, addr
);
1489 struct value
*ncopies
;
1491 elt
= rust_evaluate_subexp (NULL
, exp
, pos
, noside
);
1492 ncopies
= rust_evaluate_subexp (NULL
, exp
, pos
, noside
);
1493 copies
= value_as_long (ncopies
);
1495 error (_("Array with negative number of elements"));
1497 if (noside
== EVAL_NORMAL
)
1500 std::vector
<struct value
*> eltvec (copies
);
1502 for (i
= 0; i
< copies
; ++i
)
1504 result
= value_array (0, copies
- 1, eltvec
.data ());
1508 struct type
*arraytype
1509 = lookup_array_range_type (value_type (elt
), 0, copies
- 1);
1510 result
= allocate_value (arraytype
);
1515 case STRUCTOP_ANONYMOUS
:
1517 /* Anonymous field access, i.e. foo.1. */
1519 int pc
, field_number
, nfields
;
1523 field_number
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1525 lhs
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1527 type
= value_type (lhs
);
1529 if (type
->code () == TYPE_CODE_STRUCT
)
1531 struct type
*outer_type
= NULL
;
1533 if (rust_enum_p (type
))
1535 gdb::array_view
<const gdb_byte
> view (value_contents (lhs
),
1536 TYPE_LENGTH (type
));
1537 type
= resolve_dynamic_type (type
, view
, value_address (lhs
));
1539 if (rust_empty_enum_p (type
))
1540 error (_("Cannot access field %d of empty enum %s"),
1541 field_number
, type
->name ());
1543 int fieldno
= rust_enum_variant (type
);
1544 lhs
= value_primitive_field (lhs
, 0, fieldno
, type
);
1546 type
= value_type (lhs
);
1549 /* Tuples and tuple structs */
1550 nfields
= type
->num_fields ();
1552 if (field_number
>= nfields
|| field_number
< 0)
1554 if (outer_type
!= NULL
)
1555 error(_("Cannot access field %d of variant %s::%s, "
1556 "there are only %d fields"),
1557 field_number
, outer_type
->name (),
1558 rust_last_path_segment (type
->name ()),
1561 error(_("Cannot access field %d of %s, "
1562 "there are only %d fields"),
1563 field_number
, type
->name (), nfields
);
1566 /* Tuples are tuple structs too. */
1567 if (!rust_tuple_struct_type_p (type
))
1569 if (outer_type
!= NULL
)
1570 error(_("Variant %s::%s is not a tuple variant"),
1571 outer_type
->name (),
1572 rust_last_path_segment (type
->name ()));
1574 error(_("Attempting to access anonymous field %d "
1575 "of %s, which is not a tuple, tuple struct, or "
1576 "tuple-like variant"),
1577 field_number
, type
->name ());
1580 result
= value_primitive_field (lhs
, 0, field_number
, type
);
1583 error(_("Anonymous field access is only allowed on tuples, \
1584 tuple structs, and tuple-like enum variants"));
1588 case STRUCTOP_STRUCT
:
1595 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1596 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1597 lhs
= evaluate_subexp (nullptr, exp
, pos
, noside
);
1599 const char *field_name
= &exp
->elts
[pc
+ 2].string
;
1600 type
= value_type (lhs
);
1601 if (type
->code () == TYPE_CODE_STRUCT
&& rust_enum_p (type
))
1603 gdb::array_view
<const gdb_byte
> view (value_contents (lhs
),
1604 TYPE_LENGTH (type
));
1605 type
= resolve_dynamic_type (type
, view
, value_address (lhs
));
1607 if (rust_empty_enum_p (type
))
1608 error (_("Cannot access field %s of empty enum %s"),
1609 field_name
, type
->name ());
1611 int fieldno
= rust_enum_variant (type
);
1612 lhs
= value_primitive_field (lhs
, 0, fieldno
, type
);
1614 struct type
*outer_type
= type
;
1615 type
= value_type (lhs
);
1616 if (rust_tuple_type_p (type
) || rust_tuple_struct_type_p (type
))
1617 error (_("Attempting to access named field %s of tuple "
1618 "variant %s::%s, which has only anonymous fields"),
1619 field_name
, outer_type
->name (),
1620 rust_last_path_segment (type
->name ()));
1624 result
= value_struct_elt (&lhs
, NULL
, field_name
,
1627 catch (const gdb_exception_error
&except
)
1629 error (_("Could not find field %s of struct variant %s::%s"),
1630 field_name
, outer_type
->name (),
1631 rust_last_path_segment (type
->name ()));
1635 result
= value_struct_elt (&lhs
, NULL
, field_name
, NULL
, "structure");
1636 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1637 result
= value_zero (value_type (result
), VALUE_LVAL (result
));
1642 result
= rust_range (exp
, pos
, noside
);
1646 /* We might have &array[range], in which case we need to make a
1648 if (exp
->elts
[*pos
+ 1].opcode
== BINOP_SUBSCRIPT
)
1651 result
= rust_subscript (exp
, pos
, noside
, 1);
1656 result
= evaluate_subexp_standard (expect_type
, exp
, pos
, noside
);
1663 /* operator_length implementation for Rust. */
1666 rust_operator_length (const struct expression
*exp
, int pc
, int *oplenp
,
1672 switch (exp
->elts
[pc
- 1].opcode
)
1675 /* We handle aggregate as a type and argument count. The first
1676 argument might be OP_OTHERS. After that the arguments
1677 alternate: first an OP_NAME, then an expression. */
1679 args
= longest_to_int (exp
->elts
[pc
- 2].longconst
);
1687 case STRUCTOP_ANONYMOUS
:
1698 operator_length_standard (exp
, pc
, oplenp
, argsp
);
1706 /* op_name implementation for Rust. */
1709 rust_op_name (enum exp_opcode opcode
)
1714 return "OP_AGGREGATE";
1718 return op_name_standard (opcode
);
1722 /* dump_subexp_body implementation for Rust. */
1725 rust_dump_subexp_body (struct expression
*exp
, struct ui_file
*stream
,
1728 switch (exp
->elts
[elt
].opcode
)
1732 int length
= longest_to_int (exp
->elts
[elt
+ 2].longconst
);
1735 fprintf_filtered (stream
, "Type @");
1736 gdb_print_host_address (exp
->elts
[elt
+ 1].type
, stream
);
1737 fprintf_filtered (stream
, " (");
1738 type_print (exp
->elts
[elt
+ 1].type
, NULL
, stream
, 0);
1739 fprintf_filtered (stream
, "), length %d", length
);
1742 for (i
= 0; i
< length
; ++i
)
1743 elt
= dump_subexp (exp
, stream
, elt
);
1750 LONGEST len
= exp
->elts
[elt
+ 1].longconst
;
1752 fprintf_filtered (stream
, "%s: %s",
1753 (exp
->elts
[elt
].opcode
== OP_STRING
1754 ? "string" : "name"),
1755 &exp
->elts
[elt
+ 2].string
);
1756 elt
+= 4 + BYTES_TO_EXP_ELEM (len
+ 1);
1761 elt
= dump_subexp (exp
, stream
, elt
+ 1);
1764 case STRUCTOP_ANONYMOUS
:
1768 field_number
= longest_to_int (exp
->elts
[elt
+ 1].longconst
);
1770 fprintf_filtered (stream
, "Field number: %d", field_number
);
1771 elt
= dump_subexp (exp
, stream
, elt
+ 3);
1780 elt
= dump_subexp_body_standard (exp
, stream
, elt
);
1787 /* print_subexp implementation for Rust. */
1790 rust_print_subexp (struct expression
*exp
, int *pos
, struct ui_file
*stream
,
1791 enum precedence prec
)
1793 switch (exp
->elts
[*pos
].opcode
)
1797 int length
= longest_to_int (exp
->elts
[*pos
+ 2].longconst
);
1800 type_print (exp
->elts
[*pos
+ 1].type
, "", stream
, 0);
1801 fputs_filtered (" { ", stream
);
1804 for (i
= 0; i
< length
; ++i
)
1806 rust_print_subexp (exp
, pos
, stream
, prec
);
1807 fputs_filtered (", ", stream
);
1809 fputs_filtered (" }", stream
);
1815 LONGEST len
= exp
->elts
[*pos
+ 1].longconst
;
1817 fputs_filtered (&exp
->elts
[*pos
+ 2].string
, stream
);
1818 *pos
+= 4 + BYTES_TO_EXP_ELEM (len
+ 1);
1824 fputs_filtered ("<<others>> (", stream
);
1826 rust_print_subexp (exp
, pos
, stream
, prec
);
1827 fputs_filtered (")", stream
);
1831 case STRUCTOP_ANONYMOUS
:
1833 int tem
= longest_to_int (exp
->elts
[*pos
+ 1].longconst
);
1836 print_subexp (exp
, pos
, stream
, PREC_SUFFIX
);
1837 fprintf_filtered (stream
, ".%d", tem
);
1843 fprintf_filtered (stream
, "[");
1844 rust_print_subexp (exp
, pos
, stream
, prec
);
1845 fprintf_filtered (stream
, "; ");
1846 rust_print_subexp (exp
, pos
, stream
, prec
);
1847 fprintf_filtered (stream
, "]");
1851 print_subexp_standard (exp
, pos
, stream
, prec
);
1856 /* operator_check implementation for Rust. */
1859 rust_operator_check (struct expression
*exp
, int pos
,
1860 int (*objfile_func
) (struct objfile
*objfile
,
1864 switch (exp
->elts
[pos
].opcode
)
1868 struct type
*type
= exp
->elts
[pos
+ 1].type
;
1869 struct objfile
*objfile
= TYPE_OBJFILE (type
);
1871 if (objfile
!= NULL
&& (*objfile_func
) (objfile
, data
))
1882 return operator_check_standard (exp
, pos
, objfile_func
, data
);
1890 static const struct exp_descriptor exp_descriptor_rust
=
1893 rust_operator_length
,
1894 rust_operator_check
,
1896 rust_dump_subexp_body
,
1897 rust_evaluate_subexp
1900 /* Class representing the Rust language. */
1902 class rust_language
: public language_defn
1906 : language_defn (language_rust
)
1909 /* See language.h. */
1911 const char *name () const override
1914 /* See language.h. */
1916 const char *natural_name () const override
1919 /* See language.h. */
1921 const std::vector
<const char *> &filename_extensions () const override
1923 static const std::vector
<const char *> extensions
= { ".rs" };
1927 /* See language.h. */
1928 void language_arch_info (struct gdbarch
*gdbarch
,
1929 struct language_arch_info
*lai
) const override
1931 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
1934 = GDBARCH_OBSTACK_CALLOC (gdbarch
, nr_rust_primitive_types
+ 1,
1937 types
[rust_primitive_bool
] = arch_boolean_type (gdbarch
, 8, 1, "bool");
1938 types
[rust_primitive_char
] = arch_character_type (gdbarch
, 32, 1, "char");
1939 types
[rust_primitive_i8
] = arch_integer_type (gdbarch
, 8, 0, "i8");
1940 types
[rust_primitive_u8
] = arch_integer_type (gdbarch
, 8, 1, "u8");
1941 types
[rust_primitive_i16
] = arch_integer_type (gdbarch
, 16, 0, "i16");
1942 types
[rust_primitive_u16
] = arch_integer_type (gdbarch
, 16, 1, "u16");
1943 types
[rust_primitive_i32
] = arch_integer_type (gdbarch
, 32, 0, "i32");
1944 types
[rust_primitive_u32
] = arch_integer_type (gdbarch
, 32, 1, "u32");
1945 types
[rust_primitive_i64
] = arch_integer_type (gdbarch
, 64, 0, "i64");
1946 types
[rust_primitive_u64
] = arch_integer_type (gdbarch
, 64, 1, "u64");
1948 unsigned int length
= 8 * TYPE_LENGTH (builtin
->builtin_data_ptr
);
1949 types
[rust_primitive_isize
] = arch_integer_type (gdbarch
, length
, 0, "isize");
1950 types
[rust_primitive_usize
] = arch_integer_type (gdbarch
, length
, 1, "usize");
1952 types
[rust_primitive_f32
] = arch_float_type (gdbarch
, 32, "f32",
1953 floatformats_ieee_single
);
1954 types
[rust_primitive_f64
] = arch_float_type (gdbarch
, 64, "f64",
1955 floatformats_ieee_double
);
1957 types
[rust_primitive_unit
] = arch_integer_type (gdbarch
, 0, 1, "()");
1959 struct type
*tem
= make_cv_type (1, 0, types
[rust_primitive_u8
], NULL
);
1960 types
[rust_primitive_str
] = rust_slice_type ("&str", tem
,
1961 types
[rust_primitive_usize
]);
1963 lai
->primitive_type_vector
= types
;
1964 lai
->bool_type_default
= types
[rust_primitive_bool
];
1965 lai
->string_char_type
= types
[rust_primitive_u8
];
1968 /* See language.h. */
1969 bool sniff_from_mangled_name (const char *mangled
,
1970 char **demangled
) const override
1972 *demangled
= gdb_demangle (mangled
, DMGL_PARAMS
| DMGL_ANSI
);
1973 return *demangled
!= NULL
;
1976 /* See language.h. */
1978 char *demangle (const char *mangled
, int options
) const override
1980 return gdb_demangle (mangled
, options
);
1983 /* See language.h. */
1985 void print_type (struct type
*type
, const char *varstring
,
1986 struct ui_file
*stream
, int show
, int level
,
1987 const struct type_print_options
*flags
) const override
1989 print_offset_data podata
;
1990 rust_internal_print_type (type
, varstring
, stream
, show
, level
,
1991 flags
, false, &podata
);
1994 /* See language.h. */
1996 gdb::unique_xmalloc_ptr
<char> watch_location_expression
1997 (struct type
*type
, CORE_ADDR addr
) const override
1999 type
= check_typedef (TYPE_TARGET_TYPE (check_typedef (type
)));
2000 std::string name
= type_to_string (type
);
2001 return gdb::unique_xmalloc_ptr
<char>
2002 (xstrprintf ("*(%s as *mut %s)", core_addr_to_string (addr
),
2006 /* See language.h. */
2008 void value_print_inner
2009 (struct value
*val
, struct ui_file
*stream
, int recurse
,
2010 const struct value_print_options
*options
) const override
2012 return rust_value_print_inner (val
, stream
, recurse
, options
);
2015 /* See language.h. */
2017 struct block_symbol lookup_symbol_nonlocal
2018 (const char *name
, const struct block
*block
,
2019 const domain_enum domain
) const override
2021 struct block_symbol result
= {};
2023 if (symbol_lookup_debug
)
2025 fprintf_unfiltered (gdb_stdlog
,
2026 "rust_lookup_symbol_non_local"
2027 " (%s, %s (scope %s), %s)\n",
2028 name
, host_address_to_string (block
),
2029 block_scope (block
), domain_name (domain
));
2032 /* Look up bare names in the block's scope. */
2033 std::string scopedname
;
2034 if (name
[cp_find_first_component (name
)] == '\0')
2036 const char *scope
= block_scope (block
);
2038 if (scope
[0] != '\0')
2040 scopedname
= std::string (scope
) + "::" + name
;
2041 name
= scopedname
.c_str ();
2049 result
= lookup_symbol_in_static_block (name
, block
, domain
);
2050 if (result
.symbol
== NULL
)
2051 result
= lookup_global_symbol (name
, block
, domain
);
2056 /* See language.h. */
2058 int parser (struct parser_state
*ps
) const override
2060 return rust_parse (ps
);
2063 /* See language.h. */
2065 void emitchar (int ch
, struct type
*chtype
,
2066 struct ui_file
*stream
, int quoter
) const override
2068 if (!rust_chartype_p (chtype
))
2069 generic_emit_char (ch
, chtype
, stream
, quoter
,
2070 target_charset (get_type_arch (chtype
)));
2071 else if (ch
== '\\' || ch
== quoter
)
2072 fprintf_filtered (stream
, "\\%c", ch
);
2073 else if (ch
== '\n')
2074 fputs_filtered ("\\n", stream
);
2075 else if (ch
== '\r')
2076 fputs_filtered ("\\r", stream
);
2077 else if (ch
== '\t')
2078 fputs_filtered ("\\t", stream
);
2079 else if (ch
== '\0')
2080 fputs_filtered ("\\0", stream
);
2081 else if (ch
>= 32 && ch
<= 127 && isprint (ch
))
2082 fputc_filtered (ch
, stream
);
2084 fprintf_filtered (stream
, "\\x%02x", ch
);
2086 fprintf_filtered (stream
, "\\u{%06x}", ch
);
2089 /* See language.h. */
2091 void printchar (int ch
, struct type
*chtype
,
2092 struct ui_file
*stream
) const override
2094 fputs_filtered ("'", stream
);
2095 LA_EMIT_CHAR (ch
, chtype
, stream
, '\'');
2096 fputs_filtered ("'", stream
);
2099 /* See language.h. */
2101 void printstr (struct ui_file
*stream
, struct type
*elttype
,
2102 const gdb_byte
*string
, unsigned int length
,
2103 const char *encoding
, int force_ellipses
,
2104 const struct value_print_options
*options
) const override
2106 rust_printstr (stream
, elttype
, string
, length
, encoding
,
2107 force_ellipses
, options
);
2110 /* See language.h. */
2112 void print_typedef (struct type
*type
, struct symbol
*new_symbol
,
2113 struct ui_file
*stream
) const override
2115 type
= check_typedef (type
);
2116 fprintf_filtered (stream
, "type %s = ", new_symbol
->print_name ());
2117 type_print (type
, "", stream
, 0);
2118 fprintf_filtered (stream
, ";");
2121 /* See language.h. */
2123 bool is_string_type_p (struct type
*type
) const override
2125 LONGEST low_bound
, high_bound
;
2127 type
= check_typedef (type
);
2128 return ((type
->code () == TYPE_CODE_STRING
)
2129 || (type
->code () == TYPE_CODE_PTR
2130 && (TYPE_TARGET_TYPE (type
)->code () == TYPE_CODE_ARRAY
2131 && rust_u8_type_p (TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (type
)))
2132 && get_array_bounds (TYPE_TARGET_TYPE (type
), &low_bound
,
2134 || (type
->code () == TYPE_CODE_STRUCT
2135 && !rust_enum_p (type
)
2136 && rust_slice_type_p (type
)
2137 && strcmp (type
->name (), "&str") == 0));
2140 /* See language.h. */
2142 bool range_checking_on_by_default () const override
2145 /* See language.h. */
2147 const struct exp_descriptor
*expression_ops () const override
2148 { return &exp_descriptor_rust
; }
2150 /* See language.h. */
2152 const struct op_print
*opcode_print_table () const override
2153 { return c_op_print_tab
; }
2156 /* Single instance of the Rust language class. */
2158 static rust_language rust_language_defn
;