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