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_int8
;
457 case TDESC_TYPE_INT16
:
458 return builtin_type_int16
;
460 case TDESC_TYPE_INT32
:
461 return builtin_type_int32
;
463 case TDESC_TYPE_INT64
:
464 return builtin_type_int64
;
466 case TDESC_TYPE_INT128
:
467 return builtin_type_int128
;
469 case TDESC_TYPE_UINT8
:
470 return builtin_type_uint8
;
472 case TDESC_TYPE_UINT16
:
473 return builtin_type_uint16
;
475 case TDESC_TYPE_UINT32
:
476 return builtin_type_uint32
;
478 case TDESC_TYPE_UINT64
:
479 return builtin_type_uint64
;
481 case TDESC_TYPE_UINT128
:
482 return builtin_type_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 builtin_type_ieee_single
;
493 case TDESC_TYPE_IEEE_DOUBLE
:
494 return builtin_type_ieee_double
;
496 case TDESC_TYPE_ARM_FPA_EXT
:
497 return builtin_type_arm_ext
;
499 /* Types defined by a target feature. */
500 case TDESC_TYPE_VECTOR
:
502 struct type
*type
, *field_type
;
504 field_type
= tdesc_gdb_type (gdbarch
, tdesc_type
->u
.v
.type
);
505 type
= init_vector_type (field_type
, tdesc_type
->u
.v
.count
);
506 TYPE_NAME (type
) = xstrdup (tdesc_type
->name
);
511 case TDESC_TYPE_UNION
:
513 struct type
*type
, *field_type
;
514 struct tdesc_type_field
*f
;
517 type
= init_composite_type (NULL
, TYPE_CODE_UNION
);
518 TYPE_NAME (type
) = xstrdup (tdesc_type
->name
);
521 VEC_iterate (tdesc_type_field
, tdesc_type
->u
.u
.fields
, ix
, f
);
524 field_type
= tdesc_gdb_type (gdbarch
, f
->type
);
525 append_composite_type_field (type
, xstrdup (f
->name
), field_type
);
527 /* If any of the children of this union are vectors, flag the
528 union as a vector also. This allows e.g. a union of two
529 vector types to show up automatically in "info vector". */
530 if (TYPE_VECTOR (field_type
))
531 TYPE_VECTOR (type
) = 1;
538 internal_error (__FILE__
, __LINE__
,
539 "Type \"%s\" has an unknown kind %d",
540 tdesc_type
->name
, tdesc_type
->kind
);
544 /* Support for registers from target descriptions. */
546 /* Construct the per-gdbarch data. */
549 tdesc_data_init (struct obstack
*obstack
)
551 struct tdesc_arch_data
*data
;
553 data
= OBSTACK_ZALLOC (obstack
, struct tdesc_arch_data
);
557 /* Similar, but for the temporary copy used during architecture
560 struct tdesc_arch_data
*
561 tdesc_data_alloc (void)
563 return XZALLOC (struct tdesc_arch_data
);
566 /* Free something allocated by tdesc_data_alloc, if it is not going
567 to be used (for instance if it was unsuitable for the
571 tdesc_data_cleanup (void *data_untyped
)
573 struct tdesc_arch_data
*data
= data_untyped
;
575 VEC_free (tdesc_arch_reg
, data
->arch_regs
);
579 /* Search FEATURE for a register named NAME. */
581 static struct tdesc_reg
*
582 tdesc_find_register_early (const struct tdesc_feature
*feature
,
586 struct tdesc_reg
*reg
;
589 VEC_iterate (tdesc_reg_p
, feature
->registers
, ixr
, reg
);
591 if (strcasecmp (reg
->name
, name
) == 0)
597 /* Search FEATURE for a register named NAME. Assign REGNO to it. */
600 tdesc_numbered_register (const struct tdesc_feature
*feature
,
601 struct tdesc_arch_data
*data
,
602 int regno
, const char *name
)
604 struct tdesc_arch_reg arch_reg
= { 0 };
605 struct tdesc_reg
*reg
= tdesc_find_register_early (feature
, name
);
610 /* Make sure the vector includes a REGNO'th element. */
611 while (regno
>= VEC_length (tdesc_arch_reg
, data
->arch_regs
))
612 VEC_safe_push (tdesc_arch_reg
, data
->arch_regs
, &arch_reg
);
615 VEC_replace (tdesc_arch_reg
, data
->arch_regs
, regno
, &arch_reg
);
619 /* Search FEATURE for a register whose name is in NAMES and assign
623 tdesc_numbered_register_choices (const struct tdesc_feature
*feature
,
624 struct tdesc_arch_data
*data
,
625 int regno
, const char *const names
[])
629 for (i
= 0; names
[i
] != NULL
; i
++)
630 if (tdesc_numbered_register (feature
, data
, regno
, names
[i
]))
636 /* Search FEATURE for a register named NAME, and return its size in
637 bits. The register must exist. */
640 tdesc_register_size (const struct tdesc_feature
*feature
,
643 struct tdesc_reg
*reg
= tdesc_find_register_early (feature
, name
);
645 gdb_assert (reg
!= NULL
);
649 /* Look up a register by its GDB internal register number. */
651 static struct tdesc_arch_reg
*
652 tdesc_find_arch_register (struct gdbarch
*gdbarch
, int regno
)
654 struct tdesc_arch_reg
*reg
;
655 struct tdesc_arch_data
*data
;
657 data
= gdbarch_data (gdbarch
, tdesc_data
);
658 if (regno
< VEC_length (tdesc_arch_reg
, data
->arch_regs
))
659 return VEC_index (tdesc_arch_reg
, data
->arch_regs
, regno
);
664 static struct tdesc_reg
*
665 tdesc_find_register (struct gdbarch
*gdbarch
, int regno
)
667 struct tdesc_arch_reg
*reg
= tdesc_find_arch_register (gdbarch
, regno
);
668 return reg
? reg
->reg
: NULL
;
671 /* Return the name of register REGNO, from the target description or
672 from an architecture-provided pseudo_register_name method. */
675 tdesc_register_name (struct gdbarch
*gdbarch
, int regno
)
677 struct tdesc_reg
*reg
= tdesc_find_register (gdbarch
, regno
);
678 int num_regs
= gdbarch_num_regs (gdbarch
);
679 int num_pseudo_regs
= gdbarch_num_pseudo_regs (gdbarch
);
684 if (regno
>= num_regs
&& regno
< num_regs
+ num_pseudo_regs
)
686 struct tdesc_arch_data
*data
= gdbarch_data (gdbarch
, tdesc_data
);
687 gdb_assert (data
->pseudo_register_name
!= NULL
);
688 return data
->pseudo_register_name (gdbarch
, regno
);
695 tdesc_register_type (struct gdbarch
*gdbarch
, int regno
)
697 struct tdesc_arch_reg
*arch_reg
= tdesc_find_arch_register (gdbarch
, regno
);
698 struct tdesc_reg
*reg
= arch_reg
? arch_reg
->reg
: NULL
;
699 int num_regs
= gdbarch_num_regs (gdbarch
);
700 int num_pseudo_regs
= gdbarch_num_pseudo_regs (gdbarch
);
702 if (reg
== NULL
&& regno
>= num_regs
&& regno
< num_regs
+ num_pseudo_regs
)
704 struct tdesc_arch_data
*data
= gdbarch_data (gdbarch
, tdesc_data
);
705 gdb_assert (data
->pseudo_register_type
!= NULL
);
706 return data
->pseudo_register_type (gdbarch
, regno
);
710 /* Return "int0_t", since "void" has a misleading size of one. */
711 return builtin_type_int0
;
713 if (arch_reg
->type
== NULL
)
715 /* First check for a predefined or target defined type. */
717 arch_reg
->type
= tdesc_gdb_type (gdbarch
, reg
->tdesc_type
);
719 /* Next try size-sensitive type shortcuts. */
720 else if (strcmp (reg
->type
, "float") == 0)
722 if (reg
->bitsize
== gdbarch_float_bit (gdbarch
))
723 arch_reg
->type
= builtin_type (gdbarch
)->builtin_float
;
724 else if (reg
->bitsize
== gdbarch_double_bit (gdbarch
))
725 arch_reg
->type
= builtin_type (gdbarch
)->builtin_double
;
726 else if (reg
->bitsize
== gdbarch_long_double_bit (gdbarch
))
727 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long_double
;
730 warning (_("Register \"%s\" has an unsupported size (%d bits)"),
731 reg
->name
, reg
->bitsize
);
732 arch_reg
->type
= builtin_type (gdbarch
)->builtin_double
;
735 else if (strcmp (reg
->type
, "int") == 0)
737 if (reg
->bitsize
== gdbarch_long_bit (gdbarch
))
738 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long
;
739 else if (reg
->bitsize
== TARGET_CHAR_BIT
)
740 arch_reg
->type
= builtin_type (gdbarch
)->builtin_char
;
741 else if (reg
->bitsize
== gdbarch_short_bit (gdbarch
))
742 arch_reg
->type
= builtin_type (gdbarch
)->builtin_short
;
743 else if (reg
->bitsize
== gdbarch_int_bit (gdbarch
))
744 arch_reg
->type
= builtin_type (gdbarch
)->builtin_int
;
745 else if (reg
->bitsize
== gdbarch_long_long_bit (gdbarch
))
746 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long_long
;
747 else if (reg
->bitsize
== gdbarch_ptr_bit (gdbarch
))
748 /* A bit desperate by this point... */
749 arch_reg
->type
= builtin_type (gdbarch
)->builtin_data_ptr
;
752 warning (_("Register \"%s\" has an unsupported size (%d bits)"),
753 reg
->name
, reg
->bitsize
);
754 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long
;
758 if (arch_reg
->type
== NULL
)
759 internal_error (__FILE__
, __LINE__
,
760 "Register \"%s\" has an unknown type \"%s\"",
761 reg
->name
, reg
->type
);
764 return arch_reg
->type
;
768 tdesc_remote_register_number (struct gdbarch
*gdbarch
, int regno
)
770 struct tdesc_reg
*reg
= tdesc_find_register (gdbarch
, regno
);
773 return reg
->target_regnum
;
778 /* Check whether REGNUM is a member of REGGROUP. Registers from the
779 target description may be classified as general, float, or vector.
780 Unlike a gdbarch register_reggroup_p method, this function will
781 return -1 if it does not know; the caller should handle registers
782 with no specified group.
784 Arbitrary strings (other than "general", "float", and "vector")
785 from the description are not used; they cause the register to be
786 displayed in "info all-registers" but excluded from "info
787 registers" et al. The names of containing features are also not
788 used. This might be extended to display registers in some more
791 The save-restore flag is also implemented here. */
794 tdesc_register_in_reggroup_p (struct gdbarch
*gdbarch
, int regno
,
795 struct reggroup
*reggroup
)
797 struct tdesc_reg
*reg
= tdesc_find_register (gdbarch
, regno
);
799 if (reg
!= NULL
&& reg
->group
!= NULL
)
801 int general_p
= 0, float_p
= 0, vector_p
= 0;
803 if (strcmp (reg
->group
, "general") == 0)
805 else if (strcmp (reg
->group
, "float") == 0)
807 else if (strcmp (reg
->group
, "vector") == 0)
810 if (reggroup
== float_reggroup
)
813 if (reggroup
== vector_reggroup
)
816 if (reggroup
== general_reggroup
)
821 && (reggroup
== save_reggroup
|| reggroup
== restore_reggroup
))
822 return reg
->save_restore
;
827 /* Check whether REGNUM is a member of REGGROUP. Registers with no
828 group specified go to the default reggroup function and are handled
832 tdesc_register_reggroup_p (struct gdbarch
*gdbarch
, int regno
,
833 struct reggroup
*reggroup
)
835 int num_regs
= gdbarch_num_regs (gdbarch
);
836 int num_pseudo_regs
= gdbarch_num_pseudo_regs (gdbarch
);
839 if (regno
>= num_regs
&& regno
< num_regs
+ num_pseudo_regs
)
841 struct tdesc_arch_data
*data
= gdbarch_data (gdbarch
, tdesc_data
);
842 gdb_assert (data
->pseudo_register_reggroup_p
!= NULL
);
843 return data
->pseudo_register_reggroup_p (gdbarch
, regno
, reggroup
);
846 ret
= tdesc_register_in_reggroup_p (gdbarch
, regno
, reggroup
);
850 return default_register_reggroup_p (gdbarch
, regno
, reggroup
);
853 /* Record architecture-specific functions to call for pseudo-register
857 set_tdesc_pseudo_register_name (struct gdbarch
*gdbarch
,
858 gdbarch_register_name_ftype
*pseudo_name
)
860 struct tdesc_arch_data
*data
= gdbarch_data (gdbarch
, tdesc_data
);
862 data
->pseudo_register_name
= pseudo_name
;
866 set_tdesc_pseudo_register_type (struct gdbarch
*gdbarch
,
867 gdbarch_register_type_ftype
*pseudo_type
)
869 struct tdesc_arch_data
*data
= gdbarch_data (gdbarch
, tdesc_data
);
871 data
->pseudo_register_type
= pseudo_type
;
875 set_tdesc_pseudo_register_reggroup_p
876 (struct gdbarch
*gdbarch
,
877 gdbarch_register_reggroup_p_ftype
*pseudo_reggroup_p
)
879 struct tdesc_arch_data
*data
= gdbarch_data (gdbarch
, tdesc_data
);
881 data
->pseudo_register_reggroup_p
= pseudo_reggroup_p
;
884 /* Update GDBARCH to use the target description for registers. */
887 tdesc_use_registers (struct gdbarch
*gdbarch
,
888 const struct target_desc
*target_desc
,
889 struct tdesc_arch_data
*early_data
)
891 int num_regs
= gdbarch_num_regs (gdbarch
);
893 struct tdesc_feature
*feature
;
894 struct tdesc_reg
*reg
;
895 struct tdesc_arch_data
*data
;
896 struct tdesc_arch_reg
*arch_reg
, new_arch_reg
= { 0 };
899 /* We can't use the description for registers if it doesn't describe
900 any. This function should only be called after validating
901 registers, so the caller should know that registers are
903 gdb_assert (tdesc_has_registers (target_desc
));
905 data
= gdbarch_data (gdbarch
, tdesc_data
);
906 data
->arch_regs
= early_data
->arch_regs
;
909 /* Build up a set of all registers, so that we can assign register
910 numbers where needed. The hash table expands as necessary, so
911 the initial size is arbitrary. */
912 reg_hash
= htab_create (37, htab_hash_pointer
, htab_eq_pointer
, NULL
);
914 VEC_iterate (tdesc_feature_p
, target_desc
->features
, ixf
, feature
);
917 VEC_iterate (tdesc_reg_p
, feature
->registers
, ixr
, reg
);
920 void **slot
= htab_find_slot (reg_hash
, reg
, INSERT
);
925 /* Remove any registers which were assigned numbers by the
928 VEC_iterate (tdesc_arch_reg
, data
->arch_regs
, ixr
, arch_reg
);
931 htab_remove_elt (reg_hash
, arch_reg
->reg
);
933 /* Assign numbers to the remaining registers and add them to the
934 list of registers. The new numbers are always above gdbarch_num_regs.
935 Iterate over the features, not the hash table, so that the order
936 matches that in the target description. */
938 gdb_assert (VEC_length (tdesc_arch_reg
, data
->arch_regs
) <= num_regs
);
939 while (VEC_length (tdesc_arch_reg
, data
->arch_regs
) < num_regs
)
940 VEC_safe_push (tdesc_arch_reg
, data
->arch_regs
, &new_arch_reg
);
942 VEC_iterate (tdesc_feature_p
, target_desc
->features
, ixf
, feature
);
945 VEC_iterate (tdesc_reg_p
, feature
->registers
, ixr
, reg
);
947 if (htab_find (reg_hash
, reg
) != NULL
)
949 new_arch_reg
.reg
= reg
;
950 VEC_safe_push (tdesc_arch_reg
, data
->arch_regs
, &new_arch_reg
);
954 htab_delete (reg_hash
);
956 /* Update the architecture. */
957 set_gdbarch_num_regs (gdbarch
, num_regs
);
958 set_gdbarch_register_name (gdbarch
, tdesc_register_name
);
959 set_gdbarch_register_type (gdbarch
, tdesc_register_type
);
960 set_gdbarch_remote_register_number (gdbarch
,
961 tdesc_remote_register_number
);
962 set_gdbarch_register_reggroup_p (gdbarch
, tdesc_register_reggroup_p
);
966 /* Methods for constructing a target description. */
969 tdesc_free_reg (struct tdesc_reg
*reg
)
978 tdesc_create_reg (struct tdesc_feature
*feature
, const char *name
,
979 int regnum
, int save_restore
, const char *group
,
980 int bitsize
, const char *type
)
982 struct tdesc_reg
*reg
= XZALLOC (struct tdesc_reg
);
984 reg
->name
= xstrdup (name
);
985 reg
->target_regnum
= regnum
;
986 reg
->save_restore
= save_restore
;
987 reg
->group
= group
? xstrdup (group
) : NULL
;
988 reg
->bitsize
= bitsize
;
989 reg
->type
= type
? xstrdup (type
) : xstrdup ("<unknown>");
991 /* If the register's type is target-defined, look it up now. We may not
992 have easy access to the containing feature when we want it later. */
993 reg
->tdesc_type
= tdesc_named_type (feature
, reg
->type
);
995 VEC_safe_push (tdesc_reg_p
, feature
->registers
, reg
);
999 tdesc_free_type (struct tdesc_type
*type
)
1004 case TDESC_TYPE_UNION
:
1006 struct tdesc_type_field
*f
;
1010 VEC_iterate (tdesc_type_field
, type
->u
.u
.fields
, ix
, f
);
1014 VEC_free (tdesc_type_field
, type
->u
.u
.fields
);
1027 tdesc_create_vector (struct tdesc_feature
*feature
, const char *name
,
1028 struct tdesc_type
*field_type
, int count
)
1030 struct tdesc_type
*type
= XZALLOC (struct tdesc_type
);
1032 type
->name
= xstrdup (name
);
1033 type
->kind
= TDESC_TYPE_VECTOR
;
1034 type
->u
.v
.type
= field_type
;
1035 type
->u
.v
.count
= count
;
1037 VEC_safe_push (tdesc_type_p
, feature
->types
, type
);
1042 tdesc_create_union (struct tdesc_feature
*feature
, const char *name
)
1044 struct tdesc_type
*type
= XZALLOC (struct tdesc_type
);
1046 type
->name
= xstrdup (name
);
1047 type
->kind
= TDESC_TYPE_UNION
;
1049 VEC_safe_push (tdesc_type_p
, feature
->types
, type
);
1054 tdesc_add_field (struct tdesc_type
*type
, const char *field_name
,
1055 struct tdesc_type
*field_type
)
1057 struct tdesc_type_field f
= { 0 };
1059 gdb_assert (type
->kind
== TDESC_TYPE_UNION
);
1061 f
.name
= xstrdup (field_name
);
1062 f
.type
= field_type
;
1064 VEC_safe_push (tdesc_type_field
, type
->u
.u
.fields
, &f
);
1068 tdesc_free_feature (struct tdesc_feature
*feature
)
1070 struct tdesc_reg
*reg
;
1071 struct tdesc_type
*type
;
1074 for (ix
= 0; VEC_iterate (tdesc_reg_p
, feature
->registers
, ix
, reg
); ix
++)
1075 tdesc_free_reg (reg
);
1076 VEC_free (tdesc_reg_p
, feature
->registers
);
1078 for (ix
= 0; VEC_iterate (tdesc_type_p
, feature
->types
, ix
, type
); ix
++)
1079 tdesc_free_type (type
);
1080 VEC_free (tdesc_type_p
, feature
->types
);
1082 xfree (feature
->name
);
1086 struct tdesc_feature
*
1087 tdesc_create_feature (struct target_desc
*tdesc
, const char *name
)
1089 struct tdesc_feature
*new_feature
= XZALLOC (struct tdesc_feature
);
1091 new_feature
->name
= xstrdup (name
);
1093 VEC_safe_push (tdesc_feature_p
, tdesc
->features
, new_feature
);
1097 struct target_desc
*
1098 allocate_target_description (void)
1100 return XZALLOC (struct target_desc
);
1104 free_target_description (void *arg
)
1106 struct target_desc
*target_desc
= arg
;
1107 struct tdesc_feature
*feature
;
1108 struct property
*prop
;
1112 VEC_iterate (tdesc_feature_p
, target_desc
->features
, ix
, feature
);
1114 tdesc_free_feature (feature
);
1115 VEC_free (tdesc_feature_p
, target_desc
->features
);
1118 VEC_iterate (property_s
, target_desc
->properties
, ix
, prop
);
1122 xfree (prop
->value
);
1124 VEC_free (property_s
, target_desc
->properties
);
1126 xfree (target_desc
);
1130 make_cleanup_free_target_description (struct target_desc
*target_desc
)
1132 return make_cleanup (free_target_description
, target_desc
);
1136 set_tdesc_property (struct target_desc
*target_desc
,
1137 const char *key
, const char *value
)
1139 struct property
*prop
, new_prop
;
1142 gdb_assert (key
!= NULL
&& value
!= NULL
);
1144 for (ix
= 0; VEC_iterate (property_s
, target_desc
->properties
, ix
, prop
);
1146 if (strcmp (prop
->key
, key
) == 0)
1147 internal_error (__FILE__
, __LINE__
,
1148 _("Attempted to add duplicate property \"%s\""), key
);
1150 new_prop
.key
= xstrdup (key
);
1151 new_prop
.value
= xstrdup (value
);
1152 VEC_safe_push (property_s
, target_desc
->properties
, &new_prop
);
1156 set_tdesc_architecture (struct target_desc
*target_desc
,
1157 const struct bfd_arch_info
*arch
)
1159 target_desc
->arch
= arch
;
1163 static struct cmd_list_element
*tdesc_set_cmdlist
, *tdesc_show_cmdlist
;
1164 static struct cmd_list_element
*tdesc_unset_cmdlist
;
1166 /* Helper functions for the CLI commands. */
1169 set_tdesc_cmd (char *args
, int from_tty
)
1171 help_list (tdesc_set_cmdlist
, "set tdesc ", -1, gdb_stdout
);
1175 show_tdesc_cmd (char *args
, int from_tty
)
1177 cmd_show_list (tdesc_show_cmdlist
, from_tty
, "");
1181 unset_tdesc_cmd (char *args
, int from_tty
)
1183 help_list (tdesc_unset_cmdlist
, "unset tdesc ", -1, gdb_stdout
);
1187 set_tdesc_filename_cmd (char *args
, int from_tty
,
1188 struct cmd_list_element
*c
)
1190 target_clear_description ();
1191 target_find_description ();
1195 show_tdesc_filename_cmd (struct ui_file
*file
, int from_tty
,
1196 struct cmd_list_element
*c
,
1199 if (value
!= NULL
&& *value
!= '\0')
1200 printf_filtered (_("\
1201 The target description will be read from \"%s\".\n"),
1204 printf_filtered (_("\
1205 The target description will be read from the target.\n"));
1209 unset_tdesc_filename_cmd (char *args
, int from_tty
)
1211 xfree (target_description_filename
);
1212 target_description_filename
= NULL
;
1213 target_clear_description ();
1214 target_find_description ();
1218 maint_print_c_tdesc_cmd (char *args
, int from_tty
)
1220 const struct target_desc
*tdesc
;
1221 const char *filename
, *inp
;
1222 char *function
, *outp
;
1223 struct property
*prop
;
1224 struct tdesc_feature
*feature
;
1225 struct tdesc_reg
*reg
;
1226 struct tdesc_type
*type
;
1227 struct tdesc_type_field
*f
;
1230 /* Use the global target-supplied description, not the current
1231 architecture's. This lets a GDB for one architecture generate C
1232 for another architecture's description, even though the gdbarch
1233 initialization code will reject the new description. */
1234 tdesc
= current_target_desc
;
1236 error (_("There is no target description to print."));
1238 if (target_description_filename
== NULL
)
1239 error (_("The current target description did not come from an XML file."));
1241 filename
= lbasename (target_description_filename
);
1242 function
= alloca (strlen (filename
) + 1);
1243 for (inp
= filename
, outp
= function
; *inp
!= '\0'; inp
++)
1246 else if (*inp
== '-')
1252 /* Standard boilerplate. */
1253 printf_unfiltered ("/* THIS FILE IS GENERATED. Original: %s */\n\n",
1255 printf_unfiltered ("#include \"defs.h\"\n");
1256 printf_unfiltered ("#include \"target-descriptions.h\"\n");
1257 printf_unfiltered ("\n");
1259 printf_unfiltered ("struct target_desc *tdesc_%s;\n", function
);
1260 printf_unfiltered ("static void\n");
1261 printf_unfiltered ("initialize_tdesc_%s (void)\n", function
);
1262 printf_unfiltered ("{\n");
1264 (" struct target_desc *result = allocate_target_description ();\n");
1265 printf_unfiltered (" struct tdesc_feature *feature;\n");
1266 printf_unfiltered (" struct tdesc_type *field_type, *type;\n");
1267 printf_unfiltered ("\n");
1269 if (tdesc_architecture (tdesc
) != NULL
)
1272 (" set_tdesc_architecture (result, bfd_scan_arch (\"%s\"));\n",
1273 tdesc_architecture (tdesc
)->printable_name
);
1274 printf_unfiltered ("\n");
1277 for (ix
= 0; VEC_iterate (property_s
, tdesc
->properties
, ix
, prop
);
1280 printf_unfiltered (" set_tdesc_property (result, \"%s\", \"%s\");\n",
1281 prop
->key
, prop
->value
);
1285 VEC_iterate (tdesc_feature_p
, tdesc
->features
, ix
, feature
);
1288 printf_unfiltered (" feature = tdesc_create_feature (result, \"%s\");\n",
1292 VEC_iterate (tdesc_type_p
, feature
->types
, ix2
, type
);
1297 case TDESC_TYPE_VECTOR
:
1299 (" field_type = tdesc_named_type (feature, \"%s\");\n",
1300 type
->u
.v
.type
->name
);
1302 (" tdesc_create_vector (feature, \"%s\", field_type, %d);\n",
1303 type
->name
, type
->u
.v
.count
);
1305 case TDESC_TYPE_UNION
:
1307 (" type = tdesc_create_union (feature, \"%s\");\n",
1310 VEC_iterate (tdesc_type_field
, type
->u
.u
.fields
, ix3
, f
);
1314 (" field_type = tdesc_named_type (feature, \"%s\");\n",
1317 (" tdesc_add_field (type, \"%s\", field_type);\n",
1322 error (_("C output is not supported type \"%s\"."), type
->name
);
1324 printf_unfiltered ("\n");
1328 VEC_iterate (tdesc_reg_p
, feature
->registers
, ix2
, reg
);
1331 printf_unfiltered (" tdesc_create_reg (feature, \"%s\", %ld, %d, ",
1332 reg
->name
, reg
->target_regnum
, reg
->save_restore
);
1334 printf_unfiltered ("\"%s\", ", reg
->group
);
1336 printf_unfiltered ("NULL, ");
1337 printf_unfiltered ("%d, \"%s\");\n", reg
->bitsize
, reg
->type
);
1340 printf_unfiltered ("\n");
1343 printf_unfiltered (" tdesc_%s = result;\n", function
);
1344 printf_unfiltered ("}\n");
1347 /* Provide a prototype to silence -Wmissing-prototypes. */
1348 extern initialize_file_ftype _initialize_target_descriptions
;
1351 _initialize_target_descriptions (void)
1353 tdesc_data
= gdbarch_data_register_pre_init (tdesc_data_init
);
1355 add_prefix_cmd ("tdesc", class_maintenance
, set_tdesc_cmd
, _("\
1356 Set target description specific variables."),
1357 &tdesc_set_cmdlist
, "set tdesc ",
1358 0 /* allow-unknown */, &setlist
);
1359 add_prefix_cmd ("tdesc", class_maintenance
, show_tdesc_cmd
, _("\
1360 Show target description specific variables."),
1361 &tdesc_show_cmdlist
, "show tdesc ",
1362 0 /* allow-unknown */, &showlist
);
1363 add_prefix_cmd ("tdesc", class_maintenance
, unset_tdesc_cmd
, _("\
1364 Unset target description specific variables."),
1365 &tdesc_unset_cmdlist
, "unset tdesc ",
1366 0 /* allow-unknown */, &unsetlist
);
1368 add_setshow_filename_cmd ("filename", class_obscure
,
1369 &target_description_filename
,
1371 Set the file to read for an XML target description"), _("\
1372 Show the file to read for an XML target description"), _("\
1373 When set, GDB will read the target description from a local\n\
1374 file instead of querying the remote target."),
1375 set_tdesc_filename_cmd
,
1376 show_tdesc_filename_cmd
,
1377 &tdesc_set_cmdlist
, &tdesc_show_cmdlist
);
1379 add_cmd ("filename", class_obscure
, unset_tdesc_filename_cmd
, _("\
1380 Unset the file to read for an XML target description. When unset,\n\
1381 GDB will read the description from the target."),
1382 &tdesc_unset_cmdlist
);
1384 add_cmd ("c-tdesc", class_maintenance
, maint_print_c_tdesc_cmd
, _("\
1385 Print the current target description as a C source file."),
1386 &maintenanceprintlist
);