gdb/rust-lang.c

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