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