gdb/target-descriptions.c

   1 /* Target description support for GDB.
   2
   3    Copyright (C) 2006-2020 Free Software Foundation, Inc.
   4
   5    Contributed by CodeSourcery.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 #include "defs.h"
  23 #include "arch-utils.h"
  24 #include "gdbcmd.h"
  25 #include "gdbtypes.h"
  26 #include "reggroups.h"
  27 #include "target.h"
  28 #include "target-descriptions.h"
  29 #include "xml-support.h"
  30 #include "xml-tdesc.h"
  31 #include "osabi.h"
  32
  33 #include "gdb_obstack.h"
  34 #include "hashtab.h"
  35 #include "inferior.h"
  36 #include <algorithm>
  37 #include "completer.h"
  38 #include "readline/tilde.h" /* tilde_expand */
  39
  40 /* Types.  */
  41
  42 struct property
  43 {
  44   property (const std::string &key_, const std::string &value_)
  45   : key (key_), value (value_)
  46   {}
  47
  48   std::string key;
  49   std::string value;
  50 };
  51
  52 /* Convert a tdesc_type to a gdb type.  */
  53
  54 static type *
  55 make_gdb_type (struct gdbarch *gdbarch, struct tdesc_type *ttype)
  56 {
  57   class gdb_type_creator : public tdesc_element_visitor
  58   {
  59   public:
  60     gdb_type_creator (struct gdbarch *gdbarch)
  61       : m_gdbarch (gdbarch)
  62     {}
  63
  64     type *get_type ()
  65     {
  66       return m_type;
  67     }
  68
  69     void visit (const tdesc_type_builtin *e) override
  70     {
  71       switch (e->kind)
  72         {
  73           /* Predefined types.  */
  74         case TDESC_TYPE_BOOL:
  75           m_type = builtin_type (m_gdbarch)->builtin_bool;
  76           return;
  77         case TDESC_TYPE_INT8:
  78           m_type = builtin_type (m_gdbarch)->builtin_int8;
  79           return;
  80         case TDESC_TYPE_INT16:
  81           m_type = builtin_type (m_gdbarch)->builtin_int16;
  82           return;
  83         case TDESC_TYPE_INT32:
  84           m_type = builtin_type (m_gdbarch)->builtin_int32;
  85           return;
  86         case TDESC_TYPE_INT64:
  87           m_type = builtin_type (m_gdbarch)->builtin_int64;
  88           return;
  89         case TDESC_TYPE_INT128:
  90           m_type = builtin_type (m_gdbarch)->builtin_int128;
  91           return;
  92         case TDESC_TYPE_UINT8:
  93           m_type = builtin_type (m_gdbarch)->builtin_uint8;
  94           return;
  95         case TDESC_TYPE_UINT16:
  96           m_type = builtin_type (m_gdbarch)->builtin_uint16;
  97           return;
  98         case TDESC_TYPE_UINT32:
  99           m_type = builtin_type (m_gdbarch)->builtin_uint32;
 100           return;
 101         case TDESC_TYPE_UINT64:
 102           m_type = builtin_type (m_gdbarch)->builtin_uint64;
 103           return;
 104         case TDESC_TYPE_UINT128:
 105           m_type = builtin_type (m_gdbarch)->builtin_uint128;
 106           return;
 107         case TDESC_TYPE_CODE_PTR:
 108           m_type = builtin_type (m_gdbarch)->builtin_func_ptr;
 109           return;
 110         case TDESC_TYPE_DATA_PTR:
 111           m_type = builtin_type (m_gdbarch)->builtin_data_ptr;
 112           return;
 113         }
 114
 115       m_type = tdesc_find_type (m_gdbarch, e->name.c_str ());
 116       if (m_type != NULL)
 117         return;
 118
 119       switch (e->kind)
 120         {
 121         case TDESC_TYPE_IEEE_HALF:
 122           m_type = arch_float_type (m_gdbarch, -1, "builtin_type_ieee_half",
 123                                     floatformats_ieee_half);
 124           return;
 125
 126         case TDESC_TYPE_IEEE_SINGLE:
 127           m_type = arch_float_type (m_gdbarch, -1, "builtin_type_ieee_single",
 128                                     floatformats_ieee_single);
 129           return;
 130
 131         case TDESC_TYPE_IEEE_DOUBLE:
 132           m_type = arch_float_type (m_gdbarch, -1, "builtin_type_ieee_double",
 133                                     floatformats_ieee_double);
 134           return;
 135         case TDESC_TYPE_ARM_FPA_EXT:
 136           m_type = arch_float_type (m_gdbarch, -1, "builtin_type_arm_ext",
 137                                     floatformats_arm_ext);
 138           return;
 139
 140         case TDESC_TYPE_I387_EXT:
 141           m_type = arch_float_type (m_gdbarch, -1, "builtin_type_i387_ext",
 142                                     floatformats_i387_ext);
 143           return;
 144
 145         case TDESC_TYPE_BFLOAT16:
 146           m_type = arch_float_type (m_gdbarch, -1, "builtin_type_bfloat16",
 147                                     floatformats_bfloat16);
 148           return;
 149         }
 150
 151       internal_error (__FILE__, __LINE__,
 152                       "Type \"%s\" has an unknown kind %d",
 153                       e->name.c_str (), e->kind);
 154     }
 155
 156     void visit (const tdesc_type_vector *e) override
 157     {
 158       m_type = tdesc_find_type (m_gdbarch, e->name.c_str ());
 159       if (m_type != NULL)
 160         return;
 161
 162       type *element_gdb_type = make_gdb_type (m_gdbarch, e->element_type);
 163       m_type = init_vector_type (element_gdb_type, e->count);
 164       m_type->set_name (xstrdup (e->name.c_str ()));
 165       return;
 166     }
 167
 168     void visit (const tdesc_type_with_fields *e) override
 169     {
 170       m_type = tdesc_find_type (m_gdbarch, e->name.c_str ());
 171       if (m_type != NULL)
 172         return;
 173
 174       switch (e->kind)
 175         {
 176         case TDESC_TYPE_STRUCT:
 177           make_gdb_type_struct (e);
 178           return;
 179         case TDESC_TYPE_UNION:
 180           make_gdb_type_union (e);
 181           return;
 182         case TDESC_TYPE_FLAGS:
 183           make_gdb_type_flags (e);
 184           return;
 185         case TDESC_TYPE_ENUM:
 186           make_gdb_type_enum (e);
 187           return;
 188         }
 189
 190       internal_error (__FILE__, __LINE__,
 191                       "Type \"%s\" has an unknown kind %d",
 192                       e->name.c_str (), e->kind);
 193     }
 194
 195   private:
 196
 197     void make_gdb_type_struct (const tdesc_type_with_fields *e)
 198     {
 199       m_type = arch_composite_type (m_gdbarch, NULL, TYPE_CODE_STRUCT);
 200       m_type->set_name (xstrdup (e->name.c_str ()));
 201
 202       for (const tdesc_type_field &f : e->fields)
 203         {
 204           if (f.start != -1 && f.end != -1)
 205             {
 206               /* Bitfield.  */
 207               struct field *fld;
 208               struct type *field_gdb_type;
 209               int bitsize, total_size;
 210
 211               /* This invariant should be preserved while creating types.  */
 212               gdb_assert (e->size != 0);
 213               if (f.type != NULL)
 214                 field_gdb_type = make_gdb_type (m_gdbarch, f.type);
 215               else if (e->size > 4)
 216                 field_gdb_type = builtin_type (m_gdbarch)->builtin_uint64;
 217               else
 218                 field_gdb_type = builtin_type (m_gdbarch)->builtin_uint32;
 219
 220               fld = append_composite_type_field_raw
 221                       (m_type, xstrdup (f.name.c_str ()), field_gdb_type);
 222
 223               /* For little-endian, BITPOS counts from the LSB of
 224                  the structure and marks the LSB of the field.  For
 225                  big-endian, BITPOS counts from the MSB of the
 226                  structure and marks the MSB of the field.  Either
 227                  way, it is the number of bits to the "left" of the
 228                  field.  To calculate this in big-endian, we need
 229                  the total size of the structure.  */
 230               bitsize = f.end - f.start + 1;
 231               total_size = e->size * TARGET_CHAR_BIT;
 232               if (gdbarch_byte_order (m_gdbarch) == BFD_ENDIAN_BIG)
 233                 SET_FIELD_BITPOS (fld[0], total_size - f.start - bitsize);
 234               else
 235                 SET_FIELD_BITPOS (fld[0], f.start);
 236               FIELD_BITSIZE (fld[0]) = bitsize;
 237             }
 238           else
 239             {
 240               gdb_assert (f.start == -1 && f.end == -1);
 241               type *field_gdb_type = make_gdb_type (m_gdbarch, f.type);
 242               append_composite_type_field (m_type,
 243                                            xstrdup (f.name.c_str ()),
 244                                            field_gdb_type);
 245             }
 246         }
 247
 248       if (e->size != 0)
 249         TYPE_LENGTH (m_type) = e->size;
 250     }
 251
 252     void make_gdb_type_union (const tdesc_type_with_fields *e)
 253     {
 254       m_type = arch_composite_type (m_gdbarch, NULL, TYPE_CODE_UNION);
 255       m_type->set_name (xstrdup (e->name.c_str ()));
 256
 257       for (const tdesc_type_field &f : e->fields)
 258         {
 259           type* field_gdb_type = make_gdb_type (m_gdbarch, f.type);
 260           append_composite_type_field (m_type, xstrdup (f.name.c_str ()),
 261                                        field_gdb_type);
 262
 263           /* If any of the children of a union are vectors, flag the
 264              union as a vector also.  This allows e.g. a union of two
 265              vector types to show up automatically in "info vector".  */
 266           if (field_gdb_type->is_vector ())
 267             m_type->set_is_vector (true);
 268         }
 269     }
 270
 271     void make_gdb_type_flags (const tdesc_type_with_fields *e)
 272     {
 273       m_type = arch_flags_type (m_gdbarch, e->name.c_str (),
 274                                 e->size * TARGET_CHAR_BIT);
 275
 276       for (const tdesc_type_field &f : e->fields)
 277         {
 278           int bitsize = f.end - f.start + 1;
 279
 280           gdb_assert (f.type != NULL);
 281           type *field_gdb_type = make_gdb_type (m_gdbarch, f.type);
 282           append_flags_type_field (m_type, f.start, bitsize,
 283                                    field_gdb_type, f.name.c_str ());
 284         }
 285     }
 286
 287     void make_gdb_type_enum (const tdesc_type_with_fields *e)
 288     {
 289       m_type = arch_type (m_gdbarch, TYPE_CODE_ENUM, e->size * TARGET_CHAR_BIT,
 290                           e->name.c_str ());
 291
 292       m_type->set_is_unsigned (true);
 293
 294       for (const tdesc_type_field &f : e->fields)
 295         {
 296           struct field *fld
 297             = append_composite_type_field_raw (m_type,
 298                                                xstrdup (f.name.c_str ()),
 299                                                NULL);
 300
 301           SET_FIELD_BITPOS (fld[0], f.start);
 302         }
 303     }
 304
 305     /* The gdbarch used.  */
 306     struct gdbarch *m_gdbarch;
 307
 308     /* The type created.  */
 309     type *m_type;
 310   };
 311
 312   gdb_type_creator gdb_type (gdbarch);
 313   ttype->accept (gdb_type);
 314   return gdb_type.get_type ();
 315 }
 316
 317 /* Wrapper around bfd_arch_info_type.  A class with this name is used in
 318    the API that is shared between gdb and gdbserver code, but gdbserver
 319    doesn't use compatibility information, so its version of this class is
 320    empty.  */
 321
 322 class tdesc_compatible_info
 323 {
 324 public:
 325   /* Constructor.  */
 326   explicit tdesc_compatible_info (const bfd_arch_info_type *arch)
 327     : m_arch (arch)
 328   { /* Nothing.  */ }
 329
 330   /* Access the contained pointer.  */
 331   const bfd_arch_info_type *arch () const
 332   { return m_arch; }
 333
 334 private:
 335   /* Architecture information looked up from the <compatible> entity within
 336      a target description.  */
 337   const bfd_arch_info_type *m_arch;
 338 };
 339
 340 /* A target description.  */
 341
 342 struct target_desc : tdesc_element
 343 {
 344   target_desc ()
 345   {}
 346
 347   virtual ~target_desc () = default;
 348
 349   target_desc (const target_desc &) = delete;
 350   void operator= (const target_desc &) = delete;
 351
 352   /* The architecture reported by the target, if any.  */
 353   const struct bfd_arch_info *arch = NULL;
 354
 355   /* The osabi reported by the target, if any; GDB_OSABI_UNKNOWN
 356      otherwise.  */
 357   enum gdb_osabi osabi = GDB_OSABI_UNKNOWN;
 358
 359   /* The list of compatible architectures reported by the target.  */
 360   std::vector<tdesc_compatible_info_up> compatible;
 361
 362   /* Any architecture-specific properties specified by the target.  */
 363   std::vector<property> properties;
 364
 365   /* The features associated with this target.  */
 366   std::vector<tdesc_feature_up> features;
 367
 368   /* Used to cache the generated xml version of the target description.  */
 369   mutable char *xmltarget = nullptr;
 370
 371   void accept (tdesc_element_visitor &v) const override
 372   {
 373     v.visit_pre (this);
 374
 375     for (const tdesc_feature_up &feature : features)
 376       feature->accept (v);
 377
 378     v.visit_post (this);
 379   }
 380
 381   bool operator== (const target_desc &other) const
 382   {
 383     if (arch != other.arch)
 384       return false;
 385
 386     if (osabi != other.osabi)
 387       return false;
 388
 389     if (features.size () != other.features.size ())
 390       return false;
 391
 392     for (int ix = 0; ix < features.size (); ix++)
 393       {
 394         const tdesc_feature_up &feature1 = features[ix];
 395         const tdesc_feature_up &feature2 = other.features[ix];
 396
 397         if (feature1 != feature2 && *feature1 != *feature2)
 398           return false;
 399       }
 400
 401     return true;
 402   }
 403
 404   bool operator!= (const target_desc &other) const
 405   {
 406     return !(*this == other);
 407   }
 408 };
 409
 410 /* Per-architecture data associated with a target description.  The
 411    target description may be shared by multiple architectures, but
 412    this data is private to one gdbarch.  */
 413
 414 struct tdesc_arch_reg
 415 {
 416   tdesc_arch_reg (tdesc_reg *reg_, struct type *type_)
 417   : reg (reg_), type (type_)
 418   {}
 419
 420   struct tdesc_reg *reg;
 421   struct type *type;
 422 };
 423
 424 struct tdesc_arch_data
 425 {
 426   /* A list of register/type pairs, indexed by GDB's internal register number.
 427      During initialization of the gdbarch this list is used to store
 428      registers which the architecture assigns a fixed register number.
 429      Registers which are NULL in this array, or off the end, are
 430      treated as zero-sized and nameless (i.e. placeholders in the
 431      numbering).  */
 432   std::vector<tdesc_arch_reg> arch_regs;
 433
 434   /* Functions which report the register name, type, and reggroups for
 435      pseudo-registers.  */
 436   gdbarch_register_name_ftype *pseudo_register_name = NULL;
 437   gdbarch_register_type_ftype *pseudo_register_type = NULL;
 438   gdbarch_register_reggroup_p_ftype *pseudo_register_reggroup_p = NULL;
 439 };
 440
 441 /* Info about an inferior's target description.  There's one of these
 442    for each inferior.  */
 443
 444 struct target_desc_info
 445 {
 446   /* A flag indicating that a description has already been fetched
 447      from the target, so it should not be queried again.  */
 448
 449   int fetched;
 450
 451   /* The description fetched from the target, or NULL if the target
 452      did not supply any description.  Only valid when
 453      target_desc_fetched is set.  Only the description initialization
 454      code should access this; normally, the description should be
 455      accessed through the gdbarch object.  */
 456
 457   const struct target_desc *tdesc;
 458
 459   /* The filename to read a target description from, as set by "set
 460      tdesc filename ..."  */
 461
 462   char *filename;
 463 };
 464
 465 /* Get the inferior INF's target description info, allocating one on
 466    the stop if necessary.  */
 467
 468 static struct target_desc_info *
 469 get_tdesc_info (struct inferior *inf)
 470 {
 471   if (inf->tdesc_info == NULL)
 472     inf->tdesc_info = XCNEW (struct target_desc_info);
 473   return inf->tdesc_info;
 474 }
 475
 476 /* A handle for architecture-specific data associated with the
 477    target description (see struct tdesc_arch_data).  */
 478
 479 static struct gdbarch_data *tdesc_data;
 480
 481 /* See target-descriptions.h.  */
 482
 483 int
 484 target_desc_info_from_user_p (struct target_desc_info *info)
 485 {
 486   return info != NULL && info->filename != NULL;
 487 }
 488
 489 /* See target-descriptions.h.  */
 490
 491 void
 492 copy_inferior_target_desc_info (struct inferior *destinf, struct inferior *srcinf)
 493 {
 494   struct target_desc_info *src = get_tdesc_info (srcinf);
 495   struct target_desc_info *dest = get_tdesc_info (destinf);
 496
 497   dest->fetched = src->fetched;
 498   dest->tdesc = src->tdesc;
 499   dest->filename = src->filename != NULL ? xstrdup (src->filename) : NULL;
 500 }
 501
 502 /* See target-descriptions.h.  */
 503
 504 void
 505 target_desc_info_free (struct target_desc_info *tdesc_info)
 506 {
 507   if (tdesc_info != NULL)
 508     {
 509       xfree (tdesc_info->filename);
 510       xfree (tdesc_info);
 511     }
 512 }
 513
 514 /* Convenience helper macros.  */
 515
 516 #define target_desc_fetched \
 517   get_tdesc_info (current_inferior ())->fetched
 518 #define current_target_desc \
 519   get_tdesc_info (current_inferior ())->tdesc
 520 #define target_description_filename \
 521   get_tdesc_info (current_inferior ())->filename
 522
 523 /* The string manipulated by the "set tdesc filename ..." command.  */
 524
 525 static char *tdesc_filename_cmd_string;
 526
 527 /* Fetch the current target's description, and switch the current
 528    architecture to one which incorporates that description.  */
 529
 530 void
 531 target_find_description (void)
 532 {
 533   /* If we've already fetched a description from the target, don't do
 534      it again.  This allows a target to fetch the description early,
 535      during its to_open or to_create_inferior, if it needs extra
 536      information about the target to initialize.  */
 537   if (target_desc_fetched)
 538     return;
 539
 540   /* The current architecture should not have any target description
 541      specified.  It should have been cleared, e.g. when we
 542      disconnected from the previous target.  */
 543   gdb_assert (gdbarch_target_desc (target_gdbarch ()) == NULL);
 544
 545   /* First try to fetch an XML description from the user-specified
 546      file.  */
 547   current_target_desc = NULL;
 548   if (target_description_filename != NULL
 549       && *target_description_filename != '\0')
 550     current_target_desc
 551       = file_read_description_xml (target_description_filename);
 552
 553   /* Next try to read the description from the current target using
 554      target objects.  */
 555   if (current_target_desc == NULL)
 556     current_target_desc = target_read_description_xml (current_top_target ());
 557
 558   /* If that failed try a target-specific hook.  */
 559   if (current_target_desc == NULL)
 560     current_target_desc = target_read_description (current_top_target ());
 561
 562   /* If a non-NULL description was returned, then update the current
 563      architecture.  */
 564   if (current_target_desc)
 565     {
 566       struct gdbarch_info info;
 567
 568       gdbarch_info_init (&info);
 569       info.target_desc = current_target_desc;
 570       if (!gdbarch_update_p (info))
 571         warning (_("Architecture rejected target-supplied description"));
 572       else
 573         {
 574           struct tdesc_arch_data *data;
 575
 576           data = ((struct tdesc_arch_data *)
 577                   gdbarch_data (target_gdbarch (), tdesc_data));
 578           if (tdesc_has_registers (current_target_desc)
 579               && data->arch_regs.empty ())
 580             warning (_("Target-supplied registers are not supported "
 581                        "by the current architecture"));
 582         }
 583     }
 584
 585   /* Now that we know this description is usable, record that we
 586      fetched it.  */
 587   target_desc_fetched = 1;
 588 }
 589
 590 /* Discard any description fetched from the current target, and switch
 591    the current architecture to one with no target description.  */
 592
 593 void
 594 target_clear_description (void)
 595 {
 596   struct gdbarch_info info;
 597
 598   if (!target_desc_fetched)
 599     return;
 600
 601   target_desc_fetched = 0;
 602   current_target_desc = NULL;
 603
 604   gdbarch_info_init (&info);
 605   if (!gdbarch_update_p (info))
 606     internal_error (__FILE__, __LINE__,
 607                     _("Could not remove target-supplied description"));
 608 }
 609
 610 /* Return the global current target description.  This should only be
 611    used by gdbarch initialization code; most access should be through
 612    an existing gdbarch.  */
 613
 614 const struct target_desc *
 615 target_current_description (void)
 616 {
 617   if (target_desc_fetched)
 618     return current_target_desc;
 619
 620   return NULL;
 621 }
 622
 623 /* Return non-zero if this target description is compatible
 624    with the given BFD architecture.  */
 625
 626 int
 627 tdesc_compatible_p (const struct target_desc *target_desc,
 628                     const struct bfd_arch_info *arch)
 629 {
 630   for (const tdesc_compatible_info_up &compat : target_desc->compatible)
 631     {
 632       if (compat->arch () == arch
 633           || arch->compatible (arch, compat->arch ())
 634           || compat->arch ()->compatible (compat->arch (), arch))
 635         return 1;
 636     }
 637
 638   return 0;
 639 }
 640 \f
 641
 642 /* Direct accessors for target descriptions.  */
 643
 644 /* Return the string value of a property named KEY, or NULL if the
 645    property was not specified.  */
 646
 647 const char *
 648 tdesc_property (const struct target_desc *target_desc, const char *key)
 649 {
 650   for (const property &prop : target_desc->properties)
 651     if (prop.key == key)
 652       return prop.value.c_str ();
 653
 654   return NULL;
 655 }
 656
 657 /* Return the BFD architecture associated with this target
 658    description, or NULL if no architecture was specified.  */
 659
 660 const struct bfd_arch_info *
 661 tdesc_architecture (const struct target_desc *target_desc)
 662 {
 663   return target_desc->arch;
 664 }
 665
 666 /* See gdbsupport/tdesc.h.  */
 667
 668 const char *
 669 tdesc_architecture_name (const struct target_desc *target_desc)
 670 {
 671   if (target_desc->arch != NULL)
 672     return target_desc->arch->printable_name;
 673   return NULL;
 674 }
 675
 676 /* See gdbsupport/tdesc.h.  */
 677
 678 const std::vector<tdesc_compatible_info_up> &
 679 tdesc_compatible_info_list (const target_desc *target_desc)
 680 {
 681   return target_desc->compatible;
 682 }
 683
 684 /* See gdbsupport/tdesc.h.  */
 685
 686 const char *
 687 tdesc_compatible_info_arch_name (const tdesc_compatible_info_up &compatible)
 688 {
 689   return compatible->arch ()->printable_name;
 690 }
 691
 692 /* Return the OSABI associated with this target description, or
 693    GDB_OSABI_UNKNOWN if no osabi was specified.  */
 694
 695 enum gdb_osabi
 696 tdesc_osabi (const struct target_desc *target_desc)
 697 {
 698   return target_desc->osabi;
 699 }
 700
 701 /* See gdbsupport/tdesc.h.  */
 702
 703 const char *
 704 tdesc_osabi_name (const struct target_desc *target_desc)
 705 {
 706   enum gdb_osabi osabi = tdesc_osabi (target_desc);
 707   if (osabi > GDB_OSABI_UNKNOWN && osabi < GDB_OSABI_INVALID)
 708     return gdbarch_osabi_name (osabi);
 709   return nullptr;
 710 }
 711
 712 /* Return 1 if this target description includes any registers.  */
 713
 714 int
 715 tdesc_has_registers (const struct target_desc *target_desc)
 716 {
 717   if (target_desc == NULL)
 718     return 0;
 719
 720   for (const tdesc_feature_up &feature : target_desc->features)
 721     if (!feature->registers.empty ())
 722       return 1;
 723
 724   return 0;
 725 }
 726
 727 /* Return the feature with the given name, if present, or NULL if
 728    the named feature is not found.  */
 729
 730 const struct tdesc_feature *
 731 tdesc_find_feature (const struct target_desc *target_desc,
 732                     const char *name)
 733 {
 734   for (const tdesc_feature_up &feature : target_desc->features)
 735     if (feature->name == name)
 736       return feature.get ();
 737
 738   return NULL;
 739 }
 740
 741 /* Return the name of FEATURE.  */
 742
 743 const char *
 744 tdesc_feature_name (const struct tdesc_feature *feature)
 745 {
 746   return feature->name.c_str ();
 747 }
 748
 749 /* Lookup type associated with ID.  */
 750
 751 struct type *
 752 tdesc_find_type (struct gdbarch *gdbarch, const char *id)
 753 {
 754   tdesc_arch_data *data
 755     = (struct tdesc_arch_data *) gdbarch_data (gdbarch, tdesc_data);
 756
 757   for (const tdesc_arch_reg &reg : data->arch_regs)
 758     {
 759       if (reg.reg
 760           && reg.reg->tdesc_type
 761           && reg.type
 762           && reg.reg->tdesc_type->name == id)
 763         return reg.type;
 764     }
 765
 766   return NULL;
 767 }
 768
 769 /* Support for registers from target descriptions.  */
 770
 771 /* Construct the per-gdbarch data.  */
 772
 773 static void *
 774 tdesc_data_init (struct obstack *obstack)
 775 {
 776   return obstack_new<tdesc_arch_data> (obstack);
 777 }
 778
 779 /* Similar, but for the temporary copy used during architecture
 780    initialization.  */
 781
 782 tdesc_arch_data_up
 783 tdesc_data_alloc (void)
 784 {
 785   return tdesc_arch_data_up (new tdesc_arch_data ());
 786 }
 787
 788 /* See target-descriptions.h.  */
 789
 790 void
 791 tdesc_arch_data_deleter::operator() (struct tdesc_arch_data *data) const
 792 {
 793   delete data;
 794 }
 795
 796 /* Search FEATURE for a register named NAME.  */
 797
 798 static struct tdesc_reg *
 799 tdesc_find_register_early (const struct tdesc_feature *feature,
 800                            const char *name)
 801 {
 802   for (const tdesc_reg_up &reg : feature->registers)
 803     if (strcasecmp (reg->name.c_str (), name) == 0)
 804       return reg.get ();
 805
 806   return NULL;
 807 }
 808
 809 /* Search FEATURE for a register named NAME.  Assign REGNO to it.  */
 810
 811 int
 812 tdesc_numbered_register (const struct tdesc_feature *feature,
 813                          struct tdesc_arch_data *data,
 814                          int regno, const char *name)
 815 {
 816   struct tdesc_reg *reg = tdesc_find_register_early (feature, name);
 817
 818   if (reg == NULL)
 819     return 0;
 820
 821   /* Make sure the vector includes a REGNO'th element.  */
 822   while (regno >= data->arch_regs.size ())
 823     data->arch_regs.emplace_back (nullptr, nullptr);
 824
 825   data->arch_regs[regno] = tdesc_arch_reg (reg, NULL);
 826
 827   return 1;
 828 }
 829
 830 /* Search FEATURE for a register named NAME, but do not assign a fixed
 831    register number to it.  */
 832
 833 int
 834 tdesc_unnumbered_register (const struct tdesc_feature *feature,
 835                            const char *name)
 836 {
 837   struct tdesc_reg *reg = tdesc_find_register_early (feature, name);
 838
 839   if (reg == NULL)
 840     return 0;
 841
 842   return 1;
 843 }
 844
 845 /* Search FEATURE for a register whose name is in NAMES and assign
 846    REGNO to it.  */
 847
 848 int
 849 tdesc_numbered_register_choices (const struct tdesc_feature *feature,
 850                                  struct tdesc_arch_data *data,
 851                                  int regno, const char *const names[])
 852 {
 853   int i;
 854
 855   for (i = 0; names[i] != NULL; i++)
 856     if (tdesc_numbered_register (feature, data, regno, names[i]))
 857       return 1;
 858
 859   return 0;
 860 }
 861
 862 /* Search FEATURE for a register named NAME, and return its size in
 863    bits.  The register must exist.  */
 864
 865 int
 866 tdesc_register_bitsize (const struct tdesc_feature *feature, const char *name)
 867 {
 868   struct tdesc_reg *reg = tdesc_find_register_early (feature, name);
 869
 870   gdb_assert (reg != NULL);
 871   return reg->bitsize;
 872 }
 873
 874 /* Look up a register by its GDB internal register number.  */
 875
 876 static struct tdesc_arch_reg *
 877 tdesc_find_arch_register (struct gdbarch *gdbarch, int regno)
 878 {
 879   struct tdesc_arch_data *data;
 880
 881   data = (struct tdesc_arch_data *) gdbarch_data (gdbarch, tdesc_data);
 882   if (regno < data->arch_regs.size ())
 883     return &data->arch_regs[regno];
 884   else
 885     return NULL;
 886 }
 887
 888 static struct tdesc_reg *
 889 tdesc_find_register (struct gdbarch *gdbarch, int regno)
 890 {
 891   struct tdesc_arch_reg *reg = tdesc_find_arch_register (gdbarch, regno);
 892
 893   return reg? reg->reg : NULL;
 894 }
 895
 896 /* Return the name of register REGNO, from the target description or
 897    from an architecture-provided pseudo_register_name method.  */
 898
 899 const char *
 900 tdesc_register_name (struct gdbarch *gdbarch, int regno)
 901 {
 902   struct tdesc_reg *reg = tdesc_find_register (gdbarch, regno);
 903   int num_regs = gdbarch_num_regs (gdbarch);
 904
 905   if (reg != NULL)
 906     return reg->name.c_str ();
 907
 908   if (regno >= num_regs && regno < gdbarch_num_cooked_regs (gdbarch))
 909     {
 910       struct tdesc_arch_data *data
 911         = (struct tdesc_arch_data *) gdbarch_data (gdbarch, tdesc_data);
 912
 913       gdb_assert (data->pseudo_register_name != NULL);
 914       return data->pseudo_register_name (gdbarch, regno);
 915     }
 916
 917   return "";
 918 }
 919
 920 struct type *
 921 tdesc_register_type (struct gdbarch *gdbarch, int regno)
 922 {
 923   struct tdesc_arch_reg *arch_reg = tdesc_find_arch_register (gdbarch, regno);
 924   struct tdesc_reg *reg = arch_reg? arch_reg->reg : NULL;
 925   int num_regs = gdbarch_num_regs (gdbarch);
 926   int num_pseudo_regs = gdbarch_num_pseudo_regs (gdbarch);
 927
 928   if (reg == NULL && regno >= num_regs && regno < num_regs + num_pseudo_regs)
 929     {
 930       struct tdesc_arch_data *data
 931         = (struct tdesc_arch_data *) gdbarch_data (gdbarch, tdesc_data);
 932
 933       gdb_assert (data->pseudo_register_type != NULL);
 934       return data->pseudo_register_type (gdbarch, regno);
 935     }
 936
 937   if (reg == NULL)
 938     /* Return "int0_t", since "void" has a misleading size of one.  */
 939     return builtin_type (gdbarch)->builtin_int0;
 940
 941   if (arch_reg->type == NULL)
 942     {
 943       /* First check for a predefined or target defined type.  */
 944       if (reg->tdesc_type)
 945         arch_reg->type = make_gdb_type (gdbarch, reg->tdesc_type);
 946
 947       /* Next try size-sensitive type shortcuts.  */
 948       else if (reg->type == "float")
 949         {
 950           if (reg->bitsize == gdbarch_float_bit (gdbarch))
 951             arch_reg->type = builtin_type (gdbarch)->builtin_float;
 952           else if (reg->bitsize == gdbarch_double_bit (gdbarch))
 953             arch_reg->type = builtin_type (gdbarch)->builtin_double;
 954           else if (reg->bitsize == gdbarch_long_double_bit (gdbarch))
 955             arch_reg->type = builtin_type (gdbarch)->builtin_long_double;
 956           else
 957             {
 958               warning (_("Register \"%s\" has an unsupported size (%d bits)"),
 959                        reg->name.c_str (), reg->bitsize);
 960               arch_reg->type = builtin_type (gdbarch)->builtin_double;
 961             }
 962         }
 963       else if (reg->type == "int")
 964         {
 965           if (reg->bitsize == gdbarch_long_bit (gdbarch))
 966             arch_reg->type = builtin_type (gdbarch)->builtin_long;
 967           else if (reg->bitsize == TARGET_CHAR_BIT)
 968             arch_reg->type = builtin_type (gdbarch)->builtin_char;
 969           else if (reg->bitsize == gdbarch_short_bit (gdbarch))
 970             arch_reg->type = builtin_type (gdbarch)->builtin_short;
 971           else if (reg->bitsize == gdbarch_int_bit (gdbarch))
 972             arch_reg->type = builtin_type (gdbarch)->builtin_int;
 973           else if (reg->bitsize == gdbarch_long_long_bit (gdbarch))
 974             arch_reg->type = builtin_type (gdbarch)->builtin_long_long;
 975           else if (reg->bitsize == gdbarch_ptr_bit (gdbarch))
 976           /* A bit desperate by this point...  */
 977             arch_reg->type = builtin_type (gdbarch)->builtin_data_ptr;
 978           else
 979             {
 980               warning (_("Register \"%s\" has an unsupported size (%d bits)"),
 981                        reg->name.c_str (), reg->bitsize);
 982               arch_reg->type = builtin_type (gdbarch)->builtin_long;
 983             }
 984         }
 985
 986       if (arch_reg->type == NULL)
 987         internal_error (__FILE__, __LINE__,
 988                         "Register \"%s\" has an unknown type \"%s\"",
 989                         reg->name.c_str (), reg->type.c_str ());
 990     }
 991
 992   return arch_reg->type;
 993 }
 994
 995 static int
 996 tdesc_remote_register_number (struct gdbarch *gdbarch, int regno)
 997 {
 998   struct tdesc_reg *reg = tdesc_find_register (gdbarch, regno);
 999
1000   if (reg != NULL)
1001     return reg->target_regnum;
1002   else
1003     return -1;
1004 }
1005
1006 /* Check whether REGNUM is a member of REGGROUP.  Registers from the
1007    target description may be classified as general, float, vector or other
1008    register groups registered with reggroup_add().  Unlike a gdbarch
1009    register_reggroup_p method, this function will return -1 if it does not
1010    know; the caller should handle registers with no specified group.
1011
1012    The names of containing features are not used.  This might be extended
1013    to display registers in some more useful groupings.
1014
1015    The save-restore flag is also implemented here.  */
1016
1017 int
1018 tdesc_register_in_reggroup_p (struct gdbarch *gdbarch, int regno,
1019                               struct reggroup *reggroup)
1020 {
1021   struct tdesc_reg *reg = tdesc_find_register (gdbarch, regno);
1022
1023   if (reg != NULL && !reg->group.empty ()
1024       && (reg->group == reggroup_name (reggroup)))
1025         return 1;
1026
1027   if (reg != NULL
1028       && (reggroup == save_reggroup || reggroup == restore_reggroup))
1029     return reg->save_restore;
1030
1031   return -1;
1032 }
1033
1034 /* Check whether REGNUM is a member of REGGROUP.  Registers with no
1035    group specified go to the default reggroup function and are handled
1036    by type.  */
1037
1038 static int
1039 tdesc_register_reggroup_p (struct gdbarch *gdbarch, int regno,
1040                            struct reggroup *reggroup)
1041 {
1042   int num_regs = gdbarch_num_regs (gdbarch);
1043   int num_pseudo_regs = gdbarch_num_pseudo_regs (gdbarch);
1044   int ret;
1045
1046   if (regno >= num_regs && regno < num_regs + num_pseudo_regs)
1047     {
1048       struct tdesc_arch_data *data
1049         = (struct tdesc_arch_data *) gdbarch_data (gdbarch, tdesc_data);
1050
1051       if (data->pseudo_register_reggroup_p != NULL)
1052         return data->pseudo_register_reggroup_p (gdbarch, regno, reggroup);
1053       /* Otherwise fall through to the default reggroup_p.  */
1054     }
1055
1056   ret = tdesc_register_in_reggroup_p (gdbarch, regno, reggroup);
1057   if (ret != -1)
1058     return ret;
1059
1060   return default_register_reggroup_p (gdbarch, regno, reggroup);
1061 }
1062
1063 /* Record architecture-specific functions to call for pseudo-register
1064    support.  */
1065
1066 void
1067 set_tdesc_pseudo_register_name (struct gdbarch *gdbarch,
1068                                 gdbarch_register_name_ftype *pseudo_name)
1069 {
1070   struct tdesc_arch_data *data
1071     = (struct tdesc_arch_data *) gdbarch_data (gdbarch, tdesc_data);
1072
1073   data->pseudo_register_name = pseudo_name;
1074 }
1075
1076 void
1077 set_tdesc_pseudo_register_type (struct gdbarch *gdbarch,
1078                                 gdbarch_register_type_ftype *pseudo_type)
1079 {
1080   struct tdesc_arch_data *data
1081     = (struct tdesc_arch_data *) gdbarch_data (gdbarch, tdesc_data);
1082
1083   data->pseudo_register_type = pseudo_type;
1084 }
1085
1086 void
1087 set_tdesc_pseudo_register_reggroup_p
1088   (struct gdbarch *gdbarch,
1089    gdbarch_register_reggroup_p_ftype *pseudo_reggroup_p)
1090 {
1091   struct tdesc_arch_data *data
1092     = (struct tdesc_arch_data *) gdbarch_data (gdbarch, tdesc_data);
1093
1094   data->pseudo_register_reggroup_p = pseudo_reggroup_p;
1095 }
1096
1097 /* Update GDBARCH to use the target description for registers.  */
1098
1099 void
1100 tdesc_use_registers (struct gdbarch *gdbarch,
1101                      const struct target_desc *target_desc,
1102                      tdesc_arch_data_up &&early_data,
1103                      tdesc_unknown_register_ftype unk_reg_cb)
1104 {
1105   int num_regs = gdbarch_num_regs (gdbarch);
1106   struct tdesc_arch_data *data;
1107
1108   /* We can't use the description for registers if it doesn't describe
1109      any.  This function should only be called after validating
1110      registers, so the caller should know that registers are
1111      included.  */
1112   gdb_assert (tdesc_has_registers (target_desc));
1113
1114   data = (struct tdesc_arch_data *) gdbarch_data (gdbarch, tdesc_data);
1115   data->arch_regs = std::move (early_data->arch_regs);
1116
1117   /* Build up a set of all registers, so that we can assign register
1118      numbers where needed.  The hash table expands as necessary, so
1119      the initial size is arbitrary.  */
1120   htab_up reg_hash (htab_create (37, htab_hash_pointer, htab_eq_pointer,
1121                                  NULL));
1122   for (const tdesc_feature_up &feature : target_desc->features)
1123     for (const tdesc_reg_up &reg : feature->registers)
1124       {
1125         void **slot = htab_find_slot (reg_hash.get (), reg.get (), INSERT);
1126
1127         *slot = reg.get ();
1128         /* Add reggroup if its new.  */
1129         if (!reg->group.empty ())
1130           if (reggroup_find (gdbarch, reg->group.c_str ()) == NULL)
1131             reggroup_add (gdbarch, reggroup_gdbarch_new (gdbarch,
1132                                                          reg->group.c_str (),
1133                                                          USER_REGGROUP));
1134       }
1135
1136   /* Remove any registers which were assigned numbers by the
1137      architecture.  */
1138   for (const tdesc_arch_reg &arch_reg : data->arch_regs)
1139     if (arch_reg.reg != NULL)
1140       htab_remove_elt (reg_hash.get (), arch_reg.reg);
1141
1142   /* Assign numbers to the remaining registers and add them to the
1143      list of registers.  The new numbers are always above gdbarch_num_regs.
1144      Iterate over the features, not the hash table, so that the order
1145      matches that in the target description.  */
1146
1147   gdb_assert (data->arch_regs.size () <= num_regs);
1148   while (data->arch_regs.size () < num_regs)
1149     data->arch_regs.emplace_back (nullptr, nullptr);
1150
1151   /* First we give the target a chance to number previously unknown
1152      registers.  This allows targets to record the numbers assigned based
1153      on which feature the register was from.  */
1154   if (unk_reg_cb != NULL)
1155     {
1156       for (const tdesc_feature_up &feature : target_desc->features)
1157         for (const tdesc_reg_up &reg : feature->registers)
1158           if (htab_find (reg_hash.get (), reg.get ()) != NULL)
1159             {
1160               int regno = unk_reg_cb (gdbarch, feature.get (),
1161                                       reg->name.c_str (), num_regs);
1162               gdb_assert (regno == -1 || regno >= num_regs);
1163               if (regno != -1)
1164                 {
1165                   while (regno >= data->arch_regs.size ())
1166                     data->arch_regs.emplace_back (nullptr, nullptr);
1167                   data->arch_regs[regno] = tdesc_arch_reg (reg.get (), NULL);
1168                   num_regs = regno + 1;
1169                   htab_remove_elt (reg_hash.get (), reg.get ());
1170                 }
1171             }
1172     }
1173
1174   /* Ensure the array was sized correctly above.  */
1175   gdb_assert (data->arch_regs.size () == num_regs);
1176
1177   /* Now in a final pass we assign register numbers to any remaining
1178      unnumbered registers.  */
1179   for (const tdesc_feature_up &feature : target_desc->features)
1180     for (const tdesc_reg_up &reg : feature->registers)
1181       if (htab_find (reg_hash.get (), reg.get ()) != NULL)
1182         {
1183           data->arch_regs.emplace_back (reg.get (), nullptr);
1184           num_regs++;
1185         }
1186
1187   /* Update the architecture.  */
1188   set_gdbarch_num_regs (gdbarch, num_regs);
1189   set_gdbarch_register_name (gdbarch, tdesc_register_name);
1190   set_gdbarch_register_type (gdbarch, tdesc_register_type);
1191   set_gdbarch_remote_register_number (gdbarch,
1192                                       tdesc_remote_register_number);
1193   set_gdbarch_register_reggroup_p (gdbarch, tdesc_register_reggroup_p);
1194 }
1195
1196 /* See gdbsupport/tdesc.h.  */
1197
1198 struct tdesc_feature *
1199 tdesc_create_feature (struct target_desc *tdesc, const char *name)
1200 {
1201   struct tdesc_feature *new_feature = new tdesc_feature (name);
1202
1203   tdesc->features.emplace_back (new_feature);
1204
1205   return new_feature;
1206 }
1207
1208 /* See gdbsupport/tdesc.h.  */
1209
1210 target_desc_up
1211 allocate_target_description (void)
1212 {
1213   return target_desc_up (new target_desc ());
1214 }
1215
1216 /* See gdbsupport/tdesc.h.  */
1217
1218 void
1219 target_desc_deleter::operator() (struct target_desc *target_desc) const
1220 {
1221   delete target_desc;
1222 }
1223
1224 void
1225 tdesc_add_compatible (struct target_desc *target_desc,
1226                       const struct bfd_arch_info *compatible)
1227 {
1228   /* If this instance of GDB is compiled without BFD support for the
1229      compatible architecture, simply ignore it -- we would not be able
1230      to handle it anyway.  */
1231   if (compatible == NULL)
1232     return;
1233
1234   for (const tdesc_compatible_info_up &compat : target_desc->compatible)
1235     if (compat->arch () == compatible)
1236       internal_error (__FILE__, __LINE__,
1237                       _("Attempted to add duplicate "
1238                         "compatible architecture \"%s\""),
1239                       compatible->printable_name);
1240
1241   target_desc->compatible.push_back
1242     (std::unique_ptr<tdesc_compatible_info>
1243      (new tdesc_compatible_info (compatible)));
1244 }
1245
1246 void
1247 set_tdesc_property (struct target_desc *target_desc,
1248                     const char *key, const char *value)
1249 {
1250   gdb_assert (key != NULL && value != NULL);
1251
1252   if (tdesc_property (target_desc, key) != NULL)
1253     internal_error (__FILE__, __LINE__,
1254                     _("Attempted to add duplicate property \"%s\""), key);
1255
1256   target_desc->properties.emplace_back (key, value);
1257 }
1258
1259 /* See gdbsupport/tdesc.h.  */
1260
1261 void
1262 set_tdesc_architecture (struct target_desc *target_desc,
1263                         const char *name)
1264 {
1265   set_tdesc_architecture (target_desc, bfd_scan_arch (name));
1266 }
1267
1268 void
1269 set_tdesc_architecture (struct target_desc *target_desc,
1270                         const struct bfd_arch_info *arch)
1271 {
1272   target_desc->arch = arch;
1273 }
1274
1275 /* See gdbsupport/tdesc.h.  */
1276
1277 void
1278 set_tdesc_osabi (struct target_desc *target_desc, const char *name)
1279 {
1280   set_tdesc_osabi (target_desc, osabi_from_tdesc_string (name));
1281 }
1282
1283 void
1284 set_tdesc_osabi (struct target_desc *target_desc, enum gdb_osabi osabi)
1285 {
1286   target_desc->osabi = osabi;
1287 }
1288 \f
1289
1290 static struct cmd_list_element *tdesc_set_cmdlist, *tdesc_show_cmdlist;
1291 static struct cmd_list_element *tdesc_unset_cmdlist;
1292
1293 /* Helper functions for the CLI commands.  */
1294
1295 static void
1296 set_tdesc_filename_cmd (const char *args, int from_tty,
1297                         struct cmd_list_element *c)
1298 {
1299   xfree (target_description_filename);
1300   target_description_filename = xstrdup (tdesc_filename_cmd_string);
1301
1302   target_clear_description ();
1303   target_find_description ();
1304 }
1305
1306 static void
1307 show_tdesc_filename_cmd (struct ui_file *file, int from_tty,
1308                          struct cmd_list_element *c,
1309                          const char *value)
1310 {
1311   value = target_description_filename;
1312
1313   if (value != NULL && *value != '\0')
1314     printf_filtered (_("The target description will be read from \"%s\".\n"),
1315                      value);
1316   else
1317     printf_filtered (_("The target description will be "
1318                        "read from the target.\n"));
1319 }
1320
1321 static void
1322 unset_tdesc_filename_cmd (const char *args, int from_tty)
1323 {
1324   xfree (target_description_filename);
1325   target_description_filename = NULL;
1326   target_clear_description ();
1327   target_find_description ();
1328 }
1329
1330 /* Print target description in C.  */
1331
1332 class print_c_tdesc : public tdesc_element_visitor
1333 {
1334 public:
1335   print_c_tdesc (std::string &filename_after_features)
1336     : m_filename_after_features (filename_after_features)
1337   {
1338     const char *inp;
1339     char *outp;
1340     const char *filename = lbasename (m_filename_after_features.c_str ());
1341
1342     m_function = (char *) xmalloc (strlen (filename) + 1);
1343     for (inp = filename, outp = m_function; *inp != '\0'; inp++)
1344       if (*inp == '.')
1345         break;
1346       else if (*inp == '-')
1347         *outp++ = '_';
1348       else if (*inp == ' ')
1349         *outp++ = '_';
1350       else
1351         *outp++ = *inp;
1352     *outp = '\0';
1353
1354     /* Standard boilerplate.  */
1355     printf_unfiltered ("/* THIS FILE IS GENERATED.  "
1356                        "-*- buffer-read-only: t -*- vi"
1357                        ":set ro:\n");
1358   }
1359
1360   ~print_c_tdesc ()
1361   {
1362     xfree (m_function);
1363   }
1364
1365   void visit_pre (const target_desc *e) override
1366   {
1367     printf_unfiltered ("  Original: %s */\n\n",
1368                        lbasename (m_filename_after_features.c_str ()));
1369
1370     printf_unfiltered ("#include \"defs.h\"\n");
1371     printf_unfiltered ("#include \"osabi.h\"\n");
1372     printf_unfiltered ("#include \"target-descriptions.h\"\n");
1373     printf_unfiltered ("\n");
1374
1375     printf_unfiltered ("struct target_desc *tdesc_%s;\n", m_function);
1376     printf_unfiltered ("static void\n");
1377     printf_unfiltered ("initialize_tdesc_%s (void)\n", m_function);
1378     printf_unfiltered ("{\n");
1379     printf_unfiltered
1380       ("  target_desc_up result = allocate_target_description ();\n");
1381
1382     if (tdesc_architecture (e) != NULL)
1383       {
1384         printf_unfiltered
1385           ("  set_tdesc_architecture (result.get (), bfd_scan_arch (\"%s\"));\n",
1386            tdesc_architecture (e)->printable_name);
1387         printf_unfiltered ("\n");
1388       }
1389     if (tdesc_osabi (e) > GDB_OSABI_UNKNOWN
1390         && tdesc_osabi (e) < GDB_OSABI_INVALID)
1391       {
1392         printf_unfiltered
1393           ("  set_tdesc_osabi (result.get (), osabi_from_tdesc_string (\"%s\"));\n",
1394            gdbarch_osabi_name (tdesc_osabi (e)));
1395         printf_unfiltered ("\n");
1396       }
1397
1398     for (const tdesc_compatible_info_up &compatible : e->compatible)
1399       printf_unfiltered
1400         ("  tdesc_add_compatible (result.get (), bfd_scan_arch (\"%s\"));\n",
1401          compatible->arch ()->printable_name);
1402
1403     if (!e->compatible.empty ())
1404       printf_unfiltered ("\n");
1405
1406     for (const property &prop : e->properties)
1407       printf_unfiltered ("  set_tdesc_property (result.get (), \"%s\", \"%s\");\n",
1408                          prop.key.c_str (), prop.value.c_str ());
1409
1410     printf_unfiltered ("  struct tdesc_feature *feature;\n");
1411   }
1412
1413   void visit_pre (const tdesc_feature *e) override
1414   {
1415     printf_unfiltered ("\n  feature = tdesc_create_feature (result.get (), \"%s\");\n",
1416                        e->name.c_str ());
1417   }
1418
1419   void visit_post (const tdesc_feature *e) override
1420   {}
1421
1422   void visit_post (const target_desc *e) override
1423   {
1424     printf_unfiltered ("\n  tdesc_%s = result.release ();\n", m_function);
1425     printf_unfiltered ("}\n");
1426   }
1427
1428   void visit (const tdesc_type_builtin *type) override
1429   {
1430     error (_("C output is not supported type \"%s\"."), type->name.c_str ());
1431   }
1432
1433   void visit (const tdesc_type_vector *type) override
1434   {
1435     if (!m_printed_element_type)
1436       {
1437         printf_unfiltered ("  tdesc_type *element_type;\n");
1438         m_printed_element_type = true;
1439       }
1440
1441     printf_unfiltered
1442       ("  element_type = tdesc_named_type (feature, \"%s\");\n",
1443        type->element_type->name.c_str ());
1444     printf_unfiltered
1445       ("  tdesc_create_vector (feature, \"%s\", element_type, %d);\n",
1446        type->name.c_str (), type->count);
1447
1448     printf_unfiltered ("\n");
1449   }
1450
1451   void visit (const tdesc_type_with_fields *type) override
1452   {
1453     if (!m_printed_type_with_fields)
1454       {
1455         printf_unfiltered ("  tdesc_type_with_fields *type_with_fields;\n");
1456         m_printed_type_with_fields = true;
1457       }
1458
1459     switch (type->kind)
1460       {
1461       case TDESC_TYPE_STRUCT:
1462       case TDESC_TYPE_FLAGS:
1463         if (type->kind == TDESC_TYPE_STRUCT)
1464           {
1465             printf_unfiltered
1466               ("  type_with_fields = tdesc_create_struct (feature, \"%s\");\n",
1467                type->name.c_str ());
1468             if (type->size != 0)
1469               printf_unfiltered
1470                 ("  tdesc_set_struct_size (type_with_fields, %d);\n", type->size);
1471           }
1472         else
1473           {
1474             printf_unfiltered
1475               ("  type_with_fields = tdesc_create_flags (feature, \"%s\", %d);\n",
1476                type->name.c_str (), type->size);
1477           }
1478         for (const tdesc_type_field &f : type->fields)
1479           {
1480             const char *type_name;
1481
1482             gdb_assert (f.type != NULL);
1483             type_name = f.type->name.c_str ();
1484
1485             /* To minimize changes to generated files, don't emit type
1486                info for fields that have defaulted types.  */
1487             if (f.start != -1)
1488               {
1489                 gdb_assert (f.end != -1);
1490                 if (f.type->kind == TDESC_TYPE_BOOL)
1491                   {
1492                     gdb_assert (f.start == f.end);
1493                     printf_unfiltered
1494                       ("  tdesc_add_flag (type_with_fields, %d, \"%s\");\n",
1495                        f.start, f.name.c_str ());
1496                   }
1497                 else if ((type->size == 4 && f.type->kind == TDESC_TYPE_UINT32)
1498                          || (type->size == 8
1499                              && f.type->kind == TDESC_TYPE_UINT64))
1500                   {
1501                     printf_unfiltered
1502                       ("  tdesc_add_bitfield (type_with_fields, \"%s\", %d, %d);\n",
1503                        f.name.c_str (), f.start, f.end);
1504                   }
1505                 else
1506                   {
1507                     printf_field_type_assignment
1508                       ("tdesc_named_type (feature, \"%s\");\n",
1509                        type_name);
1510                     printf_unfiltered
1511                       ("  tdesc_add_typed_bitfield (type_with_fields, \"%s\","
1512                        " %d, %d, field_type);\n",
1513                        f.name.c_str (), f.start, f.end);
1514                   }
1515               }
1516             else /* Not a bitfield.  */
1517               {
1518                 gdb_assert (f.end == -1);
1519                 gdb_assert (type->kind == TDESC_TYPE_STRUCT);
1520                 printf_field_type_assignment
1521                   ("tdesc_named_type (feature, \"%s\");\n", type_name);
1522                 printf_unfiltered
1523                   ("  tdesc_add_field (type_with_fields, \"%s\", field_type);\n",
1524                    f.name.c_str ());
1525               }
1526           }
1527         break;
1528       case TDESC_TYPE_UNION:
1529         printf_unfiltered
1530           ("  type_with_fields = tdesc_create_union (feature, \"%s\");\n",
1531            type->name.c_str ());
1532         for (const tdesc_type_field &f : type->fields)
1533           {
1534             printf_field_type_assignment
1535               ("tdesc_named_type (feature, \"%s\");\n", f.type->name.c_str ());
1536             printf_unfiltered
1537               ("  tdesc_add_field (type_with_fields, \"%s\", field_type);\n",
1538                f.name.c_str ());
1539           }
1540         break;
1541       case TDESC_TYPE_ENUM:
1542         printf_unfiltered
1543           ("  type_with_fields = tdesc_create_enum (feature, \"%s\", %d);\n",
1544            type->name.c_str (), type->size);
1545         for (const tdesc_type_field &f : type->fields)
1546           printf_unfiltered
1547             ("  tdesc_add_enum_value (type_with_fields, %d, \"%s\");\n",
1548              f.start, f.name.c_str ());
1549         break;
1550       default:
1551         error (_("C output is not supported type \"%s\"."), type->name.c_str ());
1552       }
1553
1554     printf_unfiltered ("\n");
1555   }
1556
1557   void visit (const tdesc_reg *reg) override
1558   {
1559     printf_unfiltered ("  tdesc_create_reg (feature, \"%s\", %ld, %d, ",
1560                        reg->name.c_str (), reg->target_regnum,
1561                        reg->save_restore);
1562     if (!reg->group.empty ())
1563       printf_unfiltered ("\"%s\", ", reg->group.c_str ());
1564     else
1565       printf_unfiltered ("NULL, ");
1566     printf_unfiltered ("%d, \"%s\");\n", reg->bitsize, reg->type.c_str ());
1567   }
1568
1569 protected:
1570   std::string m_filename_after_features;
1571
1572 private:
1573
1574   /* Print an assignment to the field_type variable.  Print the declaration
1575      of field_type if that has not been done yet.  */
1576   ATTRIBUTE_PRINTF (2, 3)
1577   void printf_field_type_assignment (const char *fmt, ...)
1578   {
1579     if (!m_printed_field_type)
1580       {
1581         printf_unfiltered ("  tdesc_type *field_type;\n");
1582         m_printed_field_type = true;
1583       }
1584
1585     printf_unfiltered ("  field_type = ");
1586
1587     va_list args;
1588     va_start (args, fmt);
1589     vprintf_unfiltered (fmt, args);
1590     va_end (args);
1591   }
1592
1593   char *m_function;
1594
1595   /* Did we print "struct tdesc_type *element_type;" yet?  */
1596   bool m_printed_element_type = false;
1597
1598   /* Did we print "struct tdesc_type_with_fields *element_type;" yet?  */
1599   bool m_printed_type_with_fields = false;
1600
1601   /* Did we print "struct tdesc_type *field_type;" yet?  */
1602   bool m_printed_field_type = false;
1603 };
1604
1605 /* Print target description feature in C.  */
1606
1607 class print_c_feature : public print_c_tdesc
1608 {
1609 public:
1610   print_c_feature (std::string &file)
1611     : print_c_tdesc (file)
1612   {
1613     /* Trim ".tmp".  */
1614     auto const pos = m_filename_after_features.find_last_of ('.');
1615
1616     m_filename_after_features = m_filename_after_features.substr (0, pos);
1617   }
1618
1619   void visit_pre (const target_desc *e) override
1620   {
1621     printf_unfiltered ("  Original: %s */\n\n",
1622                        lbasename (m_filename_after_features.c_str ()));
1623
1624     printf_unfiltered ("#include \"gdbsupport/tdesc.h\"\n");
1625     printf_unfiltered ("\n");
1626   }
1627
1628   void visit_post (const target_desc *e) override
1629   {}
1630
1631   void visit_pre (const tdesc_feature *e) override
1632   {
1633     std::string name (m_filename_after_features);
1634
1635     auto pos = name.find_first_of ('.');
1636
1637     name = name.substr (0, pos);
1638     std::replace (name.begin (), name.end (), '/', '_');
1639     std::replace (name.begin (), name.end (), '-', '_');
1640
1641     printf_unfiltered ("static int\n");
1642     printf_unfiltered ("create_feature_%s ", name.c_str ());
1643     printf_unfiltered ("(struct target_desc *result, long regnum)\n");
1644
1645     printf_unfiltered ("{\n");
1646     printf_unfiltered ("  struct tdesc_feature *feature;\n");
1647
1648     printf_unfiltered
1649       ("\n  feature = tdesc_create_feature (result, \"%s\");\n",
1650        e->name.c_str ());
1651   }
1652
1653   void visit_post (const tdesc_feature *e) override
1654   {
1655     printf_unfiltered ("  return regnum;\n");
1656     printf_unfiltered ("}\n");
1657   }
1658
1659   void visit (const tdesc_reg *reg) override
1660   {
1661     /* Most "reg" in XML target descriptions don't have "regnum"
1662        attribute, so the register number is allocated sequentially.
1663        In case that reg has "regnum" attribute, register number
1664        should be set by that explicitly.  */
1665
1666     if (reg->target_regnum < m_next_regnum)
1667       {
1668         /* The integrity check, it can catch some errors on register
1669            number collision, like this,
1670
1671           <reg name="x0" bitsize="32"/>
1672           <reg name="x1" bitsize="32"/>
1673           <reg name="x2" bitsize="32"/>
1674           <reg name="x3" bitsize="32"/>
1675           <reg name="ps" bitsize="32" regnum="3"/>
1676
1677           but it also has false negatives.  The target description
1678           below is correct,
1679
1680           <reg name="x1" bitsize="32" regnum="1"/>
1681           <reg name="x3" bitsize="32" regnum="3"/>
1682           <reg name="x2" bitsize="32" regnum="2"/>
1683           <reg name="x4" bitsize="32" regnum="4"/>
1684
1685           but it is not a good practice, so still error on this,
1686           and also print the message so that it can be saved in the
1687           generated c file.  */
1688
1689         printf_unfiltered ("ERROR: \"regnum\" attribute %ld ",
1690                            reg->target_regnum);
1691         printf_unfiltered ("is not the largest number (%d).\n",
1692                            m_next_regnum);
1693         error (_("\"regnum\" attribute %ld is not the largest number (%d)."),
1694                reg->target_regnum, m_next_regnum);
1695       }
1696
1697     if (reg->target_regnum > m_next_regnum)
1698       {
1699         printf_unfiltered ("  regnum = %ld;\n", reg->target_regnum);
1700         m_next_regnum = reg->target_regnum;
1701       }
1702
1703     printf_unfiltered ("  tdesc_create_reg (feature, \"%s\", regnum++, %d, ",
1704                        reg->name.c_str (), reg->save_restore);
1705     if (!reg->group.empty ())
1706       printf_unfiltered ("\"%s\", ", reg->group.c_str ());
1707     else
1708       printf_unfiltered ("NULL, ");
1709     printf_unfiltered ("%d, \"%s\");\n", reg->bitsize, reg->type.c_str ());
1710
1711     m_next_regnum++;
1712   }
1713
1714 private:
1715   /* The register number to use for the next register we see.  */
1716   int m_next_regnum = 0;
1717 };
1718
1719 /* See gdbsupport/tdesc.h.  */
1720
1721 const char *
1722 tdesc_get_features_xml (const target_desc *tdesc)
1723 {
1724   if (tdesc->xmltarget == nullptr)
1725     {
1726       std::string buffer ("@");
1727       print_xml_feature v (&buffer);
1728       tdesc->accept (v);
1729       tdesc->xmltarget = xstrdup (buffer.c_str ());
1730     }
1731   return tdesc->xmltarget;
1732 }
1733
1734 /* Data structures and functions to setup the option flags for 'maintenance
1735    print c-tdesc command.  */
1736
1737 struct maint_print_c_tdesc_options
1738 {
1739   /* True when the '-single-feature' flag was passed.  */
1740   bool single_feature = false;
1741 };
1742
1743 using maint_print_c_tdesc_opt_def
1744   = gdb::option::flag_option_def<maint_print_c_tdesc_options>;
1745
1746 static const gdb::option::option_def maint_print_c_tdesc_opt_defs[] = {
1747   maint_print_c_tdesc_opt_def {
1748     "single-feature",
1749     [] (maint_print_c_tdesc_options *opt) { return &opt->single_feature; },
1750     N_("Print C description of just a single feature.")
1751   },
1752 };
1753
1754 static inline gdb::option::option_def_group
1755 make_maint_print_c_tdesc_options_def_group (maint_print_c_tdesc_options *opts)
1756 {
1757   return {{maint_print_c_tdesc_opt_defs}, opts};
1758 }
1759
1760 /* Implement 'maintenance print c-tdesc' command.  */
1761
1762 static void
1763 maint_print_c_tdesc_cmd (const char *args, int from_tty)
1764 {
1765   const struct target_desc *tdesc;
1766   const char *filename;
1767
1768   maint_print_c_tdesc_options opts;
1769   auto grp = make_maint_print_c_tdesc_options_def_group (&opts);
1770   gdb::option::process_options
1771     (&args, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR, grp);
1772
1773   if (args == NULL)
1774     {
1775       /* Use the global target-supplied description, not the current
1776          architecture's.  This lets a GDB for one architecture generate C
1777          for another architecture's description, even though the gdbarch
1778          initialization code will reject the new description.  */
1779       tdesc = current_target_desc;
1780       filename = target_description_filename;
1781     }
1782   else
1783     {
1784       /* Use the target description from the XML file.  */
1785       filename = args;
1786       tdesc = file_read_description_xml (filename);
1787     }
1788
1789   if (tdesc == NULL)
1790     error (_("There is no target description to print."));
1791
1792   if (filename == NULL)
1793     filename = "fetched from target";
1794
1795   std::string filename_after_features (filename);
1796   auto loc = filename_after_features.rfind ("/features/");
1797
1798   if (loc != std::string::npos)
1799     filename_after_features = filename_after_features.substr (loc + 10);
1800
1801   /* Print c files for target features instead of target descriptions,
1802      because c files got from target features are more flexible than the
1803      counterparts.  */
1804   if (opts.single_feature)
1805     {
1806       if (tdesc->features.size () != 1)
1807         error (_("only target descriptions with 1 feature can be used "
1808                  "with -single-feature option"));
1809
1810       print_c_feature v (filename_after_features);
1811
1812       tdesc->accept (v);
1813     }
1814   else
1815     {
1816       print_c_tdesc v (filename_after_features);
1817
1818       tdesc->accept (v);
1819     }
1820 }
1821
1822 /* Completer for the "backtrace" command.  */
1823
1824 static void
1825 maint_print_c_tdesc_cmd_completer (struct cmd_list_element *ignore,
1826                                    completion_tracker &tracker,
1827                                    const char *text, const char *word)
1828 {
1829   auto grp = make_maint_print_c_tdesc_options_def_group (nullptr);
1830   if (gdb::option::complete_options
1831       (tracker, &text, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR, grp))
1832     return;
1833
1834   word = advance_to_filename_complete_word_point (tracker, text);
1835   filename_completer (ignore, tracker, text, word);
1836 }
1837
1838 /* Implement the maintenance print xml-tdesc command.  */
1839
1840 static void
1841 maint_print_xml_tdesc_cmd (const char *args, int from_tty)
1842 {
1843   const struct target_desc *tdesc;
1844
1845   if (args == NULL)
1846     {
1847       /* Use the global target-supplied description, not the current
1848          architecture's.  This lets a GDB for one architecture generate XML
1849          for another architecture's description, even though the gdbarch
1850          initialization code will reject the new description.  */
1851       tdesc = current_target_desc;
1852     }
1853   else
1854     {
1855       /* Use the target description from the XML file.  */
1856       tdesc = file_read_description_xml (args);
1857     }
1858
1859   if (tdesc == NULL)
1860     error (_("There is no target description to print."));
1861
1862   std::string buf;
1863   print_xml_feature v (&buf);
1864   tdesc->accept (v);
1865   puts_unfiltered (buf.c_str ());
1866 }
1867
1868 namespace selftests {
1869
1870 /* A reference target description, used for testing (see record_xml_tdesc).  */
1871
1872 struct xml_test_tdesc
1873 {
1874   xml_test_tdesc (const char *name, std::unique_ptr<const target_desc> &&tdesc)
1875     : name (name), tdesc (std::move (tdesc))
1876   {}
1877
1878   const char *name;
1879   std::unique_ptr<const target_desc> tdesc;
1880 };
1881
1882 static std::vector<xml_test_tdesc> xml_tdesc;
1883
1884 #if GDB_SELF_TEST
1885
1886 /* See target-descriptions.h.  */
1887
1888 void
1889 record_xml_tdesc (const char *xml_file, const struct target_desc *tdesc)
1890 {
1891   xml_tdesc.emplace_back (xml_file, std::unique_ptr<const target_desc> (tdesc));
1892 }
1893 #endif
1894
1895 }
1896
1897 /* Test the conversion process of a target description to/from xml: Take a target
1898    description TDESC, convert to xml, back to a description, and confirm the new
1899    tdesc is identical to the original.  */
1900 static bool
1901 maintenance_check_tdesc_xml_convert (const target_desc *tdesc, const char *name)
1902 {
1903   const char *xml = tdesc_get_features_xml (tdesc);
1904
1905   if (xml == nullptr || *xml != '@')
1906     {
1907       printf_filtered (_("Could not convert description for %s to xml.\n"),
1908                        name);
1909       return false;
1910     }
1911
1912   const target_desc *tdesc_trans = string_read_description_xml (xml + 1);
1913
1914   if (tdesc_trans == nullptr)
1915     {
1916       printf_filtered (_("Could not convert description for %s from xml.\n"),
1917                        name);
1918       return false;
1919     }
1920   else if (*tdesc != *tdesc_trans)
1921     {
1922       printf_filtered (_("Converted description for %s does not match.\n"),
1923                        name);
1924       return false;
1925     }
1926   return true;
1927 }
1928
1929
1930 /* Check that the target descriptions created dynamically by
1931    architecture-specific code equal the descriptions created from XML files
1932    found in the specified directory DIR.  */
1933
1934 static void
1935 maintenance_check_xml_descriptions (const char *dir, int from_tty)
1936 {
1937   if (dir == NULL)
1938     error (_("Missing dir name"));
1939
1940   gdb::unique_xmalloc_ptr<char> dir1 (tilde_expand (dir));
1941   std::string feature_dir (dir1.get ());
1942   unsigned int failed = 0;
1943
1944   for (auto const &e : selftests::xml_tdesc)
1945     {
1946       std::string tdesc_xml = (feature_dir + SLASH_STRING + e.name);
1947       const target_desc *tdesc
1948         = file_read_description_xml (tdesc_xml.data ());
1949
1950       if (tdesc == NULL || *tdesc != *e.tdesc)
1951         {
1952           printf_filtered ( _("Descriptions for %s do not match.\n"), e.name);
1953           failed++;
1954         }
1955       else if (!maintenance_check_tdesc_xml_convert (tdesc, e.name)
1956                || !maintenance_check_tdesc_xml_convert (e.tdesc.get (), e.name))
1957         failed++;
1958     }
1959   printf_filtered (_("Tested %lu XML files, %d failed\n"),
1960                    (long) selftests::xml_tdesc.size (), failed);
1961 }
1962
1963 void _initialize_target_descriptions ();
1964 void
1965 _initialize_target_descriptions ()
1966 {
1967   cmd_list_element *cmd;
1968
1969   tdesc_data = gdbarch_data_register_pre_init (tdesc_data_init);
1970
1971   add_basic_prefix_cmd ("tdesc", class_maintenance, _("\
1972 Set target description specific variables."),
1973                         &tdesc_set_cmdlist, "set tdesc ",
1974                         0 /* allow-unknown */, &setlist);
1975   add_show_prefix_cmd ("tdesc", class_maintenance, _("\
1976 Show target description specific variables."),
1977                        &tdesc_show_cmdlist, "show tdesc ",
1978                        0 /* allow-unknown */, &showlist);
1979   add_basic_prefix_cmd ("tdesc", class_maintenance, _("\
1980 Unset target description specific variables."),
1981                         &tdesc_unset_cmdlist, "unset tdesc ",
1982                         0 /* allow-unknown */, &unsetlist);
1983
1984   add_setshow_filename_cmd ("filename", class_obscure,
1985                             &tdesc_filename_cmd_string,
1986                             _("\
1987 Set the file to read for an XML target description."), _("\
1988 Show the file to read for an XML target description."), _("\
1989 When set, GDB will read the target description from a local\n\
1990 file instead of querying the remote target."),
1991                             set_tdesc_filename_cmd,
1992                             show_tdesc_filename_cmd,
1993                             &tdesc_set_cmdlist, &tdesc_show_cmdlist);
1994
1995   add_cmd ("filename", class_obscure, unset_tdesc_filename_cmd, _("\
1996 Unset the file to read for an XML target description.\n\
1997 When unset, GDB will read the description from the target."),
1998            &tdesc_unset_cmdlist);
1999
2000   auto grp = make_maint_print_c_tdesc_options_def_group (nullptr);
2001   static std::string help_text
2002     = gdb::option::build_help (_("\
2003 Print the current target description as a C source file.\n\
2004 Usage: maintenance print c-tdesc [OPTION] [FILENAME]\n\
2005 \n\
2006 Options:\n\
2007 %OPTIONS%\n\
2008 \n\
2009 When FILENAME is not provided then print the current target\n\
2010 description, otherwise an XML target description is read from\n\
2011 FILENAME and printed as a C function.\n\
2012 \n\
2013 When '-single-feature' is used then the target description should\n\
2014 contain a single feature and the generated C code will only create\n\
2015 that feature within an already existing target_desc object."), grp);
2016   cmd = add_cmd ("c-tdesc", class_maintenance, maint_print_c_tdesc_cmd,
2017                  help_text.c_str (), &maintenanceprintlist);
2018   set_cmd_completer_handle_brkchars (cmd, maint_print_c_tdesc_cmd_completer);
2019
2020   cmd = add_cmd ("xml-tdesc", class_maintenance, maint_print_xml_tdesc_cmd, _("\
2021 Print the current target description as an XML file."),
2022                  &maintenanceprintlist);
2023   set_cmd_completer (cmd, filename_completer);
2024
2025   cmd = add_cmd ("xml-descriptions", class_maintenance,
2026                  maintenance_check_xml_descriptions, _("\
2027 Check equality of GDB target descriptions and XML created descriptions.\n\
2028 Check the target descriptions created in GDB equal the descriptions\n\
2029 created from XML files in the directory.\n\
2030 The parameter is the directory name."),
2031                  &maintenancechecklist);
2032   set_cmd_completer (cmd, filename_completer);
2033 }