gdb/target-descriptions.c

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