gdb/rust-lang.c

   1 /* Rust language support routines for GDB, the GNU debugger.
   2
   3    Copyright (C) 2016-2022 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21
  22 #include <ctype.h>
  23
  24 #include "block.h"
  25 #include "c-lang.h"
  26 #include "charset.h"
  27 #include "cp-support.h"
  28 #include "demangle.h"
  29 #include "gdbarch.h"
  30 #include "infcall.h"
  31 #include "objfiles.h"
  32 #include "psymtab.h"
  33 #include "rust-lang.h"
  34 #include "typeprint.h"
  35 #include "valprint.h"
  36 #include "varobj.h"
  37 #include <algorithm>
  38 #include <string>
  39 #include <vector>
  40 #include "cli/cli-style.h"
  41 #include "parser-defs.h"
  42 #include "rust-exp.h"
  43
  44 /* See rust-lang.h.  */
  45
  46 const char *
  47 rust_last_path_segment (const char *path)
  48 {
  49   const char *result = strrchr (path, ':');
  50
  51   if (result == NULL)
  52     return path;
  53   return result + 1;
  54 }
  55
  56 /* See rust-lang.h.  */
  57
  58 std::string
  59 rust_crate_for_block (const struct block *block)
  60 {
  61   const char *scope = block_scope (block);
  62
  63   if (scope[0] == '\0')
  64     return std::string ();
  65
  66   return std::string (scope, cp_find_first_component (scope));
  67 }
  68
  69 /* Return true if TYPE, which must be a struct type, represents a Rust
  70    enum.  */
  71
  72 static bool
  73 rust_enum_p (struct type *type)
  74 {
  75   /* is_dynamic_type will return true if any field has a dynamic
  76      attribute -- but we only want to check the top level.  */
  77   return TYPE_HAS_VARIANT_PARTS (type);
  78 }
  79
  80 /* Return true if TYPE, which must be an already-resolved enum type,
  81    has no variants.  */
  82
  83 static bool
  84 rust_empty_enum_p (const struct type *type)
  85 {
  86   return type->num_fields () == 0;
  87 }
  88
  89 /* Given an already-resolved enum type and contents, find which
  90    variant is active.  */
  91
  92 static int
  93 rust_enum_variant (struct type *type)
  94 {
  95   /* The active variant is simply the first non-artificial field.  */
  96   for (int i = 0; i < type->num_fields (); ++i)
  97     if (!TYPE_FIELD_ARTIFICIAL (type, i))
  98       return i;
  99
 100   /* Perhaps we could get here by trying to print an Ada variant
 101      record in Rust mode.  Unlikely, but an error is safer than an
 102      assert.  */
 103   error (_("Could not find active enum variant"));
 104 }
 105
 106 /* See rust-lang.h.  */
 107
 108 bool
 109 rust_tuple_type_p (struct type *type)
 110 {
 111   /* The current implementation is a bit of a hack, but there's
 112      nothing else in the debuginfo to distinguish a tuple from a
 113      struct.  */
 114   return (type->code () == TYPE_CODE_STRUCT
 115           && type->name () != NULL
 116           && type->name ()[0] == '(');
 117 }
 118
 119 /* Return true if all non-static fields of a structlike type are in a
 120    sequence like __0, __1, __2.  */
 121
 122 static bool
 123 rust_underscore_fields (struct type *type)
 124 {
 125   int i, field_number;
 126
 127   field_number = 0;
 128
 129   if (type->code () != TYPE_CODE_STRUCT)
 130     return false;
 131   for (i = 0; i < type->num_fields (); ++i)
 132     {
 133       if (!field_is_static (&type->field (i)))
 134         {
 135           char buf[20];
 136
 137           xsnprintf (buf, sizeof (buf), "__%d", field_number);
 138           if (strcmp (buf, type->field (i).name ()) != 0)
 139             return false;
 140           field_number++;
 141         }
 142     }
 143   return true;
 144 }
 145
 146 /* See rust-lang.h.  */
 147
 148 bool
 149 rust_tuple_struct_type_p (struct type *type)
 150 {
 151   /* This is just an approximation until DWARF can represent Rust more
 152      precisely.  We exclude zero-length structs because they may not
 153      be tuple structs, and there's no way to tell.  */
 154   return type->num_fields () > 0 && rust_underscore_fields (type);
 155 }
 156
 157 /* Return true if TYPE is a slice type, otherwise false.  */
 158
 159 static bool
 160 rust_slice_type_p (struct type *type)
 161 {
 162   return (type->code () == TYPE_CODE_STRUCT
 163           && type->name () != NULL
 164           && (strncmp (type->name (), "&[", 2) == 0
 165               || strcmp (type->name (), "&str") == 0));
 166 }
 167
 168 /* Return true if TYPE is a range type, otherwise false.  */
 169
 170 static bool
 171 rust_range_type_p (struct type *type)
 172 {
 173   int i;
 174
 175   if (type->code () != TYPE_CODE_STRUCT
 176       || type->num_fields () > 2
 177       || type->name () == NULL
 178       || strstr (type->name (), "::Range") == NULL)
 179     return false;
 180
 181   if (type->num_fields () == 0)
 182     return true;
 183
 184   i = 0;
 185   if (strcmp (type->field (0).name (), "start") == 0)
 186     {
 187       if (type->num_fields () == 1)
 188         return true;
 189       i = 1;
 190     }
 191   else if (type->num_fields () == 2)
 192     {
 193       /* First field had to be "start".  */
 194       return false;
 195     }
 196
 197   return strcmp (type->field (i).name (), "end") == 0;
 198 }
 199
 200 /* Return true if TYPE is an inclusive range type, otherwise false.
 201    This is only valid for types which are already known to be range
 202    types.  */
 203
 204 static bool
 205 rust_inclusive_range_type_p (struct type *type)
 206 {
 207   return (strstr (type->name (), "::RangeInclusive") != NULL
 208           || strstr (type->name (), "::RangeToInclusive") != NULL);
 209 }
 210
 211 /* Return true if TYPE seems to be the type "u8", otherwise false.  */
 212
 213 static bool
 214 rust_u8_type_p (struct type *type)
 215 {
 216   return (type->code () == TYPE_CODE_INT
 217           && type->is_unsigned ()
 218           && TYPE_LENGTH (type) == 1);
 219 }
 220
 221 /* Return true if TYPE is a Rust character type.  */
 222
 223 static bool
 224 rust_chartype_p (struct type *type)
 225 {
 226   return (type->code () == TYPE_CODE_CHAR
 227           && TYPE_LENGTH (type) == 4
 228           && type->is_unsigned ());
 229 }
 230
 231 /* If VALUE represents a trait object pointer, return the underlying
 232    pointer with the correct (i.e., runtime) type.  Otherwise, return
 233    NULL.  */
 234
 235 static struct value *
 236 rust_get_trait_object_pointer (struct value *value)
 237 {
 238   struct type *type = check_typedef (value_type (value));
 239
 240   if (type->code () != TYPE_CODE_STRUCT || type->num_fields () != 2)
 241     return NULL;
 242
 243   /* Try to be a bit resilient if the ABI changes.  */
 244   int vtable_field = 0;
 245   for (int i = 0; i < 2; ++i)
 246     {
 247       if (strcmp (type->field (i).name (), "vtable") == 0)
 248         vtable_field = i;
 249       else if (strcmp (type->field (i).name (), "pointer") != 0)
 250         return NULL;
 251     }
 252
 253   CORE_ADDR vtable = value_as_address (value_field (value, vtable_field));
 254   struct symbol *symbol = find_symbol_at_address (vtable);
 255   if (symbol == NULL || symbol->subclass != SYMBOL_RUST_VTABLE)
 256     return NULL;
 257
 258   struct rust_vtable_symbol *vtable_sym
 259     = static_cast<struct rust_vtable_symbol *> (symbol);
 260   struct type *pointer_type = lookup_pointer_type (vtable_sym->concrete_type);
 261   return value_cast (pointer_type, value_field (value, 1 - vtable_field));
 262 }
 263
 264 \f
 265
 266 /* See language.h.  */
 267
 268 void
 269 rust_language::printstr (struct ui_file *stream, struct type *type,
 270                          const gdb_byte *string, unsigned int length,
 271                          const char *user_encoding, int force_ellipses,
 272                          const struct value_print_options *options) const
 273 {
 274   /* Rust always uses UTF-8, but let the caller override this if need
 275      be.  */
 276   const char *encoding = user_encoding;
 277   if (user_encoding == NULL || !*user_encoding)
 278     {
 279       /* In Rust strings, characters are "u8".  */
 280       if (rust_u8_type_p (type))
 281         encoding = "UTF-8";
 282       else
 283         {
 284           /* This is probably some C string, so let's let C deal with
 285              it.  */
 286           c_printstr (stream, type, string, length, user_encoding,
 287                       force_ellipses, options);
 288           return;
 289         }
 290     }
 291
 292   /* This is not ideal as it doesn't use our character printer.  */
 293   generic_printstr (stream, type, string, length, encoding, force_ellipses,
 294                     '"', 0, options);
 295 }
 296
 297 \f
 298
 299 /* Helper function to print a string slice.  */
 300
 301 static void
 302 rust_val_print_str (struct ui_file *stream, struct value *val,
 303                     const struct value_print_options *options)
 304 {
 305   struct value *base = value_struct_elt (&val, {}, "data_ptr", NULL,
 306                                          "slice");
 307   struct value *len = value_struct_elt (&val, {}, "length", NULL, "slice");
 308
 309   val_print_string (TYPE_TARGET_TYPE (value_type (base)), "UTF-8",
 310                     value_as_address (base), value_as_long (len), stream,
 311                     options);
 312 }
 313
 314 /* See rust-lang.h.  */
 315
 316 void
 317 rust_language::val_print_struct
 318         (struct value *val, struct ui_file *stream, int recurse,
 319          const struct value_print_options *options) const
 320 {
 321   int i;
 322   int first_field;
 323   struct type *type = check_typedef (value_type (val));
 324
 325   if (rust_slice_type_p (type) && strcmp (type->name (), "&str") == 0)
 326     {
 327       /* If what we are printing here is actually a string within a
 328          structure then VAL will be the original parent value, while TYPE
 329          will be the type of the structure representing the string we want
 330          to print.
 331          However, RUST_VAL_PRINT_STR looks up the fields of the string
 332          inside VAL, assuming that VAL is the string.
 333          So, recreate VAL as a value representing just the string.  */
 334       val = value_at_lazy (type, value_address (val));
 335       rust_val_print_str (stream, val, options);
 336       return;
 337     }
 338
 339   bool is_tuple = rust_tuple_type_p (type);
 340   bool is_tuple_struct = !is_tuple && rust_tuple_struct_type_p (type);
 341   struct value_print_options opts;
 342
 343   if (!is_tuple)
 344     {
 345       if (type->name () != NULL)
 346         fprintf_filtered (stream, "%s", type->name ());
 347
 348       if (type->num_fields () == 0)
 349         return;
 350
 351       if (type->name () != NULL)
 352         fputs_filtered (" ", stream);
 353     }
 354
 355   if (is_tuple || is_tuple_struct)
 356     fputs_filtered ("(", stream);
 357   else
 358     fputs_filtered ("{", stream);
 359
 360   opts = *options;
 361   opts.deref_ref = 0;
 362
 363   first_field = 1;
 364   for (i = 0; i < type->num_fields (); ++i)
 365     {
 366       if (field_is_static (&type->field (i)))
 367         continue;
 368
 369       if (!first_field)
 370         fputs_filtered (",", stream);
 371
 372       if (options->prettyformat)
 373         {
 374           fputs_filtered ("\n", stream);
 375           print_spaces_filtered (2 + 2 * recurse, stream);
 376         }
 377       else if (!first_field)
 378         fputs_filtered (" ", stream);
 379
 380       first_field = 0;
 381
 382       if (!is_tuple && !is_tuple_struct)
 383         {
 384           fputs_styled (type->field (i).name (),
 385                         variable_name_style.style (), stream);
 386           fputs_filtered (": ", stream);
 387         }
 388
 389       common_val_print (value_field (val, i), stream, recurse + 1, &opts,
 390                         this);
 391     }
 392
 393   if (options->prettyformat)
 394     {
 395       fputs_filtered ("\n", stream);
 396       print_spaces_filtered (2 * recurse, stream);
 397     }
 398
 399   if (is_tuple || is_tuple_struct)
 400     fputs_filtered (")", stream);
 401   else
 402     fputs_filtered ("}", stream);
 403 }
 404
 405 /* See rust-lang.h.  */
 406
 407 void
 408 rust_language::print_enum (struct value *val, struct ui_file *stream,
 409                            int recurse,
 410                            const struct value_print_options *options) const
 411 {
 412   struct value_print_options opts = *options;
 413   struct type *type = check_typedef (value_type (val));
 414
 415   opts.deref_ref = 0;
 416
 417   gdb_assert (rust_enum_p (type));
 418   gdb::array_view<const gdb_byte> view
 419     (value_contents_for_printing (val).data (),
 420      TYPE_LENGTH (value_type (val)));
 421   type = resolve_dynamic_type (type, view, value_address (val));
 422
 423   if (rust_empty_enum_p (type))
 424     {
 425       /* Print the enum type name here to be more clear.  */
 426       fprintf_filtered (stream, _("%s {%p[<No data fields>%p]}"),
 427                         type->name (),
 428                         metadata_style.style ().ptr (), nullptr);
 429       return;
 430     }
 431
 432   int variant_fieldno = rust_enum_variant (type);
 433   val = value_field (val, variant_fieldno);
 434   struct type *variant_type = type->field (variant_fieldno).type ();
 435
 436   int nfields = variant_type->num_fields ();
 437
 438   bool is_tuple = rust_tuple_struct_type_p (variant_type);
 439
 440   fprintf_filtered (stream, "%s", variant_type->name ());
 441   if (nfields == 0)
 442     {
 443       /* In case of a nullary variant like 'None', just output
 444          the name. */
 445       return;
 446     }
 447
 448   /* In case of a non-nullary variant, we output 'Foo(x,y,z)'. */
 449   if (is_tuple)
 450     fprintf_filtered (stream, "(");
 451   else
 452     {
 453       /* struct variant.  */
 454       fprintf_filtered (stream, "{");
 455     }
 456
 457   bool first_field = true;
 458   for (int j = 0; j < variant_type->num_fields (); j++)
 459     {
 460       if (!first_field)
 461         fputs_filtered (", ", stream);
 462       first_field = false;
 463
 464       if (!is_tuple)
 465         fprintf_filtered (stream, "%ps: ",
 466                           styled_string (variable_name_style.style (),
 467                                          variant_type->field (j).name ()));
 468
 469       common_val_print (value_field (val, j), stream, recurse + 1, &opts,
 470                         this);
 471     }
 472
 473   if (is_tuple)
 474     fputs_filtered (")", stream);
 475   else
 476     fputs_filtered ("}", stream);
 477 }
 478
 479 static const struct generic_val_print_decorations rust_decorations =
 480 {
 481   /* Complex isn't used in Rust, but we provide C-ish values just in
 482      case.  */
 483   "",
 484   " + ",
 485   " * I",
 486   "true",
 487   "false",
 488   "()",
 489   "[",
 490   "]"
 491 };
 492
 493 /* See language.h.  */
 494
 495 void
 496 rust_language::value_print_inner
 497         (struct value *val, struct ui_file *stream, int recurse,
 498          const struct value_print_options *options) const
 499 {
 500   struct value_print_options opts = *options;
 501   opts.deref_ref = 1;
 502
 503   if (opts.prettyformat == Val_prettyformat_default)
 504     opts.prettyformat = (opts.prettyformat_structs
 505                          ? Val_prettyformat : Val_no_prettyformat);
 506
 507   struct type *type = check_typedef (value_type (val));
 508   switch (type->code ())
 509     {
 510     case TYPE_CODE_PTR:
 511       {
 512         LONGEST low_bound, high_bound;
 513
 514         if (TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_ARRAY
 515             && rust_u8_type_p (TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (type)))
 516             && get_array_bounds (TYPE_TARGET_TYPE (type), &low_bound,
 517                                  &high_bound))
 518           {
 519             /* We have a pointer to a byte string, so just print
 520                that.  */
 521             struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));
 522             CORE_ADDR addr = value_as_address (val);
 523             struct gdbarch *arch = type->arch ();
 524
 525             if (opts.addressprint)
 526               {
 527                 fputs_filtered (paddress (arch, addr), stream);
 528                 fputs_filtered (" ", stream);
 529               }
 530
 531             fputs_filtered ("b", stream);
 532             val_print_string (TYPE_TARGET_TYPE (elttype), "ASCII", addr,
 533                               high_bound - low_bound + 1, stream,
 534                               &opts);
 535             break;
 536           }
 537       }
 538       goto generic_print;
 539
 540     case TYPE_CODE_INT:
 541       /* Recognize the unit type.  */
 542       if (type->is_unsigned () && TYPE_LENGTH (type) == 0
 543           && type->name () != NULL && strcmp (type->name (), "()") == 0)
 544         {
 545           fputs_filtered ("()", stream);
 546           break;
 547         }
 548       goto generic_print;
 549
 550     case TYPE_CODE_STRING:
 551       {
 552         LONGEST low_bound, high_bound;
 553
 554         if (!get_array_bounds (type, &low_bound, &high_bound))
 555           error (_("Could not determine the array bounds"));
 556
 557         /* If we see a plain TYPE_CODE_STRING, then we're printing a
 558            byte string, hence the choice of "ASCII" as the
 559            encoding.  */
 560         fputs_filtered ("b", stream);
 561         printstr (stream, TYPE_TARGET_TYPE (type),
 562                   value_contents_for_printing (val).data (),
 563                   high_bound - low_bound + 1, "ASCII", 0, &opts);
 564       }
 565       break;
 566
 567     case TYPE_CODE_ARRAY:
 568       {
 569         LONGEST low_bound, high_bound;
 570
 571         if (get_array_bounds (type, &low_bound, &high_bound)
 572             && high_bound - low_bound + 1 == 0)
 573           fputs_filtered ("[]", stream);
 574         else
 575           goto generic_print;
 576       }
 577       break;
 578
 579     case TYPE_CODE_UNION:
 580       /* Untagged unions are printed as if they are structs.  Since
 581          the field bit positions overlap in the debuginfo, the code
 582          for printing a union is same as that for a struct, the only
 583          difference is that the input type will have overlapping
 584          fields.  */
 585       val_print_struct (val, stream, recurse, &opts);
 586       break;
 587
 588     case TYPE_CODE_STRUCT:
 589       if (rust_enum_p (type))
 590         print_enum (val, stream, recurse, &opts);
 591       else
 592         val_print_struct (val, stream, recurse, &opts);
 593       break;
 594
 595     default:
 596     generic_print:
 597       /* Nothing special yet.  */
 598       generic_value_print (val, stream, recurse, &opts, &rust_decorations);
 599     }
 600 }
 601
 602 \f
 603
 604 static void
 605 rust_internal_print_type (struct type *type, const char *varstring,
 606                           struct ui_file *stream, int show, int level,
 607                           const struct type_print_options *flags,
 608                           bool for_rust_enum, print_offset_data *podata);
 609
 610 /* Print a struct or union typedef.  */
 611 static void
 612 rust_print_struct_def (struct type *type, const char *varstring,
 613                        struct ui_file *stream, int show, int level,
 614                        const struct type_print_options *flags,
 615                        bool for_rust_enum, print_offset_data *podata)
 616 {
 617   /* Print a tuple type simply.  */
 618   if (rust_tuple_type_p (type))
 619     {
 620       fputs_filtered (type->name (), stream);
 621       return;
 622     }
 623
 624   /* If we see a base class, delegate to C.  */
 625   if (TYPE_N_BASECLASSES (type) > 0)
 626     c_print_type (type, varstring, stream, show, level, flags);
 627
 628   if (flags->print_offsets)
 629     {
 630       /* Temporarily bump the level so that the output lines up
 631          correctly.  */
 632       level += 2;
 633     }
 634
 635   /* Compute properties of TYPE here because, in the enum case, the
 636      rest of the code ends up looking only at the variant part.  */
 637   const char *tagname = type->name ();
 638   bool is_tuple_struct = rust_tuple_struct_type_p (type);
 639   bool is_tuple = rust_tuple_type_p (type);
 640   bool is_enum = rust_enum_p (type);
 641
 642   if (for_rust_enum)
 643     {
 644       /* Already printing an outer enum, so nothing to print here.  */
 645     }
 646   else
 647     {
 648       /* This code path is also used by unions and enums.  */
 649       if (is_enum)
 650         {
 651           fputs_filtered ("enum ", stream);
 652           dynamic_prop *prop = type->dyn_prop (DYN_PROP_VARIANT_PARTS);
 653           if (prop != nullptr && prop->kind () == PROP_TYPE)
 654             type = prop->original_type ();
 655         }
 656       else if (type->code () == TYPE_CODE_STRUCT)
 657         fputs_filtered ("struct ", stream);
 658       else
 659         fputs_filtered ("union ", stream);
 660
 661       if (tagname != NULL)
 662         fputs_filtered (tagname, stream);
 663     }
 664
 665   if (type->num_fields () == 0 && !is_tuple)
 666     return;
 667   if (for_rust_enum && !flags->print_offsets)
 668     fputs_filtered (is_tuple_struct ? "(" : "{", stream);
 669   else
 670     fputs_filtered (is_tuple_struct ? " (\n" : " {\n", stream);
 671
 672   /* When printing offsets, we rearrange the fields into storage
 673      order.  This lets us show holes more clearly.  We work using
 674      field indices here because it simplifies calls to
 675      print_offset_data::update below.  */
 676   std::vector<int> fields;
 677   for (int i = 0; i < type->num_fields (); ++i)
 678     {
 679       if (field_is_static (&type->field (i)))
 680         continue;
 681       if (is_enum && TYPE_FIELD_ARTIFICIAL (type, i))
 682         continue;
 683       fields.push_back (i);
 684     }
 685   if (flags->print_offsets)
 686     std::sort (fields.begin (), fields.end (),
 687                [&] (int a, int b)
 688                {
 689                  return (type->field (a).loc_bitpos ()
 690                          < type->field (b).loc_bitpos ());
 691                });
 692
 693   for (int i : fields)
 694     {
 695       QUIT;
 696
 697       gdb_assert (!field_is_static (&type->field (i)));
 698       gdb_assert (! (is_enum && TYPE_FIELD_ARTIFICIAL (type, i)));
 699
 700       if (flags->print_offsets)
 701         podata->update (type, i, stream);
 702
 703       /* We'd like to print "pub" here as needed, but rustc
 704          doesn't emit the debuginfo, and our types don't have
 705          cplus_struct_type attached.  */
 706
 707       /* For a tuple struct we print the type but nothing
 708          else.  */
 709       if (!for_rust_enum || flags->print_offsets)
 710         print_spaces_filtered (level + 2, stream);
 711       if (is_enum)
 712         fputs_styled (type->field (i).name (), variable_name_style.style (),
 713                       stream);
 714       else if (!is_tuple_struct)
 715         fprintf_filtered (stream, "%ps: ",
 716                           styled_string (variable_name_style.style (),
 717                                          type->field (i).name ()));
 718
 719       rust_internal_print_type (type->field (i).type (), NULL,
 720                                 stream, (is_enum ? show : show - 1),
 721                                 level + 2, flags, is_enum, podata);
 722       if (!for_rust_enum || flags->print_offsets)
 723         fputs_filtered (",\n", stream);
 724       /* Note that this check of "I" is ok because we only sorted the
 725          fields by offset when print_offsets was set, so we won't take
 726          this branch in that case.  */
 727       else if (i + 1 < type->num_fields ())
 728         fputs_filtered (", ", stream);
 729     }
 730
 731   if (flags->print_offsets)
 732     {
 733       /* Undo the temporary level increase we did above.  */
 734       level -= 2;
 735       podata->finish (type, level, stream);
 736       print_spaces_filtered (print_offset_data::indentation, stream);
 737       if (level == 0)
 738         print_spaces_filtered (2, stream);
 739     }
 740   if (!for_rust_enum || flags->print_offsets)
 741     print_spaces_filtered (level, stream);
 742   fputs_filtered (is_tuple_struct ? ")" : "}", stream);
 743 }
 744
 745 /* la_print_type implementation for Rust.  */
 746
 747 static void
 748 rust_internal_print_type (struct type *type, const char *varstring,
 749                           struct ui_file *stream, int show, int level,
 750                           const struct type_print_options *flags,
 751                           bool for_rust_enum, print_offset_data *podata)
 752 {
 753   QUIT;
 754   if (show <= 0
 755       && type->name () != NULL)
 756     {
 757       /* Rust calls the unit type "void" in its debuginfo,
 758          but we don't want to print it as that.  */
 759       if (type->code () == TYPE_CODE_VOID)
 760         fputs_filtered ("()", stream);
 761       else
 762         fputs_filtered (type->name (), stream);
 763       return;
 764     }
 765
 766   type = check_typedef (type);
 767   switch (type->code ())
 768     {
 769     case TYPE_CODE_VOID:
 770       /* If we have an enum, we've already printed the type's
 771          unqualified name, and there is nothing else to print
 772          here.  */
 773       if (!for_rust_enum)
 774         fputs_filtered ("()", stream);
 775       break;
 776
 777     case TYPE_CODE_FUNC:
 778       /* Delegate varargs to the C printer.  */
 779       if (type->has_varargs ())
 780         goto c_printer;
 781
 782       fputs_filtered ("fn ", stream);
 783       if (varstring != NULL)
 784         fputs_filtered (varstring, stream);
 785       fputs_filtered ("(", stream);
 786       for (int i = 0; i < type->num_fields (); ++i)
 787         {
 788           QUIT;
 789           if (i > 0)
 790             fputs_filtered (", ", stream);
 791           rust_internal_print_type (type->field (i).type (), "", stream,
 792                                     -1, 0, flags, false, podata);
 793         }
 794       fputs_filtered (")", stream);
 795       /* If it returns unit, we can omit the return type.  */
 796       if (TYPE_TARGET_TYPE (type)->code () != TYPE_CODE_VOID)
 797         {
 798           fputs_filtered (" -> ", stream);
 799           rust_internal_print_type (TYPE_TARGET_TYPE (type), "", stream,
 800                                     -1, 0, flags, false, podata);
 801         }
 802       break;
 803
 804     case TYPE_CODE_ARRAY:
 805       {
 806         LONGEST low_bound, high_bound;
 807
 808         fputs_filtered ("[", stream);
 809         rust_internal_print_type (TYPE_TARGET_TYPE (type), NULL,
 810                                   stream, show - 1, level, flags, false,
 811                                   podata);
 812
 813         if (type->bounds ()->high.kind () == PROP_LOCEXPR
 814             || type->bounds ()->high.kind () == PROP_LOCLIST)
 815           fprintf_filtered (stream, "; variable length");
 816         else if (get_array_bounds (type, &low_bound, &high_bound))
 817           fprintf_filtered (stream, "; %s",
 818                             plongest (high_bound - low_bound + 1));
 819         fputs_filtered ("]", stream);
 820       }
 821       break;
 822
 823     case TYPE_CODE_UNION:
 824     case TYPE_CODE_STRUCT:
 825       rust_print_struct_def (type, varstring, stream, show, level, flags,
 826                              for_rust_enum, podata);
 827       break;
 828
 829     case TYPE_CODE_ENUM:
 830       {
 831         int len = 0;
 832
 833         fputs_filtered ("enum ", stream);
 834         if (type->name () != NULL)
 835           {
 836             fputs_filtered (type->name (), stream);
 837             fputs_filtered (" ", stream);
 838             len = strlen (type->name ());
 839           }
 840         fputs_filtered ("{\n", stream);
 841
 842         for (int i = 0; i < type->num_fields (); ++i)
 843           {
 844             const char *name = type->field (i).name ();
 845
 846             QUIT;
 847
 848             if (len > 0
 849                 && strncmp (name, type->name (), len) == 0
 850                 && name[len] == ':'
 851                 && name[len + 1] == ':')
 852               name += len + 2;
 853             fprintf_filtered (stream, "%*s%ps,\n",
 854                               level + 2, "",
 855                               styled_string (variable_name_style.style (),
 856                                              name));
 857           }
 858
 859         fputs_filtered ("}", stream);
 860       }
 861       break;
 862
 863     case TYPE_CODE_PTR:
 864       {
 865         if (type->name () != nullptr)
 866           fputs_filtered (type->name (), stream);
 867         else
 868           {
 869             /* We currently can't distinguish between pointers and
 870                references.  */
 871             fputs_filtered ("*mut ", stream);
 872             type_print (TYPE_TARGET_TYPE (type), "", stream, 0);
 873           }
 874       }
 875       break;
 876
 877     default:
 878     c_printer:
 879       c_print_type (type, varstring, stream, show, level, flags);
 880     }
 881 }
 882
 883 \f
 884
 885 /* Like arch_composite_type, but uses TYPE to decide how to allocate
 886    -- either on an obstack or on a gdbarch.  */
 887
 888 static struct type *
 889 rust_composite_type (struct type *original,
 890                      const char *name,
 891                      const char *field1, struct type *type1,
 892                      const char *field2, struct type *type2)
 893 {
 894   struct type *result = alloc_type_copy (original);
 895   int i, nfields, bitpos;
 896
 897   nfields = 0;
 898   if (field1 != NULL)
 899     ++nfields;
 900   if (field2 != NULL)
 901     ++nfields;
 902
 903   result->set_code (TYPE_CODE_STRUCT);
 904   result->set_name (name);
 905
 906   result->set_num_fields (nfields);
 907   result->set_fields
 908     ((struct field *) TYPE_ZALLOC (result, nfields * sizeof (struct field)));
 909
 910   i = 0;
 911   bitpos = 0;
 912   if (field1 != NULL)
 913     {
 914       struct field *field = &result->field (i);
 915
 916       field->set_loc_bitpos (bitpos);
 917       bitpos += TYPE_LENGTH (type1) * TARGET_CHAR_BIT;
 918
 919       field->set_name (field1);
 920       field->set_type (type1);
 921       ++i;
 922     }
 923   if (field2 != NULL)
 924     {
 925       struct field *field = &result->field (i);
 926       unsigned align = type_align (type2);
 927
 928       if (align != 0)
 929         {
 930           int delta;
 931
 932           align *= TARGET_CHAR_BIT;
 933           delta = bitpos % align;
 934           if (delta != 0)
 935             bitpos += align - delta;
 936         }
 937       field->set_loc_bitpos (bitpos);
 938
 939       field->set_name (field2);
 940       field->set_type (type2);
 941       ++i;
 942     }
 943
 944   if (i > 0)
 945     TYPE_LENGTH (result)
 946       = (result->field (i - 1).loc_bitpos () / TARGET_CHAR_BIT +
 947          TYPE_LENGTH (result->field (i - 1).type ()));
 948   return result;
 949 }
 950
 951 /* See rust-lang.h.  */
 952
 953 struct type *
 954 rust_slice_type (const char *name, struct type *elt_type,
 955                  struct type *usize_type)
 956 {
 957   struct type *type;
 958
 959   elt_type = lookup_pointer_type (elt_type);
 960   type = rust_composite_type (elt_type, name,
 961                               "data_ptr", elt_type,
 962                               "length", usize_type);
 963
 964   return type;
 965 }
 966
 967 \f
 968
 969 /* A helper for rust_evaluate_subexp that handles OP_RANGE.  */
 970
 971 struct value *
 972 rust_range (struct type *expect_type, struct expression *exp,
 973             enum noside noside, enum range_flag kind,
 974             struct value *low, struct value *high)
 975 {
 976   struct value *addrval, *result;
 977   CORE_ADDR addr;
 978   struct type *range_type;
 979   struct type *index_type;
 980   struct type *temp_type;
 981   const char *name;
 982
 983   bool inclusive = !(kind & RANGE_HIGH_BOUND_EXCLUSIVE);
 984
 985   if (low == NULL)
 986     {
 987       if (high == NULL)
 988         {
 989           index_type = NULL;
 990           name = "std::ops::RangeFull";
 991         }
 992       else
 993         {
 994           index_type = value_type (high);
 995           name = (inclusive
 996                   ? "std::ops::RangeToInclusive" : "std::ops::RangeTo");
 997         }
 998     }
 999   else
1000     {
1001       if (high == NULL)
1002         {
1003           index_type = value_type (low);
1004           name = "std::ops::RangeFrom";
1005         }
1006       else
1007         {
1008           if (!types_equal (value_type (low), value_type (high)))
1009             error (_("Range expression with different types"));
1010           index_type = value_type (low);
1011           name = inclusive ? "std::ops::RangeInclusive" : "std::ops::Range";
1012         }
1013     }
1014
1015   /* If we don't have an index type, just allocate this on the
1016      arch.  Here any type will do.  */
1017   temp_type = (index_type == NULL
1018                ? language_bool_type (exp->language_defn, exp->gdbarch)
1019                : index_type);
1020   /* It would be nicer to cache the range type.  */
1021   range_type = rust_composite_type (temp_type, name,
1022                                     low == NULL ? NULL : "start", index_type,
1023                                     high == NULL ? NULL : "end", index_type);
1024
1025   if (noside == EVAL_AVOID_SIDE_EFFECTS)
1026     return value_zero (range_type, lval_memory);
1027
1028   addrval = value_allocate_space_in_inferior (TYPE_LENGTH (range_type));
1029   addr = value_as_long (addrval);
1030   result = value_at_lazy (range_type, addr);
1031
1032   if (low != NULL)
1033     {
1034       struct value *start = value_struct_elt (&result, {}, "start", NULL,
1035                                               "range");
1036
1037       value_assign (start, low);
1038     }
1039
1040   if (high != NULL)
1041     {
1042       struct value *end = value_struct_elt (&result, {}, "end", NULL,
1043                                             "range");
1044
1045       value_assign (end, high);
1046     }
1047
1048   result = value_at_lazy (range_type, addr);
1049   return result;
1050 }
1051
1052 /* A helper function to compute the range and kind given a range
1053    value.  TYPE is the type of the range value.  RANGE is the range
1054    value.  LOW, HIGH, and KIND are out parameters.  The LOW and HIGH
1055    parameters might be filled in, or might not be, depending on the
1056    kind of range this is.  KIND will always be set to the appropriate
1057    value describing the kind of range, and this can be used to
1058    determine whether LOW or HIGH are valid.  */
1059
1060 static void
1061 rust_compute_range (struct type *type, struct value *range,
1062                     LONGEST *low, LONGEST *high,
1063                     range_flags *kind)
1064 {
1065   int i;
1066
1067   *low = 0;
1068   *high = 0;
1069   *kind = RANGE_LOW_BOUND_DEFAULT | RANGE_HIGH_BOUND_DEFAULT;
1070
1071   if (type->num_fields () == 0)
1072     return;
1073
1074   i = 0;
1075   if (strcmp (type->field (0).name (), "start") == 0)
1076     {
1077       *kind = RANGE_HIGH_BOUND_DEFAULT;
1078       *low = value_as_long (value_field (range, 0));
1079       ++i;
1080     }
1081   if (type->num_fields () > i
1082       && strcmp (type->field (i).name (), "end") == 0)
1083     {
1084       *kind = (*kind == (RANGE_LOW_BOUND_DEFAULT | RANGE_HIGH_BOUND_DEFAULT)
1085                ? RANGE_LOW_BOUND_DEFAULT : RANGE_STANDARD);
1086       *high = value_as_long (value_field (range, i));
1087
1088       if (rust_inclusive_range_type_p (type))
1089         ++*high;
1090     }
1091 }
1092
1093 /* A helper for rust_evaluate_subexp that handles BINOP_SUBSCRIPT.  */
1094
1095 struct value *
1096 rust_subscript (struct type *expect_type, struct expression *exp,
1097                 enum noside noside, bool for_addr,
1098                 struct value *lhs, struct value *rhs)
1099 {
1100   struct value *result;
1101   struct type *rhstype;
1102   LONGEST low, high_bound;
1103   /* Initialized to appease the compiler.  */
1104   range_flags kind = RANGE_LOW_BOUND_DEFAULT | RANGE_HIGH_BOUND_DEFAULT;
1105   LONGEST high = 0;
1106   int want_slice = 0;
1107
1108   rhstype = check_typedef (value_type (rhs));
1109   if (rust_range_type_p (rhstype))
1110     {
1111       if (!for_addr)
1112         error (_("Can't take slice of array without '&'"));
1113       rust_compute_range (rhstype, rhs, &low, &high, &kind);
1114       want_slice = 1;
1115     }
1116   else
1117     low = value_as_long (rhs);
1118
1119   struct type *type = check_typedef (value_type (lhs));
1120   if (noside == EVAL_AVOID_SIDE_EFFECTS)
1121     {
1122       struct type *base_type = nullptr;
1123       if (type->code () == TYPE_CODE_ARRAY)
1124         base_type = TYPE_TARGET_TYPE (type);
1125       else if (rust_slice_type_p (type))
1126         {
1127           for (int i = 0; i < type->num_fields (); ++i)
1128             {
1129               if (strcmp (type->field (i).name (), "data_ptr") == 0)
1130                 {
1131                   base_type = TYPE_TARGET_TYPE (type->field (i).type ());
1132                   break;
1133                 }
1134             }
1135           if (base_type == nullptr)
1136             error (_("Could not find 'data_ptr' in slice type"));
1137         }
1138       else if (type->code () == TYPE_CODE_PTR)
1139         base_type = TYPE_TARGET_TYPE (type);
1140       else
1141         error (_("Cannot subscript non-array type"));
1142
1143       struct type *new_type;
1144       if (want_slice)
1145         {
1146           if (rust_slice_type_p (type))
1147             new_type = type;
1148           else
1149             {
1150               struct type *usize
1151                 = language_lookup_primitive_type (exp->language_defn,
1152                                                   exp->gdbarch,
1153                                                   "usize");
1154               new_type = rust_slice_type ("&[*gdb*]", base_type, usize);
1155             }
1156         }
1157       else
1158         new_type = base_type;
1159
1160       return value_zero (new_type, VALUE_LVAL (lhs));
1161     }
1162   else
1163     {
1164       LONGEST low_bound;
1165       struct value *base;
1166
1167       if (type->code () == TYPE_CODE_ARRAY)
1168         {
1169           base = lhs;
1170           if (!get_array_bounds (type, &low_bound, &high_bound))
1171             error (_("Can't compute array bounds"));
1172           if (low_bound != 0)
1173             error (_("Found array with non-zero lower bound"));
1174           ++high_bound;
1175         }
1176       else if (rust_slice_type_p (type))
1177         {
1178           struct value *len;
1179
1180           base = value_struct_elt (&lhs, {}, "data_ptr", NULL, "slice");
1181           len = value_struct_elt (&lhs, {}, "length", NULL, "slice");
1182           low_bound = 0;
1183           high_bound = value_as_long (len);
1184         }
1185       else if (type->code () == TYPE_CODE_PTR)
1186         {
1187           base = lhs;
1188           low_bound = 0;
1189           high_bound = LONGEST_MAX;
1190         }
1191       else
1192         error (_("Cannot subscript non-array type"));
1193
1194       if (want_slice && (kind & RANGE_LOW_BOUND_DEFAULT))
1195         low = low_bound;
1196       if (low < 0)
1197         error (_("Index less than zero"));
1198       if (low > high_bound)
1199         error (_("Index greater than length"));
1200
1201       result = value_subscript (base, low);
1202     }
1203
1204   if (for_addr)
1205     {
1206       if (want_slice)
1207         {
1208           struct type *usize, *slice;
1209           CORE_ADDR addr;
1210           struct value *addrval, *tem;
1211
1212           if (kind & RANGE_HIGH_BOUND_DEFAULT)
1213             high = high_bound;
1214           if (high < 0)
1215             error (_("High index less than zero"));
1216           if (low > high)
1217             error (_("Low index greater than high index"));
1218           if (high > high_bound)
1219             error (_("High index greater than length"));
1220
1221           usize = language_lookup_primitive_type (exp->language_defn,
1222                                                   exp->gdbarch,
1223                                                   "usize");
1224           const char *new_name = ((type != nullptr
1225                                    && rust_slice_type_p (type))
1226                                   ? type->name () : "&[*gdb*]");
1227
1228           slice = rust_slice_type (new_name, value_type (result), usize);
1229
1230           addrval = value_allocate_space_in_inferior (TYPE_LENGTH (slice));
1231           addr = value_as_long (addrval);
1232           tem = value_at_lazy (slice, addr);
1233
1234           value_assign (value_field (tem, 0), value_addr (result));
1235           value_assign (value_field (tem, 1),
1236                         value_from_longest (usize, high - low));
1237
1238           result = value_at_lazy (slice, addr);
1239         }
1240       else
1241         result = value_addr (result);
1242     }
1243
1244   return result;
1245 }
1246
1247 namespace expr
1248 {
1249
1250 struct value *
1251 rust_unop_ind_operation::evaluate (struct type *expect_type,
1252                                    struct expression *exp,
1253                                    enum noside noside)
1254 {
1255   if (noside != EVAL_NORMAL)
1256     return unop_ind_operation::evaluate (expect_type, exp, noside);
1257
1258   struct value *value = std::get<0> (m_storage)->evaluate (nullptr, exp,
1259                                                            noside);
1260   struct value *trait_ptr = rust_get_trait_object_pointer (value);
1261   if (trait_ptr != NULL)
1262     value = trait_ptr;
1263
1264   return value_ind (value);
1265 }
1266
1267 } /* namespace expr */
1268
1269 /* A helper function for UNOP_COMPLEMENT.  */
1270
1271 struct value *
1272 eval_op_rust_complement (struct type *expect_type, struct expression *exp,
1273                          enum noside noside,
1274                          enum exp_opcode opcode,
1275                          struct value *value)
1276 {
1277   if (value_type (value)->code () == TYPE_CODE_BOOL)
1278     return value_from_longest (value_type (value), value_logical_not (value));
1279   return value_complement (value);
1280 }
1281
1282 /* A helper function for OP_ARRAY.  */
1283
1284 struct value *
1285 eval_op_rust_array (struct type *expect_type, struct expression *exp,
1286                     enum noside noside,
1287                     enum exp_opcode opcode,
1288                     struct value *elt, struct value *ncopies)
1289 {
1290   int copies = value_as_long (ncopies);
1291   if (copies < 0)
1292     error (_("Array with negative number of elements"));
1293
1294   if (noside == EVAL_NORMAL)
1295     {
1296       int i;
1297       std::vector<struct value *> eltvec (copies);
1298
1299       for (i = 0; i < copies; ++i)
1300         eltvec[i] = elt;
1301       return value_array (0, copies - 1, eltvec.data ());
1302     }
1303   else
1304     {
1305       struct type *arraytype
1306         = lookup_array_range_type (value_type (elt), 0, copies - 1);
1307       return allocate_value (arraytype);
1308     }
1309 }
1310
1311 namespace expr
1312 {
1313
1314 struct value *
1315 rust_struct_anon::evaluate (struct type *expect_type,
1316                             struct expression *exp,
1317                             enum noside noside)
1318 {
1319   value *lhs = std::get<1> (m_storage)->evaluate (nullptr, exp, noside);
1320   int field_number = std::get<0> (m_storage);
1321
1322   struct type *type = value_type (lhs);
1323
1324   if (type->code () == TYPE_CODE_STRUCT)
1325     {
1326       struct type *outer_type = NULL;
1327
1328       if (rust_enum_p (type))
1329         {
1330           type = resolve_dynamic_type (type, value_contents (lhs),
1331                                        value_address (lhs));
1332
1333           if (rust_empty_enum_p (type))
1334             error (_("Cannot access field %d of empty enum %s"),
1335                    field_number, type->name ());
1336
1337           int fieldno = rust_enum_variant (type);
1338           lhs = value_primitive_field (lhs, 0, fieldno, type);
1339           outer_type = type;
1340           type = value_type (lhs);
1341         }
1342
1343       /* Tuples and tuple structs */
1344       int nfields = type->num_fields ();
1345
1346       if (field_number >= nfields || field_number < 0)
1347         {
1348           if (outer_type != NULL)
1349             error(_("Cannot access field %d of variant %s::%s, "
1350                     "there are only %d fields"),
1351                   field_number, outer_type->name (),
1352                   rust_last_path_segment (type->name ()),
1353                   nfields);
1354           else
1355             error(_("Cannot access field %d of %s, "
1356                     "there are only %d fields"),
1357                   field_number, type->name (), nfields);
1358         }
1359
1360       /* Tuples are tuple structs too.  */
1361       if (!rust_tuple_struct_type_p (type))
1362         {
1363           if (outer_type != NULL)
1364             error(_("Variant %s::%s is not a tuple variant"),
1365                   outer_type->name (),
1366                   rust_last_path_segment (type->name ()));
1367           else
1368             error(_("Attempting to access anonymous field %d "
1369                     "of %s, which is not a tuple, tuple struct, or "
1370                     "tuple-like variant"),
1371                   field_number, type->name ());
1372         }
1373
1374       return value_primitive_field (lhs, 0, field_number, type);
1375     }
1376   else
1377     error(_("Anonymous field access is only allowed on tuples, \
1378 tuple structs, and tuple-like enum variants"));
1379 }
1380
1381 struct value *
1382 rust_structop::evaluate (struct type *expect_type,
1383                          struct expression *exp,
1384                          enum noside noside)
1385 {
1386   value *lhs = std::get<0> (m_storage)->evaluate (nullptr, exp, noside);
1387   const char *field_name = std::get<1> (m_storage).c_str ();
1388
1389   struct value *result;
1390   struct type *type = value_type (lhs);
1391   if (type->code () == TYPE_CODE_STRUCT && rust_enum_p (type))
1392     {
1393       type = resolve_dynamic_type (type, value_contents (lhs),
1394                                    value_address (lhs));
1395
1396       if (rust_empty_enum_p (type))
1397         error (_("Cannot access field %s of empty enum %s"),
1398                field_name, type->name ());
1399
1400       int fieldno = rust_enum_variant (type);
1401       lhs = value_primitive_field (lhs, 0, fieldno, type);
1402
1403       struct type *outer_type = type;
1404       type = value_type (lhs);
1405       if (rust_tuple_type_p (type) || rust_tuple_struct_type_p (type))
1406         error (_("Attempting to access named field %s of tuple "
1407                  "variant %s::%s, which has only anonymous fields"),
1408                field_name, outer_type->name (),
1409                rust_last_path_segment (type->name ()));
1410
1411       try
1412         {
1413           result = value_struct_elt (&lhs, {}, field_name,
1414                                      NULL, "structure");
1415         }
1416       catch (const gdb_exception_error &except)
1417         {
1418           error (_("Could not find field %s of struct variant %s::%s"),
1419                  field_name, outer_type->name (),
1420                  rust_last_path_segment (type->name ()));
1421         }
1422     }
1423   else
1424     result = value_struct_elt (&lhs, {}, field_name, NULL, "structure");
1425   if (noside == EVAL_AVOID_SIDE_EFFECTS)
1426     result = value_zero (value_type (result), VALUE_LVAL (result));
1427   return result;
1428 }
1429
1430 value *
1431 rust_aggregate_operation::evaluate (struct type *expect_type,
1432                                     struct expression *exp,
1433                                     enum noside noside)
1434 {
1435   struct type *type = std::get<0> (m_storage);
1436   CORE_ADDR addr = 0;
1437   struct value *addrval = NULL;
1438   value *result;
1439
1440   if (noside == EVAL_NORMAL)
1441     {
1442       addrval = value_allocate_space_in_inferior (TYPE_LENGTH (type));
1443       addr = value_as_long (addrval);
1444       result = value_at_lazy (type, addr);
1445     }
1446
1447   if (std::get<1> (m_storage) != nullptr)
1448     {
1449       struct value *init = std::get<1> (m_storage)->evaluate (nullptr, exp,
1450                                                               noside);
1451
1452       if (noside == EVAL_NORMAL)
1453         {
1454           /* This isn't quite right but will do for the time
1455              being, seeing that we can't implement the Copy
1456              trait anyway.  */
1457           value_assign (result, init);
1458         }
1459     }
1460
1461   for (const auto &item : std::get<2> (m_storage))
1462     {
1463       value *val = item.second->evaluate (nullptr, exp, noside);
1464       if (noside == EVAL_NORMAL)
1465         {
1466           const char *fieldname = item.first.c_str ();
1467           value *field = value_struct_elt (&result, {}, fieldname,
1468                                            nullptr, "structure");
1469           value_assign (field, val);
1470         }
1471     }
1472
1473   if (noside == EVAL_AVOID_SIDE_EFFECTS)
1474     result = allocate_value (type);
1475   else
1476     result = value_at_lazy (type, addr);
1477
1478   return result;
1479 }
1480
1481 value *
1482 rust_structop::evaluate_funcall (struct type *expect_type,
1483                                  struct expression *exp,
1484                                  enum noside noside,
1485                                  const std::vector<operation_up> &ops)
1486 {
1487   std::vector<struct value *> args (ops.size () + 1);
1488
1489   /* Evaluate the argument to STRUCTOP_STRUCT, then find its
1490      type in order to look up the method.  */
1491   args[0] = std::get<0> (m_storage)->evaluate (nullptr, exp, noside);
1492   /* We don't yet implement real Deref semantics.  */
1493   while (value_type (args[0])->code () == TYPE_CODE_PTR)
1494     args[0] = value_ind (args[0]);
1495
1496   struct type *type = value_type (args[0]);
1497   if ((type->code () != TYPE_CODE_STRUCT
1498        && type->code () != TYPE_CODE_UNION
1499        && type->code () != TYPE_CODE_ENUM)
1500       || rust_tuple_type_p (type))
1501     error (_("Method calls only supported on struct or enum types"));
1502   if (type->name () == NULL)
1503     error (_("Method call on nameless type"));
1504
1505   std::string name = (std::string (type->name ()) + "::"
1506                       + std::get<1> (m_storage));
1507
1508   const struct block *block = get_selected_block (0);
1509   struct block_symbol sym = lookup_symbol (name.c_str (), block,
1510                                            VAR_DOMAIN, NULL);
1511   if (sym.symbol == NULL)
1512     error (_("Could not find function named '%s'"), name.c_str ());
1513
1514   struct type *fn_type = SYMBOL_TYPE (sym.symbol);
1515   if (fn_type->num_fields () == 0)
1516     error (_("Function '%s' takes no arguments"), name.c_str ());
1517
1518   if (fn_type->field (0).type ()->code () == TYPE_CODE_PTR)
1519     args[0] = value_addr (args[0]);
1520
1521   value *function = address_of_variable (sym.symbol, block);
1522
1523   for (int i = 0; i < ops.size (); ++i)
1524     args[i + 1] = ops[i]->evaluate (nullptr, exp, noside);
1525
1526   if (noside == EVAL_AVOID_SIDE_EFFECTS)
1527     return value_zero (TYPE_TARGET_TYPE (fn_type), not_lval);
1528   return call_function_by_hand (function, NULL, args);
1529 }
1530
1531 }
1532
1533 \f
1534
1535 /* See language.h.  */
1536
1537 void
1538 rust_language::language_arch_info (struct gdbarch *gdbarch,
1539                                    struct language_arch_info *lai) const
1540 {
1541   const struct builtin_type *builtin = builtin_type (gdbarch);
1542
1543   /* Helper function to allow shorter lines below.  */
1544   auto add  = [&] (struct type * t) -> struct type *
1545   {
1546     lai->add_primitive_type (t);
1547     return t;
1548   };
1549
1550   struct type *bool_type
1551     = add (arch_boolean_type (gdbarch, 8, 1, "bool"));
1552   add (arch_character_type (gdbarch, 32, 1, "char"));
1553   add (arch_integer_type (gdbarch, 8, 0, "i8"));
1554   struct type *u8_type
1555     = add (arch_integer_type (gdbarch, 8, 1, "u8"));
1556   add (arch_integer_type (gdbarch, 16, 0, "i16"));
1557   add (arch_integer_type (gdbarch, 16, 1, "u16"));
1558   add (arch_integer_type (gdbarch, 32, 0, "i32"));
1559   add (arch_integer_type (gdbarch, 32, 1, "u32"));
1560   add (arch_integer_type (gdbarch, 64, 0, "i64"));
1561   add (arch_integer_type (gdbarch, 64, 1, "u64"));
1562
1563   unsigned int length = 8 * TYPE_LENGTH (builtin->builtin_data_ptr);
1564   add (arch_integer_type (gdbarch, length, 0, "isize"));
1565   struct type *usize_type
1566     = add (arch_integer_type (gdbarch, length, 1, "usize"));
1567
1568   add (arch_float_type (gdbarch, 32, "f32", floatformats_ieee_single));
1569   add (arch_float_type (gdbarch, 64, "f64", floatformats_ieee_double));
1570   add (arch_integer_type (gdbarch, 0, 1, "()"));
1571
1572   struct type *tem = make_cv_type (1, 0, u8_type, NULL);
1573   add (rust_slice_type ("&str", tem, usize_type));
1574
1575   lai->set_bool_type (bool_type);
1576   lai->set_string_char_type (u8_type);
1577 }
1578
1579 /* See language.h.  */
1580
1581 void
1582 rust_language::print_type (struct type *type, const char *varstring,
1583                            struct ui_file *stream, int show, int level,
1584                            const struct type_print_options *flags) const
1585 {
1586   print_offset_data podata (flags);
1587   rust_internal_print_type (type, varstring, stream, show, level,
1588                             flags, false, &podata);
1589 }
1590
1591 /* See language.h.  */
1592
1593 void
1594 rust_language::emitchar (int ch, struct type *chtype,
1595                          struct ui_file *stream, int quoter) const
1596 {
1597   if (!rust_chartype_p (chtype))
1598     generic_emit_char (ch, chtype, stream, quoter,
1599                        target_charset (chtype->arch ()));
1600   else if (ch == '\\' || ch == quoter)
1601     fprintf_filtered (stream, "\\%c", ch);
1602   else if (ch == '\n')
1603     fputs_filtered ("\\n", stream);
1604   else if (ch == '\r')
1605     fputs_filtered ("\\r", stream);
1606   else if (ch == '\t')
1607     fputs_filtered ("\\t", stream);
1608   else if (ch == '\0')
1609     fputs_filtered ("\\0", stream);
1610   else if (ch >= 32 && ch <= 127 && isprint (ch))
1611     fputc_filtered (ch, stream);
1612   else if (ch <= 255)
1613     fprintf_filtered (stream, "\\x%02x", ch);
1614   else
1615     fprintf_filtered (stream, "\\u{%06x}", ch);
1616 }
1617
1618 /* See language.h.  */
1619
1620 bool
1621 rust_language::is_string_type_p (struct type *type) const
1622 {
1623   LONGEST low_bound, high_bound;
1624
1625   type = check_typedef (type);
1626   return ((type->code () == TYPE_CODE_STRING)
1627           || (type->code () == TYPE_CODE_PTR
1628               && (TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_ARRAY
1629                   && rust_u8_type_p (TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (type)))
1630                   && get_array_bounds (TYPE_TARGET_TYPE (type), &low_bound,
1631                                        &high_bound)))
1632           || (type->code () == TYPE_CODE_STRUCT
1633               && !rust_enum_p (type)
1634               && rust_slice_type_p (type)
1635               && strcmp (type->name (), "&str") == 0));
1636 }
1637
1638 /* Single instance of the Rust language class.  */
1639
1640 static rust_language rust_language_defn;