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