1/* Target description support for GDB. 2 3 Copyright (C) 2006, 2007 Free Software Foundation, Inc. 4 5 Contributed by CodeSourcery. 6 7 This file is part of GDB. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 21 22#include "defs.h" 23#include "arch-utils.h" 24#include "gdbcmd.h" 25#include "gdbtypes.h" 26#include "reggroups.h" 27#include "target.h" 28#include "target-descriptions.h" 29#include "vec.h" 30#include "xml-support.h" 31#include "xml-tdesc.h" 32 33#include "gdb_assert.h" 34#include "gdb_obstack.h" 35#include "hashtab.h" 36 37/* Types. */ 38 39typedef struct property 40{ 41 char *key; 42 char *value; 43} property_s; 44DEF_VEC_O(property_s); 45 46/* An individual register from a target description. */ 47 48typedef struct tdesc_reg 49{ 50 /* The name of this register. In standard features, it may be 51 recognized by the architecture support code, or it may be purely 52 for the user. */ 53 char *name; 54 55 /* The register number used by this target to refer to this 56 register. This is used for remote p/P packets and to determine 57 the ordering of registers in the remote g/G packets. */ 58 long target_regnum; 59 60 /* If this flag is set, GDB should save and restore this register 61 around calls to an inferior function. */ 62 int save_restore; 63 64 /* The name of the register group containing this register, or NULL 65 if the group should be automatically determined from the 66 register's type. If this is "general", "float", or "vector", the 67 corresponding "info" command should display this register's 68 value. It can be an arbitrary string, but should be limited to 69 alphanumeric characters and internal hyphens. Currently other 70 strings are ignored (treated as NULL). */ 71 char *group; 72 73 /* The size of the register, in bits. */ 74 int bitsize; 75 76 /* The type of the register. This string corresponds to either 77 a named type from the target description or a predefined 78 type from GDB. */ 79 char *type; 80 81 /* The target-described type corresponding to TYPE, if found. */ 82 struct type *gdb_type; 83} *tdesc_reg_p; 84DEF_VEC_P(tdesc_reg_p); 85 86/* A named type from a target description. */ 87typedef struct type *type_p; 88DEF_VEC_P(type_p); 89 90/* A feature from a target description. Each feature is a collection 91 of other elements, e.g. registers and types. */ 92 93typedef struct tdesc_feature 94{ 95 /* The name of this feature. It may be recognized by the architecture 96 support code. */ 97 char *name; 98 99 /* The registers associated with this feature. */ 100 VEC(tdesc_reg_p) *registers; 101 102 /* The types associated with this feature. */ 103 VEC(type_p) *types; 104} *tdesc_feature_p; 105DEF_VEC_P(tdesc_feature_p); 106 107/* A target description. */ 108 109struct target_desc 110{ 111 /* The architecture reported by the target, if any. */ 112 const struct bfd_arch_info *arch; 113 114 /* Any architecture-specific properties specified by the target. */ 115 VEC(property_s) *properties; 116 117 /* The features associated with this target. */ 118 VEC(tdesc_feature_p) *features; 119}; 120 121/* Per-architecture data associated with a target description. The 122 target description may be shared by multiple architectures, but 123 this data is private to one gdbarch. */ 124 125struct tdesc_arch_data 126{ 127 /* A list of registers, indexed by GDB's internal register number. 128 During initialization of the gdbarch this list is used to store 129 registers which the architecture assigns a fixed register number. 130 Registers which are NULL in this array, or off the end, are 131 treated as zero-sized and nameless (i.e. placeholders in the 132 numbering). */ 133 VEC(tdesc_reg_p) *registers; 134 135 /* Functions which report the register name, type, and reggroups for 136 pseudo-registers. */ 137 gdbarch_register_name_ftype *pseudo_register_name; 138 gdbarch_register_type_ftype *pseudo_register_type; 139 gdbarch_register_reggroup_p_ftype *pseudo_register_reggroup_p; 140}; 141 142/* Global state. These variables are associated with the current 143 target; if GDB adds support for multiple simultaneous targets, then 144 these variables should become target-specific data. */ 145 146/* A flag indicating that a description has already been fetched from 147 the current target, so it should not be queried again. */ 148 149static int target_desc_fetched; 150 151/* The description fetched from the current target, or NULL if the 152 current target did not supply any description. Only valid when 153 target_desc_fetched is set. Only the description initialization 154 code should access this; normally, the description should be 155 accessed through the gdbarch object. */ 156 157static const struct target_desc *current_target_desc; 158 159/* Other global variables. */ 160 161/* The filename to read a target description from. */ 162 163static char *target_description_filename; 164 165/* A handle for architecture-specific data associated with the 166 target description (see struct tdesc_arch_data). */ 167 168static struct gdbarch_data *tdesc_data; 169 170/* Fetch the current target's description, and switch the current 171 architecture to one which incorporates that description. */ 172 173void 174target_find_description (void) 175{ 176 /* If we've already fetched a description from the target, don't do 177 it again. This allows a target to fetch the description early, 178 during its to_open or to_create_inferior, if it needs extra 179 information about the target to initialize. */ 180 if (target_desc_fetched) 181 return; 182 183 /* The current architecture should not have any target description 184 specified. It should have been cleared, e.g. when we 185 disconnected from the previous target. */ 186 gdb_assert (gdbarch_target_desc (current_gdbarch) == NULL); 187 188 /* First try to fetch an XML description from the user-specified 189 file. */ 190 current_target_desc = NULL; 191 if (target_description_filename != NULL 192 && *target_description_filename != '\0') 193 current_target_desc 194 = file_read_description_xml (target_description_filename); 195 196 /* Next try to read the description from the current target using 197 target objects. */ 198 if (current_target_desc == NULL) 199 current_target_desc = target_read_description_xml (¤t_target); 200 201 /* If that failed try a target-specific hook. */ 202 if (current_target_desc == NULL) 203 current_target_desc = target_read_description (¤t_target); 204 205 /* If a non-NULL description was returned, then update the current 206 architecture. */ 207 if (current_target_desc) 208 { 209 struct gdbarch_info info; 210 211 gdbarch_info_init (&info); 212 info.target_desc = current_target_desc; 213 if (!gdbarch_update_p (info)) 214 warning (_("Architecture rejected target-supplied description")); 215 else 216 { 217 struct tdesc_arch_data *data; 218 219 data = gdbarch_data (current_gdbarch, tdesc_data); 220 if (tdesc_has_registers (current_target_desc) 221 && data->registers == NULL) 222 warning (_("Target-supplied registers are not supported " 223 "by the current architecture")); 224 } 225 } 226 227 /* Now that we know this description is usable, record that we 228 fetched it. */ 229 target_desc_fetched = 1; 230} 231 232/* Discard any description fetched from the current target, and switch 233 the current architecture to one with no target description. */ 234 235void 236target_clear_description (void) 237{ 238 struct gdbarch_info info; 239 240 if (!target_desc_fetched) 241 return; 242 243 target_desc_fetched = 0; 244 current_target_desc = NULL; 245 246 gdbarch_info_init (&info); 247 if (!gdbarch_update_p (info)) 248 internal_error (__FILE__, __LINE__, 249 _("Could not remove target-supplied description")); 250} 251 252/* Return the global current target description. This should only be 253 used by gdbarch initialization code; most access should be through 254 an existing gdbarch. */ 255 256const struct target_desc * 257target_current_description (void) 258{ 259 if (target_desc_fetched) 260 return current_target_desc; 261 262 return NULL; 263} 264 265 266/* Direct accessors for target descriptions. */ 267 268/* Return the string value of a property named KEY, or NULL if the 269 property was not specified. */ 270 271const char * 272tdesc_property (const struct target_desc *target_desc, const char *key) 273{ 274 struct property *prop; 275 int ix; 276 277 for (ix = 0; VEC_iterate (property_s, target_desc->properties, ix, prop); 278 ix++) 279 if (strcmp (prop->key, key) == 0) 280 return prop->value; 281 282 return NULL; 283} 284 285/* Return the BFD architecture associated with this target 286 description, or NULL if no architecture was specified. */ 287 288const struct bfd_arch_info * 289tdesc_architecture (const struct target_desc *target_desc) 290{ 291 return target_desc->arch; 292} 293 294 295/* Return 1 if this target description includes any registers. */ 296 297int 298tdesc_has_registers (const struct target_desc *target_desc) 299{ 300 int ix; 301 struct tdesc_feature *feature; 302 303 if (target_desc == NULL) 304 return 0; 305 306 for (ix = 0; 307 VEC_iterate (tdesc_feature_p, target_desc->features, ix, feature); 308 ix++) 309 if (! VEC_empty (tdesc_reg_p, feature->registers)) 310 return 1; 311 312 return 0; 313} 314 315/* Return the feature with the given name, if present, or NULL if 316 the named feature is not found. */ 317 318const struct tdesc_feature * 319tdesc_find_feature (const struct target_desc *target_desc, 320 const char *name) 321{ 322 int ix; 323 struct tdesc_feature *feature; 324 325 for (ix = 0; 326 VEC_iterate (tdesc_feature_p, target_desc->features, ix, feature); 327 ix++) 328 if (strcmp (feature->name, name) == 0) 329 return feature; 330 331 return NULL; 332} 333 334/* Return the name of FEATURE. */ 335 336const char * 337tdesc_feature_name (const struct tdesc_feature *feature) 338{ 339 return feature->name; 340} 341 342/* Return the type associated with ID in the context of FEATURE, or 343 NULL if none. */ 344 345struct type * 346tdesc_named_type (const struct tdesc_feature *feature, const char *id) 347{ 348 int ix; 349 struct type *gdb_type; 350 351 /* First try target-defined types. */ 352 for (ix = 0; VEC_iterate (type_p, feature->types, ix, gdb_type); ix++) 353 if (strcmp (TYPE_NAME (gdb_type), id) == 0) 354 return gdb_type; 355 356 /* Next try some predefined types. Note that none of these types 357 depend on the current architecture; some of the builtin_type_foo 358 variables are swapped based on the architecture. */ 359 if (strcmp (id, "int8") == 0) 360 return builtin_type_int8; 361 362 if (strcmp (id, "int16") == 0) 363 return builtin_type_int16; 364 365 if (strcmp (id, "int32") == 0) 366 return builtin_type_int32; 367 368 if (strcmp (id, "int64") == 0) 369 return builtin_type_int64; 370 371 if (strcmp (id, "uint8") == 0) 372 return builtin_type_uint8; 373 374 if (strcmp (id, "uint16") == 0) 375 return builtin_type_uint16; 376 377 if (strcmp (id, "uint32") == 0) 378 return builtin_type_uint32; 379 380 if (strcmp (id, "uint64") == 0) 381 return builtin_type_uint64; 382 383 if (strcmp (id, "ieee_single") == 0) 384 return builtin_type_ieee_single; 385 386 if (strcmp (id, "ieee_double") == 0) 387 return builtin_type_ieee_double; 388 389 if (strcmp (id, "arm_fpa_ext") == 0) 390 return builtin_type_arm_ext; 391 392 return NULL; 393} 394 395 396/* Support for registers from target descriptions. */ 397 398/* Construct the per-gdbarch data. */ 399 400static void * 401tdesc_data_init (struct obstack *obstack) 402{ 403 struct tdesc_arch_data *data; 404 405 data = OBSTACK_ZALLOC (obstack, struct tdesc_arch_data); 406 return data; 407} 408 409/* Similar, but for the temporary copy used during architecture 410 initialization. */ 411 412struct tdesc_arch_data * 413tdesc_data_alloc (void) 414{ 415 return XZALLOC (struct tdesc_arch_data); 416} 417 418/* Free something allocated by tdesc_data_alloc, if it is not going 419 to be used (for instance if it was unsuitable for the 420 architecture). */ 421 422void 423tdesc_data_cleanup (void *data_untyped) 424{ 425 struct tdesc_arch_data *data = data_untyped; 426 427 VEC_free (tdesc_reg_p, data->registers); 428 xfree (data); 429} 430 431/* Search FEATURE for a register named NAME. */ 432 433int 434tdesc_numbered_register (const struct tdesc_feature *feature, 435 struct tdesc_arch_data *data, 436 int regno, const char *name) 437{ 438 int ixr; 439 struct tdesc_reg *reg; 440 441 for (ixr = 0; 442 VEC_iterate (tdesc_reg_p, feature->registers, ixr, reg); 443 ixr++) 444 if (strcasecmp (reg->name, name) == 0) 445 { 446 /* Make sure the vector includes a REGNO'th element. */ 447 while (regno >= VEC_length (tdesc_reg_p, data->registers)) 448 VEC_safe_push (tdesc_reg_p, data->registers, NULL); 449 VEC_replace (tdesc_reg_p, data->registers, regno, reg); 450 return 1; 451 } 452 453 return 0; 454} 455 456/* Search FEATURE for a register whose name is in NAMES. */ 457 458int 459tdesc_numbered_register_choices (const struct tdesc_feature *feature, 460 struct tdesc_arch_data *data, 461 int regno, const char *const names[]) 462{ 463 int i; 464 465 for (i = 0; names[i] != NULL; i++) 466 if (tdesc_numbered_register (feature, data, regno, names[i])) 467 return 1; 468 469 return 0; 470} 471 472/* Look up a register by its GDB internal register number. */ 473 474static struct tdesc_reg * 475tdesc_find_register (struct gdbarch *gdbarch, int regno) 476{ 477 struct tdesc_reg *reg; 478 struct tdesc_arch_data *data; 479 480 data = gdbarch_data (gdbarch, tdesc_data); 481 if (regno < VEC_length (tdesc_reg_p, data->registers)) 482 return VEC_index (tdesc_reg_p, data->registers, regno); 483 else 484 return NULL; 485} 486 487/* Return the name of register REGNO, from the target description or 488 from an architecture-provided pseudo_register_name method. */ 489 490const char * 491tdesc_register_name (int regno) 492{ 493 struct tdesc_reg *reg = tdesc_find_register (current_gdbarch, regno); 494 int num_regs = gdbarch_num_regs (current_gdbarch); 495 int num_pseudo_regs = gdbarch_num_pseudo_regs (current_gdbarch); 496 497 if (reg != NULL) 498 return reg->name; 499 500 if (regno >= num_regs && regno < num_regs + num_pseudo_regs) 501 { 502 struct tdesc_arch_data *data = gdbarch_data (current_gdbarch, 503 tdesc_data); 504 gdb_assert (data->pseudo_register_name != NULL); 505 return data->pseudo_register_name (regno); 506 } 507 508 return ""; 509} 510 511static struct type * 512tdesc_register_type (struct gdbarch *gdbarch, int regno) 513{ 514 struct tdesc_reg *reg = tdesc_find_register (gdbarch, regno); 515 int num_regs = gdbarch_num_regs (gdbarch); 516 int num_pseudo_regs = gdbarch_num_pseudo_regs (gdbarch); 517 518 if (reg == NULL && regno >= num_regs && regno < num_regs + num_pseudo_regs) 519 { 520 struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data); 521 gdb_assert (data->pseudo_register_type != NULL); 522 return data->pseudo_register_type (gdbarch, regno); 523 } 524 525 if (reg == NULL) 526 /* Return "int0_t", since "void" has a misleading size of one. */ 527 return builtin_type_int0; 528 529 /* First check for a predefined or target defined type. */ 530 if (reg->gdb_type) 531 return reg->gdb_type; 532 533 /* Next try size-sensitive type shortcuts. */ 534 if (strcmp (reg->type, "float") == 0) 535 { 536 if (reg->bitsize == gdbarch_float_bit (gdbarch)) 537 return builtin_type_float; 538 else if (reg->bitsize == gdbarch_double_bit (gdbarch)) 539 return builtin_type_double; 540 else if (reg->bitsize == gdbarch_long_double_bit (gdbarch)) 541 return builtin_type_long_double; 542 } 543 else if (strcmp (reg->type, "int") == 0) 544 { 545 if (reg->bitsize == gdbarch_long_bit (gdbarch)) 546 return builtin_type_long; 547 else if (reg->bitsize == TARGET_CHAR_BIT) 548 return builtin_type_char; 549 else if (reg->bitsize == gdbarch_short_bit (gdbarch)) 550 return builtin_type_short; 551 else if (reg->bitsize == gdbarch_int_bit (gdbarch)) 552 return builtin_type_int; 553 else if (reg->bitsize == gdbarch_long_long_bit (gdbarch)) 554 return builtin_type_long_long; 555 else if (reg->bitsize == gdbarch_ptr_bit (gdbarch)) 556 /* A bit desperate by this point... */ 557 return builtin_type_void_data_ptr; 558 } 559 else if (strcmp (reg->type, "code_ptr") == 0) 560 return builtin_type_void_func_ptr; 561 else if (strcmp (reg->type, "data_ptr") == 0) 562 return builtin_type_void_data_ptr; 563 else 564 internal_error (__FILE__, __LINE__, 565 "Register \"%s\" has an unknown type \"%s\"", 566 reg->name, reg->type); 567 568 warning (_("Register \"%s\" has an unsupported size (%d bits)"), 569 reg->name, reg->bitsize); 570 return builtin_type_long; 571} 572 573static int 574tdesc_remote_register_number (struct gdbarch *gdbarch, int regno) 575{ 576 struct tdesc_reg *reg = tdesc_find_register (gdbarch, regno); 577 578 if (reg != NULL) 579 return reg->target_regnum; 580 else 581 return -1; 582} 583 584/* Check whether REGNUM is a member of REGGROUP. Registers from the 585 target description may be classified as general, float, or vector. 586 Unlike a gdbarch register_reggroup_p method, this function will 587 return -1 if it does not know; the caller should handle registers 588 with no specified group. 589 590 Arbitrary strings (other than "general", "float", and "vector") 591 from the description are not used; they cause the register to be 592 displayed in "info all-registers" but excluded from "info 593 registers" et al. The names of containing features are also not 594 used. This might be extended to display registers in some more 595 useful groupings. 596 597 The save-restore flag is also implemented here. */ 598 599int 600tdesc_register_in_reggroup_p (struct gdbarch *gdbarch, int regno, 601 struct reggroup *reggroup) 602{ 603 struct tdesc_reg *reg = tdesc_find_register (gdbarch, regno); 604 605 if (reg != NULL && reg->group != NULL) 606 { 607 int general_p = 0, float_p = 0, vector_p = 0; 608 609 if (strcmp (reg->group, "general") == 0) 610 general_p = 1; 611 else if (strcmp (reg->group, "float") == 0) 612 float_p = 1; 613 else if (strcmp (reg->group, "vector") == 0) 614 vector_p = 1; 615 616 if (reggroup == float_reggroup) 617 return float_p; 618 619 if (reggroup == vector_reggroup) 620 return vector_p; 621 622 if (reggroup == general_reggroup) 623 return general_p; 624 } 625 626 if (reg != NULL 627 && (reggroup == save_reggroup || reggroup == restore_reggroup)) 628 return reg->save_restore; 629 630 return -1; 631} 632 633/* Check whether REGNUM is a member of REGGROUP. Registers with no 634 group specified go to the default reggroup function and are handled 635 by type. */ 636 637static int 638tdesc_register_reggroup_p (struct gdbarch *gdbarch, int regno, 639 struct reggroup *reggroup) 640{ 641 int num_regs = gdbarch_num_regs (gdbarch); 642 int num_pseudo_regs = gdbarch_num_pseudo_regs (gdbarch); 643 int ret; 644 645 if (regno >= num_regs && regno < num_regs + num_pseudo_regs) 646 { 647 struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data); 648 gdb_assert (data->pseudo_register_reggroup_p != NULL); 649 return data->pseudo_register_reggroup_p (gdbarch, regno, reggroup); 650 } 651 652 ret = tdesc_register_in_reggroup_p (gdbarch, regno, reggroup); 653 if (ret != -1) 654 return ret; 655 656 return default_register_reggroup_p (gdbarch, regno, reggroup); 657} 658 659/* Record architecture-specific functions to call for pseudo-register 660 support. */ 661 662void 663set_tdesc_pseudo_register_name (struct gdbarch *gdbarch, 664 gdbarch_register_name_ftype *pseudo_name) 665{ 666 struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data); 667 668 data->pseudo_register_name = pseudo_name; 669} 670 671void 672set_tdesc_pseudo_register_type (struct gdbarch *gdbarch, 673 gdbarch_register_type_ftype *pseudo_type) 674{ 675 struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data); 676 677 data->pseudo_register_type = pseudo_type; 678} 679 680void 681set_tdesc_pseudo_register_reggroup_p 682 (struct gdbarch *gdbarch, 683 gdbarch_register_reggroup_p_ftype *pseudo_reggroup_p) 684{ 685 struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data); 686 687 data->pseudo_register_reggroup_p = pseudo_reggroup_p; 688} 689 690/* Update GDBARCH to use the target description for registers. */ 691 692void 693tdesc_use_registers (struct gdbarch *gdbarch, 694 struct tdesc_arch_data *early_data) 695{ 696 int num_regs = gdbarch_num_regs (gdbarch); 697 int i, ixf, ixr; 698 const struct target_desc *target_desc; 699 struct tdesc_feature *feature; 700 struct tdesc_reg *reg; 701 struct tdesc_arch_data *data; 702 htab_t reg_hash; 703 704 target_desc = gdbarch_target_desc (gdbarch); 705 706 /* We can't use the description for registers if it doesn't describe 707 any. This function should only be called after validating 708 registers, so the caller should know that registers are 709 included. */ 710 gdb_assert (tdesc_has_registers (target_desc)); 711 712 data = gdbarch_data (gdbarch, tdesc_data); 713 data->registers = early_data->registers; 714 xfree (early_data); 715 716 /* Build up a set of all registers, so that we can assign register 717 numbers where needed. The hash table expands as necessary, so 718 the initial size is arbitrary. */ 719 reg_hash = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL); 720 for (ixf = 0; 721 VEC_iterate (tdesc_feature_p, target_desc->features, ixf, feature); 722 ixf++) 723 for (ixr = 0; 724 VEC_iterate (tdesc_reg_p, feature->registers, ixr, reg); 725 ixr++) 726 { 727 void **slot = htab_find_slot (reg_hash, reg, INSERT); 728 729 *slot = reg; 730 } 731 732 /* Remove any registers which were assigned numbers by the 733 architecture. */ 734 for (ixr = 0; VEC_iterate (tdesc_reg_p, data->registers, ixr, reg); ixr++) 735 if (reg) 736 htab_remove_elt (reg_hash, reg); 737 738 /* Assign numbers to the remaining registers and add them to the 739 list of registers. The new numbers are always above gdbarch_num_regs. 740 Iterate over the features, not the hash table, so that the order 741 matches that in the target description. */ 742 743 gdb_assert (VEC_length (tdesc_reg_p, data->registers) <= num_regs); 744 while (VEC_length (tdesc_reg_p, data->registers) < num_regs) 745 VEC_safe_push (tdesc_reg_p, data->registers, NULL); 746 for (ixf = 0; 747 VEC_iterate (tdesc_feature_p, target_desc->features, ixf, feature); 748 ixf++) 749 for (ixr = 0; 750 VEC_iterate (tdesc_reg_p, feature->registers, ixr, reg); 751 ixr++) 752 if (htab_find (reg_hash, reg) != NULL) 753 { 754 VEC_safe_push (tdesc_reg_p, data->registers, reg); 755 num_regs++; 756 } 757 758 htab_delete (reg_hash); 759 760 /* Update the architecture. */ 761 set_gdbarch_num_regs (gdbarch, num_regs); 762 set_gdbarch_register_name (gdbarch, tdesc_register_name); 763 set_gdbarch_register_type (gdbarch, tdesc_register_type); 764 set_gdbarch_remote_register_number (gdbarch, 765 tdesc_remote_register_number); 766 set_gdbarch_register_reggroup_p (gdbarch, tdesc_register_reggroup_p); 767} 768 769 770/* Methods for constructing a target description. */ 771 772static void 773tdesc_free_reg (struct tdesc_reg *reg) 774{ 775 xfree (reg->name); 776 xfree (reg->type); 777 xfree (reg->group); 778 xfree (reg); 779} 780 781void 782tdesc_create_reg (struct tdesc_feature *feature, const char *name, 783 int regnum, int save_restore, const char *group, 784 int bitsize, const char *type) 785{ 786 struct tdesc_reg *reg = XZALLOC (struct tdesc_reg); 787 788 reg->name = xstrdup (name); 789 reg->target_regnum = regnum; 790 reg->save_restore = save_restore; 791 reg->group = group ? xstrdup (group) : NULL; 792 reg->bitsize = bitsize; 793 reg->type = type ? xstrdup (type) : xstrdup ("<unknown>"); 794 795 /* If the register's type is target-defined, look it up now. We may not 796 have easy access to the containing feature when we want it later. */ 797 reg->gdb_type = tdesc_named_type (feature, reg->type); 798 799 VEC_safe_push (tdesc_reg_p, feature->registers, reg); 800} 801 802static void 803tdesc_free_feature (struct tdesc_feature *feature) 804{ 805 struct tdesc_reg *reg; 806 int ix; 807 808 for (ix = 0; VEC_iterate (tdesc_reg_p, feature->registers, ix, reg); ix++) 809 tdesc_free_reg (reg); 810 VEC_free (tdesc_reg_p, feature->registers); 811 812 /* There is no easy way to free xmalloc-allocated types, nor is 813 there a way to allocate types on an obstack not associated with 814 an objfile. Therefore we never free types. Since we only ever 815 parse an identical XML document once, this memory leak is mostly 816 contained. */ 817 VEC_free (type_p, feature->types); 818 819 xfree (feature->name); 820 xfree (feature); 821} 822 823struct tdesc_feature * 824tdesc_create_feature (struct target_desc *tdesc, const char *name) 825{ 826 struct tdesc_feature *new_feature = XZALLOC (struct tdesc_feature); 827 828 new_feature->name = xstrdup (name); 829 830 VEC_safe_push (tdesc_feature_p, tdesc->features, new_feature); 831 return new_feature; 832} 833 834void 835tdesc_record_type (struct tdesc_feature *feature, struct type *type) 836{ 837 /* The type's ID should be used as its TYPE_NAME. */ 838 gdb_assert (TYPE_NAME (type) != NULL); 839 840 VEC_safe_push (type_p, feature->types, type); 841} 842 843struct target_desc * 844allocate_target_description (void) 845{ 846 return XZALLOC (struct target_desc); 847} 848 849static void 850free_target_description (void *arg) 851{ 852 struct target_desc *target_desc = arg; 853 struct tdesc_feature *feature; 854 struct property *prop; 855 int ix; 856 857 for (ix = 0; 858 VEC_iterate (tdesc_feature_p, target_desc->features, ix, feature); 859 ix++) 860 tdesc_free_feature (feature); 861 VEC_free (tdesc_feature_p, target_desc->features); 862 863 for (ix = 0; 864 VEC_iterate (property_s, target_desc->properties, ix, prop); 865 ix++) 866 { 867 xfree (prop->key); 868 xfree (prop->value); 869 } 870 VEC_free (property_s, target_desc->properties); 871 872 xfree (target_desc); 873} 874 875struct cleanup * 876make_cleanup_free_target_description (struct target_desc *target_desc) 877{ 878 return make_cleanup (free_target_description, target_desc); 879} 880 881void 882set_tdesc_property (struct target_desc *target_desc, 883 const char *key, const char *value) 884{ 885 struct property *prop, new_prop; 886 int ix; 887 888 gdb_assert (key != NULL && value != NULL); 889 890 for (ix = 0; VEC_iterate (property_s, target_desc->properties, ix, prop); 891 ix++) 892 if (strcmp (prop->key, key) == 0) 893 internal_error (__FILE__, __LINE__, 894 _("Attempted to add duplicate property \"%s\""), key); 895 896 new_prop.key = xstrdup (key); 897 new_prop.value = xstrdup (value); 898 VEC_safe_push (property_s, target_desc->properties, &new_prop); 899} 900 901void 902set_tdesc_architecture (struct target_desc *target_desc, 903 const struct bfd_arch_info *arch) 904{ 905 target_desc->arch = arch; 906} 907 908 909static struct cmd_list_element *tdesc_set_cmdlist, *tdesc_show_cmdlist; 910static struct cmd_list_element *tdesc_unset_cmdlist; 911 912/* Helper functions for the CLI commands. */ 913 914static void 915set_tdesc_cmd (char *args, int from_tty) 916{ 917 help_list (tdesc_set_cmdlist, "set tdesc ", -1, gdb_stdout); 918} 919 920static void 921show_tdesc_cmd (char *args, int from_tty) 922{ 923 cmd_show_list (tdesc_show_cmdlist, from_tty, ""); 924} 925 926static void 927unset_tdesc_cmd (char *args, int from_tty) 928{ 929 help_list (tdesc_unset_cmdlist, "unset tdesc ", -1, gdb_stdout); 930} 931 932static void 933set_tdesc_filename_cmd (char *args, int from_tty, 934 struct cmd_list_element *c) 935{ 936 target_clear_description (); 937 target_find_description (); 938} 939 940static void 941show_tdesc_filename_cmd (struct ui_file *file, int from_tty, 942 struct cmd_list_element *c, 943 const char *value) 944{ 945 if (value != NULL && *value != '\0') 946 printf_filtered (_("\ 947The target description will be read from \"%s\".\n"), 948 value); 949 else 950 printf_filtered (_("\ 951The target description will be read from the target.\n")); 952} 953 954static void 955unset_tdesc_filename_cmd (char *args, int from_tty) 956{ 957 xfree (target_description_filename); 958 target_description_filename = NULL; 959 target_clear_description (); 960 target_find_description (); 961} 962 963void 964_initialize_target_descriptions (void) 965{ 966 tdesc_data = gdbarch_data_register_pre_init (tdesc_data_init); 967 968 add_prefix_cmd ("tdesc", class_maintenance, set_tdesc_cmd, _("\ 969Set target description specific variables."), 970 &tdesc_set_cmdlist, "set tdesc ", 971 0 /* allow-unknown */, &setlist); 972 add_prefix_cmd ("tdesc", class_maintenance, show_tdesc_cmd, _("\ 973Show target description specific variables."), 974 &tdesc_show_cmdlist, "show tdesc ", 975 0 /* allow-unknown */, &showlist); 976 add_prefix_cmd ("tdesc", class_maintenance, unset_tdesc_cmd, _("\ 977Unset target description specific variables."), 978 &tdesc_unset_cmdlist, "unset tdesc ", 979 0 /* allow-unknown */, &unsetlist); 980 981 add_setshow_filename_cmd ("filename", class_obscure, 982 &target_description_filename, 983 _("\ 984Set the file to read for an XML target description"), _("\ 985Show the file to read for an XML target description"), _("\ 986When set, GDB will read the target description from a local\n\ 987file instead of querying the remote target."), 988 set_tdesc_filename_cmd, 989 show_tdesc_filename_cmd, 990 &tdesc_set_cmdlist, &tdesc_show_cmdlist); 991 992 add_cmd ("filename", class_obscure, unset_tdesc_filename_cmd, _("\ 993Unset the file to read for an XML target description. When unset,\n\ 994GDB will read the description from the target."), 995 &tdesc_unset_cmdlist); 996} 997