1 /* Target description support for GDB.
3 Copyright (C) 2006-2016 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"
34 #include "gdb_obstack.h"
40 typedef struct property
45 DEF_VEC_O(property_s
);
47 /* An individual register from a target description. */
49 typedef struct tdesc_reg
51 /* The name of this register. In standard features, it may be
52 recognized by the architecture support code, or it may be purely
56 /* The register number used by this target to refer to this
57 register. This is used for remote p/P packets and to determine
58 the ordering of registers in the remote g/G packets. */
61 /* If this flag is set, GDB should save and restore this register
62 around calls to an inferior function. */
65 /* The name of the register group containing this register, or NULL
66 if the group should be automatically determined from the
67 register's type. If this is "general", "float", or "vector", the
68 corresponding "info" command should display this register's
69 value. It can be an arbitrary string, but should be limited to
70 alphanumeric characters and internal hyphens. Currently other
71 strings are ignored (treated as NULL). */
74 /* The size of the register, in bits. */
77 /* The type of the register. This string corresponds to either
78 a named type from the target description or a predefined
82 /* The target-described type corresponding to TYPE, if found. */
83 struct tdesc_type
*tdesc_type
;
85 DEF_VEC_P(tdesc_reg_p
);
87 /* A named type from a target description. */
89 typedef struct tdesc_type_field
92 struct tdesc_type
*type
;
95 DEF_VEC_O(tdesc_type_field
);
97 typedef struct tdesc_type_flag
102 DEF_VEC_O(tdesc_type_flag
);
106 /* Predefined types. */
119 TDESC_TYPE_IEEE_SINGLE
,
120 TDESC_TYPE_IEEE_DOUBLE
,
121 TDESC_TYPE_ARM_FPA_EXT
,
124 /* Types defined by a target feature. */
131 typedef struct tdesc_type
133 /* The name of this type. */
136 /* Identify the kind of this type. */
137 enum tdesc_type_kind kind
;
139 /* Kind-specific data. */
145 struct tdesc_type
*type
;
149 /* Struct or union type. */
152 VEC(tdesc_type_field
) *fields
;
159 VEC(tdesc_type_flag
) *flags
;
164 DEF_VEC_P(tdesc_type_p
);
166 /* A feature from a target description. Each feature is a collection
167 of other elements, e.g. registers and types. */
169 typedef struct tdesc_feature
171 /* The name of this feature. It may be recognized by the architecture
175 /* The registers associated with this feature. */
176 VEC(tdesc_reg_p
) *registers
;
178 /* The types associated with this feature. */
179 VEC(tdesc_type_p
) *types
;
181 DEF_VEC_P(tdesc_feature_p
);
183 /* A compatible architecture from a target description. */
184 typedef const struct bfd_arch_info
*arch_p
;
187 /* A target description. */
191 /* The architecture reported by the target, if any. */
192 const struct bfd_arch_info
*arch
;
194 /* The osabi reported by the target, if any; GDB_OSABI_UNKNOWN
196 enum gdb_osabi osabi
;
198 /* The list of compatible architectures reported by the target. */
199 VEC(arch_p
) *compatible
;
201 /* Any architecture-specific properties specified by the target. */
202 VEC(property_s
) *properties
;
204 /* The features associated with this target. */
205 VEC(tdesc_feature_p
) *features
;
208 /* Per-architecture data associated with a target description. The
209 target description may be shared by multiple architectures, but
210 this data is private to one gdbarch. */
212 typedef struct tdesc_arch_reg
214 struct tdesc_reg
*reg
;
217 DEF_VEC_O(tdesc_arch_reg
);
219 struct tdesc_arch_data
221 /* A list of register/type pairs, indexed by GDB's internal register number.
222 During initialization of the gdbarch this list is used to store
223 registers which the architecture assigns a fixed register number.
224 Registers which are NULL in this array, or off the end, are
225 treated as zero-sized and nameless (i.e. placeholders in the
227 VEC(tdesc_arch_reg
) *arch_regs
;
229 /* Functions which report the register name, type, and reggroups for
231 gdbarch_register_name_ftype
*pseudo_register_name
;
232 gdbarch_register_type_ftype
*pseudo_register_type
;
233 gdbarch_register_reggroup_p_ftype
*pseudo_register_reggroup_p
;
236 /* Info about an inferior's target description. There's one of these
237 for each inferior. */
239 struct target_desc_info
241 /* A flag indicating that a description has already been fetched
242 from the target, so it should not be queried again. */
246 /* The description fetched from the target, or NULL if the target
247 did not supply any description. Only valid when
248 target_desc_fetched is set. Only the description initialization
249 code should access this; normally, the description should be
250 accessed through the gdbarch object. */
252 const struct target_desc
*tdesc
;
254 /* The filename to read a target description from, as set by "set
255 tdesc filename ..." */
260 /* Get the inferior INF's target description info, allocating one on
261 the stop if necessary. */
263 static struct target_desc_info
*
264 get_tdesc_info (struct inferior
*inf
)
266 if (inf
->tdesc_info
== NULL
)
267 inf
->tdesc_info
= XCNEW (struct target_desc_info
);
268 return inf
->tdesc_info
;
271 /* A handle for architecture-specific data associated with the
272 target description (see struct tdesc_arch_data). */
274 static struct gdbarch_data
*tdesc_data
;
276 /* See target-descriptions.h. */
279 target_desc_info_from_user_p (struct target_desc_info
*info
)
281 return info
!= NULL
&& info
->filename
!= NULL
;
284 /* See target-descriptions.h. */
287 copy_inferior_target_desc_info (struct inferior
*destinf
, struct inferior
*srcinf
)
289 struct target_desc_info
*src
= get_tdesc_info (srcinf
);
290 struct target_desc_info
*dest
= get_tdesc_info (destinf
);
292 dest
->fetched
= src
->fetched
;
293 dest
->tdesc
= src
->tdesc
;
294 dest
->filename
= src
->filename
!= NULL
? xstrdup (src
->filename
) : NULL
;
297 /* See target-descriptions.h. */
300 target_desc_info_free (struct target_desc_info
*tdesc_info
)
302 if (tdesc_info
!= NULL
)
304 xfree (tdesc_info
->filename
);
309 /* Convenience helper macros. */
311 #define target_desc_fetched \
312 get_tdesc_info (current_inferior ())->fetched
313 #define current_target_desc \
314 get_tdesc_info (current_inferior ())->tdesc
315 #define target_description_filename \
316 get_tdesc_info (current_inferior ())->filename
318 /* The string manipulated by the "set tdesc filename ..." command. */
320 static char *tdesc_filename_cmd_string
;
322 /* Fetch the current target's description, and switch the current
323 architecture to one which incorporates that description. */
326 target_find_description (void)
328 /* If we've already fetched a description from the target, don't do
329 it again. This allows a target to fetch the description early,
330 during its to_open or to_create_inferior, if it needs extra
331 information about the target to initialize. */
332 if (target_desc_fetched
)
335 /* The current architecture should not have any target description
336 specified. It should have been cleared, e.g. when we
337 disconnected from the previous target. */
338 gdb_assert (gdbarch_target_desc (target_gdbarch ()) == NULL
);
340 /* First try to fetch an XML description from the user-specified
342 current_target_desc
= NULL
;
343 if (target_description_filename
!= NULL
344 && *target_description_filename
!= '\0')
346 = file_read_description_xml (target_description_filename
);
348 /* Next try to read the description from the current target using
350 if (current_target_desc
== NULL
)
351 current_target_desc
= target_read_description_xml (¤t_target
);
353 /* If that failed try a target-specific hook. */
354 if (current_target_desc
== NULL
)
355 current_target_desc
= target_read_description (¤t_target
);
357 /* If a non-NULL description was returned, then update the current
359 if (current_target_desc
)
361 struct gdbarch_info info
;
363 gdbarch_info_init (&info
);
364 info
.target_desc
= current_target_desc
;
365 if (!gdbarch_update_p (info
))
366 warning (_("Architecture rejected target-supplied description"));
369 struct tdesc_arch_data
*data
;
371 data
= ((struct tdesc_arch_data
*)
372 gdbarch_data (target_gdbarch (), tdesc_data
));
373 if (tdesc_has_registers (current_target_desc
)
374 && data
->arch_regs
== NULL
)
375 warning (_("Target-supplied registers are not supported "
376 "by the current architecture"));
380 /* Now that we know this description is usable, record that we
382 target_desc_fetched
= 1;
385 /* Discard any description fetched from the current target, and switch
386 the current architecture to one with no target description. */
389 target_clear_description (void)
391 struct gdbarch_info info
;
393 if (!target_desc_fetched
)
396 target_desc_fetched
= 0;
397 current_target_desc
= NULL
;
399 gdbarch_info_init (&info
);
400 if (!gdbarch_update_p (info
))
401 internal_error (__FILE__
, __LINE__
,
402 _("Could not remove target-supplied description"));
405 /* Return the global current target description. This should only be
406 used by gdbarch initialization code; most access should be through
407 an existing gdbarch. */
409 const struct target_desc
*
410 target_current_description (void)
412 if (target_desc_fetched
)
413 return current_target_desc
;
418 /* Return non-zero if this target description is compatible
419 with the given BFD architecture. */
422 tdesc_compatible_p (const struct target_desc
*target_desc
,
423 const struct bfd_arch_info
*arch
)
425 const struct bfd_arch_info
*compat
;
428 for (ix
= 0; VEC_iterate (arch_p
, target_desc
->compatible
, ix
, compat
);
432 || arch
->compatible (arch
, compat
)
433 || compat
->compatible (compat
, arch
))
441 /* Direct accessors for target descriptions. */
443 /* Return the string value of a property named KEY, or NULL if the
444 property was not specified. */
447 tdesc_property (const struct target_desc
*target_desc
, const char *key
)
449 struct property
*prop
;
452 for (ix
= 0; VEC_iterate (property_s
, target_desc
->properties
, ix
, prop
);
454 if (strcmp (prop
->key
, key
) == 0)
460 /* Return the BFD architecture associated with this target
461 description, or NULL if no architecture was specified. */
463 const struct bfd_arch_info
*
464 tdesc_architecture (const struct target_desc
*target_desc
)
466 return target_desc
->arch
;
469 /* Return the OSABI associated with this target description, or
470 GDB_OSABI_UNKNOWN if no osabi was specified. */
473 tdesc_osabi (const struct target_desc
*target_desc
)
475 return target_desc
->osabi
;
480 /* Return 1 if this target description includes any registers. */
483 tdesc_has_registers (const struct target_desc
*target_desc
)
486 struct tdesc_feature
*feature
;
488 if (target_desc
== NULL
)
492 VEC_iterate (tdesc_feature_p
, target_desc
->features
, ix
, feature
);
494 if (! VEC_empty (tdesc_reg_p
, feature
->registers
))
500 /* Return the feature with the given name, if present, or NULL if
501 the named feature is not found. */
503 const struct tdesc_feature
*
504 tdesc_find_feature (const struct target_desc
*target_desc
,
508 struct tdesc_feature
*feature
;
511 VEC_iterate (tdesc_feature_p
, target_desc
->features
, ix
, feature
);
513 if (strcmp (feature
->name
, name
) == 0)
519 /* Return the name of FEATURE. */
522 tdesc_feature_name (const struct tdesc_feature
*feature
)
524 return feature
->name
;
527 /* Predefined types. */
528 static struct tdesc_type tdesc_predefined_types
[] =
530 { "int8", TDESC_TYPE_INT8
},
531 { "int16", TDESC_TYPE_INT16
},
532 { "int32", TDESC_TYPE_INT32
},
533 { "int64", TDESC_TYPE_INT64
},
534 { "int128", TDESC_TYPE_INT128
},
535 { "uint8", TDESC_TYPE_UINT8
},
536 { "uint16", TDESC_TYPE_UINT16
},
537 { "uint32", TDESC_TYPE_UINT32
},
538 { "uint64", TDESC_TYPE_UINT64
},
539 { "uint128", TDESC_TYPE_UINT128
},
540 { "code_ptr", TDESC_TYPE_CODE_PTR
},
541 { "data_ptr", TDESC_TYPE_DATA_PTR
},
542 { "ieee_single", TDESC_TYPE_IEEE_SINGLE
},
543 { "ieee_double", TDESC_TYPE_IEEE_DOUBLE
},
544 { "arm_fpa_ext", TDESC_TYPE_ARM_FPA_EXT
},
545 { "i387_ext", TDESC_TYPE_I387_EXT
}
548 /* Return the type associated with ID in the context of FEATURE, or
552 tdesc_named_type (const struct tdesc_feature
*feature
, const char *id
)
555 struct tdesc_type
*type
;
557 /* First try target-defined types. */
558 for (ix
= 0; VEC_iterate (tdesc_type_p
, feature
->types
, ix
, type
); ix
++)
559 if (strcmp (type
->name
, id
) == 0)
562 /* Next try the predefined types. */
563 for (ix
= 0; ix
< ARRAY_SIZE (tdesc_predefined_types
); ix
++)
564 if (strcmp (tdesc_predefined_types
[ix
].name
, id
) == 0)
565 return &tdesc_predefined_types
[ix
];
570 /* Lookup type associated with ID. */
573 tdesc_find_type (struct gdbarch
*gdbarch
, const char *id
)
575 struct tdesc_arch_reg
*reg
;
576 struct tdesc_arch_data
*data
;
579 data
= (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
580 num_regs
= VEC_length (tdesc_arch_reg
, data
->arch_regs
);
581 for (i
= 0; i
< num_regs
; i
++)
583 reg
= VEC_index (tdesc_arch_reg
, data
->arch_regs
, i
);
585 && reg
->reg
->tdesc_type
587 && strcmp (id
, reg
->reg
->tdesc_type
->name
) == 0)
594 /* Construct, if necessary, and return the GDB type implementing target
595 type TDESC_TYPE for architecture GDBARCH. */
598 tdesc_gdb_type (struct gdbarch
*gdbarch
, struct tdesc_type
*tdesc_type
)
602 switch (tdesc_type
->kind
)
604 /* Predefined types. */
605 case TDESC_TYPE_INT8
:
606 return builtin_type (gdbarch
)->builtin_int8
;
608 case TDESC_TYPE_INT16
:
609 return builtin_type (gdbarch
)->builtin_int16
;
611 case TDESC_TYPE_INT32
:
612 return builtin_type (gdbarch
)->builtin_int32
;
614 case TDESC_TYPE_INT64
:
615 return builtin_type (gdbarch
)->builtin_int64
;
617 case TDESC_TYPE_INT128
:
618 return builtin_type (gdbarch
)->builtin_int128
;
620 case TDESC_TYPE_UINT8
:
621 return builtin_type (gdbarch
)->builtin_uint8
;
623 case TDESC_TYPE_UINT16
:
624 return builtin_type (gdbarch
)->builtin_uint16
;
626 case TDESC_TYPE_UINT32
:
627 return builtin_type (gdbarch
)->builtin_uint32
;
629 case TDESC_TYPE_UINT64
:
630 return builtin_type (gdbarch
)->builtin_uint64
;
632 case TDESC_TYPE_UINT128
:
633 return builtin_type (gdbarch
)->builtin_uint128
;
635 case TDESC_TYPE_CODE_PTR
:
636 return builtin_type (gdbarch
)->builtin_func_ptr
;
638 case TDESC_TYPE_DATA_PTR
:
639 return builtin_type (gdbarch
)->builtin_data_ptr
;
645 type
= tdesc_find_type (gdbarch
, tdesc_type
->name
);
649 switch (tdesc_type
->kind
)
651 case TDESC_TYPE_IEEE_SINGLE
:
652 return arch_float_type (gdbarch
, -1, "builtin_type_ieee_single",
653 floatformats_ieee_single
);
655 case TDESC_TYPE_IEEE_DOUBLE
:
656 return arch_float_type (gdbarch
, -1, "builtin_type_ieee_double",
657 floatformats_ieee_double
);
659 case TDESC_TYPE_ARM_FPA_EXT
:
660 return arch_float_type (gdbarch
, -1, "builtin_type_arm_ext",
661 floatformats_arm_ext
);
663 case TDESC_TYPE_I387_EXT
:
664 return arch_float_type (gdbarch
, -1, "builtin_type_i387_ext",
665 floatformats_i387_ext
);
667 /* Types defined by a target feature. */
668 case TDESC_TYPE_VECTOR
:
670 struct type
*type
, *field_type
;
672 field_type
= tdesc_gdb_type (gdbarch
, tdesc_type
->u
.v
.type
);
673 type
= init_vector_type (field_type
, tdesc_type
->u
.v
.count
);
674 TYPE_NAME (type
) = xstrdup (tdesc_type
->name
);
679 case TDESC_TYPE_STRUCT
:
681 struct type
*type
, *field_type
;
682 struct tdesc_type_field
*f
;
685 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
686 TYPE_NAME (type
) = xstrdup (tdesc_type
->name
);
687 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
690 VEC_iterate (tdesc_type_field
, tdesc_type
->u
.u
.fields
, ix
, f
);
697 struct type
*field_type
;
698 int bitsize
, total_size
;
700 /* This invariant should be preserved while creating
702 gdb_assert (tdesc_type
->u
.u
.size
!= 0);
703 if (tdesc_type
->u
.u
.size
> 4)
704 field_type
= builtin_type (gdbarch
)->builtin_uint64
;
706 field_type
= builtin_type (gdbarch
)->builtin_uint32
;
708 fld
= append_composite_type_field_raw (type
, xstrdup (f
->name
),
711 /* For little-endian, BITPOS counts from the LSB of
712 the structure and marks the LSB of the field. For
713 big-endian, BITPOS counts from the MSB of the
714 structure and marks the MSB of the field. Either
715 way, it is the number of bits to the "left" of the
716 field. To calculate this in big-endian, we need
717 the total size of the structure. */
718 bitsize
= f
->end
- f
->start
+ 1;
719 total_size
= tdesc_type
->u
.u
.size
* TARGET_CHAR_BIT
;
720 if (gdbarch_bits_big_endian (gdbarch
))
721 SET_FIELD_BITPOS (fld
[0], total_size
- f
->start
- bitsize
);
723 SET_FIELD_BITPOS (fld
[0], f
->start
);
724 FIELD_BITSIZE (fld
[0]) = bitsize
;
728 field_type
= tdesc_gdb_type (gdbarch
, f
->type
);
729 append_composite_type_field (type
, xstrdup (f
->name
),
734 if (tdesc_type
->u
.u
.size
!= 0)
735 TYPE_LENGTH (type
) = tdesc_type
->u
.u
.size
;
739 case TDESC_TYPE_UNION
:
741 struct type
*type
, *field_type
;
742 struct tdesc_type_field
*f
;
745 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_UNION
);
746 TYPE_NAME (type
) = xstrdup (tdesc_type
->name
);
749 VEC_iterate (tdesc_type_field
, tdesc_type
->u
.u
.fields
, ix
, f
);
752 field_type
= tdesc_gdb_type (gdbarch
, f
->type
);
753 append_composite_type_field (type
, xstrdup (f
->name
), field_type
);
755 /* If any of the children of a union are vectors, flag the
756 union as a vector also. This allows e.g. a union of two
757 vector types to show up automatically in "info vector". */
758 if (TYPE_VECTOR (field_type
))
759 TYPE_VECTOR (type
) = 1;
764 case TDESC_TYPE_FLAGS
:
766 struct tdesc_type_flag
*f
;
769 type
= arch_flags_type (gdbarch
, tdesc_type
->name
,
770 tdesc_type
->u
.f
.size
);
772 VEC_iterate (tdesc_type_flag
, tdesc_type
->u
.f
.flags
, ix
, f
);
774 /* Note that contrary to the function name, this call will
775 just set the properties of an already-allocated
777 append_flags_type_flag (type
, f
->start
,
778 *f
->name
? f
->name
: NULL
);
784 internal_error (__FILE__
, __LINE__
,
785 "Type \"%s\" has an unknown kind %d",
786 tdesc_type
->name
, tdesc_type
->kind
);
790 /* Support for registers from target descriptions. */
792 /* Construct the per-gdbarch data. */
795 tdesc_data_init (struct obstack
*obstack
)
797 struct tdesc_arch_data
*data
;
799 data
= OBSTACK_ZALLOC (obstack
, struct tdesc_arch_data
);
803 /* Similar, but for the temporary copy used during architecture
806 struct tdesc_arch_data
*
807 tdesc_data_alloc (void)
809 return XCNEW (struct tdesc_arch_data
);
812 /* Free something allocated by tdesc_data_alloc, if it is not going
813 to be used (for instance if it was unsuitable for the
817 tdesc_data_cleanup (void *data_untyped
)
819 struct tdesc_arch_data
*data
= (struct tdesc_arch_data
*) data_untyped
;
821 VEC_free (tdesc_arch_reg
, data
->arch_regs
);
825 /* Search FEATURE for a register named NAME. */
827 static struct tdesc_reg
*
828 tdesc_find_register_early (const struct tdesc_feature
*feature
,
832 struct tdesc_reg
*reg
;
835 VEC_iterate (tdesc_reg_p
, feature
->registers
, ixr
, reg
);
837 if (strcasecmp (reg
->name
, name
) == 0)
843 /* Search FEATURE for a register named NAME. Assign REGNO to it. */
846 tdesc_numbered_register (const struct tdesc_feature
*feature
,
847 struct tdesc_arch_data
*data
,
848 int regno
, const char *name
)
850 struct tdesc_arch_reg arch_reg
= { 0 };
851 struct tdesc_reg
*reg
= tdesc_find_register_early (feature
, name
);
856 /* Make sure the vector includes a REGNO'th element. */
857 while (regno
>= VEC_length (tdesc_arch_reg
, data
->arch_regs
))
858 VEC_safe_push (tdesc_arch_reg
, data
->arch_regs
, &arch_reg
);
861 VEC_replace (tdesc_arch_reg
, data
->arch_regs
, regno
, &arch_reg
);
865 /* Search FEATURE for a register named NAME, but do not assign a fixed
866 register number to it. */
869 tdesc_unnumbered_register (const struct tdesc_feature
*feature
,
872 struct tdesc_reg
*reg
= tdesc_find_register_early (feature
, name
);
880 /* Search FEATURE for a register whose name is in NAMES and assign
884 tdesc_numbered_register_choices (const struct tdesc_feature
*feature
,
885 struct tdesc_arch_data
*data
,
886 int regno
, const char *const names
[])
890 for (i
= 0; names
[i
] != NULL
; i
++)
891 if (tdesc_numbered_register (feature
, data
, regno
, names
[i
]))
897 /* Search FEATURE for a register named NAME, and return its size in
898 bits. The register must exist. */
901 tdesc_register_size (const struct tdesc_feature
*feature
,
904 struct tdesc_reg
*reg
= tdesc_find_register_early (feature
, name
);
906 gdb_assert (reg
!= NULL
);
910 /* Look up a register by its GDB internal register number. */
912 static struct tdesc_arch_reg
*
913 tdesc_find_arch_register (struct gdbarch
*gdbarch
, int regno
)
915 struct tdesc_arch_data
*data
;
917 data
= (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
918 if (regno
< VEC_length (tdesc_arch_reg
, data
->arch_regs
))
919 return VEC_index (tdesc_arch_reg
, data
->arch_regs
, regno
);
924 static struct tdesc_reg
*
925 tdesc_find_register (struct gdbarch
*gdbarch
, int regno
)
927 struct tdesc_arch_reg
*reg
= tdesc_find_arch_register (gdbarch
, regno
);
929 return reg
? reg
->reg
: NULL
;
932 /* Return the name of register REGNO, from the target description or
933 from an architecture-provided pseudo_register_name method. */
936 tdesc_register_name (struct gdbarch
*gdbarch
, int regno
)
938 struct tdesc_reg
*reg
= tdesc_find_register (gdbarch
, regno
);
939 int num_regs
= gdbarch_num_regs (gdbarch
);
940 int num_pseudo_regs
= gdbarch_num_pseudo_regs (gdbarch
);
945 if (regno
>= num_regs
&& regno
< num_regs
+ num_pseudo_regs
)
947 struct tdesc_arch_data
*data
948 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
950 gdb_assert (data
->pseudo_register_name
!= NULL
);
951 return data
->pseudo_register_name (gdbarch
, regno
);
958 tdesc_register_type (struct gdbarch
*gdbarch
, int regno
)
960 struct tdesc_arch_reg
*arch_reg
= tdesc_find_arch_register (gdbarch
, regno
);
961 struct tdesc_reg
*reg
= arch_reg
? arch_reg
->reg
: NULL
;
962 int num_regs
= gdbarch_num_regs (gdbarch
);
963 int num_pseudo_regs
= gdbarch_num_pseudo_regs (gdbarch
);
965 if (reg
== NULL
&& regno
>= num_regs
&& regno
< num_regs
+ num_pseudo_regs
)
967 struct tdesc_arch_data
*data
968 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
970 gdb_assert (data
->pseudo_register_type
!= NULL
);
971 return data
->pseudo_register_type (gdbarch
, regno
);
975 /* Return "int0_t", since "void" has a misleading size of one. */
976 return builtin_type (gdbarch
)->builtin_int0
;
978 if (arch_reg
->type
== NULL
)
980 /* First check for a predefined or target defined type. */
982 arch_reg
->type
= tdesc_gdb_type (gdbarch
, reg
->tdesc_type
);
984 /* Next try size-sensitive type shortcuts. */
985 else if (strcmp (reg
->type
, "float") == 0)
987 if (reg
->bitsize
== gdbarch_float_bit (gdbarch
))
988 arch_reg
->type
= builtin_type (gdbarch
)->builtin_float
;
989 else if (reg
->bitsize
== gdbarch_double_bit (gdbarch
))
990 arch_reg
->type
= builtin_type (gdbarch
)->builtin_double
;
991 else if (reg
->bitsize
== gdbarch_long_double_bit (gdbarch
))
992 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long_double
;
995 warning (_("Register \"%s\" has an unsupported size (%d bits)"),
996 reg
->name
, reg
->bitsize
);
997 arch_reg
->type
= builtin_type (gdbarch
)->builtin_double
;
1000 else if (strcmp (reg
->type
, "int") == 0)
1002 if (reg
->bitsize
== gdbarch_long_bit (gdbarch
))
1003 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long
;
1004 else if (reg
->bitsize
== TARGET_CHAR_BIT
)
1005 arch_reg
->type
= builtin_type (gdbarch
)->builtin_char
;
1006 else if (reg
->bitsize
== gdbarch_short_bit (gdbarch
))
1007 arch_reg
->type
= builtin_type (gdbarch
)->builtin_short
;
1008 else if (reg
->bitsize
== gdbarch_int_bit (gdbarch
))
1009 arch_reg
->type
= builtin_type (gdbarch
)->builtin_int
;
1010 else if (reg
->bitsize
== gdbarch_long_long_bit (gdbarch
))
1011 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long_long
;
1012 else if (reg
->bitsize
== gdbarch_ptr_bit (gdbarch
))
1013 /* A bit desperate by this point... */
1014 arch_reg
->type
= builtin_type (gdbarch
)->builtin_data_ptr
;
1017 warning (_("Register \"%s\" has an unsupported size (%d bits)"),
1018 reg
->name
, reg
->bitsize
);
1019 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long
;
1023 if (arch_reg
->type
== NULL
)
1024 internal_error (__FILE__
, __LINE__
,
1025 "Register \"%s\" has an unknown type \"%s\"",
1026 reg
->name
, reg
->type
);
1029 return arch_reg
->type
;
1033 tdesc_remote_register_number (struct gdbarch
*gdbarch
, int regno
)
1035 struct tdesc_reg
*reg
= tdesc_find_register (gdbarch
, regno
);
1038 return reg
->target_regnum
;
1043 /* Check whether REGNUM is a member of REGGROUP. Registers from the
1044 target description may be classified as general, float, or vector.
1045 Unlike a gdbarch register_reggroup_p method, this function will
1046 return -1 if it does not know; the caller should handle registers
1047 with no specified group.
1049 Arbitrary strings (other than "general", "float", and "vector")
1050 from the description are not used; they cause the register to be
1051 displayed in "info all-registers" but excluded from "info
1052 registers" et al. The names of containing features are also not
1053 used. This might be extended to display registers in some more
1056 The save-restore flag is also implemented here. */
1059 tdesc_register_in_reggroup_p (struct gdbarch
*gdbarch
, int regno
,
1060 struct reggroup
*reggroup
)
1062 struct tdesc_reg
*reg
= tdesc_find_register (gdbarch
, regno
);
1064 if (reg
!= NULL
&& reg
->group
!= NULL
)
1066 int general_p
= 0, float_p
= 0, vector_p
= 0;
1068 if (strcmp (reg
->group
, "general") == 0)
1070 else if (strcmp (reg
->group
, "float") == 0)
1072 else if (strcmp (reg
->group
, "vector") == 0)
1075 if (reggroup
== float_reggroup
)
1078 if (reggroup
== vector_reggroup
)
1081 if (reggroup
== general_reggroup
)
1086 && (reggroup
== save_reggroup
|| reggroup
== restore_reggroup
))
1087 return reg
->save_restore
;
1092 /* Check whether REGNUM is a member of REGGROUP. Registers with no
1093 group specified go to the default reggroup function and are handled
1097 tdesc_register_reggroup_p (struct gdbarch
*gdbarch
, int regno
,
1098 struct reggroup
*reggroup
)
1100 int num_regs
= gdbarch_num_regs (gdbarch
);
1101 int num_pseudo_regs
= gdbarch_num_pseudo_regs (gdbarch
);
1104 if (regno
>= num_regs
&& regno
< num_regs
+ num_pseudo_regs
)
1106 struct tdesc_arch_data
*data
1107 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1109 if (data
->pseudo_register_reggroup_p
!= NULL
)
1110 return data
->pseudo_register_reggroup_p (gdbarch
, regno
, reggroup
);
1111 /* Otherwise fall through to the default reggroup_p. */
1114 ret
= tdesc_register_in_reggroup_p (gdbarch
, regno
, reggroup
);
1118 return default_register_reggroup_p (gdbarch
, regno
, reggroup
);
1121 /* Record architecture-specific functions to call for pseudo-register
1125 set_tdesc_pseudo_register_name (struct gdbarch
*gdbarch
,
1126 gdbarch_register_name_ftype
*pseudo_name
)
1128 struct tdesc_arch_data
*data
1129 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1131 data
->pseudo_register_name
= pseudo_name
;
1135 set_tdesc_pseudo_register_type (struct gdbarch
*gdbarch
,
1136 gdbarch_register_type_ftype
*pseudo_type
)
1138 struct tdesc_arch_data
*data
1139 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1141 data
->pseudo_register_type
= pseudo_type
;
1145 set_tdesc_pseudo_register_reggroup_p
1146 (struct gdbarch
*gdbarch
,
1147 gdbarch_register_reggroup_p_ftype
*pseudo_reggroup_p
)
1149 struct tdesc_arch_data
*data
1150 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1152 data
->pseudo_register_reggroup_p
= pseudo_reggroup_p
;
1155 /* Update GDBARCH to use the target description for registers. */
1158 tdesc_use_registers (struct gdbarch
*gdbarch
,
1159 const struct target_desc
*target_desc
,
1160 struct tdesc_arch_data
*early_data
)
1162 int num_regs
= gdbarch_num_regs (gdbarch
);
1164 struct tdesc_feature
*feature
;
1165 struct tdesc_reg
*reg
;
1166 struct tdesc_arch_data
*data
;
1167 struct tdesc_arch_reg
*arch_reg
, new_arch_reg
= { 0 };
1170 /* We can't use the description for registers if it doesn't describe
1171 any. This function should only be called after validating
1172 registers, so the caller should know that registers are
1174 gdb_assert (tdesc_has_registers (target_desc
));
1176 data
= (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1177 data
->arch_regs
= early_data
->arch_regs
;
1180 /* Build up a set of all registers, so that we can assign register
1181 numbers where needed. The hash table expands as necessary, so
1182 the initial size is arbitrary. */
1183 reg_hash
= htab_create (37, htab_hash_pointer
, htab_eq_pointer
, NULL
);
1185 VEC_iterate (tdesc_feature_p
, target_desc
->features
, ixf
, feature
);
1188 VEC_iterate (tdesc_reg_p
, feature
->registers
, ixr
, reg
);
1191 void **slot
= htab_find_slot (reg_hash
, reg
, INSERT
);
1196 /* Remove any registers which were assigned numbers by the
1199 VEC_iterate (tdesc_arch_reg
, data
->arch_regs
, ixr
, arch_reg
);
1202 htab_remove_elt (reg_hash
, arch_reg
->reg
);
1204 /* Assign numbers to the remaining registers and add them to the
1205 list of registers. The new numbers are always above gdbarch_num_regs.
1206 Iterate over the features, not the hash table, so that the order
1207 matches that in the target description. */
1209 gdb_assert (VEC_length (tdesc_arch_reg
, data
->arch_regs
) <= num_regs
);
1210 while (VEC_length (tdesc_arch_reg
, data
->arch_regs
) < num_regs
)
1211 VEC_safe_push (tdesc_arch_reg
, data
->arch_regs
, &new_arch_reg
);
1213 VEC_iterate (tdesc_feature_p
, target_desc
->features
, ixf
, feature
);
1216 VEC_iterate (tdesc_reg_p
, feature
->registers
, ixr
, reg
);
1218 if (htab_find (reg_hash
, reg
) != NULL
)
1220 new_arch_reg
.reg
= reg
;
1221 VEC_safe_push (tdesc_arch_reg
, data
->arch_regs
, &new_arch_reg
);
1225 htab_delete (reg_hash
);
1227 /* Update the architecture. */
1228 set_gdbarch_num_regs (gdbarch
, num_regs
);
1229 set_gdbarch_register_name (gdbarch
, tdesc_register_name
);
1230 set_gdbarch_register_type (gdbarch
, tdesc_register_type
);
1231 set_gdbarch_remote_register_number (gdbarch
,
1232 tdesc_remote_register_number
);
1233 set_gdbarch_register_reggroup_p (gdbarch
, tdesc_register_reggroup_p
);
1237 /* Methods for constructing a target description. */
1240 tdesc_free_reg (struct tdesc_reg
*reg
)
1249 tdesc_create_reg (struct tdesc_feature
*feature
, const char *name
,
1250 int regnum
, int save_restore
, const char *group
,
1251 int bitsize
, const char *type
)
1253 struct tdesc_reg
*reg
= XCNEW (struct tdesc_reg
);
1255 reg
->name
= xstrdup (name
);
1256 reg
->target_regnum
= regnum
;
1257 reg
->save_restore
= save_restore
;
1258 reg
->group
= group
? xstrdup (group
) : NULL
;
1259 reg
->bitsize
= bitsize
;
1260 reg
->type
= type
? xstrdup (type
) : xstrdup ("<unknown>");
1262 /* If the register's type is target-defined, look it up now. We may not
1263 have easy access to the containing feature when we want it later. */
1264 reg
->tdesc_type
= tdesc_named_type (feature
, reg
->type
);
1266 VEC_safe_push (tdesc_reg_p
, feature
->registers
, reg
);
1270 tdesc_free_type (struct tdesc_type
*type
)
1274 case TDESC_TYPE_STRUCT
:
1275 case TDESC_TYPE_UNION
:
1277 struct tdesc_type_field
*f
;
1281 VEC_iterate (tdesc_type_field
, type
->u
.u
.fields
, ix
, f
);
1285 VEC_free (tdesc_type_field
, type
->u
.u
.fields
);
1289 case TDESC_TYPE_FLAGS
:
1291 struct tdesc_type_flag
*f
;
1295 VEC_iterate (tdesc_type_flag
, type
->u
.f
.flags
, ix
, f
);
1299 VEC_free (tdesc_type_flag
, type
->u
.f
.flags
);
1312 tdesc_create_vector (struct tdesc_feature
*feature
, const char *name
,
1313 struct tdesc_type
*field_type
, int count
)
1315 struct tdesc_type
*type
= XCNEW (struct tdesc_type
);
1317 type
->name
= xstrdup (name
);
1318 type
->kind
= TDESC_TYPE_VECTOR
;
1319 type
->u
.v
.type
= field_type
;
1320 type
->u
.v
.count
= count
;
1322 VEC_safe_push (tdesc_type_p
, feature
->types
, type
);
1327 tdesc_create_struct (struct tdesc_feature
*feature
, const char *name
)
1329 struct tdesc_type
*type
= XCNEW (struct tdesc_type
);
1331 type
->name
= xstrdup (name
);
1332 type
->kind
= TDESC_TYPE_STRUCT
;
1334 VEC_safe_push (tdesc_type_p
, feature
->types
, type
);
1338 /* Set the total length of TYPE. Structs which contain bitfields may
1339 omit the reserved bits, so the end of the last field may not
1343 tdesc_set_struct_size (struct tdesc_type
*type
, int size
)
1345 gdb_assert (type
->kind
== TDESC_TYPE_STRUCT
);
1346 gdb_assert (size
> 0);
1347 type
->u
.u
.size
= size
;
1351 tdesc_create_union (struct tdesc_feature
*feature
, const char *name
)
1353 struct tdesc_type
*type
= XCNEW (struct tdesc_type
);
1355 type
->name
= xstrdup (name
);
1356 type
->kind
= TDESC_TYPE_UNION
;
1358 VEC_safe_push (tdesc_type_p
, feature
->types
, type
);
1363 tdesc_create_flags (struct tdesc_feature
*feature
, const char *name
,
1366 struct tdesc_type
*type
= XCNEW (struct tdesc_type
);
1368 gdb_assert (size
> 0);
1370 type
->name
= xstrdup (name
);
1371 type
->kind
= TDESC_TYPE_FLAGS
;
1372 type
->u
.f
.size
= size
;
1374 VEC_safe_push (tdesc_type_p
, feature
->types
, type
);
1378 /* Add a new field. Return a temporary pointer to the field, which
1379 is only valid until the next call to tdesc_add_field (the vector
1380 might be reallocated). */
1383 tdesc_add_field (struct tdesc_type
*type
, const char *field_name
,
1384 struct tdesc_type
*field_type
)
1386 struct tdesc_type_field f
= { 0 };
1388 gdb_assert (type
->kind
== TDESC_TYPE_UNION
1389 || type
->kind
== TDESC_TYPE_STRUCT
);
1391 f
.name
= xstrdup (field_name
);
1392 f
.type
= field_type
;
1394 VEC_safe_push (tdesc_type_field
, type
->u
.u
.fields
, &f
);
1397 /* Add a new bitfield. */
1400 tdesc_add_bitfield (struct tdesc_type
*type
, const char *field_name
,
1403 struct tdesc_type_field f
= { 0 };
1405 gdb_assert (type
->kind
== TDESC_TYPE_STRUCT
);
1407 f
.name
= xstrdup (field_name
);
1411 VEC_safe_push (tdesc_type_field
, type
->u
.u
.fields
, &f
);
1415 tdesc_add_flag (struct tdesc_type
*type
, int start
,
1416 const char *flag_name
)
1418 struct tdesc_type_flag f
= { 0 };
1420 gdb_assert (type
->kind
== TDESC_TYPE_FLAGS
);
1422 f
.name
= xstrdup (flag_name
);
1425 VEC_safe_push (tdesc_type_flag
, type
->u
.f
.flags
, &f
);
1429 tdesc_free_feature (struct tdesc_feature
*feature
)
1431 struct tdesc_reg
*reg
;
1432 struct tdesc_type
*type
;
1435 for (ix
= 0; VEC_iterate (tdesc_reg_p
, feature
->registers
, ix
, reg
); ix
++)
1436 tdesc_free_reg (reg
);
1437 VEC_free (tdesc_reg_p
, feature
->registers
);
1439 for (ix
= 0; VEC_iterate (tdesc_type_p
, feature
->types
, ix
, type
); ix
++)
1440 tdesc_free_type (type
);
1441 VEC_free (tdesc_type_p
, feature
->types
);
1443 xfree (feature
->name
);
1447 struct tdesc_feature
*
1448 tdesc_create_feature (struct target_desc
*tdesc
, const char *name
)
1450 struct tdesc_feature
*new_feature
= XCNEW (struct tdesc_feature
);
1452 new_feature
->name
= xstrdup (name
);
1454 VEC_safe_push (tdesc_feature_p
, tdesc
->features
, new_feature
);
1458 struct target_desc
*
1459 allocate_target_description (void)
1461 return XCNEW (struct target_desc
);
1465 free_target_description (void *arg
)
1467 struct target_desc
*target_desc
= (struct target_desc
*) arg
;
1468 struct tdesc_feature
*feature
;
1469 struct property
*prop
;
1473 VEC_iterate (tdesc_feature_p
, target_desc
->features
, ix
, feature
);
1475 tdesc_free_feature (feature
);
1476 VEC_free (tdesc_feature_p
, target_desc
->features
);
1479 VEC_iterate (property_s
, target_desc
->properties
, ix
, prop
);
1483 xfree (prop
->value
);
1485 VEC_free (property_s
, target_desc
->properties
);
1487 VEC_free (arch_p
, target_desc
->compatible
);
1489 xfree (target_desc
);
1493 make_cleanup_free_target_description (struct target_desc
*target_desc
)
1495 return make_cleanup (free_target_description
, target_desc
);
1499 tdesc_add_compatible (struct target_desc
*target_desc
,
1500 const struct bfd_arch_info
*compatible
)
1502 const struct bfd_arch_info
*compat
;
1505 /* If this instance of GDB is compiled without BFD support for the
1506 compatible architecture, simply ignore it -- we would not be able
1507 to handle it anyway. */
1508 if (compatible
== NULL
)
1511 for (ix
= 0; VEC_iterate (arch_p
, target_desc
->compatible
, ix
, compat
);
1513 if (compat
== compatible
)
1514 internal_error (__FILE__
, __LINE__
,
1515 _("Attempted to add duplicate "
1516 "compatible architecture \"%s\""),
1517 compatible
->printable_name
);
1519 VEC_safe_push (arch_p
, target_desc
->compatible
, compatible
);
1523 set_tdesc_property (struct target_desc
*target_desc
,
1524 const char *key
, const char *value
)
1526 struct property
*prop
, new_prop
;
1529 gdb_assert (key
!= NULL
&& value
!= NULL
);
1531 for (ix
= 0; VEC_iterate (property_s
, target_desc
->properties
, ix
, prop
);
1533 if (strcmp (prop
->key
, key
) == 0)
1534 internal_error (__FILE__
, __LINE__
,
1535 _("Attempted to add duplicate property \"%s\""), key
);
1537 new_prop
.key
= xstrdup (key
);
1538 new_prop
.value
= xstrdup (value
);
1539 VEC_safe_push (property_s
, target_desc
->properties
, &new_prop
);
1543 set_tdesc_architecture (struct target_desc
*target_desc
,
1544 const struct bfd_arch_info
*arch
)
1546 target_desc
->arch
= arch
;
1550 set_tdesc_osabi (struct target_desc
*target_desc
, enum gdb_osabi osabi
)
1552 target_desc
->osabi
= osabi
;
1556 static struct cmd_list_element
*tdesc_set_cmdlist
, *tdesc_show_cmdlist
;
1557 static struct cmd_list_element
*tdesc_unset_cmdlist
;
1559 /* Helper functions for the CLI commands. */
1562 set_tdesc_cmd (char *args
, int from_tty
)
1564 help_list (tdesc_set_cmdlist
, "set tdesc ", all_commands
, gdb_stdout
);
1568 show_tdesc_cmd (char *args
, int from_tty
)
1570 cmd_show_list (tdesc_show_cmdlist
, from_tty
, "");
1574 unset_tdesc_cmd (char *args
, int from_tty
)
1576 help_list (tdesc_unset_cmdlist
, "unset tdesc ", all_commands
, gdb_stdout
);
1580 set_tdesc_filename_cmd (char *args
, int from_tty
,
1581 struct cmd_list_element
*c
)
1583 xfree (target_description_filename
);
1584 target_description_filename
= xstrdup (tdesc_filename_cmd_string
);
1586 target_clear_description ();
1587 target_find_description ();
1591 show_tdesc_filename_cmd (struct ui_file
*file
, int from_tty
,
1592 struct cmd_list_element
*c
,
1595 value
= target_description_filename
;
1597 if (value
!= NULL
&& *value
!= '\0')
1598 printf_filtered (_("The target description will be read from \"%s\".\n"),
1601 printf_filtered (_("The target description will be "
1602 "read from the target.\n"));
1606 unset_tdesc_filename_cmd (char *args
, int from_tty
)
1608 xfree (target_description_filename
);
1609 target_description_filename
= NULL
;
1610 target_clear_description ();
1611 target_find_description ();
1615 maint_print_c_tdesc_cmd (char *args
, int from_tty
)
1617 const struct target_desc
*tdesc
;
1618 const struct bfd_arch_info
*compatible
;
1619 const char *filename
, *inp
;
1620 char *function
, *outp
;
1621 struct property
*prop
;
1622 struct tdesc_feature
*feature
;
1623 struct tdesc_reg
*reg
;
1624 struct tdesc_type
*type
;
1625 struct tdesc_type_field
*f
;
1626 struct tdesc_type_flag
*flag
;
1628 int printed_field_type
= 0;
1630 /* Use the global target-supplied description, not the current
1631 architecture's. This lets a GDB for one architecture generate C
1632 for another architecture's description, even though the gdbarch
1633 initialization code will reject the new description. */
1634 tdesc
= current_target_desc
;
1636 error (_("There is no target description to print."));
1638 if (target_description_filename
== NULL
)
1639 error (_("The current target description did not come from an XML file."));
1641 filename
= lbasename (target_description_filename
);
1642 function
= (char *) alloca (strlen (filename
) + 1);
1643 for (inp
= filename
, outp
= function
; *inp
!= '\0'; inp
++)
1646 else if (*inp
== '-')
1652 /* Standard boilerplate. */
1653 printf_unfiltered ("/* THIS FILE IS GENERATED. "
1654 "-*- buffer-read-only: t -*- vi"
1656 printf_unfiltered (" Original: %s */\n\n", filename
);
1657 printf_unfiltered ("#include \"defs.h\"\n");
1658 printf_unfiltered ("#include \"osabi.h\"\n");
1659 printf_unfiltered ("#include \"target-descriptions.h\"\n");
1660 printf_unfiltered ("\n");
1662 printf_unfiltered ("struct target_desc *tdesc_%s;\n", function
);
1663 printf_unfiltered ("static void\n");
1664 printf_unfiltered ("initialize_tdesc_%s (void)\n", function
);
1665 printf_unfiltered ("{\n");
1667 (" struct target_desc *result = allocate_target_description ();\n");
1668 printf_unfiltered (" struct tdesc_feature *feature;\n");
1670 /* Now we do some "filtering" in order to know which variables to
1671 declare. This is needed because otherwise we would declare unused
1672 variables `field_type' and `type'. */
1674 VEC_iterate (tdesc_feature_p
, tdesc
->features
, ix
, feature
);
1677 int printed_desc_type
= 0;
1680 VEC_iterate (tdesc_type_p
, feature
->types
, ix2
, type
);
1683 if (!printed_field_type
)
1685 printf_unfiltered (" struct tdesc_type *field_type;\n");
1686 printed_field_type
= 1;
1689 if (((type
->kind
== TDESC_TYPE_UNION
1690 || type
->kind
== TDESC_TYPE_STRUCT
)
1691 && VEC_length (tdesc_type_field
, type
->u
.u
.fields
) > 0)
1692 || (type
->kind
== TDESC_TYPE_FLAGS
1693 && VEC_length (tdesc_type_flag
, type
->u
.f
.flags
) > 0))
1695 printf_unfiltered (" struct tdesc_type *type;\n");
1696 printed_desc_type
= 1;
1701 if (printed_desc_type
)
1705 printf_unfiltered ("\n");
1707 if (tdesc_architecture (tdesc
) != NULL
)
1710 (" set_tdesc_architecture (result, bfd_scan_arch (\"%s\"));\n",
1711 tdesc_architecture (tdesc
)->printable_name
);
1712 printf_unfiltered ("\n");
1715 if (tdesc_osabi (tdesc
) > GDB_OSABI_UNKNOWN
1716 && tdesc_osabi (tdesc
) < GDB_OSABI_INVALID
)
1719 (" set_tdesc_osabi (result, osabi_from_tdesc_string (\"%s\"));\n",
1720 gdbarch_osabi_name (tdesc_osabi (tdesc
)));
1721 printf_unfiltered ("\n");
1724 for (ix
= 0; VEC_iterate (arch_p
, tdesc
->compatible
, ix
, compatible
);
1728 (" tdesc_add_compatible (result, bfd_scan_arch (\"%s\"));\n",
1729 compatible
->printable_name
);
1732 printf_unfiltered ("\n");
1734 for (ix
= 0; VEC_iterate (property_s
, tdesc
->properties
, ix
, prop
);
1737 printf_unfiltered (" set_tdesc_property (result, \"%s\", \"%s\");\n",
1738 prop
->key
, prop
->value
);
1742 VEC_iterate (tdesc_feature_p
, tdesc
->features
, ix
, feature
);
1745 printf_unfiltered (" \
1746 feature = tdesc_create_feature (result, \"%s\");\n",
1750 VEC_iterate (tdesc_type_p
, feature
->types
, ix2
, type
);
1755 case TDESC_TYPE_VECTOR
:
1757 (" field_type = tdesc_named_type (feature, \"%s\");\n",
1758 type
->u
.v
.type
->name
);
1760 (" tdesc_create_vector (feature, \"%s\", field_type, %d);\n",
1761 type
->name
, type
->u
.v
.count
);
1763 case TDESC_TYPE_STRUCT
:
1765 (" type = tdesc_create_struct (feature, \"%s\");\n",
1767 if (type
->u
.u
.size
!= 0)
1769 (" tdesc_set_struct_size (type, %s);\n",
1770 plongest (type
->u
.u
.size
));
1772 VEC_iterate (tdesc_type_field
, type
->u
.u
.fields
, ix3
, f
);
1775 /* Going first for implicitly sized types, else part handles
1776 bitfields. As reported on xml-tdesc.c implicitly sized types
1777 cannot contain a bitfield. */
1778 if (f
->type
!= NULL
)
1781 (" field_type = tdesc_named_type (feature, \"%s\");\n",
1784 (" tdesc_add_field (type, \"%s\", field_type);\n",
1789 (" tdesc_add_bitfield (type, \"%s\", %d, %d);\n",
1790 f
->name
, f
->start
, f
->end
);
1793 case TDESC_TYPE_UNION
:
1795 (" type = tdesc_create_union (feature, \"%s\");\n",
1798 VEC_iterate (tdesc_type_field
, type
->u
.u
.fields
, ix3
, f
);
1802 (" field_type = tdesc_named_type (feature, \"%s\");\n",
1805 (" tdesc_add_field (type, \"%s\", field_type);\n",
1809 case TDESC_TYPE_FLAGS
:
1811 (" type = tdesc_create_flags (feature, \"%s\", %d);\n",
1812 type
->name
, (int) type
->u
.f
.size
);
1814 VEC_iterate (tdesc_type_flag
, type
->u
.f
.flags
, ix3
,
1818 (" tdesc_add_flag (type, %d, \"%s\");\n",
1819 flag
->start
, flag
->name
);
1822 error (_("C output is not supported type \"%s\"."), type
->name
);
1824 printf_unfiltered ("\n");
1828 VEC_iterate (tdesc_reg_p
, feature
->registers
, ix2
, reg
);
1831 printf_unfiltered (" tdesc_create_reg (feature, \"%s\", %ld, %d, ",
1832 reg
->name
, reg
->target_regnum
, reg
->save_restore
);
1834 printf_unfiltered ("\"%s\", ", reg
->group
);
1836 printf_unfiltered ("NULL, ");
1837 printf_unfiltered ("%d, \"%s\");\n", reg
->bitsize
, reg
->type
);
1840 printf_unfiltered ("\n");
1843 printf_unfiltered (" tdesc_%s = result;\n", function
);
1844 printf_unfiltered ("}\n");
1847 /* Provide a prototype to silence -Wmissing-prototypes. */
1848 extern initialize_file_ftype _initialize_target_descriptions
;
1851 _initialize_target_descriptions (void)
1853 tdesc_data
= gdbarch_data_register_pre_init (tdesc_data_init
);
1855 add_prefix_cmd ("tdesc", class_maintenance
, set_tdesc_cmd
, _("\
1856 Set target description specific variables."),
1857 &tdesc_set_cmdlist
, "set tdesc ",
1858 0 /* allow-unknown */, &setlist
);
1859 add_prefix_cmd ("tdesc", class_maintenance
, show_tdesc_cmd
, _("\
1860 Show target description specific variables."),
1861 &tdesc_show_cmdlist
, "show tdesc ",
1862 0 /* allow-unknown */, &showlist
);
1863 add_prefix_cmd ("tdesc", class_maintenance
, unset_tdesc_cmd
, _("\
1864 Unset target description specific variables."),
1865 &tdesc_unset_cmdlist
, "unset tdesc ",
1866 0 /* allow-unknown */, &unsetlist
);
1868 add_setshow_filename_cmd ("filename", class_obscure
,
1869 &tdesc_filename_cmd_string
,
1871 Set the file to read for an XML target description"), _("\
1872 Show the file to read for an XML target description"), _("\
1873 When set, GDB will read the target description from a local\n\
1874 file instead of querying the remote target."),
1875 set_tdesc_filename_cmd
,
1876 show_tdesc_filename_cmd
,
1877 &tdesc_set_cmdlist
, &tdesc_show_cmdlist
);
1879 add_cmd ("filename", class_obscure
, unset_tdesc_filename_cmd
, _("\
1880 Unset the file to read for an XML target description. When unset,\n\
1881 GDB will read the description from the target."),
1882 &tdesc_unset_cmdlist
);
1884 add_cmd ("c-tdesc", class_maintenance
, maint_print_c_tdesc_cmd
, _("\
1885 Print the current target description as a C source file."),
1886 &maintenanceprintlist
);