gdb/rust-lang.c

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