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 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
);
156 typedef std::unique_ptr
<tdesc_reg
> tdesc_reg_up
;
158 /* A named type from a target description. */
160 typedef struct tdesc_type_field
163 struct tdesc_type
*type
;
164 /* For non-enum-values, either both are -1 (non-bitfield), or both are
165 not -1 (bitfield). For enum values, start is the value (which could be
169 DEF_VEC_O(tdesc_type_field
);
173 /* Predefined types. */
187 TDESC_TYPE_IEEE_SINGLE
,
188 TDESC_TYPE_IEEE_DOUBLE
,
189 TDESC_TYPE_ARM_FPA_EXT
,
192 /* Types defined by a target feature. */
200 typedef struct tdesc_type
: tdesc_element
202 tdesc_type (const char *name_
, enum tdesc_type_kind kind_
)
203 : name (xstrdup (name_
)), kind (kind_
)
205 memset (&u
, 0, sizeof (u
));
208 virtual ~tdesc_type ()
212 case TDESC_TYPE_STRUCT
:
213 case TDESC_TYPE_UNION
:
214 case TDESC_TYPE_FLAGS
:
215 case TDESC_TYPE_ENUM
:
217 struct tdesc_type_field
*f
;
221 VEC_iterate (tdesc_type_field
, u
.u
.fields
, ix
, f
);
225 VEC_free (tdesc_type_field
, u
.u
.fields
);
232 xfree ((char *) name
);
235 DISABLE_COPY_AND_ASSIGN (tdesc_type
);
237 /* The name of this type. If this type is a built-in type, this is
238 a pointer to a constant string. Otherwise, it's a
239 malloc-allocated string (and thus must be freed). */
242 /* Identify the kind of this type. */
243 enum tdesc_type_kind kind
;
245 /* Kind-specific data. */
251 struct tdesc_type
*type
;
255 /* Struct, union, flags, or enum type. */
258 VEC(tdesc_type_field
) *fields
;
263 void accept (tdesc_element_visitor
&v
) const override
268 bool operator== (const tdesc_type
&other
) const
270 return (streq (name
, other
.name
) && kind
== other
.kind
);
273 bool operator!= (const tdesc_type
&other
) const
275 return !(*this == other
);
278 DEF_VEC_P(tdesc_type_p
);
280 /* A feature from a target description. Each feature is a collection
281 of other elements, e.g. registers and types. */
283 struct tdesc_feature
: tdesc_element
285 tdesc_feature (const std::string
&name_
)
289 virtual ~tdesc_feature ()
291 struct tdesc_type
*type
;
294 for (ix
= 0; VEC_iterate (tdesc_type_p
, types
, ix
, type
); ix
++)
296 VEC_free (tdesc_type_p
, types
);
299 DISABLE_COPY_AND_ASSIGN (tdesc_feature
);
301 /* The name of this feature. It may be recognized by the architecture
305 /* The registers associated with this feature. */
306 std::vector
<std::unique_ptr
<tdesc_reg
>> registers
;
308 /* The types associated with this feature. */
309 VEC(tdesc_type_p
) *types
= NULL
;
311 void accept (tdesc_element_visitor
&v
) const override
315 struct tdesc_type
*type
;
318 VEC_iterate (tdesc_type_p
, types
, ix
, type
);
322 for (const tdesc_reg_up
®
: registers
)
328 bool operator== (const tdesc_feature
&other
) const
330 if (name
!= other
.name
)
333 if (registers
.size () != other
.registers
.size ())
336 for (int ix
= 0; ix
< registers
.size (); ix
++)
338 const tdesc_reg_up
®1
= registers
[ix
];
339 const tdesc_reg_up
®2
= other
.registers
[ix
];
341 if (reg1
!= reg2
&& *reg1
!= *reg2
)
345 if (VEC_length (tdesc_type_p
, types
)
346 != VEC_length (tdesc_type_p
, other
.types
))
352 VEC_iterate (tdesc_type_p
, types
, ix
, type
);
356 = VEC_index (tdesc_type_p
, other
.types
, ix
);
358 if (type
!= type2
&& *type
!= *type2
)
365 bool operator!= (const tdesc_feature
&other
) const
367 return !(*this == other
);
372 typedef std::unique_ptr
<tdesc_feature
> tdesc_feature_up
;
374 /* A target description. */
376 struct target_desc
: tdesc_element
381 virtual ~target_desc () = default;
383 target_desc (const target_desc
&) = delete;
384 void operator= (const target_desc
&) = delete;
386 /* The architecture reported by the target, if any. */
387 const struct bfd_arch_info
*arch
= NULL
;
389 /* The osabi reported by the target, if any; GDB_OSABI_UNKNOWN
391 enum gdb_osabi osabi
= GDB_OSABI_UNKNOWN
;
393 /* The list of compatible architectures reported by the target. */
394 std::vector
<const bfd_arch_info
*> compatible
;
396 /* Any architecture-specific properties specified by the target. */
397 std::vector
<property
> properties
;
399 /* The features associated with this target. */
400 std::vector
<std::unique_ptr
<tdesc_feature
>> features
;
402 void accept (tdesc_element_visitor
&v
) const override
406 for (const tdesc_feature_up
&feature
: features
)
412 bool operator== (const target_desc
&other
) const
414 if (arch
!= other
.arch
)
417 if (osabi
!= other
.osabi
)
420 if (features
.size () != other
.features
.size ())
423 for (int ix
= 0; ix
< features
.size (); ix
++)
425 const tdesc_feature_up
&feature1
= features
[ix
];
426 const tdesc_feature_up
&feature2
= other
.features
[ix
];
428 if (feature1
!= feature2
&& *feature1
!= *feature2
)
435 bool operator!= (const target_desc
&other
) const
437 return !(*this == other
);
441 /* Per-architecture data associated with a target description. The
442 target description may be shared by multiple architectures, but
443 this data is private to one gdbarch. */
445 typedef struct tdesc_arch_reg
447 struct tdesc_reg
*reg
;
450 DEF_VEC_O(tdesc_arch_reg
);
452 struct tdesc_arch_data
454 /* A list of register/type pairs, indexed by GDB's internal register number.
455 During initialization of the gdbarch this list is used to store
456 registers which the architecture assigns a fixed register number.
457 Registers which are NULL in this array, or off the end, are
458 treated as zero-sized and nameless (i.e. placeholders in the
460 VEC(tdesc_arch_reg
) *arch_regs
;
462 /* Functions which report the register name, type, and reggroups for
464 gdbarch_register_name_ftype
*pseudo_register_name
;
465 gdbarch_register_type_ftype
*pseudo_register_type
;
466 gdbarch_register_reggroup_p_ftype
*pseudo_register_reggroup_p
;
469 /* Info about an inferior's target description. There's one of these
470 for each inferior. */
472 struct target_desc_info
474 /* A flag indicating that a description has already been fetched
475 from the target, so it should not be queried again. */
479 /* The description fetched from the target, or NULL if the target
480 did not supply any description. Only valid when
481 target_desc_fetched is set. Only the description initialization
482 code should access this; normally, the description should be
483 accessed through the gdbarch object. */
485 const struct target_desc
*tdesc
;
487 /* The filename to read a target description from, as set by "set
488 tdesc filename ..." */
493 /* Get the inferior INF's target description info, allocating one on
494 the stop if necessary. */
496 static struct target_desc_info
*
497 get_tdesc_info (struct inferior
*inf
)
499 if (inf
->tdesc_info
== NULL
)
500 inf
->tdesc_info
= XCNEW (struct target_desc_info
);
501 return inf
->tdesc_info
;
504 /* A handle for architecture-specific data associated with the
505 target description (see struct tdesc_arch_data). */
507 static struct gdbarch_data
*tdesc_data
;
509 /* See target-descriptions.h. */
512 target_desc_info_from_user_p (struct target_desc_info
*info
)
514 return info
!= NULL
&& info
->filename
!= NULL
;
517 /* See target-descriptions.h. */
520 copy_inferior_target_desc_info (struct inferior
*destinf
, struct inferior
*srcinf
)
522 struct target_desc_info
*src
= get_tdesc_info (srcinf
);
523 struct target_desc_info
*dest
= get_tdesc_info (destinf
);
525 dest
->fetched
= src
->fetched
;
526 dest
->tdesc
= src
->tdesc
;
527 dest
->filename
= src
->filename
!= NULL
? xstrdup (src
->filename
) : NULL
;
530 /* See target-descriptions.h. */
533 target_desc_info_free (struct target_desc_info
*tdesc_info
)
535 if (tdesc_info
!= NULL
)
537 xfree (tdesc_info
->filename
);
542 /* Convenience helper macros. */
544 #define target_desc_fetched \
545 get_tdesc_info (current_inferior ())->fetched
546 #define current_target_desc \
547 get_tdesc_info (current_inferior ())->tdesc
548 #define target_description_filename \
549 get_tdesc_info (current_inferior ())->filename
551 /* The string manipulated by the "set tdesc filename ..." command. */
553 static char *tdesc_filename_cmd_string
;
555 /* Fetch the current target's description, and switch the current
556 architecture to one which incorporates that description. */
559 target_find_description (void)
561 /* If we've already fetched a description from the target, don't do
562 it again. This allows a target to fetch the description early,
563 during its to_open or to_create_inferior, if it needs extra
564 information about the target to initialize. */
565 if (target_desc_fetched
)
568 /* The current architecture should not have any target description
569 specified. It should have been cleared, e.g. when we
570 disconnected from the previous target. */
571 gdb_assert (gdbarch_target_desc (target_gdbarch ()) == NULL
);
573 /* First try to fetch an XML description from the user-specified
575 current_target_desc
= NULL
;
576 if (target_description_filename
!= NULL
577 && *target_description_filename
!= '\0')
579 = file_read_description_xml (target_description_filename
);
581 /* Next try to read the description from the current target using
583 if (current_target_desc
== NULL
)
584 current_target_desc
= target_read_description_xml (¤t_target
);
586 /* If that failed try a target-specific hook. */
587 if (current_target_desc
== NULL
)
588 current_target_desc
= target_read_description (¤t_target
);
590 /* If a non-NULL description was returned, then update the current
592 if (current_target_desc
)
594 struct gdbarch_info info
;
596 gdbarch_info_init (&info
);
597 info
.target_desc
= current_target_desc
;
598 if (!gdbarch_update_p (info
))
599 warning (_("Architecture rejected target-supplied description"));
602 struct tdesc_arch_data
*data
;
604 data
= ((struct tdesc_arch_data
*)
605 gdbarch_data (target_gdbarch (), tdesc_data
));
606 if (tdesc_has_registers (current_target_desc
)
607 && data
->arch_regs
== NULL
)
608 warning (_("Target-supplied registers are not supported "
609 "by the current architecture"));
613 /* Now that we know this description is usable, record that we
615 target_desc_fetched
= 1;
618 /* Discard any description fetched from the current target, and switch
619 the current architecture to one with no target description. */
622 target_clear_description (void)
624 struct gdbarch_info info
;
626 if (!target_desc_fetched
)
629 target_desc_fetched
= 0;
630 current_target_desc
= NULL
;
632 gdbarch_info_init (&info
);
633 if (!gdbarch_update_p (info
))
634 internal_error (__FILE__
, __LINE__
,
635 _("Could not remove target-supplied description"));
638 /* Return the global current target description. This should only be
639 used by gdbarch initialization code; most access should be through
640 an existing gdbarch. */
642 const struct target_desc
*
643 target_current_description (void)
645 if (target_desc_fetched
)
646 return current_target_desc
;
651 /* Return non-zero if this target description is compatible
652 with the given BFD architecture. */
655 tdesc_compatible_p (const struct target_desc
*target_desc
,
656 const struct bfd_arch_info
*arch
)
658 for (const bfd_arch_info
*compat
: target_desc
->compatible
)
661 || arch
->compatible (arch
, compat
)
662 || compat
->compatible (compat
, arch
))
670 /* Direct accessors for target descriptions. */
672 /* Return the string value of a property named KEY, or NULL if the
673 property was not specified. */
676 tdesc_property (const struct target_desc
*target_desc
, const char *key
)
678 for (const property
&prop
: target_desc
->properties
)
680 return prop
.value
.c_str ();
685 /* Return the BFD architecture associated with this target
686 description, or NULL if no architecture was specified. */
688 const struct bfd_arch_info
*
689 tdesc_architecture (const struct target_desc
*target_desc
)
691 return target_desc
->arch
;
694 /* Return the OSABI associated with this target description, or
695 GDB_OSABI_UNKNOWN if no osabi was specified. */
698 tdesc_osabi (const struct target_desc
*target_desc
)
700 return target_desc
->osabi
;
705 /* Return 1 if this target description includes any registers. */
708 tdesc_has_registers (const struct target_desc
*target_desc
)
710 if (target_desc
== NULL
)
713 for (const tdesc_feature_up
&feature
: target_desc
->features
)
714 if (!feature
->registers
.empty ())
720 /* Return the feature with the given name, if present, or NULL if
721 the named feature is not found. */
723 const struct tdesc_feature
*
724 tdesc_find_feature (const struct target_desc
*target_desc
,
727 for (const tdesc_feature_up
&feature
: target_desc
->features
)
728 if (feature
->name
== name
)
729 return feature
.get ();
734 /* Return the name of FEATURE. */
737 tdesc_feature_name (const struct tdesc_feature
*feature
)
739 return feature
->name
.c_str ();
742 /* Predefined types. */
743 static struct tdesc_type tdesc_predefined_types
[] =
745 { "bool", TDESC_TYPE_BOOL
},
746 { "int8", TDESC_TYPE_INT8
},
747 { "int16", TDESC_TYPE_INT16
},
748 { "int32", TDESC_TYPE_INT32
},
749 { "int64", TDESC_TYPE_INT64
},
750 { "int128", TDESC_TYPE_INT128
},
751 { "uint8", TDESC_TYPE_UINT8
},
752 { "uint16", TDESC_TYPE_UINT16
},
753 { "uint32", TDESC_TYPE_UINT32
},
754 { "uint64", TDESC_TYPE_UINT64
},
755 { "uint128", TDESC_TYPE_UINT128
},
756 { "code_ptr", TDESC_TYPE_CODE_PTR
},
757 { "data_ptr", TDESC_TYPE_DATA_PTR
},
758 { "ieee_single", TDESC_TYPE_IEEE_SINGLE
},
759 { "ieee_double", TDESC_TYPE_IEEE_DOUBLE
},
760 { "arm_fpa_ext", TDESC_TYPE_ARM_FPA_EXT
},
761 { "i387_ext", TDESC_TYPE_I387_EXT
}
764 /* Lookup a predefined type. */
766 static struct tdesc_type
*
767 tdesc_predefined_type (enum tdesc_type_kind kind
)
769 for (int ix
= 0; ix
< ARRAY_SIZE (tdesc_predefined_types
); ix
++)
770 if (tdesc_predefined_types
[ix
].kind
== kind
)
771 return &tdesc_predefined_types
[ix
];
773 gdb_assert_not_reached ("bad predefined tdesc type");
776 /* See arch/tdesc.h. */
779 tdesc_named_type (const struct tdesc_feature
*feature
, const char *id
)
782 struct tdesc_type
*type
;
784 /* First try target-defined types. */
785 for (ix
= 0; VEC_iterate (tdesc_type_p
, feature
->types
, ix
, type
); ix
++)
786 if (strcmp (type
->name
, id
) == 0)
789 /* Next try the predefined types. */
790 for (ix
= 0; ix
< ARRAY_SIZE (tdesc_predefined_types
); ix
++)
791 if (strcmp (tdesc_predefined_types
[ix
].name
, id
) == 0)
792 return &tdesc_predefined_types
[ix
];
797 /* Lookup type associated with ID. */
800 tdesc_find_type (struct gdbarch
*gdbarch
, const char *id
)
802 struct tdesc_arch_reg
*reg
;
803 struct tdesc_arch_data
*data
;
806 data
= (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
807 num_regs
= VEC_length (tdesc_arch_reg
, data
->arch_regs
);
808 for (i
= 0; i
< num_regs
; i
++)
810 reg
= VEC_index (tdesc_arch_reg
, data
->arch_regs
, i
);
812 && reg
->reg
->tdesc_type
814 && strcmp (id
, reg
->reg
->tdesc_type
->name
) == 0)
821 /* Construct, if necessary, and return the GDB type implementing target
822 type TDESC_TYPE for architecture GDBARCH. */
825 tdesc_gdb_type (struct gdbarch
*gdbarch
, struct tdesc_type
*tdesc_type
)
829 switch (tdesc_type
->kind
)
831 /* Predefined types. */
832 case TDESC_TYPE_BOOL
:
833 return builtin_type (gdbarch
)->builtin_bool
;
835 case TDESC_TYPE_INT8
:
836 return builtin_type (gdbarch
)->builtin_int8
;
838 case TDESC_TYPE_INT16
:
839 return builtin_type (gdbarch
)->builtin_int16
;
841 case TDESC_TYPE_INT32
:
842 return builtin_type (gdbarch
)->builtin_int32
;
844 case TDESC_TYPE_INT64
:
845 return builtin_type (gdbarch
)->builtin_int64
;
847 case TDESC_TYPE_INT128
:
848 return builtin_type (gdbarch
)->builtin_int128
;
850 case TDESC_TYPE_UINT8
:
851 return builtin_type (gdbarch
)->builtin_uint8
;
853 case TDESC_TYPE_UINT16
:
854 return builtin_type (gdbarch
)->builtin_uint16
;
856 case TDESC_TYPE_UINT32
:
857 return builtin_type (gdbarch
)->builtin_uint32
;
859 case TDESC_TYPE_UINT64
:
860 return builtin_type (gdbarch
)->builtin_uint64
;
862 case TDESC_TYPE_UINT128
:
863 return builtin_type (gdbarch
)->builtin_uint128
;
865 case TDESC_TYPE_CODE_PTR
:
866 return builtin_type (gdbarch
)->builtin_func_ptr
;
868 case TDESC_TYPE_DATA_PTR
:
869 return builtin_type (gdbarch
)->builtin_data_ptr
;
875 type
= tdesc_find_type (gdbarch
, tdesc_type
->name
);
879 switch (tdesc_type
->kind
)
881 case TDESC_TYPE_IEEE_SINGLE
:
882 return arch_float_type (gdbarch
, -1, "builtin_type_ieee_single",
883 floatformats_ieee_single
);
885 case TDESC_TYPE_IEEE_DOUBLE
:
886 return arch_float_type (gdbarch
, -1, "builtin_type_ieee_double",
887 floatformats_ieee_double
);
889 case TDESC_TYPE_ARM_FPA_EXT
:
890 return arch_float_type (gdbarch
, -1, "builtin_type_arm_ext",
891 floatformats_arm_ext
);
893 case TDESC_TYPE_I387_EXT
:
894 return arch_float_type (gdbarch
, -1, "builtin_type_i387_ext",
895 floatformats_i387_ext
);
897 /* Types defined by a target feature. */
898 case TDESC_TYPE_VECTOR
:
900 struct type
*type
, *field_type
;
902 field_type
= tdesc_gdb_type (gdbarch
, tdesc_type
->u
.v
.type
);
903 type
= init_vector_type (field_type
, tdesc_type
->u
.v
.count
);
904 TYPE_NAME (type
) = xstrdup (tdesc_type
->name
);
909 case TDESC_TYPE_STRUCT
:
911 struct type
*type
, *field_type
;
912 struct tdesc_type_field
*f
;
915 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
916 TYPE_NAME (type
) = xstrdup (tdesc_type
->name
);
917 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
920 VEC_iterate (tdesc_type_field
, tdesc_type
->u
.u
.fields
, ix
, f
);
923 if (f
->start
!= -1 && f
->end
!= -1)
927 struct type
*field_type
;
928 int bitsize
, total_size
;
930 /* This invariant should be preserved while creating types. */
931 gdb_assert (tdesc_type
->u
.u
.size
!= 0);
933 field_type
= tdesc_gdb_type (gdbarch
, f
->type
);
934 else if (tdesc_type
->u
.u
.size
> 4)
935 field_type
= builtin_type (gdbarch
)->builtin_uint64
;
937 field_type
= builtin_type (gdbarch
)->builtin_uint32
;
939 fld
= append_composite_type_field_raw (type
, xstrdup (f
->name
),
942 /* For little-endian, BITPOS counts from the LSB of
943 the structure and marks the LSB of the field. For
944 big-endian, BITPOS counts from the MSB of the
945 structure and marks the MSB of the field. Either
946 way, it is the number of bits to the "left" of the
947 field. To calculate this in big-endian, we need
948 the total size of the structure. */
949 bitsize
= f
->end
- f
->start
+ 1;
950 total_size
= tdesc_type
->u
.u
.size
* TARGET_CHAR_BIT
;
951 if (gdbarch_bits_big_endian (gdbarch
))
952 SET_FIELD_BITPOS (fld
[0], total_size
- f
->start
- bitsize
);
954 SET_FIELD_BITPOS (fld
[0], f
->start
);
955 FIELD_BITSIZE (fld
[0]) = bitsize
;
959 gdb_assert (f
->start
== -1 && f
->end
== -1);
960 field_type
= tdesc_gdb_type (gdbarch
, f
->type
);
961 append_composite_type_field (type
, xstrdup (f
->name
),
966 if (tdesc_type
->u
.u
.size
!= 0)
967 TYPE_LENGTH (type
) = tdesc_type
->u
.u
.size
;
971 case TDESC_TYPE_UNION
:
973 struct type
*type
, *field_type
;
974 struct tdesc_type_field
*f
;
977 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_UNION
);
978 TYPE_NAME (type
) = xstrdup (tdesc_type
->name
);
981 VEC_iterate (tdesc_type_field
, tdesc_type
->u
.u
.fields
, ix
, f
);
984 field_type
= tdesc_gdb_type (gdbarch
, f
->type
);
985 append_composite_type_field (type
, xstrdup (f
->name
), field_type
);
987 /* If any of the children of a union are vectors, flag the
988 union as a vector also. This allows e.g. a union of two
989 vector types to show up automatically in "info vector". */
990 if (TYPE_VECTOR (field_type
))
991 TYPE_VECTOR (type
) = 1;
996 case TDESC_TYPE_FLAGS
:
998 struct tdesc_type_field
*f
;
1001 type
= arch_flags_type (gdbarch
, tdesc_type
->name
,
1002 tdesc_type
->u
.u
.size
* TARGET_CHAR_BIT
);
1004 VEC_iterate (tdesc_type_field
, tdesc_type
->u
.u
.fields
, ix
, f
);
1007 struct type
*field_type
;
1008 int bitsize
= f
->end
- f
->start
+ 1;
1010 gdb_assert (f
->type
!= NULL
);
1011 field_type
= tdesc_gdb_type (gdbarch
, f
->type
);
1012 append_flags_type_field (type
, f
->start
, bitsize
,
1013 field_type
, f
->name
);
1019 case TDESC_TYPE_ENUM
:
1021 struct tdesc_type_field
*f
;
1024 type
= arch_type (gdbarch
, TYPE_CODE_ENUM
,
1025 tdesc_type
->u
.u
.size
* TARGET_CHAR_BIT
,
1027 TYPE_UNSIGNED (type
) = 1;
1029 VEC_iterate (tdesc_type_field
, tdesc_type
->u
.u
.fields
, ix
, f
);
1033 = append_composite_type_field_raw (type
, xstrdup (f
->name
),
1036 SET_FIELD_BITPOS (fld
[0], f
->start
);
1043 internal_error (__FILE__
, __LINE__
,
1044 "Type \"%s\" has an unknown kind %d",
1045 tdesc_type
->name
, tdesc_type
->kind
);
1049 /* Support for registers from target descriptions. */
1051 /* Construct the per-gdbarch data. */
1054 tdesc_data_init (struct obstack
*obstack
)
1056 struct tdesc_arch_data
*data
;
1058 data
= OBSTACK_ZALLOC (obstack
, struct tdesc_arch_data
);
1062 /* Similar, but for the temporary copy used during architecture
1065 struct tdesc_arch_data
*
1066 tdesc_data_alloc (void)
1068 return XCNEW (struct tdesc_arch_data
);
1071 /* Free something allocated by tdesc_data_alloc, if it is not going
1072 to be used (for instance if it was unsuitable for the
1076 tdesc_data_cleanup (void *data_untyped
)
1078 struct tdesc_arch_data
*data
= (struct tdesc_arch_data
*) data_untyped
;
1080 VEC_free (tdesc_arch_reg
, data
->arch_regs
);
1084 /* Search FEATURE for a register named NAME. */
1086 static struct tdesc_reg
*
1087 tdesc_find_register_early (const struct tdesc_feature
*feature
,
1090 for (const tdesc_reg_up
®
: feature
->registers
)
1091 if (strcasecmp (reg
->name
, name
) == 0)
1097 /* Search FEATURE for a register named NAME. Assign REGNO to it. */
1100 tdesc_numbered_register (const struct tdesc_feature
*feature
,
1101 struct tdesc_arch_data
*data
,
1102 int regno
, const char *name
)
1104 struct tdesc_arch_reg arch_reg
= { 0 };
1105 struct tdesc_reg
*reg
= tdesc_find_register_early (feature
, name
);
1110 /* Make sure the vector includes a REGNO'th element. */
1111 while (regno
>= VEC_length (tdesc_arch_reg
, data
->arch_regs
))
1112 VEC_safe_push (tdesc_arch_reg
, data
->arch_regs
, &arch_reg
);
1115 VEC_replace (tdesc_arch_reg
, data
->arch_regs
, regno
, &arch_reg
);
1119 /* Search FEATURE for a register named NAME, but do not assign a fixed
1120 register number to it. */
1123 tdesc_unnumbered_register (const struct tdesc_feature
*feature
,
1126 struct tdesc_reg
*reg
= tdesc_find_register_early (feature
, name
);
1134 /* Search FEATURE for a register whose name is in NAMES and assign
1138 tdesc_numbered_register_choices (const struct tdesc_feature
*feature
,
1139 struct tdesc_arch_data
*data
,
1140 int regno
, const char *const names
[])
1144 for (i
= 0; names
[i
] != NULL
; i
++)
1145 if (tdesc_numbered_register (feature
, data
, regno
, names
[i
]))
1151 /* Search FEATURE for a register named NAME, and return its size in
1152 bits. The register must exist. */
1155 tdesc_register_size (const struct tdesc_feature
*feature
,
1158 struct tdesc_reg
*reg
= tdesc_find_register_early (feature
, name
);
1160 gdb_assert (reg
!= NULL
);
1161 return reg
->bitsize
;
1164 /* Look up a register by its GDB internal register number. */
1166 static struct tdesc_arch_reg
*
1167 tdesc_find_arch_register (struct gdbarch
*gdbarch
, int regno
)
1169 struct tdesc_arch_data
*data
;
1171 data
= (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1172 if (regno
< VEC_length (tdesc_arch_reg
, data
->arch_regs
))
1173 return VEC_index (tdesc_arch_reg
, data
->arch_regs
, regno
);
1178 static struct tdesc_reg
*
1179 tdesc_find_register (struct gdbarch
*gdbarch
, int regno
)
1181 struct tdesc_arch_reg
*reg
= tdesc_find_arch_register (gdbarch
, regno
);
1183 return reg
? reg
->reg
: NULL
;
1186 /* Return the name of register REGNO, from the target description or
1187 from an architecture-provided pseudo_register_name method. */
1190 tdesc_register_name (struct gdbarch
*gdbarch
, int regno
)
1192 struct tdesc_reg
*reg
= tdesc_find_register (gdbarch
, regno
);
1193 int num_regs
= gdbarch_num_regs (gdbarch
);
1194 int num_pseudo_regs
= gdbarch_num_pseudo_regs (gdbarch
);
1199 if (regno
>= num_regs
&& regno
< num_regs
+ num_pseudo_regs
)
1201 struct tdesc_arch_data
*data
1202 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1204 gdb_assert (data
->pseudo_register_name
!= NULL
);
1205 return data
->pseudo_register_name (gdbarch
, regno
);
1212 tdesc_register_type (struct gdbarch
*gdbarch
, int regno
)
1214 struct tdesc_arch_reg
*arch_reg
= tdesc_find_arch_register (gdbarch
, regno
);
1215 struct tdesc_reg
*reg
= arch_reg
? arch_reg
->reg
: NULL
;
1216 int num_regs
= gdbarch_num_regs (gdbarch
);
1217 int num_pseudo_regs
= gdbarch_num_pseudo_regs (gdbarch
);
1219 if (reg
== NULL
&& regno
>= num_regs
&& regno
< num_regs
+ num_pseudo_regs
)
1221 struct tdesc_arch_data
*data
1222 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1224 gdb_assert (data
->pseudo_register_type
!= NULL
);
1225 return data
->pseudo_register_type (gdbarch
, regno
);
1229 /* Return "int0_t", since "void" has a misleading size of one. */
1230 return builtin_type (gdbarch
)->builtin_int0
;
1232 if (arch_reg
->type
== NULL
)
1234 /* First check for a predefined or target defined type. */
1235 if (reg
->tdesc_type
)
1236 arch_reg
->type
= tdesc_gdb_type (gdbarch
, reg
->tdesc_type
);
1238 /* Next try size-sensitive type shortcuts. */
1239 else if (strcmp (reg
->type
, "float") == 0)
1241 if (reg
->bitsize
== gdbarch_float_bit (gdbarch
))
1242 arch_reg
->type
= builtin_type (gdbarch
)->builtin_float
;
1243 else if (reg
->bitsize
== gdbarch_double_bit (gdbarch
))
1244 arch_reg
->type
= builtin_type (gdbarch
)->builtin_double
;
1245 else if (reg
->bitsize
== gdbarch_long_double_bit (gdbarch
))
1246 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long_double
;
1249 warning (_("Register \"%s\" has an unsupported size (%d bits)"),
1250 reg
->name
, reg
->bitsize
);
1251 arch_reg
->type
= builtin_type (gdbarch
)->builtin_double
;
1254 else if (strcmp (reg
->type
, "int") == 0)
1256 if (reg
->bitsize
== gdbarch_long_bit (gdbarch
))
1257 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long
;
1258 else if (reg
->bitsize
== TARGET_CHAR_BIT
)
1259 arch_reg
->type
= builtin_type (gdbarch
)->builtin_char
;
1260 else if (reg
->bitsize
== gdbarch_short_bit (gdbarch
))
1261 arch_reg
->type
= builtin_type (gdbarch
)->builtin_short
;
1262 else if (reg
->bitsize
== gdbarch_int_bit (gdbarch
))
1263 arch_reg
->type
= builtin_type (gdbarch
)->builtin_int
;
1264 else if (reg
->bitsize
== gdbarch_long_long_bit (gdbarch
))
1265 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long_long
;
1266 else if (reg
->bitsize
== gdbarch_ptr_bit (gdbarch
))
1267 /* A bit desperate by this point... */
1268 arch_reg
->type
= builtin_type (gdbarch
)->builtin_data_ptr
;
1271 warning (_("Register \"%s\" has an unsupported size (%d bits)"),
1272 reg
->name
, reg
->bitsize
);
1273 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long
;
1277 if (arch_reg
->type
== NULL
)
1278 internal_error (__FILE__
, __LINE__
,
1279 "Register \"%s\" has an unknown type \"%s\"",
1280 reg
->name
, reg
->type
);
1283 return arch_reg
->type
;
1287 tdesc_remote_register_number (struct gdbarch
*gdbarch
, int regno
)
1289 struct tdesc_reg
*reg
= tdesc_find_register (gdbarch
, regno
);
1292 return reg
->target_regnum
;
1297 /* Check whether REGNUM is a member of REGGROUP. Registers from the
1298 target description may be classified as general, float, or vector.
1299 Unlike a gdbarch register_reggroup_p method, this function will
1300 return -1 if it does not know; the caller should handle registers
1301 with no specified group.
1303 Arbitrary strings (other than "general", "float", and "vector")
1304 from the description are not used; they cause the register to be
1305 displayed in "info all-registers" but excluded from "info
1306 registers" et al. The names of containing features are also not
1307 used. This might be extended to display registers in some more
1310 The save-restore flag is also implemented here. */
1313 tdesc_register_in_reggroup_p (struct gdbarch
*gdbarch
, int regno
,
1314 struct reggroup
*reggroup
)
1316 struct tdesc_reg
*reg
= tdesc_find_register (gdbarch
, regno
);
1318 if (reg
!= NULL
&& reg
->group
!= NULL
)
1320 int general_p
= 0, float_p
= 0, vector_p
= 0;
1322 if (strcmp (reg
->group
, "general") == 0)
1324 else if (strcmp (reg
->group
, "float") == 0)
1326 else if (strcmp (reg
->group
, "vector") == 0)
1329 if (reggroup
== float_reggroup
)
1332 if (reggroup
== vector_reggroup
)
1335 if (reggroup
== general_reggroup
)
1340 && (reggroup
== save_reggroup
|| reggroup
== restore_reggroup
))
1341 return reg
->save_restore
;
1346 /* Check whether REGNUM is a member of REGGROUP. Registers with no
1347 group specified go to the default reggroup function and are handled
1351 tdesc_register_reggroup_p (struct gdbarch
*gdbarch
, int regno
,
1352 struct reggroup
*reggroup
)
1354 int num_regs
= gdbarch_num_regs (gdbarch
);
1355 int num_pseudo_regs
= gdbarch_num_pseudo_regs (gdbarch
);
1358 if (regno
>= num_regs
&& regno
< num_regs
+ num_pseudo_regs
)
1360 struct tdesc_arch_data
*data
1361 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1363 if (data
->pseudo_register_reggroup_p
!= NULL
)
1364 return data
->pseudo_register_reggroup_p (gdbarch
, regno
, reggroup
);
1365 /* Otherwise fall through to the default reggroup_p. */
1368 ret
= tdesc_register_in_reggroup_p (gdbarch
, regno
, reggroup
);
1372 return default_register_reggroup_p (gdbarch
, regno
, reggroup
);
1375 /* Record architecture-specific functions to call for pseudo-register
1379 set_tdesc_pseudo_register_name (struct gdbarch
*gdbarch
,
1380 gdbarch_register_name_ftype
*pseudo_name
)
1382 struct tdesc_arch_data
*data
1383 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1385 data
->pseudo_register_name
= pseudo_name
;
1389 set_tdesc_pseudo_register_type (struct gdbarch
*gdbarch
,
1390 gdbarch_register_type_ftype
*pseudo_type
)
1392 struct tdesc_arch_data
*data
1393 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1395 data
->pseudo_register_type
= pseudo_type
;
1399 set_tdesc_pseudo_register_reggroup_p
1400 (struct gdbarch
*gdbarch
,
1401 gdbarch_register_reggroup_p_ftype
*pseudo_reggroup_p
)
1403 struct tdesc_arch_data
*data
1404 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1406 data
->pseudo_register_reggroup_p
= pseudo_reggroup_p
;
1409 /* Update GDBARCH to use the target description for registers. */
1412 tdesc_use_registers (struct gdbarch
*gdbarch
,
1413 const struct target_desc
*target_desc
,
1414 struct tdesc_arch_data
*early_data
)
1416 int num_regs
= gdbarch_num_regs (gdbarch
);
1417 struct tdesc_arch_data
*data
;
1418 struct tdesc_arch_reg
*arch_reg
, new_arch_reg
= { 0 };
1421 /* We can't use the description for registers if it doesn't describe
1422 any. This function should only be called after validating
1423 registers, so the caller should know that registers are
1425 gdb_assert (tdesc_has_registers (target_desc
));
1427 data
= (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1428 data
->arch_regs
= early_data
->arch_regs
;
1431 /* Build up a set of all registers, so that we can assign register
1432 numbers where needed. The hash table expands as necessary, so
1433 the initial size is arbitrary. */
1434 reg_hash
= htab_create (37, htab_hash_pointer
, htab_eq_pointer
, NULL
);
1435 for (const tdesc_feature_up
&feature
: target_desc
->features
)
1436 for (const tdesc_reg_up
®
: feature
->registers
)
1438 void **slot
= htab_find_slot (reg_hash
, reg
.get (), INSERT
);
1443 /* Remove any registers which were assigned numbers by the
1446 VEC_iterate (tdesc_arch_reg
, data
->arch_regs
, ixr
, arch_reg
);
1449 htab_remove_elt (reg_hash
, arch_reg
->reg
);
1451 /* Assign numbers to the remaining registers and add them to the
1452 list of registers. The new numbers are always above gdbarch_num_regs.
1453 Iterate over the features, not the hash table, so that the order
1454 matches that in the target description. */
1456 gdb_assert (VEC_length (tdesc_arch_reg
, data
->arch_regs
) <= num_regs
);
1457 while (VEC_length (tdesc_arch_reg
, data
->arch_regs
) < num_regs
)
1458 VEC_safe_push (tdesc_arch_reg
, data
->arch_regs
, &new_arch_reg
);
1459 for (const tdesc_feature_up
&feature
: target_desc
->features
)
1460 for (const tdesc_reg_up
®
: feature
->registers
)
1461 if (htab_find (reg_hash
, reg
.get ()) != NULL
)
1463 new_arch_reg
.reg
= reg
.get ();
1464 VEC_safe_push (tdesc_arch_reg
, data
->arch_regs
, &new_arch_reg
);
1468 htab_delete (reg_hash
);
1470 /* Update the architecture. */
1471 set_gdbarch_num_regs (gdbarch
, num_regs
);
1472 set_gdbarch_register_name (gdbarch
, tdesc_register_name
);
1473 set_gdbarch_register_type (gdbarch
, tdesc_register_type
);
1474 set_gdbarch_remote_register_number (gdbarch
,
1475 tdesc_remote_register_number
);
1476 set_gdbarch_register_reggroup_p (gdbarch
, tdesc_register_reggroup_p
);
1480 /* See arch/tdesc.h. */
1483 tdesc_create_reg (struct tdesc_feature
*feature
, const char *name
,
1484 int regnum
, int save_restore
, const char *group
,
1485 int bitsize
, const char *type
)
1487 tdesc_reg
*reg
= new tdesc_reg (feature
, name
, regnum
, save_restore
,
1488 group
, bitsize
, type
);
1490 feature
->registers
.emplace_back (reg
);
1493 /* See arch/tdesc.h. */
1496 tdesc_create_vector (struct tdesc_feature
*feature
, const char *name
,
1497 struct tdesc_type
*field_type
, int count
)
1499 struct tdesc_type
*type
= new tdesc_type (name
, TDESC_TYPE_VECTOR
);
1501 type
->u
.v
.type
= field_type
;
1502 type
->u
.v
.count
= count
;
1504 VEC_safe_push (tdesc_type_p
, feature
->types
, type
);
1508 /* See arch/tdesc.h. */
1511 tdesc_create_struct (struct tdesc_feature
*feature
, const char *name
)
1513 struct tdesc_type
*type
= new tdesc_type (name
, TDESC_TYPE_STRUCT
);
1515 VEC_safe_push (tdesc_type_p
, feature
->types
, type
);
1519 /* See arch/tdesc.h. */
1522 tdesc_set_struct_size (struct tdesc_type
*type
, int size
)
1524 gdb_assert (type
->kind
== TDESC_TYPE_STRUCT
);
1525 gdb_assert (size
> 0);
1526 type
->u
.u
.size
= size
;
1529 /* See arch/tdesc.h. */
1532 tdesc_create_union (struct tdesc_feature
*feature
, const char *name
)
1534 struct tdesc_type
*type
= new tdesc_type (name
, TDESC_TYPE_UNION
);
1536 VEC_safe_push (tdesc_type_p
, feature
->types
, type
);
1540 /* See arch/tdesc.h. */
1543 tdesc_create_flags (struct tdesc_feature
*feature
, const char *name
,
1546 struct tdesc_type
*type
= new tdesc_type (name
, TDESC_TYPE_FLAGS
);
1548 gdb_assert (size
> 0);
1550 type
->u
.u
.size
= size
;
1552 VEC_safe_push (tdesc_type_p
, feature
->types
, type
);
1557 tdesc_create_enum (struct tdesc_feature
*feature
, const char *name
,
1560 struct tdesc_type
*type
= new tdesc_type (name
, TDESC_TYPE_ENUM
);
1562 gdb_assert (size
> 0);
1564 type
->u
.u
.size
= size
;
1566 VEC_safe_push (tdesc_type_p
, feature
->types
, type
);
1570 /* See arch/tdesc.h. */
1573 tdesc_add_field (struct tdesc_type
*type
, const char *field_name
,
1574 struct tdesc_type
*field_type
)
1576 struct tdesc_type_field f
= { 0 };
1578 gdb_assert (type
->kind
== TDESC_TYPE_UNION
1579 || type
->kind
== TDESC_TYPE_STRUCT
);
1581 f
.name
= xstrdup (field_name
);
1582 f
.type
= field_type
;
1583 /* Initialize these values so we know this is not a bit-field
1584 when we print-c-tdesc. */
1588 VEC_safe_push (tdesc_type_field
, type
->u
.u
.fields
, &f
);
1592 tdesc_add_typed_bitfield (struct tdesc_type
*type
, const char *field_name
,
1593 int start
, int end
, struct tdesc_type
*field_type
)
1595 struct tdesc_type_field f
= { 0 };
1597 gdb_assert (type
->kind
== TDESC_TYPE_STRUCT
1598 || type
->kind
== TDESC_TYPE_FLAGS
);
1599 gdb_assert (start
>= 0 && end
>= start
);
1601 f
.name
= xstrdup (field_name
);
1604 f
.type
= field_type
;
1606 VEC_safe_push (tdesc_type_field
, type
->u
.u
.fields
, &f
);
1609 /* See arch/tdesc.h. */
1612 tdesc_add_bitfield (struct tdesc_type
*type
, const char *field_name
,
1615 struct tdesc_type
*field_type
;
1617 gdb_assert (start
>= 0 && end
>= start
);
1619 if (type
->u
.u
.size
> 4)
1620 field_type
= tdesc_predefined_type (TDESC_TYPE_UINT64
);
1622 field_type
= tdesc_predefined_type (TDESC_TYPE_UINT32
);
1624 tdesc_add_typed_bitfield (type
, field_name
, start
, end
, field_type
);
1627 /* See arch/tdesc.h. */
1630 tdesc_add_flag (struct tdesc_type
*type
, int start
,
1631 const char *flag_name
)
1633 struct tdesc_type_field f
= { 0 };
1635 gdb_assert (type
->kind
== TDESC_TYPE_FLAGS
1636 || type
->kind
== TDESC_TYPE_STRUCT
);
1638 f
.name
= xstrdup (flag_name
);
1641 f
.type
= tdesc_predefined_type (TDESC_TYPE_BOOL
);
1643 VEC_safe_push (tdesc_type_field
, type
->u
.u
.fields
, &f
);
1647 tdesc_add_enum_value (struct tdesc_type
*type
, int value
,
1650 struct tdesc_type_field f
= { 0 };
1652 gdb_assert (type
->kind
== TDESC_TYPE_ENUM
);
1654 f
.name
= xstrdup (name
);
1657 f
.type
= tdesc_predefined_type (TDESC_TYPE_INT32
);
1659 VEC_safe_push (tdesc_type_field
, type
->u
.u
.fields
, &f
);
1662 /* See arch/tdesc.h. */
1664 struct tdesc_feature
*
1665 tdesc_create_feature (struct target_desc
*tdesc
, const char *name
,
1668 struct tdesc_feature
*new_feature
= new tdesc_feature (name
);
1670 tdesc
->features
.emplace_back (new_feature
);
1675 struct target_desc
*
1676 allocate_target_description (void)
1678 return new target_desc ();
1682 free_target_description (void *arg
)
1684 struct target_desc
*target_desc
= (struct target_desc
*) arg
;
1690 make_cleanup_free_target_description (struct target_desc
*target_desc
)
1692 return make_cleanup (free_target_description
, target_desc
);
1696 tdesc_add_compatible (struct target_desc
*target_desc
,
1697 const struct bfd_arch_info
*compatible
)
1699 /* If this instance of GDB is compiled without BFD support for the
1700 compatible architecture, simply ignore it -- we would not be able
1701 to handle it anyway. */
1702 if (compatible
== NULL
)
1705 for (const bfd_arch_info
*compat
: target_desc
->compatible
)
1706 if (compat
== compatible
)
1707 internal_error (__FILE__
, __LINE__
,
1708 _("Attempted to add duplicate "
1709 "compatible architecture \"%s\""),
1710 compatible
->printable_name
);
1712 target_desc
->compatible
.push_back (compatible
);
1716 set_tdesc_property (struct target_desc
*target_desc
,
1717 const char *key
, const char *value
)
1719 gdb_assert (key
!= NULL
&& value
!= NULL
);
1721 if (tdesc_property (target_desc
, key
) != NULL
)
1722 internal_error (__FILE__
, __LINE__
,
1723 _("Attempted to add duplicate property \"%s\""), key
);
1725 target_desc
->properties
.emplace_back (key
, value
);
1728 /* See arch/tdesc.h. */
1731 set_tdesc_architecture (struct target_desc
*target_desc
,
1734 set_tdesc_architecture (target_desc
, bfd_scan_arch (name
));
1738 set_tdesc_architecture (struct target_desc
*target_desc
,
1739 const struct bfd_arch_info
*arch
)
1741 target_desc
->arch
= arch
;
1744 /* See arch/tdesc.h. */
1747 set_tdesc_osabi (struct target_desc
*target_desc
, const char *name
)
1749 set_tdesc_osabi (target_desc
, osabi_from_tdesc_string (name
));
1753 set_tdesc_osabi (struct target_desc
*target_desc
, enum gdb_osabi osabi
)
1755 target_desc
->osabi
= osabi
;
1759 static struct cmd_list_element
*tdesc_set_cmdlist
, *tdesc_show_cmdlist
;
1760 static struct cmd_list_element
*tdesc_unset_cmdlist
;
1762 /* Helper functions for the CLI commands. */
1765 set_tdesc_cmd (const char *args
, int from_tty
)
1767 help_list (tdesc_set_cmdlist
, "set tdesc ", all_commands
, gdb_stdout
);
1771 show_tdesc_cmd (const char *args
, int from_tty
)
1773 cmd_show_list (tdesc_show_cmdlist
, from_tty
, "");
1777 unset_tdesc_cmd (const char *args
, int from_tty
)
1779 help_list (tdesc_unset_cmdlist
, "unset tdesc ", all_commands
, gdb_stdout
);
1783 set_tdesc_filename_cmd (const char *args
, int from_tty
,
1784 struct cmd_list_element
*c
)
1786 xfree (target_description_filename
);
1787 target_description_filename
= xstrdup (tdesc_filename_cmd_string
);
1789 target_clear_description ();
1790 target_find_description ();
1794 show_tdesc_filename_cmd (struct ui_file
*file
, int from_tty
,
1795 struct cmd_list_element
*c
,
1798 value
= target_description_filename
;
1800 if (value
!= NULL
&& *value
!= '\0')
1801 printf_filtered (_("The target description will be read from \"%s\".\n"),
1804 printf_filtered (_("The target description will be "
1805 "read from the target.\n"));
1809 unset_tdesc_filename_cmd (const char *args
, int from_tty
)
1811 xfree (target_description_filename
);
1812 target_description_filename
= NULL
;
1813 target_clear_description ();
1814 target_find_description ();
1817 /* Print target description in C. */
1819 class print_c_tdesc
: public tdesc_element_visitor
1822 print_c_tdesc (std::string
&filename_after_features
)
1823 : m_filename_after_features (filename_after_features
)
1827 const char *filename
= lbasename (m_filename_after_features
.c_str ());
1829 m_function
= (char *) xmalloc (strlen (filename
) + 1);
1830 for (inp
= filename
, outp
= m_function
; *inp
!= '\0'; inp
++)
1833 else if (*inp
== '-')
1839 /* Standard boilerplate. */
1840 printf_unfiltered ("/* THIS FILE IS GENERATED. "
1841 "-*- buffer-read-only: t -*- vi"
1850 void visit_pre (const target_desc
*e
) override
1852 printf_unfiltered (" Original: %s */\n\n",
1853 lbasename (m_filename_after_features
.c_str ()));
1855 printf_unfiltered ("#include \"defs.h\"\n");
1856 printf_unfiltered ("#include \"osabi.h\"\n");
1857 printf_unfiltered ("#include \"target-descriptions.h\"\n");
1858 printf_unfiltered ("\n");
1860 printf_unfiltered ("struct target_desc *tdesc_%s;\n", m_function
);
1861 printf_unfiltered ("static void\n");
1862 printf_unfiltered ("initialize_tdesc_%s (void)\n", m_function
);
1863 printf_unfiltered ("{\n");
1865 (" struct target_desc *result = allocate_target_description ();\n");
1867 if (tdesc_architecture (e
) != NULL
)
1870 (" set_tdesc_architecture (result, bfd_scan_arch (\"%s\"));\n",
1871 tdesc_architecture (e
)->printable_name
);
1872 printf_unfiltered ("\n");
1874 if (tdesc_osabi (e
) > GDB_OSABI_UNKNOWN
1875 && tdesc_osabi (e
) < GDB_OSABI_INVALID
)
1878 (" set_tdesc_osabi (result, osabi_from_tdesc_string (\"%s\"));\n",
1879 gdbarch_osabi_name (tdesc_osabi (e
)));
1880 printf_unfiltered ("\n");
1883 for (const struct bfd_arch_info
*compatible
: e
->compatible
)
1885 (" tdesc_add_compatible (result, bfd_scan_arch (\"%s\"));\n",
1886 compatible
->printable_name
);
1888 if (!e
->compatible
.empty ())
1889 printf_unfiltered ("\n");
1891 for (const property
&prop
: e
->properties
)
1892 printf_unfiltered (" set_tdesc_property (result, \"%s\", \"%s\");\n",
1893 prop
.key
.c_str (), prop
.value
.c_str ());
1895 printf_unfiltered (" struct tdesc_feature *feature;\n");
1898 void visit_pre (const tdesc_feature
*e
) override
1900 printf_unfiltered ("\n feature = tdesc_create_feature (result, \"%s\");\n",
1904 void visit_post (const tdesc_feature
*e
) override
1907 void visit_post (const target_desc
*e
) override
1909 printf_unfiltered ("\n tdesc_%s = result;\n", m_function
);
1910 printf_unfiltered ("}\n");
1913 void visit (const tdesc_type
*type
) override
1915 struct tdesc_type_field
*f
;
1917 /* Now we do some "filtering" in order to know which variables to
1918 declare. This is needed because otherwise we would declare unused
1919 variables `field_type' and `type'. */
1920 if (!m_printed_field_type
)
1922 printf_unfiltered (" struct tdesc_type *field_type;\n");
1923 m_printed_field_type
= true;
1926 if ((type
->kind
== TDESC_TYPE_UNION
1927 || type
->kind
== TDESC_TYPE_STRUCT
1928 || type
->kind
== TDESC_TYPE_FLAGS
1929 || type
->kind
== TDESC_TYPE_ENUM
)
1930 && VEC_length (tdesc_type_field
, type
->u
.u
.fields
) > 0
1933 printf_unfiltered (" struct tdesc_type *type;\n");
1934 m_printed_type
= true;
1939 case TDESC_TYPE_VECTOR
:
1941 (" field_type = tdesc_named_type (feature, \"%s\");\n",
1942 type
->u
.v
.type
->name
);
1944 (" tdesc_create_vector (feature, \"%s\", field_type, %d);\n",
1945 type
->name
, type
->u
.v
.count
);
1947 case TDESC_TYPE_STRUCT
:
1948 case TDESC_TYPE_FLAGS
:
1949 if (type
->kind
== TDESC_TYPE_STRUCT
)
1952 (" type = tdesc_create_struct (feature, \"%s\");\n",
1954 if (type
->u
.u
.size
!= 0)
1956 (" tdesc_set_struct_size (type, %d);\n",
1962 (" type = tdesc_create_flags (feature, \"%s\", %d);\n",
1963 type
->name
, type
->u
.u
.size
);
1966 VEC_iterate (tdesc_type_field
, type
->u
.u
.fields
, ix3
, f
);
1969 const char *type_name
;
1971 gdb_assert (f
->type
!= NULL
);
1972 type_name
= f
->type
->name
;
1974 /* To minimize changes to generated files, don't emit type
1975 info for fields that have defaulted types. */
1978 gdb_assert (f
->end
!= -1);
1979 if (f
->type
->kind
== TDESC_TYPE_BOOL
)
1981 gdb_assert (f
->start
== f
->end
);
1983 (" tdesc_add_flag (type, %d, \"%s\");\n",
1986 else if ((type
->u
.u
.size
== 4
1987 && f
->type
->kind
== TDESC_TYPE_UINT32
)
1988 || (type
->u
.u
.size
== 8
1989 && f
->type
->kind
== TDESC_TYPE_UINT64
))
1992 (" tdesc_add_bitfield (type, \"%s\", %d, %d);\n",
1993 f
->name
, f
->start
, f
->end
);
1998 (" field_type = tdesc_named_type (feature,"
2002 (" tdesc_add_typed_bitfield (type, \"%s\","
2003 " %d, %d, field_type);\n",
2004 f
->name
, f
->start
, f
->end
);
2007 else /* Not a bitfield. */
2009 gdb_assert (f
->end
== -1);
2010 gdb_assert (type
->kind
== TDESC_TYPE_STRUCT
);
2012 (" field_type = tdesc_named_type (feature,"
2016 (" tdesc_add_field (type, \"%s\", field_type);\n",
2021 case TDESC_TYPE_UNION
:
2023 (" type = tdesc_create_union (feature, \"%s\");\n",
2026 VEC_iterate (tdesc_type_field
, type
->u
.u
.fields
, ix3
, f
);
2030 (" field_type = tdesc_named_type (feature, \"%s\");\n",
2033 (" tdesc_add_field (type, \"%s\", field_type);\n",
2037 case TDESC_TYPE_ENUM
:
2039 (" type = tdesc_create_enum (feature, \"%s\", %d);\n",
2040 type
->name
, type
->u
.u
.size
);
2042 VEC_iterate (tdesc_type_field
, type
->u
.u
.fields
, ix3
, f
);
2045 (" tdesc_add_enum_value (type, %d, \"%s\");\n",
2049 error (_("C output is not supported type \"%s\"."), type
->name
);
2051 printf_unfiltered ("\n");
2054 void visit (const tdesc_reg
*reg
) override
2056 printf_unfiltered (" tdesc_create_reg (feature, \"%s\", %ld, %d, ",
2057 reg
->name
, reg
->target_regnum
, reg
->save_restore
);
2059 printf_unfiltered ("\"%s\", ", reg
->group
);
2061 printf_unfiltered ("NULL, ");
2062 printf_unfiltered ("%d, \"%s\");\n", reg
->bitsize
, reg
->type
);
2066 std::string m_filename_after_features
;
2070 bool m_printed_field_type
= false;
2071 bool m_printed_type
= false;
2074 /* Print target description feature in C. */
2076 class print_c_feature
: public print_c_tdesc
2079 print_c_feature (std::string
&file
)
2080 : print_c_tdesc (file
)
2083 auto const pos
= m_filename_after_features
.find_last_of ('.');
2085 m_filename_after_features
= m_filename_after_features
.substr (0, pos
);
2088 void visit_pre (const target_desc
*e
) override
2090 printf_unfiltered (" Original: %s */\n\n",
2091 lbasename (m_filename_after_features
.c_str ()));
2093 printf_unfiltered ("#include \"arch/tdesc.h\"\n");
2094 printf_unfiltered ("\n");
2097 void visit_post (const target_desc
*e
) override
2100 void visit_pre (const tdesc_feature
*e
) override
2102 std::string
name (m_filename_after_features
);
2104 auto pos
= name
.find_first_of ('.');
2106 name
= name
.substr (0, pos
);
2107 std::replace (name
.begin (), name
.end (), '/', '_');
2108 std::replace (name
.begin (), name
.end (), '-', '_');
2110 printf_unfiltered ("static int\n");
2111 printf_unfiltered ("create_feature_%s ", name
.c_str ());
2112 printf_unfiltered ("(struct target_desc *result, long regnum)\n");
2114 printf_unfiltered ("{\n");
2115 printf_unfiltered (" struct tdesc_feature *feature;\n");
2118 ("\n feature = tdesc_create_feature (result, \"%s\", \"%s\");\n",
2119 e
->name
.c_str (), lbasename (m_filename_after_features
.c_str ()));
2122 void visit_post (const tdesc_feature
*e
) override
2124 printf_unfiltered (" return regnum;\n");
2125 printf_unfiltered ("}\n");
2128 void visit (const tdesc_reg
*reg
) override
2130 /* Most "reg" in XML target descriptions don't have "regnum"
2131 attribute, so the register number is allocated sequentially.
2132 In case that reg has "regnum" attribute, register number
2133 should be set by that explicitly. */
2135 if (reg
->target_regnum
< m_next_regnum
)
2137 /* The integrity check, it can catch some errors on register
2138 number collision, like this,
2140 <reg name="x0" bitsize="32"/>
2141 <reg name="x1" bitsize="32"/>
2142 <reg name="x2" bitsize="32"/>
2143 <reg name="x3" bitsize="32"/>
2144 <reg name="ps" bitsize="32" regnum="3"/>
2146 but it also has false negatives. The target description
2149 <reg name="x1" bitsize="32" regnum="1"/>
2150 <reg name="x3" bitsize="32" regnum="3"/>
2151 <reg name="x2" bitsize="32" regnum="2"/>
2152 <reg name="x4" bitsize="32" regnum="4"/>
2154 but it is not a good practice, so still error on this,
2155 and also print the message so that it can be saved in the
2156 generated c file. */
2158 printf_unfiltered ("ERROR: \"regnum\" attribute %ld ",
2159 reg
->target_regnum
);
2160 printf_unfiltered ("is not the largest number (%d).\n",
2162 error (_("\"regnum\" attribute %ld is not the largest number (%d)."),
2163 reg
->target_regnum
, m_next_regnum
);
2166 if (reg
->target_regnum
> m_next_regnum
)
2168 printf_unfiltered (" regnum = %ld;\n", reg
->target_regnum
);
2169 m_next_regnum
= reg
->target_regnum
;
2172 printf_unfiltered (" tdesc_create_reg (feature, \"%s\", regnum++, %d, ",
2173 reg
->name
, reg
->save_restore
);
2175 printf_unfiltered ("\"%s\", ", reg
->group
);
2177 printf_unfiltered ("NULL, ");
2178 printf_unfiltered ("%d, \"%s\");\n", reg
->bitsize
, reg
->type
);
2184 /* The register number to use for the next register we see. */
2185 int m_next_regnum
= 0;
2189 maint_print_c_tdesc_cmd (const char *args
, int from_tty
)
2191 const struct target_desc
*tdesc
;
2192 const char *filename
;
2196 /* Use the global target-supplied description, not the current
2197 architecture's. This lets a GDB for one architecture generate C
2198 for another architecture's description, even though the gdbarch
2199 initialization code will reject the new description. */
2200 tdesc
= current_target_desc
;
2201 filename
= target_description_filename
;
2205 /* Use the target description from the XML file. */
2207 tdesc
= file_read_description_xml (filename
);
2211 error (_("There is no target description to print."));
2213 if (filename
== NULL
)
2214 error (_("The current target description did not come from an XML file."));
2216 std::string
filename_after_features (filename
);
2217 auto loc
= filename_after_features
.rfind ("/features/");
2219 if (loc
!= std::string::npos
)
2220 filename_after_features
= filename_after_features
.substr (loc
+ 10);
2222 /* Print c files for target features instead of target descriptions,
2223 because c files got from target features are more flexible than the
2225 if (startswith (filename_after_features
.c_str (), "i386/32bit-")
2226 || startswith (filename_after_features
.c_str (), "i386/64bit-")
2227 || startswith (filename_after_features
.c_str (), "i386/x32-core.xml")
2228 || startswith (filename_after_features
.c_str (), "tic6x-")
2229 || startswith (filename_after_features
.c_str (), "aarch64"))
2231 print_c_feature
v (filename_after_features
);
2237 print_c_tdesc
v (filename_after_features
);
2243 namespace selftests
{
2245 static std::vector
<std::pair
<const char*, const target_desc
*>> xml_tdesc
;
2249 /* See target-descritpions.h. */
2252 record_xml_tdesc (const char *xml_file
, const struct target_desc
*tdesc
)
2254 xml_tdesc
.emplace_back (xml_file
, tdesc
);
2260 /* Check that the target descriptions created dynamically by
2261 architecture-specific code equal the descriptions created from XML files
2262 found in the specified directory DIR. */
2265 maintenance_check_xml_descriptions (const char *dir
, int from_tty
)
2268 error (_("Missing dir name"));
2270 gdb::unique_xmalloc_ptr
<char> dir1 (tilde_expand (dir
));
2271 std::string
feature_dir (dir1
.get ());
2272 unsigned int failed
= 0;
2274 for (auto const &e
: selftests::xml_tdesc
)
2276 std::string tdesc_xml
= (feature_dir
+ SLASH_STRING
+ e
.first
);
2277 const target_desc
*tdesc
2278 = file_read_description_xml (tdesc_xml
.data ());
2280 if (tdesc
== NULL
|| *tdesc
!= *e
.second
)
2283 printf_filtered (_("Tested %lu XML files, %d failed\n"),
2284 (long) selftests::xml_tdesc
.size (), failed
);
2288 _initialize_target_descriptions (void)
2290 tdesc_data
= gdbarch_data_register_pre_init (tdesc_data_init
);
2292 add_prefix_cmd ("tdesc", class_maintenance
, set_tdesc_cmd
, _("\
2293 Set target description specific variables."),
2294 &tdesc_set_cmdlist
, "set tdesc ",
2295 0 /* allow-unknown */, &setlist
);
2296 add_prefix_cmd ("tdesc", class_maintenance
, show_tdesc_cmd
, _("\
2297 Show target description specific variables."),
2298 &tdesc_show_cmdlist
, "show tdesc ",
2299 0 /* allow-unknown */, &showlist
);
2300 add_prefix_cmd ("tdesc", class_maintenance
, unset_tdesc_cmd
, _("\
2301 Unset target description specific variables."),
2302 &tdesc_unset_cmdlist
, "unset tdesc ",
2303 0 /* allow-unknown */, &unsetlist
);
2305 add_setshow_filename_cmd ("filename", class_obscure
,
2306 &tdesc_filename_cmd_string
,
2308 Set the file to read for an XML target description"), _("\
2309 Show the file to read for an XML target description"), _("\
2310 When set, GDB will read the target description from a local\n\
2311 file instead of querying the remote target."),
2312 set_tdesc_filename_cmd
,
2313 show_tdesc_filename_cmd
,
2314 &tdesc_set_cmdlist
, &tdesc_show_cmdlist
);
2316 add_cmd ("filename", class_obscure
, unset_tdesc_filename_cmd
, _("\
2317 Unset the file to read for an XML target description. When unset,\n\
2318 GDB will read the description from the target."),
2319 &tdesc_unset_cmdlist
);
2321 add_cmd ("c-tdesc", class_maintenance
, maint_print_c_tdesc_cmd
, _("\
2322 Print the current target description as a C source file."),
2323 &maintenanceprintlist
);
2325 cmd_list_element
*cmd
;
2327 cmd
= add_cmd ("xml-descriptions", class_maintenance
,
2328 maintenance_check_xml_descriptions
, _("\
2329 Check the target descriptions created in GDB equal the descriptions\n\
2330 created from XML files in the directory.\n\
2331 The parameter is the directory name."),
2332 &maintenancechecklist
);
2333 set_cmd_completer (cmd
, filename_completer
);