projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Make exceptions use std::string and be self-managing
[deliverable/binutils-gdb.git] / gdb / rust-lang.c
CommitLineData
c44af4eb
TT		 1/* Rust language support routines for GDB, the GNU debugger.
2
42a4f53d 3 Copyright (C) 2016-2019 Free Software Foundation, Inc.
c44af4eb
TT		 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"
8b302db8 28#include "demangle.h"
c44af4eb
TT		 29#include "gdbarch.h"
30#include "infcall.h"
31#include "objfiles.h"
71a3c369 32#include "psymtab.h"
c44af4eb 33#include "rust-lang.h"
a33ccfc7 34#include "typeprint.h"
c44af4eb
TT		 35#include "valprint.h"
36#include "varobj.h"
a33ccfc7 37#include <algorithm>
ab8b80a8
TT		 38#include <string>
39#include <vector>
c44af4eb 40
c9317f21 41/* See rust-lang.h. */
c44af4eb 42
c9317f21
TT		 43const char *
44rust_last_path_segment (const char *path)
c44af4eb
TT		 45{
46 const char *result = strrchr (path, ':');
47
48 if (result == NULL)
c9317f21 49 return path;
c44af4eb
TT		 50 return result + 1;
51}
52
03c85b11 53/* See rust-lang.h. */
c44af4eb 54
03c85b11 55std::string
c44af4eb
TT		 56rust_crate_for_block (const struct block *block)
57{
58 const char *scope = block_scope (block);
59
60 if (scope[0] == '\0')
03c85b11 61 return std::string ();
c44af4eb 62
03c85b11 63 return std::string (scope, cp_find_first_component (scope));
c44af4eb
TT		 64}
65
c9317f21
TT		 66/* Return true if TYPE, which must be a struct type, represents a Rust
67 enum. */
c44af4eb 68
b96645f1 69static bool
c9317f21 70rust_enum_p (const struct type *type)
b96645f1 71{
c9317f21
TT		 72 return (TYPE_CODE (type) == TYPE_CODE_STRUCT
73 && TYPE_NFIELDS (type) == 1
74 && TYPE_FLAG_DISCRIMINATED_UNION (TYPE_FIELD_TYPE (type, 0)));
b96645f1
MG		 75}
76
098b2108
TT		 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
c9317f21 90/* Given an enum type and contents, find which variant is active. */
c44af4eb 91
098b2108 92static struct field *
c9317f21 93rust_enum_variant (struct type *type, const gdb_byte *contents)
c44af4eb 94{
c9317f21
TT		 95 /* In Rust the enum always fills the containing structure. */
96 gdb_assert (TYPE_FIELD_BITPOS (type, 0) == 0);
c44af4eb 97
c9317f21 98 struct type *union_type = TYPE_FIELD_TYPE (type, 0);
c44af4eb 99
c9317f21
TT		 100 int fieldno = value_union_variant (union_type, contents);
101 return &TYPE_FIELD (union_type, fieldno);
c44af4eb
TT		 102}
103
104/* See rust-lang.h. */
105
65c40c95 106bool
c44af4eb
TT		 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
e86ca25f
TT		 113 && TYPE_NAME (type) != NULL
114 && TYPE_NAME (type)[0] == '(');
c44af4eb
TT		 115}
116
c44af4eb 117/* Return true if all non-static fields of a structlike type are in a
c9317f21 118 sequence like __0, __1, __2. */
c44af4eb 119
65c40c95 120static bool
c9317f21 121rust_underscore_fields (struct type *type)
c44af4eb
TT		 122{
123 int i, field_number;
124
125 field_number = 0;
126
127 if (TYPE_CODE (type) != TYPE_CODE_STRUCT)
65c40c95 128 return false;
c44af4eb
TT		 129 for (i = 0; i < TYPE_NFIELDS (type); ++i)
130 {
131 if (!field_is_static (&TYPE_FIELD (type, i)))
132 {
c9317f21 133 char buf[20];
c44af4eb 134
c9317f21
TT		 135 xsnprintf (buf, sizeof (buf), "__%d", field_number);
136 if (strcmp (buf, TYPE_FIELD_NAME (type, i)) != 0)
137 return false;
138 field_number++;
c44af4eb
TT		 139 }
140 }
65c40c95 141 return true;
c44af4eb
TT		 142}
143
144/* See rust-lang.h. */
145
65c40c95 146bool
c44af4eb
TT		 147rust_tuple_struct_type_p (struct type *type)
148{
12df5c00
TT		 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. */
c9317f21 152 return TYPE_NFIELDS (type) > 0 && rust_underscore_fields (type);
c44af4eb
TT		 153}
154
155/* Return true if TYPE is a slice type, otherwise false. */
156
65c40c95 157static bool
c44af4eb
TT		 158rust_slice_type_p (struct type *type)
159{
160 return (TYPE_CODE (type) == TYPE_CODE_STRUCT
e86ca25f
TT		 161 && TYPE_NAME (type) != NULL
162 && (strncmp (TYPE_NAME (type), "&[", 2) == 0
163 || strcmp (TYPE_NAME (type), "&str") == 0));
c44af4eb
TT		 164}
165
166/* Return true if TYPE is a range type, otherwise false. */
167
65c40c95 168static bool
c44af4eb
TT		 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
e86ca25f
TT		 175 || TYPE_NAME (type) == NULL
176 || strstr (TYPE_NAME (type), "::Range") == NULL)
65c40c95 177 return false;
c44af4eb
TT		 178
179 if (TYPE_NFIELDS (type) == 0)
65c40c95 180 return true;
c44af4eb
TT		 181
182 i = 0;
183 if (strcmp (TYPE_FIELD_NAME (type, 0), "start") == 0)
184 {
185 if (TYPE_NFIELDS (type) == 1)
65c40c95 186 return true;
c44af4eb
TT		 187 i = 1;
188 }
189 else if (TYPE_NFIELDS (type) == 2)
190 {
191 /* First field had to be "start". */
65c40c95 192 return false;
c44af4eb
TT		 193 }
194
195 return strcmp (TYPE_FIELD_NAME (type, i), "end") == 0;
196}
197
6873858b
TT		 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{
e86ca25f
TT		 205 return (strstr (TYPE_NAME (type), "::RangeInclusive") != NULL
206 || strstr (TYPE_NAME (type), "::RangeToInclusive") != NULL);
6873858b
TT		 207}
208
c44af4eb
TT		 209/* Return true if TYPE seems to be the type "u8", otherwise false. */
210
65c40c95 211static bool
c44af4eb
TT		 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
65c40c95 221static bool
c44af4eb
TT		 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
71a3c369
TT		 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);
cf724bc9 253 if (symbol == NULL || symbol->subclass != SYMBOL_RUST_VTABLE)
71a3c369
TT		 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
c44af4eb
TT		 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
45320ffa
TT		 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
c9317f21 348/* rust_val_print helper for structs and untagged unions. */
b96645f1
MG		 349
350static void
e8b24d9f
YQ		 351val_print_struct (struct type *type, int embedded_offset,
352 CORE_ADDR address, struct ui_file *stream,
353 int recurse, struct value *val,
20955dbf 354 const struct value_print_options *options)
b96645f1
MG		 355{
356 int i;
357 int first_field;
45320ffa
TT		 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
65c40c95
TT		 365 bool is_tuple = rust_tuple_type_p (type);
366 bool is_tuple_struct = !is_tuple && rust_tuple_struct_type_p (type);
b96645f1
MG		 367 struct value_print_options opts;
368
369 if (!is_tuple)
370 {
e86ca25f
TT		 371 if (TYPE_NAME (type) != NULL)
372 fprintf_filtered (stream, "%s", TYPE_NAME (type));
b96645f1
MG		 373
374 if (TYPE_NFIELDS (type) == 0)
375 return;
376
e86ca25f 377 if (TYPE_NAME (type) != NULL)
b96645f1
MG		 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 {
b50f188d
TT		 400 fputs_filtered ("\n", stream);
401 print_spaces_filtered (2 + 2 * recurse, stream);
b96645f1
MG		 402 }
403 else if (!first_field)
404 fputs_filtered (" ", stream);
405
406 first_field = 0;
407
408 if (!is_tuple && !is_tuple_struct)
409 {
b50f188d
TT		 410 fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
411 fputs_filtered (": ", stream);
b96645f1
MG		 412 }
413
414 val_print (TYPE_FIELD_TYPE (type, i),
b50f188d
TT		 415 embedded_offset + TYPE_FIELD_BITPOS (type, i) / 8,
416 address,
417 stream, recurse + 1, val, &opts,
418 current_language);
b96645f1
MG		 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
c9317f21
TT		 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
098b2108
TT		 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
c9317f21
TT		 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
c44af4eb
TT		 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",
921d8f54 512 "()",
c44af4eb
TT		 513 "[",
514 "]"
515};
516
517/* la_val_print implementation for Rust. */
518
519static void
e8b24d9f 520rust_val_print (struct type *type, int embedded_offset,
c44af4eb 521 CORE_ADDR address, struct ui_file *stream, int recurse,
e8b24d9f 522 struct value *val,
c44af4eb
TT		 523 const struct value_print_options *options)
524{
e8b24d9f
YQ		 525 const gdb_byte *valaddr = value_contents_for_printing (val);
526
c44af4eb
TT		 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:
e8b24d9f 563 c_val_print (type, embedded_offset, address, stream,
c44af4eb
TT		 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:
c9317f21
TT		 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);
c44af4eb
TT		 616 break;
617
618 case TYPE_CODE_STRUCT:
c9317f21
TT		 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);
b96645f1 625 break;
c44af4eb 626
b96645f1
MG		 627 default:
628 generic_print:
629 /* Nothing special yet. */
e8b24d9f 630 generic_val_print (type, embedded_offset, address, stream,
b96645f1
MG		 631 recurse, val, options, &rust_decorations);
632 }
633}
c44af4eb 634
b96645f1 635\f
c44af4eb 636
b96645f1 637static void
c9317f21
TT		 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,
a33ccfc7 641 bool for_rust_enum, print_offset_data *podata);
b96645f1
MG		 642
643/* Print a struct or union typedef. */
644static void
645rust_print_struct_def (struct type *type, const char *varstring,
b50f188d 646 struct ui_file *stream, int show, int level,
c9317f21 647 const struct type_print_options *flags,
a33ccfc7 648 bool for_rust_enum, print_offset_data *podata)
b96645f1 649{
b50f188d
TT		 650 /* Print a tuple type simply. */
651 if (rust_tuple_type_p (type))
652 {
e86ca25f 653 fputs_filtered (TYPE_NAME (type), stream);
b50f188d
TT		 654 return;
655 }
c44af4eb 656
b50f188d
TT		 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);
c44af4eb 660
a33ccfc7
TT		 661 if (flags->print_offsets)
662 {
663 /* Temporarily bump the level so that the output lines up
664 correctly. */
665 level += 2;
666 }
667
c9317f21
TT		 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. */
e86ca25f 670 const char *tagname = TYPE_NAME (type);
c9317f21
TT		 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);
b96645f1 674
c9317f21
TT		 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);
098b2108
TT		 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
c9317f21
TT		 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 }
c9317f21
TT		 707 else if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
708 fputs_filtered ("struct ", stream);
709 else
710 fputs_filtered ("union ", stream);
b96645f1 711
c9317f21
TT		 712 if (tagname != NULL)
713 fputs_filtered (tagname, stream);
714 }
b96645f1 715
c9317f21 716 if (TYPE_NFIELDS (type) == 0 && !is_tuple)
b50f188d 717 return;
a33ccfc7 718 if (for_rust_enum && !flags->print_offsets)
c9317f21
TT		 719 fputs_filtered (is_tuple_struct ? "(" : "{", stream);
720 else
721 fputs_filtered (is_tuple_struct ? " (\n" : " {\n", stream);
c44af4eb 722
a33ccfc7
TT		 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;
c9317f21 728 for (int i = 0; i < TYPE_NFIELDS (type); ++i)
b50f188d 729 {
b50f188d
TT		 730 if (field_is_static (&TYPE_FIELD (type, i)))
731 continue;
a33ccfc7
TT		 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);
b50f188d
TT		 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. */
a33ccfc7 760 if (!for_rust_enum || flags->print_offsets)
c9317f21
TT		 761 print_spaces_filtered (level + 2, stream);
762 if (is_enum)
a33ccfc7 763 fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
c9317f21 764 else if (!is_tuple_struct)
b50f188d
TT		 765 fprintf_filtered (stream, "%s: ", TYPE_FIELD_NAME (type, i));
766
c9317f21 767 rust_internal_print_type (TYPE_FIELD_TYPE (type, i), NULL,
53d7df28 768 stream, (is_enum ? show : show - 1),
a33ccfc7
TT		 769 level + 2, flags, is_enum, podata);
770 if (!for_rust_enum || flags->print_offsets)
c9317f21 771 fputs_filtered (",\n", stream);
a33ccfc7
TT		 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. */
c9317f21
TT		 775 else if (i + 1 < TYPE_NFIELDS (type))
776 fputs_filtered (", ", stream);
b50f188d 777 }
c44af4eb 778
a33ccfc7
TT		 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)
c9317f21
TT		 789 print_spaces_filtered (level, stream);
790 fputs_filtered (is_tuple_struct ? ")" : "}", stream);
c44af4eb
TT		 791}
792
c44af4eb
TT		 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
c9317f21
TT		 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,
a33ccfc7 812 bool for_rust_enum, print_offset_data *podata)
c44af4eb 813{
c44af4eb
TT		 814 QUIT;
815 if (show <= 0
816 && TYPE_NAME (type) != NULL)
817 {
921d8f54
MG		 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);
c44af4eb
TT		 824 return;
825 }
826
827 type = check_typedef (type);
828 switch (TYPE_CODE (type))
829 {
921d8f54 830 case TYPE_CODE_VOID:
c9317f21
TT		 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);
921d8f54
MG		 836 break;
837
c44af4eb
TT		 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);
b926417a 847 for (int i = 0; i < TYPE_NFIELDS (type); ++i)
c44af4eb
TT		 848 {
849 QUIT;
850 if (i > 0)
851 fputs_filtered (", ", stream);
c9317f21 852 rust_internal_print_type (TYPE_FIELD_TYPE (type, i), "", stream,
a33ccfc7 853 -1, 0, flags, false, podata);
c44af4eb 854 }
921d8f54
MG		 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);
c9317f21 860 rust_internal_print_type (TYPE_TARGET_TYPE (type), "", stream,
a33ccfc7 861 -1, 0, flags, false, podata);
921d8f54 862 }
c44af4eb
TT		 863 break;
864
865 case TYPE_CODE_ARRAY:
866 {
867 LONGEST low_bound, high_bound;
868
869 fputs_filtered ("[", stream);
c9317f21 870 rust_internal_print_type (TYPE_TARGET_TYPE (type), NULL,
a33ccfc7
TT		 871 stream, show - 1, level, flags, false,
872 podata);
c44af4eb
TT		 873
874 if (TYPE_HIGH_BOUND_KIND (TYPE_INDEX_TYPE (type)) == PROP_LOCEXPR
875 || TYPE_HIGH_BOUND_KIND (TYPE_INDEX_TYPE (type)) == PROP_LOCLIST)
e6cf65f2 876 fprintf_filtered (stream, "; variable length");
c44af4eb 877 else if (get_array_bounds (type, &low_bound, &high_bound))
e6cf65f2 878 fprintf_filtered (stream, "; %s",
c44af4eb
TT		 879 plongest (high_bound - low_bound + 1));
880 fputs_filtered ("]", stream);
881 }
882 break;
883
c9317f21 884 case TYPE_CODE_UNION:
c44af4eb 885 case TYPE_CODE_STRUCT:
c9317f21 886 rust_print_struct_def (type, varstring, stream, show, level, flags,
a33ccfc7 887 for_rust_enum, podata);
c44af4eb
TT		 888 break;
889
890 case TYPE_CODE_ENUM:
891 {
b926417a 892 int len = 0;
c44af4eb
TT		 893
894 fputs_filtered ("enum ", stream);
e86ca25f 895 if (TYPE_NAME (type) != NULL)
c44af4eb 896 {
e86ca25f 897 fputs_filtered (TYPE_NAME (type), stream);
c44af4eb 898 fputs_filtered (" ", stream);
e86ca25f 899 len = strlen (TYPE_NAME (type));
c44af4eb
TT		 900 }
901 fputs_filtered ("{\n", stream);
902
b926417a 903 for (int i = 0; i < TYPE_NFIELDS (type); ++i)
c44af4eb
TT		 904 {
905 const char *name = TYPE_FIELD_NAME (type, i);
906
907 QUIT;
908
909 if (len > 0
e86ca25f 910 && strncmp (name, TYPE_NAME (type), len) == 0
c44af4eb
TT		 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 }
73fc52c4
TT		 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 }
c44af4eb
TT		 933 break;
934
c44af4eb
TT		 935 default:
936 c_printer:
937 c_print_type (type, varstring, stream, show, level, flags);
938 }
939}
940
c9317f21
TT		 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{
a33ccfc7 946 print_offset_data podata;
c9317f21 947 rust_internal_print_type (type, varstring, stream, show, level,
a33ccfc7 948 flags, false, &podata);
c9317f21
TT		 949}
950
c44af4eb
TT		 951\f
952
c44af4eb
TT		 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;
c44af4eb
TT		 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);
2fff16dd 994 unsigned align = type_align (type2);
c44af4eb
TT		 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
49f190bc
UW		 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);
c44af4eb
TT		 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;
c44af4eb 1111 struct value *function, *result, *arg0;
c44af4eb
TT		 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
ab8b80a8 1137 std::vector<struct value *> args (num_args + 1);
c44af4eb
TT		 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"));
e86ca25f 1150 if (TYPE_NAME (type) == NULL)
c44af4eb
TT		 1151 error (_("Method call on nameless type"));
1152
e86ca25f 1153 std::string name = std::string (TYPE_NAME (type)) + "::" + method;
c44af4eb
TT		 1154
1155 block = get_selected_block (0);
ab8b80a8 1156 sym = lookup_symbol (name.c_str (), block, VAR_DOMAIN, NULL);
c44af4eb 1157 if (sym.symbol == NULL)
ab8b80a8 1158 error (_("Could not find function named '%s'"), name.c_str ());
c44af4eb
TT		 1159
1160 fn_type = SYMBOL_TYPE (sym.symbol);
1161 if (TYPE_NFIELDS (fn_type) == 0)
ab8b80a8 1162 error (_("Function '%s' takes no arguments"), name.c_str ());
c44af4eb
TT		 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
e71585ff 1175 result = call_function_by_hand (function, NULL, args);
c44af4eb
TT		 1176 return result;
1177}
1178
01739a3b 1179/* A helper for rust_evaluate_subexp that handles OP_RANGE. */
c44af4eb
TT		 1180
1181static struct value *
1182rust_range (struct expression *exp, int *pos, enum noside noside)
1183{
01739a3b 1184 enum range_type kind;
c44af4eb
TT		 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
01739a3b 1193 kind = (enum range_type) longest_to_int (exp->elts[*pos + 1].longconst);
c44af4eb
TT		 1194 *pos += 3;
1195
6873858b
TT		 1196 if (kind == HIGH_BOUND_DEFAULT || kind == NONE_BOUND_DEFAULT
1197 || kind == NONE_BOUND_DEFAULT_EXCLUSIVE)
c44af4eb 1198 low = evaluate_subexp (NULL_TYPE, exp, pos, noside);
6873858b
TT		 1199 if (kind == LOW_BOUND_DEFAULT || kind == LOW_BOUND_DEFAULT_EXCLUSIVE
1200 || kind == NONE_BOUND_DEFAULT || kind == NONE_BOUND_DEFAULT_EXCLUSIVE)
c44af4eb 1201 high = evaluate_subexp (NULL_TYPE, exp, pos, noside);
6873858b 1202 bool inclusive = (kind == NONE_BOUND_DEFAULT || kind == LOW_BOUND_DEFAULT);
c44af4eb
TT		 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);
6873858b
TT		 1217 name = (inclusive
1218 ? "std::ops::RangeToInclusive" : "std::ops::RangeTo");
c44af4eb
TT		 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);
6873858b 1233 name = inclusive ? "std::ops::RangeInclusive" : "std::ops::Range";
c44af4eb
TT		 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,
01739a3b 1285 enum range_type *kind)
c44af4eb
TT		 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));
6873858b
TT		 1309
1310 if (rust_inclusive_range_type_p (type))
1311 ++*high;
c44af4eb
TT		 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;
45f4ed92 1323 LONGEST low, high_bound;
c44af4eb 1324 /* Initialized to appease the compiler. */
01739a3b 1325 enum range_type kind = BOTH_BOUND_DEFAULT;
45f4ed92 1326 LONGEST high = 0;
c44af4eb
TT		 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
b3e3859b 1347 struct type *type = check_typedef (value_type (lhs));
c44af4eb
TT		 1348 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1349 {
b3e3859b
TT		 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;
c44af4eb 1387
b3e3859b 1388 return value_zero (new_type, VALUE_LVAL (lhs));
c44af4eb
TT		 1389 }
1390 else
1391 {
1392 LONGEST low_bound;
1393 struct value *base;
c44af4eb
TT		 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 }
42d94011
MG		 1413 else if (TYPE_CODE (type) == TYPE_CODE_PTR)
1414 {
1415 base = lhs;
1416 low_bound = 0;
1417 high_bound = LONGEST_MAX;
1418 }
c44af4eb
TT		 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");
45320ffa
TT		 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);
c44af4eb
TT		 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 {
71a3c369
TT		 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
c44af4eb
TT		 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 {
8d49165d 1602 (*pos)++;
c44af4eb
TT		 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 {
c44af4eb 1615 int i;
ab8b80a8 1616 std::vector<struct value *> eltvec (copies);
c44af4eb
TT		 1617
1618 for (i = 0; i < copies; ++i)
1619 eltvec[i] = elt;
ab8b80a8 1620 result = value_array (0, copies - 1, eltvec.data ());
c44af4eb
TT		 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;
8d49165d 1636 struct type *type;
c44af4eb
TT		 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);
c9317f21 1644
c9317f21
TT		 1645 if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
1646 {
1647 struct type *outer_type = NULL;
1648
1649 if (rust_enum_p (type))
c44af4eb 1650 {
098b2108
TT		 1651 if (rust_empty_enum_p (type))
1652 error (_("Cannot access field %d of empty enum %s"),
1653 field_number, TYPE_NAME (type));
1654
c9317f21
TT		 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);
c44af4eb
TT		 1667 }
1668
c44af4eb 1669 /* Tuples and tuple structs */
c9317f21 1670 nfields = TYPE_NFIELDS (type);
c44af4eb
TT		 1671
1672 if (field_number >= nfields || field_number < 0)
c9317f21
TT		 1673 {
1674 if (outer_type != NULL)
1675 error(_("Cannot access field %d of variant %s::%s, "
1676 "there are only %d fields"),
e86ca25f
TT		 1677 field_number, TYPE_NAME (outer_type),
1678 rust_last_path_segment (TYPE_NAME (type)),
c9317f21
TT		 1679 nfields);
1680 else
1681 error(_("Cannot access field %d of %s, "
1682 "there are only %d fields"),
e86ca25f 1683 field_number, TYPE_NAME (type), nfields);
c9317f21 1684 }
c44af4eb
TT		 1685
1686 /* Tuples are tuple structs too. */
1687 if (!rust_tuple_struct_type_p (type))
c9317f21
TT		 1688 {
1689 if (outer_type != NULL)
1690 error(_("Variant %s::%s is not a tuple variant"),
e86ca25f
TT		 1691 TYPE_NAME (outer_type),
1692 rust_last_path_segment (TYPE_NAME (type)));
c9317f21
TT		 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"),
e86ca25f 1697 field_number, TYPE_NAME (type));
c9317f21 1698 }
c44af4eb
TT		 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 {
6830f270 1710 struct value *lhs;
c44af4eb
TT		 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
6830f270 1719 const char *field_name = &exp->elts[pc + 2].string;
c44af4eb 1720 type = value_type (lhs);
c9317f21 1721 if (TYPE_CODE (type) == TYPE_CODE_STRUCT && rust_enum_p (type))
c44af4eb 1722 {
098b2108
TT		 1723 if (rust_empty_enum_p (type))
1724 error (_("Cannot access field %s of empty enum %s"),
1725 field_name, TYPE_NAME (type));
1726
c9317f21
TT		 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))
4a3fe98f 1741 error (_("Attempting to access named field %s of tuple "
c9317f21 1742 "variant %s::%s, which has only anonymous fields"),
4a3fe98f 1743 field_name, TYPE_NAME (outer_type),
c9317f21
TT		 1744 rust_last_path_segment (TYPE_NAME (type)));
1745
1746 TRY
c44af4eb 1747 {
c9317f21
TT		 1748 result = value_struct_elt (&lhs, NULL, field_name,
1749 NULL, "structure");
c44af4eb 1750 }
c9317f21
TT		 1751 CATCH (except, RETURN_MASK_ERROR)
1752 {
1753 error (_("Could not find field %s of struct variant %s::%s"),
e86ca25f 1754 field_name, TYPE_NAME (outer_type),
c9317f21
TT		 1755 rust_last_path_segment (TYPE_NAME (type)));
1756 }
1757 END_CATCH
c44af4eb
TT		 1758 }
1759 else
c9317f21
TT		 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));
c44af4eb
TT		 1763 }
1764 break;
1765
01739a3b 1766 case OP_RANGE:
c44af4eb
TT		 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
a121b7c1 1833static const char *
c44af4eb
TT		 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
68f2f2e3 1893 field_number = longest_to_int (exp->elts[elt + 1].longconst);
c44af4eb
TT		 1894
1895 fprintf_filtered (stream, "Field number: %d", field_number);
68f2f2e3 1896 elt = dump_subexp (exp, stream, elt + 3);
c44af4eb
TT		 1897 }
1898 break;
1899
1900 case OP_RUST_ARRAY:
68f2f2e3 1901 ++elt;
c44af4eb
TT		 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 }
256afbc2 1964 break;
c44af4eb
TT		 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{
6640a367 2023 struct block_symbol result = {};
c44af4eb
TT		 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. */
fcfcc376 2035 std::string scopedname;
c44af4eb
TT		 2036 if (name[cp_find_first_component (name)] == '\0')
2037 {
2038 const char *scope = block_scope (block);
2039
2040 if (scope[0] != '\0')
2041 {
fcfcc376
TT		 2042 scopedname = std::string (scope) + "::" + name;
2043 name = scopedname.c_str ();
c44af4eb 2044 }
fcfcc376
TT		 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);
c44af4eb
TT		 2054 }
2055 return result;
2056}
2057
2058\f
2059
8b302db8
TT		 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
43cc5389
TT		 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
c44af4eb
TT		 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
56618e20
TT		 2095static const char *rust_extensions[] =
2096{
2097 ".rs", NULL
2098};
2099
47e77640 2100extern const struct language_defn rust_language_defn =
c44af4eb
TT		 2101{
2102 "rust",
2103 "Rust",
2104 language_rust,
2105 range_check_on,
2106 case_sensitive_on,
2107 array_row_major,
2108 macro_expansion_no,
56618e20 2109 rust_extensions,
c44af4eb
TT		 2110 &exp_descriptor_rust,
2111 rust_parse,
c44af4eb
TT		 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 */
59cc4834 2123 false, /* la_store_sym_names_in_linkage_form_p */
c44af4eb
TT		 2124 rust_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
2125 basic_lookup_transparent_type,/* lookup_transparent_type */
2126 gdb_demangle, /* Language specific symbol demangler */
8b302db8 2127 rust_sniff_from_mangled_name,
c44af4eb
TT		 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,
eb3ff9a5 2134 default_collect_symbol_completion_matches,
c44af4eb
TT		 2135 rust_language_arch_info,
2136 default_print_array_index,
2137 default_pass_by_reference,
2138 c_get_string,
43cc5389 2139 rust_watch_location_expression,
b5ec771e 2140 NULL, /* la_get_symbol_name_matcher */
c44af4eb 2141 iterate_over_symbols,
5ffa0793 2142 default_search_name_hash,
c44af4eb
TT		 2143 &default_varobj_ops,
2144 NULL,
2145 NULL,
2146 LANG_MAGIC
2147};
GDB Binutils - Deliverables
This page took 0.424141 seconds and 4 git commands to generate.