gdb/target-descriptions.c

   1 /* Target description support for GDB.
   2
   3    Copyright (C) 2006-2012 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, 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
 868   return reg? reg->reg : NULL;
 869 }
 870
 871 /* Return the name of register REGNO, from the target description or
 872    from an architecture-provided pseudo_register_name method.  */
 873
 874 const char *
 875 tdesc_register_name (struct gdbarch *gdbarch, int regno)
 876 {
 877   struct tdesc_reg *reg = tdesc_find_register (gdbarch, regno);
 878   int num_regs = gdbarch_num_regs (gdbarch);
 879   int num_pseudo_regs = gdbarch_num_pseudo_regs (gdbarch);
 880
 881   if (reg != NULL)
 882     return reg->name;
 883
 884   if (regno >= num_regs && regno < num_regs + num_pseudo_regs)
 885     {
 886       struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
 887
 888       gdb_assert (data->pseudo_register_name != NULL);
 889       return data->pseudo_register_name (gdbarch, regno);
 890     }
 891
 892   return "";
 893 }
 894
 895 struct type *
 896 tdesc_register_type (struct gdbarch *gdbarch, int regno)
 897 {
 898   struct tdesc_arch_reg *arch_reg = tdesc_find_arch_register (gdbarch, regno);
 899   struct tdesc_reg *reg = arch_reg? arch_reg->reg : NULL;
 900   int num_regs = gdbarch_num_regs (gdbarch);
 901   int num_pseudo_regs = gdbarch_num_pseudo_regs (gdbarch);
 902
 903   if (reg == NULL && regno >= num_regs && regno < num_regs + num_pseudo_regs)
 904     {
 905       struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
 906
 907       gdb_assert (data->pseudo_register_type != NULL);
 908       return data->pseudo_register_type (gdbarch, regno);
 909     }
 910
 911   if (reg == NULL)
 912     /* Return "int0_t", since "void" has a misleading size of one.  */
 913     return builtin_type (gdbarch)->builtin_int0;
 914
 915   if (arch_reg->type == NULL)
 916     {
 917       /* First check for a predefined or target defined type.  */
 918       if (reg->tdesc_type)
 919         arch_reg->type = tdesc_gdb_type (gdbarch, reg->tdesc_type);
 920
 921       /* Next try size-sensitive type shortcuts.  */
 922       else if (strcmp (reg->type, "float") == 0)
 923         {
 924           if (reg->bitsize == gdbarch_float_bit (gdbarch))
 925             arch_reg->type = builtin_type (gdbarch)->builtin_float;
 926           else if (reg->bitsize == gdbarch_double_bit (gdbarch))
 927             arch_reg->type = builtin_type (gdbarch)->builtin_double;
 928           else if (reg->bitsize == gdbarch_long_double_bit (gdbarch))
 929             arch_reg->type = builtin_type (gdbarch)->builtin_long_double;
 930           else
 931             {
 932               warning (_("Register \"%s\" has an unsupported size (%d bits)"),
 933                        reg->name, reg->bitsize);
 934               arch_reg->type = builtin_type (gdbarch)->builtin_double;
 935             }
 936         }
 937       else if (strcmp (reg->type, "int") == 0)
 938         {
 939           if (reg->bitsize == gdbarch_long_bit (gdbarch))
 940             arch_reg->type = builtin_type (gdbarch)->builtin_long;
 941           else if (reg->bitsize == TARGET_CHAR_BIT)
 942             arch_reg->type = builtin_type (gdbarch)->builtin_char;
 943           else if (reg->bitsize == gdbarch_short_bit (gdbarch))
 944             arch_reg->type = builtin_type (gdbarch)->builtin_short;
 945           else if (reg->bitsize == gdbarch_int_bit (gdbarch))
 946             arch_reg->type = builtin_type (gdbarch)->builtin_int;
 947           else if (reg->bitsize == gdbarch_long_long_bit (gdbarch))
 948             arch_reg->type = builtin_type (gdbarch)->builtin_long_long;
 949           else if (reg->bitsize == gdbarch_ptr_bit (gdbarch))
 950           /* A bit desperate by this point...  */
 951             arch_reg->type = builtin_type (gdbarch)->builtin_data_ptr;
 952           else
 953             {
 954               warning (_("Register \"%s\" has an unsupported size (%d bits)"),
 955                        reg->name, reg->bitsize);
 956               arch_reg->type = builtin_type (gdbarch)->builtin_long;
 957             }
 958         }
 959
 960       if (arch_reg->type == NULL)
 961         internal_error (__FILE__, __LINE__,
 962                         "Register \"%s\" has an unknown type \"%s\"",
 963                         reg->name, reg->type);
 964     }
 965
 966   return arch_reg->type;
 967 }
 968
 969 static int
 970 tdesc_remote_register_number (struct gdbarch *gdbarch, int regno)
 971 {
 972   struct tdesc_reg *reg = tdesc_find_register (gdbarch, regno);
 973
 974   if (reg != NULL)
 975     return reg->target_regnum;
 976   else
 977     return -1;
 978 }
 979
 980 /* Check whether REGNUM is a member of REGGROUP.  Registers from the
 981    target description may be classified as general, float, or vector.
 982    Unlike a gdbarch register_reggroup_p method, this function will
 983    return -1 if it does not know; the caller should handle registers
 984    with no specified group.
 985
 986    Arbitrary strings (other than "general", "float", and "vector")
 987    from the description are not used; they cause the register to be
 988    displayed in "info all-registers" but excluded from "info
 989    registers" et al.  The names of containing features are also not
 990    used.  This might be extended to display registers in some more
 991    useful groupings.
 992
 993    The save-restore flag is also implemented here.  */
 994
 995 int
 996 tdesc_register_in_reggroup_p (struct gdbarch *gdbarch, int regno,
 997                               struct reggroup *reggroup)
 998 {
 999   struct tdesc_reg *reg = tdesc_find_register (gdbarch, regno);
1000
1001   if (reg != NULL && reg->group != NULL)
1002     {
1003       int general_p = 0, float_p = 0, vector_p = 0;
1004
1005       if (strcmp (reg->group, "general") == 0)
1006         general_p = 1;
1007       else if (strcmp (reg->group, "float") == 0)
1008         float_p = 1;
1009       else if (strcmp (reg->group, "vector") == 0)
1010         vector_p = 1;
1011
1012       if (reggroup == float_reggroup)
1013         return float_p;
1014
1015       if (reggroup == vector_reggroup)
1016         return vector_p;
1017
1018       if (reggroup == general_reggroup)
1019         return general_p;
1020     }
1021
1022   if (reg != NULL
1023       && (reggroup == save_reggroup || reggroup == restore_reggroup))
1024     return reg->save_restore;
1025
1026   return -1;
1027 }
1028
1029 /* Check whether REGNUM is a member of REGGROUP.  Registers with no
1030    group specified go to the default reggroup function and are handled
1031    by type.  */
1032
1033 static int
1034 tdesc_register_reggroup_p (struct gdbarch *gdbarch, int regno,
1035                            struct reggroup *reggroup)
1036 {
1037   int num_regs = gdbarch_num_regs (gdbarch);
1038   int num_pseudo_regs = gdbarch_num_pseudo_regs (gdbarch);
1039   int ret;
1040
1041   if (regno >= num_regs && regno < num_regs + num_pseudo_regs)
1042     {
1043       struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
1044
1045       if (data->pseudo_register_reggroup_p != NULL)
1046         return data->pseudo_register_reggroup_p (gdbarch, regno, reggroup);
1047       /* Otherwise fall through to the default reggroup_p.  */
1048     }
1049
1050   ret = tdesc_register_in_reggroup_p (gdbarch, regno, reggroup);
1051   if (ret != -1)
1052     return ret;
1053
1054   return default_register_reggroup_p (gdbarch, regno, reggroup);
1055 }
1056
1057 /* Record architecture-specific functions to call for pseudo-register
1058    support.  */
1059
1060 void
1061 set_tdesc_pseudo_register_name (struct gdbarch *gdbarch,
1062                                 gdbarch_register_name_ftype *pseudo_name)
1063 {
1064   struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
1065
1066   data->pseudo_register_name = pseudo_name;
1067 }
1068
1069 void
1070 set_tdesc_pseudo_register_type (struct gdbarch *gdbarch,
1071                                 gdbarch_register_type_ftype *pseudo_type)
1072 {
1073   struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
1074
1075   data->pseudo_register_type = pseudo_type;
1076 }
1077
1078 void
1079 set_tdesc_pseudo_register_reggroup_p
1080   (struct gdbarch *gdbarch,
1081    gdbarch_register_reggroup_p_ftype *pseudo_reggroup_p)
1082 {
1083   struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
1084
1085   data->pseudo_register_reggroup_p = pseudo_reggroup_p;
1086 }
1087
1088 /* Update GDBARCH to use the target description for registers.  */
1089
1090 void
1091 tdesc_use_registers (struct gdbarch *gdbarch,
1092                      const struct target_desc *target_desc,
1093                      struct tdesc_arch_data *early_data)
1094 {
1095   int num_regs = gdbarch_num_regs (gdbarch);
1096   int ixf, ixr;
1097   struct tdesc_feature *feature;
1098   struct tdesc_reg *reg;
1099   struct tdesc_arch_data *data;
1100   struct tdesc_arch_reg *arch_reg, new_arch_reg = { 0 };
1101   htab_t reg_hash;
1102
1103   /* We can't use the description for registers if it doesn't describe
1104      any.  This function should only be called after validating
1105      registers, so the caller should know that registers are
1106      included.  */
1107   gdb_assert (tdesc_has_registers (target_desc));
1108
1109   data = gdbarch_data (gdbarch, tdesc_data);
1110   data->arch_regs = early_data->arch_regs;
1111   xfree (early_data);
1112
1113   /* Build up a set of all registers, so that we can assign register
1114      numbers where needed.  The hash table expands as necessary, so
1115      the initial size is arbitrary.  */
1116   reg_hash = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
1117   for (ixf = 0;
1118        VEC_iterate (tdesc_feature_p, target_desc->features, ixf, feature);
1119        ixf++)
1120     for (ixr = 0;
1121          VEC_iterate (tdesc_reg_p, feature->registers, ixr, reg);
1122          ixr++)
1123       {
1124         void **slot = htab_find_slot (reg_hash, reg, INSERT);
1125
1126         *slot = reg;
1127       }
1128
1129   /* Remove any registers which were assigned numbers by the
1130      architecture.  */
1131   for (ixr = 0;
1132        VEC_iterate (tdesc_arch_reg, data->arch_regs, ixr, arch_reg);
1133        ixr++)
1134     if (arch_reg->reg)
1135       htab_remove_elt (reg_hash, arch_reg->reg);
1136
1137   /* Assign numbers to the remaining registers and add them to the
1138      list of registers.  The new numbers are always above gdbarch_num_regs.
1139      Iterate over the features, not the hash table, so that the order
1140      matches that in the target description.  */
1141
1142   gdb_assert (VEC_length (tdesc_arch_reg, data->arch_regs) <= num_regs);
1143   while (VEC_length (tdesc_arch_reg, data->arch_regs) < num_regs)
1144     VEC_safe_push (tdesc_arch_reg, data->arch_regs, &new_arch_reg);
1145   for (ixf = 0;
1146        VEC_iterate (tdesc_feature_p, target_desc->features, ixf, feature);
1147        ixf++)
1148     for (ixr = 0;
1149          VEC_iterate (tdesc_reg_p, feature->registers, ixr, reg);
1150          ixr++)
1151       if (htab_find (reg_hash, reg) != NULL)
1152         {
1153           new_arch_reg.reg = reg;
1154           VEC_safe_push (tdesc_arch_reg, data->arch_regs, &new_arch_reg);
1155           num_regs++;
1156         }
1157
1158   htab_delete (reg_hash);
1159
1160   /* Update the architecture.  */
1161   set_gdbarch_num_regs (gdbarch, num_regs);
1162   set_gdbarch_register_name (gdbarch, tdesc_register_name);
1163   set_gdbarch_register_type (gdbarch, tdesc_register_type);
1164   set_gdbarch_remote_register_number (gdbarch,
1165                                       tdesc_remote_register_number);
1166   set_gdbarch_register_reggroup_p (gdbarch, tdesc_register_reggroup_p);
1167 }
1168 \f
1169
1170 /* Methods for constructing a target description.  */
1171
1172 static void
1173 tdesc_free_reg (struct tdesc_reg *reg)
1174 {
1175   xfree (reg->name);
1176   xfree (reg->type);
1177   xfree (reg->group);
1178   xfree (reg);
1179 }
1180
1181 void
1182 tdesc_create_reg (struct tdesc_feature *feature, const char *name,
1183                   int regnum, int save_restore, const char *group,
1184                   int bitsize, const char *type)
1185 {
1186   struct tdesc_reg *reg = XZALLOC (struct tdesc_reg);
1187
1188   reg->name = xstrdup (name);
1189   reg->target_regnum = regnum;
1190   reg->save_restore = save_restore;
1191   reg->group = group ? xstrdup (group) : NULL;
1192   reg->bitsize = bitsize;
1193   reg->type = type ? xstrdup (type) : xstrdup ("<unknown>");
1194
1195   /* If the register's type is target-defined, look it up now.  We may not
1196      have easy access to the containing feature when we want it later.  */
1197   reg->tdesc_type = tdesc_named_type (feature, reg->type);
1198
1199   VEC_safe_push (tdesc_reg_p, feature->registers, reg);
1200 }
1201
1202 static void
1203 tdesc_free_type (struct tdesc_type *type)
1204 {
1205   switch (type->kind)
1206     {
1207     case TDESC_TYPE_STRUCT:
1208     case TDESC_TYPE_UNION:
1209       {
1210         struct tdesc_type_field *f;
1211         int ix;
1212
1213         for (ix = 0;
1214              VEC_iterate (tdesc_type_field, type->u.u.fields, ix, f);
1215              ix++)
1216           xfree (f->name);
1217
1218         VEC_free (tdesc_type_field, type->u.u.fields);
1219       }
1220       break;
1221
1222     case TDESC_TYPE_FLAGS:
1223       {
1224         struct tdesc_type_flag *f;
1225         int ix;
1226
1227         for (ix = 0;
1228              VEC_iterate (tdesc_type_flag, type->u.f.flags, ix, f);
1229              ix++)
1230           xfree (f->name);
1231
1232         VEC_free (tdesc_type_flag, type->u.f.flags);
1233       }
1234       break;
1235
1236     default:
1237       break;
1238     }
1239
1240   xfree (type->name);
1241   xfree (type);
1242 }
1243
1244 struct tdesc_type *
1245 tdesc_create_vector (struct tdesc_feature *feature, const char *name,
1246                      struct tdesc_type *field_type, int count)
1247 {
1248   struct tdesc_type *type = XZALLOC (struct tdesc_type);
1249
1250   type->name = xstrdup (name);
1251   type->kind = TDESC_TYPE_VECTOR;
1252   type->u.v.type = field_type;
1253   type->u.v.count = count;
1254
1255   VEC_safe_push (tdesc_type_p, feature->types, type);
1256   return type;
1257 }
1258
1259 struct tdesc_type *
1260 tdesc_create_struct (struct tdesc_feature *feature, const char *name)
1261 {
1262   struct tdesc_type *type = XZALLOC (struct tdesc_type);
1263
1264   type->name = xstrdup (name);
1265   type->kind = TDESC_TYPE_STRUCT;
1266
1267   VEC_safe_push (tdesc_type_p, feature->types, type);
1268   return type;
1269 }
1270
1271 /* Set the total length of TYPE.  Structs which contain bitfields may
1272    omit the reserved bits, so the end of the last field may not
1273    suffice.  */
1274
1275 void
1276 tdesc_set_struct_size (struct tdesc_type *type, LONGEST size)
1277 {
1278   gdb_assert (type->kind == TDESC_TYPE_STRUCT);
1279   type->u.u.size = size;
1280 }
1281
1282 struct tdesc_type *
1283 tdesc_create_union (struct tdesc_feature *feature, const char *name)
1284 {
1285   struct tdesc_type *type = XZALLOC (struct tdesc_type);
1286
1287   type->name = xstrdup (name);
1288   type->kind = TDESC_TYPE_UNION;
1289
1290   VEC_safe_push (tdesc_type_p, feature->types, type);
1291   return type;
1292 }
1293
1294 struct tdesc_type *
1295 tdesc_create_flags (struct tdesc_feature *feature, const char *name,
1296                     LONGEST size)
1297 {
1298   struct tdesc_type *type = XZALLOC (struct tdesc_type);
1299
1300   type->name = xstrdup (name);
1301   type->kind = TDESC_TYPE_FLAGS;
1302   type->u.f.size = size;
1303
1304   VEC_safe_push (tdesc_type_p, feature->types, type);
1305   return type;
1306 }
1307
1308 /* Add a new field.  Return a temporary pointer to the field, which
1309    is only valid until the next call to tdesc_add_field (the vector
1310    might be reallocated).  */
1311
1312 void
1313 tdesc_add_field (struct tdesc_type *type, const char *field_name,
1314                  struct tdesc_type *field_type)
1315 {
1316   struct tdesc_type_field f = { 0 };
1317
1318   gdb_assert (type->kind == TDESC_TYPE_UNION
1319               || type->kind == TDESC_TYPE_STRUCT);
1320
1321   f.name = xstrdup (field_name);
1322   f.type = field_type;
1323
1324   VEC_safe_push (tdesc_type_field, type->u.u.fields, &f);
1325 }
1326
1327 /* Add a new bitfield.  */
1328
1329 void
1330 tdesc_add_bitfield (struct tdesc_type *type, const char *field_name,
1331                     int start, int end)
1332 {
1333   struct tdesc_type_field f = { 0 };
1334
1335   gdb_assert (type->kind == TDESC_TYPE_STRUCT);
1336
1337   f.name = xstrdup (field_name);
1338   f.start = start;
1339   f.end = end;
1340
1341   VEC_safe_push (tdesc_type_field, type->u.u.fields, &f);
1342 }
1343
1344 void
1345 tdesc_add_flag (struct tdesc_type *type, int start,
1346                 const char *flag_name)
1347 {
1348   struct tdesc_type_flag f = { 0 };
1349
1350   gdb_assert (type->kind == TDESC_TYPE_FLAGS);
1351
1352   f.name = xstrdup (flag_name);
1353   f.start = start;
1354
1355   VEC_safe_push (tdesc_type_flag, type->u.f.flags, &f);
1356 }
1357
1358 static void
1359 tdesc_free_feature (struct tdesc_feature *feature)
1360 {
1361   struct tdesc_reg *reg;
1362   struct tdesc_type *type;
1363   int ix;
1364
1365   for (ix = 0; VEC_iterate (tdesc_reg_p, feature->registers, ix, reg); ix++)
1366     tdesc_free_reg (reg);
1367   VEC_free (tdesc_reg_p, feature->registers);
1368
1369   for (ix = 0; VEC_iterate (tdesc_type_p, feature->types, ix, type); ix++)
1370     tdesc_free_type (type);
1371   VEC_free (tdesc_type_p, feature->types);
1372
1373   xfree (feature->name);
1374   xfree (feature);
1375 }
1376
1377 struct tdesc_feature *
1378 tdesc_create_feature (struct target_desc *tdesc, const char *name)
1379 {
1380   struct tdesc_feature *new_feature = XZALLOC (struct tdesc_feature);
1381
1382   new_feature->name = xstrdup (name);
1383
1384   VEC_safe_push (tdesc_feature_p, tdesc->features, new_feature);
1385   return new_feature;
1386 }
1387
1388 struct target_desc *
1389 allocate_target_description (void)
1390 {
1391   return XZALLOC (struct target_desc);
1392 }
1393
1394 static void
1395 free_target_description (void *arg)
1396 {
1397   struct target_desc *target_desc = arg;
1398   struct tdesc_feature *feature;
1399   struct property *prop;
1400   int ix;
1401
1402   for (ix = 0;
1403        VEC_iterate (tdesc_feature_p, target_desc->features, ix, feature);
1404        ix++)
1405     tdesc_free_feature (feature);
1406   VEC_free (tdesc_feature_p, target_desc->features);
1407
1408   for (ix = 0;
1409        VEC_iterate (property_s, target_desc->properties, ix, prop);
1410        ix++)
1411     {
1412       xfree (prop->key);
1413       xfree (prop->value);
1414     }
1415   VEC_free (property_s, target_desc->properties);
1416
1417   VEC_free (arch_p, target_desc->compatible);
1418
1419   xfree (target_desc);
1420 }
1421
1422 struct cleanup *
1423 make_cleanup_free_target_description (struct target_desc *target_desc)
1424 {
1425   return make_cleanup (free_target_description, target_desc);
1426 }
1427
1428 void
1429 tdesc_add_compatible (struct target_desc *target_desc,
1430                       const struct bfd_arch_info *compatible)
1431 {
1432   const struct bfd_arch_info *compat;
1433   int ix;
1434
1435   /* If this instance of GDB is compiled without BFD support for the
1436      compatible architecture, simply ignore it -- we would not be able
1437      to handle it anyway.  */
1438   if (compatible == NULL)
1439     return;
1440
1441   for (ix = 0; VEC_iterate (arch_p, target_desc->compatible, ix, compat);
1442        ix++)
1443     if (compat == compatible)
1444       internal_error (__FILE__, __LINE__,
1445                       _("Attempted to add duplicate "
1446                         "compatible architecture \"%s\""),
1447                       compatible->printable_name);
1448
1449   VEC_safe_push (arch_p, target_desc->compatible, compatible);
1450 }
1451
1452 void
1453 set_tdesc_property (struct target_desc *target_desc,
1454                     const char *key, const char *value)
1455 {
1456   struct property *prop, new_prop;
1457   int ix;
1458
1459   gdb_assert (key != NULL && value != NULL);
1460
1461   for (ix = 0; VEC_iterate (property_s, target_desc->properties, ix, prop);
1462        ix++)
1463     if (strcmp (prop->key, key) == 0)
1464       internal_error (__FILE__, __LINE__,
1465                       _("Attempted to add duplicate property \"%s\""), key);
1466
1467   new_prop.key = xstrdup (key);
1468   new_prop.value = xstrdup (value);
1469   VEC_safe_push (property_s, target_desc->properties, &new_prop);
1470 }
1471
1472 void
1473 set_tdesc_architecture (struct target_desc *target_desc,
1474                         const struct bfd_arch_info *arch)
1475 {
1476   target_desc->arch = arch;
1477 }
1478
1479 void
1480 set_tdesc_osabi (struct target_desc *target_desc, enum gdb_osabi osabi)
1481 {
1482   target_desc->osabi = osabi;
1483 }
1484 \f
1485
1486 static struct cmd_list_element *tdesc_set_cmdlist, *tdesc_show_cmdlist;
1487 static struct cmd_list_element *tdesc_unset_cmdlist;
1488
1489 /* Helper functions for the CLI commands.  */
1490
1491 static void
1492 set_tdesc_cmd (char *args, int from_tty)
1493 {
1494   help_list (tdesc_set_cmdlist, "set tdesc ", -1, gdb_stdout);
1495 }
1496
1497 static void
1498 show_tdesc_cmd (char *args, int from_tty)
1499 {
1500   cmd_show_list (tdesc_show_cmdlist, from_tty, "");
1501 }
1502
1503 static void
1504 unset_tdesc_cmd (char *args, int from_tty)
1505 {
1506   help_list (tdesc_unset_cmdlist, "unset tdesc ", -1, gdb_stdout);
1507 }
1508
1509 static void
1510 set_tdesc_filename_cmd (char *args, int from_tty,
1511                         struct cmd_list_element *c)
1512 {
1513   target_clear_description ();
1514   target_find_description ();
1515 }
1516
1517 static void
1518 show_tdesc_filename_cmd (struct ui_file *file, int from_tty,
1519                          struct cmd_list_element *c,
1520                          const char *value)
1521 {
1522   if (value != NULL && *value != '\0')
1523     printf_filtered (_("The target description will be read from \"%s\".\n"),
1524                      value);
1525   else
1526     printf_filtered (_("The target description will be "
1527                        "read from the target.\n"));
1528 }
1529
1530 static void
1531 unset_tdesc_filename_cmd (char *args, int from_tty)
1532 {
1533   xfree (target_description_filename);
1534   target_description_filename = NULL;
1535   target_clear_description ();
1536   target_find_description ();
1537 }
1538
1539 static void
1540 maint_print_c_tdesc_cmd (char *args, int from_tty)
1541 {
1542   const struct target_desc *tdesc;
1543   const struct bfd_arch_info *compatible;
1544   const char *filename, *inp;
1545   char *function, *outp;
1546   struct property *prop;
1547   struct tdesc_feature *feature;
1548   struct tdesc_reg *reg;
1549   struct tdesc_type *type;
1550   struct tdesc_type_field *f;
1551   struct tdesc_type_flag *flag;
1552   int ix, ix2, ix3;
1553
1554   /* Use the global target-supplied description, not the current
1555      architecture's.  This lets a GDB for one architecture generate C
1556      for another architecture's description, even though the gdbarch
1557      initialization code will reject the new description.  */
1558   tdesc = current_target_desc;
1559   if (tdesc == NULL)
1560     error (_("There is no target description to print."));
1561
1562   if (target_description_filename == NULL)
1563     error (_("The current target description did not come from an XML file."));
1564
1565   filename = lbasename (target_description_filename);
1566   function = alloca (strlen (filename) + 1);
1567   for (inp = filename, outp = function; *inp != '\0'; inp++)
1568     if (*inp == '.')
1569       break;
1570     else if (*inp == '-')
1571       *outp++ = '_';
1572     else
1573       *outp++ = *inp;
1574   *outp = '\0';
1575
1576   /* Standard boilerplate.  */
1577   printf_unfiltered ("/* THIS FILE IS GENERATED.  Original: %s */\n\n",
1578                      filename);
1579   printf_unfiltered ("#include \"defs.h\"\n");
1580   printf_unfiltered ("#include \"osabi.h\"\n");
1581   printf_unfiltered ("#include \"target-descriptions.h\"\n");
1582   printf_unfiltered ("\n");
1583
1584   printf_unfiltered ("struct target_desc *tdesc_%s;\n", function);
1585   printf_unfiltered ("static void\n");
1586   printf_unfiltered ("initialize_tdesc_%s (void)\n", function);
1587   printf_unfiltered ("{\n");
1588   printf_unfiltered
1589     ("  struct target_desc *result = allocate_target_description ();\n");
1590   printf_unfiltered ("  struct tdesc_feature *feature;\n");
1591   printf_unfiltered ("  struct tdesc_type *field_type, *type;\n");
1592   printf_unfiltered ("\n");
1593
1594   if (tdesc_architecture (tdesc) != NULL)
1595     {
1596       printf_unfiltered
1597         ("  set_tdesc_architecture (result, bfd_scan_arch (\"%s\"));\n",
1598          tdesc_architecture (tdesc)->printable_name);
1599       printf_unfiltered ("\n");
1600     }
1601
1602   if (tdesc_osabi (tdesc) > GDB_OSABI_UNKNOWN
1603       && tdesc_osabi (tdesc) < GDB_OSABI_INVALID)
1604     {
1605       printf_unfiltered
1606         ("  set_tdesc_osabi (result, osabi_from_tdesc_string (\"%s\"));\n",
1607          gdbarch_osabi_name (tdesc_osabi (tdesc)));
1608       printf_unfiltered ("\n");
1609     }
1610
1611   for (ix = 0; VEC_iterate (arch_p, tdesc->compatible, ix, compatible);
1612        ix++)
1613     {
1614       printf_unfiltered
1615         ("  tdesc_add_compatible (result, bfd_scan_arch (\"%s\"));\n",
1616          compatible->printable_name);
1617     }
1618   if (ix)
1619     printf_unfiltered ("\n");
1620
1621   for (ix = 0; VEC_iterate (property_s, tdesc->properties, ix, prop);
1622        ix++)
1623     {
1624       printf_unfiltered ("  set_tdesc_property (result, \"%s\", \"%s\");\n",
1625               prop->key, prop->value);
1626     }
1627
1628   for (ix = 0;
1629        VEC_iterate (tdesc_feature_p, tdesc->features, ix, feature);
1630        ix++)
1631     {
1632       printf_unfiltered ("  \
1633 feature = tdesc_create_feature (result, \"%s\");\n",
1634                          feature->name);
1635
1636       for (ix2 = 0;
1637            VEC_iterate (tdesc_type_p, feature->types, ix2, type);
1638            ix2++)
1639         {
1640           switch (type->kind)
1641             {
1642             case TDESC_TYPE_VECTOR:
1643               printf_unfiltered
1644                 ("  field_type = tdesc_named_type (feature, \"%s\");\n",
1645                  type->u.v.type->name);
1646               printf_unfiltered
1647                 ("  tdesc_create_vector (feature, \"%s\", field_type, %d);\n",
1648                  type->name, type->u.v.count);
1649               break;
1650             case TDESC_TYPE_UNION:
1651               printf_unfiltered
1652                 ("  type = tdesc_create_union (feature, \"%s\");\n",
1653                  type->name);
1654               for (ix3 = 0;
1655                    VEC_iterate (tdesc_type_field, type->u.u.fields, ix3, f);
1656                    ix3++)
1657                 {
1658                   printf_unfiltered
1659                     ("  field_type = tdesc_named_type (feature, \"%s\");\n",
1660                      f->type->name);
1661                   printf_unfiltered
1662                     ("  tdesc_add_field (type, \"%s\", field_type);\n",
1663                      f->name);
1664                 }
1665               break;
1666             case TDESC_TYPE_FLAGS:
1667               printf_unfiltered
1668                 ("  field_type = tdesc_create_flags (feature, \"%s\", %d);\n",
1669                  type->name, (int) type->u.f.size);
1670               for (ix3 = 0;
1671                    VEC_iterate (tdesc_type_flag, type->u.f.flags, ix3,
1672                                 flag);
1673                    ix3++)
1674                 printf_unfiltered
1675                   ("  tdesc_add_flag (field_type, %d, \"%s\");\n",
1676                    flag->start, flag->name);
1677               break;
1678             default:
1679               error (_("C output is not supported type \"%s\"."), type->name);
1680             }
1681           printf_unfiltered ("\n");
1682         }
1683
1684       for (ix2 = 0;
1685            VEC_iterate (tdesc_reg_p, feature->registers, ix2, reg);
1686            ix2++)
1687         {
1688           printf_unfiltered ("  tdesc_create_reg (feature, \"%s\", %ld, %d, ",
1689                              reg->name, reg->target_regnum, reg->save_restore);
1690           if (reg->group)
1691             printf_unfiltered ("\"%s\", ", reg->group);
1692           else
1693             printf_unfiltered ("NULL, ");
1694           printf_unfiltered ("%d, \"%s\");\n", reg->bitsize, reg->type);
1695         }
1696
1697       printf_unfiltered ("\n");
1698     }
1699
1700   printf_unfiltered ("  tdesc_%s = result;\n", function);
1701   printf_unfiltered ("}\n");
1702 }
1703
1704 /* Provide a prototype to silence -Wmissing-prototypes.  */
1705 extern initialize_file_ftype _initialize_target_descriptions;
1706
1707 void
1708 _initialize_target_descriptions (void)
1709 {
1710   tdesc_data = gdbarch_data_register_pre_init (tdesc_data_init);
1711
1712   add_prefix_cmd ("tdesc", class_maintenance, set_tdesc_cmd, _("\
1713 Set target description specific variables."),
1714                   &tdesc_set_cmdlist, "set tdesc ",
1715                   0 /* allow-unknown */, &setlist);
1716   add_prefix_cmd ("tdesc", class_maintenance, show_tdesc_cmd, _("\
1717 Show target description specific variables."),
1718                   &tdesc_show_cmdlist, "show tdesc ",
1719                   0 /* allow-unknown */, &showlist);
1720   add_prefix_cmd ("tdesc", class_maintenance, unset_tdesc_cmd, _("\
1721 Unset target description specific variables."),
1722                   &tdesc_unset_cmdlist, "unset tdesc ",
1723                   0 /* allow-unknown */, &unsetlist);
1724
1725   add_setshow_filename_cmd ("filename", class_obscure,
1726                             &target_description_filename,
1727                             _("\
1728 Set the file to read for an XML target description"), _("\
1729 Show the file to read for an XML target description"), _("\
1730 When set, GDB will read the target description from a local\n\
1731 file instead of querying the remote target."),
1732                             set_tdesc_filename_cmd,
1733                             show_tdesc_filename_cmd,
1734                             &tdesc_set_cmdlist, &tdesc_show_cmdlist);
1735
1736   add_cmd ("filename", class_obscure, unset_tdesc_filename_cmd, _("\
1737 Unset the file to read for an XML target description.  When unset,\n\
1738 GDB will read the description from the target."),
1739            &tdesc_unset_cmdlist);
1740
1741   add_cmd ("c-tdesc", class_maintenance, maint_print_c_tdesc_cmd, _("\
1742 Print the current target description as a C source file."),
1743            &maintenanceprintlist);
1744 }