projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Simple -Wshadow=local fixes
[deliverable/binutils-gdb.git] / gdb / rust-lang.c
CommitLineData
c44af4eb
TT		 1/* Rust language support routines for GDB, the GNU debugger.
2
e2882c85 3 Copyright (C) 2016-2018 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 }
919 break;
920
c44af4eb
TT		 921 default:
922 c_printer:
923 c_print_type (type, varstring, stream, show, level, flags);
924 }
925}
926
c9317f21
TT		 927static void
928rust_print_type (struct type *type, const char *varstring,
929 struct ui_file *stream, int show, int level,
930 const struct type_print_options *flags)
931{
a33ccfc7 932 print_offset_data podata;
c9317f21 933 rust_internal_print_type (type, varstring, stream, show, level,
a33ccfc7 934 flags, false, &podata);
c9317f21
TT		 935}
936
c44af4eb
TT		 937\f
938
c44af4eb
TT		 939/* Like arch_composite_type, but uses TYPE to decide how to allocate
940 -- either on an obstack or on a gdbarch. */
941
942static struct type *
943rust_composite_type (struct type *original,
944 const char *name,
945 const char *field1, struct type *type1,
946 const char *field2, struct type *type2)
947{
948 struct type *result = alloc_type_copy (original);
949 int i, nfields, bitpos;
950
951 nfields = 0;
952 if (field1 != NULL)
953 ++nfields;
954 if (field2 != NULL)
955 ++nfields;
956
957 TYPE_CODE (result) = TYPE_CODE_STRUCT;
958 TYPE_NAME (result) = name;
c44af4eb
TT		 959
960 TYPE_NFIELDS (result) = nfields;
961 TYPE_FIELDS (result)
962 = (struct field *) TYPE_ZALLOC (result, nfields * sizeof (struct field));
963
964 i = 0;
965 bitpos = 0;
966 if (field1 != NULL)
967 {
968 struct field *field = &TYPE_FIELD (result, i);
969
970 SET_FIELD_BITPOS (*field, bitpos);
971 bitpos += TYPE_LENGTH (type1) * TARGET_CHAR_BIT;
972
973 FIELD_NAME (*field) = field1;
974 FIELD_TYPE (*field) = type1;
975 ++i;
976 }
977 if (field2 != NULL)
978 {
979 struct field *field = &TYPE_FIELD (result, i);
2fff16dd 980 unsigned align = type_align (type2);
c44af4eb
TT		 981
982 if (align != 0)
983 {
984 int delta;
985
986 align *= TARGET_CHAR_BIT;
987 delta = bitpos % align;
988 if (delta != 0)
989 bitpos += align - delta;
990 }
991 SET_FIELD_BITPOS (*field, bitpos);
992
993 FIELD_NAME (*field) = field2;
994 FIELD_TYPE (*field) = type2;
995 ++i;
996 }
997
998 if (i > 0)
999 TYPE_LENGTH (result)
1000 = (TYPE_FIELD_BITPOS (result, i - 1) / TARGET_CHAR_BIT +
1001 TYPE_LENGTH (TYPE_FIELD_TYPE (result, i - 1)));
1002 return result;
1003}
1004
1005/* See rust-lang.h. */
1006
1007struct type *
1008rust_slice_type (const char *name, struct type *elt_type,
1009 struct type *usize_type)
1010{
1011 struct type *type;
1012
1013 elt_type = lookup_pointer_type (elt_type);
1014 type = rust_composite_type (elt_type, name,
1015 "data_ptr", elt_type,
1016 "length", usize_type);
1017
1018 return type;
1019}
1020
1021enum rust_primitive_types
1022{
1023 rust_primitive_bool,
1024 rust_primitive_char,
1025 rust_primitive_i8,
1026 rust_primitive_u8,
1027 rust_primitive_i16,
1028 rust_primitive_u16,
1029 rust_primitive_i32,
1030 rust_primitive_u32,
1031 rust_primitive_i64,
1032 rust_primitive_u64,
1033 rust_primitive_isize,
1034 rust_primitive_usize,
1035 rust_primitive_f32,
1036 rust_primitive_f64,
1037 rust_primitive_unit,
1038 rust_primitive_str,
1039 nr_rust_primitive_types
1040};
1041
1042/* la_language_arch_info implementation for Rust. */
1043
1044static void
1045rust_language_arch_info (struct gdbarch *gdbarch,
1046 struct language_arch_info *lai)
1047{
1048 const struct builtin_type *builtin = builtin_type (gdbarch);
1049 struct type *tem;
1050 struct type **types;
1051 unsigned int length;
1052
1053 types = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_rust_primitive_types + 1,
1054 struct type *);
1055
1056 types[rust_primitive_bool] = arch_boolean_type (gdbarch, 8, 1, "bool");
1057 types[rust_primitive_char] = arch_character_type (gdbarch, 32, 1, "char");
1058 types[rust_primitive_i8] = arch_integer_type (gdbarch, 8, 0, "i8");
1059 types[rust_primitive_u8] = arch_integer_type (gdbarch, 8, 1, "u8");
1060 types[rust_primitive_i16] = arch_integer_type (gdbarch, 16, 0, "i16");
1061 types[rust_primitive_u16] = arch_integer_type (gdbarch, 16, 1, "u16");
1062 types[rust_primitive_i32] = arch_integer_type (gdbarch, 32, 0, "i32");
1063 types[rust_primitive_u32] = arch_integer_type (gdbarch, 32, 1, "u32");
1064 types[rust_primitive_i64] = arch_integer_type (gdbarch, 64, 0, "i64");
1065 types[rust_primitive_u64] = arch_integer_type (gdbarch, 64, 1, "u64");
1066
1067 length = 8 * TYPE_LENGTH (builtin->builtin_data_ptr);
1068 types[rust_primitive_isize] = arch_integer_type (gdbarch, length, 0, "isize");
1069 types[rust_primitive_usize] = arch_integer_type (gdbarch, length, 1, "usize");
1070
49f190bc
UW		 1071 types[rust_primitive_f32] = arch_float_type (gdbarch, 32, "f32",
1072 floatformats_ieee_single);
1073 types[rust_primitive_f64] = arch_float_type (gdbarch, 64, "f64",
1074 floatformats_ieee_double);
c44af4eb
TT		 1075
1076 types[rust_primitive_unit] = arch_integer_type (gdbarch, 0, 1, "()");
1077
1078 tem = make_cv_type (1, 0, types[rust_primitive_u8], NULL);
1079 types[rust_primitive_str] = rust_slice_type ("&str", tem,
1080 types[rust_primitive_usize]);
1081
1082 lai->primitive_type_vector = types;
1083 lai->bool_type_default = types[rust_primitive_bool];
1084 lai->string_char_type = types[rust_primitive_u8];
1085}
1086
1087\f
1088
1089/* A helper for rust_evaluate_subexp that handles OP_FUNCALL. */
1090
1091static struct value *
1092rust_evaluate_funcall (struct expression *exp, int *pos, enum noside noside)
1093{
1094 int i;
1095 int num_args = exp->elts[*pos + 1].longconst;
1096 const char *method;
c44af4eb 1097 struct value *function, *result, *arg0;
c44af4eb
TT		 1098 struct type *type, *fn_type;
1099 const struct block *block;
1100 struct block_symbol sym;
1101
1102 /* For an ordinary function call we can simply defer to the
1103 generic implementation. */
1104 if (exp->elts[*pos + 3].opcode != STRUCTOP_STRUCT)
1105 return evaluate_subexp_standard (NULL, exp, pos, noside);
1106
1107 /* Skip over the OP_FUNCALL and the STRUCTOP_STRUCT. */
1108 *pos += 4;
1109 method = &exp->elts[*pos + 1].string;
1110 *pos += 3 + BYTES_TO_EXP_ELEM (exp->elts[*pos].longconst + 1);
1111
1112 /* Evaluate the argument to STRUCTOP_STRUCT, then find its
1113 type in order to look up the method. */
1114 arg0 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1115
1116 if (noside == EVAL_SKIP)
1117 {
1118 for (i = 0; i < num_args; ++i)
1119 evaluate_subexp (NULL_TYPE, exp, pos, noside);
1120 return arg0;
1121 }
1122
ab8b80a8 1123 std::vector<struct value *> args (num_args + 1);
c44af4eb
TT		 1124 args[0] = arg0;
1125
1126 /* We don't yet implement real Deref semantics. */
1127 while (TYPE_CODE (value_type (args[0])) == TYPE_CODE_PTR)
1128 args[0] = value_ind (args[0]);
1129
1130 type = value_type (args[0]);
1131 if ((TYPE_CODE (type) != TYPE_CODE_STRUCT
1132 && TYPE_CODE (type) != TYPE_CODE_UNION
1133 && TYPE_CODE (type) != TYPE_CODE_ENUM)
1134 || rust_tuple_type_p (type))
1135 error (_("Method calls only supported on struct or enum types"));
e86ca25f 1136 if (TYPE_NAME (type) == NULL)
c44af4eb
TT		 1137 error (_("Method call on nameless type"));
1138
e86ca25f 1139 std::string name = std::string (TYPE_NAME (type)) + "::" + method;
c44af4eb
TT		 1140
1141 block = get_selected_block (0);
ab8b80a8 1142 sym = lookup_symbol (name.c_str (), block, VAR_DOMAIN, NULL);
c44af4eb 1143 if (sym.symbol == NULL)
ab8b80a8 1144 error (_("Could not find function named '%s'"), name.c_str ());
c44af4eb
TT		 1145
1146 fn_type = SYMBOL_TYPE (sym.symbol);
1147 if (TYPE_NFIELDS (fn_type) == 0)
ab8b80a8 1148 error (_("Function '%s' takes no arguments"), name.c_str ());
c44af4eb
TT		 1149
1150 if (TYPE_CODE (TYPE_FIELD_TYPE (fn_type, 0)) == TYPE_CODE_PTR)
1151 args[0] = value_addr (args[0]);
1152
1153 function = address_of_variable (sym.symbol, block);
1154
1155 for (i = 0; i < num_args; ++i)
1156 args[i + 1] = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1157
1158 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1159 result = value_zero (TYPE_TARGET_TYPE (fn_type), not_lval);
1160 else
7022349d 1161 result = call_function_by_hand (function, NULL, num_args + 1, args.data ());
c44af4eb
TT		 1162 return result;
1163}
1164
01739a3b 1165/* A helper for rust_evaluate_subexp that handles OP_RANGE. */
c44af4eb
TT		 1166
1167static struct value *
1168rust_range (struct expression *exp, int *pos, enum noside noside)
1169{
01739a3b 1170 enum range_type kind;
c44af4eb
TT		 1171 struct value *low = NULL, *high = NULL;
1172 struct value *addrval, *result;
1173 CORE_ADDR addr;
1174 struct type *range_type;
1175 struct type *index_type;
1176 struct type *temp_type;
1177 const char *name;
1178
01739a3b 1179 kind = (enum range_type) longest_to_int (exp->elts[*pos + 1].longconst);
c44af4eb
TT		 1180 *pos += 3;
1181
6873858b
TT		 1182 if (kind == HIGH_BOUND_DEFAULT || kind == NONE_BOUND_DEFAULT
1183 || kind == NONE_BOUND_DEFAULT_EXCLUSIVE)
c44af4eb 1184 low = evaluate_subexp (NULL_TYPE, exp, pos, noside);
6873858b
TT		 1185 if (kind == LOW_BOUND_DEFAULT || kind == LOW_BOUND_DEFAULT_EXCLUSIVE
1186 || kind == NONE_BOUND_DEFAULT || kind == NONE_BOUND_DEFAULT_EXCLUSIVE)
c44af4eb 1187 high = evaluate_subexp (NULL_TYPE, exp, pos, noside);
6873858b 1188 bool inclusive = (kind == NONE_BOUND_DEFAULT || kind == LOW_BOUND_DEFAULT);
c44af4eb
TT		 1189
1190 if (noside == EVAL_SKIP)
1191 return value_from_longest (builtin_type (exp->gdbarch)->builtin_int, 1);
1192
1193 if (low == NULL)
1194 {
1195 if (high == NULL)
1196 {
1197 index_type = NULL;
1198 name = "std::ops::RangeFull";
1199 }
1200 else
1201 {
1202 index_type = value_type (high);
6873858b
TT		 1203 name = (inclusive
1204 ? "std::ops::RangeToInclusive" : "std::ops::RangeTo");
c44af4eb
TT		 1205 }
1206 }
1207 else
1208 {
1209 if (high == NULL)
1210 {
1211 index_type = value_type (low);
1212 name = "std::ops::RangeFrom";
1213 }
1214 else
1215 {
1216 if (!types_equal (value_type (low), value_type (high)))
1217 error (_("Range expression with different types"));
1218 index_type = value_type (low);
6873858b 1219 name = inclusive ? "std::ops::RangeInclusive" : "std::ops::Range";
c44af4eb
TT		 1220 }
1221 }
1222
1223 /* If we don't have an index type, just allocate this on the
1224 arch. Here any type will do. */
1225 temp_type = (index_type == NULL
1226 ? language_bool_type (exp->language_defn, exp->gdbarch)
1227 : index_type);
1228 /* It would be nicer to cache the range type. */
1229 range_type = rust_composite_type (temp_type, name,
1230 low == NULL ? NULL : "start", index_type,
1231 high == NULL ? NULL : "end", index_type);
1232
1233 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1234 return value_zero (range_type, lval_memory);
1235
1236 addrval = value_allocate_space_in_inferior (TYPE_LENGTH (range_type));
1237 addr = value_as_long (addrval);
1238 result = value_at_lazy (range_type, addr);
1239
1240 if (low != NULL)
1241 {
1242 struct value *start = value_struct_elt (&result, NULL, "start", NULL,
1243 "range");
1244
1245 value_assign (start, low);
1246 }
1247
1248 if (high != NULL)
1249 {
1250 struct value *end = value_struct_elt (&result, NULL, "end", NULL,
1251 "range");
1252
1253 value_assign (end, high);
1254 }
1255
1256 result = value_at_lazy (range_type, addr);
1257 return result;
1258}
1259
1260/* A helper function to compute the range and kind given a range
1261 value. TYPE is the type of the range value. RANGE is the range
1262 value. LOW, HIGH, and KIND are out parameters. The LOW and HIGH
1263 parameters might be filled in, or might not be, depending on the
1264 kind of range this is. KIND will always be set to the appropriate
1265 value describing the kind of range, and this can be used to
1266 determine whether LOW or HIGH are valid. */
1267
1268static void
1269rust_compute_range (struct type *type, struct value *range,
1270 LONGEST *low, LONGEST *high,
01739a3b 1271 enum range_type *kind)
c44af4eb
TT		 1272{
1273 int i;
1274
1275 *low = 0;
1276 *high = 0;
1277 *kind = BOTH_BOUND_DEFAULT;
1278
1279 if (TYPE_NFIELDS (type) == 0)
1280 return;
1281
1282 i = 0;
1283 if (strcmp (TYPE_FIELD_NAME (type, 0), "start") == 0)
1284 {
1285 *kind = HIGH_BOUND_DEFAULT;
1286 *low = value_as_long (value_field (range, 0));
1287 ++i;
1288 }
1289 if (TYPE_NFIELDS (type) > i
1290 && strcmp (TYPE_FIELD_NAME (type, i), "end") == 0)
1291 {
1292 *kind = (*kind == BOTH_BOUND_DEFAULT
1293 ? LOW_BOUND_DEFAULT : NONE_BOUND_DEFAULT);
1294 *high = value_as_long (value_field (range, i));
6873858b
TT		 1295
1296 if (rust_inclusive_range_type_p (type))
1297 ++*high;
c44af4eb
TT		 1298 }
1299}
1300
1301/* A helper for rust_evaluate_subexp that handles BINOP_SUBSCRIPT. */
1302
1303static struct value *
1304rust_subscript (struct expression *exp, int *pos, enum noside noside,
1305 int for_addr)
1306{
1307 struct value *lhs, *rhs, *result;
1308 struct type *rhstype;
45f4ed92 1309 LONGEST low, high_bound;
c44af4eb 1310 /* Initialized to appease the compiler. */
01739a3b 1311 enum range_type kind = BOTH_BOUND_DEFAULT;
45f4ed92 1312 LONGEST high = 0;
c44af4eb
TT		 1313 int want_slice = 0;
1314
1315 ++*pos;
1316 lhs = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1317 rhs = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1318
1319 if (noside == EVAL_SKIP)
1320 return lhs;
1321
1322 rhstype = check_typedef (value_type (rhs));
1323 if (rust_range_type_p (rhstype))
1324 {
1325 if (!for_addr)
1326 error (_("Can't take slice of array without '&'"));
1327 rust_compute_range (rhstype, rhs, &low, &high, &kind);
1328 want_slice = 1;
1329 }
1330 else
1331 low = value_as_long (rhs);
1332
b3e3859b 1333 struct type *type = check_typedef (value_type (lhs));
c44af4eb
TT		 1334 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1335 {
b3e3859b
TT		 1336 struct type *base_type = nullptr;
1337 if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
1338 base_type = TYPE_TARGET_TYPE (type);
1339 else if (rust_slice_type_p (type))
1340 {
1341 for (int i = 0; i < TYPE_NFIELDS (type); ++i)
1342 {
1343 if (strcmp (TYPE_FIELD_NAME (type, i), "data_ptr") == 0)
1344 {
1345 base_type = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type, i));
1346 break;
1347 }
1348 }
1349 if (base_type == nullptr)
1350 error (_("Could not find 'data_ptr' in slice type"));
1351 }
1352 else if (TYPE_CODE (type) == TYPE_CODE_PTR)
1353 base_type = TYPE_TARGET_TYPE (type);
1354 else
1355 error (_("Cannot subscript non-array type"));
1356
1357 struct type *new_type;
1358 if (want_slice)
1359 {
1360 if (rust_slice_type_p (type))
1361 new_type = type;
1362 else
1363 {
1364 struct type *usize
1365 = language_lookup_primitive_type (exp->language_defn,
1366 exp->gdbarch,
1367 "usize");
1368 new_type = rust_slice_type ("&[*gdb*]", base_type, usize);
1369 }
1370 }
1371 else
1372 new_type = base_type;
c44af4eb 1373
b3e3859b 1374 return value_zero (new_type, VALUE_LVAL (lhs));
c44af4eb
TT		 1375 }
1376 else
1377 {
1378 LONGEST low_bound;
1379 struct value *base;
c44af4eb
TT		 1380
1381 if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
1382 {
1383 base = lhs;
1384 if (!get_array_bounds (type, &low_bound, &high_bound))
1385 error (_("Can't compute array bounds"));
1386 if (low_bound != 0)
1387 error (_("Found array with non-zero lower bound"));
1388 ++high_bound;
1389 }
1390 else if (rust_slice_type_p (type))
1391 {
1392 struct value *len;
1393
1394 base = value_struct_elt (&lhs, NULL, "data_ptr", NULL, "slice");
1395 len = value_struct_elt (&lhs, NULL, "length", NULL, "slice");
1396 low_bound = 0;
1397 high_bound = value_as_long (len);
1398 }
42d94011
MG		 1399 else if (TYPE_CODE (type) == TYPE_CODE_PTR)
1400 {
1401 base = lhs;
1402 low_bound = 0;
1403 high_bound = LONGEST_MAX;
1404 }
c44af4eb
TT		 1405 else
1406 error (_("Cannot subscript non-array type"));
1407
1408 if (want_slice
1409 && (kind == BOTH_BOUND_DEFAULT || kind == LOW_BOUND_DEFAULT))
1410 low = low_bound;
1411 if (low < 0)
1412 error (_("Index less than zero"));
1413 if (low > high_bound)
1414 error (_("Index greater than length"));
1415
1416 result = value_subscript (base, low);
1417 }
1418
1419 if (for_addr)
1420 {
1421 if (want_slice)
1422 {
1423 struct type *usize, *slice;
1424 CORE_ADDR addr;
1425 struct value *addrval, *tem;
1426
1427 if (kind == BOTH_BOUND_DEFAULT || kind == HIGH_BOUND_DEFAULT)
1428 high = high_bound;
1429 if (high < 0)
1430 error (_("High index less than zero"));
1431 if (low > high)
1432 error (_("Low index greater than high index"));
1433 if (high > high_bound)
1434 error (_("High index greater than length"));
1435
1436 usize = language_lookup_primitive_type (exp->language_defn,
1437 exp->gdbarch,
1438 "usize");
45320ffa
TT		 1439 const char *new_name = ((type != nullptr
1440 && rust_slice_type_p (type))
1441 ? TYPE_NAME (type) : "&[*gdb*]");
1442
1443 slice = rust_slice_type (new_name, value_type (result), usize);
c44af4eb
TT		 1444
1445 addrval = value_allocate_space_in_inferior (TYPE_LENGTH (slice));
1446 addr = value_as_long (addrval);
1447 tem = value_at_lazy (slice, addr);
1448
1449 value_assign (value_field (tem, 0), value_addr (result));
1450 value_assign (value_field (tem, 1),
1451 value_from_longest (usize, high - low));
1452
1453 result = value_at_lazy (slice, addr);
1454 }
1455 else
1456 result = value_addr (result);
1457 }
1458
1459 return result;
1460}
1461
1462/* evaluate_exp implementation for Rust. */
1463
1464static struct value *
1465rust_evaluate_subexp (struct type *expect_type, struct expression *exp,
1466 int *pos, enum noside noside)
1467{
1468 struct value *result;
1469
1470 switch (exp->elts[*pos].opcode)
1471 {
71a3c369
TT		 1472 case UNOP_IND:
1473 {
1474 if (noside != EVAL_NORMAL)
1475 result = evaluate_subexp_standard (expect_type, exp, pos, noside);
1476 else
1477 {
1478 ++*pos;
1479 struct value *value = evaluate_subexp (expect_type, exp, pos,
1480 noside);
1481
1482 struct value *trait_ptr = rust_get_trait_object_pointer (value);
1483 if (trait_ptr != NULL)
1484 value = trait_ptr;
1485
1486 result = value_ind (value);
1487 }
1488 }
1489 break;
1490
c44af4eb
TT		 1491 case UNOP_COMPLEMENT:
1492 {
1493 struct value *value;
1494
1495 ++*pos;
1496 value = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1497 if (noside == EVAL_SKIP)
1498 {
1499 /* Preserving the type is enough. */
1500 return value;
1501 }
1502 if (TYPE_CODE (value_type (value)) == TYPE_CODE_BOOL)
1503 result = value_from_longest (value_type (value),
1504 value_logical_not (value));
1505 else
1506 result = value_complement (value);
1507 }
1508 break;
1509
1510 case BINOP_SUBSCRIPT:
1511 result = rust_subscript (exp, pos, noside, 0);
1512 break;
1513
1514 case OP_FUNCALL:
1515 result = rust_evaluate_funcall (exp, pos, noside);
1516 break;
1517
1518 case OP_AGGREGATE:
1519 {
1520 int pc = (*pos)++;
1521 struct type *type = exp->elts[pc + 1].type;
1522 int arglen = longest_to_int (exp->elts[pc + 2].longconst);
1523 int i;
1524 CORE_ADDR addr = 0;
1525 struct value *addrval = NULL;
1526
1527 *pos += 3;
1528
1529 if (noside == EVAL_NORMAL)
1530 {
1531 addrval = value_allocate_space_in_inferior (TYPE_LENGTH (type));
1532 addr = value_as_long (addrval);
1533 result = value_at_lazy (type, addr);
1534 }
1535
1536 if (arglen > 0 && exp->elts[*pos].opcode == OP_OTHERS)
1537 {
1538 struct value *init;
1539
1540 ++*pos;
1541 init = rust_evaluate_subexp (NULL, exp, pos, noside);
1542 if (noside == EVAL_NORMAL)
1543 {
1544 /* This isn't quite right but will do for the time
1545 being, seeing that we can't implement the Copy
1546 trait anyway. */
1547 value_assign (result, init);
1548 }
1549
1550 --arglen;
1551 }
1552
1553 gdb_assert (arglen % 2 == 0);
1554 for (i = 0; i < arglen; i += 2)
1555 {
1556 int len;
1557 const char *fieldname;
1558 struct value *value, *field;
1559
1560 gdb_assert (exp->elts[*pos].opcode == OP_NAME);
1561 ++*pos;
1562 len = longest_to_int (exp->elts[*pos].longconst);
1563 ++*pos;
1564 fieldname = &exp->elts[*pos].string;
1565 *pos += 2 + BYTES_TO_EXP_ELEM (len + 1);
1566
1567 value = rust_evaluate_subexp (NULL, exp, pos, noside);
1568 if (noside == EVAL_NORMAL)
1569 {
1570 field = value_struct_elt (&result, NULL, fieldname, NULL,
1571 "structure");
1572 value_assign (field, value);
1573 }
1574 }
1575
1576 if (noside == EVAL_SKIP)
1577 return value_from_longest (builtin_type (exp->gdbarch)->builtin_int,
1578 1);
1579 else if (noside == EVAL_AVOID_SIDE_EFFECTS)
1580 result = allocate_value (type);
1581 else
1582 result = value_at_lazy (type, addr);
1583 }
1584 break;
1585
1586 case OP_RUST_ARRAY:
1587 {
8d49165d 1588 (*pos)++;
c44af4eb
TT		 1589 int copies;
1590 struct value *elt;
1591 struct value *ncopies;
1592
1593 elt = rust_evaluate_subexp (NULL, exp, pos, noside);
1594 ncopies = rust_evaluate_subexp (NULL, exp, pos, noside);
1595 copies = value_as_long (ncopies);
1596 if (copies < 0)
1597 error (_("Array with negative number of elements"));
1598
1599 if (noside == EVAL_NORMAL)
1600 {
c44af4eb 1601 int i;
ab8b80a8 1602 std::vector<struct value *> eltvec (copies);
c44af4eb
TT		 1603
1604 for (i = 0; i < copies; ++i)
1605 eltvec[i] = elt;
ab8b80a8 1606 result = value_array (0, copies - 1, eltvec.data ());
c44af4eb
TT		 1607 }
1608 else
1609 {
1610 struct type *arraytype
1611 = lookup_array_range_type (value_type (elt), 0, copies - 1);
1612 result = allocate_value (arraytype);
1613 }
1614 }
1615 break;
1616
1617 case STRUCTOP_ANONYMOUS:
1618 {
1619 /* Anonymous field access, i.e. foo.1. */
1620 struct value *lhs;
1621 int pc, field_number, nfields;
8d49165d 1622 struct type *type;
c44af4eb
TT		 1623
1624 pc = (*pos)++;
1625 field_number = longest_to_int (exp->elts[pc + 1].longconst);
1626 (*pos) += 2;
1627 lhs = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1628
1629 type = value_type (lhs);
c9317f21 1630
c9317f21
TT		 1631 if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
1632 {
1633 struct type *outer_type = NULL;
1634
1635 if (rust_enum_p (type))
c44af4eb 1636 {
098b2108
TT		 1637 if (rust_empty_enum_p (type))
1638 error (_("Cannot access field %d of empty enum %s"),
1639 field_number, TYPE_NAME (type));
1640
c9317f21
TT		 1641 const gdb_byte *valaddr = value_contents (lhs);
1642 struct field *variant_field = rust_enum_variant (type, valaddr);
1643
1644 struct value *union_value = value_primitive_field (lhs, 0, 0,
1645 type);
1646
1647 int fieldno = (variant_field
1648 - &TYPE_FIELD (value_type (union_value), 0));
1649 lhs = value_primitive_field (union_value, 0, fieldno,
1650 value_type (union_value));
1651 outer_type = type;
1652 type = value_type (lhs);
c44af4eb
TT		 1653 }
1654
c44af4eb 1655 /* Tuples and tuple structs */
c9317f21 1656 nfields = TYPE_NFIELDS (type);
c44af4eb
TT		 1657
1658 if (field_number >= nfields || field_number < 0)
c9317f21
TT		 1659 {
1660 if (outer_type != NULL)
1661 error(_("Cannot access field %d of variant %s::%s, "
1662 "there are only %d fields"),
e86ca25f
TT		 1663 field_number, TYPE_NAME (outer_type),
1664 rust_last_path_segment (TYPE_NAME (type)),
c9317f21
TT		 1665 nfields);
1666 else
1667 error(_("Cannot access field %d of %s, "
1668 "there are only %d fields"),
e86ca25f 1669 field_number, TYPE_NAME (type), nfields);
c9317f21 1670 }
c44af4eb
TT		 1671
1672 /* Tuples are tuple structs too. */
1673 if (!rust_tuple_struct_type_p (type))
c9317f21
TT		 1674 {
1675 if (outer_type != NULL)
1676 error(_("Variant %s::%s is not a tuple variant"),
e86ca25f
TT		 1677 TYPE_NAME (outer_type),
1678 rust_last_path_segment (TYPE_NAME (type)));
c9317f21
TT		 1679 else
1680 error(_("Attempting to access anonymous field %d "
1681 "of %s, which is not a tuple, tuple struct, or "
1682 "tuple-like variant"),
e86ca25f 1683 field_number, TYPE_NAME (type));
c9317f21 1684 }
c44af4eb
TT		 1685
1686 result = value_primitive_field (lhs, 0, field_number, type);
1687 }
1688 else
1689 error(_("Anonymous field access is only allowed on tuples, \
1690tuple structs, and tuple-like enum variants"));
1691 }
1692 break;
1693
1694 case STRUCTOP_STRUCT:
1695 {
6830f270 1696 struct value *lhs;
c44af4eb
TT		 1697 struct type *type;
1698 int tem, pc;
1699
1700 pc = (*pos)++;
1701 tem = longest_to_int (exp->elts[pc + 1].longconst);
1702 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
1703 lhs = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1704
6830f270 1705 const char *field_name = &exp->elts[pc + 2].string;
c44af4eb 1706 type = value_type (lhs);
c9317f21 1707 if (TYPE_CODE (type) == TYPE_CODE_STRUCT && rust_enum_p (type))
c44af4eb 1708 {
098b2108
TT		 1709 if (rust_empty_enum_p (type))
1710 error (_("Cannot access field %s of empty enum %s"),
1711 field_name, TYPE_NAME (type));
1712
c9317f21
TT		 1713 const gdb_byte *valaddr = value_contents (lhs);
1714 struct field *variant_field = rust_enum_variant (type, valaddr);
1715
1716 struct value *union_value = value_primitive_field (lhs, 0, 0,
1717 type);
1718
1719 int fieldno = (variant_field
1720 - &TYPE_FIELD (value_type (union_value), 0));
1721 lhs = value_primitive_field (union_value, 0, fieldno,
1722 value_type (union_value));
1723
1724 struct type *outer_type = type;
1725 type = value_type (lhs);
1726 if (rust_tuple_type_p (type) || rust_tuple_struct_type_p (type))
4a3fe98f 1727 error (_("Attempting to access named field %s of tuple "
c9317f21 1728 "variant %s::%s, which has only anonymous fields"),
4a3fe98f 1729 field_name, TYPE_NAME (outer_type),
c9317f21
TT		 1730 rust_last_path_segment (TYPE_NAME (type)));
1731
1732 TRY
c44af4eb 1733 {
c9317f21
TT		 1734 result = value_struct_elt (&lhs, NULL, field_name,
1735 NULL, "structure");
c44af4eb 1736 }
c9317f21
TT		 1737 CATCH (except, RETURN_MASK_ERROR)
1738 {
1739 error (_("Could not find field %s of struct variant %s::%s"),
e86ca25f 1740 field_name, TYPE_NAME (outer_type),
c9317f21
TT		 1741 rust_last_path_segment (TYPE_NAME (type)));
1742 }
1743 END_CATCH
c44af4eb
TT		 1744 }
1745 else
c9317f21
TT		 1746 result = value_struct_elt (&lhs, NULL, field_name, NULL, "structure");
1747 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1748 result = value_zero (value_type (result), VALUE_LVAL (result));
c44af4eb
TT		 1749 }
1750 break;
1751
01739a3b 1752 case OP_RANGE:
c44af4eb
TT		 1753 result = rust_range (exp, pos, noside);
1754 break;
1755
1756 case UNOP_ADDR:
1757 /* We might have &array[range], in which case we need to make a
1758 slice. */
1759 if (exp->elts[*pos + 1].opcode == BINOP_SUBSCRIPT)
1760 {
1761 ++*pos;
1762 result = rust_subscript (exp, pos, noside, 1);
1763 break;
1764 }
1765 /* Fall through. */
1766 default:
1767 result = evaluate_subexp_standard (expect_type, exp, pos, noside);
1768 break;
1769 }
1770
1771 return result;
1772}
1773
1774/* operator_length implementation for Rust. */
1775
1776static void
1777rust_operator_length (const struct expression *exp, int pc, int *oplenp,
1778 int *argsp)
1779{
1780 int oplen = 1;
1781 int args = 0;
1782
1783 switch (exp->elts[pc - 1].opcode)
1784 {
1785 case OP_AGGREGATE:
1786 /* We handle aggregate as a type and argument count. The first
1787 argument might be OP_OTHERS. After that the arguments
1788 alternate: first an OP_NAME, then an expression. */
1789 oplen = 4;
1790 args = longest_to_int (exp->elts[pc - 2].longconst);
1791 break;
1792
1793 case OP_OTHERS:
1794 oplen = 1;
1795 args = 1;
1796 break;
1797
1798 case STRUCTOP_ANONYMOUS:
1799 oplen = 3;
1800 args = 1;
1801 break;
1802
1803 case OP_RUST_ARRAY:
1804 oplen = 1;
1805 args = 2;
1806 break;
1807
1808 default:
1809 operator_length_standard (exp, pc, oplenp, argsp);
1810 return;
1811 }
1812
1813 *oplenp = oplen;
1814 *argsp = args;
1815}
1816
1817/* op_name implementation for Rust. */
1818
a121b7c1 1819static const char *
c44af4eb
TT		 1820rust_op_name (enum exp_opcode opcode)
1821{
1822 switch (opcode)
1823 {
1824 case OP_AGGREGATE:
1825 return "OP_AGGREGATE";
1826 case OP_OTHERS:
1827 return "OP_OTHERS";
1828 default:
1829 return op_name_standard (opcode);
1830 }
1831}
1832
1833/* dump_subexp_body implementation for Rust. */
1834
1835static int
1836rust_dump_subexp_body (struct expression *exp, struct ui_file *stream,
1837 int elt)
1838{
1839 switch (exp->elts[elt].opcode)
1840 {
1841 case OP_AGGREGATE:
1842 {
1843 int length = longest_to_int (exp->elts[elt + 2].longconst);
1844 int i;
1845
1846 fprintf_filtered (stream, "Type @");
1847 gdb_print_host_address (exp->elts[elt + 1].type, stream);
1848 fprintf_filtered (stream, " (");
1849 type_print (exp->elts[elt + 1].type, NULL, stream, 0);
1850 fprintf_filtered (stream, "), length %d", length);
1851
1852 elt += 4;
1853 for (i = 0; i < length; ++i)
1854 elt = dump_subexp (exp, stream, elt);
1855 }
1856 break;
1857
1858 case OP_STRING:
1859 case OP_NAME:
1860 {
1861 LONGEST len = exp->elts[elt + 1].longconst;
1862
1863 fprintf_filtered (stream, "%s: %s",
1864 (exp->elts[elt].opcode == OP_STRING
1865 ? "string" : "name"),
1866 &exp->elts[elt + 2].string);
1867 elt += 4 + BYTES_TO_EXP_ELEM (len + 1);
1868 }
1869 break;
1870
1871 case OP_OTHERS:
1872 elt = dump_subexp (exp, stream, elt + 1);
1873 break;
1874
1875 case STRUCTOP_ANONYMOUS:
1876 {
1877 int field_number;
1878
68f2f2e3 1879 field_number = longest_to_int (exp->elts[elt + 1].longconst);
c44af4eb
TT		 1880
1881 fprintf_filtered (stream, "Field number: %d", field_number);
68f2f2e3 1882 elt = dump_subexp (exp, stream, elt + 3);
c44af4eb
TT		 1883 }
1884 break;
1885
1886 case OP_RUST_ARRAY:
68f2f2e3 1887 ++elt;
c44af4eb
TT		 1888 break;
1889
1890 default:
1891 elt = dump_subexp_body_standard (exp, stream, elt);
1892 break;
1893 }
1894
1895 return elt;
1896}
1897
1898/* print_subexp implementation for Rust. */
1899
1900static void
1901rust_print_subexp (struct expression *exp, int *pos, struct ui_file *stream,
1902 enum precedence prec)
1903{
1904 switch (exp->elts[*pos].opcode)
1905 {
1906 case OP_AGGREGATE:
1907 {
1908 int length = longest_to_int (exp->elts[*pos + 2].longconst);
1909 int i;
1910
1911 type_print (exp->elts[*pos + 1].type, "", stream, 0);
1912 fputs_filtered (" { ", stream);
1913
1914 *pos += 4;
1915 for (i = 0; i < length; ++i)
1916 {
1917 rust_print_subexp (exp, pos, stream, prec);
1918 fputs_filtered (", ", stream);
1919 }
1920 fputs_filtered (" }", stream);
1921 }
1922 break;
1923
1924 case OP_NAME:
1925 {
1926 LONGEST len = exp->elts[*pos + 1].longconst;
1927
1928 fputs_filtered (&exp->elts[*pos + 2].string, stream);
1929 *pos += 4 + BYTES_TO_EXP_ELEM (len + 1);
1930 }
1931 break;
1932
1933 case OP_OTHERS:
1934 {
1935 fputs_filtered ("<<others>> (", stream);
1936 ++*pos;
1937 rust_print_subexp (exp, pos, stream, prec);
1938 fputs_filtered (")", stream);
1939 }
1940 break;
1941
1942 case STRUCTOP_ANONYMOUS:
1943 {
1944 int tem = longest_to_int (exp->elts[*pos + 1].longconst);
1945
1946 (*pos) += 3;
1947 print_subexp (exp, pos, stream, PREC_SUFFIX);
1948 fprintf_filtered (stream, ".%d", tem);
1949 }
256afbc2 1950 break;
c44af4eb
TT		 1951
1952 case OP_RUST_ARRAY:
1953 ++*pos;
1954 fprintf_filtered (stream, "[");
1955 rust_print_subexp (exp, pos, stream, prec);
1956 fprintf_filtered (stream, "; ");
1957 rust_print_subexp (exp, pos, stream, prec);
1958 fprintf_filtered (stream, "]");
1959 break;
1960
1961 default:
1962 print_subexp_standard (exp, pos, stream, prec);
1963 break;
1964 }
1965}
1966
1967/* operator_check implementation for Rust. */
1968
1969static int
1970rust_operator_check (struct expression *exp, int pos,
1971 int (*objfile_func) (struct objfile *objfile,
1972 void *data),
1973 void *data)
1974{
1975 switch (exp->elts[pos].opcode)
1976 {
1977 case OP_AGGREGATE:
1978 {
1979 struct type *type = exp->elts[pos + 1].type;
1980 struct objfile *objfile = TYPE_OBJFILE (type);
1981
1982 if (objfile != NULL && (*objfile_func) (objfile, data))
1983 return 1;
1984 }
1985 break;
1986
1987 case OP_OTHERS:
1988 case OP_NAME:
1989 case OP_RUST_ARRAY:
1990 break;
1991
1992 default:
1993 return operator_check_standard (exp, pos, objfile_func, data);
1994 }
1995
1996 return 0;
1997}
1998
1999\f
2000
2001/* Implementation of la_lookup_symbol_nonlocal for Rust. */
2002
2003static struct block_symbol
2004rust_lookup_symbol_nonlocal (const struct language_defn *langdef,
2005 const char *name,
2006 const struct block *block,
2007 const domain_enum domain)
2008{
2009 struct block_symbol result = {NULL, NULL};
2010
2011 if (symbol_lookup_debug)
2012 {
2013 fprintf_unfiltered (gdb_stdlog,
2014 "rust_lookup_symbol_non_local"
2015 " (%s, %s (scope %s), %s)\n",
2016 name, host_address_to_string (block),
2017 block_scope (block), domain_name (domain));
2018 }
2019
2020 /* Look up bare names in the block's scope. */
fcfcc376 2021 std::string scopedname;
c44af4eb
TT		 2022 if (name[cp_find_first_component (name)] == '\0')
2023 {
2024 const char *scope = block_scope (block);
2025
2026 if (scope[0] != '\0')
2027 {
fcfcc376
TT		 2028 scopedname = std::string (scope) + "::" + name;
2029 name = scopedname.c_str ();
c44af4eb 2030 }
fcfcc376
TT		 2031 else
2032 name = NULL;
2033 }
2034
2035 if (name != NULL)
2036 {
2037 result = lookup_symbol_in_static_block (name, block, domain);
2038 if (result.symbol == NULL)
2039 result = lookup_global_symbol (name, block, domain);
c44af4eb
TT		 2040 }
2041 return result;
2042}
2043
2044\f
2045
8b302db8
TT		 2046/* la_sniff_from_mangled_name for Rust. */
2047
2048static int
2049rust_sniff_from_mangled_name (const char *mangled, char **demangled)
2050{
2051 *demangled = gdb_demangle (mangled, DMGL_PARAMS | DMGL_ANSI);
2052 return *demangled != NULL;
2053}
2054
2055\f
2056
43cc5389
TT		 2057/* la_watch_location_expression for Rust. */
2058
2059static gdb::unique_xmalloc_ptr<char>
2060rust_watch_location_expression (struct type *type, CORE_ADDR addr)
2061{
2062 type = check_typedef (TYPE_TARGET_TYPE (check_typedef (type)));
2063 std::string name = type_to_string (type);
2064 return gdb::unique_xmalloc_ptr<char>
2065 (xstrprintf ("*(%s as *mut %s)", core_addr_to_string (addr),
2066 name.c_str ()));
2067}
2068
2069\f
2070
c44af4eb
TT		 2071static const struct exp_descriptor exp_descriptor_rust =
2072{
2073 rust_print_subexp,
2074 rust_operator_length,
2075 rust_operator_check,
2076 rust_op_name,
2077 rust_dump_subexp_body,
2078 rust_evaluate_subexp
2079};
2080
56618e20
TT		 2081static const char *rust_extensions[] =
2082{
2083 ".rs", NULL
2084};
2085
47e77640 2086extern const struct language_defn rust_language_defn =
c44af4eb
TT		 2087{
2088 "rust",
2089 "Rust",
2090 language_rust,
2091 range_check_on,
2092 case_sensitive_on,
2093 array_row_major,
2094 macro_expansion_no,
56618e20 2095 rust_extensions,
c44af4eb
TT		 2096 &exp_descriptor_rust,
2097 rust_parse,
c44af4eb
TT		 2098 null_post_parser,
2099 rust_printchar, /* Print a character constant */
2100 rust_printstr, /* Function to print string constant */
2101 rust_emitchar, /* Print a single char */
2102 rust_print_type, /* Print a type using appropriate syntax */
2103 rust_print_typedef, /* Print a typedef using appropriate syntax */
2104 rust_val_print, /* Print a value using appropriate syntax */
2105 c_value_print, /* Print a top-level value */
2106 default_read_var_value, /* la_read_var_value */
2107 NULL, /* Language specific skip_trampoline */
2108 NULL, /* name_of_this */
59cc4834 2109 false, /* la_store_sym_names_in_linkage_form_p */
c44af4eb
TT		 2110 rust_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
2111 basic_lookup_transparent_type,/* lookup_transparent_type */
2112 gdb_demangle, /* Language specific symbol demangler */
8b302db8 2113 rust_sniff_from_mangled_name,
c44af4eb
TT		 2114 NULL, /* Language specific
2115 class_name_from_physname */
2116 c_op_print_tab, /* expression operators for printing */
2117 1, /* c-style arrays */
2118 0, /* String lower bound */
2119 default_word_break_characters,
eb3ff9a5 2120 default_collect_symbol_completion_matches,
c44af4eb
TT		 2121 rust_language_arch_info,
2122 default_print_array_index,
2123 default_pass_by_reference,
2124 c_get_string,
43cc5389 2125 rust_watch_location_expression,
b5ec771e 2126 NULL, /* la_get_symbol_name_matcher */
c44af4eb 2127 iterate_over_symbols,
5ffa0793 2128 default_search_name_hash,
c44af4eb
TT		 2129 &default_varobj_ops,
2130 NULL,
2131 NULL,
2132 LANG_MAGIC
2133};
GDB Binutils - Deliverables
This page took 0.363528 seconds and 4 git commands to generate.