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