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 type *type, *field_type;
 706         struct tdesc_type_flag *f;
 707         int ix;
 708
 709         type = arch_flags_type (gdbarch, xstrdup (tdesc_type->name),
 710                                 tdesc_type->u.f.size);
 711         for (ix = 0;
 712              VEC_iterate (tdesc_type_flag, tdesc_type->u.f.flags, ix, f);
 713              ix++)
 714           /* Note that contrary to the function name, this call will
 715              just set the properties of an already-allocated
 716              field.  */
 717           append_flags_type_flag (type, f->start,
 718                                   *f->name ? f->name : NULL);
 719
 720         return type;
 721       }
 722     }
 723
 724   internal_error (__FILE__, __LINE__,
 725                   "Type \"%s\" has an unknown kind %d",
 726                   tdesc_type->name, tdesc_type->kind);
 727 }
 728 \f
 729
 730 /* Support for registers from target descriptions.  */
 731
 732 /* Construct the per-gdbarch data.  */
 733
 734 static void *
 735 tdesc_data_init (struct obstack *obstack)
 736 {
 737   struct tdesc_arch_data *data;
 738
 739   data = OBSTACK_ZALLOC (obstack, struct tdesc_arch_data);
 740   return data;
 741 }
 742
 743 /* Similar, but for the temporary copy used during architecture
 744    initialization.  */
 745
 746 struct tdesc_arch_data *
 747 tdesc_data_alloc (void)
 748 {
 749   return XZALLOC (struct tdesc_arch_data);
 750 }
 751
 752 /* Free something allocated by tdesc_data_alloc, if it is not going
 753    to be used (for instance if it was unsuitable for the
 754    architecture).  */
 755
 756 void
 757 tdesc_data_cleanup (void *data_untyped)
 758 {
 759   struct tdesc_arch_data *data = data_untyped;
 760
 761   VEC_free (tdesc_arch_reg, data->arch_regs);
 762   xfree (data);
 763 }
 764
 765 /* Search FEATURE for a register named NAME.  */
 766
 767 static struct tdesc_reg *
 768 tdesc_find_register_early (const struct tdesc_feature *feature,
 769                            const char *name)
 770 {
 771   int ixr;
 772   struct tdesc_reg *reg;
 773
 774   for (ixr = 0;
 775        VEC_iterate (tdesc_reg_p, feature->registers, ixr, reg);
 776        ixr++)
 777     if (strcasecmp (reg->name, name) == 0)
 778       return reg;
 779
 780   return NULL;
 781 }
 782
 783 /* Search FEATURE for a register named NAME.  Assign REGNO to it.  */
 784
 785 int
 786 tdesc_numbered_register (const struct tdesc_feature *feature,
 787                          struct tdesc_arch_data *data,
 788                          int regno, const char *name)
 789 {
 790   struct tdesc_arch_reg arch_reg = { 0 };
 791   struct tdesc_reg *reg = tdesc_find_register_early (feature, name);
 792
 793   if (reg == NULL)
 794     return 0;
 795
 796   /* Make sure the vector includes a REGNO'th element.  */
 797   while (regno >= VEC_length (tdesc_arch_reg, data->arch_regs))
 798     VEC_safe_push (tdesc_arch_reg, data->arch_regs, &arch_reg);
 799
 800   arch_reg.reg = reg;
 801   VEC_replace (tdesc_arch_reg, data->arch_regs, regno, &arch_reg);
 802   return 1;
 803 }
 804
 805 /* Search FEATURE for a register named NAME, but do not assign a fixed
 806    register number to it.  */
 807
 808 int
 809 tdesc_unnumbered_register (const struct tdesc_feature *feature,
 810                            const char *name)
 811 {
 812   struct tdesc_reg *reg = tdesc_find_register_early (feature, name);
 813
 814   if (reg == NULL)
 815     return 0;
 816
 817   return 1;
 818 }
 819
 820 /* Search FEATURE for a register whose name is in NAMES and assign
 821    REGNO to it.  */
 822
 823 int
 824 tdesc_numbered_register_choices (const struct tdesc_feature *feature,
 825                                  struct tdesc_arch_data *data,
 826                                  int regno, const char *const names[])
 827 {
 828   int i;
 829
 830   for (i = 0; names[i] != NULL; i++)
 831     if (tdesc_numbered_register (feature, data, regno, names[i]))
 832       return 1;
 833
 834   return 0;
 835 }
 836
 837 /* Search FEATURE for a register named NAME, and return its size in
 838    bits.  The register must exist.  */
 839
 840 int
 841 tdesc_register_size (const struct tdesc_feature *feature,
 842                      const char *name)
 843 {
 844   struct tdesc_reg *reg = tdesc_find_register_early (feature, name);
 845
 846   gdb_assert (reg != NULL);
 847   return reg->bitsize;
 848 }
 849
 850 /* Look up a register by its GDB internal register number.  */
 851
 852 static struct tdesc_arch_reg *
 853 tdesc_find_arch_register (struct gdbarch *gdbarch, int regno)
 854 {
 855   struct tdesc_arch_reg *reg;
 856   struct tdesc_arch_data *data;
 857
 858   data = gdbarch_data (gdbarch, tdesc_data);
 859   if (regno < VEC_length (tdesc_arch_reg, data->arch_regs))
 860     return VEC_index (tdesc_arch_reg, data->arch_regs, regno);
 861   else
 862     return NULL;
 863 }
 864
 865 static struct tdesc_reg *
 866 tdesc_find_register (struct gdbarch *gdbarch, int regno)
 867 {
 868   struct tdesc_arch_reg *reg = tdesc_find_arch_register (gdbarch, regno);
 869   return reg? reg->reg : NULL;
 870 }
 871
 872 /* Return the name of register REGNO, from the target description or
 873    from an architecture-provided pseudo_register_name method.  */
 874
 875 const char *
 876 tdesc_register_name (struct gdbarch *gdbarch, int regno)
 877 {
 878   struct tdesc_reg *reg = tdesc_find_register (gdbarch, regno);
 879   int num_regs = gdbarch_num_regs (gdbarch);
 880   int num_pseudo_regs = gdbarch_num_pseudo_regs (gdbarch);
 881
 882   if (reg != NULL)
 883     return reg->name;
 884
 885   if (regno >= num_regs && regno < num_regs + num_pseudo_regs)
 886     {
 887       struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
 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       gdb_assert (data->pseudo_register_type != NULL);
 907       return data->pseudo_register_type (gdbarch, regno);
 908     }
 909
 910   if (reg == NULL)
 911     /* Return "int0_t", since "void" has a misleading size of one.  */
 912     return builtin_type (gdbarch)->builtin_int0;
 913
 914   if (arch_reg->type == NULL)
 915     {
 916       /* First check for a predefined or target defined type.  */
 917       if (reg->tdesc_type)
 918         arch_reg->type = tdesc_gdb_type (gdbarch, reg->tdesc_type);
 919
 920       /* Next try size-sensitive type shortcuts.  */
 921       else if (strcmp (reg->type, "float") == 0)
 922         {
 923           if (reg->bitsize == gdbarch_float_bit (gdbarch))
 924             arch_reg->type = builtin_type (gdbarch)->builtin_float;
 925           else if (reg->bitsize == gdbarch_double_bit (gdbarch))
 926             arch_reg->type = builtin_type (gdbarch)->builtin_double;
 927           else if (reg->bitsize == gdbarch_long_double_bit (gdbarch))
 928             arch_reg->type = builtin_type (gdbarch)->builtin_long_double;
 929           else
 930             {
 931               warning (_("Register \"%s\" has an unsupported size (%d bits)"),
 932                        reg->name, reg->bitsize);
 933               arch_reg->type = builtin_type (gdbarch)->builtin_double;
 934             }
 935         }
 936       else if (strcmp (reg->type, "int") == 0)
 937         {
 938           if (reg->bitsize == gdbarch_long_bit (gdbarch))
 939             arch_reg->type = builtin_type (gdbarch)->builtin_long;
 940           else if (reg->bitsize == TARGET_CHAR_BIT)
 941             arch_reg->type = builtin_type (gdbarch)->builtin_char;
 942           else if (reg->bitsize == gdbarch_short_bit (gdbarch))
 943             arch_reg->type = builtin_type (gdbarch)->builtin_short;
 944           else if (reg->bitsize == gdbarch_int_bit (gdbarch))
 945             arch_reg->type = builtin_type (gdbarch)->builtin_int;
 946           else if (reg->bitsize == gdbarch_long_long_bit (gdbarch))
 947             arch_reg->type = builtin_type (gdbarch)->builtin_long_long;
 948           else if (reg->bitsize == gdbarch_ptr_bit (gdbarch))
 949           /* A bit desperate by this point... */
 950             arch_reg->type = builtin_type (gdbarch)->builtin_data_ptr;
 951           else
 952             {
 953               warning (_("Register \"%s\" has an unsupported size (%d bits)"),
 954                        reg->name, reg->bitsize);
 955               arch_reg->type = builtin_type (gdbarch)->builtin_long;
 956             }
 957         }
 958
 959       if (arch_reg->type == NULL)
 960         internal_error (__FILE__, __LINE__,
 961                         "Register \"%s\" has an unknown type \"%s\"",
 962                         reg->name, reg->type);
 963     }
 964
 965   return arch_reg->type;
 966 }
 967
 968 static int
 969 tdesc_remote_register_number (struct gdbarch *gdbarch, int regno)
 970 {
 971   struct tdesc_reg *reg = tdesc_find_register (gdbarch, regno);
 972
 973   if (reg != NULL)
 974     return reg->target_regnum;
 975   else
 976     return -1;
 977 }
 978
 979 /* Check whether REGNUM is a member of REGGROUP.  Registers from the
 980    target description may be classified as general, float, or vector.
 981    Unlike a gdbarch register_reggroup_p method, this function will
 982    return -1 if it does not know; the caller should handle registers
 983    with no specified group.
 984
 985    Arbitrary strings (other than "general", "float", and "vector")
 986    from the description are not used; they cause the register to be
 987    displayed in "info all-registers" but excluded from "info
 988    registers" et al.  The names of containing features are also not
 989    used.  This might be extended to display registers in some more
 990    useful groupings.
 991
 992    The save-restore flag is also implemented here.  */
 993
 994 int
 995 tdesc_register_in_reggroup_p (struct gdbarch *gdbarch, int regno,
 996                               struct reggroup *reggroup)
 997 {
 998   struct tdesc_reg *reg = tdesc_find_register (gdbarch, regno);
 999
1000   if (reg != NULL && reg->group != NULL)
1001     {
1002       int general_p = 0, float_p = 0, vector_p = 0;
1003
1004       if (strcmp (reg->group, "general") == 0)
1005         general_p = 1;
1006       else if (strcmp (reg->group, "float") == 0)
1007         float_p = 1;
1008       else if (strcmp (reg->group, "vector") == 0)
1009         vector_p = 1;
1010
1011       if (reggroup == float_reggroup)
1012         return float_p;
1013
1014       if (reggroup == vector_reggroup)
1015         return vector_p;
1016
1017       if (reggroup == general_reggroup)
1018         return general_p;
1019     }
1020
1021   if (reg != NULL
1022       && (reggroup == save_reggroup || reggroup == restore_reggroup))
1023     return reg->save_restore;
1024
1025   return -1;
1026 }
1027
1028 /* Check whether REGNUM is a member of REGGROUP.  Registers with no
1029    group specified go to the default reggroup function and are handled
1030    by type.  */
1031
1032 static int
1033 tdesc_register_reggroup_p (struct gdbarch *gdbarch, int regno,
1034                            struct reggroup *reggroup)
1035 {
1036   int num_regs = gdbarch_num_regs (gdbarch);
1037   int num_pseudo_regs = gdbarch_num_pseudo_regs (gdbarch);
1038   int ret;
1039
1040   if (regno >= num_regs && regno < num_regs + num_pseudo_regs)
1041     {
1042       struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
1043       if (data->pseudo_register_reggroup_p != NULL)
1044         return data->pseudo_register_reggroup_p (gdbarch, regno, reggroup);
1045       /* Otherwise fall through to the default reggroup_p.  */
1046     }
1047
1048   ret = tdesc_register_in_reggroup_p (gdbarch, regno, reggroup);
1049   if (ret != -1)
1050     return ret;
1051
1052   return default_register_reggroup_p (gdbarch, regno, reggroup);
1053 }
1054
1055 /* Record architecture-specific functions to call for pseudo-register
1056    support.  */
1057
1058 void
1059 set_tdesc_pseudo_register_name (struct gdbarch *gdbarch,
1060                                 gdbarch_register_name_ftype *pseudo_name)
1061 {
1062   struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
1063
1064   data->pseudo_register_name = pseudo_name;
1065 }
1066
1067 void
1068 set_tdesc_pseudo_register_type (struct gdbarch *gdbarch,
1069                                 gdbarch_register_type_ftype *pseudo_type)
1070 {
1071   struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
1072
1073   data->pseudo_register_type = pseudo_type;
1074 }
1075
1076 void
1077 set_tdesc_pseudo_register_reggroup_p
1078   (struct gdbarch *gdbarch,
1079    gdbarch_register_reggroup_p_ftype *pseudo_reggroup_p)
1080 {
1081   struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
1082
1083   data->pseudo_register_reggroup_p = pseudo_reggroup_p;
1084 }
1085
1086 /* Update GDBARCH to use the target description for registers.  */
1087
1088 void
1089 tdesc_use_registers (struct gdbarch *gdbarch,
1090                      const struct target_desc *target_desc,
1091                      struct tdesc_arch_data *early_data)
1092 {
1093   int num_regs = gdbarch_num_regs (gdbarch);
1094   int i, ixf, ixr;
1095   struct tdesc_feature *feature;
1096   struct tdesc_reg *reg;
1097   struct tdesc_arch_data *data;
1098   struct tdesc_arch_reg *arch_reg, new_arch_reg = { 0 };
1099   htab_t reg_hash;
1100
1101   /* We can't use the description for registers if it doesn't describe
1102      any.  This function should only be called after validating
1103      registers, so the caller should know that registers are
1104      included.  */
1105   gdb_assert (tdesc_has_registers (target_desc));
1106
1107   data = gdbarch_data (gdbarch, tdesc_data);
1108   data->arch_regs = early_data->arch_regs;
1109   xfree (early_data);
1110
1111   /* Build up a set of all registers, so that we can assign register
1112      numbers where needed.  The hash table expands as necessary, so
1113      the initial size is arbitrary.  */
1114   reg_hash = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
1115   for (ixf = 0;
1116        VEC_iterate (tdesc_feature_p, target_desc->features, ixf, feature);
1117        ixf++)
1118     for (ixr = 0;
1119          VEC_iterate (tdesc_reg_p, feature->registers, ixr, reg);
1120          ixr++)
1121       {
1122         void **slot = htab_find_slot (reg_hash, reg, INSERT);
1123
1124         *slot = reg;
1125       }
1126
1127   /* Remove any registers which were assigned numbers by the
1128      architecture.  */
1129   for (ixr = 0;
1130        VEC_iterate (tdesc_arch_reg, data->arch_regs, ixr, arch_reg);
1131        ixr++)
1132     if (arch_reg->reg)
1133       htab_remove_elt (reg_hash, arch_reg->reg);
1134
1135   /* Assign numbers to the remaining registers and add them to the
1136      list of registers.  The new numbers are always above gdbarch_num_regs.
1137      Iterate over the features, not the hash table, so that the order
1138      matches that in the target description.  */
1139
1140   gdb_assert (VEC_length (tdesc_arch_reg, data->arch_regs) <= num_regs);
1141   while (VEC_length (tdesc_arch_reg, data->arch_regs) < num_regs)
1142     VEC_safe_push (tdesc_arch_reg, data->arch_regs, &new_arch_reg);
1143   for (ixf = 0;
1144        VEC_iterate (tdesc_feature_p, target_desc->features, ixf, feature);
1145        ixf++)
1146     for (ixr = 0;
1147          VEC_iterate (tdesc_reg_p, feature->registers, ixr, reg);
1148          ixr++)
1149       if (htab_find (reg_hash, reg) != NULL)
1150         {
1151           new_arch_reg.reg = reg;
1152           VEC_safe_push (tdesc_arch_reg, data->arch_regs, &new_arch_reg);
1153           num_regs++;
1154         }
1155
1156   htab_delete (reg_hash);
1157
1158   /* Update the architecture.  */
1159   set_gdbarch_num_regs (gdbarch, num_regs);
1160   set_gdbarch_register_name (gdbarch, tdesc_register_name);
1161   set_gdbarch_register_type (gdbarch, tdesc_register_type);
1162   set_gdbarch_remote_register_number (gdbarch,
1163                                       tdesc_remote_register_number);
1164   set_gdbarch_register_reggroup_p (gdbarch, tdesc_register_reggroup_p);
1165 }
1166 \f
1167
1168 /* Methods for constructing a target description.  */
1169
1170 static void
1171 tdesc_free_reg (struct tdesc_reg *reg)
1172 {
1173   xfree (reg->name);
1174   xfree (reg->type);
1175   xfree (reg->group);
1176   xfree (reg);
1177 }
1178
1179 void
1180 tdesc_create_reg (struct tdesc_feature *feature, const char *name,
1181                   int regnum, int save_restore, const char *group,
1182                   int bitsize, const char *type)
1183 {
1184   struct tdesc_reg *reg = XZALLOC (struct tdesc_reg);
1185
1186   reg->name = xstrdup (name);
1187   reg->target_regnum = regnum;
1188   reg->save_restore = save_restore;
1189   reg->group = group ? xstrdup (group) : NULL;
1190   reg->bitsize = bitsize;
1191   reg->type = type ? xstrdup (type) : xstrdup ("<unknown>");
1192
1193   /* If the register's type is target-defined, look it up now.  We may not
1194      have easy access to the containing feature when we want it later.  */
1195   reg->tdesc_type = tdesc_named_type (feature, reg->type);
1196
1197   VEC_safe_push (tdesc_reg_p, feature->registers, reg);
1198 }
1199
1200 static void
1201 tdesc_free_type (struct tdesc_type *type)
1202 {
1203
1204   switch (type->kind)
1205     {
1206     case TDESC_TYPE_STRUCT:
1207     case TDESC_TYPE_UNION:
1208       {
1209         struct tdesc_type_field *f;
1210         int ix;
1211
1212         for (ix = 0;
1213              VEC_iterate (tdesc_type_field, type->u.u.fields, ix, f);
1214              ix++)
1215           xfree (f->name);
1216
1217         VEC_free (tdesc_type_field, type->u.u.fields);
1218       }
1219       break;
1220
1221     case TDESC_TYPE_FLAGS:
1222       {
1223         struct tdesc_type_flag *f;
1224         int ix;
1225
1226         for (ix = 0;
1227              VEC_iterate (tdesc_type_flag, type->u.f.flags, ix, f);
1228              ix++)
1229           xfree (f->name);
1230
1231         VEC_free (tdesc_type_flag, type->u.f.flags);
1232       }
1233       break;
1234
1235     default:
1236       break;
1237     }
1238
1239   xfree (type->name);
1240   xfree (type);
1241 }
1242
1243 struct tdesc_type *
1244 tdesc_create_vector (struct tdesc_feature *feature, const char *name,
1245                      struct tdesc_type *field_type, int count)
1246 {
1247   struct tdesc_type *type = XZALLOC (struct tdesc_type);
1248
1249   type->name = xstrdup (name);
1250   type->kind = TDESC_TYPE_VECTOR;
1251   type->u.v.type = field_type;
1252   type->u.v.count = count;
1253
1254   VEC_safe_push (tdesc_type_p, feature->types, type);
1255   return type;
1256 }
1257
1258 struct tdesc_type *
1259 tdesc_create_struct (struct tdesc_feature *feature, const char *name)
1260 {
1261   struct tdesc_type *type = XZALLOC (struct tdesc_type);
1262
1263   type->name = xstrdup (name);
1264   type->kind = TDESC_TYPE_STRUCT;
1265
1266   VEC_safe_push (tdesc_type_p, feature->types, type);
1267   return type;
1268 }
1269
1270 /* Set the total length of TYPE.  Structs which contain bitfields may
1271    omit the reserved bits, so the end of the last field may not
1272    suffice.  */
1273
1274 void
1275 tdesc_set_struct_size (struct tdesc_type *type, LONGEST size)
1276 {
1277   gdb_assert (type->kind == TDESC_TYPE_STRUCT);
1278   type->u.u.size = size;
1279 }
1280
1281 struct tdesc_type *
1282 tdesc_create_union (struct tdesc_feature *feature, const char *name)
1283 {
1284   struct tdesc_type *type = XZALLOC (struct tdesc_type);
1285
1286   type->name = xstrdup (name);
1287   type->kind = TDESC_TYPE_UNION;
1288
1289   VEC_safe_push (tdesc_type_p, feature->types, type);
1290   return type;
1291 }
1292
1293 struct tdesc_type *
1294 tdesc_create_flags (struct tdesc_feature *feature, const char *name,
1295                     LONGEST size)
1296 {
1297   struct tdesc_type *type = XZALLOC (struct tdesc_type);
1298
1299   type->name = xstrdup (name);
1300   type->kind = TDESC_TYPE_FLAGS;
1301   type->u.f.size = size;
1302
1303   VEC_safe_push (tdesc_type_p, feature->types, type);
1304   return type;
1305 }
1306
1307 /* Add a new field.  Return a temporary pointer to the field, which
1308    is only valid until the next call to tdesc_add_field (the vector
1309    might be reallocated).  */
1310
1311 void
1312 tdesc_add_field (struct tdesc_type *type, const char *field_name,
1313                  struct tdesc_type *field_type)
1314 {
1315   struct tdesc_type_field f = { 0 };
1316
1317   gdb_assert (type->kind == TDESC_TYPE_UNION
1318               || type->kind == TDESC_TYPE_STRUCT);
1319
1320   f.name = xstrdup (field_name);
1321   f.type = field_type;
1322
1323   VEC_safe_push (tdesc_type_field, type->u.u.fields, &f);
1324 }
1325
1326 /* Add a new bitfield.  */
1327
1328 void
1329 tdesc_add_bitfield (struct tdesc_type *type, const char *field_name,
1330                     int start, int end)
1331 {
1332   struct tdesc_type_field f = { 0 };
1333
1334   gdb_assert (type->kind == TDESC_TYPE_STRUCT);
1335
1336   f.name = xstrdup (field_name);
1337   f.start = start;
1338   f.end = end;
1339
1340   VEC_safe_push (tdesc_type_field, type->u.u.fields, &f);
1341 }
1342
1343 void
1344 tdesc_add_flag (struct tdesc_type *type, int start,
1345                 const char *flag_name)
1346 {
1347   struct tdesc_type_flag f = { 0 };
1348
1349   gdb_assert (type->kind == TDESC_TYPE_FLAGS);
1350
1351   f.name = xstrdup (flag_name);
1352   f.start = start;
1353
1354   VEC_safe_push (tdesc_type_flag, type->u.f.flags, &f);
1355 }
1356
1357 static void
1358 tdesc_free_feature (struct tdesc_feature *feature)
1359 {
1360   struct tdesc_reg *reg;
1361   struct tdesc_type *type;
1362   int ix;
1363
1364   for (ix = 0; VEC_iterate (tdesc_reg_p, feature->registers, ix, reg); ix++)
1365     tdesc_free_reg (reg);
1366   VEC_free (tdesc_reg_p, feature->registers);
1367
1368   for (ix = 0; VEC_iterate (tdesc_type_p, feature->types, ix, type); ix++)
1369     tdesc_free_type (type);
1370   VEC_free (tdesc_type_p, feature->types);
1371
1372   xfree (feature->name);
1373   xfree (feature);
1374 }
1375
1376 struct tdesc_feature *
1377 tdesc_create_feature (struct target_desc *tdesc, const char *name)
1378 {
1379   struct tdesc_feature *new_feature = XZALLOC (struct tdesc_feature);
1380
1381   new_feature->name = xstrdup (name);
1382
1383   VEC_safe_push (tdesc_feature_p, tdesc->features, new_feature);
1384   return new_feature;
1385 }
1386
1387 struct target_desc *
1388 allocate_target_description (void)
1389 {
1390   return XZALLOC (struct target_desc);
1391 }
1392
1393 static void
1394 free_target_description (void *arg)
1395 {
1396   struct target_desc *target_desc = arg;
1397   struct tdesc_feature *feature;
1398   struct property *prop;
1399   int ix;
1400
1401   for (ix = 0;
1402        VEC_iterate (tdesc_feature_p, target_desc->features, ix, feature);
1403        ix++)
1404     tdesc_free_feature (feature);
1405   VEC_free (tdesc_feature_p, target_desc->features);
1406
1407   for (ix = 0;
1408        VEC_iterate (property_s, target_desc->properties, ix, prop);
1409        ix++)
1410     {
1411       xfree (prop->key);
1412       xfree (prop->value);
1413     }
1414   VEC_free (property_s, target_desc->properties);
1415
1416   VEC_free (arch_p, target_desc->compatible);
1417
1418   xfree (target_desc);
1419 }
1420
1421 struct cleanup *
1422 make_cleanup_free_target_description (struct target_desc *target_desc)
1423 {
1424   return make_cleanup (free_target_description, target_desc);
1425 }
1426
1427 void
1428 tdesc_add_compatible (struct target_desc *target_desc,
1429                       const struct bfd_arch_info *compatible)
1430 {
1431   const struct bfd_arch_info *compat;
1432   int ix;
1433
1434   /* If this instance of GDB is compiled without BFD support for the
1435      compatible architecture, simply ignore it -- we would not be able
1436      to handle it anyway.  */
1437   if (compatible == NULL)
1438     return;
1439
1440   for (ix = 0; VEC_iterate (arch_p, target_desc->compatible, ix, compat);
1441        ix++)
1442     if (compat == compatible)
1443       internal_error (__FILE__, __LINE__,
1444                       _("Attempted to add duplicate "
1445                         "compatible architecture \"%s\""),
1446                       compatible->printable_name);
1447
1448   VEC_safe_push (arch_p, target_desc->compatible, compatible);
1449 }
1450
1451 void
1452 set_tdesc_property (struct target_desc *target_desc,
1453                     const char *key, const char *value)
1454 {
1455   struct property *prop, new_prop;
1456   int ix;
1457
1458   gdb_assert (key != NULL && value != NULL);
1459
1460   for (ix = 0; VEC_iterate (property_s, target_desc->properties, ix, prop);
1461        ix++)
1462     if (strcmp (prop->key, key) == 0)
1463       internal_error (__FILE__, __LINE__,
1464                       _("Attempted to add duplicate property \"%s\""), key);
1465
1466   new_prop.key = xstrdup (key);
1467   new_prop.value = xstrdup (value);
1468   VEC_safe_push (property_s, target_desc->properties, &new_prop);
1469 }
1470
1471 void
1472 set_tdesc_architecture (struct target_desc *target_desc,
1473                         const struct bfd_arch_info *arch)
1474 {
1475   target_desc->arch = arch;
1476 }
1477
1478 void
1479 set_tdesc_osabi (struct target_desc *target_desc, enum gdb_osabi osabi)
1480 {
1481   target_desc->osabi = osabi;
1482 }
1483 \f
1484
1485 static struct cmd_list_element *tdesc_set_cmdlist, *tdesc_show_cmdlist;
1486 static struct cmd_list_element *tdesc_unset_cmdlist;
1487
1488 /* Helper functions for the CLI commands.  */
1489
1490 static void
1491 set_tdesc_cmd (char *args, int from_tty)
1492 {
1493   help_list (tdesc_set_cmdlist, "set tdesc ", -1, gdb_stdout);
1494 }
1495
1496 static void
1497 show_tdesc_cmd (char *args, int from_tty)
1498 {
1499   cmd_show_list (tdesc_show_cmdlist, from_tty, "");
1500 }
1501
1502 static void
1503 unset_tdesc_cmd (char *args, int from_tty)
1504 {
1505   help_list (tdesc_unset_cmdlist, "unset tdesc ", -1, gdb_stdout);
1506 }
1507
1508 static void
1509 set_tdesc_filename_cmd (char *args, int from_tty,
1510                         struct cmd_list_element *c)
1511 {
1512   target_clear_description ();
1513   target_find_description ();
1514 }
1515
1516 static void
1517 show_tdesc_filename_cmd (struct ui_file *file, int from_tty,
1518                          struct cmd_list_element *c,
1519                          const char *value)
1520 {
1521   if (value != NULL && *value != '\0')
1522     printf_filtered (_("\
1523 The target description will be read from \"%s\".\n"),
1524                      value);
1525   else
1526     printf_filtered (_("\
1527 The target description will be 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 ("  feature = tdesc_create_feature (result, \"%s\");\n",
1633                          feature->name);
1634
1635       for (ix2 = 0;
1636            VEC_iterate (tdesc_type_p, feature->types, ix2, type);
1637            ix2++)
1638         {
1639           switch (type->kind)
1640             {
1641             case TDESC_TYPE_VECTOR:
1642               printf_unfiltered
1643                 ("  field_type = tdesc_named_type (feature, \"%s\");\n",
1644                  type->u.v.type->name);
1645               printf_unfiltered
1646                 ("  tdesc_create_vector (feature, \"%s\", field_type, %d);\n",
1647                  type->name, type->u.v.count);
1648               break;
1649             case TDESC_TYPE_UNION:
1650               printf_unfiltered
1651                 ("  type = tdesc_create_union (feature, \"%s\");\n",
1652                  type->name);
1653               for (ix3 = 0;
1654                    VEC_iterate (tdesc_type_field, type->u.u.fields, ix3, f);
1655                    ix3++)
1656                 {
1657                   printf_unfiltered
1658                     ("  field_type = tdesc_named_type (feature, \"%s\");\n",
1659                      f->type->name);
1660                   printf_unfiltered
1661                     ("  tdesc_add_field (type, \"%s\", field_type);\n",
1662                      f->name);
1663                 }
1664               break;
1665             case TDESC_TYPE_FLAGS:
1666               printf_unfiltered
1667                 ("  field_type = tdesc_create_flags (feature, \"%s\", %d);\n",
1668                  type->name, (int) type->u.f.size);
1669               for (ix3 = 0;
1670                    VEC_iterate (tdesc_type_flag, type->u.f.flags, ix3,
1671                                 flag);
1672                    ix3++)
1673                 printf_unfiltered
1674                   ("  tdesc_add_flag (field_type, %d, \"%s\");\n",
1675                    flag->start, flag->name);
1676               break;
1677             default:
1678               error (_("C output is not supported type \"%s\"."), type->name);
1679             }
1680           printf_unfiltered ("\n");
1681         }
1682
1683       for (ix2 = 0;
1684            VEC_iterate (tdesc_reg_p, feature->registers, ix2, reg);
1685            ix2++)
1686         {
1687           printf_unfiltered ("  tdesc_create_reg (feature, \"%s\", %ld, %d, ",
1688                              reg->name, reg->target_regnum, reg->save_restore);
1689           if (reg->group)
1690             printf_unfiltered ("\"%s\", ", reg->group);
1691           else
1692             printf_unfiltered ("NULL, ");
1693           printf_unfiltered ("%d, \"%s\");\n", reg->bitsize, reg->type);
1694         }
1695
1696       printf_unfiltered ("\n");
1697     }
1698
1699   printf_unfiltered ("  tdesc_%s = result;\n", function);
1700   printf_unfiltered ("}\n");
1701 }
1702
1703 /* Provide a prototype to silence -Wmissing-prototypes.  */
1704 extern initialize_file_ftype _initialize_target_descriptions;
1705
1706 void
1707 _initialize_target_descriptions (void)
1708 {
1709   tdesc_data = gdbarch_data_register_pre_init (tdesc_data_init);
1710
1711   add_prefix_cmd ("tdesc", class_maintenance, set_tdesc_cmd, _("\
1712 Set target description specific variables."),
1713                   &tdesc_set_cmdlist, "set tdesc ",
1714                   0 /* allow-unknown */, &setlist);
1715   add_prefix_cmd ("tdesc", class_maintenance, show_tdesc_cmd, _("\
1716 Show target description specific variables."),
1717                   &tdesc_show_cmdlist, "show tdesc ",
1718                   0 /* allow-unknown */, &showlist);
1719   add_prefix_cmd ("tdesc", class_maintenance, unset_tdesc_cmd, _("\
1720 Unset target description specific variables."),
1721                   &tdesc_unset_cmdlist, "unset tdesc ",
1722                   0 /* allow-unknown */, &unsetlist);
1723
1724   add_setshow_filename_cmd ("filename", class_obscure,
1725                             &target_description_filename,
1726                             _("\
1727 Set the file to read for an XML target description"), _("\
1728 Show the file to read for an XML target description"), _("\
1729 When set, GDB will read the target description from a local\n\
1730 file instead of querying the remote target."),
1731                             set_tdesc_filename_cmd,
1732                             show_tdesc_filename_cmd,
1733                             &tdesc_set_cmdlist, &tdesc_show_cmdlist);
1734
1735   add_cmd ("filename", class_obscure, unset_tdesc_filename_cmd, _("\
1736 Unset the file to read for an XML target description.  When unset,\n\
1737 GDB will read the description from the target."),
1738            &tdesc_unset_cmdlist);
1739
1740   add_cmd ("c-tdesc", class_maintenance, maint_print_c_tdesc_cmd, _("\
1741 Print the current target description as a C source file."),
1742            &maintenanceprintlist);
1743 }