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 target description. */
391 struct target_desc
: tdesc_element
396 virtual ~target_desc ()
398 struct tdesc_feature
*feature
;
402 VEC_iterate (tdesc_feature_p
, features
, ix
, feature
);
405 VEC_free (tdesc_feature_p
, features
);
408 target_desc (const target_desc
&) = delete;
409 void operator= (const target_desc
&) = delete;
411 /* The architecture reported by the target, if any. */
412 const struct bfd_arch_info
*arch
= NULL
;
414 /* The osabi reported by the target, if any; GDB_OSABI_UNKNOWN
416 enum gdb_osabi osabi
= GDB_OSABI_UNKNOWN
;
418 /* The list of compatible architectures reported by the target. */
419 std::vector
<const bfd_arch_info
*> compatible
;
421 /* Any architecture-specific properties specified by the target. */
422 std::vector
<property
> properties
;
424 /* The features associated with this target. */
425 VEC(tdesc_feature_p
) *features
= NULL
;
427 void accept (tdesc_element_visitor
&v
) const override
431 struct tdesc_feature
*feature
;
434 VEC_iterate (tdesc_feature_p
, features
, ix
, feature
);
441 bool operator== (const target_desc
&other
) const
443 if (arch
!= other
.arch
)
446 if (osabi
!= other
.osabi
)
449 if (VEC_length (tdesc_feature_p
, features
)
450 != VEC_length (tdesc_feature_p
, other
.features
))
453 struct tdesc_feature
*feature
;
456 VEC_iterate (tdesc_feature_p
, features
, ix
, feature
);
459 struct tdesc_feature
*feature2
460 = VEC_index (tdesc_feature_p
, other
.features
, ix
);
462 if (feature
!= feature2
&& *feature
!= *feature2
)
469 bool operator!= (const target_desc
&other
) const
471 return !(*this == other
);
475 /* Per-architecture data associated with a target description. The
476 target description may be shared by multiple architectures, but
477 this data is private to one gdbarch. */
479 typedef struct tdesc_arch_reg
481 struct tdesc_reg
*reg
;
484 DEF_VEC_O(tdesc_arch_reg
);
486 struct tdesc_arch_data
488 /* A list of register/type pairs, indexed by GDB's internal register number.
489 During initialization of the gdbarch this list is used to store
490 registers which the architecture assigns a fixed register number.
491 Registers which are NULL in this array, or off the end, are
492 treated as zero-sized and nameless (i.e. placeholders in the
494 VEC(tdesc_arch_reg
) *arch_regs
;
496 /* Functions which report the register name, type, and reggroups for
498 gdbarch_register_name_ftype
*pseudo_register_name
;
499 gdbarch_register_type_ftype
*pseudo_register_type
;
500 gdbarch_register_reggroup_p_ftype
*pseudo_register_reggroup_p
;
503 /* Info about an inferior's target description. There's one of these
504 for each inferior. */
506 struct target_desc_info
508 /* A flag indicating that a description has already been fetched
509 from the target, so it should not be queried again. */
513 /* The description fetched from the target, or NULL if the target
514 did not supply any description. Only valid when
515 target_desc_fetched is set. Only the description initialization
516 code should access this; normally, the description should be
517 accessed through the gdbarch object. */
519 const struct target_desc
*tdesc
;
521 /* The filename to read a target description from, as set by "set
522 tdesc filename ..." */
527 /* Get the inferior INF's target description info, allocating one on
528 the stop if necessary. */
530 static struct target_desc_info
*
531 get_tdesc_info (struct inferior
*inf
)
533 if (inf
->tdesc_info
== NULL
)
534 inf
->tdesc_info
= XCNEW (struct target_desc_info
);
535 return inf
->tdesc_info
;
538 /* A handle for architecture-specific data associated with the
539 target description (see struct tdesc_arch_data). */
541 static struct gdbarch_data
*tdesc_data
;
543 /* See target-descriptions.h. */
546 target_desc_info_from_user_p (struct target_desc_info
*info
)
548 return info
!= NULL
&& info
->filename
!= NULL
;
551 /* See target-descriptions.h. */
554 copy_inferior_target_desc_info (struct inferior
*destinf
, struct inferior
*srcinf
)
556 struct target_desc_info
*src
= get_tdesc_info (srcinf
);
557 struct target_desc_info
*dest
= get_tdesc_info (destinf
);
559 dest
->fetched
= src
->fetched
;
560 dest
->tdesc
= src
->tdesc
;
561 dest
->filename
= src
->filename
!= NULL
? xstrdup (src
->filename
) : NULL
;
564 /* See target-descriptions.h. */
567 target_desc_info_free (struct target_desc_info
*tdesc_info
)
569 if (tdesc_info
!= NULL
)
571 xfree (tdesc_info
->filename
);
576 /* Convenience helper macros. */
578 #define target_desc_fetched \
579 get_tdesc_info (current_inferior ())->fetched
580 #define current_target_desc \
581 get_tdesc_info (current_inferior ())->tdesc
582 #define target_description_filename \
583 get_tdesc_info (current_inferior ())->filename
585 /* The string manipulated by the "set tdesc filename ..." command. */
587 static char *tdesc_filename_cmd_string
;
589 /* Fetch the current target's description, and switch the current
590 architecture to one which incorporates that description. */
593 target_find_description (void)
595 /* If we've already fetched a description from the target, don't do
596 it again. This allows a target to fetch the description early,
597 during its to_open or to_create_inferior, if it needs extra
598 information about the target to initialize. */
599 if (target_desc_fetched
)
602 /* The current architecture should not have any target description
603 specified. It should have been cleared, e.g. when we
604 disconnected from the previous target. */
605 gdb_assert (gdbarch_target_desc (target_gdbarch ()) == NULL
);
607 /* First try to fetch an XML description from the user-specified
609 current_target_desc
= NULL
;
610 if (target_description_filename
!= NULL
611 && *target_description_filename
!= '\0')
613 = file_read_description_xml (target_description_filename
);
615 /* Next try to read the description from the current target using
617 if (current_target_desc
== NULL
)
618 current_target_desc
= target_read_description_xml (¤t_target
);
620 /* If that failed try a target-specific hook. */
621 if (current_target_desc
== NULL
)
622 current_target_desc
= target_read_description (¤t_target
);
624 /* If a non-NULL description was returned, then update the current
626 if (current_target_desc
)
628 struct gdbarch_info info
;
630 gdbarch_info_init (&info
);
631 info
.target_desc
= current_target_desc
;
632 if (!gdbarch_update_p (info
))
633 warning (_("Architecture rejected target-supplied description"));
636 struct tdesc_arch_data
*data
;
638 data
= ((struct tdesc_arch_data
*)
639 gdbarch_data (target_gdbarch (), tdesc_data
));
640 if (tdesc_has_registers (current_target_desc
)
641 && data
->arch_regs
== NULL
)
642 warning (_("Target-supplied registers are not supported "
643 "by the current architecture"));
647 /* Now that we know this description is usable, record that we
649 target_desc_fetched
= 1;
652 /* Discard any description fetched from the current target, and switch
653 the current architecture to one with no target description. */
656 target_clear_description (void)
658 struct gdbarch_info info
;
660 if (!target_desc_fetched
)
663 target_desc_fetched
= 0;
664 current_target_desc
= NULL
;
666 gdbarch_info_init (&info
);
667 if (!gdbarch_update_p (info
))
668 internal_error (__FILE__
, __LINE__
,
669 _("Could not remove target-supplied description"));
672 /* Return the global current target description. This should only be
673 used by gdbarch initialization code; most access should be through
674 an existing gdbarch. */
676 const struct target_desc
*
677 target_current_description (void)
679 if (target_desc_fetched
)
680 return current_target_desc
;
685 /* Return non-zero if this target description is compatible
686 with the given BFD architecture. */
689 tdesc_compatible_p (const struct target_desc
*target_desc
,
690 const struct bfd_arch_info
*arch
)
692 for (const bfd_arch_info
*compat
: target_desc
->compatible
)
695 || arch
->compatible (arch
, compat
)
696 || compat
->compatible (compat
, arch
))
704 /* Direct accessors for target descriptions. */
706 /* Return the string value of a property named KEY, or NULL if the
707 property was not specified. */
710 tdesc_property (const struct target_desc
*target_desc
, const char *key
)
712 for (const property
&prop
: target_desc
->properties
)
714 return prop
.value
.c_str ();
719 /* Return the BFD architecture associated with this target
720 description, or NULL if no architecture was specified. */
722 const struct bfd_arch_info
*
723 tdesc_architecture (const struct target_desc
*target_desc
)
725 return target_desc
->arch
;
728 /* Return the OSABI associated with this target description, or
729 GDB_OSABI_UNKNOWN if no osabi was specified. */
732 tdesc_osabi (const struct target_desc
*target_desc
)
734 return target_desc
->osabi
;
739 /* Return 1 if this target description includes any registers. */
742 tdesc_has_registers (const struct target_desc
*target_desc
)
745 struct tdesc_feature
*feature
;
747 if (target_desc
== NULL
)
751 VEC_iterate (tdesc_feature_p
, target_desc
->features
, ix
, feature
);
753 if (! VEC_empty (tdesc_reg_p
, feature
->registers
))
759 /* Return the feature with the given name, if present, or NULL if
760 the named feature is not found. */
762 const struct tdesc_feature
*
763 tdesc_find_feature (const struct target_desc
*target_desc
,
767 struct tdesc_feature
*feature
;
770 VEC_iterate (tdesc_feature_p
, target_desc
->features
, ix
, feature
);
772 if (strcmp (feature
->name
, name
) == 0)
778 /* Return the name of FEATURE. */
781 tdesc_feature_name (const struct tdesc_feature
*feature
)
783 return feature
->name
;
786 /* Predefined types. */
787 static struct tdesc_type tdesc_predefined_types
[] =
789 { "bool", TDESC_TYPE_BOOL
},
790 { "int8", TDESC_TYPE_INT8
},
791 { "int16", TDESC_TYPE_INT16
},
792 { "int32", TDESC_TYPE_INT32
},
793 { "int64", TDESC_TYPE_INT64
},
794 { "int128", TDESC_TYPE_INT128
},
795 { "uint8", TDESC_TYPE_UINT8
},
796 { "uint16", TDESC_TYPE_UINT16
},
797 { "uint32", TDESC_TYPE_UINT32
},
798 { "uint64", TDESC_TYPE_UINT64
},
799 { "uint128", TDESC_TYPE_UINT128
},
800 { "code_ptr", TDESC_TYPE_CODE_PTR
},
801 { "data_ptr", TDESC_TYPE_DATA_PTR
},
802 { "ieee_single", TDESC_TYPE_IEEE_SINGLE
},
803 { "ieee_double", TDESC_TYPE_IEEE_DOUBLE
},
804 { "arm_fpa_ext", TDESC_TYPE_ARM_FPA_EXT
},
805 { "i387_ext", TDESC_TYPE_I387_EXT
}
808 /* Lookup a predefined type. */
810 static struct tdesc_type
*
811 tdesc_predefined_type (enum tdesc_type_kind kind
)
813 for (int ix
= 0; ix
< ARRAY_SIZE (tdesc_predefined_types
); ix
++)
814 if (tdesc_predefined_types
[ix
].kind
== kind
)
815 return &tdesc_predefined_types
[ix
];
817 gdb_assert_not_reached ("bad predefined tdesc type");
820 /* See arch/tdesc.h. */
823 tdesc_named_type (const struct tdesc_feature
*feature
, const char *id
)
826 struct tdesc_type
*type
;
828 /* First try target-defined types. */
829 for (ix
= 0; VEC_iterate (tdesc_type_p
, feature
->types
, ix
, type
); ix
++)
830 if (strcmp (type
->name
, id
) == 0)
833 /* Next try the predefined types. */
834 for (ix
= 0; ix
< ARRAY_SIZE (tdesc_predefined_types
); ix
++)
835 if (strcmp (tdesc_predefined_types
[ix
].name
, id
) == 0)
836 return &tdesc_predefined_types
[ix
];
841 /* Lookup type associated with ID. */
844 tdesc_find_type (struct gdbarch
*gdbarch
, const char *id
)
846 struct tdesc_arch_reg
*reg
;
847 struct tdesc_arch_data
*data
;
850 data
= (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
851 num_regs
= VEC_length (tdesc_arch_reg
, data
->arch_regs
);
852 for (i
= 0; i
< num_regs
; i
++)
854 reg
= VEC_index (tdesc_arch_reg
, data
->arch_regs
, i
);
856 && reg
->reg
->tdesc_type
858 && strcmp (id
, reg
->reg
->tdesc_type
->name
) == 0)
865 /* Construct, if necessary, and return the GDB type implementing target
866 type TDESC_TYPE for architecture GDBARCH. */
869 tdesc_gdb_type (struct gdbarch
*gdbarch
, struct tdesc_type
*tdesc_type
)
873 switch (tdesc_type
->kind
)
875 /* Predefined types. */
876 case TDESC_TYPE_BOOL
:
877 return builtin_type (gdbarch
)->builtin_bool
;
879 case TDESC_TYPE_INT8
:
880 return builtin_type (gdbarch
)->builtin_int8
;
882 case TDESC_TYPE_INT16
:
883 return builtin_type (gdbarch
)->builtin_int16
;
885 case TDESC_TYPE_INT32
:
886 return builtin_type (gdbarch
)->builtin_int32
;
888 case TDESC_TYPE_INT64
:
889 return builtin_type (gdbarch
)->builtin_int64
;
891 case TDESC_TYPE_INT128
:
892 return builtin_type (gdbarch
)->builtin_int128
;
894 case TDESC_TYPE_UINT8
:
895 return builtin_type (gdbarch
)->builtin_uint8
;
897 case TDESC_TYPE_UINT16
:
898 return builtin_type (gdbarch
)->builtin_uint16
;
900 case TDESC_TYPE_UINT32
:
901 return builtin_type (gdbarch
)->builtin_uint32
;
903 case TDESC_TYPE_UINT64
:
904 return builtin_type (gdbarch
)->builtin_uint64
;
906 case TDESC_TYPE_UINT128
:
907 return builtin_type (gdbarch
)->builtin_uint128
;
909 case TDESC_TYPE_CODE_PTR
:
910 return builtin_type (gdbarch
)->builtin_func_ptr
;
912 case TDESC_TYPE_DATA_PTR
:
913 return builtin_type (gdbarch
)->builtin_data_ptr
;
919 type
= tdesc_find_type (gdbarch
, tdesc_type
->name
);
923 switch (tdesc_type
->kind
)
925 case TDESC_TYPE_IEEE_SINGLE
:
926 return arch_float_type (gdbarch
, -1, "builtin_type_ieee_single",
927 floatformats_ieee_single
);
929 case TDESC_TYPE_IEEE_DOUBLE
:
930 return arch_float_type (gdbarch
, -1, "builtin_type_ieee_double",
931 floatformats_ieee_double
);
933 case TDESC_TYPE_ARM_FPA_EXT
:
934 return arch_float_type (gdbarch
, -1, "builtin_type_arm_ext",
935 floatformats_arm_ext
);
937 case TDESC_TYPE_I387_EXT
:
938 return arch_float_type (gdbarch
, -1, "builtin_type_i387_ext",
939 floatformats_i387_ext
);
941 /* Types defined by a target feature. */
942 case TDESC_TYPE_VECTOR
:
944 struct type
*type
, *field_type
;
946 field_type
= tdesc_gdb_type (gdbarch
, tdesc_type
->u
.v
.type
);
947 type
= init_vector_type (field_type
, tdesc_type
->u
.v
.count
);
948 TYPE_NAME (type
) = xstrdup (tdesc_type
->name
);
953 case TDESC_TYPE_STRUCT
:
955 struct type
*type
, *field_type
;
956 struct tdesc_type_field
*f
;
959 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
960 TYPE_NAME (type
) = xstrdup (tdesc_type
->name
);
961 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
964 VEC_iterate (tdesc_type_field
, tdesc_type
->u
.u
.fields
, ix
, f
);
967 if (f
->start
!= -1 && f
->end
!= -1)
971 struct type
*field_type
;
972 int bitsize
, total_size
;
974 /* This invariant should be preserved while creating types. */
975 gdb_assert (tdesc_type
->u
.u
.size
!= 0);
977 field_type
= tdesc_gdb_type (gdbarch
, f
->type
);
978 else if (tdesc_type
->u
.u
.size
> 4)
979 field_type
= builtin_type (gdbarch
)->builtin_uint64
;
981 field_type
= builtin_type (gdbarch
)->builtin_uint32
;
983 fld
= append_composite_type_field_raw (type
, xstrdup (f
->name
),
986 /* For little-endian, BITPOS counts from the LSB of
987 the structure and marks the LSB of the field. For
988 big-endian, BITPOS counts from the MSB of the
989 structure and marks the MSB of the field. Either
990 way, it is the number of bits to the "left" of the
991 field. To calculate this in big-endian, we need
992 the total size of the structure. */
993 bitsize
= f
->end
- f
->start
+ 1;
994 total_size
= tdesc_type
->u
.u
.size
* TARGET_CHAR_BIT
;
995 if (gdbarch_bits_big_endian (gdbarch
))
996 SET_FIELD_BITPOS (fld
[0], total_size
- f
->start
- bitsize
);
998 SET_FIELD_BITPOS (fld
[0], f
->start
);
999 FIELD_BITSIZE (fld
[0]) = bitsize
;
1003 gdb_assert (f
->start
== -1 && f
->end
== -1);
1004 field_type
= tdesc_gdb_type (gdbarch
, f
->type
);
1005 append_composite_type_field (type
, xstrdup (f
->name
),
1010 if (tdesc_type
->u
.u
.size
!= 0)
1011 TYPE_LENGTH (type
) = tdesc_type
->u
.u
.size
;
1015 case TDESC_TYPE_UNION
:
1017 struct type
*type
, *field_type
;
1018 struct tdesc_type_field
*f
;
1021 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_UNION
);
1022 TYPE_NAME (type
) = xstrdup (tdesc_type
->name
);
1025 VEC_iterate (tdesc_type_field
, tdesc_type
->u
.u
.fields
, ix
, f
);
1028 field_type
= tdesc_gdb_type (gdbarch
, f
->type
);
1029 append_composite_type_field (type
, xstrdup (f
->name
), field_type
);
1031 /* If any of the children of a union are vectors, flag the
1032 union as a vector also. This allows e.g. a union of two
1033 vector types to show up automatically in "info vector". */
1034 if (TYPE_VECTOR (field_type
))
1035 TYPE_VECTOR (type
) = 1;
1040 case TDESC_TYPE_FLAGS
:
1042 struct tdesc_type_field
*f
;
1045 type
= arch_flags_type (gdbarch
, tdesc_type
->name
,
1046 tdesc_type
->u
.u
.size
* TARGET_CHAR_BIT
);
1048 VEC_iterate (tdesc_type_field
, tdesc_type
->u
.u
.fields
, ix
, f
);
1051 struct type
*field_type
;
1052 int bitsize
= f
->end
- f
->start
+ 1;
1054 gdb_assert (f
->type
!= NULL
);
1055 field_type
= tdesc_gdb_type (gdbarch
, f
->type
);
1056 append_flags_type_field (type
, f
->start
, bitsize
,
1057 field_type
, f
->name
);
1063 case TDESC_TYPE_ENUM
:
1065 struct tdesc_type_field
*f
;
1068 type
= arch_type (gdbarch
, TYPE_CODE_ENUM
,
1069 tdesc_type
->u
.u
.size
* TARGET_CHAR_BIT
,
1071 TYPE_UNSIGNED (type
) = 1;
1073 VEC_iterate (tdesc_type_field
, tdesc_type
->u
.u
.fields
, ix
, f
);
1077 = append_composite_type_field_raw (type
, xstrdup (f
->name
),
1080 SET_FIELD_BITPOS (fld
[0], f
->start
);
1087 internal_error (__FILE__
, __LINE__
,
1088 "Type \"%s\" has an unknown kind %d",
1089 tdesc_type
->name
, tdesc_type
->kind
);
1093 /* Support for registers from target descriptions. */
1095 /* Construct the per-gdbarch data. */
1098 tdesc_data_init (struct obstack
*obstack
)
1100 struct tdesc_arch_data
*data
;
1102 data
= OBSTACK_ZALLOC (obstack
, struct tdesc_arch_data
);
1106 /* Similar, but for the temporary copy used during architecture
1109 struct tdesc_arch_data
*
1110 tdesc_data_alloc (void)
1112 return XCNEW (struct tdesc_arch_data
);
1115 /* Free something allocated by tdesc_data_alloc, if it is not going
1116 to be used (for instance if it was unsuitable for the
1120 tdesc_data_cleanup (void *data_untyped
)
1122 struct tdesc_arch_data
*data
= (struct tdesc_arch_data
*) data_untyped
;
1124 VEC_free (tdesc_arch_reg
, data
->arch_regs
);
1128 /* Search FEATURE for a register named NAME. */
1130 static struct tdesc_reg
*
1131 tdesc_find_register_early (const struct tdesc_feature
*feature
,
1135 struct tdesc_reg
*reg
;
1138 VEC_iterate (tdesc_reg_p
, feature
->registers
, ixr
, reg
);
1140 if (strcasecmp (reg
->name
, name
) == 0)
1146 /* Search FEATURE for a register named NAME. Assign REGNO to it. */
1149 tdesc_numbered_register (const struct tdesc_feature
*feature
,
1150 struct tdesc_arch_data
*data
,
1151 int regno
, const char *name
)
1153 struct tdesc_arch_reg arch_reg
= { 0 };
1154 struct tdesc_reg
*reg
= tdesc_find_register_early (feature
, name
);
1159 /* Make sure the vector includes a REGNO'th element. */
1160 while (regno
>= VEC_length (tdesc_arch_reg
, data
->arch_regs
))
1161 VEC_safe_push (tdesc_arch_reg
, data
->arch_regs
, &arch_reg
);
1164 VEC_replace (tdesc_arch_reg
, data
->arch_regs
, regno
, &arch_reg
);
1168 /* Search FEATURE for a register named NAME, but do not assign a fixed
1169 register number to it. */
1172 tdesc_unnumbered_register (const struct tdesc_feature
*feature
,
1175 struct tdesc_reg
*reg
= tdesc_find_register_early (feature
, name
);
1183 /* Search FEATURE for a register whose name is in NAMES and assign
1187 tdesc_numbered_register_choices (const struct tdesc_feature
*feature
,
1188 struct tdesc_arch_data
*data
,
1189 int regno
, const char *const names
[])
1193 for (i
= 0; names
[i
] != NULL
; i
++)
1194 if (tdesc_numbered_register (feature
, data
, regno
, names
[i
]))
1200 /* Search FEATURE for a register named NAME, and return its size in
1201 bits. The register must exist. */
1204 tdesc_register_size (const struct tdesc_feature
*feature
,
1207 struct tdesc_reg
*reg
= tdesc_find_register_early (feature
, name
);
1209 gdb_assert (reg
!= NULL
);
1210 return reg
->bitsize
;
1213 /* Look up a register by its GDB internal register number. */
1215 static struct tdesc_arch_reg
*
1216 tdesc_find_arch_register (struct gdbarch
*gdbarch
, int regno
)
1218 struct tdesc_arch_data
*data
;
1220 data
= (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1221 if (regno
< VEC_length (tdesc_arch_reg
, data
->arch_regs
))
1222 return VEC_index (tdesc_arch_reg
, data
->arch_regs
, regno
);
1227 static struct tdesc_reg
*
1228 tdesc_find_register (struct gdbarch
*gdbarch
, int regno
)
1230 struct tdesc_arch_reg
*reg
= tdesc_find_arch_register (gdbarch
, regno
);
1232 return reg
? reg
->reg
: NULL
;
1235 /* Return the name of register REGNO, from the target description or
1236 from an architecture-provided pseudo_register_name method. */
1239 tdesc_register_name (struct gdbarch
*gdbarch
, int regno
)
1241 struct tdesc_reg
*reg
= tdesc_find_register (gdbarch
, regno
);
1242 int num_regs
= gdbarch_num_regs (gdbarch
);
1243 int num_pseudo_regs
= gdbarch_num_pseudo_regs (gdbarch
);
1248 if (regno
>= num_regs
&& regno
< num_regs
+ num_pseudo_regs
)
1250 struct tdesc_arch_data
*data
1251 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1253 gdb_assert (data
->pseudo_register_name
!= NULL
);
1254 return data
->pseudo_register_name (gdbarch
, regno
);
1261 tdesc_register_type (struct gdbarch
*gdbarch
, int regno
)
1263 struct tdesc_arch_reg
*arch_reg
= tdesc_find_arch_register (gdbarch
, regno
);
1264 struct tdesc_reg
*reg
= arch_reg
? arch_reg
->reg
: NULL
;
1265 int num_regs
= gdbarch_num_regs (gdbarch
);
1266 int num_pseudo_regs
= gdbarch_num_pseudo_regs (gdbarch
);
1268 if (reg
== NULL
&& regno
>= num_regs
&& regno
< num_regs
+ num_pseudo_regs
)
1270 struct tdesc_arch_data
*data
1271 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1273 gdb_assert (data
->pseudo_register_type
!= NULL
);
1274 return data
->pseudo_register_type (gdbarch
, regno
);
1278 /* Return "int0_t", since "void" has a misleading size of one. */
1279 return builtin_type (gdbarch
)->builtin_int0
;
1281 if (arch_reg
->type
== NULL
)
1283 /* First check for a predefined or target defined type. */
1284 if (reg
->tdesc_type
)
1285 arch_reg
->type
= tdesc_gdb_type (gdbarch
, reg
->tdesc_type
);
1287 /* Next try size-sensitive type shortcuts. */
1288 else if (strcmp (reg
->type
, "float") == 0)
1290 if (reg
->bitsize
== gdbarch_float_bit (gdbarch
))
1291 arch_reg
->type
= builtin_type (gdbarch
)->builtin_float
;
1292 else if (reg
->bitsize
== gdbarch_double_bit (gdbarch
))
1293 arch_reg
->type
= builtin_type (gdbarch
)->builtin_double
;
1294 else if (reg
->bitsize
== gdbarch_long_double_bit (gdbarch
))
1295 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long_double
;
1298 warning (_("Register \"%s\" has an unsupported size (%d bits)"),
1299 reg
->name
, reg
->bitsize
);
1300 arch_reg
->type
= builtin_type (gdbarch
)->builtin_double
;
1303 else if (strcmp (reg
->type
, "int") == 0)
1305 if (reg
->bitsize
== gdbarch_long_bit (gdbarch
))
1306 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long
;
1307 else if (reg
->bitsize
== TARGET_CHAR_BIT
)
1308 arch_reg
->type
= builtin_type (gdbarch
)->builtin_char
;
1309 else if (reg
->bitsize
== gdbarch_short_bit (gdbarch
))
1310 arch_reg
->type
= builtin_type (gdbarch
)->builtin_short
;
1311 else if (reg
->bitsize
== gdbarch_int_bit (gdbarch
))
1312 arch_reg
->type
= builtin_type (gdbarch
)->builtin_int
;
1313 else if (reg
->bitsize
== gdbarch_long_long_bit (gdbarch
))
1314 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long_long
;
1315 else if (reg
->bitsize
== gdbarch_ptr_bit (gdbarch
))
1316 /* A bit desperate by this point... */
1317 arch_reg
->type
= builtin_type (gdbarch
)->builtin_data_ptr
;
1320 warning (_("Register \"%s\" has an unsupported size (%d bits)"),
1321 reg
->name
, reg
->bitsize
);
1322 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long
;
1326 if (arch_reg
->type
== NULL
)
1327 internal_error (__FILE__
, __LINE__
,
1328 "Register \"%s\" has an unknown type \"%s\"",
1329 reg
->name
, reg
->type
);
1332 return arch_reg
->type
;
1336 tdesc_remote_register_number (struct gdbarch
*gdbarch
, int regno
)
1338 struct tdesc_reg
*reg
= tdesc_find_register (gdbarch
, regno
);
1341 return reg
->target_regnum
;
1346 /* Check whether REGNUM is a member of REGGROUP. Registers from the
1347 target description may be classified as general, float, or vector.
1348 Unlike a gdbarch register_reggroup_p method, this function will
1349 return -1 if it does not know; the caller should handle registers
1350 with no specified group.
1352 Arbitrary strings (other than "general", "float", and "vector")
1353 from the description are not used; they cause the register to be
1354 displayed in "info all-registers" but excluded from "info
1355 registers" et al. The names of containing features are also not
1356 used. This might be extended to display registers in some more
1359 The save-restore flag is also implemented here. */
1362 tdesc_register_in_reggroup_p (struct gdbarch
*gdbarch
, int regno
,
1363 struct reggroup
*reggroup
)
1365 struct tdesc_reg
*reg
= tdesc_find_register (gdbarch
, regno
);
1367 if (reg
!= NULL
&& reg
->group
!= NULL
)
1369 int general_p
= 0, float_p
= 0, vector_p
= 0;
1371 if (strcmp (reg
->group
, "general") == 0)
1373 else if (strcmp (reg
->group
, "float") == 0)
1375 else if (strcmp (reg
->group
, "vector") == 0)
1378 if (reggroup
== float_reggroup
)
1381 if (reggroup
== vector_reggroup
)
1384 if (reggroup
== general_reggroup
)
1389 && (reggroup
== save_reggroup
|| reggroup
== restore_reggroup
))
1390 return reg
->save_restore
;
1395 /* Check whether REGNUM is a member of REGGROUP. Registers with no
1396 group specified go to the default reggroup function and are handled
1400 tdesc_register_reggroup_p (struct gdbarch
*gdbarch
, int regno
,
1401 struct reggroup
*reggroup
)
1403 int num_regs
= gdbarch_num_regs (gdbarch
);
1404 int num_pseudo_regs
= gdbarch_num_pseudo_regs (gdbarch
);
1407 if (regno
>= num_regs
&& regno
< num_regs
+ num_pseudo_regs
)
1409 struct tdesc_arch_data
*data
1410 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1412 if (data
->pseudo_register_reggroup_p
!= NULL
)
1413 return data
->pseudo_register_reggroup_p (gdbarch
, regno
, reggroup
);
1414 /* Otherwise fall through to the default reggroup_p. */
1417 ret
= tdesc_register_in_reggroup_p (gdbarch
, regno
, reggroup
);
1421 return default_register_reggroup_p (gdbarch
, regno
, reggroup
);
1424 /* Record architecture-specific functions to call for pseudo-register
1428 set_tdesc_pseudo_register_name (struct gdbarch
*gdbarch
,
1429 gdbarch_register_name_ftype
*pseudo_name
)
1431 struct tdesc_arch_data
*data
1432 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1434 data
->pseudo_register_name
= pseudo_name
;
1438 set_tdesc_pseudo_register_type (struct gdbarch
*gdbarch
,
1439 gdbarch_register_type_ftype
*pseudo_type
)
1441 struct tdesc_arch_data
*data
1442 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1444 data
->pseudo_register_type
= pseudo_type
;
1448 set_tdesc_pseudo_register_reggroup_p
1449 (struct gdbarch
*gdbarch
,
1450 gdbarch_register_reggroup_p_ftype
*pseudo_reggroup_p
)
1452 struct tdesc_arch_data
*data
1453 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1455 data
->pseudo_register_reggroup_p
= pseudo_reggroup_p
;
1458 /* Update GDBARCH to use the target description for registers. */
1461 tdesc_use_registers (struct gdbarch
*gdbarch
,
1462 const struct target_desc
*target_desc
,
1463 struct tdesc_arch_data
*early_data
)
1465 int num_regs
= gdbarch_num_regs (gdbarch
);
1467 struct tdesc_feature
*feature
;
1468 struct tdesc_reg
*reg
;
1469 struct tdesc_arch_data
*data
;
1470 struct tdesc_arch_reg
*arch_reg
, new_arch_reg
= { 0 };
1473 /* We can't use the description for registers if it doesn't describe
1474 any. This function should only be called after validating
1475 registers, so the caller should know that registers are
1477 gdb_assert (tdesc_has_registers (target_desc
));
1479 data
= (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1480 data
->arch_regs
= early_data
->arch_regs
;
1483 /* Build up a set of all registers, so that we can assign register
1484 numbers where needed. The hash table expands as necessary, so
1485 the initial size is arbitrary. */
1486 reg_hash
= htab_create (37, htab_hash_pointer
, htab_eq_pointer
, NULL
);
1488 VEC_iterate (tdesc_feature_p
, target_desc
->features
, ixf
, feature
);
1491 VEC_iterate (tdesc_reg_p
, feature
->registers
, ixr
, reg
);
1494 void **slot
= htab_find_slot (reg_hash
, reg
, INSERT
);
1499 /* Remove any registers which were assigned numbers by the
1502 VEC_iterate (tdesc_arch_reg
, data
->arch_regs
, ixr
, arch_reg
);
1505 htab_remove_elt (reg_hash
, arch_reg
->reg
);
1507 /* Assign numbers to the remaining registers and add them to the
1508 list of registers. The new numbers are always above gdbarch_num_regs.
1509 Iterate over the features, not the hash table, so that the order
1510 matches that in the target description. */
1512 gdb_assert (VEC_length (tdesc_arch_reg
, data
->arch_regs
) <= num_regs
);
1513 while (VEC_length (tdesc_arch_reg
, data
->arch_regs
) < num_regs
)
1514 VEC_safe_push (tdesc_arch_reg
, data
->arch_regs
, &new_arch_reg
);
1516 VEC_iterate (tdesc_feature_p
, target_desc
->features
, ixf
, feature
);
1519 VEC_iterate (tdesc_reg_p
, feature
->registers
, ixr
, reg
);
1521 if (htab_find (reg_hash
, reg
) != NULL
)
1523 new_arch_reg
.reg
= reg
;
1524 VEC_safe_push (tdesc_arch_reg
, data
->arch_regs
, &new_arch_reg
);
1528 htab_delete (reg_hash
);
1530 /* Update the architecture. */
1531 set_gdbarch_num_regs (gdbarch
, num_regs
);
1532 set_gdbarch_register_name (gdbarch
, tdesc_register_name
);
1533 set_gdbarch_register_type (gdbarch
, tdesc_register_type
);
1534 set_gdbarch_remote_register_number (gdbarch
,
1535 tdesc_remote_register_number
);
1536 set_gdbarch_register_reggroup_p (gdbarch
, tdesc_register_reggroup_p
);
1540 /* See arch/tdesc.h. */
1543 tdesc_create_reg (struct tdesc_feature
*feature
, const char *name
,
1544 int regnum
, int save_restore
, const char *group
,
1545 int bitsize
, const char *type
)
1547 tdesc_reg
*reg
= new tdesc_reg (feature
, name
, regnum
, save_restore
,
1548 group
, bitsize
, type
);
1550 VEC_safe_push (tdesc_reg_p
, feature
->registers
, reg
);
1553 /* See arch/tdesc.h. */
1556 tdesc_create_vector (struct tdesc_feature
*feature
, const char *name
,
1557 struct tdesc_type
*field_type
, int count
)
1559 struct tdesc_type
*type
= new tdesc_type (name
, TDESC_TYPE_VECTOR
);
1561 type
->u
.v
.type
= field_type
;
1562 type
->u
.v
.count
= count
;
1564 VEC_safe_push (tdesc_type_p
, feature
->types
, type
);
1568 /* See arch/tdesc.h. */
1571 tdesc_create_struct (struct tdesc_feature
*feature
, const char *name
)
1573 struct tdesc_type
*type
= new tdesc_type (name
, TDESC_TYPE_STRUCT
);
1575 VEC_safe_push (tdesc_type_p
, feature
->types
, type
);
1579 /* See arch/tdesc.h. */
1582 tdesc_set_struct_size (struct tdesc_type
*type
, int size
)
1584 gdb_assert (type
->kind
== TDESC_TYPE_STRUCT
);
1585 gdb_assert (size
> 0);
1586 type
->u
.u
.size
= size
;
1589 /* See arch/tdesc.h. */
1592 tdesc_create_union (struct tdesc_feature
*feature
, const char *name
)
1594 struct tdesc_type
*type
= new tdesc_type (name
, TDESC_TYPE_UNION
);
1596 VEC_safe_push (tdesc_type_p
, feature
->types
, type
);
1600 /* See arch/tdesc.h. */
1603 tdesc_create_flags (struct tdesc_feature
*feature
, const char *name
,
1606 struct tdesc_type
*type
= new tdesc_type (name
, TDESC_TYPE_FLAGS
);
1608 gdb_assert (size
> 0);
1610 type
->u
.u
.size
= size
;
1612 VEC_safe_push (tdesc_type_p
, feature
->types
, type
);
1617 tdesc_create_enum (struct tdesc_feature
*feature
, const char *name
,
1620 struct tdesc_type
*type
= new tdesc_type (name
, TDESC_TYPE_ENUM
);
1622 gdb_assert (size
> 0);
1624 type
->u
.u
.size
= size
;
1626 VEC_safe_push (tdesc_type_p
, feature
->types
, type
);
1630 /* See arch/tdesc.h. */
1633 tdesc_add_field (struct tdesc_type
*type
, const char *field_name
,
1634 struct tdesc_type
*field_type
)
1636 struct tdesc_type_field f
= { 0 };
1638 gdb_assert (type
->kind
== TDESC_TYPE_UNION
1639 || type
->kind
== TDESC_TYPE_STRUCT
);
1641 f
.name
= xstrdup (field_name
);
1642 f
.type
= field_type
;
1643 /* Initialize these values so we know this is not a bit-field
1644 when we print-c-tdesc. */
1648 VEC_safe_push (tdesc_type_field
, type
->u
.u
.fields
, &f
);
1652 tdesc_add_typed_bitfield (struct tdesc_type
*type
, const char *field_name
,
1653 int start
, int end
, struct tdesc_type
*field_type
)
1655 struct tdesc_type_field f
= { 0 };
1657 gdb_assert (type
->kind
== TDESC_TYPE_STRUCT
1658 || type
->kind
== TDESC_TYPE_FLAGS
);
1659 gdb_assert (start
>= 0 && end
>= start
);
1661 f
.name
= xstrdup (field_name
);
1664 f
.type
= field_type
;
1666 VEC_safe_push (tdesc_type_field
, type
->u
.u
.fields
, &f
);
1669 /* See arch/tdesc.h. */
1672 tdesc_add_bitfield (struct tdesc_type
*type
, const char *field_name
,
1675 struct tdesc_type
*field_type
;
1677 gdb_assert (start
>= 0 && end
>= start
);
1679 if (type
->u
.u
.size
> 4)
1680 field_type
= tdesc_predefined_type (TDESC_TYPE_UINT64
);
1682 field_type
= tdesc_predefined_type (TDESC_TYPE_UINT32
);
1684 tdesc_add_typed_bitfield (type
, field_name
, start
, end
, field_type
);
1687 /* See arch/tdesc.h. */
1690 tdesc_add_flag (struct tdesc_type
*type
, int start
,
1691 const char *flag_name
)
1693 struct tdesc_type_field f
= { 0 };
1695 gdb_assert (type
->kind
== TDESC_TYPE_FLAGS
1696 || type
->kind
== TDESC_TYPE_STRUCT
);
1698 f
.name
= xstrdup (flag_name
);
1701 f
.type
= tdesc_predefined_type (TDESC_TYPE_BOOL
);
1703 VEC_safe_push (tdesc_type_field
, type
->u
.u
.fields
, &f
);
1707 tdesc_add_enum_value (struct tdesc_type
*type
, int value
,
1710 struct tdesc_type_field f
= { 0 };
1712 gdb_assert (type
->kind
== TDESC_TYPE_ENUM
);
1714 f
.name
= xstrdup (name
);
1717 f
.type
= tdesc_predefined_type (TDESC_TYPE_INT32
);
1719 VEC_safe_push (tdesc_type_field
, type
->u
.u
.fields
, &f
);
1722 /* See arch/tdesc.h. */
1724 struct tdesc_feature
*
1725 tdesc_create_feature (struct target_desc
*tdesc
, const char *name
,
1728 struct tdesc_feature
*new_feature
= new tdesc_feature (name
);
1730 VEC_safe_push (tdesc_feature_p
, tdesc
->features
, new_feature
);
1734 struct target_desc
*
1735 allocate_target_description (void)
1737 return new target_desc ();
1741 free_target_description (void *arg
)
1743 struct target_desc
*target_desc
= (struct target_desc
*) arg
;
1749 make_cleanup_free_target_description (struct target_desc
*target_desc
)
1751 return make_cleanup (free_target_description
, target_desc
);
1755 tdesc_add_compatible (struct target_desc
*target_desc
,
1756 const struct bfd_arch_info
*compatible
)
1758 /* If this instance of GDB is compiled without BFD support for the
1759 compatible architecture, simply ignore it -- we would not be able
1760 to handle it anyway. */
1761 if (compatible
== NULL
)
1764 for (const bfd_arch_info
*compat
: target_desc
->compatible
)
1765 if (compat
== compatible
)
1766 internal_error (__FILE__
, __LINE__
,
1767 _("Attempted to add duplicate "
1768 "compatible architecture \"%s\""),
1769 compatible
->printable_name
);
1771 target_desc
->compatible
.push_back (compatible
);
1775 set_tdesc_property (struct target_desc
*target_desc
,
1776 const char *key
, const char *value
)
1778 gdb_assert (key
!= NULL
&& value
!= NULL
);
1780 if (tdesc_property (target_desc
, key
) != NULL
)
1781 internal_error (__FILE__
, __LINE__
,
1782 _("Attempted to add duplicate property \"%s\""), key
);
1784 target_desc
->properties
.emplace_back (key
, value
);
1787 /* See arch/tdesc.h. */
1790 set_tdesc_architecture (struct target_desc
*target_desc
,
1793 set_tdesc_architecture (target_desc
, bfd_scan_arch (name
));
1797 set_tdesc_architecture (struct target_desc
*target_desc
,
1798 const struct bfd_arch_info
*arch
)
1800 target_desc
->arch
= arch
;
1803 /* See arch/tdesc.h. */
1806 set_tdesc_osabi (struct target_desc
*target_desc
, const char *name
)
1808 set_tdesc_osabi (target_desc
, osabi_from_tdesc_string (name
));
1812 set_tdesc_osabi (struct target_desc
*target_desc
, enum gdb_osabi osabi
)
1814 target_desc
->osabi
= osabi
;
1818 static struct cmd_list_element
*tdesc_set_cmdlist
, *tdesc_show_cmdlist
;
1819 static struct cmd_list_element
*tdesc_unset_cmdlist
;
1821 /* Helper functions for the CLI commands. */
1824 set_tdesc_cmd (const char *args
, int from_tty
)
1826 help_list (tdesc_set_cmdlist
, "set tdesc ", all_commands
, gdb_stdout
);
1830 show_tdesc_cmd (const char *args
, int from_tty
)
1832 cmd_show_list (tdesc_show_cmdlist
, from_tty
, "");
1836 unset_tdesc_cmd (const char *args
, int from_tty
)
1838 help_list (tdesc_unset_cmdlist
, "unset tdesc ", all_commands
, gdb_stdout
);
1842 set_tdesc_filename_cmd (const char *args
, int from_tty
,
1843 struct cmd_list_element
*c
)
1845 xfree (target_description_filename
);
1846 target_description_filename
= xstrdup (tdesc_filename_cmd_string
);
1848 target_clear_description ();
1849 target_find_description ();
1853 show_tdesc_filename_cmd (struct ui_file
*file
, int from_tty
,
1854 struct cmd_list_element
*c
,
1857 value
= target_description_filename
;
1859 if (value
!= NULL
&& *value
!= '\0')
1860 printf_filtered (_("The target description will be read from \"%s\".\n"),
1863 printf_filtered (_("The target description will be "
1864 "read from the target.\n"));
1868 unset_tdesc_filename_cmd (const char *args
, int from_tty
)
1870 xfree (target_description_filename
);
1871 target_description_filename
= NULL
;
1872 target_clear_description ();
1873 target_find_description ();
1876 /* Print target description in C. */
1878 class print_c_tdesc
: public tdesc_element_visitor
1881 print_c_tdesc (std::string
&filename_after_features
)
1882 : m_filename_after_features (filename_after_features
)
1886 const char *filename
= lbasename (m_filename_after_features
.c_str ());
1888 m_function
= (char *) xmalloc (strlen (filename
) + 1);
1889 for (inp
= filename
, outp
= m_function
; *inp
!= '\0'; inp
++)
1892 else if (*inp
== '-')
1898 /* Standard boilerplate. */
1899 printf_unfiltered ("/* THIS FILE IS GENERATED. "
1900 "-*- buffer-read-only: t -*- vi"
1909 void visit_pre (const target_desc
*e
) override
1911 printf_unfiltered (" Original: %s */\n\n",
1912 lbasename (m_filename_after_features
.c_str ()));
1914 printf_unfiltered ("#include \"defs.h\"\n");
1915 printf_unfiltered ("#include \"osabi.h\"\n");
1916 printf_unfiltered ("#include \"target-descriptions.h\"\n");
1917 printf_unfiltered ("\n");
1919 printf_unfiltered ("struct target_desc *tdesc_%s;\n", m_function
);
1920 printf_unfiltered ("static void\n");
1921 printf_unfiltered ("initialize_tdesc_%s (void)\n", m_function
);
1922 printf_unfiltered ("{\n");
1924 (" struct target_desc *result = allocate_target_description ();\n");
1926 if (tdesc_architecture (e
) != NULL
)
1929 (" set_tdesc_architecture (result, bfd_scan_arch (\"%s\"));\n",
1930 tdesc_architecture (e
)->printable_name
);
1931 printf_unfiltered ("\n");
1933 if (tdesc_osabi (e
) > GDB_OSABI_UNKNOWN
1934 && tdesc_osabi (e
) < GDB_OSABI_INVALID
)
1937 (" set_tdesc_osabi (result, osabi_from_tdesc_string (\"%s\"));\n",
1938 gdbarch_osabi_name (tdesc_osabi (e
)));
1939 printf_unfiltered ("\n");
1942 for (const struct bfd_arch_info
*compatible
: e
->compatible
)
1944 (" tdesc_add_compatible (result, bfd_scan_arch (\"%s\"));\n",
1945 compatible
->printable_name
);
1947 if (!e
->compatible
.empty ())
1948 printf_unfiltered ("\n");
1950 for (const property
&prop
: e
->properties
)
1951 printf_unfiltered (" set_tdesc_property (result, \"%s\", \"%s\");\n",
1952 prop
.key
.c_str (), prop
.value
.c_str ());
1954 printf_unfiltered (" struct tdesc_feature *feature;\n");
1957 void visit_pre (const tdesc_feature
*e
) override
1959 printf_unfiltered ("\n feature = tdesc_create_feature (result, \"%s\");\n",
1963 void visit_post (const tdesc_feature
*e
) override
1966 void visit_post (const target_desc
*e
) override
1968 printf_unfiltered ("\n tdesc_%s = result;\n", m_function
);
1969 printf_unfiltered ("}\n");
1972 void visit (const tdesc_type
*type
) override
1974 struct tdesc_type_field
*f
;
1976 /* Now we do some "filtering" in order to know which variables to
1977 declare. This is needed because otherwise we would declare unused
1978 variables `field_type' and `type'. */
1979 if (!m_printed_field_type
)
1981 printf_unfiltered (" struct tdesc_type *field_type;\n");
1982 m_printed_field_type
= true;
1985 if ((type
->kind
== TDESC_TYPE_UNION
1986 || type
->kind
== TDESC_TYPE_STRUCT
1987 || type
->kind
== TDESC_TYPE_FLAGS
1988 || type
->kind
== TDESC_TYPE_ENUM
)
1989 && VEC_length (tdesc_type_field
, type
->u
.u
.fields
) > 0
1992 printf_unfiltered (" struct tdesc_type *type;\n");
1993 m_printed_type
= true;
1998 case TDESC_TYPE_VECTOR
:
2000 (" field_type = tdesc_named_type (feature, \"%s\");\n",
2001 type
->u
.v
.type
->name
);
2003 (" tdesc_create_vector (feature, \"%s\", field_type, %d);\n",
2004 type
->name
, type
->u
.v
.count
);
2006 case TDESC_TYPE_STRUCT
:
2007 case TDESC_TYPE_FLAGS
:
2008 if (type
->kind
== TDESC_TYPE_STRUCT
)
2011 (" type = tdesc_create_struct (feature, \"%s\");\n",
2013 if (type
->u
.u
.size
!= 0)
2015 (" tdesc_set_struct_size (type, %d);\n",
2021 (" type = tdesc_create_flags (feature, \"%s\", %d);\n",
2022 type
->name
, type
->u
.u
.size
);
2025 VEC_iterate (tdesc_type_field
, type
->u
.u
.fields
, ix3
, f
);
2028 const char *type_name
;
2030 gdb_assert (f
->type
!= NULL
);
2031 type_name
= f
->type
->name
;
2033 /* To minimize changes to generated files, don't emit type
2034 info for fields that have defaulted types. */
2037 gdb_assert (f
->end
!= -1);
2038 if (f
->type
->kind
== TDESC_TYPE_BOOL
)
2040 gdb_assert (f
->start
== f
->end
);
2042 (" tdesc_add_flag (type, %d, \"%s\");\n",
2045 else if ((type
->u
.u
.size
== 4
2046 && f
->type
->kind
== TDESC_TYPE_UINT32
)
2047 || (type
->u
.u
.size
== 8
2048 && f
->type
->kind
== TDESC_TYPE_UINT64
))
2051 (" tdesc_add_bitfield (type, \"%s\", %d, %d);\n",
2052 f
->name
, f
->start
, f
->end
);
2057 (" field_type = tdesc_named_type (feature,"
2061 (" tdesc_add_typed_bitfield (type, \"%s\","
2062 " %d, %d, field_type);\n",
2063 f
->name
, f
->start
, f
->end
);
2066 else /* Not a bitfield. */
2068 gdb_assert (f
->end
== -1);
2069 gdb_assert (type
->kind
== TDESC_TYPE_STRUCT
);
2071 (" field_type = tdesc_named_type (feature,"
2075 (" tdesc_add_field (type, \"%s\", field_type);\n",
2080 case TDESC_TYPE_UNION
:
2082 (" type = tdesc_create_union (feature, \"%s\");\n",
2085 VEC_iterate (tdesc_type_field
, type
->u
.u
.fields
, ix3
, f
);
2089 (" field_type = tdesc_named_type (feature, \"%s\");\n",
2092 (" tdesc_add_field (type, \"%s\", field_type);\n",
2096 case TDESC_TYPE_ENUM
:
2098 (" type = tdesc_create_enum (feature, \"%s\", %d);\n",
2099 type
->name
, type
->u
.u
.size
);
2101 VEC_iterate (tdesc_type_field
, type
->u
.u
.fields
, ix3
, f
);
2104 (" tdesc_add_enum_value (type, %d, \"%s\");\n",
2108 error (_("C output is not supported type \"%s\"."), type
->name
);
2110 printf_unfiltered ("\n");
2113 void visit (const tdesc_reg
*reg
) override
2115 printf_unfiltered (" tdesc_create_reg (feature, \"%s\", %ld, %d, ",
2116 reg
->name
, reg
->target_regnum
, reg
->save_restore
);
2118 printf_unfiltered ("\"%s\", ", reg
->group
);
2120 printf_unfiltered ("NULL, ");
2121 printf_unfiltered ("%d, \"%s\");\n", reg
->bitsize
, reg
->type
);
2125 std::string m_filename_after_features
;
2129 bool m_printed_field_type
= false;
2130 bool m_printed_type
= false;
2133 /* Print target description feature in C. */
2135 class print_c_feature
: public print_c_tdesc
2138 print_c_feature (std::string
&file
)
2139 : print_c_tdesc (file
)
2142 auto const pos
= m_filename_after_features
.find_last_of ('.');
2144 m_filename_after_features
= m_filename_after_features
.substr (0, pos
);
2147 void visit_pre (const target_desc
*e
) override
2149 printf_unfiltered (" Original: %s */\n\n",
2150 lbasename (m_filename_after_features
.c_str ()));
2152 printf_unfiltered ("#include \"arch/tdesc.h\"\n");
2153 printf_unfiltered ("\n");
2156 void visit_post (const target_desc
*e
) override
2159 void visit_pre (const tdesc_feature
*e
) override
2161 std::string
name (m_filename_after_features
);
2163 auto pos
= name
.find_first_of ('.');
2165 name
= name
.substr (0, pos
);
2166 std::replace (name
.begin (), name
.end (), '/', '_');
2167 std::replace (name
.begin (), name
.end (), '-', '_');
2169 printf_unfiltered ("static int\n");
2170 printf_unfiltered ("create_feature_%s ", name
.c_str ());
2171 printf_unfiltered ("(struct target_desc *result, long regnum)\n");
2173 printf_unfiltered ("{\n");
2174 printf_unfiltered (" struct tdesc_feature *feature;\n");
2177 ("\n feature = tdesc_create_feature (result, \"%s\", \"%s\");\n",
2178 e
->name
, lbasename (m_filename_after_features
.c_str ()));
2181 void visit_post (const tdesc_feature
*e
) override
2183 printf_unfiltered (" return regnum;\n");
2184 printf_unfiltered ("}\n");
2187 void visit (const tdesc_reg
*reg
) override
2189 /* Most "reg" in XML target descriptions don't have "regnum"
2190 attribute, so the register number is allocated sequentially.
2191 In case that reg has "regnum" attribute, register number
2192 should be set by that explicitly. */
2194 if (reg
->target_regnum
< m_next_regnum
)
2196 /* The integrity check, it can catch some errors on register
2197 number collision, like this,
2199 <reg name="x0" bitsize="32"/>
2200 <reg name="x1" bitsize="32"/>
2201 <reg name="x2" bitsize="32"/>
2202 <reg name="x3" bitsize="32"/>
2203 <reg name="ps" bitsize="32" regnum="3"/>
2205 but it also has false negatives. The target description
2208 <reg name="x1" bitsize="32" regnum="1"/>
2209 <reg name="x3" bitsize="32" regnum="3"/>
2210 <reg name="x2" bitsize="32" regnum="2"/>
2211 <reg name="x4" bitsize="32" regnum="4"/>
2213 but it is not a good practice, so still error on this,
2214 and also print the message so that it can be saved in the
2215 generated c file. */
2217 printf_unfiltered ("ERROR: \"regnum\" attribute %ld ",
2218 reg
->target_regnum
);
2219 printf_unfiltered ("is not the largest number (%d).\n",
2221 error (_("\"regnum\" attribute %ld is not the largest number (%d)."),
2222 reg
->target_regnum
, m_next_regnum
);
2225 if (reg
->target_regnum
> m_next_regnum
)
2227 printf_unfiltered (" regnum = %ld;\n", reg
->target_regnum
);
2228 m_next_regnum
= reg
->target_regnum
;
2231 printf_unfiltered (" tdesc_create_reg (feature, \"%s\", regnum++, %d, ",
2232 reg
->name
, reg
->save_restore
);
2234 printf_unfiltered ("\"%s\", ", reg
->group
);
2236 printf_unfiltered ("NULL, ");
2237 printf_unfiltered ("%d, \"%s\");\n", reg
->bitsize
, reg
->type
);
2243 /* The register number to use for the next register we see. */
2244 int m_next_regnum
= 0;
2248 maint_print_c_tdesc_cmd (const char *args
, int from_tty
)
2250 const struct target_desc
*tdesc
;
2251 const char *filename
;
2255 /* Use the global target-supplied description, not the current
2256 architecture's. This lets a GDB for one architecture generate C
2257 for another architecture's description, even though the gdbarch
2258 initialization code will reject the new description. */
2259 tdesc
= current_target_desc
;
2260 filename
= target_description_filename
;
2264 /* Use the target description from the XML file. */
2266 tdesc
= file_read_description_xml (filename
);
2270 error (_("There is no target description to print."));
2272 if (filename
== NULL
)
2273 error (_("The current target description did not come from an XML file."));
2275 std::string
filename_after_features (filename
);
2276 auto loc
= filename_after_features
.rfind ("/features/");
2278 if (loc
!= std::string::npos
)
2279 filename_after_features
= filename_after_features
.substr (loc
+ 10);
2281 /* Print c files for target features instead of target descriptions,
2282 because c files got from target features are more flexible than the
2284 if (startswith (filename_after_features
.c_str (), "i386/32bit-")
2285 || startswith (filename_after_features
.c_str (), "i386/64bit-")
2286 || startswith (filename_after_features
.c_str (), "i386/x32-core.xml")
2287 || startswith (filename_after_features
.c_str (), "tic6x-")
2288 || startswith (filename_after_features
.c_str (), "aarch64"))
2290 print_c_feature
v (filename_after_features
);
2296 print_c_tdesc
v (filename_after_features
);
2302 namespace selftests
{
2304 static std::vector
<std::pair
<const char*, const target_desc
*>> xml_tdesc
;
2308 /* See target-descritpions.h. */
2311 record_xml_tdesc (const char *xml_file
, const struct target_desc
*tdesc
)
2313 xml_tdesc
.emplace_back (xml_file
, tdesc
);
2319 /* Check that the target descriptions created dynamically by
2320 architecture-specific code equal the descriptions created from XML files
2321 found in the specified directory DIR. */
2324 maintenance_check_xml_descriptions (const char *dir
, int from_tty
)
2327 error (_("Missing dir name"));
2329 gdb::unique_xmalloc_ptr
<char> dir1 (tilde_expand (dir
));
2330 std::string
feature_dir (dir1
.get ());
2331 unsigned int failed
= 0;
2333 for (auto const &e
: selftests::xml_tdesc
)
2335 std::string tdesc_xml
= (feature_dir
+ SLASH_STRING
+ e
.first
);
2336 const target_desc
*tdesc
2337 = file_read_description_xml (tdesc_xml
.data ());
2339 if (tdesc
== NULL
|| *tdesc
!= *e
.second
)
2342 printf_filtered (_("Tested %lu XML files, %d failed\n"),
2343 (long) selftests::xml_tdesc
.size (), failed
);
2347 _initialize_target_descriptions (void)
2349 tdesc_data
= gdbarch_data_register_pre_init (tdesc_data_init
);
2351 add_prefix_cmd ("tdesc", class_maintenance
, set_tdesc_cmd
, _("\
2352 Set target description specific variables."),
2353 &tdesc_set_cmdlist
, "set tdesc ",
2354 0 /* allow-unknown */, &setlist
);
2355 add_prefix_cmd ("tdesc", class_maintenance
, show_tdesc_cmd
, _("\
2356 Show target description specific variables."),
2357 &tdesc_show_cmdlist
, "show tdesc ",
2358 0 /* allow-unknown */, &showlist
);
2359 add_prefix_cmd ("tdesc", class_maintenance
, unset_tdesc_cmd
, _("\
2360 Unset target description specific variables."),
2361 &tdesc_unset_cmdlist
, "unset tdesc ",
2362 0 /* allow-unknown */, &unsetlist
);
2364 add_setshow_filename_cmd ("filename", class_obscure
,
2365 &tdesc_filename_cmd_string
,
2367 Set the file to read for an XML target description"), _("\
2368 Show the file to read for an XML target description"), _("\
2369 When set, GDB will read the target description from a local\n\
2370 file instead of querying the remote target."),
2371 set_tdesc_filename_cmd
,
2372 show_tdesc_filename_cmd
,
2373 &tdesc_set_cmdlist
, &tdesc_show_cmdlist
);
2375 add_cmd ("filename", class_obscure
, unset_tdesc_filename_cmd
, _("\
2376 Unset the file to read for an XML target description. When unset,\n\
2377 GDB will read the description from the target."),
2378 &tdesc_unset_cmdlist
);
2380 add_cmd ("c-tdesc", class_maintenance
, maint_print_c_tdesc_cmd
, _("\
2381 Print the current target description as a C source file."),
2382 &maintenanceprintlist
);
2384 cmd_list_element
*cmd
;
2386 cmd
= add_cmd ("xml-descriptions", class_maintenance
,
2387 maintenance_check_xml_descriptions
, _("\
2388 Check the target descriptions created in GDB equal the descriptions\n\
2389 created from XML files in the directory.\n\
2390 The parameter is the directory name."),
2391 &maintenancechecklist
);
2392 set_cmd_completer (cmd
, filename_completer
);