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 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 type *gdb_type;
  83 } *tdesc_reg_p;
  84 DEF_VEC_P(tdesc_reg_p);
  85
  86 /* A named type from a target description.  */
  87 typedef struct type *type_p;
  88 DEF_VEC_P(type_p);
  89
  90 /* A feature from a target description.  Each feature is a collection
  91    of other elements, e.g. registers and types.  */
  92
  93 typedef struct tdesc_feature
  94 {
  95   /* The name of this feature.  It may be recognized by the architecture
  96      support code.  */
  97   char *name;
  98
  99   /* The registers associated with this feature.  */
 100   VEC(tdesc_reg_p) *registers;
 101
 102   /* The types associated with this feature.  */
 103   VEC(type_p) *types;
 104 } *tdesc_feature_p;
 105 DEF_VEC_P(tdesc_feature_p);
 106
 107 /* A target description.  */
 108
 109 struct target_desc
 110 {
 111   /* The architecture reported by the target, if any.  */
 112   const struct bfd_arch_info *arch;
 113
 114   /* Any architecture-specific properties specified by the target.  */
 115   VEC(property_s) *properties;
 116
 117   /* The features associated with this target.  */
 118   VEC(tdesc_feature_p) *features;
 119 };
 120
 121 /* Per-architecture data associated with a target description.  The
 122    target description may be shared by multiple architectures, but
 123    this data is private to one gdbarch.  */
 124
 125 struct tdesc_arch_data
 126 {
 127   /* A list of registers, indexed by GDB's internal register number.
 128      During initialization of the gdbarch this list is used to store
 129      registers which the architecture assigns a fixed register number.
 130      Registers which are NULL in this array, or off the end, are
 131      treated as zero-sized and nameless (i.e. placeholders in the
 132      numbering).  */
 133   VEC(tdesc_reg_p) *registers;
 134
 135   /* Functions which report the register name, type, and reggroups for
 136      pseudo-registers.  */
 137   gdbarch_register_name_ftype *pseudo_register_name;
 138   gdbarch_register_type_ftype *pseudo_register_type;
 139   gdbarch_register_reggroup_p_ftype *pseudo_register_reggroup_p;
 140 };
 141
 142 /* Global state.  These variables are associated with the current
 143    target; if GDB adds support for multiple simultaneous targets, then
 144    these variables should become target-specific data.  */
 145
 146 /* A flag indicating that a description has already been fetched from
 147    the current target, so it should not be queried again.  */
 148
 149 static int target_desc_fetched;
 150
 151 /* The description fetched from the current target, or NULL if the
 152    current target did not supply any description.  Only valid when
 153    target_desc_fetched is set.  Only the description initialization
 154    code should access this; normally, the description should be
 155    accessed through the gdbarch object.  */
 156
 157 static const struct target_desc *current_target_desc;
 158
 159 /* Other global variables.  */
 160
 161 /* The filename to read a target description from.  */
 162
 163 static char *target_description_filename;
 164
 165 /* A handle for architecture-specific data associated with the
 166    target description (see struct tdesc_arch_data).  */
 167
 168 static struct gdbarch_data *tdesc_data;
 169
 170 /* Fetch the current target's description, and switch the current
 171    architecture to one which incorporates that description.  */
 172
 173 void
 174 target_find_description (void)
 175 {
 176   /* If we've already fetched a description from the target, don't do
 177      it again.  This allows a target to fetch the description early,
 178      during its to_open or to_create_inferior, if it needs extra
 179      information about the target to initialize.  */
 180   if (target_desc_fetched)
 181     return;
 182
 183   /* The current architecture should not have any target description
 184      specified.  It should have been cleared, e.g. when we
 185      disconnected from the previous target.  */
 186   gdb_assert (gdbarch_target_desc (current_gdbarch) == NULL);
 187
 188   /* First try to fetch an XML description from the user-specified
 189      file.  */
 190   current_target_desc = NULL;
 191   if (target_description_filename != NULL
 192       && *target_description_filename != '\0')
 193     current_target_desc
 194       = file_read_description_xml (target_description_filename);
 195
 196   /* Next try to read the description from the current target using
 197      target objects.  */
 198   if (current_target_desc == NULL)
 199     current_target_desc = target_read_description_xml (&current_target);
 200
 201   /* If that failed try a target-specific hook.  */
 202   if (current_target_desc == NULL)
 203     current_target_desc = target_read_description (&current_target);
 204
 205   /* If a non-NULL description was returned, then update the current
 206      architecture.  */
 207   if (current_target_desc)
 208     {
 209       struct gdbarch_info info;
 210
 211       gdbarch_info_init (&info);
 212       info.target_desc = current_target_desc;
 213       if (!gdbarch_update_p (info))
 214         warning (_("Architecture rejected target-supplied description"));
 215       else
 216         {
 217           struct tdesc_arch_data *data;
 218
 219           data = gdbarch_data (current_gdbarch, tdesc_data);
 220           if (tdesc_has_registers (current_target_desc)
 221               && data->registers == NULL)
 222             warning (_("Target-supplied registers are not supported "
 223                        "by the current architecture"));
 224         }
 225     }
 226
 227   /* Now that we know this description is usable, record that we
 228      fetched it.  */
 229   target_desc_fetched = 1;
 230 }
 231
 232 /* Discard any description fetched from the current target, and switch
 233    the current architecture to one with no target description.  */
 234
 235 void
 236 target_clear_description (void)
 237 {
 238   struct gdbarch_info info;
 239
 240   if (!target_desc_fetched)
 241     return;
 242
 243   target_desc_fetched = 0;
 244   current_target_desc = NULL;
 245
 246   gdbarch_info_init (&info);
 247   if (!gdbarch_update_p (info))
 248     internal_error (__FILE__, __LINE__,
 249                     _("Could not remove target-supplied description"));
 250 }
 251
 252 /* Return the global current target description.  This should only be
 253    used by gdbarch initialization code; most access should be through
 254    an existing gdbarch.  */
 255
 256 const struct target_desc *
 257 target_current_description (void)
 258 {
 259   if (target_desc_fetched)
 260     return current_target_desc;
 261
 262   return NULL;
 263 }
 264 \f
 265
 266 /* Direct accessors for target descriptions.  */
 267
 268 /* Return the string value of a property named KEY, or NULL if the
 269    property was not specified.  */
 270
 271 const char *
 272 tdesc_property (const struct target_desc *target_desc, const char *key)
 273 {
 274   struct property *prop;
 275   int ix;
 276
 277   for (ix = 0; VEC_iterate (property_s, target_desc->properties, ix, prop);
 278        ix++)
 279     if (strcmp (prop->key, key) == 0)
 280       return prop->value;
 281
 282   return NULL;
 283 }
 284
 285 /* Return the BFD architecture associated with this target
 286    description, or NULL if no architecture was specified.  */
 287
 288 const struct bfd_arch_info *
 289 tdesc_architecture (const struct target_desc *target_desc)
 290 {
 291   return target_desc->arch;
 292 }
 293 \f
 294
 295 /* Return 1 if this target description includes any registers.  */
 296
 297 int
 298 tdesc_has_registers (const struct target_desc *target_desc)
 299 {
 300   int ix;
 301   struct tdesc_feature *feature;
 302
 303   if (target_desc == NULL)
 304     return 0;
 305
 306   for (ix = 0;
 307        VEC_iterate (tdesc_feature_p, target_desc->features, ix, feature);
 308        ix++)
 309     if (! VEC_empty (tdesc_reg_p, feature->registers))
 310       return 1;
 311
 312   return 0;
 313 }
 314
 315 /* Return the feature with the given name, if present, or NULL if
 316    the named feature is not found.  */
 317
 318 const struct tdesc_feature *
 319 tdesc_find_feature (const struct target_desc *target_desc,
 320                     const char *name)
 321 {
 322   int ix;
 323   struct tdesc_feature *feature;
 324
 325   for (ix = 0;
 326        VEC_iterate (tdesc_feature_p, target_desc->features, ix, feature);
 327        ix++)
 328     if (strcmp (feature->name, name) == 0)
 329       return feature;
 330
 331   return NULL;
 332 }
 333
 334 /* Return the name of FEATURE.  */
 335
 336 const char *
 337 tdesc_feature_name (const struct tdesc_feature *feature)
 338 {
 339   return feature->name;
 340 }
 341
 342 /* Predefined types.  Note that none of these types depend on the
 343    current architecture; some of the builtin_type_foo variables are
 344    swapped based on the architecture.  */
 345 static struct
 346 {
 347   const char *name;
 348   struct type **type;
 349 } tdesc_predefined_types[] =
 350   {
 351     { "int8", &builtin_type_int8 },
 352     { "int16", &builtin_type_int16 },
 353     { "int32", &builtin_type_int32 },
 354     { "int64", &builtin_type_int64 },
 355     { "int128", &builtin_type_int128 },
 356     { "uint8", &builtin_type_uint8 },
 357     { "uint16", &builtin_type_uint16 },
 358     { "uint32", &builtin_type_uint32 },
 359     { "uint64", &builtin_type_uint64 },
 360     { "uint128", &builtin_type_uint128 },
 361     { "ieee_single", &builtin_type_ieee_single },
 362     { "ieee_double", &builtin_type_ieee_double },
 363     { "arm_fpa_ext", &builtin_type_arm_ext }
 364   };
 365
 366 /* Return the type associated with ID in the context of FEATURE, or
 367    NULL if none.  */
 368
 369 struct type *
 370 tdesc_named_type (const struct tdesc_feature *feature, const char *id)
 371 {
 372   int ix;
 373   struct type *gdb_type;
 374
 375   /* First try target-defined types.  */
 376   for (ix = 0; VEC_iterate (type_p, feature->types, ix, gdb_type); ix++)
 377     if (strcmp (TYPE_NAME (gdb_type), id) == 0)
 378       return gdb_type;
 379
 380   /* Next try the predefined types.  */
 381   for (ix = 0; ix < ARRAY_SIZE (tdesc_predefined_types); ix++)
 382     if (strcmp (tdesc_predefined_types[ix].name, id) == 0)
 383       return *tdesc_predefined_types[ix].type;
 384
 385   return NULL;
 386 }
 387 \f
 388
 389 /* Support for registers from target descriptions.  */
 390
 391 /* Construct the per-gdbarch data.  */
 392
 393 static void *
 394 tdesc_data_init (struct obstack *obstack)
 395 {
 396   struct tdesc_arch_data *data;
 397
 398   data = OBSTACK_ZALLOC (obstack, struct tdesc_arch_data);
 399   return data;
 400 }
 401
 402 /* Similar, but for the temporary copy used during architecture
 403    initialization.  */
 404
 405 struct tdesc_arch_data *
 406 tdesc_data_alloc (void)
 407 {
 408   return XZALLOC (struct tdesc_arch_data);
 409 }
 410
 411 /* Free something allocated by tdesc_data_alloc, if it is not going
 412    to be used (for instance if it was unsuitable for the
 413    architecture).  */
 414
 415 void
 416 tdesc_data_cleanup (void *data_untyped)
 417 {
 418   struct tdesc_arch_data *data = data_untyped;
 419
 420   VEC_free (tdesc_reg_p, data->registers);
 421   xfree (data);
 422 }
 423
 424 /* Search FEATURE for a register named NAME.  */
 425
 426 static struct tdesc_reg *
 427 tdesc_find_register_early (const struct tdesc_feature *feature,
 428                            const char *name)
 429 {
 430   int ixr;
 431   struct tdesc_reg *reg;
 432
 433   for (ixr = 0;
 434        VEC_iterate (tdesc_reg_p, feature->registers, ixr, reg);
 435        ixr++)
 436     if (strcasecmp (reg->name, name) == 0)
 437       return reg;
 438
 439   return NULL;
 440 }
 441
 442 /* Search FEATURE for a register named NAME.  Assign REGNO to it.  */
 443
 444 int
 445 tdesc_numbered_register (const struct tdesc_feature *feature,
 446                          struct tdesc_arch_data *data,
 447                          int regno, const char *name)
 448 {
 449   struct tdesc_reg *reg = tdesc_find_register_early (feature, name);
 450
 451   if (reg == NULL)
 452     return 0;
 453
 454   /* Make sure the vector includes a REGNO'th element.  */
 455   while (regno >= VEC_length (tdesc_reg_p, data->registers))
 456     VEC_safe_push (tdesc_reg_p, data->registers, NULL);
 457   VEC_replace (tdesc_reg_p, data->registers, regno, reg);
 458   return 1;
 459 }
 460
 461 /* Search FEATURE for a register whose name is in NAMES and assign
 462    REGNO to it.  */
 463
 464 int
 465 tdesc_numbered_register_choices (const struct tdesc_feature *feature,
 466                                  struct tdesc_arch_data *data,
 467                                  int regno, const char *const names[])
 468 {
 469   int i;
 470
 471   for (i = 0; names[i] != NULL; i++)
 472     if (tdesc_numbered_register (feature, data, regno, names[i]))
 473       return 1;
 474
 475   return 0;
 476 }
 477
 478 /* Search FEATURE for a register named NAME, and return its size in
 479    bits.  The register must exist.  */
 480
 481 int
 482 tdesc_register_size (const struct tdesc_feature *feature,
 483                      const char *name)
 484 {
 485   struct tdesc_reg *reg = tdesc_find_register_early (feature, name);
 486
 487   gdb_assert (reg != NULL);
 488   return reg->bitsize;
 489 }
 490
 491 /* Look up a register by its GDB internal register number.  */
 492
 493 static struct tdesc_reg *
 494 tdesc_find_register (struct gdbarch *gdbarch, int regno)
 495 {
 496   struct tdesc_reg *reg;
 497   struct tdesc_arch_data *data;
 498
 499   data = gdbarch_data (gdbarch, tdesc_data);
 500   if (regno < VEC_length (tdesc_reg_p, data->registers))
 501     return VEC_index (tdesc_reg_p, data->registers, regno);
 502   else
 503     return NULL;
 504 }
 505
 506 /* Return the name of register REGNO, from the target description or
 507    from an architecture-provided pseudo_register_name method.  */
 508
 509 const char *
 510 tdesc_register_name (int regno)
 511 {
 512   struct tdesc_reg *reg = tdesc_find_register (current_gdbarch, regno);
 513   int num_regs = gdbarch_num_regs (current_gdbarch);
 514   int num_pseudo_regs = gdbarch_num_pseudo_regs (current_gdbarch);
 515
 516   if (reg != NULL)
 517     return reg->name;
 518
 519   if (regno >= num_regs && regno < num_regs + num_pseudo_regs)
 520     {
 521       struct tdesc_arch_data *data = gdbarch_data (current_gdbarch,
 522                                                    tdesc_data);
 523       gdb_assert (data->pseudo_register_name != NULL);
 524       return data->pseudo_register_name (regno);
 525     }
 526
 527   return "";
 528 }
 529
 530 static struct type *
 531 tdesc_register_type (struct gdbarch *gdbarch, int regno)
 532 {
 533   struct tdesc_reg *reg = tdesc_find_register (gdbarch, regno);
 534   int num_regs = gdbarch_num_regs (gdbarch);
 535   int num_pseudo_regs = gdbarch_num_pseudo_regs (gdbarch);
 536
 537   if (reg == NULL && regno >= num_regs && regno < num_regs + num_pseudo_regs)
 538     {
 539       struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
 540       gdb_assert (data->pseudo_register_type != NULL);
 541       return data->pseudo_register_type (gdbarch, regno);
 542     }
 543
 544   if (reg == NULL)
 545     /* Return "int0_t", since "void" has a misleading size of one.  */
 546     return builtin_type_int0;
 547
 548   /* First check for a predefined or target defined type.  */
 549   if (reg->gdb_type)
 550     return reg->gdb_type;
 551
 552   /* Next try size-sensitive type shortcuts.  */
 553   if (strcmp (reg->type, "float") == 0)
 554     {
 555       if (reg->bitsize == gdbarch_float_bit (gdbarch))
 556         return builtin_type_float;
 557       else if (reg->bitsize == gdbarch_double_bit (gdbarch))
 558         return builtin_type_double;
 559       else if (reg->bitsize == gdbarch_long_double_bit (gdbarch))
 560         return builtin_type_long_double;
 561     }
 562   else if (strcmp (reg->type, "int") == 0)
 563     {
 564       if (reg->bitsize == gdbarch_long_bit (gdbarch))
 565         return builtin_type_long;
 566       else if (reg->bitsize == TARGET_CHAR_BIT)
 567         return builtin_type_char;
 568       else if (reg->bitsize == gdbarch_short_bit (gdbarch))
 569         return builtin_type_short;
 570       else if (reg->bitsize == gdbarch_int_bit (gdbarch))
 571         return builtin_type_int;
 572       else if (reg->bitsize == gdbarch_long_long_bit (gdbarch))
 573         return builtin_type_long_long;
 574       else if (reg->bitsize == gdbarch_ptr_bit (gdbarch))
 575         /* A bit desperate by this point... */
 576         return builtin_type_void_data_ptr;
 577     }
 578   else if (strcmp (reg->type, "code_ptr") == 0)
 579     return builtin_type_void_func_ptr;
 580   else if (strcmp (reg->type, "data_ptr") == 0)
 581     return builtin_type_void_data_ptr;
 582   else
 583     internal_error (__FILE__, __LINE__,
 584                     "Register \"%s\" has an unknown type \"%s\"",
 585                     reg->name, reg->type);
 586
 587   warning (_("Register \"%s\" has an unsupported size (%d bits)"),
 588            reg->name, reg->bitsize);
 589   return builtin_type_long;
 590 }
 591
 592 static int
 593 tdesc_remote_register_number (struct gdbarch *gdbarch, int regno)
 594 {
 595   struct tdesc_reg *reg = tdesc_find_register (gdbarch, regno);
 596
 597   if (reg != NULL)
 598     return reg->target_regnum;
 599   else
 600     return -1;
 601 }
 602
 603 /* Check whether REGNUM is a member of REGGROUP.  Registers from the
 604    target description may be classified as general, float, or vector.
 605    Unlike a gdbarch register_reggroup_p method, this function will
 606    return -1 if it does not know; the caller should handle registers
 607    with no specified group.
 608
 609    Arbitrary strings (other than "general", "float", and "vector")
 610    from the description are not used; they cause the register to be
 611    displayed in "info all-registers" but excluded from "info
 612    registers" et al.  The names of containing features are also not
 613    used.  This might be extended to display registers in some more
 614    useful groupings.
 615
 616    The save-restore flag is also implemented here.  */
 617
 618 int
 619 tdesc_register_in_reggroup_p (struct gdbarch *gdbarch, int regno,
 620                               struct reggroup *reggroup)
 621 {
 622   struct tdesc_reg *reg = tdesc_find_register (gdbarch, regno);
 623
 624   if (reg != NULL && reg->group != NULL)
 625     {
 626       int general_p = 0, float_p = 0, vector_p = 0;
 627
 628       if (strcmp (reg->group, "general") == 0)
 629         general_p = 1;
 630       else if (strcmp (reg->group, "float") == 0)
 631         float_p = 1;
 632       else if (strcmp (reg->group, "vector") == 0)
 633         vector_p = 1;
 634
 635       if (reggroup == float_reggroup)
 636         return float_p;
 637
 638       if (reggroup == vector_reggroup)
 639         return vector_p;
 640
 641       if (reggroup == general_reggroup)
 642         return general_p;
 643     }
 644
 645   if (reg != NULL
 646       && (reggroup == save_reggroup || reggroup == restore_reggroup))
 647     return reg->save_restore;
 648
 649   return -1;
 650 }
 651
 652 /* Check whether REGNUM is a member of REGGROUP.  Registers with no
 653    group specified go to the default reggroup function and are handled
 654    by type.  */
 655
 656 static int
 657 tdesc_register_reggroup_p (struct gdbarch *gdbarch, int regno,
 658                            struct reggroup *reggroup)
 659 {
 660   int num_regs = gdbarch_num_regs (gdbarch);
 661   int num_pseudo_regs = gdbarch_num_pseudo_regs (gdbarch);
 662   int ret;
 663
 664   if (regno >= num_regs && regno < num_regs + num_pseudo_regs)
 665     {
 666       struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
 667       gdb_assert (data->pseudo_register_reggroup_p != NULL);
 668       return data->pseudo_register_reggroup_p (gdbarch, regno, reggroup);
 669     }
 670
 671   ret = tdesc_register_in_reggroup_p (gdbarch, regno, reggroup);
 672   if (ret != -1)
 673     return ret;
 674
 675   return default_register_reggroup_p (gdbarch, regno, reggroup);
 676 }
 677
 678 /* Record architecture-specific functions to call for pseudo-register
 679    support.  */
 680
 681 void
 682 set_tdesc_pseudo_register_name (struct gdbarch *gdbarch,
 683                                 gdbarch_register_name_ftype *pseudo_name)
 684 {
 685   struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
 686
 687   data->pseudo_register_name = pseudo_name;
 688 }
 689
 690 void
 691 set_tdesc_pseudo_register_type (struct gdbarch *gdbarch,
 692                                 gdbarch_register_type_ftype *pseudo_type)
 693 {
 694   struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
 695
 696   data->pseudo_register_type = pseudo_type;
 697 }
 698
 699 void
 700 set_tdesc_pseudo_register_reggroup_p
 701   (struct gdbarch *gdbarch,
 702    gdbarch_register_reggroup_p_ftype *pseudo_reggroup_p)
 703 {
 704   struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
 705
 706   data->pseudo_register_reggroup_p = pseudo_reggroup_p;
 707 }
 708
 709 /* Update GDBARCH to use the target description for registers.  */
 710
 711 void
 712 tdesc_use_registers (struct gdbarch *gdbarch,
 713                      const struct target_desc *target_desc,
 714                      struct tdesc_arch_data *early_data)
 715 {
 716   int num_regs = gdbarch_num_regs (gdbarch);
 717   int i, ixf, ixr;
 718   struct tdesc_feature *feature;
 719   struct tdesc_reg *reg;
 720   struct tdesc_arch_data *data;
 721   htab_t reg_hash;
 722
 723   /* We can't use the description for registers if it doesn't describe
 724      any.  This function should only be called after validating
 725      registers, so the caller should know that registers are
 726      included.  */
 727   gdb_assert (tdesc_has_registers (target_desc));
 728
 729   data = gdbarch_data (gdbarch, tdesc_data);
 730   data->registers = early_data->registers;
 731   xfree (early_data);
 732
 733   /* Build up a set of all registers, so that we can assign register
 734      numbers where needed.  The hash table expands as necessary, so
 735      the initial size is arbitrary.  */
 736   reg_hash = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
 737   for (ixf = 0;
 738        VEC_iterate (tdesc_feature_p, target_desc->features, ixf, feature);
 739        ixf++)
 740     for (ixr = 0;
 741          VEC_iterate (tdesc_reg_p, feature->registers, ixr, reg);
 742          ixr++)
 743       {
 744         void **slot = htab_find_slot (reg_hash, reg, INSERT);
 745
 746         *slot = reg;
 747       }
 748
 749   /* Remove any registers which were assigned numbers by the
 750      architecture.  */
 751   for (ixr = 0; VEC_iterate (tdesc_reg_p, data->registers, ixr, reg); ixr++)
 752     if (reg)
 753       htab_remove_elt (reg_hash, reg);
 754
 755   /* Assign numbers to the remaining registers and add them to the
 756      list of registers.  The new numbers are always above gdbarch_num_regs.
 757      Iterate over the features, not the hash table, so that the order
 758      matches that in the target description.  */
 759
 760   gdb_assert (VEC_length (tdesc_reg_p, data->registers) <= num_regs);
 761   while (VEC_length (tdesc_reg_p, data->registers) < num_regs)
 762     VEC_safe_push (tdesc_reg_p, data->registers, NULL);
 763   for (ixf = 0;
 764        VEC_iterate (tdesc_feature_p, target_desc->features, ixf, feature);
 765        ixf++)
 766     for (ixr = 0;
 767          VEC_iterate (tdesc_reg_p, feature->registers, ixr, reg);
 768          ixr++)
 769       if (htab_find (reg_hash, reg) != NULL)
 770         {
 771           VEC_safe_push (tdesc_reg_p, data->registers, reg);
 772           num_regs++;
 773         }
 774
 775   htab_delete (reg_hash);
 776
 777   /* Update the architecture.  */
 778   set_gdbarch_num_regs (gdbarch, num_regs);
 779   set_gdbarch_register_name (gdbarch, tdesc_register_name);
 780   set_gdbarch_register_type (gdbarch, tdesc_register_type);
 781   set_gdbarch_remote_register_number (gdbarch,
 782                                       tdesc_remote_register_number);
 783   set_gdbarch_register_reggroup_p (gdbarch, tdesc_register_reggroup_p);
 784 }
 785 \f
 786
 787 /* Methods for constructing a target description.  */
 788
 789 static void
 790 tdesc_free_reg (struct tdesc_reg *reg)
 791 {
 792   xfree (reg->name);
 793   xfree (reg->type);
 794   xfree (reg->group);
 795   xfree (reg);
 796 }
 797
 798 void
 799 tdesc_create_reg (struct tdesc_feature *feature, const char *name,
 800                   int regnum, int save_restore, const char *group,
 801                   int bitsize, const char *type)
 802 {
 803   struct tdesc_reg *reg = XZALLOC (struct tdesc_reg);
 804
 805   reg->name = xstrdup (name);
 806   reg->target_regnum = regnum;
 807   reg->save_restore = save_restore;
 808   reg->group = group ? xstrdup (group) : NULL;
 809   reg->bitsize = bitsize;
 810   reg->type = type ? xstrdup (type) : xstrdup ("<unknown>");
 811
 812   /* If the register's type is target-defined, look it up now.  We may not
 813      have easy access to the containing feature when we want it later.  */
 814   reg->gdb_type = tdesc_named_type (feature, reg->type);
 815
 816   VEC_safe_push (tdesc_reg_p, feature->registers, reg);
 817 }
 818
 819 static void
 820 tdesc_free_feature (struct tdesc_feature *feature)
 821 {
 822   struct tdesc_reg *reg;
 823   int ix;
 824
 825   for (ix = 0; VEC_iterate (tdesc_reg_p, feature->registers, ix, reg); ix++)
 826     tdesc_free_reg (reg);
 827   VEC_free (tdesc_reg_p, feature->registers);
 828
 829   /* There is no easy way to free xmalloc-allocated types, nor is
 830      there a way to allocate types on an obstack not associated with
 831      an objfile.  Therefore we never free types.  Since we only ever
 832      parse an identical XML document once, this memory leak is mostly
 833      contained.  */
 834   VEC_free (type_p, feature->types);
 835
 836   xfree (feature->name);
 837   xfree (feature);
 838 }
 839
 840 struct tdesc_feature *
 841 tdesc_create_feature (struct target_desc *tdesc, const char *name)
 842 {
 843   struct tdesc_feature *new_feature = XZALLOC (struct tdesc_feature);
 844
 845   new_feature->name = xstrdup (name);
 846
 847   VEC_safe_push (tdesc_feature_p, tdesc->features, new_feature);
 848   return new_feature;
 849 }
 850
 851 void
 852 tdesc_record_type (struct tdesc_feature *feature, struct type *type)
 853 {
 854   /* The type's ID should be used as its TYPE_NAME.  */
 855   gdb_assert (TYPE_NAME (type) != NULL);
 856
 857   VEC_safe_push (type_p, feature->types, type);
 858 }
 859
 860 struct target_desc *
 861 allocate_target_description (void)
 862 {
 863   return XZALLOC (struct target_desc);
 864 }
 865
 866 static void
 867 free_target_description (void *arg)
 868 {
 869   struct target_desc *target_desc = arg;
 870   struct tdesc_feature *feature;
 871   struct property *prop;
 872   int ix;
 873
 874   for (ix = 0;
 875        VEC_iterate (tdesc_feature_p, target_desc->features, ix, feature);
 876        ix++)
 877     tdesc_free_feature (feature);
 878   VEC_free (tdesc_feature_p, target_desc->features);
 879
 880   for (ix = 0;
 881        VEC_iterate (property_s, target_desc->properties, ix, prop);
 882        ix++)
 883     {
 884       xfree (prop->key);
 885       xfree (prop->value);
 886     }
 887   VEC_free (property_s, target_desc->properties);
 888
 889   xfree (target_desc);
 890 }
 891
 892 struct cleanup *
 893 make_cleanup_free_target_description (struct target_desc *target_desc)
 894 {
 895   return make_cleanup (free_target_description, target_desc);
 896 }
 897
 898 void
 899 set_tdesc_property (struct target_desc *target_desc,
 900                     const char *key, const char *value)
 901 {
 902   struct property *prop, new_prop;
 903   int ix;
 904
 905   gdb_assert (key != NULL && value != NULL);
 906
 907   for (ix = 0; VEC_iterate (property_s, target_desc->properties, ix, prop);
 908        ix++)
 909     if (strcmp (prop->key, key) == 0)
 910       internal_error (__FILE__, __LINE__,
 911                       _("Attempted to add duplicate property \"%s\""), key);
 912
 913   new_prop.key = xstrdup (key);
 914   new_prop.value = xstrdup (value);
 915   VEC_safe_push (property_s, target_desc->properties, &new_prop);
 916 }
 917
 918 void
 919 set_tdesc_architecture (struct target_desc *target_desc,
 920                         const struct bfd_arch_info *arch)
 921 {
 922   target_desc->arch = arch;
 923 }
 924 \f
 925
 926 static struct cmd_list_element *tdesc_set_cmdlist, *tdesc_show_cmdlist;
 927 static struct cmd_list_element *tdesc_unset_cmdlist;
 928
 929 /* Helper functions for the CLI commands.  */
 930
 931 static void
 932 set_tdesc_cmd (char *args, int from_tty)
 933 {
 934   help_list (tdesc_set_cmdlist, "set tdesc ", -1, gdb_stdout);
 935 }
 936
 937 static void
 938 show_tdesc_cmd (char *args, int from_tty)
 939 {
 940   cmd_show_list (tdesc_show_cmdlist, from_tty, "");
 941 }
 942
 943 static void
 944 unset_tdesc_cmd (char *args, int from_tty)
 945 {
 946   help_list (tdesc_unset_cmdlist, "unset tdesc ", -1, gdb_stdout);
 947 }
 948
 949 static void
 950 set_tdesc_filename_cmd (char *args, int from_tty,
 951                         struct cmd_list_element *c)
 952 {
 953   target_clear_description ();
 954   target_find_description ();
 955 }
 956
 957 static void
 958 show_tdesc_filename_cmd (struct ui_file *file, int from_tty,
 959                          struct cmd_list_element *c,
 960                          const char *value)
 961 {
 962   if (value != NULL && *value != '\0')
 963     printf_filtered (_("\
 964 The target description will be read from \"%s\".\n"),
 965                      value);
 966   else
 967     printf_filtered (_("\
 968 The target description will be read from the target.\n"));
 969 }
 970
 971 static void
 972 unset_tdesc_filename_cmd (char *args, int from_tty)
 973 {
 974   xfree (target_description_filename);
 975   target_description_filename = NULL;
 976   target_clear_description ();
 977   target_find_description ();
 978 }
 979
 980 static const char *
 981 tdesc_type_id (struct type *type)
 982 {
 983   int ix;
 984
 985   for (ix = 0; ix < ARRAY_SIZE (tdesc_predefined_types); ix++)
 986     if (TYPE_MAIN_TYPE (*tdesc_predefined_types[ix].type)
 987         == TYPE_MAIN_TYPE (type))
 988       return tdesc_predefined_types[ix].name;
 989
 990   return TYPE_NAME (type);
 991 }
 992
 993 static void
 994 maint_print_c_tdesc_cmd (char *args, int from_tty)
 995 {
 996   const struct target_desc *tdesc;
 997   const char *filename, *inp;
 998   char *function, *outp;
 999   struct property *prop;
1000   struct tdesc_feature *feature;
1001   struct tdesc_reg *reg;
1002   struct type *type;
1003   int ix, ix2, ix3;
1004
1005   /* Use the global target-supplied description, not the current
1006      architecture's.  This lets a GDB for one architecture generate C
1007      for another architecture's description, even though the gdbarch
1008      initialization code will reject the new description.  */
1009   tdesc = current_target_desc;
1010   if (tdesc == NULL)
1011     error (_("There is no target description to print."));
1012
1013   if (target_description_filename == NULL)
1014     error (_("The current target description did not come from an XML file."));
1015
1016   filename = lbasename (target_description_filename);
1017   function = xmalloc (strlen (filename) + 1);
1018   for (inp = filename, outp = function; *inp != '\0'; inp++)
1019     if (*inp == '.')
1020       break;
1021     else if (*inp == '-')
1022       *outp++ = '_';
1023     else
1024       *outp++ = *inp;
1025   *outp = '\0';
1026
1027   /* Standard boilerplate.  */
1028   printf_unfiltered ("/* THIS FILE IS GENERATED.  Original: %s */\n\n",
1029                      filename);
1030   printf_unfiltered ("#include \"defs.h\"\n");
1031   printf_unfiltered ("#include \"gdbtypes.h\"\n");
1032   printf_unfiltered ("#include \"target-descriptions.h\"\n");
1033   printf_unfiltered ("\n");
1034
1035   printf_unfiltered ("struct target_desc *tdesc_%s;\n", function);
1036   printf_unfiltered ("static void\n");
1037   printf_unfiltered ("initialize_tdesc_%s (void)\n", function);
1038   printf_unfiltered ("{\n");
1039   printf_unfiltered
1040     ("  struct target_desc *result = allocate_target_description ();\n");
1041   printf_unfiltered ("  struct tdesc_feature *feature;\n");
1042   printf_unfiltered ("  struct type *field_type, *type;\n");
1043   printf_unfiltered ("\n");
1044
1045   if (tdesc_architecture (tdesc) != NULL)
1046     {
1047       printf_unfiltered
1048         ("  set_tdesc_architecture (result, bfd_scan_arch (\"%s\"));\n",
1049          tdesc_architecture (tdesc)->printable_name);
1050       printf_unfiltered ("\n");
1051     }
1052
1053   for (ix = 0; VEC_iterate (property_s, tdesc->properties, ix, prop);
1054        ix++)
1055     {
1056       printf_unfiltered ("  set_tdesc_property (result, \"%s\", \"%s\");\n",
1057               prop->key, prop->value);
1058     }
1059
1060   for (ix = 0;
1061        VEC_iterate (tdesc_feature_p, tdesc->features, ix, feature);
1062        ix++)
1063     {
1064       printf_unfiltered ("  feature = tdesc_create_feature (result, \"%s\");\n",
1065                          feature->name);
1066
1067       for (ix2 = 0;
1068            VEC_iterate (type_p, feature->types, ix2, type);
1069            ix2++)
1070         {
1071           switch (TYPE_CODE (type))
1072             {
1073             case TYPE_CODE_ARRAY:
1074               printf_unfiltered
1075                 ("  field_type = tdesc_named_type (feature, \"%s\");\n",
1076                  tdesc_type_id (TYPE_TARGET_TYPE (type)));
1077               printf_unfiltered
1078                 ("  type = init_vector_type (field_type, %d);\n",
1079                  TYPE_LENGTH (type) / TYPE_LENGTH (TYPE_TARGET_TYPE (type)));
1080               printf_unfiltered
1081                 ("  TYPE_NAME (type) = xstrdup (\"%s\");\n", TYPE_NAME (type));
1082               break;
1083             case TYPE_CODE_UNION:
1084               printf_unfiltered
1085                 ("  type = init_composite_type (NULL, TYPE_CODE_UNION);\n");
1086               printf_unfiltered
1087                 ("  TYPE_NAME (type) = xstrdup (\"%s\");\n", TYPE_NAME (type));
1088               for (ix3 = 0; ix3 < TYPE_NFIELDS (type); ix3++)
1089                 {
1090                   printf_unfiltered
1091                     ("  field_type = tdesc_named_type (feature, \"%s\");\n",
1092                      tdesc_type_id (TYPE_FIELD_TYPE (type, ix3)));
1093                   printf_unfiltered
1094                     ("  append_composite_type_field (type, "
1095                      "xstrdup (\"%s\"), field_type);\n",
1096                      TYPE_FIELD_NAME (type, ix3));
1097                 }
1098               if (TYPE_VECTOR (type))
1099                 printf_unfiltered
1100                   ("  TYPE_FLAGS (type) |= TYPE_FLAG_VECTOR;\n");
1101               break;
1102             default:
1103               error (_("C output is not supported type \"%s\"."), TYPE_NAME (type));
1104             }
1105           printf_unfiltered ("  tdesc_record_type (feature, type);\n");
1106           printf_unfiltered ("\n");
1107         }
1108
1109       for (ix2 = 0;
1110            VEC_iterate (tdesc_reg_p, feature->registers, ix2, reg);
1111            ix2++)
1112         {
1113           printf_unfiltered ("  tdesc_create_reg (feature, \"%s\", %ld, %d, ",
1114                              reg->name, reg->target_regnum, reg->save_restore);
1115           if (reg->group)
1116             printf_unfiltered ("\"%s\", ", reg->group);
1117           else
1118             printf_unfiltered ("NULL, ");
1119           printf_unfiltered ("%d, \"%s\");\n", reg->bitsize, reg->type);
1120         }
1121
1122       printf_unfiltered ("\n");
1123     }
1124
1125   printf_unfiltered ("  tdesc_%s = result;\n", function);
1126   printf_unfiltered ("}\n");
1127 }
1128
1129 void
1130 _initialize_target_descriptions (void)
1131 {
1132   tdesc_data = gdbarch_data_register_pre_init (tdesc_data_init);
1133
1134   add_prefix_cmd ("tdesc", class_maintenance, set_tdesc_cmd, _("\
1135 Set target description specific variables."),
1136                   &tdesc_set_cmdlist, "set tdesc ",
1137                   0 /* allow-unknown */, &setlist);
1138   add_prefix_cmd ("tdesc", class_maintenance, show_tdesc_cmd, _("\
1139 Show target description specific variables."),
1140                   &tdesc_show_cmdlist, "show tdesc ",
1141                   0 /* allow-unknown */, &showlist);
1142   add_prefix_cmd ("tdesc", class_maintenance, unset_tdesc_cmd, _("\
1143 Unset target description specific variables."),
1144                   &tdesc_unset_cmdlist, "unset tdesc ",
1145                   0 /* allow-unknown */, &unsetlist);
1146
1147   add_setshow_filename_cmd ("filename", class_obscure,
1148                             &target_description_filename,
1149                             _("\
1150 Set the file to read for an XML target description"), _("\
1151 Show the file to read for an XML target description"), _("\
1152 When set, GDB will read the target description from a local\n\
1153 file instead of querying the remote target."),
1154                             set_tdesc_filename_cmd,
1155                             show_tdesc_filename_cmd,
1156                             &tdesc_set_cmdlist, &tdesc_show_cmdlist);
1157
1158   add_cmd ("filename", class_obscure, unset_tdesc_filename_cmd, _("\
1159 Unset the file to read for an XML target description.  When unset,\n\
1160 GDB will read the description from the target."),
1161            &tdesc_unset_cmdlist);
1162
1163   add_cmd ("c-tdesc", class_maintenance, maint_print_c_tdesc_cmd, _("\
1164 Print the current target description as a C source file."),
1165            &maintenanceprintlist);
1166 }