projects / deliverable / binutils-gdb.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Remove null_block_symbol
[deliverable/binutils-gdb.git] / gdb / rust-lang.c
... / ...
CommitLineData
1/* Rust language support routines for GDB, the GNU debugger.
2
3 Copyright (C) 2016-2019 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
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.
11
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.
16
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/>. */
19
20#include "defs.h"
21
22#include <ctype.h>
23
24#include "block.h"
25#include "c-lang.h"
26#include "charset.h"
27#include "cp-support.h"
28#include "demangle.h"
29#include "gdbarch.h"
30#include "infcall.h"
31#include "objfiles.h"
32#include "psymtab.h"
33#include "rust-lang.h"
34#include "typeprint.h"
35#include "valprint.h"
36#include "varobj.h"
37#include <algorithm>
38#include <string>
39#include <vector>
40
41/* See rust-lang.h. */
42
43const char *
44rust_last_path_segment (const char *path)
45{
46 const char *result = strrchr (path, ':');
47
48 if (result == NULL)
49 return path;
50 return result + 1;
51}
52
53/* See rust-lang.h. */
54
55std::string
56rust_crate_for_block (const struct block *block)
57{
58 const char *scope = block_scope (block);
59
60 if (scope[0] == '\0')
61 return std::string ();
62
63 return std::string (scope, cp_find_first_component (scope));
64}
65
66/* Return true if TYPE, which must be a struct type, represents a Rust
67 enum. */
68
69static bool
70rust_enum_p (const struct type *type)
71{
72 return (TYPE_CODE (type) == TYPE_CODE_STRUCT
73 && TYPE_NFIELDS (type) == 1
74 && TYPE_FLAG_DISCRIMINATED_UNION (TYPE_FIELD_TYPE (type, 0)));
75}
76
77/* Return true if TYPE, which must be an enum type, has no
78 variants. */
79
80static bool
81rust_empty_enum_p (const struct type *type)
82{
83 gdb_assert (rust_enum_p (type));
84 /* In Rust the enum always fills the containing structure. */
85 gdb_assert (TYPE_FIELD_BITPOS (type, 0) == 0);
86
87 return TYPE_NFIELDS (TYPE_FIELD_TYPE (type, 0)) == 0;
88}
89
90/* Given an enum type and contents, find which variant is active. */
91
92static struct field *
93rust_enum_variant (struct type *type, const gdb_byte *contents)
94{
95 /* In Rust the enum always fills the containing structure. */
96 gdb_assert (TYPE_FIELD_BITPOS (type, 0) == 0);
97
98 struct type *union_type = TYPE_FIELD_TYPE (type, 0);
99
100 int fieldno = value_union_variant (union_type, contents);
101 return &TYPE_FIELD (union_type, fieldno);
102}
103
104/* See rust-lang.h. */
105
106bool
107rust_tuple_type_p (struct type *type)
108{
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
111 struct. */
112 return (TYPE_CODE (type) == TYPE_CODE_STRUCT
113 && TYPE_NAME (type) != NULL
114 && TYPE_NAME (type)[0] == '(');
115}
116
117/* Return true if all non-static fields of a structlike type are in a
118 sequence like __0, __1, __2. */
119
120static bool
121rust_underscore_fields (struct type *type)
122{
123 int i, field_number;
124
125 field_number = 0;
126
127 if (TYPE_CODE (type) != TYPE_CODE_STRUCT)
128 return false;
129 for (i = 0; i < TYPE_NFIELDS (type); ++i)
130 {
131 if (!field_is_static (&TYPE_FIELD (type, i)))
132 {
133 char buf[20];
134
135 xsnprintf (buf, sizeof (buf), "__%d", field_number);
136 if (strcmp (buf, TYPE_FIELD_NAME (type, i)) != 0)
137 return false;
138 field_number++;
139 }
140 }
141 return true;
142}
143
144/* See rust-lang.h. */
145
146bool
147rust_tuple_struct_type_p (struct type *type)
148{
149 /* This is just an approximation until DWARF can represent Rust more
150 precisely. We exclude zero-length structs because they may not
151 be tuple structs, and there's no way to tell. */
152 return TYPE_NFIELDS (type) > 0 && rust_underscore_fields (type);
153}
154
155/* Return true if TYPE is a slice type, otherwise false. */
156
157static bool
158rust_slice_type_p (struct type *type)
159{
160 return (TYPE_CODE (type) == TYPE_CODE_STRUCT
161 && TYPE_NAME (type) != NULL
162 && (strncmp (TYPE_NAME (type), "&[", 2) == 0
163 || strcmp (TYPE_NAME (type), "&str") == 0));
164}
165
166/* Return true if TYPE is a range type, otherwise false. */
167
168static bool
169rust_range_type_p (struct type *type)
170{
171 int i;
172
173 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
174 || TYPE_NFIELDS (type) > 2
175 || TYPE_NAME (type) == NULL
176 || strstr (TYPE_NAME (type), "::Range") == NULL)
177 return false;
178
179 if (TYPE_NFIELDS (type) == 0)
180 return true;
181
182 i = 0;
183 if (strcmp (TYPE_FIELD_NAME (type, 0), "start") == 0)
184 {
185 if (TYPE_NFIELDS (type) == 1)
186 return true;
187 i = 1;
188 }
189 else if (TYPE_NFIELDS (type) == 2)
190 {
191 /* First field had to be "start". */
192 return false;
193 }
194
195 return strcmp (TYPE_FIELD_NAME (type, i), "end") == 0;
196}
197
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
200 types. */
201
202static bool
203rust_inclusive_range_type_p (struct type *type)
204{
205 return (strstr (TYPE_NAME (type), "::RangeInclusive") != NULL
206 || strstr (TYPE_NAME (type), "::RangeToInclusive") != NULL);
207}
208
209/* Return true if TYPE seems to be the type "u8", otherwise false. */
210
211static bool
212rust_u8_type_p (struct type *type)
213{
214 return (TYPE_CODE (type) == TYPE_CODE_INT
215 && TYPE_UNSIGNED (type)
216 && TYPE_LENGTH (type) == 1);
217}
218
219/* Return true if TYPE is a Rust character type. */
220
221static bool
222rust_chartype_p (struct type *type)
223{
224 return (TYPE_CODE (type) == TYPE_CODE_CHAR
225 && TYPE_LENGTH (type) == 4
226 && TYPE_UNSIGNED (type));
227}
228
229/* If VALUE represents a trait object pointer, return the underlying
230 pointer with the correct (i.e., runtime) type. Otherwise, return
231 NULL. */
232
233static struct value *
234rust_get_trait_object_pointer (struct value *value)
235{
236 struct type *type = check_typedef (value_type (value));
237
238 if (TYPE_CODE (type) != TYPE_CODE_STRUCT || TYPE_NFIELDS (type) != 2)
239 return NULL;
240
241 /* Try to be a bit resilient if the ABI changes. */
242 int vtable_field = 0;
243 for (int i = 0; i < 2; ++i)
244 {
245 if (strcmp (TYPE_FIELD_NAME (type, i), "vtable") == 0)
246 vtable_field = i;
247 else if (strcmp (TYPE_FIELD_NAME (type, i), "pointer") != 0)
248 return NULL;
249 }
250
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)
254 return NULL;
255
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));
260}
261
262\f
263
264/* la_emitchar implementation for Rust. */
265
266static void
267rust_emitchar (int c, struct type *type, struct ui_file *stream, int quoter)
268{
269 if (!rust_chartype_p (type))
270 generic_emit_char (c, type, stream, quoter,
271 target_charset (get_type_arch (type)));
272 else if (c == '\\' || c == quoter)
273 fprintf_filtered (stream, "\\%c", c);
274 else if (c == '\n')
275 fputs_filtered ("\\n", stream);
276 else if (c == '\r')
277 fputs_filtered ("\\r", stream);
278 else if (c == '\t')
279 fputs_filtered ("\\t", stream);
280 else if (c == '\0')
281 fputs_filtered ("\\0", stream);
282 else if (c >= 32 && c <= 127 && isprint (c))
283 fputc_filtered (c, stream);
284 else if (c <= 255)
285 fprintf_filtered (stream, "\\x%02x", c);
286 else
287 fprintf_filtered (stream, "\\u{%06x}", c);
288}
289
290/* la_printchar implementation for Rust. */
291
292static void
293rust_printchar (int c, struct type *type, struct ui_file *stream)
294{
295 fputs_filtered ("'", stream);
296 LA_EMIT_CHAR (c, type, stream, '\'');
297 fputs_filtered ("'", stream);
298}
299
300/* la_printstr implementation for Rust. */
301
302static void
303rust_printstr (struct ui_file *stream, struct type *type,
304 const gdb_byte *string, unsigned int length,
305 const char *user_encoding, int force_ellipses,
306 const struct value_print_options *options)
307{
308 /* Rust always uses UTF-8, but let the caller override this if need
309 be. */
310 const char *encoding = user_encoding;
311 if (user_encoding == NULL || !*user_encoding)
312 {
313 /* In Rust strings, characters are "u8". */
314 if (rust_u8_type_p (type))
315 encoding = "UTF-8";
316 else
317 {
318 /* This is probably some C string, so let's let C deal with
319 it. */
320 c_printstr (stream, type, string, length, user_encoding,
321 force_ellipses, options);
322 return;
323 }
324 }
325
326 /* This is not ideal as it doesn't use our character printer. */
327 generic_printstr (stream, type, string, length, encoding, force_ellipses,
328 '"', 0, options);
329}
330
331\f
332
333/* Helper function to print a string slice. */
334
335static void
336rust_val_print_str (struct ui_file *stream, struct value *val,
337 const struct value_print_options *options)
338{
339 struct value *base = value_struct_elt (&val, NULL, "data_ptr", NULL,
340 "slice");
341 struct value *len = value_struct_elt (&val, NULL, "length", NULL, "slice");
342
343 val_print_string (TYPE_TARGET_TYPE (value_type (base)), "UTF-8",
344 value_as_address (base), value_as_long (len), stream,
345 options);
346}
347
348/* rust_val_print helper for structs and untagged unions. */
349
350static void
351val_print_struct (struct type *type, int embedded_offset,
352 CORE_ADDR address, struct ui_file *stream,
353 int recurse, struct value *val,
354 const struct value_print_options *options)
355{
356 int i;
357 int first_field;
358
359 if (rust_slice_type_p (type) && strcmp (TYPE_NAME (type), "&str") == 0)
360 {
361 rust_val_print_str (stream, val, options);
362 return;
363 }
364
365 bool is_tuple = rust_tuple_type_p (type);
366 bool is_tuple_struct = !is_tuple && rust_tuple_struct_type_p (type);
367 struct value_print_options opts;
368
369 if (!is_tuple)
370 {
371 if (TYPE_NAME (type) != NULL)
372 fprintf_filtered (stream, "%s", TYPE_NAME (type));
373
374 if (TYPE_NFIELDS (type) == 0)
375 return;
376
377 if (TYPE_NAME (type) != NULL)
378 fputs_filtered (" ", stream);
379 }
380
381 if (is_tuple || is_tuple_struct)
382 fputs_filtered ("(", stream);
383 else
384 fputs_filtered ("{", stream);
385
386 opts = *options;
387 opts.deref_ref = 0;
388
389 first_field = 1;
390 for (i = 0; i < TYPE_NFIELDS (type); ++i)
391 {
392 if (field_is_static (&TYPE_FIELD (type, i)))
393 continue;
394
395 if (!first_field)
396 fputs_filtered (",", stream);
397
398 if (options->prettyformat)
399 {
400 fputs_filtered ("\n", stream);
401 print_spaces_filtered (2 + 2 * recurse, stream);
402 }
403 else if (!first_field)
404 fputs_filtered (" ", stream);
405
406 first_field = 0;
407
408 if (!is_tuple && !is_tuple_struct)
409 {
410 fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
411 fputs_filtered (": ", stream);
412 }
413
414 val_print (TYPE_FIELD_TYPE (type, i),
415 embedded_offset + TYPE_FIELD_BITPOS (type, i) / 8,
416 address,
417 stream, recurse + 1, val, &opts,
418 current_language);
419 }
420
421 if (options->prettyformat)
422 {
423 fputs_filtered ("\n", stream);
424 print_spaces_filtered (2 * recurse, stream);
425 }
426
427 if (is_tuple || is_tuple_struct)
428 fputs_filtered (")", stream);
429 else
430 fputs_filtered ("}", stream);
431}
432
433/* rust_val_print helper for discriminated unions (Rust enums). */
434
435static void
436rust_print_enum (struct type *type, int embedded_offset,
437 CORE_ADDR address, struct ui_file *stream,
438 int recurse, struct value *val,
439 const struct value_print_options *options)
440{
441 struct value_print_options opts = *options;
442
443 opts.deref_ref = 0;
444
445 if (rust_empty_enum_p (type))
446 {
447 /* Print the enum type name here to be more clear. */
448 fprintf_filtered (stream, _("%s {<No data fields>}"), TYPE_NAME (type));
449 return;
450 }
451
452 const gdb_byte *valaddr = value_contents_for_printing (val);
453 struct field *variant_field = rust_enum_variant (type, valaddr);
454 embedded_offset += FIELD_BITPOS (*variant_field) / 8;
455 struct type *variant_type = FIELD_TYPE (*variant_field);
456
457 int nfields = TYPE_NFIELDS (variant_type);
458
459 bool is_tuple = rust_tuple_struct_type_p (variant_type);
460
461 fprintf_filtered (stream, "%s", TYPE_NAME (variant_type));
462 if (nfields == 0)
463 {
464 /* In case of a nullary variant like 'None', just output
465 the name. */
466 return;
467 }
468
469 /* In case of a non-nullary variant, we output 'Foo(x,y,z)'. */
470 if (is_tuple)
471 fprintf_filtered (stream, "(");
472 else
473 {
474 /* struct variant. */
475 fprintf_filtered (stream, "{");
476 }
477
478 bool first_field = true;
479 for (int j = 0; j < TYPE_NFIELDS (variant_type); j++)
480 {
481 if (!first_field)
482 fputs_filtered (", ", stream);
483 first_field = false;
484
485 if (!is_tuple)
486 fprintf_filtered (stream, "%s: ",
487 TYPE_FIELD_NAME (variant_type, j));
488
489 val_print (TYPE_FIELD_TYPE (variant_type, j),
490 (embedded_offset
491 + TYPE_FIELD_BITPOS (variant_type, j) / 8),
492 address,
493 stream, recurse + 1, val, &opts,
494 current_language);
495 }
496
497 if (is_tuple)
498 fputs_filtered (")", stream);
499 else
500 fputs_filtered ("}", stream);
501}
502
503static const struct generic_val_print_decorations rust_decorations =
504{
505 /* Complex isn't used in Rust, but we provide C-ish values just in
506 case. */
507 "",
508 " + ",
509 " * I",
510 "true",
511 "false",
512 "()",
513 "[",
514 "]"
515};
516
517/* la_val_print implementation for Rust. */
518
519static void
520rust_val_print (struct type *type, int embedded_offset,
521 CORE_ADDR address, struct ui_file *stream, int recurse,
522 struct value *val,
523 const struct value_print_options *options)
524{
525 const gdb_byte *valaddr = value_contents_for_printing (val);
526
527 type = check_typedef (type);
528 switch (TYPE_CODE (type))
529 {
530 case TYPE_CODE_PTR:
531 {
532 LONGEST low_bound, high_bound;
533
534 if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_ARRAY
535 && rust_u8_type_p (TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (type)))
536 && get_array_bounds (TYPE_TARGET_TYPE (type), &low_bound,
537 &high_bound)) {
538 /* We have a pointer to a byte string, so just print
539 that. */
540 struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));
541 CORE_ADDR addr;
542 struct gdbarch *arch = get_type_arch (type);
543 int unit_size = gdbarch_addressable_memory_unit_size (arch);
544
545 addr = unpack_pointer (type, valaddr + embedded_offset * unit_size);
546 if (options->addressprint)
547 {
548 fputs_filtered (paddress (arch, addr), stream);
549 fputs_filtered (" ", stream);
550 }
551
552 fputs_filtered ("b", stream);
553 val_print_string (TYPE_TARGET_TYPE (elttype), "ASCII", addr,
554 high_bound - low_bound + 1, stream,
555 options);
556 break;
557 }
558 }
559 /* Fall through. */
560
561 case TYPE_CODE_METHODPTR:
562 case TYPE_CODE_MEMBERPTR:
563 c_val_print (type, embedded_offset, address, stream,
564 recurse, val, options);
565 break;
566
567 case TYPE_CODE_INT:
568 /* Recognize the unit type. */
569 if (TYPE_UNSIGNED (type) && TYPE_LENGTH (type) == 0
570 && TYPE_NAME (type) != NULL && strcmp (TYPE_NAME (type), "()") == 0)
571 {
572 fputs_filtered ("()", stream);
573 break;
574 }
575 goto generic_print;
576
577 case TYPE_CODE_STRING:
578 {
579 struct gdbarch *arch = get_type_arch (type);
580 int unit_size = gdbarch_addressable_memory_unit_size (arch);
581 LONGEST low_bound, high_bound;
582
583 if (!get_array_bounds (type, &low_bound, &high_bound))
584 error (_("Could not determine the array bounds"));
585
586 /* If we see a plain TYPE_CODE_STRING, then we're printing a
587 byte string, hence the choice of "ASCII" as the
588 encoding. */
589 fputs_filtered ("b", stream);
590 rust_printstr (stream, TYPE_TARGET_TYPE (type),
591 valaddr + embedded_offset * unit_size,
592 high_bound - low_bound + 1, "ASCII", 0, options);
593 }
594 break;
595
596 case TYPE_CODE_ARRAY:
597 {
598 LONGEST low_bound, high_bound;
599
600 if (get_array_bounds (type, &low_bound, &high_bound)
601 && high_bound - low_bound + 1 == 0)
602 fputs_filtered ("[]", stream);
603 else
604 goto generic_print;
605 }
606 break;
607
608 case TYPE_CODE_UNION:
609 /* Untagged unions are printed as if they are structs. Since
610 the field bit positions overlap in the debuginfo, the code
611 for printing a union is same as that for a struct, the only
612 difference is that the input type will have overlapping
613 fields. */
614 val_print_struct (type, embedded_offset, address, stream,
615 recurse, val, options);
616 break;
617
618 case TYPE_CODE_STRUCT:
619 if (rust_enum_p (type))
620 rust_print_enum (type, embedded_offset, address, stream,
621 recurse, val, options);
622 else
623 val_print_struct (type, embedded_offset, address, stream,
624 recurse, val, options);
625 break;
626
627 default:
628 generic_print:
629 /* Nothing special yet. */
630 generic_val_print (type, embedded_offset, address, stream,
631 recurse, val, options, &rust_decorations);
632 }
633}
634
635\f
636
637static void
638rust_internal_print_type (struct type *type, const char *varstring,
639 struct ui_file *stream, int show, int level,
640 const struct type_print_options *flags,
641 bool for_rust_enum, print_offset_data *podata);
642
643/* Print a struct or union typedef. */
644static void
645rust_print_struct_def (struct type *type, const char *varstring,
646 struct ui_file *stream, int show, int level,
647 const struct type_print_options *flags,
648 bool for_rust_enum, print_offset_data *podata)
649{
650 /* Print a tuple type simply. */
651 if (rust_tuple_type_p (type))
652 {
653 fputs_filtered (TYPE_NAME (type), stream);
654 return;
655 }
656
657 /* If we see a base class, delegate to C. */
658 if (TYPE_N_BASECLASSES (type) > 0)
659 c_print_type (type, varstring, stream, show, level, flags);
660
661 if (flags->print_offsets)
662 {
663 /* Temporarily bump the level so that the output lines up
664 correctly. */
665 level += 2;
666 }
667
668 /* Compute properties of TYPE here because, in the enum case, the
669 rest of the code ends up looking only at the variant part. */
670 const char *tagname = TYPE_NAME (type);
671 bool is_tuple_struct = rust_tuple_struct_type_p (type);
672 bool is_tuple = rust_tuple_type_p (type);
673 bool is_enum = rust_enum_p (type);
674
675 int enum_discriminant_index = -1;
676
677 if (for_rust_enum)
678 {
679 /* Already printing an outer enum, so nothing to print here. */
680 }
681 else
682 {
683 /* This code path is also used by unions and enums. */
684 if (is_enum)
685 {
686 fputs_filtered ("enum ", stream);
687
688 if (rust_empty_enum_p (type))
689 {
690 if (tagname != NULL)
691 {
692 fputs_filtered (tagname, stream);
693 fputs_filtered (" ", stream);
694 }
695 fputs_filtered ("{}", stream);
696 return;
697 }
698
699 type = TYPE_FIELD_TYPE (type, 0);
700
701 struct dynamic_prop *discriminant_prop
702 = get_dyn_prop (DYN_PROP_DISCRIMINATED, type);
703 struct discriminant_info *info
704 = (struct discriminant_info *) discriminant_prop->data.baton;
705 enum_discriminant_index = info->discriminant_index;
706 }
707 else if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
708 fputs_filtered ("struct ", stream);
709 else
710 fputs_filtered ("union ", stream);
711
712 if (tagname != NULL)
713 fputs_filtered (tagname, stream);
714 }
715
716 if (TYPE_NFIELDS (type) == 0 && !is_tuple)
717 return;
718 if (for_rust_enum && !flags->print_offsets)
719 fputs_filtered (is_tuple_struct ? "(" : "{", stream);
720 else
721 fputs_filtered (is_tuple_struct ? " (\n" : " {\n", stream);
722
723 /* When printing offsets, we rearrange the fields into storage
724 order. This lets us show holes more clearly. We work using
725 field indices here because it simplifies calls to
726 print_offset_data::update below. */
727 std::vector<int> fields;
728 for (int i = 0; i < TYPE_NFIELDS (type); ++i)
729 {
730 if (field_is_static (&TYPE_FIELD (type, i)))
731 continue;
732 if (is_enum && i == enum_discriminant_index)
733 continue;
734 fields.push_back (i);
735 }
736 if (flags->print_offsets)
737 std::sort (fields.begin (), fields.end (),
738 [&] (int a, int b)
739 {
740 return (TYPE_FIELD_BITPOS (type, a)
741 < TYPE_FIELD_BITPOS (type, b));
742 });
743
744 for (int i : fields)
745 {
746 QUIT;
747
748 gdb_assert (!field_is_static (&TYPE_FIELD (type, i)));
749 gdb_assert (! (is_enum && i == enum_discriminant_index));
750
751 if (flags->print_offsets)
752 podata->update (type, i, stream);
753
754 /* We'd like to print "pub" here as needed, but rustc
755 doesn't emit the debuginfo, and our types don't have
756 cplus_struct_type attached. */
757
758 /* For a tuple struct we print the type but nothing
759 else. */
760 if (!for_rust_enum || flags->print_offsets)
761 print_spaces_filtered (level + 2, stream);
762 if (is_enum)
763 fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
764 else if (!is_tuple_struct)
765 fprintf_filtered (stream, "%s: ", TYPE_FIELD_NAME (type, i));
766
767 rust_internal_print_type (TYPE_FIELD_TYPE (type, i), NULL,
768 stream, (is_enum ? show : show - 1),
769 level + 2, flags, is_enum, podata);
770 if (!for_rust_enum || flags->print_offsets)
771 fputs_filtered (",\n", stream);
772 /* Note that this check of "I" is ok because we only sorted the
773 fields by offset when print_offsets was set, so we won't take
774 this branch in that case. */
775 else if (i + 1 < TYPE_NFIELDS (type))
776 fputs_filtered (", ", stream);
777 }
778
779 if (flags->print_offsets)
780 {
781 /* Undo the temporary level increase we did above. */
782 level -= 2;
783 podata->finish (type, level, stream);
784 print_spaces_filtered (print_offset_data::indentation, stream);
785 if (level == 0)
786 print_spaces_filtered (2, stream);
787 }
788 if (!for_rust_enum || flags->print_offsets)
789 print_spaces_filtered (level, stream);
790 fputs_filtered (is_tuple_struct ? ")" : "}", stream);
791}
792
793/* la_print_typedef implementation for Rust. */
794
795static void
796rust_print_typedef (struct type *type,
797 struct symbol *new_symbol,
798 struct ui_file *stream)
799{
800 type = check_typedef (type);
801 fprintf_filtered (stream, "type %s = ", SYMBOL_PRINT_NAME (new_symbol));
802 type_print (type, "", stream, 0);
803 fprintf_filtered (stream, ";\n");
804}
805
806/* la_print_type implementation for Rust. */
807
808static void
809rust_internal_print_type (struct type *type, const char *varstring,
810 struct ui_file *stream, int show, int level,
811 const struct type_print_options *flags,
812 bool for_rust_enum, print_offset_data *podata)
813{
814 QUIT;
815 if (show <= 0
816 && TYPE_NAME (type) != NULL)
817 {
818 /* Rust calls the unit type "void" in its debuginfo,
819 but we don't want to print it as that. */
820 if (TYPE_CODE (type) == TYPE_CODE_VOID)
821 fputs_filtered ("()", stream);
822 else
823 fputs_filtered (TYPE_NAME (type), stream);
824 return;
825 }
826
827 type = check_typedef (type);
828 switch (TYPE_CODE (type))
829 {
830 case TYPE_CODE_VOID:
831 /* If we have an enum, we've already printed the type's
832 unqualified name, and there is nothing else to print
833 here. */
834 if (!for_rust_enum)
835 fputs_filtered ("()", stream);
836 break;
837
838 case TYPE_CODE_FUNC:
839 /* Delegate varargs to the C printer. */
840 if (TYPE_VARARGS (type))
841 goto c_printer;
842
843 fputs_filtered ("fn ", stream);
844 if (varstring != NULL)
845 fputs_filtered (varstring, stream);
846 fputs_filtered ("(", stream);
847 for (int i = 0; i < TYPE_NFIELDS (type); ++i)
848 {
849 QUIT;
850 if (i > 0)
851 fputs_filtered (", ", stream);
852 rust_internal_print_type (TYPE_FIELD_TYPE (type, i), "", stream,
853 -1, 0, flags, false, podata);
854 }
855 fputs_filtered (")", stream);
856 /* If it returns unit, we can omit the return type. */
857 if (TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_VOID)
858 {
859 fputs_filtered (" -> ", stream);
860 rust_internal_print_type (TYPE_TARGET_TYPE (type), "", stream,
861 -1, 0, flags, false, podata);
862 }
863 break;
864
865 case TYPE_CODE_ARRAY:
866 {
867 LONGEST low_bound, high_bound;
868
869 fputs_filtered ("[", stream);
870 rust_internal_print_type (TYPE_TARGET_TYPE (type), NULL,
871 stream, show - 1, level, flags, false,
872 podata);
873
874 if (TYPE_HIGH_BOUND_KIND (TYPE_INDEX_TYPE (type)) == PROP_LOCEXPR
875 || TYPE_HIGH_BOUND_KIND (TYPE_INDEX_TYPE (type)) == PROP_LOCLIST)
876 fprintf_filtered (stream, "; variable length");
877 else if (get_array_bounds (type, &low_bound, &high_bound))
878 fprintf_filtered (stream, "; %s",
879 plongest (high_bound - low_bound + 1));
880 fputs_filtered ("]", stream);
881 }
882 break;
883
884 case TYPE_CODE_UNION:
885 case TYPE_CODE_STRUCT:
886 rust_print_struct_def (type, varstring, stream, show, level, flags,
887 for_rust_enum, podata);
888 break;
889
890 case TYPE_CODE_ENUM:
891 {
892 int len = 0;
893
894 fputs_filtered ("enum ", stream);
895 if (TYPE_NAME (type) != NULL)
896 {
897 fputs_filtered (TYPE_NAME (type), stream);
898 fputs_filtered (" ", stream);
899 len = strlen (TYPE_NAME (type));
900 }
901 fputs_filtered ("{\n", stream);
902
903 for (int i = 0; i < TYPE_NFIELDS (type); ++i)
904 {
905 const char *name = TYPE_FIELD_NAME (type, i);
906
907 QUIT;
908
909 if (len > 0
910 && strncmp (name, TYPE_NAME (type), len) == 0
911 && name[len] == ':'
912 && name[len + 1] == ':')
913 name += len + 2;
914 fprintfi_filtered (level + 2, stream, "%s,\n", name);
915 }
916
917 fputs_filtered ("}", stream);
918 }
919 break;
920
921 case TYPE_CODE_PTR:
922 {
923 if (TYPE_NAME (type) != nullptr)
924 fputs_filtered (TYPE_NAME (type), stream);
925 else
926 {
927 /* We currently can't distinguish between pointers and
928 references. */
929 fputs_filtered ("*mut ", stream);
930 type_print (TYPE_TARGET_TYPE (type), "", stream, 0);
931 }
932 }
933 break;
934
935 default:
936 c_printer:
937 c_print_type (type, varstring, stream, show, level, flags);
938 }
939}
940
941static void
942rust_print_type (struct type *type, const char *varstring,
943 struct ui_file *stream, int show, int level,
944 const struct type_print_options *flags)
945{
946 print_offset_data podata;
947 rust_internal_print_type (type, varstring, stream, show, level,
948 flags, false, &podata);
949}
950
951\f
952
953/* Like arch_composite_type, but uses TYPE to decide how to allocate
954 -- either on an obstack or on a gdbarch. */
955
956static struct type *
957rust_composite_type (struct type *original,
958 const char *name,
959 const char *field1, struct type *type1,
960 const char *field2, struct type *type2)
961{
962 struct type *result = alloc_type_copy (original);
963 int i, nfields, bitpos;
964
965 nfields = 0;
966 if (field1 != NULL)
967 ++nfields;
968 if (field2 != NULL)
969 ++nfields;
970
971 TYPE_CODE (result) = TYPE_CODE_STRUCT;
972 TYPE_NAME (result) = name;
973
974 TYPE_NFIELDS (result) = nfields;
975 TYPE_FIELDS (result)
976 = (struct field *) TYPE_ZALLOC (result, nfields * sizeof (struct field));
977
978 i = 0;
979 bitpos = 0;
980 if (field1 != NULL)
981 {
982 struct field *field = &TYPE_FIELD (result, i);
983
984 SET_FIELD_BITPOS (*field, bitpos);
985 bitpos += TYPE_LENGTH (type1) * TARGET_CHAR_BIT;
986
987 FIELD_NAME (*field) = field1;
988 FIELD_TYPE (*field) = type1;
989 ++i;
990 }
991 if (field2 != NULL)
992 {
993 struct field *field = &TYPE_FIELD (result, i);
994 unsigned align = type_align (type2);
995
996 if (align != 0)
997 {
998 int delta;
999
1000 align *= TARGET_CHAR_BIT;
1001 delta = bitpos % align;
1002 if (delta != 0)
1003 bitpos += align - delta;
1004 }
1005 SET_FIELD_BITPOS (*field, bitpos);
1006
1007 FIELD_NAME (*field) = field2;
1008 FIELD_TYPE (*field) = type2;
1009 ++i;
1010 }
1011
1012 if (i > 0)
1013 TYPE_LENGTH (result)
1014 = (TYPE_FIELD_BITPOS (result, i - 1) / TARGET_CHAR_BIT +
1015 TYPE_LENGTH (TYPE_FIELD_TYPE (result, i - 1)));
1016 return result;
1017}
1018
1019/* See rust-lang.h. */
1020
1021struct type *
1022rust_slice_type (const char *name, struct type *elt_type,
1023 struct type *usize_type)
1024{
1025 struct type *type;
1026
1027 elt_type = lookup_pointer_type (elt_type);
1028 type = rust_composite_type (elt_type, name,
1029 "data_ptr", elt_type,
1030 "length", usize_type);
1031
1032 return type;
1033}
1034
1035enum rust_primitive_types
1036{
1037 rust_primitive_bool,
1038 rust_primitive_char,
1039 rust_primitive_i8,
1040 rust_primitive_u8,
1041 rust_primitive_i16,
1042 rust_primitive_u16,
1043 rust_primitive_i32,
1044 rust_primitive_u32,
1045 rust_primitive_i64,
1046 rust_primitive_u64,
1047 rust_primitive_isize,
1048 rust_primitive_usize,
1049 rust_primitive_f32,
1050 rust_primitive_f64,
1051 rust_primitive_unit,
1052 rust_primitive_str,
1053 nr_rust_primitive_types
1054};
1055
1056/* la_language_arch_info implementation for Rust. */
1057
1058static void
1059rust_language_arch_info (struct gdbarch *gdbarch,
1060 struct language_arch_info *lai)
1061{
1062 const struct builtin_type *builtin = builtin_type (gdbarch);
1063 struct type *tem;
1064 struct type **types;
1065 unsigned int length;
1066
1067 types = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_rust_primitive_types + 1,
1068 struct type *);
1069
1070 types[rust_primitive_bool] = arch_boolean_type (gdbarch, 8, 1, "bool");
1071 types[rust_primitive_char] = arch_character_type (gdbarch, 32, 1, "char");
1072 types[rust_primitive_i8] = arch_integer_type (gdbarch, 8, 0, "i8");
1073 types[rust_primitive_u8] = arch_integer_type (gdbarch, 8, 1, "u8");
1074 types[rust_primitive_i16] = arch_integer_type (gdbarch, 16, 0, "i16");
1075 types[rust_primitive_u16] = arch_integer_type (gdbarch, 16, 1, "u16");
1076 types[rust_primitive_i32] = arch_integer_type (gdbarch, 32, 0, "i32");
1077 types[rust_primitive_u32] = arch_integer_type (gdbarch, 32, 1, "u32");
1078 types[rust_primitive_i64] = arch_integer_type (gdbarch, 64, 0, "i64");
1079 types[rust_primitive_u64] = arch_integer_type (gdbarch, 64, 1, "u64");
1080
1081 length = 8 * TYPE_LENGTH (builtin->builtin_data_ptr);
1082 types[rust_primitive_isize] = arch_integer_type (gdbarch, length, 0, "isize");
1083 types[rust_primitive_usize] = arch_integer_type (gdbarch, length, 1, "usize");
1084
1085 types[rust_primitive_f32] = arch_float_type (gdbarch, 32, "f32",
1086 floatformats_ieee_single);
1087 types[rust_primitive_f64] = arch_float_type (gdbarch, 64, "f64",
1088 floatformats_ieee_double);
1089
1090 types[rust_primitive_unit] = arch_integer_type (gdbarch, 0, 1, "()");
1091
1092 tem = make_cv_type (1, 0, types[rust_primitive_u8], NULL);
1093 types[rust_primitive_str] = rust_slice_type ("&str", tem,
1094 types[rust_primitive_usize]);
1095
1096 lai->primitive_type_vector = types;
1097 lai->bool_type_default = types[rust_primitive_bool];
1098 lai->string_char_type = types[rust_primitive_u8];
1099}
1100
1101\f
1102
1103/* A helper for rust_evaluate_subexp that handles OP_FUNCALL. */
1104
1105static struct value *
1106rust_evaluate_funcall (struct expression *exp, int *pos, enum noside noside)
1107{
1108 int i;
1109 int num_args = exp->elts[*pos + 1].longconst;
1110 const char *method;
1111 struct value *function, *result, *arg0;
1112 struct type *type, *fn_type;
1113 const struct block *block;
1114 struct block_symbol sym;
1115
1116 /* For an ordinary function call we can simply defer to the
1117 generic implementation. */
1118 if (exp->elts[*pos + 3].opcode != STRUCTOP_STRUCT)
1119 return evaluate_subexp_standard (NULL, exp, pos, noside);
1120
1121 /* Skip over the OP_FUNCALL and the STRUCTOP_STRUCT. */
1122 *pos += 4;
1123 method = &exp->elts[*pos + 1].string;
1124 *pos += 3 + BYTES_TO_EXP_ELEM (exp->elts[*pos].longconst + 1);
1125
1126 /* Evaluate the argument to STRUCTOP_STRUCT, then find its
1127 type in order to look up the method. */
1128 arg0 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1129
1130 if (noside == EVAL_SKIP)
1131 {
1132 for (i = 0; i < num_args; ++i)
1133 evaluate_subexp (NULL_TYPE, exp, pos, noside);
1134 return arg0;
1135 }
1136
1137 std::vector<struct value *> args (num_args + 1);
1138 args[0] = arg0;
1139
1140 /* We don't yet implement real Deref semantics. */
1141 while (TYPE_CODE (value_type (args[0])) == TYPE_CODE_PTR)
1142 args[0] = value_ind (args[0]);
1143
1144 type = value_type (args[0]);
1145 if ((TYPE_CODE (type) != TYPE_CODE_STRUCT
1146 && TYPE_CODE (type) != TYPE_CODE_UNION
1147 && TYPE_CODE (type) != TYPE_CODE_ENUM)
1148 || rust_tuple_type_p (type))
1149 error (_("Method calls only supported on struct or enum types"));
1150 if (TYPE_NAME (type) == NULL)
1151 error (_("Method call on nameless type"));
1152
1153 std::string name = std::string (TYPE_NAME (type)) + "::" + method;
1154
1155 block = get_selected_block (0);
1156 sym = lookup_symbol (name.c_str (), block, VAR_DOMAIN, NULL);
1157 if (sym.symbol == NULL)
1158 error (_("Could not find function named '%s'"), name.c_str ());
1159
1160 fn_type = SYMBOL_TYPE (sym.symbol);
1161 if (TYPE_NFIELDS (fn_type) == 0)
1162 error (_("Function '%s' takes no arguments"), name.c_str ());
1163
1164 if (TYPE_CODE (TYPE_FIELD_TYPE (fn_type, 0)) == TYPE_CODE_PTR)
1165 args[0] = value_addr (args[0]);
1166
1167 function = address_of_variable (sym.symbol, block);
1168
1169 for (i = 0; i < num_args; ++i)
1170 args[i + 1] = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1171
1172 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1173 result = value_zero (TYPE_TARGET_TYPE (fn_type), not_lval);
1174 else
1175 result = call_function_by_hand (function, NULL, args);
1176 return result;
1177}
1178
1179/* A helper for rust_evaluate_subexp that handles OP_RANGE. */
1180
1181static struct value *
1182rust_range (struct expression *exp, int *pos, enum noside noside)
1183{
1184 enum range_type kind;
1185 struct value *low = NULL, *high = NULL;
1186 struct value *addrval, *result;
1187 CORE_ADDR addr;
1188 struct type *range_type;
1189 struct type *index_type;
1190 struct type *temp_type;
1191 const char *name;
1192
1193 kind = (enum range_type) longest_to_int (exp->elts[*pos + 1].longconst);
1194 *pos += 3;
1195
1196 if (kind == HIGH_BOUND_DEFAULT || kind == NONE_BOUND_DEFAULT
1197 || kind == NONE_BOUND_DEFAULT_EXCLUSIVE)
1198 low = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1199 if (kind == LOW_BOUND_DEFAULT || kind == LOW_BOUND_DEFAULT_EXCLUSIVE
1200 || kind == NONE_BOUND_DEFAULT || kind == NONE_BOUND_DEFAULT_EXCLUSIVE)
1201 high = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1202 bool inclusive = (kind == NONE_BOUND_DEFAULT || kind == LOW_BOUND_DEFAULT);
1203
1204 if (noside == EVAL_SKIP)
1205 return value_from_longest (builtin_type (exp->gdbarch)->builtin_int, 1);
1206
1207 if (low == NULL)
1208 {
1209 if (high == NULL)
1210 {
1211 index_type = NULL;
1212 name = "std::ops::RangeFull";
1213 }
1214 else
1215 {
1216 index_type = value_type (high);
1217 name = (inclusive
1218 ? "std::ops::RangeToInclusive" : "std::ops::RangeTo");
1219 }
1220 }
1221 else
1222 {
1223 if (high == NULL)
1224 {
1225 index_type = value_type (low);
1226 name = "std::ops::RangeFrom";
1227 }
1228 else
1229 {
1230 if (!types_equal (value_type (low), value_type (high)))
1231 error (_("Range expression with different types"));
1232 index_type = value_type (low);
1233 name = inclusive ? "std::ops::RangeInclusive" : "std::ops::Range";
1234 }
1235 }
1236
1237 /* If we don't have an index type, just allocate this on the
1238 arch. Here any type will do. */
1239 temp_type = (index_type == NULL
1240 ? language_bool_type (exp->language_defn, exp->gdbarch)
1241 : index_type);
1242 /* It would be nicer to cache the range type. */
1243 range_type = rust_composite_type (temp_type, name,
1244 low == NULL ? NULL : "start", index_type,
1245 high == NULL ? NULL : "end", index_type);
1246
1247 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1248 return value_zero (range_type, lval_memory);
1249
1250 addrval = value_allocate_space_in_inferior (TYPE_LENGTH (range_type));
1251 addr = value_as_long (addrval);
1252 result = value_at_lazy (range_type, addr);
1253
1254 if (low != NULL)
1255 {
1256 struct value *start = value_struct_elt (&result, NULL, "start", NULL,
1257 "range");
1258
1259 value_assign (start, low);
1260 }
1261
1262 if (high != NULL)
1263 {
1264 struct value *end = value_struct_elt (&result, NULL, "end", NULL,
1265 "range");
1266
1267 value_assign (end, high);
1268 }
1269
1270 result = value_at_lazy (range_type, addr);
1271 return result;
1272}
1273
1274/* A helper function to compute the range and kind given a range
1275 value. TYPE is the type of the range value. RANGE is the range
1276 value. LOW, HIGH, and KIND are out parameters. The LOW and HIGH
1277 parameters might be filled in, or might not be, depending on the
1278 kind of range this is. KIND will always be set to the appropriate
1279 value describing the kind of range, and this can be used to
1280 determine whether LOW or HIGH are valid. */
1281
1282static void
1283rust_compute_range (struct type *type, struct value *range,
1284 LONGEST *low, LONGEST *high,
1285 enum range_type *kind)
1286{
1287 int i;
1288
1289 *low = 0;
1290 *high = 0;
1291 *kind = BOTH_BOUND_DEFAULT;
1292
1293 if (TYPE_NFIELDS (type) == 0)
1294 return;
1295
1296 i = 0;
1297 if (strcmp (TYPE_FIELD_NAME (type, 0), "start") == 0)
1298 {
1299 *kind = HIGH_BOUND_DEFAULT;
1300 *low = value_as_long (value_field (range, 0));
1301 ++i;
1302 }
1303 if (TYPE_NFIELDS (type) > i
1304 && strcmp (TYPE_FIELD_NAME (type, i), "end") == 0)
1305 {
1306 *kind = (*kind == BOTH_BOUND_DEFAULT
1307 ? LOW_BOUND_DEFAULT : NONE_BOUND_DEFAULT);
1308 *high = value_as_long (value_field (range, i));
1309
1310 if (rust_inclusive_range_type_p (type))
1311 ++*high;
1312 }
1313}
1314
1315/* A helper for rust_evaluate_subexp that handles BINOP_SUBSCRIPT. */
1316
1317static struct value *
1318rust_subscript (struct expression *exp, int *pos, enum noside noside,
1319 int for_addr)
1320{
1321 struct value *lhs, *rhs, *result;
1322 struct type *rhstype;
1323 LONGEST low, high_bound;
1324 /* Initialized to appease the compiler. */
1325 enum range_type kind = BOTH_BOUND_DEFAULT;
1326 LONGEST high = 0;
1327 int want_slice = 0;
1328
1329 ++*pos;
1330 lhs = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1331 rhs = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1332
1333 if (noside == EVAL_SKIP)
1334 return lhs;
1335
1336 rhstype = check_typedef (value_type (rhs));
1337 if (rust_range_type_p (rhstype))
1338 {
1339 if (!for_addr)
1340 error (_("Can't take slice of array without '&'"));
1341 rust_compute_range (rhstype, rhs, &low, &high, &kind);
1342 want_slice = 1;
1343 }
1344 else
1345 low = value_as_long (rhs);
1346
1347 struct type *type = check_typedef (value_type (lhs));
1348 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1349 {
1350 struct type *base_type = nullptr;
1351 if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
1352 base_type = TYPE_TARGET_TYPE (type);
1353 else if (rust_slice_type_p (type))
1354 {
1355 for (int i = 0; i < TYPE_NFIELDS (type); ++i)
1356 {
1357 if (strcmp (TYPE_FIELD_NAME (type, i), "data_ptr") == 0)
1358 {
1359 base_type = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type, i));
1360 break;
1361 }
1362 }
1363 if (base_type == nullptr)
1364 error (_("Could not find 'data_ptr' in slice type"));
1365 }
1366 else if (TYPE_CODE (type) == TYPE_CODE_PTR)
1367 base_type = TYPE_TARGET_TYPE (type);
1368 else
1369 error (_("Cannot subscript non-array type"));
1370
1371 struct type *new_type;
1372 if (want_slice)
1373 {
1374 if (rust_slice_type_p (type))
1375 new_type = type;
1376 else
1377 {
1378 struct type *usize
1379 = language_lookup_primitive_type (exp->language_defn,
1380 exp->gdbarch,
1381 "usize");
1382 new_type = rust_slice_type ("&[*gdb*]", base_type, usize);
1383 }
1384 }
1385 else
1386 new_type = base_type;
1387
1388 return value_zero (new_type, VALUE_LVAL (lhs));
1389 }
1390 else
1391 {
1392 LONGEST low_bound;
1393 struct value *base;
1394
1395 if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
1396 {
1397 base = lhs;
1398 if (!get_array_bounds (type, &low_bound, &high_bound))
1399 error (_("Can't compute array bounds"));
1400 if (low_bound != 0)
1401 error (_("Found array with non-zero lower bound"));
1402 ++high_bound;
1403 }
1404 else if (rust_slice_type_p (type))
1405 {
1406 struct value *len;
1407
1408 base = value_struct_elt (&lhs, NULL, "data_ptr", NULL, "slice");
1409 len = value_struct_elt (&lhs, NULL, "length", NULL, "slice");
1410 low_bound = 0;
1411 high_bound = value_as_long (len);
1412 }
1413 else if (TYPE_CODE (type) == TYPE_CODE_PTR)
1414 {
1415 base = lhs;
1416 low_bound = 0;
1417 high_bound = LONGEST_MAX;
1418 }
1419 else
1420 error (_("Cannot subscript non-array type"));
1421
1422 if (want_slice
1423 && (kind == BOTH_BOUND_DEFAULT || kind == LOW_BOUND_DEFAULT))
1424 low = low_bound;
1425 if (low < 0)
1426 error (_("Index less than zero"));
1427 if (low > high_bound)
1428 error (_("Index greater than length"));
1429
1430 result = value_subscript (base, low);
1431 }
1432
1433 if (for_addr)
1434 {
1435 if (want_slice)
1436 {
1437 struct type *usize, *slice;
1438 CORE_ADDR addr;
1439 struct value *addrval, *tem;
1440
1441 if (kind == BOTH_BOUND_DEFAULT || kind == HIGH_BOUND_DEFAULT)
1442 high = high_bound;
1443 if (high < 0)
1444 error (_("High index less than zero"));
1445 if (low > high)
1446 error (_("Low index greater than high index"));
1447 if (high > high_bound)
1448 error (_("High index greater than length"));
1449
1450 usize = language_lookup_primitive_type (exp->language_defn,
1451 exp->gdbarch,
1452 "usize");
1453 const char *new_name = ((type != nullptr
1454 && rust_slice_type_p (type))
1455 ? TYPE_NAME (type) : "&[*gdb*]");
1456
1457 slice = rust_slice_type (new_name, value_type (result), usize);
1458
1459 addrval = value_allocate_space_in_inferior (TYPE_LENGTH (slice));
1460 addr = value_as_long (addrval);
1461 tem = value_at_lazy (slice, addr);
1462
1463 value_assign (value_field (tem, 0), value_addr (result));
1464 value_assign (value_field (tem, 1),
1465 value_from_longest (usize, high - low));
1466
1467 result = value_at_lazy (slice, addr);
1468 }
1469 else
1470 result = value_addr (result);
1471 }
1472
1473 return result;
1474}
1475
1476/* evaluate_exp implementation for Rust. */
1477
1478static struct value *
1479rust_evaluate_subexp (struct type *expect_type, struct expression *exp,
1480 int *pos, enum noside noside)
1481{
1482 struct value *result;
1483
1484 switch (exp->elts[*pos].opcode)
1485 {
1486 case UNOP_IND:
1487 {
1488 if (noside != EVAL_NORMAL)
1489 result = evaluate_subexp_standard (expect_type, exp, pos, noside);
1490 else
1491 {
1492 ++*pos;
1493 struct value *value = evaluate_subexp (expect_type, exp, pos,
1494 noside);
1495
1496 struct value *trait_ptr = rust_get_trait_object_pointer (value);
1497 if (trait_ptr != NULL)
1498 value = trait_ptr;
1499
1500 result = value_ind (value);
1501 }
1502 }
1503 break;
1504
1505 case UNOP_COMPLEMENT:
1506 {
1507 struct value *value;
1508
1509 ++*pos;
1510 value = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1511 if (noside == EVAL_SKIP)
1512 {
1513 /* Preserving the type is enough. */
1514 return value;
1515 }
1516 if (TYPE_CODE (value_type (value)) == TYPE_CODE_BOOL)
1517 result = value_from_longest (value_type (value),
1518 value_logical_not (value));
1519 else
1520 result = value_complement (value);
1521 }
1522 break;
1523
1524 case BINOP_SUBSCRIPT:
1525 result = rust_subscript (exp, pos, noside, 0);
1526 break;
1527
1528 case OP_FUNCALL:
1529 result = rust_evaluate_funcall (exp, pos, noside);
1530 break;
1531
1532 case OP_AGGREGATE:
1533 {
1534 int pc = (*pos)++;
1535 struct type *type = exp->elts[pc + 1].type;
1536 int arglen = longest_to_int (exp->elts[pc + 2].longconst);
1537 int i;
1538 CORE_ADDR addr = 0;
1539 struct value *addrval = NULL;
1540
1541 *pos += 3;
1542
1543 if (noside == EVAL_NORMAL)
1544 {
1545 addrval = value_allocate_space_in_inferior (TYPE_LENGTH (type));
1546 addr = value_as_long (addrval);
1547 result = value_at_lazy (type, addr);
1548 }
1549
1550 if (arglen > 0 && exp->elts[*pos].opcode == OP_OTHERS)
1551 {
1552 struct value *init;
1553
1554 ++*pos;
1555 init = rust_evaluate_subexp (NULL, exp, pos, noside);
1556 if (noside == EVAL_NORMAL)
1557 {
1558 /* This isn't quite right but will do for the time
1559 being, seeing that we can't implement the Copy
1560 trait anyway. */
1561 value_assign (result, init);
1562 }
1563
1564 --arglen;
1565 }
1566
1567 gdb_assert (arglen % 2 == 0);
1568 for (i = 0; i < arglen; i += 2)
1569 {
1570 int len;
1571 const char *fieldname;
1572 struct value *value, *field;
1573
1574 gdb_assert (exp->elts[*pos].opcode == OP_NAME);
1575 ++*pos;
1576 len = longest_to_int (exp->elts[*pos].longconst);
1577 ++*pos;
1578 fieldname = &exp->elts[*pos].string;
1579 *pos += 2 + BYTES_TO_EXP_ELEM (len + 1);
1580
1581 value = rust_evaluate_subexp (NULL, exp, pos, noside);
1582 if (noside == EVAL_NORMAL)
1583 {
1584 field = value_struct_elt (&result, NULL, fieldname, NULL,
1585 "structure");
1586 value_assign (field, value);
1587 }
1588 }
1589
1590 if (noside == EVAL_SKIP)
1591 return value_from_longest (builtin_type (exp->gdbarch)->builtin_int,
1592 1);
1593 else if (noside == EVAL_AVOID_SIDE_EFFECTS)
1594 result = allocate_value (type);
1595 else
1596 result = value_at_lazy (type, addr);
1597 }
1598 break;
1599
1600 case OP_RUST_ARRAY:
1601 {
1602 (*pos)++;
1603 int copies;
1604 struct value *elt;
1605 struct value *ncopies;
1606
1607 elt = rust_evaluate_subexp (NULL, exp, pos, noside);
1608 ncopies = rust_evaluate_subexp (NULL, exp, pos, noside);
1609 copies = value_as_long (ncopies);
1610 if (copies < 0)
1611 error (_("Array with negative number of elements"));
1612
1613 if (noside == EVAL_NORMAL)
1614 {
1615 int i;
1616 std::vector<struct value *> eltvec (copies);
1617
1618 for (i = 0; i < copies; ++i)
1619 eltvec[i] = elt;
1620 result = value_array (0, copies - 1, eltvec.data ());
1621 }
1622 else
1623 {
1624 struct type *arraytype
1625 = lookup_array_range_type (value_type (elt), 0, copies - 1);
1626 result = allocate_value (arraytype);
1627 }
1628 }
1629 break;
1630
1631 case STRUCTOP_ANONYMOUS:
1632 {
1633 /* Anonymous field access, i.e. foo.1. */
1634 struct value *lhs;
1635 int pc, field_number, nfields;
1636 struct type *type;
1637
1638 pc = (*pos)++;
1639 field_number = longest_to_int (exp->elts[pc + 1].longconst);
1640 (*pos) += 2;
1641 lhs = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1642
1643 type = value_type (lhs);
1644
1645 if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
1646 {
1647 struct type *outer_type = NULL;
1648
1649 if (rust_enum_p (type))
1650 {
1651 if (rust_empty_enum_p (type))
1652 error (_("Cannot access field %d of empty enum %s"),
1653 field_number, TYPE_NAME (type));
1654
1655 const gdb_byte *valaddr = value_contents (lhs);
1656 struct field *variant_field = rust_enum_variant (type, valaddr);
1657
1658 struct value *union_value = value_primitive_field (lhs, 0, 0,
1659 type);
1660
1661 int fieldno = (variant_field
1662 - &TYPE_FIELD (value_type (union_value), 0));
1663 lhs = value_primitive_field (union_value, 0, fieldno,
1664 value_type (union_value));
1665 outer_type = type;
1666 type = value_type (lhs);
1667 }
1668
1669 /* Tuples and tuple structs */
1670 nfields = TYPE_NFIELDS (type);
1671
1672 if (field_number >= nfields || field_number < 0)
1673 {
1674 if (outer_type != NULL)
1675 error(_("Cannot access field %d of variant %s::%s, "
1676 "there are only %d fields"),
1677 field_number, TYPE_NAME (outer_type),
1678 rust_last_path_segment (TYPE_NAME (type)),
1679 nfields);
1680 else
1681 error(_("Cannot access field %d of %s, "
1682 "there are only %d fields"),
1683 field_number, TYPE_NAME (type), nfields);
1684 }
1685
1686 /* Tuples are tuple structs too. */
1687 if (!rust_tuple_struct_type_p (type))
1688 {
1689 if (outer_type != NULL)
1690 error(_("Variant %s::%s is not a tuple variant"),
1691 TYPE_NAME (outer_type),
1692 rust_last_path_segment (TYPE_NAME (type)));
1693 else
1694 error(_("Attempting to access anonymous field %d "
1695 "of %s, which is not a tuple, tuple struct, or "
1696 "tuple-like variant"),
1697 field_number, TYPE_NAME (type));
1698 }
1699
1700 result = value_primitive_field (lhs, 0, field_number, type);
1701 }
1702 else
1703 error(_("Anonymous field access is only allowed on tuples, \
1704tuple structs, and tuple-like enum variants"));
1705 }
1706 break;
1707
1708 case STRUCTOP_STRUCT:
1709 {
1710 struct value *lhs;
1711 struct type *type;
1712 int tem, pc;
1713
1714 pc = (*pos)++;
1715 tem = longest_to_int (exp->elts[pc + 1].longconst);
1716 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
1717 lhs = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1718
1719 const char *field_name = &exp->elts[pc + 2].string;
1720 type = value_type (lhs);
1721 if (TYPE_CODE (type) == TYPE_CODE_STRUCT && rust_enum_p (type))
1722 {
1723 if (rust_empty_enum_p (type))
1724 error (_("Cannot access field %s of empty enum %s"),
1725 field_name, TYPE_NAME (type));
1726
1727 const gdb_byte *valaddr = value_contents (lhs);
1728 struct field *variant_field = rust_enum_variant (type, valaddr);
1729
1730 struct value *union_value = value_primitive_field (lhs, 0, 0,
1731 type);
1732
1733 int fieldno = (variant_field
1734 - &TYPE_FIELD (value_type (union_value), 0));
1735 lhs = value_primitive_field (union_value, 0, fieldno,
1736 value_type (union_value));
1737
1738 struct type *outer_type = type;
1739 type = value_type (lhs);
1740 if (rust_tuple_type_p (type) || rust_tuple_struct_type_p (type))
1741 error (_("Attempting to access named field %s of tuple "
1742 "variant %s::%s, which has only anonymous fields"),
1743 field_name, TYPE_NAME (outer_type),
1744 rust_last_path_segment (TYPE_NAME (type)));
1745
1746 TRY
1747 {
1748 result = value_struct_elt (&lhs, NULL, field_name,
1749 NULL, "structure");
1750 }
1751 CATCH (except, RETURN_MASK_ERROR)
1752 {
1753 error (_("Could not find field %s of struct variant %s::%s"),
1754 field_name, TYPE_NAME (outer_type),
1755 rust_last_path_segment (TYPE_NAME (type)));
1756 }
1757 END_CATCH
1758 }
1759 else
1760 result = value_struct_elt (&lhs, NULL, field_name, NULL, "structure");
1761 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1762 result = value_zero (value_type (result), VALUE_LVAL (result));
1763 }
1764 break;
1765
1766 case OP_RANGE:
1767 result = rust_range (exp, pos, noside);
1768 break;
1769
1770 case UNOP_ADDR:
1771 /* We might have &array[range], in which case we need to make a
1772 slice. */
1773 if (exp->elts[*pos + 1].opcode == BINOP_SUBSCRIPT)
1774 {
1775 ++*pos;
1776 result = rust_subscript (exp, pos, noside, 1);
1777 break;
1778 }
1779 /* Fall through. */
1780 default:
1781 result = evaluate_subexp_standard (expect_type, exp, pos, noside);
1782 break;
1783 }
1784
1785 return result;
1786}
1787
1788/* operator_length implementation for Rust. */
1789
1790static void
1791rust_operator_length (const struct expression *exp, int pc, int *oplenp,
1792 int *argsp)
1793{
1794 int oplen = 1;
1795 int args = 0;
1796
1797 switch (exp->elts[pc - 1].opcode)
1798 {
1799 case OP_AGGREGATE:
1800 /* We handle aggregate as a type and argument count. The first
1801 argument might be OP_OTHERS. After that the arguments
1802 alternate: first an OP_NAME, then an expression. */
1803 oplen = 4;
1804 args = longest_to_int (exp->elts[pc - 2].longconst);
1805 break;
1806
1807 case OP_OTHERS:
1808 oplen = 1;
1809 args = 1;
1810 break;
1811
1812 case STRUCTOP_ANONYMOUS:
1813 oplen = 3;
1814 args = 1;
1815 break;
1816
1817 case OP_RUST_ARRAY:
1818 oplen = 1;
1819 args = 2;
1820 break;
1821
1822 default:
1823 operator_length_standard (exp, pc, oplenp, argsp);
1824 return;
1825 }
1826
1827 *oplenp = oplen;
1828 *argsp = args;
1829}
1830
1831/* op_name implementation for Rust. */
1832
1833static const char *
1834rust_op_name (enum exp_opcode opcode)
1835{
1836 switch (opcode)
1837 {
1838 case OP_AGGREGATE:
1839 return "OP_AGGREGATE";
1840 case OP_OTHERS:
1841 return "OP_OTHERS";
1842 default:
1843 return op_name_standard (opcode);
1844 }
1845}
1846
1847/* dump_subexp_body implementation for Rust. */
1848
1849static int
1850rust_dump_subexp_body (struct expression *exp, struct ui_file *stream,
1851 int elt)
1852{
1853 switch (exp->elts[elt].opcode)
1854 {
1855 case OP_AGGREGATE:
1856 {
1857 int length = longest_to_int (exp->elts[elt + 2].longconst);
1858 int i;
1859
1860 fprintf_filtered (stream, "Type @");
1861 gdb_print_host_address (exp->elts[elt + 1].type, stream);
1862 fprintf_filtered (stream, " (");
1863 type_print (exp->elts[elt + 1].type, NULL, stream, 0);
1864 fprintf_filtered (stream, "), length %d", length);
1865
1866 elt += 4;
1867 for (i = 0; i < length; ++i)
1868 elt = dump_subexp (exp, stream, elt);
1869 }
1870 break;
1871
1872 case OP_STRING:
1873 case OP_NAME:
1874 {
1875 LONGEST len = exp->elts[elt + 1].longconst;
1876
1877 fprintf_filtered (stream, "%s: %s",
1878 (exp->elts[elt].opcode == OP_STRING
1879 ? "string" : "name"),
1880 &exp->elts[elt + 2].string);
1881 elt += 4 + BYTES_TO_EXP_ELEM (len + 1);
1882 }
1883 break;
1884
1885 case OP_OTHERS:
1886 elt = dump_subexp (exp, stream, elt + 1);
1887 break;
1888
1889 case STRUCTOP_ANONYMOUS:
1890 {
1891 int field_number;
1892
1893 field_number = longest_to_int (exp->elts[elt + 1].longconst);
1894
1895 fprintf_filtered (stream, "Field number: %d", field_number);
1896 elt = dump_subexp (exp, stream, elt + 3);
1897 }
1898 break;
1899
1900 case OP_RUST_ARRAY:
1901 ++elt;
1902 break;
1903
1904 default:
1905 elt = dump_subexp_body_standard (exp, stream, elt);
1906 break;
1907 }
1908
1909 return elt;
1910}
1911
1912/* print_subexp implementation for Rust. */
1913
1914static void
1915rust_print_subexp (struct expression *exp, int *pos, struct ui_file *stream,
1916 enum precedence prec)
1917{
1918 switch (exp->elts[*pos].opcode)
1919 {
1920 case OP_AGGREGATE:
1921 {
1922 int length = longest_to_int (exp->elts[*pos + 2].longconst);
1923 int i;
1924
1925 type_print (exp->elts[*pos + 1].type, "", stream, 0);
1926 fputs_filtered (" { ", stream);
1927
1928 *pos += 4;
1929 for (i = 0; i < length; ++i)
1930 {
1931 rust_print_subexp (exp, pos, stream, prec);
1932 fputs_filtered (", ", stream);
1933 }
1934 fputs_filtered (" }", stream);
1935 }
1936 break;
1937
1938 case OP_NAME:
1939 {
1940 LONGEST len = exp->elts[*pos + 1].longconst;
1941
1942 fputs_filtered (&exp->elts[*pos + 2].string, stream);
1943 *pos += 4 + BYTES_TO_EXP_ELEM (len + 1);
1944 }
1945 break;
1946
1947 case OP_OTHERS:
1948 {
1949 fputs_filtered ("<<others>> (", stream);
1950 ++*pos;
1951 rust_print_subexp (exp, pos, stream, prec);
1952 fputs_filtered (")", stream);
1953 }
1954 break;
1955
1956 case STRUCTOP_ANONYMOUS:
1957 {
1958 int tem = longest_to_int (exp->elts[*pos + 1].longconst);
1959
1960 (*pos) += 3;
1961 print_subexp (exp, pos, stream, PREC_SUFFIX);
1962 fprintf_filtered (stream, ".%d", tem);
1963 }
1964 break;
1965
1966 case OP_RUST_ARRAY:
1967 ++*pos;
1968 fprintf_filtered (stream, "[");
1969 rust_print_subexp (exp, pos, stream, prec);
1970 fprintf_filtered (stream, "; ");
1971 rust_print_subexp (exp, pos, stream, prec);
1972 fprintf_filtered (stream, "]");
1973 break;
1974
1975 default:
1976 print_subexp_standard (exp, pos, stream, prec);
1977 break;
1978 }
1979}
1980
1981/* operator_check implementation for Rust. */
1982
1983static int
1984rust_operator_check (struct expression *exp, int pos,
1985 int (*objfile_func) (struct objfile *objfile,
1986 void *data),
1987 void *data)
1988{
1989 switch (exp->elts[pos].opcode)
1990 {
1991 case OP_AGGREGATE:
1992 {
1993 struct type *type = exp->elts[pos + 1].type;
1994 struct objfile *objfile = TYPE_OBJFILE (type);
1995
1996 if (objfile != NULL && (*objfile_func) (objfile, data))
1997 return 1;
1998 }
1999 break;
2000
2001 case OP_OTHERS:
2002 case OP_NAME:
2003 case OP_RUST_ARRAY:
2004 break;
2005
2006 default:
2007 return operator_check_standard (exp, pos, objfile_func, data);
2008 }
2009
2010 return 0;
2011}
2012
2013\f
2014
2015/* Implementation of la_lookup_symbol_nonlocal for Rust. */
2016
2017static struct block_symbol
2018rust_lookup_symbol_nonlocal (const struct language_defn *langdef,
2019 const char *name,
2020 const struct block *block,
2021 const domain_enum domain)
2022{
2023 struct block_symbol result = {};
2024
2025 if (symbol_lookup_debug)
2026 {
2027 fprintf_unfiltered (gdb_stdlog,
2028 "rust_lookup_symbol_non_local"
2029 " (%s, %s (scope %s), %s)\n",
2030 name, host_address_to_string (block),
2031 block_scope (block), domain_name (domain));
2032 }
2033
2034 /* Look up bare names in the block's scope. */
2035 std::string scopedname;
2036 if (name[cp_find_first_component (name)] == '\0')
2037 {
2038 const char *scope = block_scope (block);
2039
2040 if (scope[0] != '\0')
2041 {
2042 scopedname = std::string (scope) + "::" + name;
2043 name = scopedname.c_str ();
2044 }
2045 else
2046 name = NULL;
2047 }
2048
2049 if (name != NULL)
2050 {
2051 result = lookup_symbol_in_static_block (name, block, domain);
2052 if (result.symbol == NULL)
2053 result = lookup_global_symbol (name, block, domain);
2054 }
2055 return result;
2056}
2057
2058\f
2059
2060/* la_sniff_from_mangled_name for Rust. */
2061
2062static int
2063rust_sniff_from_mangled_name (const char *mangled, char **demangled)
2064{
2065 *demangled = gdb_demangle (mangled, DMGL_PARAMS | DMGL_ANSI);
2066 return *demangled != NULL;
2067}
2068
2069\f
2070
2071/* la_watch_location_expression for Rust. */
2072
2073static gdb::unique_xmalloc_ptr<char>
2074rust_watch_location_expression (struct type *type, CORE_ADDR addr)
2075{
2076 type = check_typedef (TYPE_TARGET_TYPE (check_typedef (type)));
2077 std::string name = type_to_string (type);
2078 return gdb::unique_xmalloc_ptr<char>
2079 (xstrprintf ("*(%s as *mut %s)", core_addr_to_string (addr),
2080 name.c_str ()));
2081}
2082
2083\f
2084
2085static const struct exp_descriptor exp_descriptor_rust =
2086{
2087 rust_print_subexp,
2088 rust_operator_length,
2089 rust_operator_check,
2090 rust_op_name,
2091 rust_dump_subexp_body,
2092 rust_evaluate_subexp
2093};
2094
2095static const char *rust_extensions[] =
2096{
2097 ".rs", NULL
2098};
2099
2100extern const struct language_defn rust_language_defn =
2101{
2102 "rust",
2103 "Rust",
2104 language_rust,
2105 range_check_on,
2106 case_sensitive_on,
2107 array_row_major,
2108 macro_expansion_no,
2109 rust_extensions,
2110 &exp_descriptor_rust,
2111 rust_parse,
2112 null_post_parser,
2113 rust_printchar, /* Print a character constant */
2114 rust_printstr, /* Function to print string constant */
2115 rust_emitchar, /* Print a single char */
2116 rust_print_type, /* Print a type using appropriate syntax */
2117 rust_print_typedef, /* Print a typedef using appropriate syntax */
2118 rust_val_print, /* Print a value using appropriate syntax */
2119 c_value_print, /* Print a top-level value */
2120 default_read_var_value, /* la_read_var_value */
2121 NULL, /* Language specific skip_trampoline */
2122 NULL, /* name_of_this */
2123 false, /* la_store_sym_names_in_linkage_form_p */
2124 rust_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
2125 basic_lookup_transparent_type,/* lookup_transparent_type */
2126 gdb_demangle, /* Language specific symbol demangler */
2127 rust_sniff_from_mangled_name,
2128 NULL, /* Language specific
2129 class_name_from_physname */
2130 c_op_print_tab, /* expression operators for printing */
2131 1, /* c-style arrays */
2132 0, /* String lower bound */
2133 default_word_break_characters,
2134 default_collect_symbol_completion_matches,
2135 rust_language_arch_info,
2136 default_print_array_index,
2137 default_pass_by_reference,
2138 c_get_string,
2139 rust_watch_location_expression,
2140 NULL, /* la_get_symbol_name_matcher */
2141 iterate_over_symbols,
2142 default_search_name_hash,
2143 &default_varobj_ops,
2144 NULL,
2145 NULL,
2146 LANG_MAGIC
2147};
GDB Binutils - Deliverables
This page took 0.038598 seconds and 4 git commands to generate.