1 /* Target description support for GDB.
3 Copyright (C) 2006, 2007, 2008, 2009 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 tdesc_type
*tdesc_type
;
84 DEF_VEC_P(tdesc_reg_p
);
86 /* A named type from a target description. */
88 typedef struct tdesc_type_field
91 struct tdesc_type
*type
;
93 DEF_VEC_O(tdesc_type_field
);
95 typedef struct tdesc_type
97 /* The name of this type. */
100 /* Identify the kind of this type. */
103 /* Predefined types. */
116 TDESC_TYPE_IEEE_SINGLE
,
117 TDESC_TYPE_IEEE_DOUBLE
,
118 TDESC_TYPE_ARM_FPA_EXT
,
120 /* Types defined by a target feature. */
125 /* Kind-specific data. */
131 struct tdesc_type
*type
;
138 VEC(tdesc_type_field
) *fields
;
142 DEF_VEC_P(tdesc_type_p
);
144 /* A feature from a target description. Each feature is a collection
145 of other elements, e.g. registers and types. */
147 typedef struct tdesc_feature
149 /* The name of this feature. It may be recognized by the architecture
153 /* The registers associated with this feature. */
154 VEC(tdesc_reg_p
) *registers
;
156 /* The types associated with this feature. */
157 VEC(tdesc_type_p
) *types
;
159 DEF_VEC_P(tdesc_feature_p
);
161 /* A target description. */
165 /* The architecture reported by the target, if any. */
166 const struct bfd_arch_info
*arch
;
168 /* Any architecture-specific properties specified by the target. */
169 VEC(property_s
) *properties
;
171 /* The features associated with this target. */
172 VEC(tdesc_feature_p
) *features
;
175 /* Per-architecture data associated with a target description. The
176 target description may be shared by multiple architectures, but
177 this data is private to one gdbarch. */
179 typedef struct tdesc_arch_reg
181 struct tdesc_reg
*reg
;
184 DEF_VEC_O(tdesc_arch_reg
);
186 struct tdesc_arch_data
188 /* A list of register/type pairs, indexed by GDB's internal register number.
189 During initialization of the gdbarch this list is used to store
190 registers which the architecture assigns a fixed register number.
191 Registers which are NULL in this array, or off the end, are
192 treated as zero-sized and nameless (i.e. placeholders in the
194 VEC(tdesc_arch_reg
) *arch_regs
;
196 /* Functions which report the register name, type, and reggroups for
198 gdbarch_register_name_ftype
*pseudo_register_name
;
199 gdbarch_register_type_ftype
*pseudo_register_type
;
200 gdbarch_register_reggroup_p_ftype
*pseudo_register_reggroup_p
;
203 /* Global state. These variables are associated with the current
204 target; if GDB adds support for multiple simultaneous targets, then
205 these variables should become target-specific data. */
207 /* A flag indicating that a description has already been fetched from
208 the current target, so it should not be queried again. */
210 static int target_desc_fetched
;
212 /* The description fetched from the current target, or NULL if the
213 current target did not supply any description. Only valid when
214 target_desc_fetched is set. Only the description initialization
215 code should access this; normally, the description should be
216 accessed through the gdbarch object. */
218 static const struct target_desc
*current_target_desc
;
220 /* Other global variables. */
222 /* The filename to read a target description from. */
224 static char *target_description_filename
;
226 /* A handle for architecture-specific data associated with the
227 target description (see struct tdesc_arch_data). */
229 static struct gdbarch_data
*tdesc_data
;
231 /* Fetch the current target's description, and switch the current
232 architecture to one which incorporates that description. */
235 target_find_description (void)
237 /* If we've already fetched a description from the target, don't do
238 it again. This allows a target to fetch the description early,
239 during its to_open or to_create_inferior, if it needs extra
240 information about the target to initialize. */
241 if (target_desc_fetched
)
244 /* The current architecture should not have any target description
245 specified. It should have been cleared, e.g. when we
246 disconnected from the previous target. */
247 gdb_assert (gdbarch_target_desc (target_gdbarch
) == NULL
);
249 /* First try to fetch an XML description from the user-specified
251 current_target_desc
= NULL
;
252 if (target_description_filename
!= NULL
253 && *target_description_filename
!= '\0')
255 = file_read_description_xml (target_description_filename
);
257 /* Next try to read the description from the current target using
259 if (current_target_desc
== NULL
)
260 current_target_desc
= target_read_description_xml (¤t_target
);
262 /* If that failed try a target-specific hook. */
263 if (current_target_desc
== NULL
)
264 current_target_desc
= target_read_description (¤t_target
);
266 /* If a non-NULL description was returned, then update the current
268 if (current_target_desc
)
270 struct gdbarch_info info
;
272 gdbarch_info_init (&info
);
273 info
.target_desc
= current_target_desc
;
274 if (!gdbarch_update_p (info
))
275 warning (_("Architecture rejected target-supplied description"));
278 struct tdesc_arch_data
*data
;
280 data
= gdbarch_data (target_gdbarch
, tdesc_data
);
281 if (tdesc_has_registers (current_target_desc
)
282 && data
->arch_regs
== NULL
)
283 warning (_("Target-supplied registers are not supported "
284 "by the current architecture"));
288 /* Now that we know this description is usable, record that we
290 target_desc_fetched
= 1;
293 /* Discard any description fetched from the current target, and switch
294 the current architecture to one with no target description. */
297 target_clear_description (void)
299 struct gdbarch_info info
;
301 if (!target_desc_fetched
)
304 target_desc_fetched
= 0;
305 current_target_desc
= NULL
;
307 gdbarch_info_init (&info
);
308 if (!gdbarch_update_p (info
))
309 internal_error (__FILE__
, __LINE__
,
310 _("Could not remove target-supplied description"));
313 /* Return the global current target description. This should only be
314 used by gdbarch initialization code; most access should be through
315 an existing gdbarch. */
317 const struct target_desc
*
318 target_current_description (void)
320 if (target_desc_fetched
)
321 return current_target_desc
;
327 /* Direct accessors for target descriptions. */
329 /* Return the string value of a property named KEY, or NULL if the
330 property was not specified. */
333 tdesc_property (const struct target_desc
*target_desc
, const char *key
)
335 struct property
*prop
;
338 for (ix
= 0; VEC_iterate (property_s
, target_desc
->properties
, ix
, prop
);
340 if (strcmp (prop
->key
, key
) == 0)
346 /* Return the BFD architecture associated with this target
347 description, or NULL if no architecture was specified. */
349 const struct bfd_arch_info
*
350 tdesc_architecture (const struct target_desc
*target_desc
)
352 return target_desc
->arch
;
356 /* Return 1 if this target description includes any registers. */
359 tdesc_has_registers (const struct target_desc
*target_desc
)
362 struct tdesc_feature
*feature
;
364 if (target_desc
== NULL
)
368 VEC_iterate (tdesc_feature_p
, target_desc
->features
, ix
, feature
);
370 if (! VEC_empty (tdesc_reg_p
, feature
->registers
))
376 /* Return the feature with the given name, if present, or NULL if
377 the named feature is not found. */
379 const struct tdesc_feature
*
380 tdesc_find_feature (const struct target_desc
*target_desc
,
384 struct tdesc_feature
*feature
;
387 VEC_iterate (tdesc_feature_p
, target_desc
->features
, ix
, feature
);
389 if (strcmp (feature
->name
, name
) == 0)
395 /* Return the name of FEATURE. */
398 tdesc_feature_name (const struct tdesc_feature
*feature
)
400 return feature
->name
;
403 /* Predefined types. */
404 static struct tdesc_type tdesc_predefined_types
[] =
406 { "int8", TDESC_TYPE_INT8
},
407 { "int16", TDESC_TYPE_INT16
},
408 { "int32", TDESC_TYPE_INT32
},
409 { "int64", TDESC_TYPE_INT64
},
410 { "int128", TDESC_TYPE_INT128
},
411 { "uint8", TDESC_TYPE_UINT8
},
412 { "uint16", TDESC_TYPE_UINT16
},
413 { "uint32", TDESC_TYPE_UINT32
},
414 { "uint64", TDESC_TYPE_UINT64
},
415 { "uint128", TDESC_TYPE_UINT128
},
416 { "code_ptr", TDESC_TYPE_CODE_PTR
},
417 { "data_ptr", TDESC_TYPE_DATA_PTR
},
418 { "ieee_single", TDESC_TYPE_IEEE_SINGLE
},
419 { "ieee_double", TDESC_TYPE_IEEE_DOUBLE
},
420 { "arm_fpa_ext", TDESC_TYPE_ARM_FPA_EXT
}
423 /* Return the type associated with ID in the context of FEATURE, or
427 tdesc_named_type (const struct tdesc_feature
*feature
, const char *id
)
430 struct tdesc_type
*type
;
432 /* First try target-defined types. */
433 for (ix
= 0; VEC_iterate (tdesc_type_p
, feature
->types
, ix
, type
); ix
++)
434 if (strcmp (type
->name
, id
) == 0)
437 /* Next try the predefined types. */
438 for (ix
= 0; ix
< ARRAY_SIZE (tdesc_predefined_types
); ix
++)
439 if (strcmp (tdesc_predefined_types
[ix
].name
, id
) == 0)
440 return &tdesc_predefined_types
[ix
];
445 /* Construct, if necessary, and return the GDB type implementing target
446 type TDESC_TYPE for architecture GDBARCH. */
449 tdesc_gdb_type (struct gdbarch
*gdbarch
, struct tdesc_type
*tdesc_type
)
451 switch (tdesc_type
->kind
)
453 /* Predefined types. */
454 case TDESC_TYPE_INT8
:
455 return builtin_type (gdbarch
)->builtin_int8
;
457 case TDESC_TYPE_INT16
:
458 return builtin_type (gdbarch
)->builtin_int16
;
460 case TDESC_TYPE_INT32
:
461 return builtin_type (gdbarch
)->builtin_int32
;
463 case TDESC_TYPE_INT64
:
464 return builtin_type (gdbarch
)->builtin_int64
;
466 case TDESC_TYPE_INT128
:
467 return builtin_type (gdbarch
)->builtin_int128
;
469 case TDESC_TYPE_UINT8
:
470 return builtin_type (gdbarch
)->builtin_uint8
;
472 case TDESC_TYPE_UINT16
:
473 return builtin_type (gdbarch
)->builtin_uint16
;
475 case TDESC_TYPE_UINT32
:
476 return builtin_type (gdbarch
)->builtin_uint32
;
478 case TDESC_TYPE_UINT64
:
479 return builtin_type (gdbarch
)->builtin_uint64
;
481 case TDESC_TYPE_UINT128
:
482 return builtin_type (gdbarch
)->builtin_uint128
;
484 case TDESC_TYPE_CODE_PTR
:
485 return builtin_type (gdbarch
)->builtin_func_ptr
;
487 case TDESC_TYPE_DATA_PTR
:
488 return builtin_type (gdbarch
)->builtin_data_ptr
;
490 case TDESC_TYPE_IEEE_SINGLE
:
491 return init_float_type (-1, "builtin_type_ieee_single",
492 floatformats_ieee_single
);
494 case TDESC_TYPE_IEEE_DOUBLE
:
495 return init_float_type (-1, "builtin_type_ieee_double",
496 floatformats_ieee_double
);
498 case TDESC_TYPE_ARM_FPA_EXT
:
499 return init_float_type (-1, "builtin_type_arm_ext",
500 floatformats_arm_ext
);
502 /* Types defined by a target feature. */
503 case TDESC_TYPE_VECTOR
:
505 struct type
*type
, *field_type
;
507 field_type
= tdesc_gdb_type (gdbarch
, tdesc_type
->u
.v
.type
);
508 type
= init_vector_type (field_type
, tdesc_type
->u
.v
.count
);
509 TYPE_NAME (type
) = xstrdup (tdesc_type
->name
);
514 case TDESC_TYPE_UNION
:
516 struct type
*type
, *field_type
;
517 struct tdesc_type_field
*f
;
520 type
= init_composite_type (NULL
, TYPE_CODE_UNION
);
521 TYPE_NAME (type
) = xstrdup (tdesc_type
->name
);
524 VEC_iterate (tdesc_type_field
, tdesc_type
->u
.u
.fields
, ix
, f
);
527 field_type
= tdesc_gdb_type (gdbarch
, f
->type
);
528 append_composite_type_field (type
, xstrdup (f
->name
), field_type
);
530 /* If any of the children of this union are vectors, flag the
531 union as a vector also. This allows e.g. a union of two
532 vector types to show up automatically in "info vector". */
533 if (TYPE_VECTOR (field_type
))
534 TYPE_VECTOR (type
) = 1;
541 internal_error (__FILE__
, __LINE__
,
542 "Type \"%s\" has an unknown kind %d",
543 tdesc_type
->name
, tdesc_type
->kind
);
547 /* Support for registers from target descriptions. */
549 /* Construct the per-gdbarch data. */
552 tdesc_data_init (struct obstack
*obstack
)
554 struct tdesc_arch_data
*data
;
556 data
= OBSTACK_ZALLOC (obstack
, struct tdesc_arch_data
);
560 /* Similar, but for the temporary copy used during architecture
563 struct tdesc_arch_data
*
564 tdesc_data_alloc (void)
566 return XZALLOC (struct tdesc_arch_data
);
569 /* Free something allocated by tdesc_data_alloc, if it is not going
570 to be used (for instance if it was unsuitable for the
574 tdesc_data_cleanup (void *data_untyped
)
576 struct tdesc_arch_data
*data
= data_untyped
;
578 VEC_free (tdesc_arch_reg
, data
->arch_regs
);
582 /* Search FEATURE for a register named NAME. */
584 static struct tdesc_reg
*
585 tdesc_find_register_early (const struct tdesc_feature
*feature
,
589 struct tdesc_reg
*reg
;
592 VEC_iterate (tdesc_reg_p
, feature
->registers
, ixr
, reg
);
594 if (strcasecmp (reg
->name
, name
) == 0)
600 /* Search FEATURE for a register named NAME. Assign REGNO to it. */
603 tdesc_numbered_register (const struct tdesc_feature
*feature
,
604 struct tdesc_arch_data
*data
,
605 int regno
, const char *name
)
607 struct tdesc_arch_reg arch_reg
= { 0 };
608 struct tdesc_reg
*reg
= tdesc_find_register_early (feature
, name
);
613 /* Make sure the vector includes a REGNO'th element. */
614 while (regno
>= VEC_length (tdesc_arch_reg
, data
->arch_regs
))
615 VEC_safe_push (tdesc_arch_reg
, data
->arch_regs
, &arch_reg
);
618 VEC_replace (tdesc_arch_reg
, data
->arch_regs
, regno
, &arch_reg
);
622 /* Search FEATURE for a register whose name is in NAMES and assign
626 tdesc_numbered_register_choices (const struct tdesc_feature
*feature
,
627 struct tdesc_arch_data
*data
,
628 int regno
, const char *const names
[])
632 for (i
= 0; names
[i
] != NULL
; i
++)
633 if (tdesc_numbered_register (feature
, data
, regno
, names
[i
]))
639 /* Search FEATURE for a register named NAME, and return its size in
640 bits. The register must exist. */
643 tdesc_register_size (const struct tdesc_feature
*feature
,
646 struct tdesc_reg
*reg
= tdesc_find_register_early (feature
, name
);
648 gdb_assert (reg
!= NULL
);
652 /* Look up a register by its GDB internal register number. */
654 static struct tdesc_arch_reg
*
655 tdesc_find_arch_register (struct gdbarch
*gdbarch
, int regno
)
657 struct tdesc_arch_reg
*reg
;
658 struct tdesc_arch_data
*data
;
660 data
= gdbarch_data (gdbarch
, tdesc_data
);
661 if (regno
< VEC_length (tdesc_arch_reg
, data
->arch_regs
))
662 return VEC_index (tdesc_arch_reg
, data
->arch_regs
, regno
);
667 static struct tdesc_reg
*
668 tdesc_find_register (struct gdbarch
*gdbarch
, int regno
)
670 struct tdesc_arch_reg
*reg
= tdesc_find_arch_register (gdbarch
, regno
);
671 return reg
? reg
->reg
: NULL
;
674 /* Return the name of register REGNO, from the target description or
675 from an architecture-provided pseudo_register_name method. */
678 tdesc_register_name (struct gdbarch
*gdbarch
, int regno
)
680 struct tdesc_reg
*reg
= tdesc_find_register (gdbarch
, regno
);
681 int num_regs
= gdbarch_num_regs (gdbarch
);
682 int num_pseudo_regs
= gdbarch_num_pseudo_regs (gdbarch
);
687 if (regno
>= num_regs
&& regno
< num_regs
+ num_pseudo_regs
)
689 struct tdesc_arch_data
*data
= gdbarch_data (gdbarch
, tdesc_data
);
690 gdb_assert (data
->pseudo_register_name
!= NULL
);
691 return data
->pseudo_register_name (gdbarch
, regno
);
698 tdesc_register_type (struct gdbarch
*gdbarch
, int regno
)
700 struct tdesc_arch_reg
*arch_reg
= tdesc_find_arch_register (gdbarch
, regno
);
701 struct tdesc_reg
*reg
= arch_reg
? arch_reg
->reg
: NULL
;
702 int num_regs
= gdbarch_num_regs (gdbarch
);
703 int num_pseudo_regs
= gdbarch_num_pseudo_regs (gdbarch
);
705 if (reg
== NULL
&& regno
>= num_regs
&& regno
< num_regs
+ num_pseudo_regs
)
707 struct tdesc_arch_data
*data
= gdbarch_data (gdbarch
, tdesc_data
);
708 gdb_assert (data
->pseudo_register_type
!= NULL
);
709 return data
->pseudo_register_type (gdbarch
, regno
);
713 /* Return "int0_t", since "void" has a misleading size of one. */
714 return builtin_type (gdbarch
)->builtin_int0
;
716 if (arch_reg
->type
== NULL
)
718 /* First check for a predefined or target defined type. */
720 arch_reg
->type
= tdesc_gdb_type (gdbarch
, reg
->tdesc_type
);
722 /* Next try size-sensitive type shortcuts. */
723 else if (strcmp (reg
->type
, "float") == 0)
725 if (reg
->bitsize
== gdbarch_float_bit (gdbarch
))
726 arch_reg
->type
= builtin_type (gdbarch
)->builtin_float
;
727 else if (reg
->bitsize
== gdbarch_double_bit (gdbarch
))
728 arch_reg
->type
= builtin_type (gdbarch
)->builtin_double
;
729 else if (reg
->bitsize
== gdbarch_long_double_bit (gdbarch
))
730 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long_double
;
733 warning (_("Register \"%s\" has an unsupported size (%d bits)"),
734 reg
->name
, reg
->bitsize
);
735 arch_reg
->type
= builtin_type (gdbarch
)->builtin_double
;
738 else if (strcmp (reg
->type
, "int") == 0)
740 if (reg
->bitsize
== gdbarch_long_bit (gdbarch
))
741 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long
;
742 else if (reg
->bitsize
== TARGET_CHAR_BIT
)
743 arch_reg
->type
= builtin_type (gdbarch
)->builtin_char
;
744 else if (reg
->bitsize
== gdbarch_short_bit (gdbarch
))
745 arch_reg
->type
= builtin_type (gdbarch
)->builtin_short
;
746 else if (reg
->bitsize
== gdbarch_int_bit (gdbarch
))
747 arch_reg
->type
= builtin_type (gdbarch
)->builtin_int
;
748 else if (reg
->bitsize
== gdbarch_long_long_bit (gdbarch
))
749 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long_long
;
750 else if (reg
->bitsize
== gdbarch_ptr_bit (gdbarch
))
751 /* A bit desperate by this point... */
752 arch_reg
->type
= builtin_type (gdbarch
)->builtin_data_ptr
;
755 warning (_("Register \"%s\" has an unsupported size (%d bits)"),
756 reg
->name
, reg
->bitsize
);
757 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long
;
761 if (arch_reg
->type
== NULL
)
762 internal_error (__FILE__
, __LINE__
,
763 "Register \"%s\" has an unknown type \"%s\"",
764 reg
->name
, reg
->type
);
767 return arch_reg
->type
;
771 tdesc_remote_register_number (struct gdbarch
*gdbarch
, int regno
)
773 struct tdesc_reg
*reg
= tdesc_find_register (gdbarch
, regno
);
776 return reg
->target_regnum
;
781 /* Check whether REGNUM is a member of REGGROUP. Registers from the
782 target description may be classified as general, float, or vector.
783 Unlike a gdbarch register_reggroup_p method, this function will
784 return -1 if it does not know; the caller should handle registers
785 with no specified group.
787 Arbitrary strings (other than "general", "float", and "vector")
788 from the description are not used; they cause the register to be
789 displayed in "info all-registers" but excluded from "info
790 registers" et al. The names of containing features are also not
791 used. This might be extended to display registers in some more
794 The save-restore flag is also implemented here. */
797 tdesc_register_in_reggroup_p (struct gdbarch
*gdbarch
, int regno
,
798 struct reggroup
*reggroup
)
800 struct tdesc_reg
*reg
= tdesc_find_register (gdbarch
, regno
);
802 if (reg
!= NULL
&& reg
->group
!= NULL
)
804 int general_p
= 0, float_p
= 0, vector_p
= 0;
806 if (strcmp (reg
->group
, "general") == 0)
808 else if (strcmp (reg
->group
, "float") == 0)
810 else if (strcmp (reg
->group
, "vector") == 0)
813 if (reggroup
== float_reggroup
)
816 if (reggroup
== vector_reggroup
)
819 if (reggroup
== general_reggroup
)
824 && (reggroup
== save_reggroup
|| reggroup
== restore_reggroup
))
825 return reg
->save_restore
;
830 /* Check whether REGNUM is a member of REGGROUP. Registers with no
831 group specified go to the default reggroup function and are handled
835 tdesc_register_reggroup_p (struct gdbarch
*gdbarch
, int regno
,
836 struct reggroup
*reggroup
)
838 int num_regs
= gdbarch_num_regs (gdbarch
);
839 int num_pseudo_regs
= gdbarch_num_pseudo_regs (gdbarch
);
842 if (regno
>= num_regs
&& regno
< num_regs
+ num_pseudo_regs
)
844 struct tdesc_arch_data
*data
= gdbarch_data (gdbarch
, tdesc_data
);
845 gdb_assert (data
->pseudo_register_reggroup_p
!= NULL
);
846 return data
->pseudo_register_reggroup_p (gdbarch
, regno
, reggroup
);
849 ret
= tdesc_register_in_reggroup_p (gdbarch
, regno
, reggroup
);
853 return default_register_reggroup_p (gdbarch
, regno
, reggroup
);
856 /* Record architecture-specific functions to call for pseudo-register
860 set_tdesc_pseudo_register_name (struct gdbarch
*gdbarch
,
861 gdbarch_register_name_ftype
*pseudo_name
)
863 struct tdesc_arch_data
*data
= gdbarch_data (gdbarch
, tdesc_data
);
865 data
->pseudo_register_name
= pseudo_name
;
869 set_tdesc_pseudo_register_type (struct gdbarch
*gdbarch
,
870 gdbarch_register_type_ftype
*pseudo_type
)
872 struct tdesc_arch_data
*data
= gdbarch_data (gdbarch
, tdesc_data
);
874 data
->pseudo_register_type
= pseudo_type
;
878 set_tdesc_pseudo_register_reggroup_p
879 (struct gdbarch
*gdbarch
,
880 gdbarch_register_reggroup_p_ftype
*pseudo_reggroup_p
)
882 struct tdesc_arch_data
*data
= gdbarch_data (gdbarch
, tdesc_data
);
884 data
->pseudo_register_reggroup_p
= pseudo_reggroup_p
;
887 /* Update GDBARCH to use the target description for registers. */
890 tdesc_use_registers (struct gdbarch
*gdbarch
,
891 const struct target_desc
*target_desc
,
892 struct tdesc_arch_data
*early_data
)
894 int num_regs
= gdbarch_num_regs (gdbarch
);
896 struct tdesc_feature
*feature
;
897 struct tdesc_reg
*reg
;
898 struct tdesc_arch_data
*data
;
899 struct tdesc_arch_reg
*arch_reg
, new_arch_reg
= { 0 };
902 /* We can't use the description for registers if it doesn't describe
903 any. This function should only be called after validating
904 registers, so the caller should know that registers are
906 gdb_assert (tdesc_has_registers (target_desc
));
908 data
= gdbarch_data (gdbarch
, tdesc_data
);
909 data
->arch_regs
= early_data
->arch_regs
;
912 /* Build up a set of all registers, so that we can assign register
913 numbers where needed. The hash table expands as necessary, so
914 the initial size is arbitrary. */
915 reg_hash
= htab_create (37, htab_hash_pointer
, htab_eq_pointer
, NULL
);
917 VEC_iterate (tdesc_feature_p
, target_desc
->features
, ixf
, feature
);
920 VEC_iterate (tdesc_reg_p
, feature
->registers
, ixr
, reg
);
923 void **slot
= htab_find_slot (reg_hash
, reg
, INSERT
);
928 /* Remove any registers which were assigned numbers by the
931 VEC_iterate (tdesc_arch_reg
, data
->arch_regs
, ixr
, arch_reg
);
934 htab_remove_elt (reg_hash
, arch_reg
->reg
);
936 /* Assign numbers to the remaining registers and add them to the
937 list of registers. The new numbers are always above gdbarch_num_regs.
938 Iterate over the features, not the hash table, so that the order
939 matches that in the target description. */
941 gdb_assert (VEC_length (tdesc_arch_reg
, data
->arch_regs
) <= num_regs
);
942 while (VEC_length (tdesc_arch_reg
, data
->arch_regs
) < num_regs
)
943 VEC_safe_push (tdesc_arch_reg
, data
->arch_regs
, &new_arch_reg
);
945 VEC_iterate (tdesc_feature_p
, target_desc
->features
, ixf
, feature
);
948 VEC_iterate (tdesc_reg_p
, feature
->registers
, ixr
, reg
);
950 if (htab_find (reg_hash
, reg
) != NULL
)
952 new_arch_reg
.reg
= reg
;
953 VEC_safe_push (tdesc_arch_reg
, data
->arch_regs
, &new_arch_reg
);
957 htab_delete (reg_hash
);
959 /* Update the architecture. */
960 set_gdbarch_num_regs (gdbarch
, num_regs
);
961 set_gdbarch_register_name (gdbarch
, tdesc_register_name
);
962 set_gdbarch_register_type (gdbarch
, tdesc_register_type
);
963 set_gdbarch_remote_register_number (gdbarch
,
964 tdesc_remote_register_number
);
965 set_gdbarch_register_reggroup_p (gdbarch
, tdesc_register_reggroup_p
);
969 /* Methods for constructing a target description. */
972 tdesc_free_reg (struct tdesc_reg
*reg
)
981 tdesc_create_reg (struct tdesc_feature
*feature
, const char *name
,
982 int regnum
, int save_restore
, const char *group
,
983 int bitsize
, const char *type
)
985 struct tdesc_reg
*reg
= XZALLOC (struct tdesc_reg
);
987 reg
->name
= xstrdup (name
);
988 reg
->target_regnum
= regnum
;
989 reg
->save_restore
= save_restore
;
990 reg
->group
= group
? xstrdup (group
) : NULL
;
991 reg
->bitsize
= bitsize
;
992 reg
->type
= type
? xstrdup (type
) : xstrdup ("<unknown>");
994 /* If the register's type is target-defined, look it up now. We may not
995 have easy access to the containing feature when we want it later. */
996 reg
->tdesc_type
= tdesc_named_type (feature
, reg
->type
);
998 VEC_safe_push (tdesc_reg_p
, feature
->registers
, reg
);
1002 tdesc_free_type (struct tdesc_type
*type
)
1007 case TDESC_TYPE_UNION
:
1009 struct tdesc_type_field
*f
;
1013 VEC_iterate (tdesc_type_field
, type
->u
.u
.fields
, ix
, f
);
1017 VEC_free (tdesc_type_field
, type
->u
.u
.fields
);
1030 tdesc_create_vector (struct tdesc_feature
*feature
, const char *name
,
1031 struct tdesc_type
*field_type
, int count
)
1033 struct tdesc_type
*type
= XZALLOC (struct tdesc_type
);
1035 type
->name
= xstrdup (name
);
1036 type
->kind
= TDESC_TYPE_VECTOR
;
1037 type
->u
.v
.type
= field_type
;
1038 type
->u
.v
.count
= count
;
1040 VEC_safe_push (tdesc_type_p
, feature
->types
, type
);
1045 tdesc_create_union (struct tdesc_feature
*feature
, const char *name
)
1047 struct tdesc_type
*type
= XZALLOC (struct tdesc_type
);
1049 type
->name
= xstrdup (name
);
1050 type
->kind
= TDESC_TYPE_UNION
;
1052 VEC_safe_push (tdesc_type_p
, feature
->types
, type
);
1057 tdesc_add_field (struct tdesc_type
*type
, const char *field_name
,
1058 struct tdesc_type
*field_type
)
1060 struct tdesc_type_field f
= { 0 };
1062 gdb_assert (type
->kind
== TDESC_TYPE_UNION
);
1064 f
.name
= xstrdup (field_name
);
1065 f
.type
= field_type
;
1067 VEC_safe_push (tdesc_type_field
, type
->u
.u
.fields
, &f
);
1071 tdesc_free_feature (struct tdesc_feature
*feature
)
1073 struct tdesc_reg
*reg
;
1074 struct tdesc_type
*type
;
1077 for (ix
= 0; VEC_iterate (tdesc_reg_p
, feature
->registers
, ix
, reg
); ix
++)
1078 tdesc_free_reg (reg
);
1079 VEC_free (tdesc_reg_p
, feature
->registers
);
1081 for (ix
= 0; VEC_iterate (tdesc_type_p
, feature
->types
, ix
, type
); ix
++)
1082 tdesc_free_type (type
);
1083 VEC_free (tdesc_type_p
, feature
->types
);
1085 xfree (feature
->name
);
1089 struct tdesc_feature
*
1090 tdesc_create_feature (struct target_desc
*tdesc
, const char *name
)
1092 struct tdesc_feature
*new_feature
= XZALLOC (struct tdesc_feature
);
1094 new_feature
->name
= xstrdup (name
);
1096 VEC_safe_push (tdesc_feature_p
, tdesc
->features
, new_feature
);
1100 struct target_desc
*
1101 allocate_target_description (void)
1103 return XZALLOC (struct target_desc
);
1107 free_target_description (void *arg
)
1109 struct target_desc
*target_desc
= arg
;
1110 struct tdesc_feature
*feature
;
1111 struct property
*prop
;
1115 VEC_iterate (tdesc_feature_p
, target_desc
->features
, ix
, feature
);
1117 tdesc_free_feature (feature
);
1118 VEC_free (tdesc_feature_p
, target_desc
->features
);
1121 VEC_iterate (property_s
, target_desc
->properties
, ix
, prop
);
1125 xfree (prop
->value
);
1127 VEC_free (property_s
, target_desc
->properties
);
1129 xfree (target_desc
);
1133 make_cleanup_free_target_description (struct target_desc
*target_desc
)
1135 return make_cleanup (free_target_description
, target_desc
);
1139 set_tdesc_property (struct target_desc
*target_desc
,
1140 const char *key
, const char *value
)
1142 struct property
*prop
, new_prop
;
1145 gdb_assert (key
!= NULL
&& value
!= NULL
);
1147 for (ix
= 0; VEC_iterate (property_s
, target_desc
->properties
, ix
, prop
);
1149 if (strcmp (prop
->key
, key
) == 0)
1150 internal_error (__FILE__
, __LINE__
,
1151 _("Attempted to add duplicate property \"%s\""), key
);
1153 new_prop
.key
= xstrdup (key
);
1154 new_prop
.value
= xstrdup (value
);
1155 VEC_safe_push (property_s
, target_desc
->properties
, &new_prop
);
1159 set_tdesc_architecture (struct target_desc
*target_desc
,
1160 const struct bfd_arch_info
*arch
)
1162 target_desc
->arch
= arch
;
1166 static struct cmd_list_element
*tdesc_set_cmdlist
, *tdesc_show_cmdlist
;
1167 static struct cmd_list_element
*tdesc_unset_cmdlist
;
1169 /* Helper functions for the CLI commands. */
1172 set_tdesc_cmd (char *args
, int from_tty
)
1174 help_list (tdesc_set_cmdlist
, "set tdesc ", -1, gdb_stdout
);
1178 show_tdesc_cmd (char *args
, int from_tty
)
1180 cmd_show_list (tdesc_show_cmdlist
, from_tty
, "");
1184 unset_tdesc_cmd (char *args
, int from_tty
)
1186 help_list (tdesc_unset_cmdlist
, "unset tdesc ", -1, gdb_stdout
);
1190 set_tdesc_filename_cmd (char *args
, int from_tty
,
1191 struct cmd_list_element
*c
)
1193 target_clear_description ();
1194 target_find_description ();
1198 show_tdesc_filename_cmd (struct ui_file
*file
, int from_tty
,
1199 struct cmd_list_element
*c
,
1202 if (value
!= NULL
&& *value
!= '\0')
1203 printf_filtered (_("\
1204 The target description will be read from \"%s\".\n"),
1207 printf_filtered (_("\
1208 The target description will be read from the target.\n"));
1212 unset_tdesc_filename_cmd (char *args
, int from_tty
)
1214 xfree (target_description_filename
);
1215 target_description_filename
= NULL
;
1216 target_clear_description ();
1217 target_find_description ();
1221 maint_print_c_tdesc_cmd (char *args
, int from_tty
)
1223 const struct target_desc
*tdesc
;
1224 const char *filename
, *inp
;
1225 char *function
, *outp
;
1226 struct property
*prop
;
1227 struct tdesc_feature
*feature
;
1228 struct tdesc_reg
*reg
;
1229 struct tdesc_type
*type
;
1230 struct tdesc_type_field
*f
;
1233 /* Use the global target-supplied description, not the current
1234 architecture's. This lets a GDB for one architecture generate C
1235 for another architecture's description, even though the gdbarch
1236 initialization code will reject the new description. */
1237 tdesc
= current_target_desc
;
1239 error (_("There is no target description to print."));
1241 if (target_description_filename
== NULL
)
1242 error (_("The current target description did not come from an XML file."));
1244 filename
= lbasename (target_description_filename
);
1245 function
= alloca (strlen (filename
) + 1);
1246 for (inp
= filename
, outp
= function
; *inp
!= '\0'; inp
++)
1249 else if (*inp
== '-')
1255 /* Standard boilerplate. */
1256 printf_unfiltered ("/* THIS FILE IS GENERATED. Original: %s */\n\n",
1258 printf_unfiltered ("#include \"defs.h\"\n");
1259 printf_unfiltered ("#include \"target-descriptions.h\"\n");
1260 printf_unfiltered ("\n");
1262 printf_unfiltered ("struct target_desc *tdesc_%s;\n", function
);
1263 printf_unfiltered ("static void\n");
1264 printf_unfiltered ("initialize_tdesc_%s (void)\n", function
);
1265 printf_unfiltered ("{\n");
1267 (" struct target_desc *result = allocate_target_description ();\n");
1268 printf_unfiltered (" struct tdesc_feature *feature;\n");
1269 printf_unfiltered (" struct tdesc_type *field_type, *type;\n");
1270 printf_unfiltered ("\n");
1272 if (tdesc_architecture (tdesc
) != NULL
)
1275 (" set_tdesc_architecture (result, bfd_scan_arch (\"%s\"));\n",
1276 tdesc_architecture (tdesc
)->printable_name
);
1277 printf_unfiltered ("\n");
1280 for (ix
= 0; VEC_iterate (property_s
, tdesc
->properties
, ix
, prop
);
1283 printf_unfiltered (" set_tdesc_property (result, \"%s\", \"%s\");\n",
1284 prop
->key
, prop
->value
);
1288 VEC_iterate (tdesc_feature_p
, tdesc
->features
, ix
, feature
);
1291 printf_unfiltered (" feature = tdesc_create_feature (result, \"%s\");\n",
1295 VEC_iterate (tdesc_type_p
, feature
->types
, ix2
, type
);
1300 case TDESC_TYPE_VECTOR
:
1302 (" field_type = tdesc_named_type (feature, \"%s\");\n",
1303 type
->u
.v
.type
->name
);
1305 (" tdesc_create_vector (feature, \"%s\", field_type, %d);\n",
1306 type
->name
, type
->u
.v
.count
);
1308 case TDESC_TYPE_UNION
:
1310 (" type = tdesc_create_union (feature, \"%s\");\n",
1313 VEC_iterate (tdesc_type_field
, type
->u
.u
.fields
, ix3
, f
);
1317 (" field_type = tdesc_named_type (feature, \"%s\");\n",
1320 (" tdesc_add_field (type, \"%s\", field_type);\n",
1325 error (_("C output is not supported type \"%s\"."), type
->name
);
1327 printf_unfiltered ("\n");
1331 VEC_iterate (tdesc_reg_p
, feature
->registers
, ix2
, reg
);
1334 printf_unfiltered (" tdesc_create_reg (feature, \"%s\", %ld, %d, ",
1335 reg
->name
, reg
->target_regnum
, reg
->save_restore
);
1337 printf_unfiltered ("\"%s\", ", reg
->group
);
1339 printf_unfiltered ("NULL, ");
1340 printf_unfiltered ("%d, \"%s\");\n", reg
->bitsize
, reg
->type
);
1343 printf_unfiltered ("\n");
1346 printf_unfiltered (" tdesc_%s = result;\n", function
);
1347 printf_unfiltered ("}\n");
1350 /* Provide a prototype to silence -Wmissing-prototypes. */
1351 extern initialize_file_ftype _initialize_target_descriptions
;
1354 _initialize_target_descriptions (void)
1356 tdesc_data
= gdbarch_data_register_pre_init (tdesc_data_init
);
1358 add_prefix_cmd ("tdesc", class_maintenance
, set_tdesc_cmd
, _("\
1359 Set target description specific variables."),
1360 &tdesc_set_cmdlist
, "set tdesc ",
1361 0 /* allow-unknown */, &setlist
);
1362 add_prefix_cmd ("tdesc", class_maintenance
, show_tdesc_cmd
, _("\
1363 Show target description specific variables."),
1364 &tdesc_show_cmdlist
, "show tdesc ",
1365 0 /* allow-unknown */, &showlist
);
1366 add_prefix_cmd ("tdesc", class_maintenance
, unset_tdesc_cmd
, _("\
1367 Unset target description specific variables."),
1368 &tdesc_unset_cmdlist
, "unset tdesc ",
1369 0 /* allow-unknown */, &unsetlist
);
1371 add_setshow_filename_cmd ("filename", class_obscure
,
1372 &target_description_filename
,
1374 Set the file to read for an XML target description"), _("\
1375 Show the file to read for an XML target description"), _("\
1376 When set, GDB will read the target description from a local\n\
1377 file instead of querying the remote target."),
1378 set_tdesc_filename_cmd
,
1379 show_tdesc_filename_cmd
,
1380 &tdesc_set_cmdlist
, &tdesc_show_cmdlist
);
1382 add_cmd ("filename", class_obscure
, unset_tdesc_filename_cmd
, _("\
1383 Unset the file to read for an XML target description. When unset,\n\
1384 GDB will read the description from the target."),
1385 &tdesc_unset_cmdlist
);
1387 add_cmd ("c-tdesc", class_maintenance
, maint_print_c_tdesc_cmd
, _("\
1388 Print the current target description as a C source file."),
1389 &maintenanceprintlist
);