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 (const struct type
*type
)
73 return (TYPE_CODE (type
) == TYPE_CODE_STRUCT
74 && TYPE_NFIELDS (type
) == 1
75 && TYPE_FLAG_DISCRIMINATED_UNION (TYPE_FIELD_TYPE (type
, 0)));
78 /* Return true if TYPE, which must be an enum type, has no
82 rust_empty_enum_p (const struct type
*type
)
84 gdb_assert (rust_enum_p (type
));
85 /* In Rust the enum always fills the containing structure. */
86 gdb_assert (TYPE_FIELD_BITPOS (type
, 0) == 0);
88 return TYPE_NFIELDS (TYPE_FIELD_TYPE (type
, 0)) == 0;
91 /* Given an enum type and contents, find which variant is active. */
94 rust_enum_variant (struct type
*type
, const gdb_byte
*contents
)
96 /* In Rust the enum always fills the containing structure. */
97 gdb_assert (TYPE_FIELD_BITPOS (type
, 0) == 0);
99 struct type
*union_type
= TYPE_FIELD_TYPE (type
, 0);
101 int fieldno
= value_union_variant (union_type
, contents
);
102 return &TYPE_FIELD (union_type
, fieldno
);
105 /* See rust-lang.h. */
108 rust_tuple_type_p (struct type
*type
)
110 /* The current implementation is a bit of a hack, but there's
111 nothing else in the debuginfo to distinguish a tuple from a
113 return (TYPE_CODE (type
) == TYPE_CODE_STRUCT
114 && TYPE_NAME (type
) != NULL
115 && TYPE_NAME (type
)[0] == '(');
118 /* Return true if all non-static fields of a structlike type are in a
119 sequence like __0, __1, __2. */
122 rust_underscore_fields (struct type
*type
)
128 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
)
130 for (i
= 0; i
< TYPE_NFIELDS (type
); ++i
)
132 if (!field_is_static (&TYPE_FIELD (type
, i
)))
136 xsnprintf (buf
, sizeof (buf
), "__%d", field_number
);
137 if (strcmp (buf
, TYPE_FIELD_NAME (type
, i
)) != 0)
145 /* See rust-lang.h. */
148 rust_tuple_struct_type_p (struct type
*type
)
150 /* This is just an approximation until DWARF can represent Rust more
151 precisely. We exclude zero-length structs because they may not
152 be tuple structs, and there's no way to tell. */
153 return TYPE_NFIELDS (type
) > 0 && rust_underscore_fields (type
);
156 /* Return true if TYPE is a slice type, otherwise false. */
159 rust_slice_type_p (struct type
*type
)
161 return (TYPE_CODE (type
) == TYPE_CODE_STRUCT
162 && TYPE_NAME (type
) != NULL
163 && (strncmp (TYPE_NAME (type
), "&[", 2) == 0
164 || strcmp (TYPE_NAME (type
), "&str") == 0));
167 /* Return true if TYPE is a range type, otherwise false. */
170 rust_range_type_p (struct type
*type
)
174 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
175 || TYPE_NFIELDS (type
) > 2
176 || TYPE_NAME (type
) == NULL
177 || strstr (TYPE_NAME (type
), "::Range") == NULL
)
180 if (TYPE_NFIELDS (type
) == 0)
184 if (strcmp (TYPE_FIELD_NAME (type
, 0), "start") == 0)
186 if (TYPE_NFIELDS (type
) == 1)
190 else if (TYPE_NFIELDS (type
) == 2)
192 /* First field had to be "start". */
196 return strcmp (TYPE_FIELD_NAME (type
, i
), "end") == 0;
199 /* Return true if TYPE is an inclusive range type, otherwise false.
200 This is only valid for types which are already known to be range
204 rust_inclusive_range_type_p (struct type
*type
)
206 return (strstr (TYPE_NAME (type
), "::RangeInclusive") != NULL
207 || strstr (TYPE_NAME (type
), "::RangeToInclusive") != NULL
);
210 /* Return true if TYPE seems to be the type "u8", otherwise false. */
213 rust_u8_type_p (struct type
*type
)
215 return (TYPE_CODE (type
) == TYPE_CODE_INT
216 && TYPE_UNSIGNED (type
)
217 && TYPE_LENGTH (type
) == 1);
220 /* Return true if TYPE is a Rust character type. */
223 rust_chartype_p (struct type
*type
)
225 return (TYPE_CODE (type
) == TYPE_CODE_CHAR
226 && TYPE_LENGTH (type
) == 4
227 && TYPE_UNSIGNED (type
));
230 /* Return true if TYPE is a string type. */
233 rust_is_string_type_p (struct type
*type
)
235 LONGEST low_bound
, high_bound
;
237 type
= check_typedef (type
);
238 return ((TYPE_CODE (type
) == TYPE_CODE_STRING
)
239 || (TYPE_CODE (type
) == TYPE_CODE_PTR
240 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_ARRAY
241 && rust_u8_type_p (TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (type
)))
242 && get_array_bounds (TYPE_TARGET_TYPE (type
), &low_bound
,
244 || (TYPE_CODE (type
) == TYPE_CODE_STRUCT
245 && !rust_enum_p (type
)
246 && rust_slice_type_p (type
)
247 && strcmp (TYPE_NAME (type
), "&str") == 0));
250 /* If VALUE represents a trait object pointer, return the underlying
251 pointer with the correct (i.e., runtime) type. Otherwise, return
254 static struct value
*
255 rust_get_trait_object_pointer (struct value
*value
)
257 struct type
*type
= check_typedef (value_type (value
));
259 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
|| TYPE_NFIELDS (type
) != 2)
262 /* Try to be a bit resilient if the ABI changes. */
263 int vtable_field
= 0;
264 for (int i
= 0; i
< 2; ++i
)
266 if (strcmp (TYPE_FIELD_NAME (type
, i
), "vtable") == 0)
268 else if (strcmp (TYPE_FIELD_NAME (type
, i
), "pointer") != 0)
272 CORE_ADDR vtable
= value_as_address (value_field (value
, vtable_field
));
273 struct symbol
*symbol
= find_symbol_at_address (vtable
);
274 if (symbol
== NULL
|| symbol
->subclass
!= SYMBOL_RUST_VTABLE
)
277 struct rust_vtable_symbol
*vtable_sym
278 = static_cast<struct rust_vtable_symbol
*> (symbol
);
279 struct type
*pointer_type
= lookup_pointer_type (vtable_sym
->concrete_type
);
280 return value_cast (pointer_type
, value_field (value
, 1 - vtable_field
));
285 /* la_emitchar implementation for Rust. */
288 rust_emitchar (int c
, struct type
*type
, struct ui_file
*stream
, int quoter
)
290 if (!rust_chartype_p (type
))
291 generic_emit_char (c
, type
, stream
, quoter
,
292 target_charset (get_type_arch (type
)));
293 else if (c
== '\\' || c
== quoter
)
294 fprintf_filtered (stream
, "\\%c", c
);
296 fputs_filtered ("\\n", stream
);
298 fputs_filtered ("\\r", stream
);
300 fputs_filtered ("\\t", stream
);
302 fputs_filtered ("\\0", stream
);
303 else if (c
>= 32 && c
<= 127 && isprint (c
))
304 fputc_filtered (c
, stream
);
306 fprintf_filtered (stream
, "\\x%02x", c
);
308 fprintf_filtered (stream
, "\\u{%06x}", c
);
311 /* la_printchar implementation for Rust. */
314 rust_printchar (int c
, struct type
*type
, struct ui_file
*stream
)
316 fputs_filtered ("'", stream
);
317 LA_EMIT_CHAR (c
, type
, stream
, '\'');
318 fputs_filtered ("'", stream
);
321 /* la_printstr implementation for Rust. */
324 rust_printstr (struct ui_file
*stream
, struct type
*type
,
325 const gdb_byte
*string
, unsigned int length
,
326 const char *user_encoding
, int force_ellipses
,
327 const struct value_print_options
*options
)
329 /* Rust always uses UTF-8, but let the caller override this if need
331 const char *encoding
= user_encoding
;
332 if (user_encoding
== NULL
|| !*user_encoding
)
334 /* In Rust strings, characters are "u8". */
335 if (rust_u8_type_p (type
))
339 /* This is probably some C string, so let's let C deal with
341 c_printstr (stream
, type
, string
, length
, user_encoding
,
342 force_ellipses
, options
);
347 /* This is not ideal as it doesn't use our character printer. */
348 generic_printstr (stream
, type
, string
, length
, encoding
, force_ellipses
,
354 static void rust_value_print_inner (struct value
*val
, struct ui_file
*stream
,
356 const struct value_print_options
*options
);
358 /* Helper function to print a string slice. */
361 rust_val_print_str (struct ui_file
*stream
, struct value
*val
,
362 const struct value_print_options
*options
)
364 struct value
*base
= value_struct_elt (&val
, NULL
, "data_ptr", NULL
,
366 struct value
*len
= value_struct_elt (&val
, NULL
, "length", NULL
, "slice");
368 val_print_string (TYPE_TARGET_TYPE (value_type (base
)), "UTF-8",
369 value_as_address (base
), value_as_long (len
), stream
,
373 /* rust_val_print helper for structs and untagged unions. */
376 val_print_struct (struct value
*val
, struct ui_file
*stream
, int recurse
,
377 const struct value_print_options
*options
)
381 struct type
*type
= check_typedef (value_type (val
));
383 if (rust_slice_type_p (type
) && strcmp (TYPE_NAME (type
), "&str") == 0)
385 /* If what we are printing here is actually a string within a
386 structure then VAL will be the original parent value, while TYPE
387 will be the type of the structure representing the string we want
389 However, RUST_VAL_PRINT_STR looks up the fields of the string
390 inside VAL, assuming that VAL is the string.
391 So, recreate VAL as a value representing just the string. */
392 val
= value_at_lazy (type
, value_address (val
));
393 rust_val_print_str (stream
, val
, options
);
397 bool is_tuple
= rust_tuple_type_p (type
);
398 bool is_tuple_struct
= !is_tuple
&& rust_tuple_struct_type_p (type
);
399 struct value_print_options opts
;
403 if (TYPE_NAME (type
) != NULL
)
404 fprintf_filtered (stream
, "%s", TYPE_NAME (type
));
406 if (TYPE_NFIELDS (type
) == 0)
409 if (TYPE_NAME (type
) != NULL
)
410 fputs_filtered (" ", stream
);
413 if (is_tuple
|| is_tuple_struct
)
414 fputs_filtered ("(", stream
);
416 fputs_filtered ("{", stream
);
422 for (i
= 0; i
< TYPE_NFIELDS (type
); ++i
)
424 if (field_is_static (&TYPE_FIELD (type
, i
)))
428 fputs_filtered (",", stream
);
430 if (options
->prettyformat
)
432 fputs_filtered ("\n", stream
);
433 print_spaces_filtered (2 + 2 * recurse
, stream
);
435 else if (!first_field
)
436 fputs_filtered (" ", stream
);
440 if (!is_tuple
&& !is_tuple_struct
)
442 fputs_styled (TYPE_FIELD_NAME (type
, i
),
443 variable_name_style
.style (), stream
);
444 fputs_filtered (": ", stream
);
447 rust_value_print_inner (value_field (val
, i
), stream
, recurse
+ 1,
451 if (options
->prettyformat
)
453 fputs_filtered ("\n", stream
);
454 print_spaces_filtered (2 * recurse
, stream
);
457 if (is_tuple
|| is_tuple_struct
)
458 fputs_filtered (")", stream
);
460 fputs_filtered ("}", stream
);
463 /* rust_val_print helper for discriminated unions (Rust enums). */
466 rust_print_enum (struct value
*val
, struct ui_file
*stream
, int recurse
,
467 const struct value_print_options
*options
)
469 struct value_print_options opts
= *options
;
470 struct type
*type
= check_typedef (value_type (val
));
474 if (rust_empty_enum_p (type
))
476 /* Print the enum type name here to be more clear. */
477 fprintf_filtered (stream
, _("%s {%p[<No data fields>%p]}"),
479 metadata_style
.style ().ptr (), nullptr);
483 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
484 struct field
*variant_field
= rust_enum_variant (type
, valaddr
);
485 struct type
*variant_type
= FIELD_TYPE (*variant_field
);
487 int nfields
= TYPE_NFIELDS (variant_type
);
489 bool is_tuple
= rust_tuple_struct_type_p (variant_type
);
491 fprintf_filtered (stream
, "%s", TYPE_NAME (variant_type
));
494 /* In case of a nullary variant like 'None', just output
499 /* In case of a non-nullary variant, we output 'Foo(x,y,z)'. */
501 fprintf_filtered (stream
, "(");
504 /* struct variant. */
505 fprintf_filtered (stream
, "{");
508 struct value
*union_value
= value_field (val
, 0);
509 int fieldno
= (variant_field
- &TYPE_FIELD (value_type (union_value
), 0));
510 val
= value_field (union_value
, fieldno
);
512 bool first_field
= true;
513 for (int j
= 0; j
< TYPE_NFIELDS (variant_type
); j
++)
516 fputs_filtered (", ", stream
);
520 fprintf_filtered (stream
, "%ps: ",
521 styled_string (variable_name_style
.style (),
522 TYPE_FIELD_NAME (variant_type
, j
)));
524 rust_value_print_inner (value_field (val
, j
), stream
, recurse
+ 1,
529 fputs_filtered (")", stream
);
531 fputs_filtered ("}", stream
);
534 static const struct generic_val_print_decorations rust_decorations
=
536 /* Complex isn't used in Rust, but we provide C-ish values just in
548 /* la_val_print implementation for Rust. */
551 rust_val_print (struct type
*type
, int embedded_offset
,
552 CORE_ADDR address
, struct ui_file
*stream
, int recurse
,
554 const struct value_print_options
*options
)
556 generic_val_print (type
, embedded_offset
, address
, stream
,
557 recurse
, val
, options
, &rust_decorations
);
560 /* la_value_print_inner implementation for Rust. */
562 rust_value_print_inner (struct value
*val
, struct ui_file
*stream
,
564 const struct value_print_options
*options
)
566 struct value_print_options opts
= *options
;
569 if (opts
.prettyformat
== Val_prettyformat_default
)
570 opts
.prettyformat
= (opts
.prettyformat_structs
571 ? Val_prettyformat
: Val_no_prettyformat
);
573 struct type
*type
= check_typedef (value_type (val
));
574 switch (TYPE_CODE (type
))
578 LONGEST low_bound
, high_bound
;
580 if (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_ARRAY
581 && rust_u8_type_p (TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (type
)))
582 && get_array_bounds (TYPE_TARGET_TYPE (type
), &low_bound
,
585 /* We have a pointer to a byte string, so just print
587 struct type
*elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
588 CORE_ADDR addr
= value_as_address (val
);
589 struct gdbarch
*arch
= get_type_arch (type
);
591 if (opts
.addressprint
)
593 fputs_filtered (paddress (arch
, addr
), stream
);
594 fputs_filtered (" ", stream
);
597 fputs_filtered ("b", stream
);
598 val_print_string (TYPE_TARGET_TYPE (elttype
), "ASCII", addr
,
599 high_bound
- low_bound
+ 1, stream
,
606 case TYPE_CODE_METHODPTR
:
607 case TYPE_CODE_MEMBERPTR
:
608 c_value_print_inner (val
, stream
, recurse
, &opts
);
612 /* Recognize the unit type. */
613 if (TYPE_UNSIGNED (type
) && TYPE_LENGTH (type
) == 0
614 && TYPE_NAME (type
) != NULL
&& strcmp (TYPE_NAME (type
), "()") == 0)
616 fputs_filtered ("()", stream
);
621 case TYPE_CODE_STRING
:
623 LONGEST low_bound
, high_bound
;
625 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
626 error (_("Could not determine the array bounds"));
628 /* If we see a plain TYPE_CODE_STRING, then we're printing a
629 byte string, hence the choice of "ASCII" as the
631 fputs_filtered ("b", stream
);
632 rust_printstr (stream
, TYPE_TARGET_TYPE (type
),
633 value_contents_for_printing (val
),
634 high_bound
- low_bound
+ 1, "ASCII", 0, &opts
);
638 case TYPE_CODE_ARRAY
:
640 LONGEST low_bound
, high_bound
;
642 if (get_array_bounds (type
, &low_bound
, &high_bound
)
643 && high_bound
- low_bound
+ 1 == 0)
644 fputs_filtered ("[]", stream
);
650 case TYPE_CODE_UNION
:
651 /* Untagged unions are printed as if they are structs. Since
652 the field bit positions overlap in the debuginfo, the code
653 for printing a union is same as that for a struct, the only
654 difference is that the input type will have overlapping
656 val_print_struct (val
, stream
, recurse
, &opts
);
659 case TYPE_CODE_STRUCT
:
660 if (rust_enum_p (type
))
661 rust_print_enum (val
, stream
, recurse
, &opts
);
663 val_print_struct (val
, stream
, recurse
, &opts
);
668 /* Nothing special yet. */
669 generic_value_print (val
, stream
, recurse
, &opts
, &rust_decorations
);
676 rust_internal_print_type (struct type
*type
, const char *varstring
,
677 struct ui_file
*stream
, int show
, int level
,
678 const struct type_print_options
*flags
,
679 bool for_rust_enum
, print_offset_data
*podata
);
681 /* Print a struct or union typedef. */
683 rust_print_struct_def (struct type
*type
, const char *varstring
,
684 struct ui_file
*stream
, int show
, int level
,
685 const struct type_print_options
*flags
,
686 bool for_rust_enum
, print_offset_data
*podata
)
688 /* Print a tuple type simply. */
689 if (rust_tuple_type_p (type
))
691 fputs_filtered (TYPE_NAME (type
), stream
);
695 /* If we see a base class, delegate to C. */
696 if (TYPE_N_BASECLASSES (type
) > 0)
697 c_print_type (type
, varstring
, stream
, show
, level
, flags
);
699 if (flags
->print_offsets
)
701 /* Temporarily bump the level so that the output lines up
706 /* Compute properties of TYPE here because, in the enum case, the
707 rest of the code ends up looking only at the variant part. */
708 const char *tagname
= TYPE_NAME (type
);
709 bool is_tuple_struct
= rust_tuple_struct_type_p (type
);
710 bool is_tuple
= rust_tuple_type_p (type
);
711 bool is_enum
= rust_enum_p (type
);
713 int enum_discriminant_index
= -1;
717 /* Already printing an outer enum, so nothing to print here. */
721 /* This code path is also used by unions and enums. */
724 fputs_filtered ("enum ", stream
);
726 if (rust_empty_enum_p (type
))
730 fputs_filtered (tagname
, stream
);
731 fputs_filtered (" ", stream
);
733 fputs_filtered ("{}", stream
);
737 type
= TYPE_FIELD_TYPE (type
, 0);
739 struct dynamic_prop
*discriminant_prop
740 = get_dyn_prop (DYN_PROP_DISCRIMINATED
, type
);
741 struct discriminant_info
*info
742 = (struct discriminant_info
*) discriminant_prop
->data
.baton
;
743 enum_discriminant_index
= info
->discriminant_index
;
745 else if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
746 fputs_filtered ("struct ", stream
);
748 fputs_filtered ("union ", stream
);
751 fputs_filtered (tagname
, stream
);
754 if (TYPE_NFIELDS (type
) == 0 && !is_tuple
)
756 if (for_rust_enum
&& !flags
->print_offsets
)
757 fputs_filtered (is_tuple_struct
? "(" : "{", stream
);
759 fputs_filtered (is_tuple_struct
? " (\n" : " {\n", stream
);
761 /* When printing offsets, we rearrange the fields into storage
762 order. This lets us show holes more clearly. We work using
763 field indices here because it simplifies calls to
764 print_offset_data::update below. */
765 std::vector
<int> fields
;
766 for (int i
= 0; i
< TYPE_NFIELDS (type
); ++i
)
768 if (field_is_static (&TYPE_FIELD (type
, i
)))
770 if (is_enum
&& i
== enum_discriminant_index
)
772 fields
.push_back (i
);
774 if (flags
->print_offsets
)
775 std::sort (fields
.begin (), fields
.end (),
778 return (TYPE_FIELD_BITPOS (type
, a
)
779 < TYPE_FIELD_BITPOS (type
, b
));
786 gdb_assert (!field_is_static (&TYPE_FIELD (type
, i
)));
787 gdb_assert (! (is_enum
&& i
== enum_discriminant_index
));
789 if (flags
->print_offsets
)
790 podata
->update (type
, i
, stream
);
792 /* We'd like to print "pub" here as needed, but rustc
793 doesn't emit the debuginfo, and our types don't have
794 cplus_struct_type attached. */
796 /* For a tuple struct we print the type but nothing
798 if (!for_rust_enum
|| flags
->print_offsets
)
799 print_spaces_filtered (level
+ 2, stream
);
801 fputs_styled (TYPE_FIELD_NAME (type
, i
), variable_name_style
.style (),
803 else if (!is_tuple_struct
)
804 fprintf_filtered (stream
, "%ps: ",
805 styled_string (variable_name_style
.style (),
806 TYPE_FIELD_NAME (type
, i
)));
808 rust_internal_print_type (TYPE_FIELD_TYPE (type
, i
), NULL
,
809 stream
, (is_enum
? show
: show
- 1),
810 level
+ 2, flags
, is_enum
, podata
);
811 if (!for_rust_enum
|| flags
->print_offsets
)
812 fputs_filtered (",\n", stream
);
813 /* Note that this check of "I" is ok because we only sorted the
814 fields by offset when print_offsets was set, so we won't take
815 this branch in that case. */
816 else if (i
+ 1 < TYPE_NFIELDS (type
))
817 fputs_filtered (", ", stream
);
820 if (flags
->print_offsets
)
822 /* Undo the temporary level increase we did above. */
824 podata
->finish (type
, level
, stream
);
825 print_spaces_filtered (print_offset_data::indentation
, stream
);
827 print_spaces_filtered (2, stream
);
829 if (!for_rust_enum
|| flags
->print_offsets
)
830 print_spaces_filtered (level
, stream
);
831 fputs_filtered (is_tuple_struct
? ")" : "}", stream
);
834 /* la_print_typedef implementation for Rust. */
837 rust_print_typedef (struct type
*type
,
838 struct symbol
*new_symbol
,
839 struct ui_file
*stream
)
841 type
= check_typedef (type
);
842 fprintf_filtered (stream
, "type %s = ", new_symbol
->print_name ());
843 type_print (type
, "", stream
, 0);
844 fprintf_filtered (stream
, ";");
847 /* la_print_type implementation for Rust. */
850 rust_internal_print_type (struct type
*type
, const char *varstring
,
851 struct ui_file
*stream
, int show
, int level
,
852 const struct type_print_options
*flags
,
853 bool for_rust_enum
, print_offset_data
*podata
)
857 && TYPE_NAME (type
) != NULL
)
859 /* Rust calls the unit type "void" in its debuginfo,
860 but we don't want to print it as that. */
861 if (TYPE_CODE (type
) == TYPE_CODE_VOID
)
862 fputs_filtered ("()", stream
);
864 fputs_filtered (TYPE_NAME (type
), stream
);
868 type
= check_typedef (type
);
869 switch (TYPE_CODE (type
))
872 /* If we have an enum, we've already printed the type's
873 unqualified name, and there is nothing else to print
876 fputs_filtered ("()", stream
);
880 /* Delegate varargs to the C printer. */
881 if (TYPE_VARARGS (type
))
884 fputs_filtered ("fn ", stream
);
885 if (varstring
!= NULL
)
886 fputs_filtered (varstring
, stream
);
887 fputs_filtered ("(", stream
);
888 for (int i
= 0; i
< TYPE_NFIELDS (type
); ++i
)
892 fputs_filtered (", ", stream
);
893 rust_internal_print_type (TYPE_FIELD_TYPE (type
, i
), "", stream
,
894 -1, 0, flags
, false, podata
);
896 fputs_filtered (")", stream
);
897 /* If it returns unit, we can omit the return type. */
898 if (TYPE_CODE (TYPE_TARGET_TYPE (type
)) != TYPE_CODE_VOID
)
900 fputs_filtered (" -> ", stream
);
901 rust_internal_print_type (TYPE_TARGET_TYPE (type
), "", stream
,
902 -1, 0, flags
, false, podata
);
906 case TYPE_CODE_ARRAY
:
908 LONGEST low_bound
, high_bound
;
910 fputs_filtered ("[", stream
);
911 rust_internal_print_type (TYPE_TARGET_TYPE (type
), NULL
,
912 stream
, show
- 1, level
, flags
, false,
915 if (TYPE_HIGH_BOUND_KIND (TYPE_INDEX_TYPE (type
)) == PROP_LOCEXPR
916 || TYPE_HIGH_BOUND_KIND (TYPE_INDEX_TYPE (type
)) == PROP_LOCLIST
)
917 fprintf_filtered (stream
, "; variable length");
918 else if (get_array_bounds (type
, &low_bound
, &high_bound
))
919 fprintf_filtered (stream
, "; %s",
920 plongest (high_bound
- low_bound
+ 1));
921 fputs_filtered ("]", stream
);
925 case TYPE_CODE_UNION
:
926 case TYPE_CODE_STRUCT
:
927 rust_print_struct_def (type
, varstring
, stream
, show
, level
, flags
,
928 for_rust_enum
, podata
);
935 fputs_filtered ("enum ", stream
);
936 if (TYPE_NAME (type
) != NULL
)
938 fputs_filtered (TYPE_NAME (type
), stream
);
939 fputs_filtered (" ", stream
);
940 len
= strlen (TYPE_NAME (type
));
942 fputs_filtered ("{\n", stream
);
944 for (int i
= 0; i
< TYPE_NFIELDS (type
); ++i
)
946 const char *name
= TYPE_FIELD_NAME (type
, i
);
951 && strncmp (name
, TYPE_NAME (type
), len
) == 0
953 && name
[len
+ 1] == ':')
955 fprintfi_filtered (level
+ 2, stream
, "%ps,\n",
956 styled_string (variable_name_style
.style (),
960 fputs_filtered ("}", stream
);
966 if (TYPE_NAME (type
) != nullptr)
967 fputs_filtered (TYPE_NAME (type
), stream
);
970 /* We currently can't distinguish between pointers and
972 fputs_filtered ("*mut ", stream
);
973 type_print (TYPE_TARGET_TYPE (type
), "", stream
, 0);
980 c_print_type (type
, varstring
, stream
, show
, level
, flags
);
985 rust_print_type (struct type
*type
, const char *varstring
,
986 struct ui_file
*stream
, int show
, int level
,
987 const struct type_print_options
*flags
)
989 print_offset_data podata
;
990 rust_internal_print_type (type
, varstring
, stream
, show
, level
,
991 flags
, false, &podata
);
996 /* Like arch_composite_type, but uses TYPE to decide how to allocate
997 -- either on an obstack or on a gdbarch. */
1000 rust_composite_type (struct type
*original
,
1002 const char *field1
, struct type
*type1
,
1003 const char *field2
, struct type
*type2
)
1005 struct type
*result
= alloc_type_copy (original
);
1006 int i
, nfields
, bitpos
;
1014 TYPE_CODE (result
) = TYPE_CODE_STRUCT
;
1015 TYPE_NAME (result
) = name
;
1017 TYPE_NFIELDS (result
) = nfields
;
1018 TYPE_FIELDS (result
)
1019 = (struct field
*) TYPE_ZALLOC (result
, nfields
* sizeof (struct field
));
1025 struct field
*field
= &TYPE_FIELD (result
, i
);
1027 SET_FIELD_BITPOS (*field
, bitpos
);
1028 bitpos
+= TYPE_LENGTH (type1
) * TARGET_CHAR_BIT
;
1030 FIELD_NAME (*field
) = field1
;
1031 FIELD_TYPE (*field
) = type1
;
1036 struct field
*field
= &TYPE_FIELD (result
, i
);
1037 unsigned align
= type_align (type2
);
1043 align
*= TARGET_CHAR_BIT
;
1044 delta
= bitpos
% align
;
1046 bitpos
+= align
- delta
;
1048 SET_FIELD_BITPOS (*field
, bitpos
);
1050 FIELD_NAME (*field
) = field2
;
1051 FIELD_TYPE (*field
) = type2
;
1056 TYPE_LENGTH (result
)
1057 = (TYPE_FIELD_BITPOS (result
, i
- 1) / TARGET_CHAR_BIT
+
1058 TYPE_LENGTH (TYPE_FIELD_TYPE (result
, i
- 1)));
1062 /* See rust-lang.h. */
1065 rust_slice_type (const char *name
, struct type
*elt_type
,
1066 struct type
*usize_type
)
1070 elt_type
= lookup_pointer_type (elt_type
);
1071 type
= rust_composite_type (elt_type
, name
,
1072 "data_ptr", elt_type
,
1073 "length", usize_type
);
1078 enum rust_primitive_types
1080 rust_primitive_bool
,
1081 rust_primitive_char
,
1090 rust_primitive_isize
,
1091 rust_primitive_usize
,
1094 rust_primitive_unit
,
1096 nr_rust_primitive_types
1099 /* la_language_arch_info implementation for Rust. */
1102 rust_language_arch_info (struct gdbarch
*gdbarch
,
1103 struct language_arch_info
*lai
)
1105 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
1107 struct type
**types
;
1108 unsigned int length
;
1110 types
= GDBARCH_OBSTACK_CALLOC (gdbarch
, nr_rust_primitive_types
+ 1,
1113 types
[rust_primitive_bool
] = arch_boolean_type (gdbarch
, 8, 1, "bool");
1114 types
[rust_primitive_char
] = arch_character_type (gdbarch
, 32, 1, "char");
1115 types
[rust_primitive_i8
] = arch_integer_type (gdbarch
, 8, 0, "i8");
1116 types
[rust_primitive_u8
] = arch_integer_type (gdbarch
, 8, 1, "u8");
1117 types
[rust_primitive_i16
] = arch_integer_type (gdbarch
, 16, 0, "i16");
1118 types
[rust_primitive_u16
] = arch_integer_type (gdbarch
, 16, 1, "u16");
1119 types
[rust_primitive_i32
] = arch_integer_type (gdbarch
, 32, 0, "i32");
1120 types
[rust_primitive_u32
] = arch_integer_type (gdbarch
, 32, 1, "u32");
1121 types
[rust_primitive_i64
] = arch_integer_type (gdbarch
, 64, 0, "i64");
1122 types
[rust_primitive_u64
] = arch_integer_type (gdbarch
, 64, 1, "u64");
1124 length
= 8 * TYPE_LENGTH (builtin
->builtin_data_ptr
);
1125 types
[rust_primitive_isize
] = arch_integer_type (gdbarch
, length
, 0, "isize");
1126 types
[rust_primitive_usize
] = arch_integer_type (gdbarch
, length
, 1, "usize");
1128 types
[rust_primitive_f32
] = arch_float_type (gdbarch
, 32, "f32",
1129 floatformats_ieee_single
);
1130 types
[rust_primitive_f64
] = arch_float_type (gdbarch
, 64, "f64",
1131 floatformats_ieee_double
);
1133 types
[rust_primitive_unit
] = arch_integer_type (gdbarch
, 0, 1, "()");
1135 tem
= make_cv_type (1, 0, types
[rust_primitive_u8
], NULL
);
1136 types
[rust_primitive_str
] = rust_slice_type ("&str", tem
,
1137 types
[rust_primitive_usize
]);
1139 lai
->primitive_type_vector
= types
;
1140 lai
->bool_type_default
= types
[rust_primitive_bool
];
1141 lai
->string_char_type
= types
[rust_primitive_u8
];
1146 /* A helper for rust_evaluate_subexp that handles OP_FUNCALL. */
1148 static struct value
*
1149 rust_evaluate_funcall (struct expression
*exp
, int *pos
, enum noside noside
)
1152 int num_args
= exp
->elts
[*pos
+ 1].longconst
;
1154 struct value
*function
, *result
, *arg0
;
1155 struct type
*type
, *fn_type
;
1156 const struct block
*block
;
1157 struct block_symbol sym
;
1159 /* For an ordinary function call we can simply defer to the
1160 generic implementation. */
1161 if (exp
->elts
[*pos
+ 3].opcode
!= STRUCTOP_STRUCT
)
1162 return evaluate_subexp_standard (NULL
, exp
, pos
, noside
);
1164 /* Skip over the OP_FUNCALL and the STRUCTOP_STRUCT. */
1166 method
= &exp
->elts
[*pos
+ 1].string
;
1167 *pos
+= 3 + BYTES_TO_EXP_ELEM (exp
->elts
[*pos
].longconst
+ 1);
1169 /* Evaluate the argument to STRUCTOP_STRUCT, then find its
1170 type in order to look up the method. */
1171 arg0
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1173 if (noside
== EVAL_SKIP
)
1175 for (i
= 0; i
< num_args
; ++i
)
1176 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1180 std::vector
<struct value
*> args (num_args
+ 1);
1183 /* We don't yet implement real Deref semantics. */
1184 while (TYPE_CODE (value_type (args
[0])) == TYPE_CODE_PTR
)
1185 args
[0] = value_ind (args
[0]);
1187 type
= value_type (args
[0]);
1188 if ((TYPE_CODE (type
) != TYPE_CODE_STRUCT
1189 && TYPE_CODE (type
) != TYPE_CODE_UNION
1190 && TYPE_CODE (type
) != TYPE_CODE_ENUM
)
1191 || rust_tuple_type_p (type
))
1192 error (_("Method calls only supported on struct or enum types"));
1193 if (TYPE_NAME (type
) == NULL
)
1194 error (_("Method call on nameless type"));
1196 std::string name
= std::string (TYPE_NAME (type
)) + "::" + method
;
1198 block
= get_selected_block (0);
1199 sym
= lookup_symbol (name
.c_str (), block
, VAR_DOMAIN
, NULL
);
1200 if (sym
.symbol
== NULL
)
1201 error (_("Could not find function named '%s'"), name
.c_str ());
1203 fn_type
= SYMBOL_TYPE (sym
.symbol
);
1204 if (TYPE_NFIELDS (fn_type
) == 0)
1205 error (_("Function '%s' takes no arguments"), name
.c_str ());
1207 if (TYPE_CODE (TYPE_FIELD_TYPE (fn_type
, 0)) == TYPE_CODE_PTR
)
1208 args
[0] = value_addr (args
[0]);
1210 function
= address_of_variable (sym
.symbol
, block
);
1212 for (i
= 0; i
< num_args
; ++i
)
1213 args
[i
+ 1] = evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1215 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1216 result
= value_zero (TYPE_TARGET_TYPE (fn_type
), not_lval
);
1218 result
= call_function_by_hand (function
, NULL
, args
);
1222 /* A helper for rust_evaluate_subexp that handles OP_RANGE. */
1224 static struct value
*
1225 rust_range (struct expression
*exp
, int *pos
, enum noside noside
)
1227 enum range_type kind
;
1228 struct value
*low
= NULL
, *high
= NULL
;
1229 struct value
*addrval
, *result
;
1231 struct type
*range_type
;
1232 struct type
*index_type
;
1233 struct type
*temp_type
;
1236 kind
= (enum range_type
) longest_to_int (exp
->elts
[*pos
+ 1].longconst
);
1239 if (kind
== HIGH_BOUND_DEFAULT
|| kind
== NONE_BOUND_DEFAULT
1240 || kind
== NONE_BOUND_DEFAULT_EXCLUSIVE
)
1241 low
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1242 if (kind
== LOW_BOUND_DEFAULT
|| kind
== LOW_BOUND_DEFAULT_EXCLUSIVE
1243 || kind
== NONE_BOUND_DEFAULT
|| kind
== NONE_BOUND_DEFAULT_EXCLUSIVE
)
1244 high
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1245 bool inclusive
= (kind
== NONE_BOUND_DEFAULT
|| kind
== LOW_BOUND_DEFAULT
);
1247 if (noside
== EVAL_SKIP
)
1248 return value_from_longest (builtin_type (exp
->gdbarch
)->builtin_int
, 1);
1255 name
= "std::ops::RangeFull";
1259 index_type
= value_type (high
);
1261 ? "std::ops::RangeToInclusive" : "std::ops::RangeTo");
1268 index_type
= value_type (low
);
1269 name
= "std::ops::RangeFrom";
1273 if (!types_equal (value_type (low
), value_type (high
)))
1274 error (_("Range expression with different types"));
1275 index_type
= value_type (low
);
1276 name
= inclusive
? "std::ops::RangeInclusive" : "std::ops::Range";
1280 /* If we don't have an index type, just allocate this on the
1281 arch. Here any type will do. */
1282 temp_type
= (index_type
== NULL
1283 ? language_bool_type (exp
->language_defn
, exp
->gdbarch
)
1285 /* It would be nicer to cache the range type. */
1286 range_type
= rust_composite_type (temp_type
, name
,
1287 low
== NULL
? NULL
: "start", index_type
,
1288 high
== NULL
? NULL
: "end", index_type
);
1290 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1291 return value_zero (range_type
, lval_memory
);
1293 addrval
= value_allocate_space_in_inferior (TYPE_LENGTH (range_type
));
1294 addr
= value_as_long (addrval
);
1295 result
= value_at_lazy (range_type
, addr
);
1299 struct value
*start
= value_struct_elt (&result
, NULL
, "start", NULL
,
1302 value_assign (start
, low
);
1307 struct value
*end
= value_struct_elt (&result
, NULL
, "end", NULL
,
1310 value_assign (end
, high
);
1313 result
= value_at_lazy (range_type
, addr
);
1317 /* A helper function to compute the range and kind given a range
1318 value. TYPE is the type of the range value. RANGE is the range
1319 value. LOW, HIGH, and KIND are out parameters. The LOW and HIGH
1320 parameters might be filled in, or might not be, depending on the
1321 kind of range this is. KIND will always be set to the appropriate
1322 value describing the kind of range, and this can be used to
1323 determine whether LOW or HIGH are valid. */
1326 rust_compute_range (struct type
*type
, struct value
*range
,
1327 LONGEST
*low
, LONGEST
*high
,
1328 enum range_type
*kind
)
1334 *kind
= BOTH_BOUND_DEFAULT
;
1336 if (TYPE_NFIELDS (type
) == 0)
1340 if (strcmp (TYPE_FIELD_NAME (type
, 0), "start") == 0)
1342 *kind
= HIGH_BOUND_DEFAULT
;
1343 *low
= value_as_long (value_field (range
, 0));
1346 if (TYPE_NFIELDS (type
) > i
1347 && strcmp (TYPE_FIELD_NAME (type
, i
), "end") == 0)
1349 *kind
= (*kind
== BOTH_BOUND_DEFAULT
1350 ? LOW_BOUND_DEFAULT
: NONE_BOUND_DEFAULT
);
1351 *high
= value_as_long (value_field (range
, i
));
1353 if (rust_inclusive_range_type_p (type
))
1358 /* A helper for rust_evaluate_subexp that handles BINOP_SUBSCRIPT. */
1360 static struct value
*
1361 rust_subscript (struct expression
*exp
, int *pos
, enum noside noside
,
1364 struct value
*lhs
, *rhs
, *result
;
1365 struct type
*rhstype
;
1366 LONGEST low
, high_bound
;
1367 /* Initialized to appease the compiler. */
1368 enum range_type kind
= BOTH_BOUND_DEFAULT
;
1373 lhs
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1374 rhs
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1376 if (noside
== EVAL_SKIP
)
1379 rhstype
= check_typedef (value_type (rhs
));
1380 if (rust_range_type_p (rhstype
))
1383 error (_("Can't take slice of array without '&'"));
1384 rust_compute_range (rhstype
, rhs
, &low
, &high
, &kind
);
1388 low
= value_as_long (rhs
);
1390 struct type
*type
= check_typedef (value_type (lhs
));
1391 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1393 struct type
*base_type
= nullptr;
1394 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
1395 base_type
= TYPE_TARGET_TYPE (type
);
1396 else if (rust_slice_type_p (type
))
1398 for (int i
= 0; i
< TYPE_NFIELDS (type
); ++i
)
1400 if (strcmp (TYPE_FIELD_NAME (type
, i
), "data_ptr") == 0)
1402 base_type
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type
, i
));
1406 if (base_type
== nullptr)
1407 error (_("Could not find 'data_ptr' in slice type"));
1409 else if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
1410 base_type
= TYPE_TARGET_TYPE (type
);
1412 error (_("Cannot subscript non-array type"));
1414 struct type
*new_type
;
1417 if (rust_slice_type_p (type
))
1422 = language_lookup_primitive_type (exp
->language_defn
,
1425 new_type
= rust_slice_type ("&[*gdb*]", base_type
, usize
);
1429 new_type
= base_type
;
1431 return value_zero (new_type
, VALUE_LVAL (lhs
));
1438 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
1441 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
1442 error (_("Can't compute array bounds"));
1444 error (_("Found array with non-zero lower bound"));
1447 else if (rust_slice_type_p (type
))
1451 base
= value_struct_elt (&lhs
, NULL
, "data_ptr", NULL
, "slice");
1452 len
= value_struct_elt (&lhs
, NULL
, "length", NULL
, "slice");
1454 high_bound
= value_as_long (len
);
1456 else if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
1460 high_bound
= LONGEST_MAX
;
1463 error (_("Cannot subscript non-array type"));
1466 && (kind
== BOTH_BOUND_DEFAULT
|| kind
== LOW_BOUND_DEFAULT
))
1469 error (_("Index less than zero"));
1470 if (low
> high_bound
)
1471 error (_("Index greater than length"));
1473 result
= value_subscript (base
, low
);
1480 struct type
*usize
, *slice
;
1482 struct value
*addrval
, *tem
;
1484 if (kind
== BOTH_BOUND_DEFAULT
|| kind
== HIGH_BOUND_DEFAULT
)
1487 error (_("High index less than zero"));
1489 error (_("Low index greater than high index"));
1490 if (high
> high_bound
)
1491 error (_("High index greater than length"));
1493 usize
= language_lookup_primitive_type (exp
->language_defn
,
1496 const char *new_name
= ((type
!= nullptr
1497 && rust_slice_type_p (type
))
1498 ? TYPE_NAME (type
) : "&[*gdb*]");
1500 slice
= rust_slice_type (new_name
, value_type (result
), usize
);
1502 addrval
= value_allocate_space_in_inferior (TYPE_LENGTH (slice
));
1503 addr
= value_as_long (addrval
);
1504 tem
= value_at_lazy (slice
, addr
);
1506 value_assign (value_field (tem
, 0), value_addr (result
));
1507 value_assign (value_field (tem
, 1),
1508 value_from_longest (usize
, high
- low
));
1510 result
= value_at_lazy (slice
, addr
);
1513 result
= value_addr (result
);
1519 /* evaluate_exp implementation for Rust. */
1521 static struct value
*
1522 rust_evaluate_subexp (struct type
*expect_type
, struct expression
*exp
,
1523 int *pos
, enum noside noside
)
1525 struct value
*result
;
1527 switch (exp
->elts
[*pos
].opcode
)
1531 if (noside
!= EVAL_NORMAL
)
1532 result
= evaluate_subexp_standard (expect_type
, exp
, pos
, noside
);
1536 struct value
*value
= evaluate_subexp (expect_type
, exp
, pos
,
1539 struct value
*trait_ptr
= rust_get_trait_object_pointer (value
);
1540 if (trait_ptr
!= NULL
)
1543 result
= value_ind (value
);
1548 case UNOP_COMPLEMENT
:
1550 struct value
*value
;
1553 value
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1554 if (noside
== EVAL_SKIP
)
1556 /* Preserving the type is enough. */
1559 if (TYPE_CODE (value_type (value
)) == TYPE_CODE_BOOL
)
1560 result
= value_from_longest (value_type (value
),
1561 value_logical_not (value
));
1563 result
= value_complement (value
);
1567 case BINOP_SUBSCRIPT
:
1568 result
= rust_subscript (exp
, pos
, noside
, 0);
1572 result
= rust_evaluate_funcall (exp
, pos
, noside
);
1578 struct type
*type
= exp
->elts
[pc
+ 1].type
;
1579 int arglen
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
1582 struct value
*addrval
= NULL
;
1586 if (noside
== EVAL_NORMAL
)
1588 addrval
= value_allocate_space_in_inferior (TYPE_LENGTH (type
));
1589 addr
= value_as_long (addrval
);
1590 result
= value_at_lazy (type
, addr
);
1593 if (arglen
> 0 && exp
->elts
[*pos
].opcode
== OP_OTHERS
)
1598 init
= rust_evaluate_subexp (NULL
, exp
, pos
, noside
);
1599 if (noside
== EVAL_NORMAL
)
1601 /* This isn't quite right but will do for the time
1602 being, seeing that we can't implement the Copy
1604 value_assign (result
, init
);
1610 gdb_assert (arglen
% 2 == 0);
1611 for (i
= 0; i
< arglen
; i
+= 2)
1614 const char *fieldname
;
1615 struct value
*value
, *field
;
1617 gdb_assert (exp
->elts
[*pos
].opcode
== OP_NAME
);
1619 len
= longest_to_int (exp
->elts
[*pos
].longconst
);
1621 fieldname
= &exp
->elts
[*pos
].string
;
1622 *pos
+= 2 + BYTES_TO_EXP_ELEM (len
+ 1);
1624 value
= rust_evaluate_subexp (NULL
, exp
, pos
, noside
);
1625 if (noside
== EVAL_NORMAL
)
1627 field
= value_struct_elt (&result
, NULL
, fieldname
, NULL
,
1629 value_assign (field
, value
);
1633 if (noside
== EVAL_SKIP
)
1634 return value_from_longest (builtin_type (exp
->gdbarch
)->builtin_int
,
1636 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1637 result
= allocate_value (type
);
1639 result
= value_at_lazy (type
, addr
);
1648 struct value
*ncopies
;
1650 elt
= rust_evaluate_subexp (NULL
, exp
, pos
, noside
);
1651 ncopies
= rust_evaluate_subexp (NULL
, exp
, pos
, noside
);
1652 copies
= value_as_long (ncopies
);
1654 error (_("Array with negative number of elements"));
1656 if (noside
== EVAL_NORMAL
)
1659 std::vector
<struct value
*> eltvec (copies
);
1661 for (i
= 0; i
< copies
; ++i
)
1663 result
= value_array (0, copies
- 1, eltvec
.data ());
1667 struct type
*arraytype
1668 = lookup_array_range_type (value_type (elt
), 0, copies
- 1);
1669 result
= allocate_value (arraytype
);
1674 case STRUCTOP_ANONYMOUS
:
1676 /* Anonymous field access, i.e. foo.1. */
1678 int pc
, field_number
, nfields
;
1682 field_number
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1684 lhs
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1686 type
= value_type (lhs
);
1688 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
1690 struct type
*outer_type
= NULL
;
1692 if (rust_enum_p (type
))
1694 if (rust_empty_enum_p (type
))
1695 error (_("Cannot access field %d of empty enum %s"),
1696 field_number
, TYPE_NAME (type
));
1698 const gdb_byte
*valaddr
= value_contents (lhs
);
1699 struct field
*variant_field
= rust_enum_variant (type
, valaddr
);
1701 struct value
*union_value
= value_primitive_field (lhs
, 0, 0,
1704 int fieldno
= (variant_field
1705 - &TYPE_FIELD (value_type (union_value
), 0));
1706 lhs
= value_primitive_field (union_value
, 0, fieldno
,
1707 value_type (union_value
));
1709 type
= value_type (lhs
);
1712 /* Tuples and tuple structs */
1713 nfields
= TYPE_NFIELDS (type
);
1715 if (field_number
>= nfields
|| field_number
< 0)
1717 if (outer_type
!= NULL
)
1718 error(_("Cannot access field %d of variant %s::%s, "
1719 "there are only %d fields"),
1720 field_number
, TYPE_NAME (outer_type
),
1721 rust_last_path_segment (TYPE_NAME (type
)),
1724 error(_("Cannot access field %d of %s, "
1725 "there are only %d fields"),
1726 field_number
, TYPE_NAME (type
), nfields
);
1729 /* Tuples are tuple structs too. */
1730 if (!rust_tuple_struct_type_p (type
))
1732 if (outer_type
!= NULL
)
1733 error(_("Variant %s::%s is not a tuple variant"),
1734 TYPE_NAME (outer_type
),
1735 rust_last_path_segment (TYPE_NAME (type
)));
1737 error(_("Attempting to access anonymous field %d "
1738 "of %s, which is not a tuple, tuple struct, or "
1739 "tuple-like variant"),
1740 field_number
, TYPE_NAME (type
));
1743 result
= value_primitive_field (lhs
, 0, field_number
, type
);
1746 error(_("Anonymous field access is only allowed on tuples, \
1747 tuple structs, and tuple-like enum variants"));
1751 case STRUCTOP_STRUCT
:
1758 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1759 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1760 lhs
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1762 const char *field_name
= &exp
->elts
[pc
+ 2].string
;
1763 type
= value_type (lhs
);
1764 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
&& rust_enum_p (type
))
1766 if (rust_empty_enum_p (type
))
1767 error (_("Cannot access field %s of empty enum %s"),
1768 field_name
, TYPE_NAME (type
));
1770 const gdb_byte
*valaddr
= value_contents (lhs
);
1771 struct field
*variant_field
= rust_enum_variant (type
, valaddr
);
1773 struct value
*union_value
= value_primitive_field (lhs
, 0, 0,
1776 int fieldno
= (variant_field
1777 - &TYPE_FIELD (value_type (union_value
), 0));
1778 lhs
= value_primitive_field (union_value
, 0, fieldno
,
1779 value_type (union_value
));
1781 struct type
*outer_type
= type
;
1782 type
= value_type (lhs
);
1783 if (rust_tuple_type_p (type
) || rust_tuple_struct_type_p (type
))
1784 error (_("Attempting to access named field %s of tuple "
1785 "variant %s::%s, which has only anonymous fields"),
1786 field_name
, TYPE_NAME (outer_type
),
1787 rust_last_path_segment (TYPE_NAME (type
)));
1791 result
= value_struct_elt (&lhs
, NULL
, field_name
,
1794 catch (const gdb_exception_error
&except
)
1796 error (_("Could not find field %s of struct variant %s::%s"),
1797 field_name
, TYPE_NAME (outer_type
),
1798 rust_last_path_segment (TYPE_NAME (type
)));
1802 result
= value_struct_elt (&lhs
, NULL
, field_name
, NULL
, "structure");
1803 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1804 result
= value_zero (value_type (result
), VALUE_LVAL (result
));
1809 result
= rust_range (exp
, pos
, noside
);
1813 /* We might have &array[range], in which case we need to make a
1815 if (exp
->elts
[*pos
+ 1].opcode
== BINOP_SUBSCRIPT
)
1818 result
= rust_subscript (exp
, pos
, noside
, 1);
1823 result
= evaluate_subexp_standard (expect_type
, exp
, pos
, noside
);
1830 /* operator_length implementation for Rust. */
1833 rust_operator_length (const struct expression
*exp
, int pc
, int *oplenp
,
1839 switch (exp
->elts
[pc
- 1].opcode
)
1842 /* We handle aggregate as a type and argument count. The first
1843 argument might be OP_OTHERS. After that the arguments
1844 alternate: first an OP_NAME, then an expression. */
1846 args
= longest_to_int (exp
->elts
[pc
- 2].longconst
);
1854 case STRUCTOP_ANONYMOUS
:
1865 operator_length_standard (exp
, pc
, oplenp
, argsp
);
1873 /* op_name implementation for Rust. */
1876 rust_op_name (enum exp_opcode opcode
)
1881 return "OP_AGGREGATE";
1885 return op_name_standard (opcode
);
1889 /* dump_subexp_body implementation for Rust. */
1892 rust_dump_subexp_body (struct expression
*exp
, struct ui_file
*stream
,
1895 switch (exp
->elts
[elt
].opcode
)
1899 int length
= longest_to_int (exp
->elts
[elt
+ 2].longconst
);
1902 fprintf_filtered (stream
, "Type @");
1903 gdb_print_host_address (exp
->elts
[elt
+ 1].type
, stream
);
1904 fprintf_filtered (stream
, " (");
1905 type_print (exp
->elts
[elt
+ 1].type
, NULL
, stream
, 0);
1906 fprintf_filtered (stream
, "), length %d", length
);
1909 for (i
= 0; i
< length
; ++i
)
1910 elt
= dump_subexp (exp
, stream
, elt
);
1917 LONGEST len
= exp
->elts
[elt
+ 1].longconst
;
1919 fprintf_filtered (stream
, "%s: %s",
1920 (exp
->elts
[elt
].opcode
== OP_STRING
1921 ? "string" : "name"),
1922 &exp
->elts
[elt
+ 2].string
);
1923 elt
+= 4 + BYTES_TO_EXP_ELEM (len
+ 1);
1928 elt
= dump_subexp (exp
, stream
, elt
+ 1);
1931 case STRUCTOP_ANONYMOUS
:
1935 field_number
= longest_to_int (exp
->elts
[elt
+ 1].longconst
);
1937 fprintf_filtered (stream
, "Field number: %d", field_number
);
1938 elt
= dump_subexp (exp
, stream
, elt
+ 3);
1947 elt
= dump_subexp_body_standard (exp
, stream
, elt
);
1954 /* print_subexp implementation for Rust. */
1957 rust_print_subexp (struct expression
*exp
, int *pos
, struct ui_file
*stream
,
1958 enum precedence prec
)
1960 switch (exp
->elts
[*pos
].opcode
)
1964 int length
= longest_to_int (exp
->elts
[*pos
+ 2].longconst
);
1967 type_print (exp
->elts
[*pos
+ 1].type
, "", stream
, 0);
1968 fputs_filtered (" { ", stream
);
1971 for (i
= 0; i
< length
; ++i
)
1973 rust_print_subexp (exp
, pos
, stream
, prec
);
1974 fputs_filtered (", ", stream
);
1976 fputs_filtered (" }", stream
);
1982 LONGEST len
= exp
->elts
[*pos
+ 1].longconst
;
1984 fputs_filtered (&exp
->elts
[*pos
+ 2].string
, stream
);
1985 *pos
+= 4 + BYTES_TO_EXP_ELEM (len
+ 1);
1991 fputs_filtered ("<<others>> (", stream
);
1993 rust_print_subexp (exp
, pos
, stream
, prec
);
1994 fputs_filtered (")", stream
);
1998 case STRUCTOP_ANONYMOUS
:
2000 int tem
= longest_to_int (exp
->elts
[*pos
+ 1].longconst
);
2003 print_subexp (exp
, pos
, stream
, PREC_SUFFIX
);
2004 fprintf_filtered (stream
, ".%d", tem
);
2010 fprintf_filtered (stream
, "[");
2011 rust_print_subexp (exp
, pos
, stream
, prec
);
2012 fprintf_filtered (stream
, "; ");
2013 rust_print_subexp (exp
, pos
, stream
, prec
);
2014 fprintf_filtered (stream
, "]");
2018 print_subexp_standard (exp
, pos
, stream
, prec
);
2023 /* operator_check implementation for Rust. */
2026 rust_operator_check (struct expression
*exp
, int pos
,
2027 int (*objfile_func
) (struct objfile
*objfile
,
2031 switch (exp
->elts
[pos
].opcode
)
2035 struct type
*type
= exp
->elts
[pos
+ 1].type
;
2036 struct objfile
*objfile
= TYPE_OBJFILE (type
);
2038 if (objfile
!= NULL
&& (*objfile_func
) (objfile
, data
))
2049 return operator_check_standard (exp
, pos
, objfile_func
, data
);
2057 /* Implementation of la_lookup_symbol_nonlocal for Rust. */
2059 static struct block_symbol
2060 rust_lookup_symbol_nonlocal (const struct language_defn
*langdef
,
2062 const struct block
*block
,
2063 const domain_enum domain
)
2065 struct block_symbol result
= {};
2067 if (symbol_lookup_debug
)
2069 fprintf_unfiltered (gdb_stdlog
,
2070 "rust_lookup_symbol_non_local"
2071 " (%s, %s (scope %s), %s)\n",
2072 name
, host_address_to_string (block
),
2073 block_scope (block
), domain_name (domain
));
2076 /* Look up bare names in the block's scope. */
2077 std::string scopedname
;
2078 if (name
[cp_find_first_component (name
)] == '\0')
2080 const char *scope
= block_scope (block
);
2082 if (scope
[0] != '\0')
2084 scopedname
= std::string (scope
) + "::" + name
;
2085 name
= scopedname
.c_str ();
2093 result
= lookup_symbol_in_static_block (name
, block
, domain
);
2094 if (result
.symbol
== NULL
)
2095 result
= lookup_global_symbol (name
, block
, domain
);
2102 /* la_sniff_from_mangled_name for Rust. */
2105 rust_sniff_from_mangled_name (const char *mangled
, char **demangled
)
2107 *demangled
= gdb_demangle (mangled
, DMGL_PARAMS
| DMGL_ANSI
);
2108 return *demangled
!= NULL
;
2113 /* la_watch_location_expression for Rust. */
2115 static gdb::unique_xmalloc_ptr
<char>
2116 rust_watch_location_expression (struct type
*type
, CORE_ADDR addr
)
2118 type
= check_typedef (TYPE_TARGET_TYPE (check_typedef (type
)));
2119 std::string name
= type_to_string (type
);
2120 return gdb::unique_xmalloc_ptr
<char>
2121 (xstrprintf ("*(%s as *mut %s)", core_addr_to_string (addr
),
2127 static const struct exp_descriptor exp_descriptor_rust
=
2130 rust_operator_length
,
2131 rust_operator_check
,
2133 rust_dump_subexp_body
,
2134 rust_evaluate_subexp
2137 static const char *rust_extensions
[] =
2142 extern const struct language_defn rust_language_defn
=
2152 &exp_descriptor_rust
,
2155 rust_printchar
, /* Print a character constant */
2156 rust_printstr
, /* Function to print string constant */
2157 rust_emitchar
, /* Print a single char */
2158 rust_print_type
, /* Print a type using appropriate syntax */
2159 rust_print_typedef
, /* Print a typedef using appropriate syntax */
2160 rust_val_print
, /* Print a value using appropriate syntax */
2161 rust_value_print_inner
, /* la_value_print_inner */
2162 c_value_print
, /* Print a top-level value */
2163 default_read_var_value
, /* la_read_var_value */
2164 NULL
, /* Language specific skip_trampoline */
2165 NULL
, /* name_of_this */
2166 false, /* la_store_sym_names_in_linkage_form_p */
2167 rust_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
2168 basic_lookup_transparent_type
,/* lookup_transparent_type */
2169 gdb_demangle
, /* Language specific symbol demangler */
2170 rust_sniff_from_mangled_name
,
2171 NULL
, /* Language specific
2172 class_name_from_physname */
2173 c_op_print_tab
, /* expression operators for printing */
2174 1, /* c-style arrays */
2175 0, /* String lower bound */
2176 default_word_break_characters
,
2177 default_collect_symbol_completion_matches
,
2178 rust_language_arch_info
,
2179 default_print_array_index
,
2180 default_pass_by_reference
,
2181 rust_watch_location_expression
,
2182 NULL
, /* la_get_symbol_name_matcher */
2183 iterate_over_symbols
,
2184 default_search_name_hash
,
2185 &default_varobj_ops
,
2188 rust_is_string_type_p
,
2189 "{...}" /* la_struct_too_deep_ellipsis */