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