gdb/target-descriptions.c

   1 /* Target description support for GDB.
   2
   3    Copyright (C) 2006, 2007, 2008, 2009 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 "vec.h"
  30 #include "xml-support.h"
  31 #include "xml-tdesc.h"
  32
  33 #include "gdb_assert.h"
  34 #include "gdb_obstack.h"
  35 #include "hashtab.h"
  36
  37 /* Types.  */
  38
  39 typedef struct property
  40 {
  41   char *key;
  42   char *value;
  43 } property_s;
  44 DEF_VEC_O(property_s);
  45
  46 /* An individual register from a target description.  */
  47
  48 typedef struct tdesc_reg
  49 {
  50   /* The name of this register.  In standard features, it may be
  51      recognized by the architecture support code, or it may be purely
  52      for the user.  */
  53   char *name;
  54
  55   /* The register number used by this target to refer to this
  56      register.  This is used for remote p/P packets and to determine
  57      the ordering of registers in the remote g/G packets.  */
  58   long target_regnum;
  59
  60   /* If this flag is set, GDB should save and restore this register
  61      around calls to an inferior function.  */
  62   int save_restore;
  63
  64   /* The name of the register group containing this register, or NULL
  65      if the group should be automatically determined from the
  66      register's type.  If this is "general", "float", or "vector", the
  67      corresponding "info" command should display this register's
  68      value.  It can be an arbitrary string, but should be limited to
  69      alphanumeric characters and internal hyphens.  Currently other
  70      strings are ignored (treated as NULL).  */
  71   char *group;
  72
  73   /* The size of the register, in bits.  */
  74   int bitsize;
  75
  76   /* The type of the register.  This string corresponds to either
  77      a named type from the target description or a predefined
  78      type from GDB.  */
  79   char *type;
  80
  81   /* The target-described type corresponding to TYPE, if found.  */
  82   struct tdesc_type *tdesc_type;
  83 } *tdesc_reg_p;
  84 DEF_VEC_P(tdesc_reg_p);
  85
  86 /* A named type from a target description.  */
  87
  88 typedef struct tdesc_type_field
  89 {
  90   char *name;
  91   struct tdesc_type *type;
  92 } tdesc_type_field;
  93 DEF_VEC_O(tdesc_type_field);
  94
  95 typedef struct tdesc_type
  96 {
  97   /* The name of this type.  */
  98   char *name;
  99
 100   /* Identify the kind of this type.  */
 101   enum
 102   {
 103     /* Predefined types.  */
 104     TDESC_TYPE_INT8,
 105     TDESC_TYPE_INT16,
 106     TDESC_TYPE_INT32,
 107     TDESC_TYPE_INT64,
 108     TDESC_TYPE_INT128,
 109     TDESC_TYPE_UINT8,
 110     TDESC_TYPE_UINT16,
 111     TDESC_TYPE_UINT32,
 112     TDESC_TYPE_UINT64,
 113     TDESC_TYPE_UINT128,
 114     TDESC_TYPE_CODE_PTR,
 115     TDESC_TYPE_DATA_PTR,
 116     TDESC_TYPE_IEEE_SINGLE,
 117     TDESC_TYPE_IEEE_DOUBLE,
 118     TDESC_TYPE_ARM_FPA_EXT,
 119
 120     /* Types defined by a target feature.  */
 121     TDESC_TYPE_VECTOR,
 122     TDESC_TYPE_UNION
 123   } kind;
 124
 125   /* Kind-specific data.  */
 126   union
 127   {
 128     /* Vector type.  */
 129     struct
 130     {
 131       struct tdesc_type *type;
 132       int count;
 133     } v;
 134
 135     /* Union type.  */
 136     struct
 137     {
 138       VEC(tdesc_type_field) *fields;
 139     } u;
 140   } u;
 141 } *tdesc_type_p;
 142 DEF_VEC_P(tdesc_type_p);
 143
 144 /* A feature from a target description.  Each feature is a collection
 145    of other elements, e.g. registers and types.  */
 146
 147 typedef struct tdesc_feature
 148 {
 149   /* The name of this feature.  It may be recognized by the architecture
 150      support code.  */
 151   char *name;
 152
 153   /* The registers associated with this feature.  */
 154   VEC(tdesc_reg_p) *registers;
 155
 156   /* The types associated with this feature.  */
 157   VEC(tdesc_type_p) *types;
 158 } *tdesc_feature_p;
 159 DEF_VEC_P(tdesc_feature_p);
 160
 161 /* A target description.  */
 162
 163 struct target_desc
 164 {
 165   /* The architecture reported by the target, if any.  */
 166   const struct bfd_arch_info *arch;
 167
 168   /* The osabi reported by the target, if any; GDB_OSABI_UNKNOWN
 169      otherwise.  */
 170   enum gdb_osabi osabi;
 171
 172   /* Any architecture-specific properties specified by the target.  */
 173   VEC(property_s) *properties;
 174
 175   /* The features associated with this target.  */
 176   VEC(tdesc_feature_p) *features;
 177 };
 178
 179 /* Per-architecture data associated with a target description.  The
 180    target description may be shared by multiple architectures, but
 181    this data is private to one gdbarch.  */
 182
 183 typedef struct tdesc_arch_reg
 184 {
 185   struct tdesc_reg *reg;
 186   struct type *type;
 187 } tdesc_arch_reg;
 188 DEF_VEC_O(tdesc_arch_reg);
 189
 190 struct tdesc_arch_data
 191 {
 192   /* A list of register/type pairs, indexed by GDB's internal register number.
 193      During initialization of the gdbarch this list is used to store
 194      registers which the architecture assigns a fixed register number.
 195      Registers which are NULL in this array, or off the end, are
 196      treated as zero-sized and nameless (i.e. placeholders in the
 197      numbering).  */
 198   VEC(tdesc_arch_reg) *arch_regs;
 199
 200   /* Functions which report the register name, type, and reggroups for
 201      pseudo-registers.  */
 202   gdbarch_register_name_ftype *pseudo_register_name;
 203   gdbarch_register_type_ftype *pseudo_register_type;
 204   gdbarch_register_reggroup_p_ftype *pseudo_register_reggroup_p;
 205 };
 206
 207 /* Global state.  These variables are associated with the current
 208    target; if GDB adds support for multiple simultaneous targets, then
 209    these variables should become target-specific data.  */
 210
 211 /* A flag indicating that a description has already been fetched from
 212    the current target, so it should not be queried again.  */
 213
 214 static int target_desc_fetched;
 215
 216 /* The description fetched from the current target, or NULL if the
 217    current target did not supply any description.  Only valid when
 218    target_desc_fetched is set.  Only the description initialization
 219    code should access this; normally, the description should be
 220    accessed through the gdbarch object.  */
 221
 222 static const struct target_desc *current_target_desc;
 223
 224 /* Other global variables.  */
 225
 226 /* The filename to read a target description from.  */
 227
 228 static char *target_description_filename;
 229
 230 /* A handle for architecture-specific data associated with the
 231    target description (see struct tdesc_arch_data).  */
 232
 233 static struct gdbarch_data *tdesc_data;
 234
 235 /* Fetch the current target's description, and switch the current
 236    architecture to one which incorporates that description.  */
 237
 238 void
 239 target_find_description (void)
 240 {
 241   /* If we've already fetched a description from the target, don't do
 242      it again.  This allows a target to fetch the description early,
 243      during its to_open or to_create_inferior, if it needs extra
 244      information about the target to initialize.  */
 245   if (target_desc_fetched)
 246     return;
 247
 248   /* The current architecture should not have any target description
 249      specified.  It should have been cleared, e.g. when we
 250      disconnected from the previous target.  */
 251   gdb_assert (gdbarch_target_desc (target_gdbarch) == NULL);
 252
 253   /* First try to fetch an XML description from the user-specified
 254      file.  */
 255   current_target_desc = NULL;
 256   if (target_description_filename != NULL
 257       && *target_description_filename != '\0')
 258     current_target_desc
 259       = file_read_description_xml (target_description_filename);
 260
 261   /* Next try to read the description from the current target using
 262      target objects.  */
 263   if (current_target_desc == NULL)
 264     current_target_desc = target_read_description_xml (&current_target);
 265
 266   /* If that failed try a target-specific hook.  */
 267   if (current_target_desc == NULL)
 268     current_target_desc = target_read_description (&current_target);
 269
 270   /* If a non-NULL description was returned, then update the current
 271      architecture.  */
 272   if (current_target_desc)
 273     {
 274       struct gdbarch_info info;
 275
 276       gdbarch_info_init (&info);
 277       info.target_desc = current_target_desc;
 278       if (!gdbarch_update_p (info))
 279         warning (_("Architecture rejected target-supplied description"));
 280       else
 281         {
 282           struct tdesc_arch_data *data;
 283
 284           data = gdbarch_data (target_gdbarch, tdesc_data);
 285           if (tdesc_has_registers (current_target_desc)
 286               && data->arch_regs == NULL)
 287             warning (_("Target-supplied registers are not supported "
 288                        "by the current architecture"));
 289         }
 290     }
 291
 292   /* Now that we know this description is usable, record that we
 293      fetched it.  */
 294   target_desc_fetched = 1;
 295 }
 296
 297 /* Discard any description fetched from the current target, and switch
 298    the current architecture to one with no target description.  */
 299
 300 void
 301 target_clear_description (void)
 302 {
 303   struct gdbarch_info info;
 304
 305   if (!target_desc_fetched)
 306     return;
 307
 308   target_desc_fetched = 0;
 309   current_target_desc = NULL;
 310
 311   gdbarch_info_init (&info);
 312   if (!gdbarch_update_p (info))
 313     internal_error (__FILE__, __LINE__,
 314                     _("Could not remove target-supplied description"));
 315 }
 316
 317 /* Return the global current target description.  This should only be
 318    used by gdbarch initialization code; most access should be through
 319    an existing gdbarch.  */
 320
 321 const struct target_desc *
 322 target_current_description (void)
 323 {
 324   if (target_desc_fetched)
 325     return current_target_desc;
 326
 327   return NULL;
 328 }
 329 \f
 330
 331 /* Direct accessors for target descriptions.  */
 332
 333 /* Return the string value of a property named KEY, or NULL if the
 334    property was not specified.  */
 335
 336 const char *
 337 tdesc_property (const struct target_desc *target_desc, const char *key)
 338 {
 339   struct property *prop;
 340   int ix;
 341
 342   for (ix = 0; VEC_iterate (property_s, target_desc->properties, ix, prop);
 343        ix++)
 344     if (strcmp (prop->key, key) == 0)
 345       return prop->value;
 346
 347   return NULL;
 348 }
 349
 350 /* Return the BFD architecture associated with this target
 351    description, or NULL if no architecture was specified.  */
 352
 353 const struct bfd_arch_info *
 354 tdesc_architecture (const struct target_desc *target_desc)
 355 {
 356   return target_desc->arch;
 357 }
 358
 359 /* Return the OSABI associated with this target description, or
 360    GDB_OSABI_UNKNOWN if no osabi was specified.  */
 361
 362 enum gdb_osabi
 363 tdesc_osabi (const struct target_desc *target_desc)
 364 {
 365   return target_desc->osabi;
 366 }
 367
 368 \f
 369
 370 /* Return 1 if this target description includes any registers.  */
 371
 372 int
 373 tdesc_has_registers (const struct target_desc *target_desc)
 374 {
 375   int ix;
 376   struct tdesc_feature *feature;
 377
 378   if (target_desc == NULL)
 379     return 0;
 380
 381   for (ix = 0;
 382        VEC_iterate (tdesc_feature_p, target_desc->features, ix, feature);
 383        ix++)
 384     if (! VEC_empty (tdesc_reg_p, feature->registers))
 385       return 1;
 386
 387   return 0;
 388 }
 389
 390 /* Return the feature with the given name, if present, or NULL if
 391    the named feature is not found.  */
 392
 393 const struct tdesc_feature *
 394 tdesc_find_feature (const struct target_desc *target_desc,
 395                     const char *name)
 396 {
 397   int ix;
 398   struct tdesc_feature *feature;
 399
 400   for (ix = 0;
 401        VEC_iterate (tdesc_feature_p, target_desc->features, ix, feature);
 402        ix++)
 403     if (strcmp (feature->name, name) == 0)
 404       return feature;
 405
 406   return NULL;
 407 }
 408
 409 /* Return the name of FEATURE.  */
 410
 411 const char *
 412 tdesc_feature_name (const struct tdesc_feature *feature)
 413 {
 414   return feature->name;
 415 }
 416
 417 /* Predefined types.  */
 418 static struct tdesc_type tdesc_predefined_types[] =
 419 {
 420   { "int8", TDESC_TYPE_INT8 },
 421   { "int16", TDESC_TYPE_INT16 },
 422   { "int32", TDESC_TYPE_INT32 },
 423   { "int64", TDESC_TYPE_INT64 },
 424   { "int128", TDESC_TYPE_INT128 },
 425   { "uint8", TDESC_TYPE_UINT8 },
 426   { "uint16", TDESC_TYPE_UINT16 },
 427   { "uint32", TDESC_TYPE_UINT32 },
 428   { "uint64", TDESC_TYPE_UINT64 },
 429   { "uint128", TDESC_TYPE_UINT128 },
 430   { "code_ptr", TDESC_TYPE_CODE_PTR },
 431   { "data_ptr", TDESC_TYPE_DATA_PTR },
 432   { "ieee_single", TDESC_TYPE_IEEE_SINGLE },
 433   { "ieee_double", TDESC_TYPE_IEEE_DOUBLE },
 434   { "arm_fpa_ext", TDESC_TYPE_ARM_FPA_EXT }
 435 };
 436
 437 /* Return the type associated with ID in the context of FEATURE, or
 438    NULL if none.  */
 439
 440 struct tdesc_type *
 441 tdesc_named_type (const struct tdesc_feature *feature, const char *id)
 442 {
 443   int ix;
 444   struct tdesc_type *type;
 445
 446   /* First try target-defined types.  */
 447   for (ix = 0; VEC_iterate (tdesc_type_p, feature->types, ix, type); ix++)
 448     if (strcmp (type->name, id) == 0)
 449       return type;
 450
 451   /* Next try the predefined types.  */
 452   for (ix = 0; ix < ARRAY_SIZE (tdesc_predefined_types); ix++)
 453     if (strcmp (tdesc_predefined_types[ix].name, id) == 0)
 454       return &tdesc_predefined_types[ix];
 455
 456   return NULL;
 457 }
 458
 459 /* Construct, if necessary, and return the GDB type implementing target
 460    type TDESC_TYPE for architecture GDBARCH.  */
 461
 462 static struct type *
 463 tdesc_gdb_type (struct gdbarch *gdbarch, struct tdesc_type *tdesc_type)
 464 {
 465   switch (tdesc_type->kind)
 466     {
 467     /* Predefined types.  */
 468     case TDESC_TYPE_INT8:
 469       return builtin_type (gdbarch)->builtin_int8;
 470
 471     case TDESC_TYPE_INT16:
 472       return builtin_type (gdbarch)->builtin_int16;
 473
 474     case TDESC_TYPE_INT32:
 475       return builtin_type (gdbarch)->builtin_int32;
 476
 477     case TDESC_TYPE_INT64:
 478       return builtin_type (gdbarch)->builtin_int64;
 479
 480     case TDESC_TYPE_INT128:
 481       return builtin_type (gdbarch)->builtin_int128;
 482
 483     case TDESC_TYPE_UINT8:
 484       return builtin_type (gdbarch)->builtin_uint8;
 485
 486     case TDESC_TYPE_UINT16:
 487       return builtin_type (gdbarch)->builtin_uint16;
 488
 489     case TDESC_TYPE_UINT32:
 490       return builtin_type (gdbarch)->builtin_uint32;
 491
 492     case TDESC_TYPE_UINT64:
 493       return builtin_type (gdbarch)->builtin_uint64;
 494
 495     case TDESC_TYPE_UINT128:
 496       return builtin_type (gdbarch)->builtin_uint128;
 497
 498     case TDESC_TYPE_CODE_PTR:
 499       return builtin_type (gdbarch)->builtin_func_ptr;
 500
 501     case TDESC_TYPE_DATA_PTR:
 502       return builtin_type (gdbarch)->builtin_data_ptr;
 503
 504     case TDESC_TYPE_IEEE_SINGLE:
 505       return arch_float_type (gdbarch, -1, "builtin_type_ieee_single",
 506                               floatformats_ieee_single);
 507
 508     case TDESC_TYPE_IEEE_DOUBLE:
 509       return arch_float_type (gdbarch, -1, "builtin_type_ieee_double",
 510                               floatformats_ieee_double);
 511
 512     case TDESC_TYPE_ARM_FPA_EXT:
 513       return arch_float_type (gdbarch, -1, "builtin_type_arm_ext",
 514                               floatformats_arm_ext);
 515
 516     /* Types defined by a target feature.  */
 517     case TDESC_TYPE_VECTOR:
 518       {
 519         struct type *type, *field_type;
 520
 521         field_type = tdesc_gdb_type (gdbarch, tdesc_type->u.v.type);
 522         type = init_vector_type (field_type, tdesc_type->u.v.count);
 523         TYPE_NAME (type) = xstrdup (tdesc_type->name);
 524
 525         return type;
 526       }
 527
 528     case TDESC_TYPE_UNION:
 529       {
 530         struct type *type, *field_type;
 531         struct tdesc_type_field *f;
 532         int ix;
 533
 534         type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION);
 535         TYPE_NAME (type) = xstrdup (tdesc_type->name);
 536
 537         for (ix = 0;
 538              VEC_iterate (tdesc_type_field, tdesc_type->u.u.fields, ix, f);
 539              ix++)
 540           {
 541             field_type = tdesc_gdb_type (gdbarch, f->type);
 542             append_composite_type_field (type, xstrdup (f->name), field_type);
 543
 544             /* If any of the children of this union are vectors, flag the
 545                union as a vector also.  This allows e.g. a union of two
 546                vector types to show up automatically in "info vector".  */
 547             if (TYPE_VECTOR (field_type))
 548               TYPE_VECTOR (type) = 1;
 549           }
 550
 551         return type;
 552       }
 553     }
 554
 555   internal_error (__FILE__, __LINE__,
 556                   "Type \"%s\" has an unknown kind %d",
 557                   tdesc_type->name, tdesc_type->kind);
 558 }
 559 \f
 560
 561 /* Support for registers from target descriptions.  */
 562
 563 /* Construct the per-gdbarch data.  */
 564
 565 static void *
 566 tdesc_data_init (struct obstack *obstack)
 567 {
 568   struct tdesc_arch_data *data;
 569
 570   data = OBSTACK_ZALLOC (obstack, struct tdesc_arch_data);
 571   return data;
 572 }
 573
 574 /* Similar, but for the temporary copy used during architecture
 575    initialization.  */
 576
 577 struct tdesc_arch_data *
 578 tdesc_data_alloc (void)
 579 {
 580   return XZALLOC (struct tdesc_arch_data);
 581 }
 582
 583 /* Free something allocated by tdesc_data_alloc, if it is not going
 584    to be used (for instance if it was unsuitable for the
 585    architecture).  */
 586
 587 void
 588 tdesc_data_cleanup (void *data_untyped)
 589 {
 590   struct tdesc_arch_data *data = data_untyped;
 591
 592   VEC_free (tdesc_arch_reg, data->arch_regs);
 593   xfree (data);
 594 }
 595
 596 /* Search FEATURE for a register named NAME.  */
 597
 598 static struct tdesc_reg *
 599 tdesc_find_register_early (const struct tdesc_feature *feature,
 600                            const char *name)
 601 {
 602   int ixr;
 603   struct tdesc_reg *reg;
 604
 605   for (ixr = 0;
 606        VEC_iterate (tdesc_reg_p, feature->registers, ixr, reg);
 607        ixr++)
 608     if (strcasecmp (reg->name, name) == 0)
 609       return reg;
 610
 611   return NULL;
 612 }
 613
 614 /* Search FEATURE for a register named NAME.  Assign REGNO to it.  */
 615
 616 int
 617 tdesc_numbered_register (const struct tdesc_feature *feature,
 618                          struct tdesc_arch_data *data,
 619                          int regno, const char *name)
 620 {
 621   struct tdesc_arch_reg arch_reg = { 0 };
 622   struct tdesc_reg *reg = tdesc_find_register_early (feature, name);
 623
 624   if (reg == NULL)
 625     return 0;
 626
 627   /* Make sure the vector includes a REGNO'th element.  */
 628   while (regno >= VEC_length (tdesc_arch_reg, data->arch_regs))
 629     VEC_safe_push (tdesc_arch_reg, data->arch_regs, &arch_reg);
 630
 631   arch_reg.reg = reg;
 632   VEC_replace (tdesc_arch_reg, data->arch_regs, regno, &arch_reg);
 633   return 1;
 634 }
 635
 636 /* Search FEATURE for a register whose name is in NAMES and assign
 637    REGNO to it.  */
 638
 639 int
 640 tdesc_numbered_register_choices (const struct tdesc_feature *feature,
 641                                  struct tdesc_arch_data *data,
 642                                  int regno, const char *const names[])
 643 {
 644   int i;
 645
 646   for (i = 0; names[i] != NULL; i++)
 647     if (tdesc_numbered_register (feature, data, regno, names[i]))
 648       return 1;
 649
 650   return 0;
 651 }
 652
 653 /* Search FEATURE for a register named NAME, and return its size in
 654    bits.  The register must exist.  */
 655
 656 int
 657 tdesc_register_size (const struct tdesc_feature *feature,
 658                      const char *name)
 659 {
 660   struct tdesc_reg *reg = tdesc_find_register_early (feature, name);
 661
 662   gdb_assert (reg != NULL);
 663   return reg->bitsize;
 664 }
 665
 666 /* Look up a register by its GDB internal register number.  */
 667
 668 static struct tdesc_arch_reg *
 669 tdesc_find_arch_register (struct gdbarch *gdbarch, int regno)
 670 {
 671   struct tdesc_arch_reg *reg;
 672   struct tdesc_arch_data *data;
 673
 674   data = gdbarch_data (gdbarch, tdesc_data);
 675   if (regno < VEC_length (tdesc_arch_reg, data->arch_regs))
 676     return VEC_index (tdesc_arch_reg, data->arch_regs, regno);
 677   else
 678     return NULL;
 679 }
 680
 681 static struct tdesc_reg *
 682 tdesc_find_register (struct gdbarch *gdbarch, int regno)
 683 {
 684   struct tdesc_arch_reg *reg = tdesc_find_arch_register (gdbarch, regno);
 685   return reg? reg->reg : NULL;
 686 }
 687
 688 /* Return the name of register REGNO, from the target description or
 689    from an architecture-provided pseudo_register_name method.  */
 690
 691 const char *
 692 tdesc_register_name (struct gdbarch *gdbarch, int regno)
 693 {
 694   struct tdesc_reg *reg = tdesc_find_register (gdbarch, regno);
 695   int num_regs = gdbarch_num_regs (gdbarch);
 696   int num_pseudo_regs = gdbarch_num_pseudo_regs (gdbarch);
 697
 698   if (reg != NULL)
 699     return reg->name;
 700
 701   if (regno >= num_regs && regno < num_regs + num_pseudo_regs)
 702     {
 703       struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
 704       gdb_assert (data->pseudo_register_name != NULL);
 705       return data->pseudo_register_name (gdbarch, regno);
 706     }
 707
 708   return "";
 709 }
 710
 711 static struct type *
 712 tdesc_register_type (struct gdbarch *gdbarch, int regno)
 713 {
 714   struct tdesc_arch_reg *arch_reg = tdesc_find_arch_register (gdbarch, regno);
 715   struct tdesc_reg *reg = arch_reg? arch_reg->reg : NULL;
 716   int num_regs = gdbarch_num_regs (gdbarch);
 717   int num_pseudo_regs = gdbarch_num_pseudo_regs (gdbarch);
 718
 719   if (reg == NULL && regno >= num_regs && regno < num_regs + num_pseudo_regs)
 720     {
 721       struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
 722       gdb_assert (data->pseudo_register_type != NULL);
 723       return data->pseudo_register_type (gdbarch, regno);
 724     }
 725
 726   if (reg == NULL)
 727     /* Return "int0_t", since "void" has a misleading size of one.  */
 728     return builtin_type (gdbarch)->builtin_int0;
 729
 730   if (arch_reg->type == NULL)
 731     {
 732       /* First check for a predefined or target defined type.  */
 733       if (reg->tdesc_type)
 734         arch_reg->type = tdesc_gdb_type (gdbarch, reg->tdesc_type);
 735
 736       /* Next try size-sensitive type shortcuts.  */
 737       else if (strcmp (reg->type, "float") == 0)
 738         {
 739           if (reg->bitsize == gdbarch_float_bit (gdbarch))
 740             arch_reg->type = builtin_type (gdbarch)->builtin_float;
 741           else if (reg->bitsize == gdbarch_double_bit (gdbarch))
 742             arch_reg->type = builtin_type (gdbarch)->builtin_double;
 743           else if (reg->bitsize == gdbarch_long_double_bit (gdbarch))
 744             arch_reg->type = builtin_type (gdbarch)->builtin_long_double;
 745           else
 746             {
 747               warning (_("Register \"%s\" has an unsupported size (%d bits)"),
 748                        reg->name, reg->bitsize);
 749               arch_reg->type = builtin_type (gdbarch)->builtin_double;
 750             }
 751         }
 752       else if (strcmp (reg->type, "int") == 0)
 753         {
 754           if (reg->bitsize == gdbarch_long_bit (gdbarch))
 755             arch_reg->type = builtin_type (gdbarch)->builtin_long;
 756           else if (reg->bitsize == TARGET_CHAR_BIT)
 757             arch_reg->type = builtin_type (gdbarch)->builtin_char;
 758           else if (reg->bitsize == gdbarch_short_bit (gdbarch))
 759             arch_reg->type = builtin_type (gdbarch)->builtin_short;
 760           else if (reg->bitsize == gdbarch_int_bit (gdbarch))
 761             arch_reg->type = builtin_type (gdbarch)->builtin_int;
 762           else if (reg->bitsize == gdbarch_long_long_bit (gdbarch))
 763             arch_reg->type = builtin_type (gdbarch)->builtin_long_long;
 764           else if (reg->bitsize == gdbarch_ptr_bit (gdbarch))
 765           /* A bit desperate by this point... */
 766             arch_reg->type = builtin_type (gdbarch)->builtin_data_ptr;
 767           else
 768             {
 769               warning (_("Register \"%s\" has an unsupported size (%d bits)"),
 770                        reg->name, reg->bitsize);
 771               arch_reg->type = builtin_type (gdbarch)->builtin_long;
 772             }
 773         }
 774
 775       if (arch_reg->type == NULL)
 776         internal_error (__FILE__, __LINE__,
 777                         "Register \"%s\" has an unknown type \"%s\"",
 778                         reg->name, reg->type);
 779     }
 780
 781   return arch_reg->type;
 782 }
 783
 784 static int
 785 tdesc_remote_register_number (struct gdbarch *gdbarch, int regno)
 786 {
 787   struct tdesc_reg *reg = tdesc_find_register (gdbarch, regno);
 788
 789   if (reg != NULL)
 790     return reg->target_regnum;
 791   else
 792     return -1;
 793 }
 794
 795 /* Check whether REGNUM is a member of REGGROUP.  Registers from the
 796    target description may be classified as general, float, or vector.
 797    Unlike a gdbarch register_reggroup_p method, this function will
 798    return -1 if it does not know; the caller should handle registers
 799    with no specified group.
 800
 801    Arbitrary strings (other than "general", "float", and "vector")
 802    from the description are not used; they cause the register to be
 803    displayed in "info all-registers" but excluded from "info
 804    registers" et al.  The names of containing features are also not
 805    used.  This might be extended to display registers in some more
 806    useful groupings.
 807
 808    The save-restore flag is also implemented here.  */
 809
 810 int
 811 tdesc_register_in_reggroup_p (struct gdbarch *gdbarch, int regno,
 812                               struct reggroup *reggroup)
 813 {
 814   struct tdesc_reg *reg = tdesc_find_register (gdbarch, regno);
 815
 816   if (reg != NULL && reg->group != NULL)
 817     {
 818       int general_p = 0, float_p = 0, vector_p = 0;
 819
 820       if (strcmp (reg->group, "general") == 0)
 821         general_p = 1;
 822       else if (strcmp (reg->group, "float") == 0)
 823         float_p = 1;
 824       else if (strcmp (reg->group, "vector") == 0)
 825         vector_p = 1;
 826
 827       if (reggroup == float_reggroup)
 828         return float_p;
 829
 830       if (reggroup == vector_reggroup)
 831         return vector_p;
 832
 833       if (reggroup == general_reggroup)
 834         return general_p;
 835     }
 836
 837   if (reg != NULL
 838       && (reggroup == save_reggroup || reggroup == restore_reggroup))
 839     return reg->save_restore;
 840
 841   return -1;
 842 }
 843
 844 /* Check whether REGNUM is a member of REGGROUP.  Registers with no
 845    group specified go to the default reggroup function and are handled
 846    by type.  */
 847
 848 static int
 849 tdesc_register_reggroup_p (struct gdbarch *gdbarch, int regno,
 850                            struct reggroup *reggroup)
 851 {
 852   int num_regs = gdbarch_num_regs (gdbarch);
 853   int num_pseudo_regs = gdbarch_num_pseudo_regs (gdbarch);
 854   int ret;
 855
 856   if (regno >= num_regs && regno < num_regs + num_pseudo_regs)
 857     {
 858       struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
 859       gdb_assert (data->pseudo_register_reggroup_p != NULL);
 860       return data->pseudo_register_reggroup_p (gdbarch, regno, reggroup);
 861     }
 862
 863   ret = tdesc_register_in_reggroup_p (gdbarch, regno, reggroup);
 864   if (ret != -1)
 865     return ret;
 866
 867   return default_register_reggroup_p (gdbarch, regno, reggroup);
 868 }
 869
 870 /* Record architecture-specific functions to call for pseudo-register
 871    support.  */
 872
 873 void
 874 set_tdesc_pseudo_register_name (struct gdbarch *gdbarch,
 875                                 gdbarch_register_name_ftype *pseudo_name)
 876 {
 877   struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
 878
 879   data->pseudo_register_name = pseudo_name;
 880 }
 881
 882 void
 883 set_tdesc_pseudo_register_type (struct gdbarch *gdbarch,
 884                                 gdbarch_register_type_ftype *pseudo_type)
 885 {
 886   struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
 887
 888   data->pseudo_register_type = pseudo_type;
 889 }
 890
 891 void
 892 set_tdesc_pseudo_register_reggroup_p
 893   (struct gdbarch *gdbarch,
 894    gdbarch_register_reggroup_p_ftype *pseudo_reggroup_p)
 895 {
 896   struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
 897
 898   data->pseudo_register_reggroup_p = pseudo_reggroup_p;
 899 }
 900
 901 /* Update GDBARCH to use the target description for registers.  */
 902
 903 void
 904 tdesc_use_registers (struct gdbarch *gdbarch,
 905                      const struct target_desc *target_desc,
 906                      struct tdesc_arch_data *early_data)
 907 {
 908   int num_regs = gdbarch_num_regs (gdbarch);
 909   int i, ixf, ixr;
 910   struct tdesc_feature *feature;
 911   struct tdesc_reg *reg;
 912   struct tdesc_arch_data *data;
 913   struct tdesc_arch_reg *arch_reg, new_arch_reg = { 0 };
 914   htab_t reg_hash;
 915
 916   /* We can't use the description for registers if it doesn't describe
 917      any.  This function should only be called after validating
 918      registers, so the caller should know that registers are
 919      included.  */
 920   gdb_assert (tdesc_has_registers (target_desc));
 921
 922   data = gdbarch_data (gdbarch, tdesc_data);
 923   data->arch_regs = early_data->arch_regs;
 924   xfree (early_data);
 925
 926   /* Build up a set of all registers, so that we can assign register
 927      numbers where needed.  The hash table expands as necessary, so
 928      the initial size is arbitrary.  */
 929   reg_hash = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
 930   for (ixf = 0;
 931        VEC_iterate (tdesc_feature_p, target_desc->features, ixf, feature);
 932        ixf++)
 933     for (ixr = 0;
 934          VEC_iterate (tdesc_reg_p, feature->registers, ixr, reg);
 935          ixr++)
 936       {
 937         void **slot = htab_find_slot (reg_hash, reg, INSERT);
 938
 939         *slot = reg;
 940       }
 941
 942   /* Remove any registers which were assigned numbers by the
 943      architecture.  */
 944   for (ixr = 0;
 945        VEC_iterate (tdesc_arch_reg, data->arch_regs, ixr, arch_reg);
 946        ixr++)
 947     if (arch_reg->reg)
 948       htab_remove_elt (reg_hash, arch_reg->reg);
 949
 950   /* Assign numbers to the remaining registers and add them to the
 951      list of registers.  The new numbers are always above gdbarch_num_regs.
 952      Iterate over the features, not the hash table, so that the order
 953      matches that in the target description.  */
 954
 955   gdb_assert (VEC_length (tdesc_arch_reg, data->arch_regs) <= num_regs);
 956   while (VEC_length (tdesc_arch_reg, data->arch_regs) < num_regs)
 957     VEC_safe_push (tdesc_arch_reg, data->arch_regs, &new_arch_reg);
 958   for (ixf = 0;
 959        VEC_iterate (tdesc_feature_p, target_desc->features, ixf, feature);
 960        ixf++)
 961     for (ixr = 0;
 962          VEC_iterate (tdesc_reg_p, feature->registers, ixr, reg);
 963          ixr++)
 964       if (htab_find (reg_hash, reg) != NULL)
 965         {
 966           new_arch_reg.reg = reg;
 967           VEC_safe_push (tdesc_arch_reg, data->arch_regs, &new_arch_reg);
 968           num_regs++;
 969         }
 970
 971   htab_delete (reg_hash);
 972
 973   /* Update the architecture.  */
 974   set_gdbarch_num_regs (gdbarch, num_regs);
 975   set_gdbarch_register_name (gdbarch, tdesc_register_name);
 976   set_gdbarch_register_type (gdbarch, tdesc_register_type);
 977   set_gdbarch_remote_register_number (gdbarch,
 978                                       tdesc_remote_register_number);
 979   set_gdbarch_register_reggroup_p (gdbarch, tdesc_register_reggroup_p);
 980 }
 981 \f
 982
 983 /* Methods for constructing a target description.  */
 984
 985 static void
 986 tdesc_free_reg (struct tdesc_reg *reg)
 987 {
 988   xfree (reg->name);
 989   xfree (reg->type);
 990   xfree (reg->group);
 991   xfree (reg);
 992 }
 993
 994 void
 995 tdesc_create_reg (struct tdesc_feature *feature, const char *name,
 996                   int regnum, int save_restore, const char *group,
 997                   int bitsize, const char *type)
 998 {
 999   struct tdesc_reg *reg = XZALLOC (struct tdesc_reg);
1000
1001   reg->name = xstrdup (name);
1002   reg->target_regnum = regnum;
1003   reg->save_restore = save_restore;
1004   reg->group = group ? xstrdup (group) : NULL;
1005   reg->bitsize = bitsize;
1006   reg->type = type ? xstrdup (type) : xstrdup ("<unknown>");
1007
1008   /* If the register's type is target-defined, look it up now.  We may not
1009      have easy access to the containing feature when we want it later.  */
1010   reg->tdesc_type = tdesc_named_type (feature, reg->type);
1011
1012   VEC_safe_push (tdesc_reg_p, feature->registers, reg);
1013 }
1014
1015 static void
1016 tdesc_free_type (struct tdesc_type *type)
1017 {
1018
1019   switch (type->kind)
1020     {
1021     case TDESC_TYPE_UNION:
1022       {
1023         struct tdesc_type_field *f;
1024         int ix;
1025
1026         for (ix = 0;
1027              VEC_iterate (tdesc_type_field, type->u.u.fields, ix, f);
1028              ix++)
1029           xfree (f->name);
1030
1031         VEC_free (tdesc_type_field, type->u.u.fields);
1032       }
1033       break;
1034
1035     default:
1036       break;
1037     }
1038
1039   xfree (type->name);
1040   xfree (type);
1041 }
1042
1043 struct tdesc_type *
1044 tdesc_create_vector (struct tdesc_feature *feature, const char *name,
1045                      struct tdesc_type *field_type, int count)
1046 {
1047   struct tdesc_type *type = XZALLOC (struct tdesc_type);
1048
1049   type->name = xstrdup (name);
1050   type->kind = TDESC_TYPE_VECTOR;
1051   type->u.v.type = field_type;
1052   type->u.v.count = count;
1053
1054   VEC_safe_push (tdesc_type_p, feature->types, type);
1055   return type;
1056 }
1057
1058 struct tdesc_type *
1059 tdesc_create_union (struct tdesc_feature *feature, const char *name)
1060 {
1061   struct tdesc_type *type = XZALLOC (struct tdesc_type);
1062
1063   type->name = xstrdup (name);
1064   type->kind = TDESC_TYPE_UNION;
1065
1066   VEC_safe_push (tdesc_type_p, feature->types, type);
1067   return type;
1068 }
1069
1070 void
1071 tdesc_add_field (struct tdesc_type *type, const char *field_name,
1072                  struct tdesc_type *field_type)
1073 {
1074   struct tdesc_type_field f = { 0 };
1075
1076   gdb_assert (type->kind == TDESC_TYPE_UNION);
1077
1078   f.name = xstrdup (field_name);
1079   f.type = field_type;
1080
1081   VEC_safe_push (tdesc_type_field, type->u.u.fields, &f);
1082 }
1083
1084 static void
1085 tdesc_free_feature (struct tdesc_feature *feature)
1086 {
1087   struct tdesc_reg *reg;
1088   struct tdesc_type *type;
1089   int ix;
1090
1091   for (ix = 0; VEC_iterate (tdesc_reg_p, feature->registers, ix, reg); ix++)
1092     tdesc_free_reg (reg);
1093   VEC_free (tdesc_reg_p, feature->registers);
1094
1095   for (ix = 0; VEC_iterate (tdesc_type_p, feature->types, ix, type); ix++)
1096     tdesc_free_type (type);
1097   VEC_free (tdesc_type_p, feature->types);
1098
1099   xfree (feature->name);
1100   xfree (feature);
1101 }
1102
1103 struct tdesc_feature *
1104 tdesc_create_feature (struct target_desc *tdesc, const char *name)
1105 {
1106   struct tdesc_feature *new_feature = XZALLOC (struct tdesc_feature);
1107
1108   new_feature->name = xstrdup (name);
1109
1110   VEC_safe_push (tdesc_feature_p, tdesc->features, new_feature);
1111   return new_feature;
1112 }
1113
1114 struct target_desc *
1115 allocate_target_description (void)
1116 {
1117   return XZALLOC (struct target_desc);
1118 }
1119
1120 static void
1121 free_target_description (void *arg)
1122 {
1123   struct target_desc *target_desc = arg;
1124   struct tdesc_feature *feature;
1125   struct property *prop;
1126   int ix;
1127
1128   for (ix = 0;
1129        VEC_iterate (tdesc_feature_p, target_desc->features, ix, feature);
1130        ix++)
1131     tdesc_free_feature (feature);
1132   VEC_free (tdesc_feature_p, target_desc->features);
1133
1134   for (ix = 0;
1135        VEC_iterate (property_s, target_desc->properties, ix, prop);
1136        ix++)
1137     {
1138       xfree (prop->key);
1139       xfree (prop->value);
1140     }
1141   VEC_free (property_s, target_desc->properties);
1142
1143   xfree (target_desc);
1144 }
1145
1146 struct cleanup *
1147 make_cleanup_free_target_description (struct target_desc *target_desc)
1148 {
1149   return make_cleanup (free_target_description, target_desc);
1150 }
1151
1152 void
1153 set_tdesc_property (struct target_desc *target_desc,
1154                     const char *key, const char *value)
1155 {
1156   struct property *prop, new_prop;
1157   int ix;
1158
1159   gdb_assert (key != NULL && value != NULL);
1160
1161   for (ix = 0; VEC_iterate (property_s, target_desc->properties, ix, prop);
1162        ix++)
1163     if (strcmp (prop->key, key) == 0)
1164       internal_error (__FILE__, __LINE__,
1165                       _("Attempted to add duplicate property \"%s\""), key);
1166
1167   new_prop.key = xstrdup (key);
1168   new_prop.value = xstrdup (value);
1169   VEC_safe_push (property_s, target_desc->properties, &new_prop);
1170 }
1171
1172 void
1173 set_tdesc_architecture (struct target_desc *target_desc,
1174                         const struct bfd_arch_info *arch)
1175 {
1176   target_desc->arch = arch;
1177 }
1178
1179 void
1180 set_tdesc_osabi (struct target_desc *target_desc, enum gdb_osabi osabi)
1181 {
1182   target_desc->osabi = osabi;
1183 }
1184 \f
1185
1186 static struct cmd_list_element *tdesc_set_cmdlist, *tdesc_show_cmdlist;
1187 static struct cmd_list_element *tdesc_unset_cmdlist;
1188
1189 /* Helper functions for the CLI commands.  */
1190
1191 static void
1192 set_tdesc_cmd (char *args, int from_tty)
1193 {
1194   help_list (tdesc_set_cmdlist, "set tdesc ", -1, gdb_stdout);
1195 }
1196
1197 static void
1198 show_tdesc_cmd (char *args, int from_tty)
1199 {
1200   cmd_show_list (tdesc_show_cmdlist, from_tty, "");
1201 }
1202
1203 static void
1204 unset_tdesc_cmd (char *args, int from_tty)
1205 {
1206   help_list (tdesc_unset_cmdlist, "unset tdesc ", -1, gdb_stdout);
1207 }
1208
1209 static void
1210 set_tdesc_filename_cmd (char *args, int from_tty,
1211                         struct cmd_list_element *c)
1212 {
1213   target_clear_description ();
1214   target_find_description ();
1215 }
1216
1217 static void
1218 show_tdesc_filename_cmd (struct ui_file *file, int from_tty,
1219                          struct cmd_list_element *c,
1220                          const char *value)
1221 {
1222   if (value != NULL && *value != '\0')
1223     printf_filtered (_("\
1224 The target description will be read from \"%s\".\n"),
1225                      value);
1226   else
1227     printf_filtered (_("\
1228 The target description will be read from the target.\n"));
1229 }
1230
1231 static void
1232 unset_tdesc_filename_cmd (char *args, int from_tty)
1233 {
1234   xfree (target_description_filename);
1235   target_description_filename = NULL;
1236   target_clear_description ();
1237   target_find_description ();
1238 }
1239
1240 static void
1241 maint_print_c_tdesc_cmd (char *args, int from_tty)
1242 {
1243   const struct target_desc *tdesc;
1244   const char *filename, *inp;
1245   char *function, *outp;
1246   struct property *prop;
1247   struct tdesc_feature *feature;
1248   struct tdesc_reg *reg;
1249   struct tdesc_type *type;
1250   struct tdesc_type_field *f;
1251   int ix, ix2, ix3;
1252
1253   /* Use the global target-supplied description, not the current
1254      architecture's.  This lets a GDB for one architecture generate C
1255      for another architecture's description, even though the gdbarch
1256      initialization code will reject the new description.  */
1257   tdesc = current_target_desc;
1258   if (tdesc == NULL)
1259     error (_("There is no target description to print."));
1260
1261   if (target_description_filename == NULL)
1262     error (_("The current target description did not come from an XML file."));
1263
1264   filename = lbasename (target_description_filename);
1265   function = alloca (strlen (filename) + 1);
1266   for (inp = filename, outp = function; *inp != '\0'; inp++)
1267     if (*inp == '.')
1268       break;
1269     else if (*inp == '-')
1270       *outp++ = '_';
1271     else
1272       *outp++ = *inp;
1273   *outp = '\0';
1274
1275   /* Standard boilerplate.  */
1276   printf_unfiltered ("/* THIS FILE IS GENERATED.  Original: %s */\n\n",
1277                      filename);
1278   printf_unfiltered ("#include \"defs.h\"\n");
1279   printf_unfiltered ("#include \"target-descriptions.h\"\n");
1280   printf_unfiltered ("\n");
1281
1282   printf_unfiltered ("struct target_desc *tdesc_%s;\n", function);
1283   printf_unfiltered ("static void\n");
1284   printf_unfiltered ("initialize_tdesc_%s (void)\n", function);
1285   printf_unfiltered ("{\n");
1286   printf_unfiltered
1287     ("  struct target_desc *result = allocate_target_description ();\n");
1288   printf_unfiltered ("  struct tdesc_feature *feature;\n");
1289   printf_unfiltered ("  struct tdesc_type *field_type, *type;\n");
1290   printf_unfiltered ("\n");
1291
1292   if (tdesc_architecture (tdesc) != NULL)
1293     {
1294       printf_unfiltered
1295         ("  set_tdesc_architecture (result, bfd_scan_arch (\"%s\"));\n",
1296          tdesc_architecture (tdesc)->printable_name);
1297       printf_unfiltered ("\n");
1298     }
1299
1300   for (ix = 0; VEC_iterate (property_s, tdesc->properties, ix, prop);
1301        ix++)
1302     {
1303       printf_unfiltered ("  set_tdesc_property (result, \"%s\", \"%s\");\n",
1304               prop->key, prop->value);
1305     }
1306
1307   for (ix = 0;
1308        VEC_iterate (tdesc_feature_p, tdesc->features, ix, feature);
1309        ix++)
1310     {
1311       printf_unfiltered ("  feature = tdesc_create_feature (result, \"%s\");\n",
1312                          feature->name);
1313
1314       for (ix2 = 0;
1315            VEC_iterate (tdesc_type_p, feature->types, ix2, type);
1316            ix2++)
1317         {
1318           switch (type->kind)
1319             {
1320             case TDESC_TYPE_VECTOR:
1321               printf_unfiltered
1322                 ("  field_type = tdesc_named_type (feature, \"%s\");\n",
1323                  type->u.v.type->name);
1324               printf_unfiltered
1325                 ("  tdesc_create_vector (feature, \"%s\", field_type, %d);\n",
1326                  type->name, type->u.v.count);
1327               break;
1328             case TDESC_TYPE_UNION:
1329               printf_unfiltered
1330                 ("  type = tdesc_create_union (feature, \"%s\");\n",
1331                  type->name);
1332               for (ix3 = 0;
1333                    VEC_iterate (tdesc_type_field, type->u.u.fields, ix3, f);
1334                    ix3++)
1335                 {
1336                   printf_unfiltered
1337                     ("  field_type = tdesc_named_type (feature, \"%s\");\n",
1338                      f->type->name);
1339                   printf_unfiltered
1340                     ("  tdesc_add_field (type, \"%s\", field_type);\n",
1341                      f->name);
1342                 }
1343               break;
1344             default:
1345               error (_("C output is not supported type \"%s\"."), type->name);
1346             }
1347           printf_unfiltered ("\n");
1348         }
1349
1350       for (ix2 = 0;
1351            VEC_iterate (tdesc_reg_p, feature->registers, ix2, reg);
1352            ix2++)
1353         {
1354           printf_unfiltered ("  tdesc_create_reg (feature, \"%s\", %ld, %d, ",
1355                              reg->name, reg->target_regnum, reg->save_restore);
1356           if (reg->group)
1357             printf_unfiltered ("\"%s\", ", reg->group);
1358           else
1359             printf_unfiltered ("NULL, ");
1360           printf_unfiltered ("%d, \"%s\");\n", reg->bitsize, reg->type);
1361         }
1362
1363       printf_unfiltered ("\n");
1364     }
1365
1366   printf_unfiltered ("  tdesc_%s = result;\n", function);
1367   printf_unfiltered ("}\n");
1368 }
1369
1370 /* Provide a prototype to silence -Wmissing-prototypes.  */
1371 extern initialize_file_ftype _initialize_target_descriptions;
1372
1373 void
1374 _initialize_target_descriptions (void)
1375 {
1376   tdesc_data = gdbarch_data_register_pre_init (tdesc_data_init);
1377
1378   add_prefix_cmd ("tdesc", class_maintenance, set_tdesc_cmd, _("\
1379 Set target description specific variables."),
1380                   &tdesc_set_cmdlist, "set tdesc ",
1381                   0 /* allow-unknown */, &setlist);
1382   add_prefix_cmd ("tdesc", class_maintenance, show_tdesc_cmd, _("\
1383 Show target description specific variables."),
1384                   &tdesc_show_cmdlist, "show tdesc ",
1385                   0 /* allow-unknown */, &showlist);
1386   add_prefix_cmd ("tdesc", class_maintenance, unset_tdesc_cmd, _("\
1387 Unset target description specific variables."),
1388                   &tdesc_unset_cmdlist, "unset tdesc ",
1389                   0 /* allow-unknown */, &unsetlist);
1390
1391   add_setshow_filename_cmd ("filename", class_obscure,
1392                             &target_description_filename,
1393                             _("\
1394 Set the file to read for an XML target description"), _("\
1395 Show the file to read for an XML target description"), _("\
1396 When set, GDB will read the target description from a local\n\
1397 file instead of querying the remote target."),
1398                             set_tdesc_filename_cmd,
1399                             show_tdesc_filename_cmd,
1400                             &tdesc_set_cmdlist, &tdesc_show_cmdlist);
1401
1402   add_cmd ("filename", class_obscure, unset_tdesc_filename_cmd, _("\
1403 Unset the file to read for an XML target description.  When unset,\n\
1404 GDB will read the description from the target."),
1405            &tdesc_unset_cmdlist);
1406
1407   add_cmd ("c-tdesc", class_maintenance, maint_print_c_tdesc_cmd, _("\
1408 Print the current target description as a C source file."),
1409            &maintenanceprintlist);
1410 }