1 /* Target description support for GDB.
3 Copyright (C) 2006-2017 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"
38 #include "completer.h"
39 #include "readline/tilde.h" /* tilde_expand */
41 /* The interface to visit different elements of target description. */
43 class tdesc_element_visitor
46 virtual void visit_pre (const target_desc
*e
) = 0;
47 virtual void visit_post (const target_desc
*e
) = 0;
49 virtual void visit_pre (const tdesc_feature
*e
) = 0;
50 virtual void visit_post (const tdesc_feature
*e
) = 0;
52 virtual void visit (const tdesc_type
*e
) = 0;
53 virtual void visit (const tdesc_reg
*e
) = 0;
59 virtual void accept (tdesc_element_visitor
&v
) const = 0;
66 property (const std::string
&key_
, const std::string
&value_
)
67 : key (key_
), value (value_
)
74 /* An individual register from a target description. */
76 typedef struct tdesc_reg
: tdesc_element
78 tdesc_reg (struct tdesc_feature
*feature
, const char *name_
,
79 int regnum
, int save_restore_
, const char *group_
,
80 int bitsize_
, const char *type_
)
81 : name (xstrdup (name_
)), target_regnum (regnum
),
82 save_restore (save_restore_
),
83 group (group_
!= NULL
? xstrdup (group_
) : NULL
),
85 type (type_
!= NULL
? xstrdup (type_
) : xstrdup ("<unknown>"))
87 /* If the register's type is target-defined, look it up now. We may not
88 have easy access to the containing feature when we want it later. */
89 tdesc_type
= tdesc_named_type (feature
, type
);
99 DISABLE_COPY_AND_ASSIGN (tdesc_reg
);
101 /* The name of this register. In standard features, it may be
102 recognized by the architecture support code, or it may be purely
106 /* The register number used by this target to refer to this
107 register. This is used for remote p/P packets and to determine
108 the ordering of registers in the remote g/G packets. */
111 /* If this flag is set, GDB should save and restore this register
112 around calls to an inferior function. */
115 /* The name of the register group containing this register, or NULL
116 if the group should be automatically determined from the
117 register's type. If this is "general", "float", or "vector", the
118 corresponding "info" command should display this register's
119 value. It can be an arbitrary string, but should be limited to
120 alphanumeric characters and internal hyphens. Currently other
121 strings are ignored (treated as NULL). */
124 /* The size of the register, in bits. */
127 /* The type of the register. This string corresponds to either
128 a named type from the target description or a predefined
132 /* The target-described type corresponding to TYPE, if found. */
133 struct tdesc_type
*tdesc_type
;
135 void accept (tdesc_element_visitor
&v
) const override
140 bool operator== (const tdesc_reg
&other
) const
142 return (streq (name
, other
.name
)
143 && target_regnum
== other
.target_regnum
144 && save_restore
== other
.save_restore
145 && bitsize
== other
.bitsize
146 && (group
== other
.group
|| streq (group
, other
.group
))
147 && streq (type
, other
.type
));
150 bool operator!= (const tdesc_reg
&other
) const
152 return !(*this == other
);
155 DEF_VEC_P(tdesc_reg_p
);
157 /* A named type from a target description. */
159 typedef struct tdesc_type_field
162 struct tdesc_type
*type
;
163 /* For non-enum-values, either both are -1 (non-bitfield), or both are
164 not -1 (bitfield). For enum values, start is the value (which could be
168 DEF_VEC_O(tdesc_type_field
);
172 /* Predefined types. */
186 TDESC_TYPE_IEEE_SINGLE
,
187 TDESC_TYPE_IEEE_DOUBLE
,
188 TDESC_TYPE_ARM_FPA_EXT
,
191 /* Types defined by a target feature. */
199 typedef struct tdesc_type
: tdesc_element
201 tdesc_type (const char *name_
, enum tdesc_type_kind kind_
)
202 : name (xstrdup (name_
)), kind (kind_
)
204 memset (&u
, 0, sizeof (u
));
207 virtual ~tdesc_type ()
211 case TDESC_TYPE_STRUCT
:
212 case TDESC_TYPE_UNION
:
213 case TDESC_TYPE_FLAGS
:
214 case TDESC_TYPE_ENUM
:
216 struct tdesc_type_field
*f
;
220 VEC_iterate (tdesc_type_field
, u
.u
.fields
, ix
, f
);
224 VEC_free (tdesc_type_field
, u
.u
.fields
);
231 xfree ((char *) name
);
234 DISABLE_COPY_AND_ASSIGN (tdesc_type
);
236 /* The name of this type. If this type is a built-in type, this is
237 a pointer to a constant string. Otherwise, it's a
238 malloc-allocated string (and thus must be freed). */
241 /* Identify the kind of this type. */
242 enum tdesc_type_kind kind
;
244 /* Kind-specific data. */
250 struct tdesc_type
*type
;
254 /* Struct, union, flags, or enum type. */
257 VEC(tdesc_type_field
) *fields
;
262 void accept (tdesc_element_visitor
&v
) const override
267 bool operator== (const tdesc_type
&other
) const
269 return (streq (name
, other
.name
) && kind
== other
.kind
);
272 bool operator!= (const tdesc_type
&other
) const
274 return !(*this == other
);
277 DEF_VEC_P(tdesc_type_p
);
279 /* A feature from a target description. Each feature is a collection
280 of other elements, e.g. registers and types. */
282 typedef struct tdesc_feature
: tdesc_element
284 tdesc_feature (const char *name_
)
285 : name (xstrdup (name_
))
288 virtual ~tdesc_feature ()
290 struct tdesc_reg
*reg
;
291 struct tdesc_type
*type
;
294 for (ix
= 0; VEC_iterate (tdesc_reg_p
, registers
, ix
, reg
); ix
++)
296 VEC_free (tdesc_reg_p
, registers
);
298 for (ix
= 0; VEC_iterate (tdesc_type_p
, types
, ix
, type
); ix
++)
300 VEC_free (tdesc_type_p
, types
);
305 DISABLE_COPY_AND_ASSIGN (tdesc_feature
);
307 /* The name of this feature. It may be recognized by the architecture
311 /* The registers associated with this feature. */
312 VEC(tdesc_reg_p
) *registers
= NULL
;
314 /* The types associated with this feature. */
315 VEC(tdesc_type_p
) *types
= NULL
;
317 void accept (tdesc_element_visitor
&v
) const override
321 struct tdesc_type
*type
;
324 VEC_iterate (tdesc_type_p
, types
, ix
, type
);
328 struct tdesc_reg
*reg
;
331 VEC_iterate (tdesc_reg_p
, registers
, ix
, reg
);
339 bool operator== (const tdesc_feature
&other
) const
341 if (strcmp (name
, other
.name
) != 0)
344 if (VEC_length (tdesc_reg_p
, registers
)
345 != VEC_length (tdesc_reg_p
, other
.registers
))
348 struct tdesc_reg
*reg
;
351 VEC_iterate (tdesc_reg_p
, registers
, ix
, reg
);
355 = VEC_index (tdesc_reg_p
, other
.registers
, ix
);
357 if (reg
!= reg2
&& *reg
!= *reg2
)
361 if (VEC_length (tdesc_type_p
, types
)
362 != VEC_length (tdesc_type_p
, other
.types
))
368 VEC_iterate (tdesc_type_p
, types
, ix
, type
);
372 = VEC_index (tdesc_type_p
, other
.types
, ix
);
374 if (type
!= type2
&& *type
!= *type2
)
381 bool operator!= (const tdesc_feature
&other
) const
383 return !(*this == other
);
387 DEF_VEC_P(tdesc_feature_p
);
389 /* A compatible architecture from a target description. */
390 typedef const struct bfd_arch_info
*arch_p
;
393 /* A target description. */
395 struct target_desc
: tdesc_element
400 virtual ~target_desc ()
402 struct tdesc_feature
*feature
;
406 VEC_iterate (tdesc_feature_p
, features
, ix
, feature
);
409 VEC_free (tdesc_feature_p
, features
);
411 VEC_free (arch_p
, compatible
);
414 target_desc (const target_desc
&) = delete;
415 void operator= (const target_desc
&) = delete;
417 /* The architecture reported by the target, if any. */
418 const struct bfd_arch_info
*arch
= NULL
;
420 /* The osabi reported by the target, if any; GDB_OSABI_UNKNOWN
422 enum gdb_osabi osabi
= GDB_OSABI_UNKNOWN
;
424 /* The list of compatible architectures reported by the target. */
425 VEC(arch_p
) *compatible
= NULL
;
427 /* Any architecture-specific properties specified by the target. */
428 std::vector
<property
> properties
;
430 /* The features associated with this target. */
431 VEC(tdesc_feature_p
) *features
= NULL
;
433 void accept (tdesc_element_visitor
&v
) const override
437 struct tdesc_feature
*feature
;
440 VEC_iterate (tdesc_feature_p
, features
, ix
, feature
);
447 bool operator== (const target_desc
&other
) const
449 if (arch
!= other
.arch
)
452 if (osabi
!= other
.osabi
)
455 if (VEC_length (tdesc_feature_p
, features
)
456 != VEC_length (tdesc_feature_p
, other
.features
))
459 struct tdesc_feature
*feature
;
462 VEC_iterate (tdesc_feature_p
, features
, ix
, feature
);
465 struct tdesc_feature
*feature2
466 = VEC_index (tdesc_feature_p
, other
.features
, ix
);
468 if (feature
!= feature2
&& *feature
!= *feature2
)
475 bool operator!= (const target_desc
&other
) const
477 return !(*this == other
);
481 /* Per-architecture data associated with a target description. The
482 target description may be shared by multiple architectures, but
483 this data is private to one gdbarch. */
485 typedef struct tdesc_arch_reg
487 struct tdesc_reg
*reg
;
490 DEF_VEC_O(tdesc_arch_reg
);
492 struct tdesc_arch_data
494 /* A list of register/type pairs, indexed by GDB's internal register number.
495 During initialization of the gdbarch this list is used to store
496 registers which the architecture assigns a fixed register number.
497 Registers which are NULL in this array, or off the end, are
498 treated as zero-sized and nameless (i.e. placeholders in the
500 VEC(tdesc_arch_reg
) *arch_regs
;
502 /* Functions which report the register name, type, and reggroups for
504 gdbarch_register_name_ftype
*pseudo_register_name
;
505 gdbarch_register_type_ftype
*pseudo_register_type
;
506 gdbarch_register_reggroup_p_ftype
*pseudo_register_reggroup_p
;
509 /* Info about an inferior's target description. There's one of these
510 for each inferior. */
512 struct target_desc_info
514 /* A flag indicating that a description has already been fetched
515 from the target, so it should not be queried again. */
519 /* The description fetched from the target, or NULL if the target
520 did not supply any description. Only valid when
521 target_desc_fetched is set. Only the description initialization
522 code should access this; normally, the description should be
523 accessed through the gdbarch object. */
525 const struct target_desc
*tdesc
;
527 /* The filename to read a target description from, as set by "set
528 tdesc filename ..." */
533 /* Get the inferior INF's target description info, allocating one on
534 the stop if necessary. */
536 static struct target_desc_info
*
537 get_tdesc_info (struct inferior
*inf
)
539 if (inf
->tdesc_info
== NULL
)
540 inf
->tdesc_info
= XCNEW (struct target_desc_info
);
541 return inf
->tdesc_info
;
544 /* A handle for architecture-specific data associated with the
545 target description (see struct tdesc_arch_data). */
547 static struct gdbarch_data
*tdesc_data
;
549 /* See target-descriptions.h. */
552 target_desc_info_from_user_p (struct target_desc_info
*info
)
554 return info
!= NULL
&& info
->filename
!= NULL
;
557 /* See target-descriptions.h. */
560 copy_inferior_target_desc_info (struct inferior
*destinf
, struct inferior
*srcinf
)
562 struct target_desc_info
*src
= get_tdesc_info (srcinf
);
563 struct target_desc_info
*dest
= get_tdesc_info (destinf
);
565 dest
->fetched
= src
->fetched
;
566 dest
->tdesc
= src
->tdesc
;
567 dest
->filename
= src
->filename
!= NULL
? xstrdup (src
->filename
) : NULL
;
570 /* See target-descriptions.h. */
573 target_desc_info_free (struct target_desc_info
*tdesc_info
)
575 if (tdesc_info
!= NULL
)
577 xfree (tdesc_info
->filename
);
582 /* Convenience helper macros. */
584 #define target_desc_fetched \
585 get_tdesc_info (current_inferior ())->fetched
586 #define current_target_desc \
587 get_tdesc_info (current_inferior ())->tdesc
588 #define target_description_filename \
589 get_tdesc_info (current_inferior ())->filename
591 /* The string manipulated by the "set tdesc filename ..." command. */
593 static char *tdesc_filename_cmd_string
;
595 /* Fetch the current target's description, and switch the current
596 architecture to one which incorporates that description. */
599 target_find_description (void)
601 /* If we've already fetched a description from the target, don't do
602 it again. This allows a target to fetch the description early,
603 during its to_open or to_create_inferior, if it needs extra
604 information about the target to initialize. */
605 if (target_desc_fetched
)
608 /* The current architecture should not have any target description
609 specified. It should have been cleared, e.g. when we
610 disconnected from the previous target. */
611 gdb_assert (gdbarch_target_desc (target_gdbarch ()) == NULL
);
613 /* First try to fetch an XML description from the user-specified
615 current_target_desc
= NULL
;
616 if (target_description_filename
!= NULL
617 && *target_description_filename
!= '\0')
619 = file_read_description_xml (target_description_filename
);
621 /* Next try to read the description from the current target using
623 if (current_target_desc
== NULL
)
624 current_target_desc
= target_read_description_xml (¤t_target
);
626 /* If that failed try a target-specific hook. */
627 if (current_target_desc
== NULL
)
628 current_target_desc
= target_read_description (¤t_target
);
630 /* If a non-NULL description was returned, then update the current
632 if (current_target_desc
)
634 struct gdbarch_info info
;
636 gdbarch_info_init (&info
);
637 info
.target_desc
= current_target_desc
;
638 if (!gdbarch_update_p (info
))
639 warning (_("Architecture rejected target-supplied description"));
642 struct tdesc_arch_data
*data
;
644 data
= ((struct tdesc_arch_data
*)
645 gdbarch_data (target_gdbarch (), tdesc_data
));
646 if (tdesc_has_registers (current_target_desc
)
647 && data
->arch_regs
== NULL
)
648 warning (_("Target-supplied registers are not supported "
649 "by the current architecture"));
653 /* Now that we know this description is usable, record that we
655 target_desc_fetched
= 1;
658 /* Discard any description fetched from the current target, and switch
659 the current architecture to one with no target description. */
662 target_clear_description (void)
664 struct gdbarch_info info
;
666 if (!target_desc_fetched
)
669 target_desc_fetched
= 0;
670 current_target_desc
= NULL
;
672 gdbarch_info_init (&info
);
673 if (!gdbarch_update_p (info
))
674 internal_error (__FILE__
, __LINE__
,
675 _("Could not remove target-supplied description"));
678 /* Return the global current target description. This should only be
679 used by gdbarch initialization code; most access should be through
680 an existing gdbarch. */
682 const struct target_desc
*
683 target_current_description (void)
685 if (target_desc_fetched
)
686 return current_target_desc
;
691 /* Return non-zero if this target description is compatible
692 with the given BFD architecture. */
695 tdesc_compatible_p (const struct target_desc
*target_desc
,
696 const struct bfd_arch_info
*arch
)
698 const struct bfd_arch_info
*compat
;
701 for (ix
= 0; VEC_iterate (arch_p
, target_desc
->compatible
, ix
, compat
);
705 || arch
->compatible (arch
, compat
)
706 || compat
->compatible (compat
, arch
))
714 /* Direct accessors for target descriptions. */
716 /* Return the string value of a property named KEY, or NULL if the
717 property was not specified. */
720 tdesc_property (const struct target_desc
*target_desc
, const char *key
)
722 for (const property
&prop
: target_desc
->properties
)
724 return prop
.value
.c_str ();
729 /* Return the BFD architecture associated with this target
730 description, or NULL if no architecture was specified. */
732 const struct bfd_arch_info
*
733 tdesc_architecture (const struct target_desc
*target_desc
)
735 return target_desc
->arch
;
738 /* Return the OSABI associated with this target description, or
739 GDB_OSABI_UNKNOWN if no osabi was specified. */
742 tdesc_osabi (const struct target_desc
*target_desc
)
744 return target_desc
->osabi
;
749 /* Return 1 if this target description includes any registers. */
752 tdesc_has_registers (const struct target_desc
*target_desc
)
755 struct tdesc_feature
*feature
;
757 if (target_desc
== NULL
)
761 VEC_iterate (tdesc_feature_p
, target_desc
->features
, ix
, feature
);
763 if (! VEC_empty (tdesc_reg_p
, feature
->registers
))
769 /* Return the feature with the given name, if present, or NULL if
770 the named feature is not found. */
772 const struct tdesc_feature
*
773 tdesc_find_feature (const struct target_desc
*target_desc
,
777 struct tdesc_feature
*feature
;
780 VEC_iterate (tdesc_feature_p
, target_desc
->features
, ix
, feature
);
782 if (strcmp (feature
->name
, name
) == 0)
788 /* Return the name of FEATURE. */
791 tdesc_feature_name (const struct tdesc_feature
*feature
)
793 return feature
->name
;
796 /* Predefined types. */
797 static struct tdesc_type tdesc_predefined_types
[] =
799 { "bool", TDESC_TYPE_BOOL
},
800 { "int8", TDESC_TYPE_INT8
},
801 { "int16", TDESC_TYPE_INT16
},
802 { "int32", TDESC_TYPE_INT32
},
803 { "int64", TDESC_TYPE_INT64
},
804 { "int128", TDESC_TYPE_INT128
},
805 { "uint8", TDESC_TYPE_UINT8
},
806 { "uint16", TDESC_TYPE_UINT16
},
807 { "uint32", TDESC_TYPE_UINT32
},
808 { "uint64", TDESC_TYPE_UINT64
},
809 { "uint128", TDESC_TYPE_UINT128
},
810 { "code_ptr", TDESC_TYPE_CODE_PTR
},
811 { "data_ptr", TDESC_TYPE_DATA_PTR
},
812 { "ieee_single", TDESC_TYPE_IEEE_SINGLE
},
813 { "ieee_double", TDESC_TYPE_IEEE_DOUBLE
},
814 { "arm_fpa_ext", TDESC_TYPE_ARM_FPA_EXT
},
815 { "i387_ext", TDESC_TYPE_I387_EXT
}
818 /* Lookup a predefined type. */
820 static struct tdesc_type
*
821 tdesc_predefined_type (enum tdesc_type_kind kind
)
823 for (int ix
= 0; ix
< ARRAY_SIZE (tdesc_predefined_types
); ix
++)
824 if (tdesc_predefined_types
[ix
].kind
== kind
)
825 return &tdesc_predefined_types
[ix
];
827 gdb_assert_not_reached ("bad predefined tdesc type");
830 /* See arch/tdesc.h. */
833 tdesc_named_type (const struct tdesc_feature
*feature
, const char *id
)
836 struct tdesc_type
*type
;
838 /* First try target-defined types. */
839 for (ix
= 0; VEC_iterate (tdesc_type_p
, feature
->types
, ix
, type
); ix
++)
840 if (strcmp (type
->name
, id
) == 0)
843 /* Next try the predefined types. */
844 for (ix
= 0; ix
< ARRAY_SIZE (tdesc_predefined_types
); ix
++)
845 if (strcmp (tdesc_predefined_types
[ix
].name
, id
) == 0)
846 return &tdesc_predefined_types
[ix
];
851 /* Lookup type associated with ID. */
854 tdesc_find_type (struct gdbarch
*gdbarch
, const char *id
)
856 struct tdesc_arch_reg
*reg
;
857 struct tdesc_arch_data
*data
;
860 data
= (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
861 num_regs
= VEC_length (tdesc_arch_reg
, data
->arch_regs
);
862 for (i
= 0; i
< num_regs
; i
++)
864 reg
= VEC_index (tdesc_arch_reg
, data
->arch_regs
, i
);
866 && reg
->reg
->tdesc_type
868 && strcmp (id
, reg
->reg
->tdesc_type
->name
) == 0)
875 /* Construct, if necessary, and return the GDB type implementing target
876 type TDESC_TYPE for architecture GDBARCH. */
879 tdesc_gdb_type (struct gdbarch
*gdbarch
, struct tdesc_type
*tdesc_type
)
883 switch (tdesc_type
->kind
)
885 /* Predefined types. */
886 case TDESC_TYPE_BOOL
:
887 return builtin_type (gdbarch
)->builtin_bool
;
889 case TDESC_TYPE_INT8
:
890 return builtin_type (gdbarch
)->builtin_int8
;
892 case TDESC_TYPE_INT16
:
893 return builtin_type (gdbarch
)->builtin_int16
;
895 case TDESC_TYPE_INT32
:
896 return builtin_type (gdbarch
)->builtin_int32
;
898 case TDESC_TYPE_INT64
:
899 return builtin_type (gdbarch
)->builtin_int64
;
901 case TDESC_TYPE_INT128
:
902 return builtin_type (gdbarch
)->builtin_int128
;
904 case TDESC_TYPE_UINT8
:
905 return builtin_type (gdbarch
)->builtin_uint8
;
907 case TDESC_TYPE_UINT16
:
908 return builtin_type (gdbarch
)->builtin_uint16
;
910 case TDESC_TYPE_UINT32
:
911 return builtin_type (gdbarch
)->builtin_uint32
;
913 case TDESC_TYPE_UINT64
:
914 return builtin_type (gdbarch
)->builtin_uint64
;
916 case TDESC_TYPE_UINT128
:
917 return builtin_type (gdbarch
)->builtin_uint128
;
919 case TDESC_TYPE_CODE_PTR
:
920 return builtin_type (gdbarch
)->builtin_func_ptr
;
922 case TDESC_TYPE_DATA_PTR
:
923 return builtin_type (gdbarch
)->builtin_data_ptr
;
929 type
= tdesc_find_type (gdbarch
, tdesc_type
->name
);
933 switch (tdesc_type
->kind
)
935 case TDESC_TYPE_IEEE_SINGLE
:
936 return arch_float_type (gdbarch
, -1, "builtin_type_ieee_single",
937 floatformats_ieee_single
);
939 case TDESC_TYPE_IEEE_DOUBLE
:
940 return arch_float_type (gdbarch
, -1, "builtin_type_ieee_double",
941 floatformats_ieee_double
);
943 case TDESC_TYPE_ARM_FPA_EXT
:
944 return arch_float_type (gdbarch
, -1, "builtin_type_arm_ext",
945 floatformats_arm_ext
);
947 case TDESC_TYPE_I387_EXT
:
948 return arch_float_type (gdbarch
, -1, "builtin_type_i387_ext",
949 floatformats_i387_ext
);
951 /* Types defined by a target feature. */
952 case TDESC_TYPE_VECTOR
:
954 struct type
*type
, *field_type
;
956 field_type
= tdesc_gdb_type (gdbarch
, tdesc_type
->u
.v
.type
);
957 type
= init_vector_type (field_type
, tdesc_type
->u
.v
.count
);
958 TYPE_NAME (type
) = xstrdup (tdesc_type
->name
);
963 case TDESC_TYPE_STRUCT
:
965 struct type
*type
, *field_type
;
966 struct tdesc_type_field
*f
;
969 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
970 TYPE_NAME (type
) = xstrdup (tdesc_type
->name
);
971 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
974 VEC_iterate (tdesc_type_field
, tdesc_type
->u
.u
.fields
, ix
, f
);
977 if (f
->start
!= -1 && f
->end
!= -1)
981 struct type
*field_type
;
982 int bitsize
, total_size
;
984 /* This invariant should be preserved while creating types. */
985 gdb_assert (tdesc_type
->u
.u
.size
!= 0);
987 field_type
= tdesc_gdb_type (gdbarch
, f
->type
);
988 else if (tdesc_type
->u
.u
.size
> 4)
989 field_type
= builtin_type (gdbarch
)->builtin_uint64
;
991 field_type
= builtin_type (gdbarch
)->builtin_uint32
;
993 fld
= append_composite_type_field_raw (type
, xstrdup (f
->name
),
996 /* For little-endian, BITPOS counts from the LSB of
997 the structure and marks the LSB of the field. For
998 big-endian, BITPOS counts from the MSB of the
999 structure and marks the MSB of the field. Either
1000 way, it is the number of bits to the "left" of the
1001 field. To calculate this in big-endian, we need
1002 the total size of the structure. */
1003 bitsize
= f
->end
- f
->start
+ 1;
1004 total_size
= tdesc_type
->u
.u
.size
* TARGET_CHAR_BIT
;
1005 if (gdbarch_bits_big_endian (gdbarch
))
1006 SET_FIELD_BITPOS (fld
[0], total_size
- f
->start
- bitsize
);
1008 SET_FIELD_BITPOS (fld
[0], f
->start
);
1009 FIELD_BITSIZE (fld
[0]) = bitsize
;
1013 gdb_assert (f
->start
== -1 && f
->end
== -1);
1014 field_type
= tdesc_gdb_type (gdbarch
, f
->type
);
1015 append_composite_type_field (type
, xstrdup (f
->name
),
1020 if (tdesc_type
->u
.u
.size
!= 0)
1021 TYPE_LENGTH (type
) = tdesc_type
->u
.u
.size
;
1025 case TDESC_TYPE_UNION
:
1027 struct type
*type
, *field_type
;
1028 struct tdesc_type_field
*f
;
1031 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_UNION
);
1032 TYPE_NAME (type
) = xstrdup (tdesc_type
->name
);
1035 VEC_iterate (tdesc_type_field
, tdesc_type
->u
.u
.fields
, ix
, f
);
1038 field_type
= tdesc_gdb_type (gdbarch
, f
->type
);
1039 append_composite_type_field (type
, xstrdup (f
->name
), field_type
);
1041 /* If any of the children of a union are vectors, flag the
1042 union as a vector also. This allows e.g. a union of two
1043 vector types to show up automatically in "info vector". */
1044 if (TYPE_VECTOR (field_type
))
1045 TYPE_VECTOR (type
) = 1;
1050 case TDESC_TYPE_FLAGS
:
1052 struct tdesc_type_field
*f
;
1055 type
= arch_flags_type (gdbarch
, tdesc_type
->name
,
1056 tdesc_type
->u
.u
.size
* TARGET_CHAR_BIT
);
1058 VEC_iterate (tdesc_type_field
, tdesc_type
->u
.u
.fields
, ix
, f
);
1061 struct type
*field_type
;
1062 int bitsize
= f
->end
- f
->start
+ 1;
1064 gdb_assert (f
->type
!= NULL
);
1065 field_type
= tdesc_gdb_type (gdbarch
, f
->type
);
1066 append_flags_type_field (type
, f
->start
, bitsize
,
1067 field_type
, f
->name
);
1073 case TDESC_TYPE_ENUM
:
1075 struct tdesc_type_field
*f
;
1078 type
= arch_type (gdbarch
, TYPE_CODE_ENUM
,
1079 tdesc_type
->u
.u
.size
* TARGET_CHAR_BIT
,
1081 TYPE_UNSIGNED (type
) = 1;
1083 VEC_iterate (tdesc_type_field
, tdesc_type
->u
.u
.fields
, ix
, f
);
1087 = append_composite_type_field_raw (type
, xstrdup (f
->name
),
1090 SET_FIELD_BITPOS (fld
[0], f
->start
);
1097 internal_error (__FILE__
, __LINE__
,
1098 "Type \"%s\" has an unknown kind %d",
1099 tdesc_type
->name
, tdesc_type
->kind
);
1103 /* Support for registers from target descriptions. */
1105 /* Construct the per-gdbarch data. */
1108 tdesc_data_init (struct obstack
*obstack
)
1110 struct tdesc_arch_data
*data
;
1112 data
= OBSTACK_ZALLOC (obstack
, struct tdesc_arch_data
);
1116 /* Similar, but for the temporary copy used during architecture
1119 struct tdesc_arch_data
*
1120 tdesc_data_alloc (void)
1122 return XCNEW (struct tdesc_arch_data
);
1125 /* Free something allocated by tdesc_data_alloc, if it is not going
1126 to be used (for instance if it was unsuitable for the
1130 tdesc_data_cleanup (void *data_untyped
)
1132 struct tdesc_arch_data
*data
= (struct tdesc_arch_data
*) data_untyped
;
1134 VEC_free (tdesc_arch_reg
, data
->arch_regs
);
1138 /* Search FEATURE for a register named NAME. */
1140 static struct tdesc_reg
*
1141 tdesc_find_register_early (const struct tdesc_feature
*feature
,
1145 struct tdesc_reg
*reg
;
1148 VEC_iterate (tdesc_reg_p
, feature
->registers
, ixr
, reg
);
1150 if (strcasecmp (reg
->name
, name
) == 0)
1156 /* Search FEATURE for a register named NAME. Assign REGNO to it. */
1159 tdesc_numbered_register (const struct tdesc_feature
*feature
,
1160 struct tdesc_arch_data
*data
,
1161 int regno
, const char *name
)
1163 struct tdesc_arch_reg arch_reg
= { 0 };
1164 struct tdesc_reg
*reg
= tdesc_find_register_early (feature
, name
);
1169 /* Make sure the vector includes a REGNO'th element. */
1170 while (regno
>= VEC_length (tdesc_arch_reg
, data
->arch_regs
))
1171 VEC_safe_push (tdesc_arch_reg
, data
->arch_regs
, &arch_reg
);
1174 VEC_replace (tdesc_arch_reg
, data
->arch_regs
, regno
, &arch_reg
);
1178 /* Search FEATURE for a register named NAME, but do not assign a fixed
1179 register number to it. */
1182 tdesc_unnumbered_register (const struct tdesc_feature
*feature
,
1185 struct tdesc_reg
*reg
= tdesc_find_register_early (feature
, name
);
1193 /* Search FEATURE for a register whose name is in NAMES and assign
1197 tdesc_numbered_register_choices (const struct tdesc_feature
*feature
,
1198 struct tdesc_arch_data
*data
,
1199 int regno
, const char *const names
[])
1203 for (i
= 0; names
[i
] != NULL
; i
++)
1204 if (tdesc_numbered_register (feature
, data
, regno
, names
[i
]))
1210 /* Search FEATURE for a register named NAME, and return its size in
1211 bits. The register must exist. */
1214 tdesc_register_size (const struct tdesc_feature
*feature
,
1217 struct tdesc_reg
*reg
= tdesc_find_register_early (feature
, name
);
1219 gdb_assert (reg
!= NULL
);
1220 return reg
->bitsize
;
1223 /* Look up a register by its GDB internal register number. */
1225 static struct tdesc_arch_reg
*
1226 tdesc_find_arch_register (struct gdbarch
*gdbarch
, int regno
)
1228 struct tdesc_arch_data
*data
;
1230 data
= (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1231 if (regno
< VEC_length (tdesc_arch_reg
, data
->arch_regs
))
1232 return VEC_index (tdesc_arch_reg
, data
->arch_regs
, regno
);
1237 static struct tdesc_reg
*
1238 tdesc_find_register (struct gdbarch
*gdbarch
, int regno
)
1240 struct tdesc_arch_reg
*reg
= tdesc_find_arch_register (gdbarch
, regno
);
1242 return reg
? reg
->reg
: NULL
;
1245 /* Return the name of register REGNO, from the target description or
1246 from an architecture-provided pseudo_register_name method. */
1249 tdesc_register_name (struct gdbarch
*gdbarch
, int regno
)
1251 struct tdesc_reg
*reg
= tdesc_find_register (gdbarch
, regno
);
1252 int num_regs
= gdbarch_num_regs (gdbarch
);
1253 int num_pseudo_regs
= gdbarch_num_pseudo_regs (gdbarch
);
1258 if (regno
>= num_regs
&& regno
< num_regs
+ num_pseudo_regs
)
1260 struct tdesc_arch_data
*data
1261 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1263 gdb_assert (data
->pseudo_register_name
!= NULL
);
1264 return data
->pseudo_register_name (gdbarch
, regno
);
1271 tdesc_register_type (struct gdbarch
*gdbarch
, int regno
)
1273 struct tdesc_arch_reg
*arch_reg
= tdesc_find_arch_register (gdbarch
, regno
);
1274 struct tdesc_reg
*reg
= arch_reg
? arch_reg
->reg
: NULL
;
1275 int num_regs
= gdbarch_num_regs (gdbarch
);
1276 int num_pseudo_regs
= gdbarch_num_pseudo_regs (gdbarch
);
1278 if (reg
== NULL
&& regno
>= num_regs
&& regno
< num_regs
+ num_pseudo_regs
)
1280 struct tdesc_arch_data
*data
1281 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1283 gdb_assert (data
->pseudo_register_type
!= NULL
);
1284 return data
->pseudo_register_type (gdbarch
, regno
);
1288 /* Return "int0_t", since "void" has a misleading size of one. */
1289 return builtin_type (gdbarch
)->builtin_int0
;
1291 if (arch_reg
->type
== NULL
)
1293 /* First check for a predefined or target defined type. */
1294 if (reg
->tdesc_type
)
1295 arch_reg
->type
= tdesc_gdb_type (gdbarch
, reg
->tdesc_type
);
1297 /* Next try size-sensitive type shortcuts. */
1298 else if (strcmp (reg
->type
, "float") == 0)
1300 if (reg
->bitsize
== gdbarch_float_bit (gdbarch
))
1301 arch_reg
->type
= builtin_type (gdbarch
)->builtin_float
;
1302 else if (reg
->bitsize
== gdbarch_double_bit (gdbarch
))
1303 arch_reg
->type
= builtin_type (gdbarch
)->builtin_double
;
1304 else if (reg
->bitsize
== gdbarch_long_double_bit (gdbarch
))
1305 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long_double
;
1308 warning (_("Register \"%s\" has an unsupported size (%d bits)"),
1309 reg
->name
, reg
->bitsize
);
1310 arch_reg
->type
= builtin_type (gdbarch
)->builtin_double
;
1313 else if (strcmp (reg
->type
, "int") == 0)
1315 if (reg
->bitsize
== gdbarch_long_bit (gdbarch
))
1316 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long
;
1317 else if (reg
->bitsize
== TARGET_CHAR_BIT
)
1318 arch_reg
->type
= builtin_type (gdbarch
)->builtin_char
;
1319 else if (reg
->bitsize
== gdbarch_short_bit (gdbarch
))
1320 arch_reg
->type
= builtin_type (gdbarch
)->builtin_short
;
1321 else if (reg
->bitsize
== gdbarch_int_bit (gdbarch
))
1322 arch_reg
->type
= builtin_type (gdbarch
)->builtin_int
;
1323 else if (reg
->bitsize
== gdbarch_long_long_bit (gdbarch
))
1324 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long_long
;
1325 else if (reg
->bitsize
== gdbarch_ptr_bit (gdbarch
))
1326 /* A bit desperate by this point... */
1327 arch_reg
->type
= builtin_type (gdbarch
)->builtin_data_ptr
;
1330 warning (_("Register \"%s\" has an unsupported size (%d bits)"),
1331 reg
->name
, reg
->bitsize
);
1332 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long
;
1336 if (arch_reg
->type
== NULL
)
1337 internal_error (__FILE__
, __LINE__
,
1338 "Register \"%s\" has an unknown type \"%s\"",
1339 reg
->name
, reg
->type
);
1342 return arch_reg
->type
;
1346 tdesc_remote_register_number (struct gdbarch
*gdbarch
, int regno
)
1348 struct tdesc_reg
*reg
= tdesc_find_register (gdbarch
, regno
);
1351 return reg
->target_regnum
;
1356 /* Check whether REGNUM is a member of REGGROUP. Registers from the
1357 target description may be classified as general, float, or vector.
1358 Unlike a gdbarch register_reggroup_p method, this function will
1359 return -1 if it does not know; the caller should handle registers
1360 with no specified group.
1362 Arbitrary strings (other than "general", "float", and "vector")
1363 from the description are not used; they cause the register to be
1364 displayed in "info all-registers" but excluded from "info
1365 registers" et al. The names of containing features are also not
1366 used. This might be extended to display registers in some more
1369 The save-restore flag is also implemented here. */
1372 tdesc_register_in_reggroup_p (struct gdbarch
*gdbarch
, int regno
,
1373 struct reggroup
*reggroup
)
1375 struct tdesc_reg
*reg
= tdesc_find_register (gdbarch
, regno
);
1377 if (reg
!= NULL
&& reg
->group
!= NULL
)
1379 int general_p
= 0, float_p
= 0, vector_p
= 0;
1381 if (strcmp (reg
->group
, "general") == 0)
1383 else if (strcmp (reg
->group
, "float") == 0)
1385 else if (strcmp (reg
->group
, "vector") == 0)
1388 if (reggroup
== float_reggroup
)
1391 if (reggroup
== vector_reggroup
)
1394 if (reggroup
== general_reggroup
)
1399 && (reggroup
== save_reggroup
|| reggroup
== restore_reggroup
))
1400 return reg
->save_restore
;
1405 /* Check whether REGNUM is a member of REGGROUP. Registers with no
1406 group specified go to the default reggroup function and are handled
1410 tdesc_register_reggroup_p (struct gdbarch
*gdbarch
, int regno
,
1411 struct reggroup
*reggroup
)
1413 int num_regs
= gdbarch_num_regs (gdbarch
);
1414 int num_pseudo_regs
= gdbarch_num_pseudo_regs (gdbarch
);
1417 if (regno
>= num_regs
&& regno
< num_regs
+ num_pseudo_regs
)
1419 struct tdesc_arch_data
*data
1420 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1422 if (data
->pseudo_register_reggroup_p
!= NULL
)
1423 return data
->pseudo_register_reggroup_p (gdbarch
, regno
, reggroup
);
1424 /* Otherwise fall through to the default reggroup_p. */
1427 ret
= tdesc_register_in_reggroup_p (gdbarch
, regno
, reggroup
);
1431 return default_register_reggroup_p (gdbarch
, regno
, reggroup
);
1434 /* Record architecture-specific functions to call for pseudo-register
1438 set_tdesc_pseudo_register_name (struct gdbarch
*gdbarch
,
1439 gdbarch_register_name_ftype
*pseudo_name
)
1441 struct tdesc_arch_data
*data
1442 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1444 data
->pseudo_register_name
= pseudo_name
;
1448 set_tdesc_pseudo_register_type (struct gdbarch
*gdbarch
,
1449 gdbarch_register_type_ftype
*pseudo_type
)
1451 struct tdesc_arch_data
*data
1452 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1454 data
->pseudo_register_type
= pseudo_type
;
1458 set_tdesc_pseudo_register_reggroup_p
1459 (struct gdbarch
*gdbarch
,
1460 gdbarch_register_reggroup_p_ftype
*pseudo_reggroup_p
)
1462 struct tdesc_arch_data
*data
1463 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1465 data
->pseudo_register_reggroup_p
= pseudo_reggroup_p
;
1468 /* Update GDBARCH to use the target description for registers. */
1471 tdesc_use_registers (struct gdbarch
*gdbarch
,
1472 const struct target_desc
*target_desc
,
1473 struct tdesc_arch_data
*early_data
)
1475 int num_regs
= gdbarch_num_regs (gdbarch
);
1477 struct tdesc_feature
*feature
;
1478 struct tdesc_reg
*reg
;
1479 struct tdesc_arch_data
*data
;
1480 struct tdesc_arch_reg
*arch_reg
, new_arch_reg
= { 0 };
1483 /* We can't use the description for registers if it doesn't describe
1484 any. This function should only be called after validating
1485 registers, so the caller should know that registers are
1487 gdb_assert (tdesc_has_registers (target_desc
));
1489 data
= (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1490 data
->arch_regs
= early_data
->arch_regs
;
1493 /* Build up a set of all registers, so that we can assign register
1494 numbers where needed. The hash table expands as necessary, so
1495 the initial size is arbitrary. */
1496 reg_hash
= htab_create (37, htab_hash_pointer
, htab_eq_pointer
, NULL
);
1498 VEC_iterate (tdesc_feature_p
, target_desc
->features
, ixf
, feature
);
1501 VEC_iterate (tdesc_reg_p
, feature
->registers
, ixr
, reg
);
1504 void **slot
= htab_find_slot (reg_hash
, reg
, INSERT
);
1509 /* Remove any registers which were assigned numbers by the
1512 VEC_iterate (tdesc_arch_reg
, data
->arch_regs
, ixr
, arch_reg
);
1515 htab_remove_elt (reg_hash
, arch_reg
->reg
);
1517 /* Assign numbers to the remaining registers and add them to the
1518 list of registers. The new numbers are always above gdbarch_num_regs.
1519 Iterate over the features, not the hash table, so that the order
1520 matches that in the target description. */
1522 gdb_assert (VEC_length (tdesc_arch_reg
, data
->arch_regs
) <= num_regs
);
1523 while (VEC_length (tdesc_arch_reg
, data
->arch_regs
) < num_regs
)
1524 VEC_safe_push (tdesc_arch_reg
, data
->arch_regs
, &new_arch_reg
);
1526 VEC_iterate (tdesc_feature_p
, target_desc
->features
, ixf
, feature
);
1529 VEC_iterate (tdesc_reg_p
, feature
->registers
, ixr
, reg
);
1531 if (htab_find (reg_hash
, reg
) != NULL
)
1533 new_arch_reg
.reg
= reg
;
1534 VEC_safe_push (tdesc_arch_reg
, data
->arch_regs
, &new_arch_reg
);
1538 htab_delete (reg_hash
);
1540 /* Update the architecture. */
1541 set_gdbarch_num_regs (gdbarch
, num_regs
);
1542 set_gdbarch_register_name (gdbarch
, tdesc_register_name
);
1543 set_gdbarch_register_type (gdbarch
, tdesc_register_type
);
1544 set_gdbarch_remote_register_number (gdbarch
,
1545 tdesc_remote_register_number
);
1546 set_gdbarch_register_reggroup_p (gdbarch
, tdesc_register_reggroup_p
);
1550 /* See arch/tdesc.h. */
1553 tdesc_create_reg (struct tdesc_feature
*feature
, const char *name
,
1554 int regnum
, int save_restore
, const char *group
,
1555 int bitsize
, const char *type
)
1557 tdesc_reg
*reg
= new tdesc_reg (feature
, name
, regnum
, save_restore
,
1558 group
, bitsize
, type
);
1560 VEC_safe_push (tdesc_reg_p
, feature
->registers
, reg
);
1563 /* See arch/tdesc.h. */
1566 tdesc_create_vector (struct tdesc_feature
*feature
, const char *name
,
1567 struct tdesc_type
*field_type
, int count
)
1569 struct tdesc_type
*type
= new tdesc_type (name
, TDESC_TYPE_VECTOR
);
1571 type
->u
.v
.type
= field_type
;
1572 type
->u
.v
.count
= count
;
1574 VEC_safe_push (tdesc_type_p
, feature
->types
, type
);
1578 /* See arch/tdesc.h. */
1581 tdesc_create_struct (struct tdesc_feature
*feature
, const char *name
)
1583 struct tdesc_type
*type
= new tdesc_type (name
, TDESC_TYPE_STRUCT
);
1585 VEC_safe_push (tdesc_type_p
, feature
->types
, type
);
1589 /* See arch/tdesc.h. */
1592 tdesc_set_struct_size (struct tdesc_type
*type
, int size
)
1594 gdb_assert (type
->kind
== TDESC_TYPE_STRUCT
);
1595 gdb_assert (size
> 0);
1596 type
->u
.u
.size
= size
;
1599 /* See arch/tdesc.h. */
1602 tdesc_create_union (struct tdesc_feature
*feature
, const char *name
)
1604 struct tdesc_type
*type
= new tdesc_type (name
, TDESC_TYPE_UNION
);
1606 VEC_safe_push (tdesc_type_p
, feature
->types
, type
);
1610 /* See arch/tdesc.h. */
1613 tdesc_create_flags (struct tdesc_feature
*feature
, const char *name
,
1616 struct tdesc_type
*type
= new tdesc_type (name
, TDESC_TYPE_FLAGS
);
1618 gdb_assert (size
> 0);
1620 type
->u
.u
.size
= size
;
1622 VEC_safe_push (tdesc_type_p
, feature
->types
, type
);
1627 tdesc_create_enum (struct tdesc_feature
*feature
, const char *name
,
1630 struct tdesc_type
*type
= new tdesc_type (name
, TDESC_TYPE_ENUM
);
1632 gdb_assert (size
> 0);
1634 type
->u
.u
.size
= size
;
1636 VEC_safe_push (tdesc_type_p
, feature
->types
, type
);
1640 /* See arch/tdesc.h. */
1643 tdesc_add_field (struct tdesc_type
*type
, const char *field_name
,
1644 struct tdesc_type
*field_type
)
1646 struct tdesc_type_field f
= { 0 };
1648 gdb_assert (type
->kind
== TDESC_TYPE_UNION
1649 || type
->kind
== TDESC_TYPE_STRUCT
);
1651 f
.name
= xstrdup (field_name
);
1652 f
.type
= field_type
;
1653 /* Initialize these values so we know this is not a bit-field
1654 when we print-c-tdesc. */
1658 VEC_safe_push (tdesc_type_field
, type
->u
.u
.fields
, &f
);
1662 tdesc_add_typed_bitfield (struct tdesc_type
*type
, const char *field_name
,
1663 int start
, int end
, struct tdesc_type
*field_type
)
1665 struct tdesc_type_field f
= { 0 };
1667 gdb_assert (type
->kind
== TDESC_TYPE_STRUCT
1668 || type
->kind
== TDESC_TYPE_FLAGS
);
1669 gdb_assert (start
>= 0 && end
>= start
);
1671 f
.name
= xstrdup (field_name
);
1674 f
.type
= field_type
;
1676 VEC_safe_push (tdesc_type_field
, type
->u
.u
.fields
, &f
);
1679 /* See arch/tdesc.h. */
1682 tdesc_add_bitfield (struct tdesc_type
*type
, const char *field_name
,
1685 struct tdesc_type
*field_type
;
1687 gdb_assert (start
>= 0 && end
>= start
);
1689 if (type
->u
.u
.size
> 4)
1690 field_type
= tdesc_predefined_type (TDESC_TYPE_UINT64
);
1692 field_type
= tdesc_predefined_type (TDESC_TYPE_UINT32
);
1694 tdesc_add_typed_bitfield (type
, field_name
, start
, end
, field_type
);
1697 /* See arch/tdesc.h. */
1700 tdesc_add_flag (struct tdesc_type
*type
, int start
,
1701 const char *flag_name
)
1703 struct tdesc_type_field f
= { 0 };
1705 gdb_assert (type
->kind
== TDESC_TYPE_FLAGS
1706 || type
->kind
== TDESC_TYPE_STRUCT
);
1708 f
.name
= xstrdup (flag_name
);
1711 f
.type
= tdesc_predefined_type (TDESC_TYPE_BOOL
);
1713 VEC_safe_push (tdesc_type_field
, type
->u
.u
.fields
, &f
);
1717 tdesc_add_enum_value (struct tdesc_type
*type
, int value
,
1720 struct tdesc_type_field f
= { 0 };
1722 gdb_assert (type
->kind
== TDESC_TYPE_ENUM
);
1724 f
.name
= xstrdup (name
);
1727 f
.type
= tdesc_predefined_type (TDESC_TYPE_INT32
);
1729 VEC_safe_push (tdesc_type_field
, type
->u
.u
.fields
, &f
);
1732 /* See arch/tdesc.h. */
1734 struct tdesc_feature
*
1735 tdesc_create_feature (struct target_desc
*tdesc
, const char *name
,
1738 struct tdesc_feature
*new_feature
= new tdesc_feature (name
);
1740 VEC_safe_push (tdesc_feature_p
, tdesc
->features
, new_feature
);
1744 struct target_desc
*
1745 allocate_target_description (void)
1747 return new target_desc ();
1751 free_target_description (void *arg
)
1753 struct target_desc
*target_desc
= (struct target_desc
*) arg
;
1759 make_cleanup_free_target_description (struct target_desc
*target_desc
)
1761 return make_cleanup (free_target_description
, target_desc
);
1765 tdesc_add_compatible (struct target_desc
*target_desc
,
1766 const struct bfd_arch_info
*compatible
)
1768 const struct bfd_arch_info
*compat
;
1771 /* If this instance of GDB is compiled without BFD support for the
1772 compatible architecture, simply ignore it -- we would not be able
1773 to handle it anyway. */
1774 if (compatible
== NULL
)
1777 for (ix
= 0; VEC_iterate (arch_p
, target_desc
->compatible
, ix
, compat
);
1779 if (compat
== compatible
)
1780 internal_error (__FILE__
, __LINE__
,
1781 _("Attempted to add duplicate "
1782 "compatible architecture \"%s\""),
1783 compatible
->printable_name
);
1785 VEC_safe_push (arch_p
, target_desc
->compatible
, compatible
);
1789 set_tdesc_property (struct target_desc
*target_desc
,
1790 const char *key
, const char *value
)
1792 gdb_assert (key
!= NULL
&& value
!= NULL
);
1794 if (tdesc_property (target_desc
, key
) != NULL
)
1795 internal_error (__FILE__
, __LINE__
,
1796 _("Attempted to add duplicate property \"%s\""), key
);
1798 target_desc
->properties
.emplace_back (key
, value
);
1801 /* See arch/tdesc.h. */
1804 set_tdesc_architecture (struct target_desc
*target_desc
,
1807 set_tdesc_architecture (target_desc
, bfd_scan_arch (name
));
1811 set_tdesc_architecture (struct target_desc
*target_desc
,
1812 const struct bfd_arch_info
*arch
)
1814 target_desc
->arch
= arch
;
1817 /* See arch/tdesc.h. */
1820 set_tdesc_osabi (struct target_desc
*target_desc
, const char *name
)
1822 set_tdesc_osabi (target_desc
, osabi_from_tdesc_string (name
));
1826 set_tdesc_osabi (struct target_desc
*target_desc
, enum gdb_osabi osabi
)
1828 target_desc
->osabi
= osabi
;
1832 static struct cmd_list_element
*tdesc_set_cmdlist
, *tdesc_show_cmdlist
;
1833 static struct cmd_list_element
*tdesc_unset_cmdlist
;
1835 /* Helper functions for the CLI commands. */
1838 set_tdesc_cmd (const char *args
, int from_tty
)
1840 help_list (tdesc_set_cmdlist
, "set tdesc ", all_commands
, gdb_stdout
);
1844 show_tdesc_cmd (const char *args
, int from_tty
)
1846 cmd_show_list (tdesc_show_cmdlist
, from_tty
, "");
1850 unset_tdesc_cmd (const char *args
, int from_tty
)
1852 help_list (tdesc_unset_cmdlist
, "unset tdesc ", all_commands
, gdb_stdout
);
1856 set_tdesc_filename_cmd (const char *args
, int from_tty
,
1857 struct cmd_list_element
*c
)
1859 xfree (target_description_filename
);
1860 target_description_filename
= xstrdup (tdesc_filename_cmd_string
);
1862 target_clear_description ();
1863 target_find_description ();
1867 show_tdesc_filename_cmd (struct ui_file
*file
, int from_tty
,
1868 struct cmd_list_element
*c
,
1871 value
= target_description_filename
;
1873 if (value
!= NULL
&& *value
!= '\0')
1874 printf_filtered (_("The target description will be read from \"%s\".\n"),
1877 printf_filtered (_("The target description will be "
1878 "read from the target.\n"));
1882 unset_tdesc_filename_cmd (const char *args
, int from_tty
)
1884 xfree (target_description_filename
);
1885 target_description_filename
= NULL
;
1886 target_clear_description ();
1887 target_find_description ();
1890 /* Print target description in C. */
1892 class print_c_tdesc
: public tdesc_element_visitor
1895 print_c_tdesc (std::string
&filename_after_features
)
1896 : m_filename_after_features (filename_after_features
)
1900 const char *filename
= lbasename (m_filename_after_features
.c_str ());
1902 m_function
= (char *) xmalloc (strlen (filename
) + 1);
1903 for (inp
= filename
, outp
= m_function
; *inp
!= '\0'; inp
++)
1906 else if (*inp
== '-')
1912 /* Standard boilerplate. */
1913 printf_unfiltered ("/* THIS FILE IS GENERATED. "
1914 "-*- buffer-read-only: t -*- vi"
1923 void visit_pre (const target_desc
*e
) override
1925 printf_unfiltered (" Original: %s */\n\n",
1926 lbasename (m_filename_after_features
.c_str ()));
1928 printf_unfiltered ("#include \"defs.h\"\n");
1929 printf_unfiltered ("#include \"osabi.h\"\n");
1930 printf_unfiltered ("#include \"target-descriptions.h\"\n");
1931 printf_unfiltered ("\n");
1933 printf_unfiltered ("struct target_desc *tdesc_%s;\n", m_function
);
1934 printf_unfiltered ("static void\n");
1935 printf_unfiltered ("initialize_tdesc_%s (void)\n", m_function
);
1936 printf_unfiltered ("{\n");
1938 (" struct target_desc *result = allocate_target_description ();\n");
1940 if (tdesc_architecture (e
) != NULL
)
1943 (" set_tdesc_architecture (result, bfd_scan_arch (\"%s\"));\n",
1944 tdesc_architecture (e
)->printable_name
);
1945 printf_unfiltered ("\n");
1947 if (tdesc_osabi (e
) > GDB_OSABI_UNKNOWN
1948 && tdesc_osabi (e
) < GDB_OSABI_INVALID
)
1951 (" set_tdesc_osabi (result, osabi_from_tdesc_string (\"%s\"));\n",
1952 gdbarch_osabi_name (tdesc_osabi (e
)));
1953 printf_unfiltered ("\n");
1957 const struct bfd_arch_info
*compatible
;
1958 struct property
*prop
;
1960 for (ix
= 0; VEC_iterate (arch_p
, e
->compatible
, ix
, compatible
);
1964 (" tdesc_add_compatible (result, bfd_scan_arch (\"%s\"));\n",
1965 compatible
->printable_name
);
1969 printf_unfiltered ("\n");
1971 for (const property
&prop
: e
->properties
)
1972 printf_unfiltered (" set_tdesc_property (result, \"%s\", \"%s\");\n",
1973 prop
.key
.c_str (), prop
.value
.c_str ());
1975 printf_unfiltered (" struct tdesc_feature *feature;\n");
1978 void visit_pre (const tdesc_feature
*e
) override
1980 printf_unfiltered ("\n feature = tdesc_create_feature (result, \"%s\");\n",
1984 void visit_post (const tdesc_feature
*e
) override
1987 void visit_post (const target_desc
*e
) override
1989 printf_unfiltered ("\n tdesc_%s = result;\n", m_function
);
1990 printf_unfiltered ("}\n");
1993 void visit (const tdesc_type
*type
) override
1995 struct tdesc_type_field
*f
;
1997 /* Now we do some "filtering" in order to know which variables to
1998 declare. This is needed because otherwise we would declare unused
1999 variables `field_type' and `type'. */
2000 if (!m_printed_field_type
)
2002 printf_unfiltered (" struct tdesc_type *field_type;\n");
2003 m_printed_field_type
= true;
2006 if ((type
->kind
== TDESC_TYPE_UNION
2007 || type
->kind
== TDESC_TYPE_STRUCT
2008 || type
->kind
== TDESC_TYPE_FLAGS
2009 || type
->kind
== TDESC_TYPE_ENUM
)
2010 && VEC_length (tdesc_type_field
, type
->u
.u
.fields
) > 0
2013 printf_unfiltered (" struct tdesc_type *type;\n");
2014 m_printed_type
= true;
2019 case TDESC_TYPE_VECTOR
:
2021 (" field_type = tdesc_named_type (feature, \"%s\");\n",
2022 type
->u
.v
.type
->name
);
2024 (" tdesc_create_vector (feature, \"%s\", field_type, %d);\n",
2025 type
->name
, type
->u
.v
.count
);
2027 case TDESC_TYPE_STRUCT
:
2028 case TDESC_TYPE_FLAGS
:
2029 if (type
->kind
== TDESC_TYPE_STRUCT
)
2032 (" type = tdesc_create_struct (feature, \"%s\");\n",
2034 if (type
->u
.u
.size
!= 0)
2036 (" tdesc_set_struct_size (type, %d);\n",
2042 (" type = tdesc_create_flags (feature, \"%s\", %d);\n",
2043 type
->name
, type
->u
.u
.size
);
2046 VEC_iterate (tdesc_type_field
, type
->u
.u
.fields
, ix3
, f
);
2049 const char *type_name
;
2051 gdb_assert (f
->type
!= NULL
);
2052 type_name
= f
->type
->name
;
2054 /* To minimize changes to generated files, don't emit type
2055 info for fields that have defaulted types. */
2058 gdb_assert (f
->end
!= -1);
2059 if (f
->type
->kind
== TDESC_TYPE_BOOL
)
2061 gdb_assert (f
->start
== f
->end
);
2063 (" tdesc_add_flag (type, %d, \"%s\");\n",
2066 else if ((type
->u
.u
.size
== 4
2067 && f
->type
->kind
== TDESC_TYPE_UINT32
)
2068 || (type
->u
.u
.size
== 8
2069 && f
->type
->kind
== TDESC_TYPE_UINT64
))
2072 (" tdesc_add_bitfield (type, \"%s\", %d, %d);\n",
2073 f
->name
, f
->start
, f
->end
);
2078 (" field_type = tdesc_named_type (feature,"
2082 (" tdesc_add_typed_bitfield (type, \"%s\","
2083 " %d, %d, field_type);\n",
2084 f
->name
, f
->start
, f
->end
);
2087 else /* Not a bitfield. */
2089 gdb_assert (f
->end
== -1);
2090 gdb_assert (type
->kind
== TDESC_TYPE_STRUCT
);
2092 (" field_type = tdesc_named_type (feature,"
2096 (" tdesc_add_field (type, \"%s\", field_type);\n",
2101 case TDESC_TYPE_UNION
:
2103 (" type = tdesc_create_union (feature, \"%s\");\n",
2106 VEC_iterate (tdesc_type_field
, type
->u
.u
.fields
, ix3
, f
);
2110 (" field_type = tdesc_named_type (feature, \"%s\");\n",
2113 (" tdesc_add_field (type, \"%s\", field_type);\n",
2117 case TDESC_TYPE_ENUM
:
2119 (" type = tdesc_create_enum (feature, \"%s\", %d);\n",
2120 type
->name
, type
->u
.u
.size
);
2122 VEC_iterate (tdesc_type_field
, type
->u
.u
.fields
, ix3
, f
);
2125 (" tdesc_add_enum_value (type, %d, \"%s\");\n",
2129 error (_("C output is not supported type \"%s\"."), type
->name
);
2131 printf_unfiltered ("\n");
2134 void visit (const tdesc_reg
*reg
) override
2136 printf_unfiltered (" tdesc_create_reg (feature, \"%s\", %ld, %d, ",
2137 reg
->name
, reg
->target_regnum
, reg
->save_restore
);
2139 printf_unfiltered ("\"%s\", ", reg
->group
);
2141 printf_unfiltered ("NULL, ");
2142 printf_unfiltered ("%d, \"%s\");\n", reg
->bitsize
, reg
->type
);
2146 std::string m_filename_after_features
;
2150 bool m_printed_field_type
= false;
2151 bool m_printed_type
= false;
2154 /* Print target description feature in C. */
2156 class print_c_feature
: public print_c_tdesc
2159 print_c_feature (std::string
&file
)
2160 : print_c_tdesc (file
)
2163 auto const pos
= m_filename_after_features
.find_last_of ('.');
2165 m_filename_after_features
= m_filename_after_features
.substr (0, pos
);
2168 void visit_pre (const target_desc
*e
) override
2170 printf_unfiltered (" Original: %s */\n\n",
2171 lbasename (m_filename_after_features
.c_str ()));
2173 printf_unfiltered ("#include \"arch/tdesc.h\"\n");
2174 printf_unfiltered ("\n");
2177 void visit_post (const target_desc
*e
) override
2180 void visit_pre (const tdesc_feature
*e
) override
2182 std::string
name (m_filename_after_features
);
2184 auto pos
= name
.find_first_of ('.');
2186 name
= name
.substr (0, pos
);
2187 std::replace (name
.begin (), name
.end (), '/', '_');
2188 std::replace (name
.begin (), name
.end (), '-', '_');
2190 printf_unfiltered ("static int\n");
2191 printf_unfiltered ("create_feature_%s ", name
.c_str ());
2192 printf_unfiltered ("(struct target_desc *result, long regnum)\n");
2194 printf_unfiltered ("{\n");
2195 printf_unfiltered (" struct tdesc_feature *feature;\n");
2198 ("\n feature = tdesc_create_feature (result, \"%s\", \"%s\");\n",
2199 e
->name
, lbasename (m_filename_after_features
.c_str ()));
2202 void visit_post (const tdesc_feature
*e
) override
2204 printf_unfiltered (" return regnum;\n");
2205 printf_unfiltered ("}\n");
2208 void visit (const tdesc_reg
*reg
) override
2210 /* Most "reg" in XML target descriptions don't have "regnum"
2211 attribute, so the register number is allocated sequentially.
2212 In case that reg has "regnum" attribute, register number
2213 should be set by that explicitly. */
2215 if (reg
->target_regnum
< m_next_regnum
)
2217 /* The integrity check, it can catch some errors on register
2218 number collision, like this,
2220 <reg name="x0" bitsize="32"/>
2221 <reg name="x1" bitsize="32"/>
2222 <reg name="x2" bitsize="32"/>
2223 <reg name="x3" bitsize="32"/>
2224 <reg name="ps" bitsize="32" regnum="3"/>
2226 but it also has false negatives. The target description
2229 <reg name="x1" bitsize="32" regnum="1"/>
2230 <reg name="x3" bitsize="32" regnum="3"/>
2231 <reg name="x2" bitsize="32" regnum="2"/>
2232 <reg name="x4" bitsize="32" regnum="4"/>
2234 but it is not a good practice, so still error on this,
2235 and also print the message so that it can be saved in the
2236 generated c file. */
2238 printf_unfiltered ("ERROR: \"regnum\" attribute %ld ",
2239 reg
->target_regnum
);
2240 printf_unfiltered ("is not the largest number (%d).\n",
2242 error (_("\"regnum\" attribute %ld is not the largest number (%d)."),
2243 reg
->target_regnum
, m_next_regnum
);
2246 if (reg
->target_regnum
> m_next_regnum
)
2248 printf_unfiltered (" regnum = %ld;\n", reg
->target_regnum
);
2249 m_next_regnum
= reg
->target_regnum
;
2252 printf_unfiltered (" tdesc_create_reg (feature, \"%s\", regnum++, %d, ",
2253 reg
->name
, reg
->save_restore
);
2255 printf_unfiltered ("\"%s\", ", reg
->group
);
2257 printf_unfiltered ("NULL, ");
2258 printf_unfiltered ("%d, \"%s\");\n", reg
->bitsize
, reg
->type
);
2264 /* The register number to use for the next register we see. */
2265 int m_next_regnum
= 0;
2269 maint_print_c_tdesc_cmd (const char *args
, int from_tty
)
2271 const struct target_desc
*tdesc
;
2272 const char *filename
;
2276 /* Use the global target-supplied description, not the current
2277 architecture's. This lets a GDB for one architecture generate C
2278 for another architecture's description, even though the gdbarch
2279 initialization code will reject the new description. */
2280 tdesc
= current_target_desc
;
2281 filename
= target_description_filename
;
2285 /* Use the target description from the XML file. */
2287 tdesc
= file_read_description_xml (filename
);
2291 error (_("There is no target description to print."));
2293 if (filename
== NULL
)
2294 error (_("The current target description did not come from an XML file."));
2296 std::string
filename_after_features (filename
);
2297 auto loc
= filename_after_features
.rfind ("/features/");
2299 if (loc
!= std::string::npos
)
2300 filename_after_features
= filename_after_features
.substr (loc
+ 10);
2302 /* Print c files for target features instead of target descriptions,
2303 because c files got from target features are more flexible than the
2305 if (startswith (filename_after_features
.c_str (), "i386/32bit-")
2306 || startswith (filename_after_features
.c_str (), "i386/64bit-")
2307 || startswith (filename_after_features
.c_str (), "i386/x32-core.xml")
2308 || startswith (filename_after_features
.c_str (), "tic6x-")
2309 || startswith (filename_after_features
.c_str (), "aarch64"))
2311 print_c_feature
v (filename_after_features
);
2317 print_c_tdesc
v (filename_after_features
);
2323 namespace selftests
{
2325 static std::vector
<std::pair
<const char*, const target_desc
*>> xml_tdesc
;
2329 /* See target-descritpions.h. */
2332 record_xml_tdesc (const char *xml_file
, const struct target_desc
*tdesc
)
2334 xml_tdesc
.emplace_back (xml_file
, tdesc
);
2340 /* Check that the target descriptions created dynamically by
2341 architecture-specific code equal the descriptions created from XML files
2342 found in the specified directory DIR. */
2345 maintenance_check_xml_descriptions (const char *dir
, int from_tty
)
2348 error (_("Missing dir name"));
2350 gdb::unique_xmalloc_ptr
<char> dir1 (tilde_expand (dir
));
2351 std::string
feature_dir (dir1
.get ());
2352 unsigned int failed
= 0;
2354 for (auto const &e
: selftests::xml_tdesc
)
2356 std::string tdesc_xml
= (feature_dir
+ SLASH_STRING
+ e
.first
);
2357 const target_desc
*tdesc
2358 = file_read_description_xml (tdesc_xml
.data ());
2360 if (tdesc
== NULL
|| *tdesc
!= *e
.second
)
2363 printf_filtered (_("Tested %lu XML files, %d failed\n"),
2364 (long) selftests::xml_tdesc
.size (), failed
);
2368 _initialize_target_descriptions (void)
2370 tdesc_data
= gdbarch_data_register_pre_init (tdesc_data_init
);
2372 add_prefix_cmd ("tdesc", class_maintenance
, set_tdesc_cmd
, _("\
2373 Set target description specific variables."),
2374 &tdesc_set_cmdlist
, "set tdesc ",
2375 0 /* allow-unknown */, &setlist
);
2376 add_prefix_cmd ("tdesc", class_maintenance
, show_tdesc_cmd
, _("\
2377 Show target description specific variables."),
2378 &tdesc_show_cmdlist
, "show tdesc ",
2379 0 /* allow-unknown */, &showlist
);
2380 add_prefix_cmd ("tdesc", class_maintenance
, unset_tdesc_cmd
, _("\
2381 Unset target description specific variables."),
2382 &tdesc_unset_cmdlist
, "unset tdesc ",
2383 0 /* allow-unknown */, &unsetlist
);
2385 add_setshow_filename_cmd ("filename", class_obscure
,
2386 &tdesc_filename_cmd_string
,
2388 Set the file to read for an XML target description"), _("\
2389 Show the file to read for an XML target description"), _("\
2390 When set, GDB will read the target description from a local\n\
2391 file instead of querying the remote target."),
2392 set_tdesc_filename_cmd
,
2393 show_tdesc_filename_cmd
,
2394 &tdesc_set_cmdlist
, &tdesc_show_cmdlist
);
2396 add_cmd ("filename", class_obscure
, unset_tdesc_filename_cmd
, _("\
2397 Unset the file to read for an XML target description. When unset,\n\
2398 GDB will read the description from the target."),
2399 &tdesc_unset_cmdlist
);
2401 add_cmd ("c-tdesc", class_maintenance
, maint_print_c_tdesc_cmd
, _("\
2402 Print the current target description as a C source file."),
2403 &maintenanceprintlist
);
2405 cmd_list_element
*cmd
;
2407 cmd
= add_cmd ("xml-descriptions", class_maintenance
,
2408 maintenance_check_xml_descriptions
, _("\
2409 Check the target descriptions created in GDB equal the descriptions\n\
2410 created from XML files in the directory.\n\
2411 The parameter is the directory name."),
2412 &maintenancechecklist
);
2413 set_cmd_completer (cmd
, filename_completer
);