1 /* Target description support for GDB.
3 Copyright (C) 2006, 2007 Free Software Foundation, Inc.
5 Contributed by CodeSourcery.
7 This file is part of GDB.
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.
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.
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/>. */
23 #include "arch-utils.h"
26 #include "reggroups.h"
28 #include "target-descriptions.h"
30 #include "xml-support.h"
31 #include "xml-tdesc.h"
33 #include "gdb_assert.h"
34 #include "gdb_obstack.h"
39 typedef struct property
44 DEF_VEC_O(property_s
);
46 /* An individual register from a target description. */
48 typedef struct tdesc_reg
50 /* The name of this register. In standard features, it may be
51 recognized by the architecture support code, or it may be purely
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. */
60 /* If this flag is set, GDB should save and restore this register
61 around calls to an inferior function. */
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). */
73 /* The size of the register, in bits. */
76 /* The type of the register. This string corresponds to either
77 a named type from the target description or a predefined
81 /* The target-described type corresponding to TYPE, if found. */
82 struct type
*gdb_type
;
84 DEF_VEC_P(tdesc_reg_p
);
86 /* A named type from a target description. */
87 typedef struct type
*type_p
;
90 /* A feature from a target description. Each feature is a collection
91 of other elements, e.g. registers and types. */
93 typedef struct tdesc_feature
95 /* The name of this feature. It may be recognized by the architecture
99 /* The registers associated with this feature. */
100 VEC(tdesc_reg_p
) *registers
;
102 /* The types associated with this feature. */
105 DEF_VEC_P(tdesc_feature_p
);
107 /* A target description. */
111 /* The architecture reported by the target, if any. */
112 const struct bfd_arch_info
*arch
;
114 /* Any architecture-specific properties specified by the target. */
115 VEC(property_s
) *properties
;
117 /* The features associated with this target. */
118 VEC(tdesc_feature_p
) *features
;
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. */
125 struct tdesc_arch_data
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
133 VEC(tdesc_reg_p
) *registers
;
135 /* Functions which report the register name, type, and reggroups for
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
;
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. */
146 /* A flag indicating that a description has already been fetched from
147 the current target, so it should not be queried again. */
149 static int target_desc_fetched
;
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. */
157 static const struct target_desc
*current_target_desc
;
159 /* Other global variables. */
161 /* The filename to read a target description from. */
163 static char *target_description_filename
;
165 /* A handle for architecture-specific data associated with the
166 target description (see struct tdesc_arch_data). */
168 static struct gdbarch_data
*tdesc_data
;
170 /* Fetch the current target's description, and switch the current
171 architecture to one which incorporates that description. */
174 target_find_description (void)
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
)
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
);
188 /* First try to fetch an XML description from the user-specified
190 current_target_desc
= NULL
;
191 if (target_description_filename
!= NULL
192 && *target_description_filename
!= '\0')
194 = file_read_description_xml (target_description_filename
);
196 /* Next try to read the description from the current target using
198 if (current_target_desc
== NULL
)
199 current_target_desc
= target_read_description_xml (¤t_target
);
201 /* If that failed try a target-specific hook. */
202 if (current_target_desc
== NULL
)
203 current_target_desc
= target_read_description (¤t_target
);
205 /* If a non-NULL description was returned, then update the current
207 if (current_target_desc
)
209 struct gdbarch_info info
;
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"));
217 struct tdesc_arch_data
*data
;
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"));
227 /* Now that we know this description is usable, record that we
229 target_desc_fetched
= 1;
232 /* Discard any description fetched from the current target, and switch
233 the current architecture to one with no target description. */
236 target_clear_description (void)
238 struct gdbarch_info info
;
240 if (!target_desc_fetched
)
243 target_desc_fetched
= 0;
244 current_target_desc
= NULL
;
246 gdbarch_info_init (&info
);
247 if (!gdbarch_update_p (info
))
248 internal_error (__FILE__
, __LINE__
,
249 _("Could not remove target-supplied description"));
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. */
256 const struct target_desc
*
257 target_current_description (void)
259 if (target_desc_fetched
)
260 return current_target_desc
;
266 /* Direct accessors for target descriptions. */
268 /* Return the string value of a property named KEY, or NULL if the
269 property was not specified. */
272 tdesc_property (const struct target_desc
*target_desc
, const char *key
)
274 struct property
*prop
;
277 for (ix
= 0; VEC_iterate (property_s
, target_desc
->properties
, ix
, prop
);
279 if (strcmp (prop
->key
, key
) == 0)
285 /* Return the BFD architecture associated with this target
286 description, or NULL if no architecture was specified. */
288 const struct bfd_arch_info
*
289 tdesc_architecture (const struct target_desc
*target_desc
)
291 return target_desc
->arch
;
295 /* Return 1 if this target description includes any registers. */
298 tdesc_has_registers (const struct target_desc
*target_desc
)
301 struct tdesc_feature
*feature
;
303 if (target_desc
== NULL
)
307 VEC_iterate (tdesc_feature_p
, target_desc
->features
, ix
, feature
);
309 if (! VEC_empty (tdesc_reg_p
, feature
->registers
))
315 /* Return the feature with the given name, if present, or NULL if
316 the named feature is not found. */
318 const struct tdesc_feature
*
319 tdesc_find_feature (const struct target_desc
*target_desc
,
323 struct tdesc_feature
*feature
;
326 VEC_iterate (tdesc_feature_p
, target_desc
->features
, ix
, feature
);
328 if (strcmp (feature
->name
, name
) == 0)
334 /* Return the name of FEATURE. */
337 tdesc_feature_name (const struct tdesc_feature
*feature
)
339 return feature
->name
;
342 /* Predefined types. Note that none of these types depend on the
343 current architecture; some of the builtin_type_foo variables are
344 swapped based on the architecture. */
349 } tdesc_predefined_types
[] =
351 { "int8", &builtin_type_int8
},
352 { "int16", &builtin_type_int16
},
353 { "int32", &builtin_type_int32
},
354 { "int64", &builtin_type_int64
},
355 { "int128", &builtin_type_int128
},
356 { "uint8", &builtin_type_uint8
},
357 { "uint16", &builtin_type_uint16
},
358 { "uint32", &builtin_type_uint32
},
359 { "uint64", &builtin_type_uint64
},
360 { "uint128", &builtin_type_uint128
},
361 { "ieee_single", &builtin_type_ieee_single
},
362 { "ieee_double", &builtin_type_ieee_double
},
363 { "arm_fpa_ext", &builtin_type_arm_ext
}
366 /* Return the type associated with ID in the context of FEATURE, or
370 tdesc_named_type (const struct tdesc_feature
*feature
, const char *id
)
373 struct type
*gdb_type
;
375 /* First try target-defined types. */
376 for (ix
= 0; VEC_iterate (type_p
, feature
->types
, ix
, gdb_type
); ix
++)
377 if (strcmp (TYPE_NAME (gdb_type
), id
) == 0)
380 /* Next try the predefined types. */
381 for (ix
= 0; ix
< ARRAY_SIZE (tdesc_predefined_types
); ix
++)
382 if (strcmp (tdesc_predefined_types
[ix
].name
, id
) == 0)
383 return *tdesc_predefined_types
[ix
].type
;
389 /* Support for registers from target descriptions. */
391 /* Construct the per-gdbarch data. */
394 tdesc_data_init (struct obstack
*obstack
)
396 struct tdesc_arch_data
*data
;
398 data
= OBSTACK_ZALLOC (obstack
, struct tdesc_arch_data
);
402 /* Similar, but for the temporary copy used during architecture
405 struct tdesc_arch_data
*
406 tdesc_data_alloc (void)
408 return XZALLOC (struct tdesc_arch_data
);
411 /* Free something allocated by tdesc_data_alloc, if it is not going
412 to be used (for instance if it was unsuitable for the
416 tdesc_data_cleanup (void *data_untyped
)
418 struct tdesc_arch_data
*data
= data_untyped
;
420 VEC_free (tdesc_reg_p
, data
->registers
);
424 /* Search FEATURE for a register named NAME. */
426 static struct tdesc_reg
*
427 tdesc_find_register_early (const struct tdesc_feature
*feature
,
431 struct tdesc_reg
*reg
;
434 VEC_iterate (tdesc_reg_p
, feature
->registers
, ixr
, reg
);
436 if (strcasecmp (reg
->name
, name
) == 0)
442 /* Search FEATURE for a register named NAME. Assign REGNO to it. */
445 tdesc_numbered_register (const struct tdesc_feature
*feature
,
446 struct tdesc_arch_data
*data
,
447 int regno
, const char *name
)
449 struct tdesc_reg
*reg
= tdesc_find_register_early (feature
, name
);
454 /* Make sure the vector includes a REGNO'th element. */
455 while (regno
>= VEC_length (tdesc_reg_p
, data
->registers
))
456 VEC_safe_push (tdesc_reg_p
, data
->registers
, NULL
);
457 VEC_replace (tdesc_reg_p
, data
->registers
, regno
, reg
);
461 /* Search FEATURE for a register whose name is in NAMES and assign
465 tdesc_numbered_register_choices (const struct tdesc_feature
*feature
,
466 struct tdesc_arch_data
*data
,
467 int regno
, const char *const names
[])
471 for (i
= 0; names
[i
] != NULL
; i
++)
472 if (tdesc_numbered_register (feature
, data
, regno
, names
[i
]))
478 /* Search FEATURE for a register named NAME, and return its size in
479 bits. The register must exist. */
482 tdesc_register_size (const struct tdesc_feature
*feature
,
485 struct tdesc_reg
*reg
= tdesc_find_register_early (feature
, name
);
487 gdb_assert (reg
!= NULL
);
491 /* Look up a register by its GDB internal register number. */
493 static struct tdesc_reg
*
494 tdesc_find_register (struct gdbarch
*gdbarch
, int regno
)
496 struct tdesc_reg
*reg
;
497 struct tdesc_arch_data
*data
;
499 data
= gdbarch_data (gdbarch
, tdesc_data
);
500 if (regno
< VEC_length (tdesc_reg_p
, data
->registers
))
501 return VEC_index (tdesc_reg_p
, data
->registers
, regno
);
506 /* Return the name of register REGNO, from the target description or
507 from an architecture-provided pseudo_register_name method. */
510 tdesc_register_name (int regno
)
512 struct tdesc_reg
*reg
= tdesc_find_register (current_gdbarch
, regno
);
513 int num_regs
= gdbarch_num_regs (current_gdbarch
);
514 int num_pseudo_regs
= gdbarch_num_pseudo_regs (current_gdbarch
);
519 if (regno
>= num_regs
&& regno
< num_regs
+ num_pseudo_regs
)
521 struct tdesc_arch_data
*data
= gdbarch_data (current_gdbarch
,
523 gdb_assert (data
->pseudo_register_name
!= NULL
);
524 return data
->pseudo_register_name (regno
);
531 tdesc_register_type (struct gdbarch
*gdbarch
, int regno
)
533 struct tdesc_reg
*reg
= tdesc_find_register (gdbarch
, regno
);
534 int num_regs
= gdbarch_num_regs (gdbarch
);
535 int num_pseudo_regs
= gdbarch_num_pseudo_regs (gdbarch
);
537 if (reg
== NULL
&& regno
>= num_regs
&& regno
< num_regs
+ num_pseudo_regs
)
539 struct tdesc_arch_data
*data
= gdbarch_data (gdbarch
, tdesc_data
);
540 gdb_assert (data
->pseudo_register_type
!= NULL
);
541 return data
->pseudo_register_type (gdbarch
, regno
);
545 /* Return "int0_t", since "void" has a misleading size of one. */
546 return builtin_type_int0
;
548 /* First check for a predefined or target defined type. */
550 return reg
->gdb_type
;
552 /* Next try size-sensitive type shortcuts. */
553 if (strcmp (reg
->type
, "float") == 0)
555 if (reg
->bitsize
== gdbarch_float_bit (gdbarch
))
556 return builtin_type_float
;
557 else if (reg
->bitsize
== gdbarch_double_bit (gdbarch
))
558 return builtin_type_double
;
559 else if (reg
->bitsize
== gdbarch_long_double_bit (gdbarch
))
560 return builtin_type_long_double
;
562 else if (strcmp (reg
->type
, "int") == 0)
564 if (reg
->bitsize
== gdbarch_long_bit (gdbarch
))
565 return builtin_type_long
;
566 else if (reg
->bitsize
== TARGET_CHAR_BIT
)
567 return builtin_type_char
;
568 else if (reg
->bitsize
== gdbarch_short_bit (gdbarch
))
569 return builtin_type_short
;
570 else if (reg
->bitsize
== gdbarch_int_bit (gdbarch
))
571 return builtin_type_int
;
572 else if (reg
->bitsize
== gdbarch_long_long_bit (gdbarch
))
573 return builtin_type_long_long
;
574 else if (reg
->bitsize
== gdbarch_ptr_bit (gdbarch
))
575 /* A bit desperate by this point... */
576 return builtin_type_void_data_ptr
;
578 else if (strcmp (reg
->type
, "code_ptr") == 0)
579 return builtin_type_void_func_ptr
;
580 else if (strcmp (reg
->type
, "data_ptr") == 0)
581 return builtin_type_void_data_ptr
;
583 internal_error (__FILE__
, __LINE__
,
584 "Register \"%s\" has an unknown type \"%s\"",
585 reg
->name
, reg
->type
);
587 warning (_("Register \"%s\" has an unsupported size (%d bits)"),
588 reg
->name
, reg
->bitsize
);
589 return builtin_type_long
;
593 tdesc_remote_register_number (struct gdbarch
*gdbarch
, int regno
)
595 struct tdesc_reg
*reg
= tdesc_find_register (gdbarch
, regno
);
598 return reg
->target_regnum
;
603 /* Check whether REGNUM is a member of REGGROUP. Registers from the
604 target description may be classified as general, float, or vector.
605 Unlike a gdbarch register_reggroup_p method, this function will
606 return -1 if it does not know; the caller should handle registers
607 with no specified group.
609 Arbitrary strings (other than "general", "float", and "vector")
610 from the description are not used; they cause the register to be
611 displayed in "info all-registers" but excluded from "info
612 registers" et al. The names of containing features are also not
613 used. This might be extended to display registers in some more
616 The save-restore flag is also implemented here. */
619 tdesc_register_in_reggroup_p (struct gdbarch
*gdbarch
, int regno
,
620 struct reggroup
*reggroup
)
622 struct tdesc_reg
*reg
= tdesc_find_register (gdbarch
, regno
);
624 if (reg
!= NULL
&& reg
->group
!= NULL
)
626 int general_p
= 0, float_p
= 0, vector_p
= 0;
628 if (strcmp (reg
->group
, "general") == 0)
630 else if (strcmp (reg
->group
, "float") == 0)
632 else if (strcmp (reg
->group
, "vector") == 0)
635 if (reggroup
== float_reggroup
)
638 if (reggroup
== vector_reggroup
)
641 if (reggroup
== general_reggroup
)
646 && (reggroup
== save_reggroup
|| reggroup
== restore_reggroup
))
647 return reg
->save_restore
;
652 /* Check whether REGNUM is a member of REGGROUP. Registers with no
653 group specified go to the default reggroup function and are handled
657 tdesc_register_reggroup_p (struct gdbarch
*gdbarch
, int regno
,
658 struct reggroup
*reggroup
)
660 int num_regs
= gdbarch_num_regs (gdbarch
);
661 int num_pseudo_regs
= gdbarch_num_pseudo_regs (gdbarch
);
664 if (regno
>= num_regs
&& regno
< num_regs
+ num_pseudo_regs
)
666 struct tdesc_arch_data
*data
= gdbarch_data (gdbarch
, tdesc_data
);
667 gdb_assert (data
->pseudo_register_reggroup_p
!= NULL
);
668 return data
->pseudo_register_reggroup_p (gdbarch
, regno
, reggroup
);
671 ret
= tdesc_register_in_reggroup_p (gdbarch
, regno
, reggroup
);
675 return default_register_reggroup_p (gdbarch
, regno
, reggroup
);
678 /* Record architecture-specific functions to call for pseudo-register
682 set_tdesc_pseudo_register_name (struct gdbarch
*gdbarch
,
683 gdbarch_register_name_ftype
*pseudo_name
)
685 struct tdesc_arch_data
*data
= gdbarch_data (gdbarch
, tdesc_data
);
687 data
->pseudo_register_name
= pseudo_name
;
691 set_tdesc_pseudo_register_type (struct gdbarch
*gdbarch
,
692 gdbarch_register_type_ftype
*pseudo_type
)
694 struct tdesc_arch_data
*data
= gdbarch_data (gdbarch
, tdesc_data
);
696 data
->pseudo_register_type
= pseudo_type
;
700 set_tdesc_pseudo_register_reggroup_p
701 (struct gdbarch
*gdbarch
,
702 gdbarch_register_reggroup_p_ftype
*pseudo_reggroup_p
)
704 struct tdesc_arch_data
*data
= gdbarch_data (gdbarch
, tdesc_data
);
706 data
->pseudo_register_reggroup_p
= pseudo_reggroup_p
;
709 /* Update GDBARCH to use the target description for registers. */
712 tdesc_use_registers (struct gdbarch
*gdbarch
,
713 const struct target_desc
*target_desc
,
714 struct tdesc_arch_data
*early_data
)
716 int num_regs
= gdbarch_num_regs (gdbarch
);
718 struct tdesc_feature
*feature
;
719 struct tdesc_reg
*reg
;
720 struct tdesc_arch_data
*data
;
723 /* We can't use the description for registers if it doesn't describe
724 any. This function should only be called after validating
725 registers, so the caller should know that registers are
727 gdb_assert (tdesc_has_registers (target_desc
));
729 data
= gdbarch_data (gdbarch
, tdesc_data
);
730 data
->registers
= early_data
->registers
;
733 /* Build up a set of all registers, so that we can assign register
734 numbers where needed. The hash table expands as necessary, so
735 the initial size is arbitrary. */
736 reg_hash
= htab_create (37, htab_hash_pointer
, htab_eq_pointer
, NULL
);
738 VEC_iterate (tdesc_feature_p
, target_desc
->features
, ixf
, feature
);
741 VEC_iterate (tdesc_reg_p
, feature
->registers
, ixr
, reg
);
744 void **slot
= htab_find_slot (reg_hash
, reg
, INSERT
);
749 /* Remove any registers which were assigned numbers by the
751 for (ixr
= 0; VEC_iterate (tdesc_reg_p
, data
->registers
, ixr
, reg
); ixr
++)
753 htab_remove_elt (reg_hash
, reg
);
755 /* Assign numbers to the remaining registers and add them to the
756 list of registers. The new numbers are always above gdbarch_num_regs.
757 Iterate over the features, not the hash table, so that the order
758 matches that in the target description. */
760 gdb_assert (VEC_length (tdesc_reg_p
, data
->registers
) <= num_regs
);
761 while (VEC_length (tdesc_reg_p
, data
->registers
) < num_regs
)
762 VEC_safe_push (tdesc_reg_p
, data
->registers
, NULL
);
764 VEC_iterate (tdesc_feature_p
, target_desc
->features
, ixf
, feature
);
767 VEC_iterate (tdesc_reg_p
, feature
->registers
, ixr
, reg
);
769 if (htab_find (reg_hash
, reg
) != NULL
)
771 VEC_safe_push (tdesc_reg_p
, data
->registers
, reg
);
775 htab_delete (reg_hash
);
777 /* Update the architecture. */
778 set_gdbarch_num_regs (gdbarch
, num_regs
);
779 set_gdbarch_register_name (gdbarch
, tdesc_register_name
);
780 set_gdbarch_register_type (gdbarch
, tdesc_register_type
);
781 set_gdbarch_remote_register_number (gdbarch
,
782 tdesc_remote_register_number
);
783 set_gdbarch_register_reggroup_p (gdbarch
, tdesc_register_reggroup_p
);
787 /* Methods for constructing a target description. */
790 tdesc_free_reg (struct tdesc_reg
*reg
)
799 tdesc_create_reg (struct tdesc_feature
*feature
, const char *name
,
800 int regnum
, int save_restore
, const char *group
,
801 int bitsize
, const char *type
)
803 struct tdesc_reg
*reg
= XZALLOC (struct tdesc_reg
);
805 reg
->name
= xstrdup (name
);
806 reg
->target_regnum
= regnum
;
807 reg
->save_restore
= save_restore
;
808 reg
->group
= group
? xstrdup (group
) : NULL
;
809 reg
->bitsize
= bitsize
;
810 reg
->type
= type
? xstrdup (type
) : xstrdup ("<unknown>");
812 /* If the register's type is target-defined, look it up now. We may not
813 have easy access to the containing feature when we want it later. */
814 reg
->gdb_type
= tdesc_named_type (feature
, reg
->type
);
816 VEC_safe_push (tdesc_reg_p
, feature
->registers
, reg
);
820 tdesc_free_feature (struct tdesc_feature
*feature
)
822 struct tdesc_reg
*reg
;
825 for (ix
= 0; VEC_iterate (tdesc_reg_p
, feature
->registers
, ix
, reg
); ix
++)
826 tdesc_free_reg (reg
);
827 VEC_free (tdesc_reg_p
, feature
->registers
);
829 /* There is no easy way to free xmalloc-allocated types, nor is
830 there a way to allocate types on an obstack not associated with
831 an objfile. Therefore we never free types. Since we only ever
832 parse an identical XML document once, this memory leak is mostly
834 VEC_free (type_p
, feature
->types
);
836 xfree (feature
->name
);
840 struct tdesc_feature
*
841 tdesc_create_feature (struct target_desc
*tdesc
, const char *name
)
843 struct tdesc_feature
*new_feature
= XZALLOC (struct tdesc_feature
);
845 new_feature
->name
= xstrdup (name
);
847 VEC_safe_push (tdesc_feature_p
, tdesc
->features
, new_feature
);
852 tdesc_record_type (struct tdesc_feature
*feature
, struct type
*type
)
854 /* The type's ID should be used as its TYPE_NAME. */
855 gdb_assert (TYPE_NAME (type
) != NULL
);
857 VEC_safe_push (type_p
, feature
->types
, type
);
861 allocate_target_description (void)
863 return XZALLOC (struct target_desc
);
867 free_target_description (void *arg
)
869 struct target_desc
*target_desc
= arg
;
870 struct tdesc_feature
*feature
;
871 struct property
*prop
;
875 VEC_iterate (tdesc_feature_p
, target_desc
->features
, ix
, feature
);
877 tdesc_free_feature (feature
);
878 VEC_free (tdesc_feature_p
, target_desc
->features
);
881 VEC_iterate (property_s
, target_desc
->properties
, ix
, prop
);
887 VEC_free (property_s
, target_desc
->properties
);
893 make_cleanup_free_target_description (struct target_desc
*target_desc
)
895 return make_cleanup (free_target_description
, target_desc
);
899 set_tdesc_property (struct target_desc
*target_desc
,
900 const char *key
, const char *value
)
902 struct property
*prop
, new_prop
;
905 gdb_assert (key
!= NULL
&& value
!= NULL
);
907 for (ix
= 0; VEC_iterate (property_s
, target_desc
->properties
, ix
, prop
);
909 if (strcmp (prop
->key
, key
) == 0)
910 internal_error (__FILE__
, __LINE__
,
911 _("Attempted to add duplicate property \"%s\""), key
);
913 new_prop
.key
= xstrdup (key
);
914 new_prop
.value
= xstrdup (value
);
915 VEC_safe_push (property_s
, target_desc
->properties
, &new_prop
);
919 set_tdesc_architecture (struct target_desc
*target_desc
,
920 const struct bfd_arch_info
*arch
)
922 target_desc
->arch
= arch
;
926 static struct cmd_list_element
*tdesc_set_cmdlist
, *tdesc_show_cmdlist
;
927 static struct cmd_list_element
*tdesc_unset_cmdlist
;
929 /* Helper functions for the CLI commands. */
932 set_tdesc_cmd (char *args
, int from_tty
)
934 help_list (tdesc_set_cmdlist
, "set tdesc ", -1, gdb_stdout
);
938 show_tdesc_cmd (char *args
, int from_tty
)
940 cmd_show_list (tdesc_show_cmdlist
, from_tty
, "");
944 unset_tdesc_cmd (char *args
, int from_tty
)
946 help_list (tdesc_unset_cmdlist
, "unset tdesc ", -1, gdb_stdout
);
950 set_tdesc_filename_cmd (char *args
, int from_tty
,
951 struct cmd_list_element
*c
)
953 target_clear_description ();
954 target_find_description ();
958 show_tdesc_filename_cmd (struct ui_file
*file
, int from_tty
,
959 struct cmd_list_element
*c
,
962 if (value
!= NULL
&& *value
!= '\0')
963 printf_filtered (_("\
964 The target description will be read from \"%s\".\n"),
967 printf_filtered (_("\
968 The target description will be read from the target.\n"));
972 unset_tdesc_filename_cmd (char *args
, int from_tty
)
974 xfree (target_description_filename
);
975 target_description_filename
= NULL
;
976 target_clear_description ();
977 target_find_description ();
981 tdesc_type_id (struct type
*type
)
985 for (ix
= 0; ix
< ARRAY_SIZE (tdesc_predefined_types
); ix
++)
986 if (TYPE_MAIN_TYPE (*tdesc_predefined_types
[ix
].type
)
987 == TYPE_MAIN_TYPE (type
))
988 return tdesc_predefined_types
[ix
].name
;
990 return TYPE_NAME (type
);
994 maint_print_c_tdesc_cmd (char *args
, int from_tty
)
996 const struct target_desc
*tdesc
;
997 const char *filename
, *inp
;
998 char *function
, *outp
;
999 struct property
*prop
;
1000 struct tdesc_feature
*feature
;
1001 struct tdesc_reg
*reg
;
1005 /* Use the global target-supplied description, not the current
1006 architecture's. This lets a GDB for one architecture generate C
1007 for another architecture's description, even though the gdbarch
1008 initialization code will reject the new description. */
1009 tdesc
= current_target_desc
;
1011 error (_("There is no target description to print."));
1013 if (target_description_filename
== NULL
)
1014 error (_("The current target description did not come from an XML file."));
1016 filename
= lbasename (target_description_filename
);
1017 function
= xmalloc (strlen (filename
) + 1);
1018 for (inp
= filename
, outp
= function
; *inp
!= '\0'; inp
++)
1021 else if (*inp
== '-')
1027 /* Standard boilerplate. */
1028 printf_unfiltered ("/* THIS FILE IS GENERATED. Original: %s */\n\n",
1030 printf_unfiltered ("#include \"defs.h\"\n");
1031 printf_unfiltered ("#include \"gdbtypes.h\"\n");
1032 printf_unfiltered ("#include \"target-descriptions.h\"\n");
1033 printf_unfiltered ("\n");
1035 printf_unfiltered ("struct target_desc *tdesc_%s;\n", function
);
1036 printf_unfiltered ("static void\n");
1037 printf_unfiltered ("initialize_tdesc_%s (void)\n", function
);
1038 printf_unfiltered ("{\n");
1040 (" struct target_desc *result = allocate_target_description ();\n");
1041 printf_unfiltered (" struct tdesc_feature *feature;\n");
1042 printf_unfiltered (" struct type *field_type, *type;\n");
1043 printf_unfiltered ("\n");
1045 if (tdesc_architecture (tdesc
) != NULL
)
1048 (" set_tdesc_architecture (result, bfd_scan_arch (\"%s\"));\n",
1049 tdesc_architecture (tdesc
)->printable_name
);
1050 printf_unfiltered ("\n");
1053 for (ix
= 0; VEC_iterate (property_s
, tdesc
->properties
, ix
, prop
);
1056 printf_unfiltered (" set_tdesc_property (result, \"%s\", \"%s\");\n",
1057 prop
->key
, prop
->value
);
1061 VEC_iterate (tdesc_feature_p
, tdesc
->features
, ix
, feature
);
1064 printf_unfiltered (" feature = tdesc_create_feature (result, \"%s\");\n",
1068 VEC_iterate (type_p
, feature
->types
, ix2
, type
);
1071 switch (TYPE_CODE (type
))
1073 case TYPE_CODE_ARRAY
:
1075 (" field_type = tdesc_named_type (feature, \"%s\");\n",
1076 tdesc_type_id (TYPE_TARGET_TYPE (type
)));
1078 (" type = init_vector_type (field_type, %d);\n",
1079 TYPE_LENGTH (type
) / TYPE_LENGTH (TYPE_TARGET_TYPE (type
)));
1081 (" TYPE_NAME (type) = xstrdup (\"%s\");\n", TYPE_NAME (type
));
1083 case TYPE_CODE_UNION
:
1085 (" type = init_composite_type (NULL, TYPE_CODE_UNION);\n");
1087 (" TYPE_NAME (type) = xstrdup (\"%s\");\n", TYPE_NAME (type
));
1088 for (ix3
= 0; ix3
< TYPE_NFIELDS (type
); ix3
++)
1091 (" field_type = tdesc_named_type (feature, \"%s\");\n",
1092 tdesc_type_id (TYPE_FIELD_TYPE (type
, ix3
)));
1094 (" append_composite_type_field (type, "
1095 "xstrdup (\"%s\"), field_type);\n",
1096 TYPE_FIELD_NAME (type
, ix3
));
1098 if (TYPE_VECTOR (type
))
1100 (" TYPE_FLAGS (type) |= TYPE_FLAG_VECTOR;\n");
1103 error (_("C output is not supported type \"%s\"."), TYPE_NAME (type
));
1105 printf_unfiltered (" tdesc_record_type (feature, type);\n");
1106 printf_unfiltered ("\n");
1110 VEC_iterate (tdesc_reg_p
, feature
->registers
, ix2
, reg
);
1113 printf_unfiltered (" tdesc_create_reg (feature, \"%s\", %ld, %d, ",
1114 reg
->name
, reg
->target_regnum
, reg
->save_restore
);
1116 printf_unfiltered ("\"%s\", ", reg
->group
);
1118 printf_unfiltered ("NULL, ");
1119 printf_unfiltered ("%d, \"%s\");\n", reg
->bitsize
, reg
->type
);
1122 printf_unfiltered ("\n");
1125 printf_unfiltered (" tdesc_%s = result;\n", function
);
1126 printf_unfiltered ("}\n");
1130 _initialize_target_descriptions (void)
1132 tdesc_data
= gdbarch_data_register_pre_init (tdesc_data_init
);
1134 add_prefix_cmd ("tdesc", class_maintenance
, set_tdesc_cmd
, _("\
1135 Set target description specific variables."),
1136 &tdesc_set_cmdlist
, "set tdesc ",
1137 0 /* allow-unknown */, &setlist
);
1138 add_prefix_cmd ("tdesc", class_maintenance
, show_tdesc_cmd
, _("\
1139 Show target description specific variables."),
1140 &tdesc_show_cmdlist
, "show tdesc ",
1141 0 /* allow-unknown */, &showlist
);
1142 add_prefix_cmd ("tdesc", class_maintenance
, unset_tdesc_cmd
, _("\
1143 Unset target description specific variables."),
1144 &tdesc_unset_cmdlist
, "unset tdesc ",
1145 0 /* allow-unknown */, &unsetlist
);
1147 add_setshow_filename_cmd ("filename", class_obscure
,
1148 &target_description_filename
,
1150 Set the file to read for an XML target description"), _("\
1151 Show the file to read for an XML target description"), _("\
1152 When set, GDB will read the target description from a local\n\
1153 file instead of querying the remote target."),
1154 set_tdesc_filename_cmd
,
1155 show_tdesc_filename_cmd
,
1156 &tdesc_set_cmdlist
, &tdesc_show_cmdlist
);
1158 add_cmd ("filename", class_obscure
, unset_tdesc_filename_cmd
, _("\
1159 Unset the file to read for an XML target description. When unset,\n\
1160 GDB will read the description from the target."),
1161 &tdesc_unset_cmdlist
);
1163 add_cmd ("c-tdesc", class_maintenance
, maint_print_c_tdesc_cmd
, _("\
1164 Print the current target description as a C source file."),
1165 &maintenanceprintlist
);