gdb/target-descriptions.c

   1 /* Target description support for GDB.
   2
   3    Copyright (C) 2006, 2007 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 2 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, write to the Free Software
  21    Foundation, Inc., 51 Franklin Street, Fifth Floor,
  22    Boston, MA 02110-1301, USA.  */
  23
  24 #include "defs.h"
  25 #include "arch-utils.h"
  26 #include "gdbcmd.h"
  27 #include "gdbtypes.h"
  28 #include "reggroups.h"
  29 #include "target.h"
  30 #include "target-descriptions.h"
  31 #include "vec.h"
  32 #include "xml-support.h"
  33 #include "xml-tdesc.h"
  34
  35 #include "gdb_assert.h"
  36 #include "gdb_obstack.h"
  37 #include "hashtab.h"
  38
  39 /* Types.  */
  40
  41 typedef struct property
  42 {
  43   char *key;
  44   char *value;
  45 } property_s;
  46 DEF_VEC_O(property_s);
  47
  48 /* An individual register from a target description.  */
  49
  50 typedef struct tdesc_reg
  51 {
  52   /* The name of this register.  In standard features, it may be
  53      recognized by the architecture support code, or it may be purely
  54      for the user.  */
  55   char *name;
  56
  57   /* The register number used by this target to refer to this
  58      register.  This is used for remote p/P packets and to determine
  59      the ordering of registers in the remote g/G packets.  */
  60   long target_regnum;
  61
  62   /* If this flag is set, GDB should save and restore this register
  63      around calls to an inferior function.  */
  64   int save_restore;
  65
  66   /* The name of the register group containing this register, or NULL
  67      if the group should be automatically determined from the
  68      register's type.  If this is "general", "float", or "vector", the
  69      corresponding "info" command should display this register's
  70      value.  It can be an arbitrary string, but should be limited to
  71      alphanumeric characters and internal hyphens.  Currently other
  72      strings are ignored (treated as NULL).  */
  73   char *group;
  74
  75   /* The size of the register, in bits.  */
  76   int bitsize;
  77
  78   /* The type of the register.  This string corresponds to either
  79      a named type from the target description or a predefined
  80      type from GDB.  */
  81   char *type;
  82
  83   /* The target-described type corresponding to TYPE, if found.  */
  84   struct type *gdb_type;
  85 } *tdesc_reg_p;
  86 DEF_VEC_P(tdesc_reg_p);
  87
  88 /* A named type from a target description.  */
  89 typedef struct type *type_p;
  90 DEF_VEC_P(type_p);
  91
  92 /* A feature from a target description.  Each feature is a collection
  93    of other elements, e.g. registers and types.  */
  94
  95 typedef struct tdesc_feature
  96 {
  97   /* The name of this feature.  It may be recognized by the architecture
  98      support code.  */
  99   char *name;
 100
 101   /* The registers associated with this feature.  */
 102   VEC(tdesc_reg_p) *registers;
 103
 104   /* The types associated with this feature.  */
 105   VEC(type_p) *types;
 106 } *tdesc_feature_p;
 107 DEF_VEC_P(tdesc_feature_p);
 108
 109 /* A target description.  */
 110
 111 struct target_desc
 112 {
 113   /* The architecture reported by the target, if any.  */
 114   const struct bfd_arch_info *arch;
 115
 116   /* Any architecture-specific properties specified by the target.  */
 117   VEC(property_s) *properties;
 118
 119   /* The features associated with this target.  */
 120   VEC(tdesc_feature_p) *features;
 121 };
 122
 123 /* Per-architecture data associated with a target description.  The
 124    target description may be shared by multiple architectures, but
 125    this data is private to one gdbarch.  */
 126
 127 struct tdesc_arch_data
 128 {
 129   /* A list of registers, indexed by GDB's internal register number.
 130      During initialization of the gdbarch this list is used to store
 131      registers which the architecture assigns a fixed register number.
 132      Registers which are NULL in this array, or off the end, are
 133      treated as zero-sized and nameless (i.e. placeholders in the
 134      numbering).  */
 135   VEC(tdesc_reg_p) *registers;
 136
 137   /* Functions which report the register name, type, and reggroups for
 138      pseudo-registers.  */
 139   gdbarch_register_name_ftype *pseudo_register_name;
 140   gdbarch_register_type_ftype *pseudo_register_type;
 141   gdbarch_register_reggroup_p_ftype *pseudo_register_reggroup_p;
 142 };
 143
 144 /* Global state.  These variables are associated with the current
 145    target; if GDB adds support for multiple simultaneous targets, then
 146    these variables should become target-specific data.  */
 147
 148 /* A flag indicating that a description has already been fetched from
 149    the current target, so it should not be queried again.  */
 150
 151 static int target_desc_fetched;
 152
 153 /* The description fetched from the current target, or NULL if the
 154    current target did not supply any description.  Only valid when
 155    target_desc_fetched is set.  Only the description initialization
 156    code should access this; normally, the description should be
 157    accessed through the gdbarch object.  */
 158
 159 static const struct target_desc *current_target_desc;
 160
 161 /* Other global variables.  */
 162
 163 /* The filename to read a target description from.  */
 164
 165 static char *target_description_filename;
 166
 167 /* A handle for architecture-specific data associated with the
 168    target description (see struct tdesc_arch_data).  */
 169
 170 static struct gdbarch_data *tdesc_data;
 171
 172 /* Fetch the current target's description, and switch the current
 173    architecture to one which incorporates that description.  */
 174
 175 void
 176 target_find_description (void)
 177 {
 178   /* If we've already fetched a description from the target, don't do
 179      it again.  This allows a target to fetch the description early,
 180      during its to_open or to_create_inferior, if it needs extra
 181      information about the target to initialize.  */
 182   if (target_desc_fetched)
 183     return;
 184
 185   /* The current architecture should not have any target description
 186      specified.  It should have been cleared, e.g. when we
 187      disconnected from the previous target.  */
 188   gdb_assert (gdbarch_target_desc (current_gdbarch) == NULL);
 189
 190   /* First try to fetch an XML description from the user-specified
 191      file.  */
 192   current_target_desc = NULL;
 193   if (target_description_filename != NULL
 194       && *target_description_filename != '\0')
 195     current_target_desc
 196       = file_read_description_xml (target_description_filename);
 197
 198   /* Next try to read the description from the current target using
 199      target objects.  */
 200   if (current_target_desc == NULL)
 201     current_target_desc = target_read_description_xml (&current_target);
 202
 203   /* If that failed try a target-specific hook.  */
 204   if (current_target_desc == NULL)
 205     current_target_desc = target_read_description (&current_target);
 206
 207   /* If a non-NULL description was returned, then update the current
 208      architecture.  */
 209   if (current_target_desc)
 210     {
 211       struct gdbarch_info info;
 212
 213       gdbarch_info_init (&info);
 214       info.target_desc = current_target_desc;
 215       if (!gdbarch_update_p (info))
 216         warning (_("Architecture rejected target-supplied description"));
 217       else
 218         {
 219           struct tdesc_arch_data *data;
 220
 221           data = gdbarch_data (current_gdbarch, tdesc_data);
 222           if (tdesc_has_registers (current_target_desc)
 223               && data->registers == NULL)
 224             warning (_("Target-supplied registers are not supported "
 225                        "by the current architecture"));
 226         }
 227     }
 228
 229   /* Now that we know this description is usable, record that we
 230      fetched it.  */
 231   target_desc_fetched = 1;
 232 }
 233
 234 /* Discard any description fetched from the current target, and switch
 235    the current architecture to one with no target description.  */
 236
 237 void
 238 target_clear_description (void)
 239 {
 240   struct gdbarch_info info;
 241
 242   if (!target_desc_fetched)
 243     return;
 244
 245   target_desc_fetched = 0;
 246   current_target_desc = NULL;
 247
 248   gdbarch_info_init (&info);
 249   if (!gdbarch_update_p (info))
 250     internal_error (__FILE__, __LINE__,
 251                     _("Could not remove target-supplied description"));
 252 }
 253
 254 /* Return the global current target description.  This should only be
 255    used by gdbarch initialization code; most access should be through
 256    an existing gdbarch.  */
 257
 258 const struct target_desc *
 259 target_current_description (void)
 260 {
 261   if (target_desc_fetched)
 262     return current_target_desc;
 263
 264   return NULL;
 265 }
 266 \f
 267
 268 /* Direct accessors for target descriptions.  */
 269
 270 /* Return the string value of a property named KEY, or NULL if the
 271    property was not specified.  */
 272
 273 const char *
 274 tdesc_property (const struct target_desc *target_desc, const char *key)
 275 {
 276   struct property *prop;
 277   int ix;
 278
 279   for (ix = 0; VEC_iterate (property_s, target_desc->properties, ix, prop);
 280        ix++)
 281     if (strcmp (prop->key, key) == 0)
 282       return prop->value;
 283
 284   return NULL;
 285 }
 286
 287 /* Return the BFD architecture associated with this target
 288    description, or NULL if no architecture was specified.  */
 289
 290 const struct bfd_arch_info *
 291 tdesc_architecture (const struct target_desc *target_desc)
 292 {
 293   return target_desc->arch;
 294 }
 295 \f
 296
 297 /* Return 1 if this target description includes any registers.  */
 298
 299 int
 300 tdesc_has_registers (const struct target_desc *target_desc)
 301 {
 302   int ix;
 303   struct tdesc_feature *feature;
 304
 305   if (target_desc == NULL)
 306     return 0;
 307
 308   for (ix = 0;
 309        VEC_iterate (tdesc_feature_p, target_desc->features, ix, feature);
 310        ix++)
 311     if (! VEC_empty (tdesc_reg_p, feature->registers))
 312       return 1;
 313
 314   return 0;
 315 }
 316
 317 /* Return the feature with the given name, if present, or NULL if
 318    the named feature is not found.  */
 319
 320 const struct tdesc_feature *
 321 tdesc_find_feature (const struct target_desc *target_desc,
 322                     const char *name)
 323 {
 324   int ix;
 325   struct tdesc_feature *feature;
 326
 327   for (ix = 0;
 328        VEC_iterate (tdesc_feature_p, target_desc->features, ix, feature);
 329        ix++)
 330     if (strcmp (feature->name, name) == 0)
 331       return feature;
 332
 333   return NULL;
 334 }
 335
 336 /* Return the name of FEATURE.  */
 337
 338 const char *
 339 tdesc_feature_name (const struct tdesc_feature *feature)
 340 {
 341   return feature->name;
 342 }
 343
 344 /* Return the type associated with ID in the context of FEATURE, or
 345    NULL if none.  */
 346
 347 struct type *
 348 tdesc_named_type (const struct tdesc_feature *feature, const char *id)
 349 {
 350   int ix;
 351   struct type *gdb_type;
 352
 353   /* First try target-defined types.  */
 354   for (ix = 0; VEC_iterate (type_p, feature->types, ix, gdb_type); ix++)
 355     if (strcmp (TYPE_NAME (gdb_type), id) == 0)
 356       return gdb_type;
 357
 358   /* Next try some predefined types.  Note that none of these types
 359      depend on the current architecture; some of the builtin_type_foo
 360      variables are swapped based on the architecture.  */
 361   if (strcmp (id, "int8") == 0)
 362     return builtin_type_int8;
 363
 364   if (strcmp (id, "int16") == 0)
 365     return builtin_type_int16;
 366
 367   if (strcmp (id, "int32") == 0)
 368     return builtin_type_int32;
 369
 370   if (strcmp (id, "int64") == 0)
 371     return builtin_type_int64;
 372
 373   if (strcmp (id, "uint8") == 0)
 374     return builtin_type_uint8;
 375
 376   if (strcmp (id, "uint16") == 0)
 377     return builtin_type_uint16;
 378
 379   if (strcmp (id, "uint32") == 0)
 380     return builtin_type_uint32;
 381
 382   if (strcmp (id, "uint64") == 0)
 383     return builtin_type_uint64;
 384
 385   if (strcmp (id, "code_ptr") == 0)
 386     return builtin_type_void_func_ptr;
 387
 388   if (strcmp (id, "data_ptr") == 0)
 389     return builtin_type_void_data_ptr;
 390
 391   if (strcmp (id, "arm_fpa_ext") == 0)
 392     return builtin_type_arm_ext;
 393
 394   return NULL;
 395 }
 396 \f
 397
 398 /* Support for registers from target descriptions.  */
 399
 400 /* Construct the per-gdbarch data.  */
 401
 402 static void *
 403 tdesc_data_init (struct obstack *obstack)
 404 {
 405   struct tdesc_arch_data *data;
 406
 407   data = OBSTACK_ZALLOC (obstack, struct tdesc_arch_data);
 408   return data;
 409 }
 410
 411 /* Similar, but for the temporary copy used during architecture
 412    initialization.  */
 413
 414 struct tdesc_arch_data *
 415 tdesc_data_alloc (void)
 416 {
 417   return XZALLOC (struct tdesc_arch_data);
 418 }
 419
 420 /* Free something allocated by tdesc_data_alloc, if it is not going
 421    to be used (for instance if it was unsuitable for the
 422    architecture).  */
 423
 424 void
 425 tdesc_data_cleanup (void *data_untyped)
 426 {
 427   struct tdesc_arch_data *data = data_untyped;
 428
 429   VEC_free (tdesc_reg_p, data->registers);
 430   xfree (data);
 431 }
 432
 433 /* Search FEATURE for a register named NAME.  */
 434
 435 int
 436 tdesc_numbered_register (const struct tdesc_feature *feature,
 437                          struct tdesc_arch_data *data,
 438                          int regno, const char *name)
 439 {
 440   int ixr;
 441   struct tdesc_reg *reg;
 442
 443   for (ixr = 0;
 444        VEC_iterate (tdesc_reg_p, feature->registers, ixr, reg);
 445        ixr++)
 446     if (strcasecmp (reg->name, name) == 0)
 447       {
 448         /* Make sure the vector includes a REGNO'th element.  */
 449         while (regno >= VEC_length (tdesc_reg_p, data->registers))
 450           VEC_safe_push (tdesc_reg_p, data->registers, NULL);
 451         VEC_replace (tdesc_reg_p, data->registers, regno, reg);
 452         return 1;
 453       }
 454
 455   return 0;
 456 }
 457
 458 /* Search FEATURE for a register whose name is in NAMES.  */
 459
 460 int
 461 tdesc_numbered_register_choices (const struct tdesc_feature *feature,
 462                                  struct tdesc_arch_data *data,
 463                                  int regno, const char *const names[])
 464 {
 465   int i;
 466
 467   for (i = 0; names[i] != NULL; i++)
 468     if (tdesc_numbered_register (feature, data, regno, names[i]))
 469       return 1;
 470
 471   return 0;
 472 }
 473
 474 /* Look up a register by its GDB internal register number.  */
 475
 476 static struct tdesc_reg *
 477 tdesc_find_register (struct gdbarch *gdbarch, int regno)
 478 {
 479   struct tdesc_reg *reg;
 480   struct tdesc_arch_data *data;
 481
 482   data = gdbarch_data (gdbarch, tdesc_data);
 483   if (regno < VEC_length (tdesc_reg_p, data->registers))
 484     return VEC_index (tdesc_reg_p, data->registers, regno);
 485   else
 486     return NULL;
 487 }
 488
 489 static const char *
 490 tdesc_register_name (int regno)
 491 {
 492   struct tdesc_reg *reg = tdesc_find_register (current_gdbarch, regno);
 493   int num_regs = gdbarch_num_regs (current_gdbarch);
 494   int num_pseudo_regs = gdbarch_num_pseudo_regs (current_gdbarch);
 495
 496   if (reg != NULL)
 497     return reg->name;
 498
 499   if (regno >= num_regs && regno < num_regs + num_pseudo_regs)
 500     {
 501       struct tdesc_arch_data *data = gdbarch_data (current_gdbarch,
 502                                                    tdesc_data);
 503       gdb_assert (data->pseudo_register_name != NULL);
 504       return data->pseudo_register_name (regno);
 505     }
 506
 507   return "";
 508 }
 509
 510 static struct type *
 511 tdesc_register_type (struct gdbarch *gdbarch, int regno)
 512 {
 513   struct tdesc_reg *reg = tdesc_find_register (gdbarch, regno);
 514   int num_regs = gdbarch_num_regs (gdbarch);
 515   int num_pseudo_regs = gdbarch_num_pseudo_regs (gdbarch);
 516
 517   if (reg == NULL && regno >= num_regs && regno < num_regs + num_pseudo_regs)
 518     {
 519       struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
 520       gdb_assert (data->pseudo_register_type != NULL);
 521       return data->pseudo_register_type (gdbarch, regno);
 522     }
 523
 524   if (reg == NULL)
 525     /* Return "int0_t", since "void" has a misleading size of one.  */
 526     return builtin_type_int0;
 527
 528   /* First check for a predefined or target defined type.  */
 529   if (reg->gdb_type)
 530     return reg->gdb_type;
 531
 532   /* Next try size-sensitive type shortcuts.  */
 533   if (strcmp (reg->type, "float") == 0)
 534     {
 535       if (reg->bitsize == gdbarch_float_bit (gdbarch))
 536         return builtin_type_float;
 537       else if (reg->bitsize == gdbarch_double_bit (gdbarch))
 538         return builtin_type_double;
 539       else if (reg->bitsize == gdbarch_long_double_bit (gdbarch))
 540         return builtin_type_long_double;
 541     }
 542   else if (strcmp (reg->type, "int") == 0)
 543     {
 544       if (reg->bitsize == gdbarch_long_bit (gdbarch))
 545         return builtin_type_long;
 546       else if (reg->bitsize == TARGET_CHAR_BIT)
 547         return builtin_type_char;
 548       else if (reg->bitsize == gdbarch_short_bit (gdbarch))
 549         return builtin_type_short;
 550       else if (reg->bitsize == gdbarch_int_bit (gdbarch))
 551         return builtin_type_int;
 552       else if (reg->bitsize == gdbarch_long_long_bit (gdbarch))
 553         return builtin_type_long_long;
 554       else if (reg->bitsize == gdbarch_ptr_bit (gdbarch))
 555         /* A bit desperate by this point... */
 556         return builtin_type_void_data_ptr;
 557     }
 558   else
 559     internal_error (__FILE__, __LINE__,
 560                     "Register \"%s\" has an unknown type \"%s\"",
 561                     reg->name, reg->type);
 562
 563   warning (_("Register \"%s\" has an unsupported size (%d bits)"),
 564            reg->name, reg->bitsize);
 565   return builtin_type_long;
 566 }
 567
 568 static int
 569 tdesc_remote_register_number (struct gdbarch *gdbarch, int regno)
 570 {
 571   struct tdesc_reg *reg = tdesc_find_register (gdbarch, regno);
 572
 573   if (reg != NULL)
 574     return reg->target_regnum;
 575   else
 576     return -1;
 577 }
 578
 579 /* Check whether REGNUM is a member of REGGROUP.  Registers from the
 580    target description may be classified as general, float, or vector.
 581    Registers with no group specified go to the default reggroup
 582    function and are handled by type.
 583
 584    Arbitrary strings (other than "general", "float", and "vector")
 585    from the description are not used; they cause the register to be
 586    displayed in "info all-registers" but excluded from "info
 587    registers" et al.  The names of containing features are also not
 588    used.  This might be extended to display registers in some more
 589    useful groupings.
 590
 591    The save-restore flag is also implemented here.  */
 592
 593 static int
 594 tdesc_register_reggroup_p (struct gdbarch *gdbarch, int regno,
 595                            struct reggroup *reggroup)
 596 {
 597   int num_regs = gdbarch_num_regs (gdbarch);
 598   int num_pseudo_regs = gdbarch_num_pseudo_regs (gdbarch);
 599   struct tdesc_reg *reg = tdesc_find_register (gdbarch, regno);
 600
 601   if (reg == NULL && regno >= num_regs && regno < num_regs + num_pseudo_regs)
 602     {
 603       struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
 604       gdb_assert (data->pseudo_register_reggroup_p != NULL);
 605       return data->pseudo_register_reggroup_p (gdbarch, regno, reggroup);
 606     }
 607
 608   if (reg != NULL && reg->group != NULL)
 609     {
 610       int general_p = 0, float_p = 0, vector_p = 0;
 611
 612       if (strcmp (reg->group, "general") == 0)
 613         general_p = 1;
 614       else if (strcmp (reg->group, "float") == 0)
 615         float_p = 1;
 616       else if (strcmp (reg->group, "vector") == 0)
 617         vector_p = 1;
 618
 619       if (reggroup == float_reggroup)
 620         return float_p;
 621
 622       if (reggroup == vector_reggroup)
 623         return vector_p;
 624
 625       if (reggroup == general_reggroup)
 626         return general_p;
 627     }
 628
 629   if (reg != NULL
 630       && (reggroup == save_reggroup || reggroup == restore_reggroup))
 631     return reg->save_restore;
 632
 633   return default_register_reggroup_p (gdbarch, regno, reggroup);
 634 }
 635
 636 /* Record architecture-specific functions to call for pseudo-register
 637    support.  */
 638
 639 void
 640 set_tdesc_pseudo_register_name (struct gdbarch *gdbarch,
 641                                 gdbarch_register_name_ftype *pseudo_name)
 642 {
 643   struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
 644
 645   data->pseudo_register_name = pseudo_name;
 646 }
 647
 648 void
 649 set_tdesc_pseudo_register_type (struct gdbarch *gdbarch,
 650                                 gdbarch_register_type_ftype *pseudo_type)
 651 {
 652   struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
 653
 654   data->pseudo_register_type = pseudo_type;
 655 }
 656
 657 void
 658 set_tdesc_pseudo_register_reggroup_p
 659   (struct gdbarch *gdbarch,
 660    gdbarch_register_reggroup_p_ftype *pseudo_reggroup_p)
 661 {
 662   struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
 663
 664   data->pseudo_register_reggroup_p = pseudo_reggroup_p;
 665 }
 666
 667 /* Update GDBARCH to use the target description for registers.  */
 668
 669 void
 670 tdesc_use_registers (struct gdbarch *gdbarch,
 671                      struct tdesc_arch_data *early_data)
 672 {
 673   int num_regs = gdbarch_num_regs (gdbarch);
 674   int i, ixf, ixr;
 675   const struct target_desc *target_desc;
 676   struct tdesc_feature *feature;
 677   struct tdesc_reg *reg;
 678   struct tdesc_arch_data *data;
 679   htab_t reg_hash;
 680
 681   target_desc = gdbarch_target_desc (gdbarch);
 682
 683   /* We can't use the description for registers if it doesn't describe
 684      any.  This function should only be called after validating
 685      registers, so the caller should know that registers are
 686      included.  */
 687   gdb_assert (tdesc_has_registers (target_desc));
 688
 689   data = gdbarch_data (gdbarch, tdesc_data);
 690   data->registers = early_data->registers;
 691   xfree (early_data);
 692
 693   /* Build up a set of all registers, so that we can assign register
 694      numbers where needed.  The hash table expands as necessary, so
 695      the initial size is arbitrary.  */
 696   reg_hash = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
 697   for (ixf = 0;
 698        VEC_iterate (tdesc_feature_p, target_desc->features, ixf, feature);
 699        ixf++)
 700     for (ixr = 0;
 701          VEC_iterate (tdesc_reg_p, feature->registers, ixr, reg);
 702          ixr++)
 703       {
 704         void **slot = htab_find_slot (reg_hash, reg, INSERT);
 705
 706         *slot = reg;
 707       }
 708
 709   /* Remove any registers which were assigned numbers by the
 710      architecture.  */
 711   for (ixr = 0; VEC_iterate (tdesc_reg_p, data->registers, ixr, reg); ixr++)
 712     if (reg)
 713       htab_remove_elt (reg_hash, reg);
 714
 715   /* Assign numbers to the remaining registers and add them to the
 716      list of registers.  The new numbers are always above NUM_REGS.
 717      Iterate over the features, not the hash table, so that the order
 718      matches that in the target description.  */
 719
 720   gdb_assert (VEC_length (tdesc_reg_p, data->registers) <= num_regs);
 721   while (VEC_length (tdesc_reg_p, data->registers) < num_regs)
 722     VEC_safe_push (tdesc_reg_p, data->registers, NULL);
 723   for (ixf = 0;
 724        VEC_iterate (tdesc_feature_p, target_desc->features, ixf, feature);
 725        ixf++)
 726     for (ixr = 0;
 727          VEC_iterate (tdesc_reg_p, feature->registers, ixr, reg);
 728          ixr++)
 729       if (htab_find (reg_hash, reg) != NULL)
 730         {
 731           VEC_safe_push (tdesc_reg_p, data->registers, reg);
 732           num_regs++;
 733         }
 734
 735   htab_delete (reg_hash);
 736
 737   /* Update the architecture.  */
 738   set_gdbarch_num_regs (gdbarch, num_regs);
 739   set_gdbarch_register_name (gdbarch, tdesc_register_name);
 740   set_gdbarch_register_type (gdbarch, tdesc_register_type);
 741   set_gdbarch_remote_register_number (gdbarch,
 742                                       tdesc_remote_register_number);
 743   set_gdbarch_register_reggroup_p (gdbarch, tdesc_register_reggroup_p);
 744 }
 745 \f
 746
 747 /* Methods for constructing a target description.  */
 748
 749 static void
 750 tdesc_free_reg (struct tdesc_reg *reg)
 751 {
 752   xfree (reg->name);
 753   xfree (reg->type);
 754   xfree (reg->group);
 755   xfree (reg);
 756 }
 757
 758 void
 759 tdesc_create_reg (struct tdesc_feature *feature, const char *name,
 760                   int regnum, int save_restore, const char *group,
 761                   int bitsize, const char *type)
 762 {
 763   struct tdesc_reg *reg = XZALLOC (struct tdesc_reg);
 764
 765   reg->name = xstrdup (name);
 766   reg->target_regnum = regnum;
 767   reg->save_restore = save_restore;
 768   reg->group = group ? xstrdup (group) : NULL;
 769   reg->bitsize = bitsize;
 770   reg->type = type ? xstrdup (type) : NULL;
 771
 772   /* If the register's type is target-defined, look it up now.  We may not
 773      have easy access to the containing feature when we want it later.  */
 774   reg->gdb_type = tdesc_named_type (feature, reg->type);
 775
 776   VEC_safe_push (tdesc_reg_p, feature->registers, reg);
 777 }
 778
 779 static void
 780 tdesc_free_feature (struct tdesc_feature *feature)
 781 {
 782   struct tdesc_reg *reg;
 783   int ix;
 784
 785   for (ix = 0; VEC_iterate (tdesc_reg_p, feature->registers, ix, reg); ix++)
 786     tdesc_free_reg (reg);
 787   VEC_free (tdesc_reg_p, feature->registers);
 788
 789   /* There is no easy way to free xmalloc-allocated types, nor is
 790      there a way to allocate types on an obstack not associated with
 791      an objfile.  Therefore we never free types.  Since we only ever
 792      parse an identical XML document once, this memory leak is mostly
 793      contained.  */
 794   VEC_free (type_p, feature->types);
 795
 796   xfree (feature->name);
 797   xfree (feature);
 798 }
 799
 800 struct tdesc_feature *
 801 tdesc_create_feature (struct target_desc *tdesc, const char *name)
 802 {
 803   struct tdesc_feature *new_feature = XZALLOC (struct tdesc_feature);
 804
 805   new_feature->name = xstrdup (name);
 806
 807   VEC_safe_push (tdesc_feature_p, tdesc->features, new_feature);
 808   return new_feature;
 809 }
 810
 811 void
 812 tdesc_record_type (struct tdesc_feature *feature, struct type *type)
 813 {
 814   /* The type's ID should be used as its TYPE_NAME.  */
 815   gdb_assert (TYPE_NAME (type) != NULL);
 816
 817   VEC_safe_push (type_p, feature->types, type);
 818 }
 819
 820 struct target_desc *
 821 allocate_target_description (void)
 822 {
 823   return XZALLOC (struct target_desc);
 824 }
 825
 826 static void
 827 free_target_description (void *arg)
 828 {
 829   struct target_desc *target_desc = arg;
 830   struct tdesc_feature *feature;
 831   struct property *prop;
 832   int ix;
 833
 834   for (ix = 0;
 835        VEC_iterate (tdesc_feature_p, target_desc->features, ix, feature);
 836        ix++)
 837     tdesc_free_feature (feature);
 838   VEC_free (tdesc_feature_p, target_desc->features);
 839
 840   for (ix = 0;
 841        VEC_iterate (property_s, target_desc->properties, ix, prop);
 842        ix++)
 843     {
 844       xfree (prop->key);
 845       xfree (prop->value);
 846     }
 847   VEC_free (property_s, target_desc->properties);
 848
 849   xfree (target_desc);
 850 }
 851
 852 struct cleanup *
 853 make_cleanup_free_target_description (struct target_desc *target_desc)
 854 {
 855   return make_cleanup (free_target_description, target_desc);
 856 }
 857
 858 void
 859 set_tdesc_property (struct target_desc *target_desc,
 860                     const char *key, const char *value)
 861 {
 862   struct property *prop, new_prop;
 863   int ix;
 864
 865   gdb_assert (key != NULL && value != NULL);
 866
 867   for (ix = 0; VEC_iterate (property_s, target_desc->properties, ix, prop);
 868        ix++)
 869     if (strcmp (prop->key, key) == 0)
 870       internal_error (__FILE__, __LINE__,
 871                       _("Attempted to add duplicate property \"%s\""), key);
 872
 873   new_prop.key = xstrdup (key);
 874   new_prop.value = xstrdup (value);
 875   VEC_safe_push (property_s, target_desc->properties, &new_prop);
 876 }
 877
 878 void
 879 set_tdesc_architecture (struct target_desc *target_desc,
 880                         const struct bfd_arch_info *arch)
 881 {
 882   target_desc->arch = arch;
 883 }
 884 \f
 885
 886 static struct cmd_list_element *tdesc_set_cmdlist, *tdesc_show_cmdlist;
 887 static struct cmd_list_element *tdesc_unset_cmdlist;
 888
 889 /* Helper functions for the CLI commands.  */
 890
 891 static void
 892 set_tdesc_cmd (char *args, int from_tty)
 893 {
 894   help_list (tdesc_set_cmdlist, "set tdesc ", -1, gdb_stdout);
 895 }
 896
 897 static void
 898 show_tdesc_cmd (char *args, int from_tty)
 899 {
 900   cmd_show_list (tdesc_show_cmdlist, from_tty, "");
 901 }
 902
 903 static void
 904 unset_tdesc_cmd (char *args, int from_tty)
 905 {
 906   help_list (tdesc_unset_cmdlist, "unset tdesc ", -1, gdb_stdout);
 907 }
 908
 909 static void
 910 set_tdesc_filename_cmd (char *args, int from_tty,
 911                         struct cmd_list_element *c)
 912 {
 913   target_clear_description ();
 914   target_find_description ();
 915 }
 916
 917 static void
 918 show_tdesc_filename_cmd (struct ui_file *file, int from_tty,
 919                          struct cmd_list_element *c,
 920                          const char *value)
 921 {
 922   if (value != NULL && *value != '\0')
 923     printf_filtered (_("\
 924 The target description will be read from \"%s\".\n"),
 925                      value);
 926   else
 927     printf_filtered (_("\
 928 The target description will be read from the target.\n"));
 929 }
 930
 931 static void
 932 unset_tdesc_filename_cmd (char *args, int from_tty)
 933 {
 934   xfree (target_description_filename);
 935   target_description_filename = NULL;
 936   target_clear_description ();
 937   target_find_description ();
 938 }
 939
 940 void
 941 _initialize_target_descriptions (void)
 942 {
 943   tdesc_data = gdbarch_data_register_pre_init (tdesc_data_init);
 944
 945   add_prefix_cmd ("tdesc", class_maintenance, set_tdesc_cmd, _("\
 946 Set target description specific variables."),
 947                   &tdesc_set_cmdlist, "set tdesc ",
 948                   0 /* allow-unknown */, &setlist);
 949   add_prefix_cmd ("tdesc", class_maintenance, show_tdesc_cmd, _("\
 950 Show target description specific variables."),
 951                   &tdesc_show_cmdlist, "show tdesc ",
 952                   0 /* allow-unknown */, &showlist);
 953   add_prefix_cmd ("tdesc", class_maintenance, unset_tdesc_cmd, _("\
 954 Unset target description specific variables."),
 955                   &tdesc_unset_cmdlist, "unset tdesc ",
 956                   0 /* allow-unknown */, &unsetlist);
 957
 958   add_setshow_filename_cmd ("filename", class_obscure,
 959                             &target_description_filename,
 960                             _("\
 961 Set the file to read for an XML target description"), _("\
 962 Show the file to read for an XML target description"), _("\
 963 When set, GDB will read the target description from a local\n\
 964 file instead of querying the remote target."),
 965                             set_tdesc_filename_cmd,
 966                             show_tdesc_filename_cmd,
 967                             &tdesc_set_cmdlist, &tdesc_show_cmdlist);
 968
 969   add_cmd ("filename", class_obscure, unset_tdesc_filename_cmd, _("\
 970 Unset the file to read for an XML target description.  When unset,\n\
 971 GDB will read the description from the target."),
 972            &tdesc_unset_cmdlist);
 973 }