gdb/rust-lang.c

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