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, "ieee_single") == 0)
 386     return builtin_type_ieee_single;
 387
 388   if (strcmp (id, "ieee_double") == 0)
 389     return builtin_type_ieee_double;
 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 /* Return the name of register REGNO, from the target description or
 490    from an architecture-provided pseudo_register_name method.  */
 491
 492 const char *
 493 tdesc_register_name (int regno)
 494 {
 495   struct tdesc_reg *reg = tdesc_find_register (current_gdbarch, regno);
 496   int num_regs = gdbarch_num_regs (current_gdbarch);
 497   int num_pseudo_regs = gdbarch_num_pseudo_regs (current_gdbarch);
 498
 499   if (reg != NULL)
 500     return reg->name;
 501
 502   if (regno >= num_regs && regno < num_regs + num_pseudo_regs)
 503     {
 504       struct tdesc_arch_data *data = gdbarch_data (current_gdbarch,
 505                                                    tdesc_data);
 506       gdb_assert (data->pseudo_register_name != NULL);
 507       return data->pseudo_register_name (regno);
 508     }
 509
 510   return "";
 511 }
 512
 513 static struct type *
 514 tdesc_register_type (struct gdbarch *gdbarch, int regno)
 515 {
 516   struct tdesc_reg *reg = tdesc_find_register (gdbarch, regno);
 517   int num_regs = gdbarch_num_regs (gdbarch);
 518   int num_pseudo_regs = gdbarch_num_pseudo_regs (gdbarch);
 519
 520   if (reg == NULL && regno >= num_regs && regno < num_regs + num_pseudo_regs)
 521     {
 522       struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
 523       gdb_assert (data->pseudo_register_type != NULL);
 524       return data->pseudo_register_type (gdbarch, regno);
 525     }
 526
 527   if (reg == NULL)
 528     /* Return "int0_t", since "void" has a misleading size of one.  */
 529     return builtin_type_int0;
 530
 531   /* First check for a predefined or target defined type.  */
 532   if (reg->gdb_type)
 533     return reg->gdb_type;
 534
 535   /* Next try size-sensitive type shortcuts.  */
 536   if (strcmp (reg->type, "float") == 0)
 537     {
 538       if (reg->bitsize == gdbarch_float_bit (gdbarch))
 539         return builtin_type_float;
 540       else if (reg->bitsize == gdbarch_double_bit (gdbarch))
 541         return builtin_type_double;
 542       else if (reg->bitsize == gdbarch_long_double_bit (gdbarch))
 543         return builtin_type_long_double;
 544     }
 545   else if (strcmp (reg->type, "int") == 0)
 546     {
 547       if (reg->bitsize == gdbarch_long_bit (gdbarch))
 548         return builtin_type_long;
 549       else if (reg->bitsize == TARGET_CHAR_BIT)
 550         return builtin_type_char;
 551       else if (reg->bitsize == gdbarch_short_bit (gdbarch))
 552         return builtin_type_short;
 553       else if (reg->bitsize == gdbarch_int_bit (gdbarch))
 554         return builtin_type_int;
 555       else if (reg->bitsize == gdbarch_long_long_bit (gdbarch))
 556         return builtin_type_long_long;
 557       else if (reg->bitsize == gdbarch_ptr_bit (gdbarch))
 558         /* A bit desperate by this point... */
 559         return builtin_type_void_data_ptr;
 560     }
 561   else if (strcmp (reg->type, "code_ptr") == 0)
 562     return builtin_type_void_func_ptr;
 563   else if (strcmp (reg->type, "data_ptr") == 0)
 564     return builtin_type_void_data_ptr;
 565   else
 566     internal_error (__FILE__, __LINE__,
 567                     "Register \"%s\" has an unknown type \"%s\"",
 568                     reg->name, reg->type);
 569
 570   warning (_("Register \"%s\" has an unsupported size (%d bits)"),
 571            reg->name, reg->bitsize);
 572   return builtin_type_long;
 573 }
 574
 575 static int
 576 tdesc_remote_register_number (struct gdbarch *gdbarch, int regno)
 577 {
 578   struct tdesc_reg *reg = tdesc_find_register (gdbarch, regno);
 579
 580   if (reg != NULL)
 581     return reg->target_regnum;
 582   else
 583     return -1;
 584 }
 585
 586 /* Check whether REGNUM is a member of REGGROUP.  Registers from the
 587    target description may be classified as general, float, or vector.
 588    Unlike a gdbarch register_reggroup_p method, this function will
 589    return -1 if it does not know; the caller should handle registers
 590    with no specified group.
 591
 592    Arbitrary strings (other than "general", "float", and "vector")
 593    from the description are not used; they cause the register to be
 594    displayed in "info all-registers" but excluded from "info
 595    registers" et al.  The names of containing features are also not
 596    used.  This might be extended to display registers in some more
 597    useful groupings.
 598
 599    The save-restore flag is also implemented here.  */
 600
 601 int
 602 tdesc_register_in_reggroup_p (struct gdbarch *gdbarch, int regno,
 603                               struct reggroup *reggroup)
 604 {
 605   struct tdesc_reg *reg = tdesc_find_register (gdbarch, regno);
 606
 607   if (reg != NULL && reg->group != NULL)
 608     {
 609       int general_p = 0, float_p = 0, vector_p = 0;
 610
 611       if (strcmp (reg->group, "general") == 0)
 612         general_p = 1;
 613       else if (strcmp (reg->group, "float") == 0)
 614         float_p = 1;
 615       else if (strcmp (reg->group, "vector") == 0)
 616         vector_p = 1;
 617
 618       if (reggroup == float_reggroup)
 619         return float_p;
 620
 621       if (reggroup == vector_reggroup)
 622         return vector_p;
 623
 624       if (reggroup == general_reggroup)
 625         return general_p;
 626     }
 627
 628   if (reg != NULL
 629       && (reggroup == save_reggroup || reggroup == restore_reggroup))
 630     return reg->save_restore;
 631
 632   return -1;
 633 }
 634
 635 /* Check whether REGNUM is a member of REGGROUP.  Registers with no
 636    group specified go to the default reggroup function and are handled
 637    by type.  */
 638
 639 static int
 640 tdesc_register_reggroup_p (struct gdbarch *gdbarch, int regno,
 641                            struct reggroup *reggroup)
 642 {
 643   int num_regs = gdbarch_num_regs (gdbarch);
 644   int num_pseudo_regs = gdbarch_num_pseudo_regs (gdbarch);
 645   int ret;
 646
 647   if (regno >= num_regs && regno < num_regs + num_pseudo_regs)
 648     {
 649       struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
 650       gdb_assert (data->pseudo_register_reggroup_p != NULL);
 651       return data->pseudo_register_reggroup_p (gdbarch, regno, reggroup);
 652     }
 653
 654   ret = tdesc_register_in_reggroup_p (gdbarch, regno, reggroup);
 655   if (ret != -1)
 656     return ret;
 657
 658   return default_register_reggroup_p (gdbarch, regno, reggroup);
 659 }
 660
 661 /* Record architecture-specific functions to call for pseudo-register
 662    support.  */
 663
 664 void
 665 set_tdesc_pseudo_register_name (struct gdbarch *gdbarch,
 666                                 gdbarch_register_name_ftype *pseudo_name)
 667 {
 668   struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
 669
 670   data->pseudo_register_name = pseudo_name;
 671 }
 672
 673 void
 674 set_tdesc_pseudo_register_type (struct gdbarch *gdbarch,
 675                                 gdbarch_register_type_ftype *pseudo_type)
 676 {
 677   struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
 678
 679   data->pseudo_register_type = pseudo_type;
 680 }
 681
 682 void
 683 set_tdesc_pseudo_register_reggroup_p
 684   (struct gdbarch *gdbarch,
 685    gdbarch_register_reggroup_p_ftype *pseudo_reggroup_p)
 686 {
 687   struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
 688
 689   data->pseudo_register_reggroup_p = pseudo_reggroup_p;
 690 }
 691
 692 /* Update GDBARCH to use the target description for registers.  */
 693
 694 void
 695 tdesc_use_registers (struct gdbarch *gdbarch,
 696                      struct tdesc_arch_data *early_data)
 697 {
 698   int num_regs = gdbarch_num_regs (gdbarch);
 699   int i, ixf, ixr;
 700   const struct target_desc *target_desc;
 701   struct tdesc_feature *feature;
 702   struct tdesc_reg *reg;
 703   struct tdesc_arch_data *data;
 704   htab_t reg_hash;
 705
 706   target_desc = gdbarch_target_desc (gdbarch);
 707
 708   /* We can't use the description for registers if it doesn't describe
 709      any.  This function should only be called after validating
 710      registers, so the caller should know that registers are
 711      included.  */
 712   gdb_assert (tdesc_has_registers (target_desc));
 713
 714   data = gdbarch_data (gdbarch, tdesc_data);
 715   data->registers = early_data->registers;
 716   xfree (early_data);
 717
 718   /* Build up a set of all registers, so that we can assign register
 719      numbers where needed.  The hash table expands as necessary, so
 720      the initial size is arbitrary.  */
 721   reg_hash = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
 722   for (ixf = 0;
 723        VEC_iterate (tdesc_feature_p, target_desc->features, ixf, feature);
 724        ixf++)
 725     for (ixr = 0;
 726          VEC_iterate (tdesc_reg_p, feature->registers, ixr, reg);
 727          ixr++)
 728       {
 729         void **slot = htab_find_slot (reg_hash, reg, INSERT);
 730
 731         *slot = reg;
 732       }
 733
 734   /* Remove any registers which were assigned numbers by the
 735      architecture.  */
 736   for (ixr = 0; VEC_iterate (tdesc_reg_p, data->registers, ixr, reg); ixr++)
 737     if (reg)
 738       htab_remove_elt (reg_hash, reg);
 739
 740   /* Assign numbers to the remaining registers and add them to the
 741      list of registers.  The new numbers are always above gdbarch_num_regs.
 742      Iterate over the features, not the hash table, so that the order
 743      matches that in the target description.  */
 744
 745   gdb_assert (VEC_length (tdesc_reg_p, data->registers) <= num_regs);
 746   while (VEC_length (tdesc_reg_p, data->registers) < num_regs)
 747     VEC_safe_push (tdesc_reg_p, data->registers, NULL);
 748   for (ixf = 0;
 749        VEC_iterate (tdesc_feature_p, target_desc->features, ixf, feature);
 750        ixf++)
 751     for (ixr = 0;
 752          VEC_iterate (tdesc_reg_p, feature->registers, ixr, reg);
 753          ixr++)
 754       if (htab_find (reg_hash, reg) != NULL)
 755         {
 756           VEC_safe_push (tdesc_reg_p, data->registers, reg);
 757           num_regs++;
 758         }
 759
 760   htab_delete (reg_hash);
 761
 762   /* Update the architecture.  */
 763   set_gdbarch_num_regs (gdbarch, num_regs);
 764   set_gdbarch_register_name (gdbarch, tdesc_register_name);
 765   set_gdbarch_register_type (gdbarch, tdesc_register_type);
 766   set_gdbarch_remote_register_number (gdbarch,
 767                                       tdesc_remote_register_number);
 768   set_gdbarch_register_reggroup_p (gdbarch, tdesc_register_reggroup_p);
 769 }
 770 \f
 771
 772 /* Methods for constructing a target description.  */
 773
 774 static void
 775 tdesc_free_reg (struct tdesc_reg *reg)
 776 {
 777   xfree (reg->name);
 778   xfree (reg->type);
 779   xfree (reg->group);
 780   xfree (reg);
 781 }
 782
 783 void
 784 tdesc_create_reg (struct tdesc_feature *feature, const char *name,
 785                   int regnum, int save_restore, const char *group,
 786                   int bitsize, const char *type)
 787 {
 788   struct tdesc_reg *reg = XZALLOC (struct tdesc_reg);
 789
 790   reg->name = xstrdup (name);
 791   reg->target_regnum = regnum;
 792   reg->save_restore = save_restore;
 793   reg->group = group ? xstrdup (group) : NULL;
 794   reg->bitsize = bitsize;
 795   reg->type = type ? xstrdup (type) : xstrdup ("<unknown>");
 796
 797   /* If the register's type is target-defined, look it up now.  We may not
 798      have easy access to the containing feature when we want it later.  */
 799   reg->gdb_type = tdesc_named_type (feature, reg->type);
 800
 801   VEC_safe_push (tdesc_reg_p, feature->registers, reg);
 802 }
 803
 804 static void
 805 tdesc_free_feature (struct tdesc_feature *feature)
 806 {
 807   struct tdesc_reg *reg;
 808   int ix;
 809
 810   for (ix = 0; VEC_iterate (tdesc_reg_p, feature->registers, ix, reg); ix++)
 811     tdesc_free_reg (reg);
 812   VEC_free (tdesc_reg_p, feature->registers);
 813
 814   /* There is no easy way to free xmalloc-allocated types, nor is
 815      there a way to allocate types on an obstack not associated with
 816      an objfile.  Therefore we never free types.  Since we only ever
 817      parse an identical XML document once, this memory leak is mostly
 818      contained.  */
 819   VEC_free (type_p, feature->types);
 820
 821   xfree (feature->name);
 822   xfree (feature);
 823 }
 824
 825 struct tdesc_feature *
 826 tdesc_create_feature (struct target_desc *tdesc, const char *name)
 827 {
 828   struct tdesc_feature *new_feature = XZALLOC (struct tdesc_feature);
 829
 830   new_feature->name = xstrdup (name);
 831
 832   VEC_safe_push (tdesc_feature_p, tdesc->features, new_feature);
 833   return new_feature;
 834 }
 835
 836 void
 837 tdesc_record_type (struct tdesc_feature *feature, struct type *type)
 838 {
 839   /* The type's ID should be used as its TYPE_NAME.  */
 840   gdb_assert (TYPE_NAME (type) != NULL);
 841
 842   VEC_safe_push (type_p, feature->types, type);
 843 }
 844
 845 struct target_desc *
 846 allocate_target_description (void)
 847 {
 848   return XZALLOC (struct target_desc);
 849 }
 850
 851 static void
 852 free_target_description (void *arg)
 853 {
 854   struct target_desc *target_desc = arg;
 855   struct tdesc_feature *feature;
 856   struct property *prop;
 857   int ix;
 858
 859   for (ix = 0;
 860        VEC_iterate (tdesc_feature_p, target_desc->features, ix, feature);
 861        ix++)
 862     tdesc_free_feature (feature);
 863   VEC_free (tdesc_feature_p, target_desc->features);
 864
 865   for (ix = 0;
 866        VEC_iterate (property_s, target_desc->properties, ix, prop);
 867        ix++)
 868     {
 869       xfree (prop->key);
 870       xfree (prop->value);
 871     }
 872   VEC_free (property_s, target_desc->properties);
 873
 874   xfree (target_desc);
 875 }
 876
 877 struct cleanup *
 878 make_cleanup_free_target_description (struct target_desc *target_desc)
 879 {
 880   return make_cleanup (free_target_description, target_desc);
 881 }
 882
 883 void
 884 set_tdesc_property (struct target_desc *target_desc,
 885                     const char *key, const char *value)
 886 {
 887   struct property *prop, new_prop;
 888   int ix;
 889
 890   gdb_assert (key != NULL && value != NULL);
 891
 892   for (ix = 0; VEC_iterate (property_s, target_desc->properties, ix, prop);
 893        ix++)
 894     if (strcmp (prop->key, key) == 0)
 895       internal_error (__FILE__, __LINE__,
 896                       _("Attempted to add duplicate property \"%s\""), key);
 897
 898   new_prop.key = xstrdup (key);
 899   new_prop.value = xstrdup (value);
 900   VEC_safe_push (property_s, target_desc->properties, &new_prop);
 901 }
 902
 903 void
 904 set_tdesc_architecture (struct target_desc *target_desc,
 905                         const struct bfd_arch_info *arch)
 906 {
 907   target_desc->arch = arch;
 908 }
 909 \f
 910
 911 static struct cmd_list_element *tdesc_set_cmdlist, *tdesc_show_cmdlist;
 912 static struct cmd_list_element *tdesc_unset_cmdlist;
 913
 914 /* Helper functions for the CLI commands.  */
 915
 916 static void
 917 set_tdesc_cmd (char *args, int from_tty)
 918 {
 919   help_list (tdesc_set_cmdlist, "set tdesc ", -1, gdb_stdout);
 920 }
 921
 922 static void
 923 show_tdesc_cmd (char *args, int from_tty)
 924 {
 925   cmd_show_list (tdesc_show_cmdlist, from_tty, "");
 926 }
 927
 928 static void
 929 unset_tdesc_cmd (char *args, int from_tty)
 930 {
 931   help_list (tdesc_unset_cmdlist, "unset tdesc ", -1, gdb_stdout);
 932 }
 933
 934 static void
 935 set_tdesc_filename_cmd (char *args, int from_tty,
 936                         struct cmd_list_element *c)
 937 {
 938   target_clear_description ();
 939   target_find_description ();
 940 }
 941
 942 static void
 943 show_tdesc_filename_cmd (struct ui_file *file, int from_tty,
 944                          struct cmd_list_element *c,
 945                          const char *value)
 946 {
 947   if (value != NULL && *value != '\0')
 948     printf_filtered (_("\
 949 The target description will be read from \"%s\".\n"),
 950                      value);
 951   else
 952     printf_filtered (_("\
 953 The target description will be read from the target.\n"));
 954 }
 955
 956 static void
 957 unset_tdesc_filename_cmd (char *args, int from_tty)
 958 {
 959   xfree (target_description_filename);
 960   target_description_filename = NULL;
 961   target_clear_description ();
 962   target_find_description ();
 963 }
 964
 965 void
 966 _initialize_target_descriptions (void)
 967 {
 968   tdesc_data = gdbarch_data_register_pre_init (tdesc_data_init);
 969
 970   add_prefix_cmd ("tdesc", class_maintenance, set_tdesc_cmd, _("\
 971 Set target description specific variables."),
 972                   &tdesc_set_cmdlist, "set tdesc ",
 973                   0 /* allow-unknown */, &setlist);
 974   add_prefix_cmd ("tdesc", class_maintenance, show_tdesc_cmd, _("\
 975 Show target description specific variables."),
 976                   &tdesc_show_cmdlist, "show tdesc ",
 977                   0 /* allow-unknown */, &showlist);
 978   add_prefix_cmd ("tdesc", class_maintenance, unset_tdesc_cmd, _("\
 979 Unset target description specific variables."),
 980                   &tdesc_unset_cmdlist, "unset tdesc ",
 981                   0 /* allow-unknown */, &unsetlist);
 982
 983   add_setshow_filename_cmd ("filename", class_obscure,
 984                             &target_description_filename,
 985                             _("\
 986 Set the file to read for an XML target description"), _("\
 987 Show the file to read for an XML target description"), _("\
 988 When set, GDB will read the target description from a local\n\
 989 file instead of querying the remote target."),
 990                             set_tdesc_filename_cmd,
 991                             show_tdesc_filename_cmd,
 992                             &tdesc_set_cmdlist, &tdesc_show_cmdlist);
 993
 994   add_cmd ("filename", class_obscure, unset_tdesc_filename_cmd, _("\
 995 Unset the file to read for an XML target description.  When unset,\n\
 996 GDB will read the description from the target."),
 997            &tdesc_unset_cmdlist);
 998 }