1 /* Target description support for GDB.
3 Copyright (C) 2006-2020 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"
29 #include "xml-support.h"
30 #include "xml-tdesc.h"
33 #include "gdb_obstack.h"
37 #include "completer.h"
38 #include "readline/tilde.h" /* tilde_expand */
44 property (const std::string
&key_
, const std::string
&value_
)
45 : key (key_
), value (value_
)
52 /* Convert a tdesc_type to a gdb type. */
55 make_gdb_type (struct gdbarch
*gdbarch
, struct tdesc_type
*ttype
)
57 class gdb_type_creator
: public tdesc_element_visitor
60 gdb_type_creator (struct gdbarch
*gdbarch
)
69 void visit (const tdesc_type_builtin
*e
) override
73 /* Predefined types. */
75 m_type
= builtin_type (m_gdbarch
)->builtin_bool
;
78 m_type
= builtin_type (m_gdbarch
)->builtin_int8
;
80 case TDESC_TYPE_INT16
:
81 m_type
= builtin_type (m_gdbarch
)->builtin_int16
;
83 case TDESC_TYPE_INT32
:
84 m_type
= builtin_type (m_gdbarch
)->builtin_int32
;
86 case TDESC_TYPE_INT64
:
87 m_type
= builtin_type (m_gdbarch
)->builtin_int64
;
89 case TDESC_TYPE_INT128
:
90 m_type
= builtin_type (m_gdbarch
)->builtin_int128
;
92 case TDESC_TYPE_UINT8
:
93 m_type
= builtin_type (m_gdbarch
)->builtin_uint8
;
95 case TDESC_TYPE_UINT16
:
96 m_type
= builtin_type (m_gdbarch
)->builtin_uint16
;
98 case TDESC_TYPE_UINT32
:
99 m_type
= builtin_type (m_gdbarch
)->builtin_uint32
;
101 case TDESC_TYPE_UINT64
:
102 m_type
= builtin_type (m_gdbarch
)->builtin_uint64
;
104 case TDESC_TYPE_UINT128
:
105 m_type
= builtin_type (m_gdbarch
)->builtin_uint128
;
107 case TDESC_TYPE_CODE_PTR
:
108 m_type
= builtin_type (m_gdbarch
)->builtin_func_ptr
;
110 case TDESC_TYPE_DATA_PTR
:
111 m_type
= builtin_type (m_gdbarch
)->builtin_data_ptr
;
115 m_type
= tdesc_find_type (m_gdbarch
, e
->name
.c_str ());
121 case TDESC_TYPE_IEEE_HALF
:
122 m_type
= arch_float_type (m_gdbarch
, -1, "builtin_type_ieee_half",
123 floatformats_ieee_half
);
126 case TDESC_TYPE_IEEE_SINGLE
:
127 m_type
= arch_float_type (m_gdbarch
, -1, "builtin_type_ieee_single",
128 floatformats_ieee_single
);
131 case TDESC_TYPE_IEEE_DOUBLE
:
132 m_type
= arch_float_type (m_gdbarch
, -1, "builtin_type_ieee_double",
133 floatformats_ieee_double
);
135 case TDESC_TYPE_ARM_FPA_EXT
:
136 m_type
= arch_float_type (m_gdbarch
, -1, "builtin_type_arm_ext",
137 floatformats_arm_ext
);
140 case TDESC_TYPE_I387_EXT
:
141 m_type
= arch_float_type (m_gdbarch
, -1, "builtin_type_i387_ext",
142 floatformats_i387_ext
);
145 case TDESC_TYPE_BFLOAT16
:
146 m_type
= arch_float_type (m_gdbarch
, -1, "builtin_type_bfloat16",
147 floatformats_bfloat16
);
151 internal_error (__FILE__
, __LINE__
,
152 "Type \"%s\" has an unknown kind %d",
153 e
->name
.c_str (), e
->kind
);
156 void visit (const tdesc_type_vector
*e
) override
158 m_type
= tdesc_find_type (m_gdbarch
, e
->name
.c_str ());
162 type
*element_gdb_type
= make_gdb_type (m_gdbarch
, e
->element_type
);
163 m_type
= init_vector_type (element_gdb_type
, e
->count
);
164 m_type
->set_name (xstrdup (e
->name
.c_str ()));
168 void visit (const tdesc_type_with_fields
*e
) override
170 m_type
= tdesc_find_type (m_gdbarch
, e
->name
.c_str ());
176 case TDESC_TYPE_STRUCT
:
177 make_gdb_type_struct (e
);
179 case TDESC_TYPE_UNION
:
180 make_gdb_type_union (e
);
182 case TDESC_TYPE_FLAGS
:
183 make_gdb_type_flags (e
);
185 case TDESC_TYPE_ENUM
:
186 make_gdb_type_enum (e
);
190 internal_error (__FILE__
, __LINE__
,
191 "Type \"%s\" has an unknown kind %d",
192 e
->name
.c_str (), e
->kind
);
197 void make_gdb_type_struct (const tdesc_type_with_fields
*e
)
199 m_type
= arch_composite_type (m_gdbarch
, NULL
, TYPE_CODE_STRUCT
);
200 m_type
->set_name (xstrdup (e
->name
.c_str ()));
202 for (const tdesc_type_field
&f
: e
->fields
)
204 if (f
.start
!= -1 && f
.end
!= -1)
208 struct type
*field_gdb_type
;
209 int bitsize
, total_size
;
211 /* This invariant should be preserved while creating types. */
212 gdb_assert (e
->size
!= 0);
214 field_gdb_type
= make_gdb_type (m_gdbarch
, f
.type
);
215 else if (e
->size
> 4)
216 field_gdb_type
= builtin_type (m_gdbarch
)->builtin_uint64
;
218 field_gdb_type
= builtin_type (m_gdbarch
)->builtin_uint32
;
220 fld
= append_composite_type_field_raw
221 (m_type
, xstrdup (f
.name
.c_str ()), field_gdb_type
);
223 /* For little-endian, BITPOS counts from the LSB of
224 the structure and marks the LSB of the field. For
225 big-endian, BITPOS counts from the MSB of the
226 structure and marks the MSB of the field. Either
227 way, it is the number of bits to the "left" of the
228 field. To calculate this in big-endian, we need
229 the total size of the structure. */
230 bitsize
= f
.end
- f
.start
+ 1;
231 total_size
= e
->size
* TARGET_CHAR_BIT
;
232 if (gdbarch_byte_order (m_gdbarch
) == BFD_ENDIAN_BIG
)
233 SET_FIELD_BITPOS (fld
[0], total_size
- f
.start
- bitsize
);
235 SET_FIELD_BITPOS (fld
[0], f
.start
);
236 FIELD_BITSIZE (fld
[0]) = bitsize
;
240 gdb_assert (f
.start
== -1 && f
.end
== -1);
241 type
*field_gdb_type
= make_gdb_type (m_gdbarch
, f
.type
);
242 append_composite_type_field (m_type
,
243 xstrdup (f
.name
.c_str ()),
249 TYPE_LENGTH (m_type
) = e
->size
;
252 void make_gdb_type_union (const tdesc_type_with_fields
*e
)
254 m_type
= arch_composite_type (m_gdbarch
, NULL
, TYPE_CODE_UNION
);
255 m_type
->set_name (xstrdup (e
->name
.c_str ()));
257 for (const tdesc_type_field
&f
: e
->fields
)
259 type
* field_gdb_type
= make_gdb_type (m_gdbarch
, f
.type
);
260 append_composite_type_field (m_type
, xstrdup (f
.name
.c_str ()),
263 /* If any of the children of a union are vectors, flag the
264 union as a vector also. This allows e.g. a union of two
265 vector types to show up automatically in "info vector". */
266 if (field_gdb_type
->is_vector ())
267 m_type
->set_is_vector (true);
271 void make_gdb_type_flags (const tdesc_type_with_fields
*e
)
273 m_type
= arch_flags_type (m_gdbarch
, e
->name
.c_str (),
274 e
->size
* TARGET_CHAR_BIT
);
276 for (const tdesc_type_field
&f
: e
->fields
)
278 int bitsize
= f
.end
- f
.start
+ 1;
280 gdb_assert (f
.type
!= NULL
);
281 type
*field_gdb_type
= make_gdb_type (m_gdbarch
, f
.type
);
282 append_flags_type_field (m_type
, f
.start
, bitsize
,
283 field_gdb_type
, f
.name
.c_str ());
287 void make_gdb_type_enum (const tdesc_type_with_fields
*e
)
289 m_type
= arch_type (m_gdbarch
, TYPE_CODE_ENUM
, e
->size
* TARGET_CHAR_BIT
,
292 m_type
->set_is_unsigned (true);
294 for (const tdesc_type_field
&f
: e
->fields
)
297 = append_composite_type_field_raw (m_type
,
298 xstrdup (f
.name
.c_str ()),
301 SET_FIELD_BITPOS (fld
[0], f
.start
);
305 /* The gdbarch used. */
306 struct gdbarch
*m_gdbarch
;
308 /* The type created. */
312 gdb_type_creator
gdb_type (gdbarch
);
313 ttype
->accept (gdb_type
);
314 return gdb_type
.get_type ();
317 /* Wrapper around bfd_arch_info_type. A class with this name is used in
318 the API that is shared between gdb and gdbserver code, but gdbserver
319 doesn't use compatibility information, so its version of this class is
322 class tdesc_compatible_info
326 explicit tdesc_compatible_info (const bfd_arch_info_type
*arch
)
330 /* Access the contained pointer. */
331 const bfd_arch_info_type
*arch () const
335 /* Architecture information looked up from the <compatible> entity within
336 a target description. */
337 const bfd_arch_info_type
*m_arch
;
340 /* A target description. */
342 struct target_desc
: tdesc_element
347 virtual ~target_desc () = default;
349 target_desc (const target_desc
&) = delete;
350 void operator= (const target_desc
&) = delete;
352 /* The architecture reported by the target, if any. */
353 const struct bfd_arch_info
*arch
= NULL
;
355 /* The osabi reported by the target, if any; GDB_OSABI_UNKNOWN
357 enum gdb_osabi osabi
= GDB_OSABI_UNKNOWN
;
359 /* The list of compatible architectures reported by the target. */
360 std::vector
<tdesc_compatible_info_up
> compatible
;
362 /* Any architecture-specific properties specified by the target. */
363 std::vector
<property
> properties
;
365 /* The features associated with this target. */
366 std::vector
<tdesc_feature_up
> features
;
368 /* Used to cache the generated xml version of the target description. */
369 mutable char *xmltarget
= nullptr;
371 void accept (tdesc_element_visitor
&v
) const override
375 for (const tdesc_feature_up
&feature
: features
)
381 bool operator== (const target_desc
&other
) const
383 if (arch
!= other
.arch
)
386 if (osabi
!= other
.osabi
)
389 if (features
.size () != other
.features
.size ())
392 for (int ix
= 0; ix
< features
.size (); ix
++)
394 const tdesc_feature_up
&feature1
= features
[ix
];
395 const tdesc_feature_up
&feature2
= other
.features
[ix
];
397 if (feature1
!= feature2
&& *feature1
!= *feature2
)
404 bool operator!= (const target_desc
&other
) const
406 return !(*this == other
);
410 /* Per-architecture data associated with a target description. The
411 target description may be shared by multiple architectures, but
412 this data is private to one gdbarch. */
414 struct tdesc_arch_reg
416 tdesc_arch_reg (tdesc_reg
*reg_
, struct type
*type_
)
417 : reg (reg_
), type (type_
)
420 struct tdesc_reg
*reg
;
424 struct tdesc_arch_data
426 /* A list of register/type pairs, indexed by GDB's internal register number.
427 During initialization of the gdbarch this list is used to store
428 registers which the architecture assigns a fixed register number.
429 Registers which are NULL in this array, or off the end, are
430 treated as zero-sized and nameless (i.e. placeholders in the
432 std::vector
<tdesc_arch_reg
> arch_regs
;
434 /* Functions which report the register name, type, and reggroups for
436 gdbarch_register_name_ftype
*pseudo_register_name
= NULL
;
437 gdbarch_register_type_ftype
*pseudo_register_type
= NULL
;
438 gdbarch_register_reggroup_p_ftype
*pseudo_register_reggroup_p
= NULL
;
441 /* Info about an inferior's target description. There's one of these
442 for each inferior. */
444 struct target_desc_info
446 /* A flag indicating that a description has already been fetched
447 from the target, so it should not be queried again. */
451 /* The description fetched from the target, or NULL if the target
452 did not supply any description. Only valid when
453 target_desc_fetched is set. Only the description initialization
454 code should access this; normally, the description should be
455 accessed through the gdbarch object. */
457 const struct target_desc
*tdesc
;
459 /* The filename to read a target description from, as set by "set
460 tdesc filename ..." */
465 /* Get the inferior INF's target description info, allocating one on
466 the stop if necessary. */
468 static struct target_desc_info
*
469 get_tdesc_info (struct inferior
*inf
)
471 if (inf
->tdesc_info
== NULL
)
472 inf
->tdesc_info
= XCNEW (struct target_desc_info
);
473 return inf
->tdesc_info
;
476 /* A handle for architecture-specific data associated with the
477 target description (see struct tdesc_arch_data). */
479 static struct gdbarch_data
*tdesc_data
;
481 /* See target-descriptions.h. */
484 target_desc_info_from_user_p (struct target_desc_info
*info
)
486 return info
!= NULL
&& info
->filename
!= NULL
;
489 /* See target-descriptions.h. */
492 copy_inferior_target_desc_info (struct inferior
*destinf
, struct inferior
*srcinf
)
494 struct target_desc_info
*src
= get_tdesc_info (srcinf
);
495 struct target_desc_info
*dest
= get_tdesc_info (destinf
);
497 dest
->fetched
= src
->fetched
;
498 dest
->tdesc
= src
->tdesc
;
499 dest
->filename
= src
->filename
!= NULL
? xstrdup (src
->filename
) : NULL
;
502 /* See target-descriptions.h. */
505 target_desc_info_free (struct target_desc_info
*tdesc_info
)
507 if (tdesc_info
!= NULL
)
509 xfree (tdesc_info
->filename
);
514 /* Convenience helper macros. */
516 #define target_desc_fetched \
517 get_tdesc_info (current_inferior ())->fetched
518 #define current_target_desc \
519 get_tdesc_info (current_inferior ())->tdesc
520 #define target_description_filename \
521 get_tdesc_info (current_inferior ())->filename
523 /* The string manipulated by the "set tdesc filename ..." command. */
525 static char *tdesc_filename_cmd_string
;
527 /* Fetch the current target's description, and switch the current
528 architecture to one which incorporates that description. */
531 target_find_description (void)
533 /* If we've already fetched a description from the target, don't do
534 it again. This allows a target to fetch the description early,
535 during its to_open or to_create_inferior, if it needs extra
536 information about the target to initialize. */
537 if (target_desc_fetched
)
540 /* The current architecture should not have any target description
541 specified. It should have been cleared, e.g. when we
542 disconnected from the previous target. */
543 gdb_assert (gdbarch_target_desc (target_gdbarch ()) == NULL
);
545 /* First try to fetch an XML description from the user-specified
547 current_target_desc
= NULL
;
548 if (target_description_filename
!= NULL
549 && *target_description_filename
!= '\0')
551 = file_read_description_xml (target_description_filename
);
553 /* Next try to read the description from the current target using
555 if (current_target_desc
== NULL
)
556 current_target_desc
= target_read_description_xml (current_top_target ());
558 /* If that failed try a target-specific hook. */
559 if (current_target_desc
== NULL
)
560 current_target_desc
= target_read_description (current_top_target ());
562 /* If a non-NULL description was returned, then update the current
564 if (current_target_desc
)
566 struct gdbarch_info info
;
568 gdbarch_info_init (&info
);
569 info
.target_desc
= current_target_desc
;
570 if (!gdbarch_update_p (info
))
571 warning (_("Architecture rejected target-supplied description"));
574 struct tdesc_arch_data
*data
;
576 data
= ((struct tdesc_arch_data
*)
577 gdbarch_data (target_gdbarch (), tdesc_data
));
578 if (tdesc_has_registers (current_target_desc
)
579 && data
->arch_regs
.empty ())
580 warning (_("Target-supplied registers are not supported "
581 "by the current architecture"));
585 /* Now that we know this description is usable, record that we
587 target_desc_fetched
= 1;
590 /* Discard any description fetched from the current target, and switch
591 the current architecture to one with no target description. */
594 target_clear_description (void)
596 struct gdbarch_info info
;
598 if (!target_desc_fetched
)
601 target_desc_fetched
= 0;
602 current_target_desc
= NULL
;
604 gdbarch_info_init (&info
);
605 if (!gdbarch_update_p (info
))
606 internal_error (__FILE__
, __LINE__
,
607 _("Could not remove target-supplied description"));
610 /* Return the global current target description. This should only be
611 used by gdbarch initialization code; most access should be through
612 an existing gdbarch. */
614 const struct target_desc
*
615 target_current_description (void)
617 if (target_desc_fetched
)
618 return current_target_desc
;
623 /* Return non-zero if this target description is compatible
624 with the given BFD architecture. */
627 tdesc_compatible_p (const struct target_desc
*target_desc
,
628 const struct bfd_arch_info
*arch
)
630 for (const tdesc_compatible_info_up
&compat
: target_desc
->compatible
)
632 if (compat
->arch () == arch
633 || arch
->compatible (arch
, compat
->arch ())
634 || compat
->arch ()->compatible (compat
->arch (), arch
))
642 /* Direct accessors for target descriptions. */
644 /* Return the string value of a property named KEY, or NULL if the
645 property was not specified. */
648 tdesc_property (const struct target_desc
*target_desc
, const char *key
)
650 for (const property
&prop
: target_desc
->properties
)
652 return prop
.value
.c_str ();
657 /* Return the BFD architecture associated with this target
658 description, or NULL if no architecture was specified. */
660 const struct bfd_arch_info
*
661 tdesc_architecture (const struct target_desc
*target_desc
)
663 return target_desc
->arch
;
666 /* See gdbsupport/tdesc.h. */
669 tdesc_architecture_name (const struct target_desc
*target_desc
)
671 if (target_desc
->arch
!= NULL
)
672 return target_desc
->arch
->printable_name
;
676 /* See gdbsupport/tdesc.h. */
678 const std::vector
<tdesc_compatible_info_up
> &
679 tdesc_compatible_info_list (const target_desc
*target_desc
)
681 return target_desc
->compatible
;
684 /* See gdbsupport/tdesc.h. */
687 tdesc_compatible_info_arch_name (const tdesc_compatible_info_up
&compatible
)
689 return compatible
->arch ()->printable_name
;
692 /* Return the OSABI associated with this target description, or
693 GDB_OSABI_UNKNOWN if no osabi was specified. */
696 tdesc_osabi (const struct target_desc
*target_desc
)
698 return target_desc
->osabi
;
701 /* See gdbsupport/tdesc.h. */
704 tdesc_osabi_name (const struct target_desc
*target_desc
)
706 enum gdb_osabi osabi
= tdesc_osabi (target_desc
);
707 if (osabi
> GDB_OSABI_UNKNOWN
&& osabi
< GDB_OSABI_INVALID
)
708 return gdbarch_osabi_name (osabi
);
712 /* Return 1 if this target description includes any registers. */
715 tdesc_has_registers (const struct target_desc
*target_desc
)
717 if (target_desc
== NULL
)
720 for (const tdesc_feature_up
&feature
: target_desc
->features
)
721 if (!feature
->registers
.empty ())
727 /* Return the feature with the given name, if present, or NULL if
728 the named feature is not found. */
730 const struct tdesc_feature
*
731 tdesc_find_feature (const struct target_desc
*target_desc
,
734 for (const tdesc_feature_up
&feature
: target_desc
->features
)
735 if (feature
->name
== name
)
736 return feature
.get ();
741 /* Return the name of FEATURE. */
744 tdesc_feature_name (const struct tdesc_feature
*feature
)
746 return feature
->name
.c_str ();
749 /* Lookup type associated with ID. */
752 tdesc_find_type (struct gdbarch
*gdbarch
, const char *id
)
754 tdesc_arch_data
*data
755 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
757 for (const tdesc_arch_reg
®
: data
->arch_regs
)
760 && reg
.reg
->tdesc_type
762 && reg
.reg
->tdesc_type
->name
== id
)
769 /* Support for registers from target descriptions. */
771 /* Construct the per-gdbarch data. */
774 tdesc_data_init (struct obstack
*obstack
)
776 return obstack_new
<tdesc_arch_data
> (obstack
);
779 /* Similar, but for the temporary copy used during architecture
782 struct tdesc_arch_data
*
783 tdesc_data_alloc (void)
785 return new tdesc_arch_data ();
788 /* Free something allocated by tdesc_data_alloc, if it is not going
789 to be used (for instance if it was unsuitable for the
793 tdesc_data_cleanup (void *data_untyped
)
795 struct tdesc_arch_data
*data
= (struct tdesc_arch_data
*) data_untyped
;
800 /* Search FEATURE for a register named NAME. */
802 static struct tdesc_reg
*
803 tdesc_find_register_early (const struct tdesc_feature
*feature
,
806 for (const tdesc_reg_up
®
: feature
->registers
)
807 if (strcasecmp (reg
->name
.c_str (), name
) == 0)
813 /* Search FEATURE for a register named NAME. Assign REGNO to it. */
816 tdesc_numbered_register (const struct tdesc_feature
*feature
,
817 struct tdesc_arch_data
*data
,
818 int regno
, const char *name
)
820 struct tdesc_reg
*reg
= tdesc_find_register_early (feature
, name
);
825 /* Make sure the vector includes a REGNO'th element. */
826 while (regno
>= data
->arch_regs
.size ())
827 data
->arch_regs
.emplace_back (nullptr, nullptr);
829 data
->arch_regs
[regno
] = tdesc_arch_reg (reg
, NULL
);
834 /* Search FEATURE for a register named NAME, but do not assign a fixed
835 register number to it. */
838 tdesc_unnumbered_register (const struct tdesc_feature
*feature
,
841 struct tdesc_reg
*reg
= tdesc_find_register_early (feature
, name
);
849 /* Search FEATURE for a register whose name is in NAMES and assign
853 tdesc_numbered_register_choices (const struct tdesc_feature
*feature
,
854 struct tdesc_arch_data
*data
,
855 int regno
, const char *const names
[])
859 for (i
= 0; names
[i
] != NULL
; i
++)
860 if (tdesc_numbered_register (feature
, data
, regno
, names
[i
]))
866 /* Search FEATURE for a register named NAME, and return its size in
867 bits. The register must exist. */
870 tdesc_register_bitsize (const struct tdesc_feature
*feature
, const char *name
)
872 struct tdesc_reg
*reg
= tdesc_find_register_early (feature
, name
);
874 gdb_assert (reg
!= NULL
);
878 /* Look up a register by its GDB internal register number. */
880 static struct tdesc_arch_reg
*
881 tdesc_find_arch_register (struct gdbarch
*gdbarch
, int regno
)
883 struct tdesc_arch_data
*data
;
885 data
= (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
886 if (regno
< data
->arch_regs
.size ())
887 return &data
->arch_regs
[regno
];
892 static struct tdesc_reg
*
893 tdesc_find_register (struct gdbarch
*gdbarch
, int regno
)
895 struct tdesc_arch_reg
*reg
= tdesc_find_arch_register (gdbarch
, regno
);
897 return reg
? reg
->reg
: NULL
;
900 /* Return the name of register REGNO, from the target description or
901 from an architecture-provided pseudo_register_name method. */
904 tdesc_register_name (struct gdbarch
*gdbarch
, int regno
)
906 struct tdesc_reg
*reg
= tdesc_find_register (gdbarch
, regno
);
907 int num_regs
= gdbarch_num_regs (gdbarch
);
910 return reg
->name
.c_str ();
912 if (regno
>= num_regs
&& regno
< gdbarch_num_cooked_regs (gdbarch
))
914 struct tdesc_arch_data
*data
915 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
917 gdb_assert (data
->pseudo_register_name
!= NULL
);
918 return data
->pseudo_register_name (gdbarch
, regno
);
925 tdesc_register_type (struct gdbarch
*gdbarch
, int regno
)
927 struct tdesc_arch_reg
*arch_reg
= tdesc_find_arch_register (gdbarch
, regno
);
928 struct tdesc_reg
*reg
= arch_reg
? arch_reg
->reg
: NULL
;
929 int num_regs
= gdbarch_num_regs (gdbarch
);
930 int num_pseudo_regs
= gdbarch_num_pseudo_regs (gdbarch
);
932 if (reg
== NULL
&& regno
>= num_regs
&& regno
< num_regs
+ num_pseudo_regs
)
934 struct tdesc_arch_data
*data
935 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
937 gdb_assert (data
->pseudo_register_type
!= NULL
);
938 return data
->pseudo_register_type (gdbarch
, regno
);
942 /* Return "int0_t", since "void" has a misleading size of one. */
943 return builtin_type (gdbarch
)->builtin_int0
;
945 if (arch_reg
->type
== NULL
)
947 /* First check for a predefined or target defined type. */
949 arch_reg
->type
= make_gdb_type (gdbarch
, reg
->tdesc_type
);
951 /* Next try size-sensitive type shortcuts. */
952 else if (reg
->type
== "float")
954 if (reg
->bitsize
== gdbarch_float_bit (gdbarch
))
955 arch_reg
->type
= builtin_type (gdbarch
)->builtin_float
;
956 else if (reg
->bitsize
== gdbarch_double_bit (gdbarch
))
957 arch_reg
->type
= builtin_type (gdbarch
)->builtin_double
;
958 else if (reg
->bitsize
== gdbarch_long_double_bit (gdbarch
))
959 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long_double
;
962 warning (_("Register \"%s\" has an unsupported size (%d bits)"),
963 reg
->name
.c_str (), reg
->bitsize
);
964 arch_reg
->type
= builtin_type (gdbarch
)->builtin_double
;
967 else if (reg
->type
== "int")
969 if (reg
->bitsize
== gdbarch_long_bit (gdbarch
))
970 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long
;
971 else if (reg
->bitsize
== TARGET_CHAR_BIT
)
972 arch_reg
->type
= builtin_type (gdbarch
)->builtin_char
;
973 else if (reg
->bitsize
== gdbarch_short_bit (gdbarch
))
974 arch_reg
->type
= builtin_type (gdbarch
)->builtin_short
;
975 else if (reg
->bitsize
== gdbarch_int_bit (gdbarch
))
976 arch_reg
->type
= builtin_type (gdbarch
)->builtin_int
;
977 else if (reg
->bitsize
== gdbarch_long_long_bit (gdbarch
))
978 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long_long
;
979 else if (reg
->bitsize
== gdbarch_ptr_bit (gdbarch
))
980 /* A bit desperate by this point... */
981 arch_reg
->type
= builtin_type (gdbarch
)->builtin_data_ptr
;
984 warning (_("Register \"%s\" has an unsupported size (%d bits)"),
985 reg
->name
.c_str (), reg
->bitsize
);
986 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long
;
990 if (arch_reg
->type
== NULL
)
991 internal_error (__FILE__
, __LINE__
,
992 "Register \"%s\" has an unknown type \"%s\"",
993 reg
->name
.c_str (), reg
->type
.c_str ());
996 return arch_reg
->type
;
1000 tdesc_remote_register_number (struct gdbarch
*gdbarch
, int regno
)
1002 struct tdesc_reg
*reg
= tdesc_find_register (gdbarch
, regno
);
1005 return reg
->target_regnum
;
1010 /* Check whether REGNUM is a member of REGGROUP. Registers from the
1011 target description may be classified as general, float, vector or other
1012 register groups registered with reggroup_add(). Unlike a gdbarch
1013 register_reggroup_p method, this function will return -1 if it does not
1014 know; the caller should handle registers with no specified group.
1016 The names of containing features are not used. This might be extended
1017 to display registers in some more useful groupings.
1019 The save-restore flag is also implemented here. */
1022 tdesc_register_in_reggroup_p (struct gdbarch
*gdbarch
, int regno
,
1023 struct reggroup
*reggroup
)
1025 struct tdesc_reg
*reg
= tdesc_find_register (gdbarch
, regno
);
1027 if (reg
!= NULL
&& !reg
->group
.empty ()
1028 && (reg
->group
== reggroup_name (reggroup
)))
1032 && (reggroup
== save_reggroup
|| reggroup
== restore_reggroup
))
1033 return reg
->save_restore
;
1038 /* Check whether REGNUM is a member of REGGROUP. Registers with no
1039 group specified go to the default reggroup function and are handled
1043 tdesc_register_reggroup_p (struct gdbarch
*gdbarch
, int regno
,
1044 struct reggroup
*reggroup
)
1046 int num_regs
= gdbarch_num_regs (gdbarch
);
1047 int num_pseudo_regs
= gdbarch_num_pseudo_regs (gdbarch
);
1050 if (regno
>= num_regs
&& regno
< num_regs
+ num_pseudo_regs
)
1052 struct tdesc_arch_data
*data
1053 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1055 if (data
->pseudo_register_reggroup_p
!= NULL
)
1056 return data
->pseudo_register_reggroup_p (gdbarch
, regno
, reggroup
);
1057 /* Otherwise fall through to the default reggroup_p. */
1060 ret
= tdesc_register_in_reggroup_p (gdbarch
, regno
, reggroup
);
1064 return default_register_reggroup_p (gdbarch
, regno
, reggroup
);
1067 /* Record architecture-specific functions to call for pseudo-register
1071 set_tdesc_pseudo_register_name (struct gdbarch
*gdbarch
,
1072 gdbarch_register_name_ftype
*pseudo_name
)
1074 struct tdesc_arch_data
*data
1075 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1077 data
->pseudo_register_name
= pseudo_name
;
1081 set_tdesc_pseudo_register_type (struct gdbarch
*gdbarch
,
1082 gdbarch_register_type_ftype
*pseudo_type
)
1084 struct tdesc_arch_data
*data
1085 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1087 data
->pseudo_register_type
= pseudo_type
;
1091 set_tdesc_pseudo_register_reggroup_p
1092 (struct gdbarch
*gdbarch
,
1093 gdbarch_register_reggroup_p_ftype
*pseudo_reggroup_p
)
1095 struct tdesc_arch_data
*data
1096 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1098 data
->pseudo_register_reggroup_p
= pseudo_reggroup_p
;
1101 /* Update GDBARCH to use the target description for registers. */
1104 tdesc_use_registers (struct gdbarch
*gdbarch
,
1105 const struct target_desc
*target_desc
,
1106 struct tdesc_arch_data
*early_data
,
1107 tdesc_unknown_register_ftype unk_reg_cb
)
1109 int num_regs
= gdbarch_num_regs (gdbarch
);
1110 struct tdesc_arch_data
*data
;
1112 /* We can't use the description for registers if it doesn't describe
1113 any. This function should only be called after validating
1114 registers, so the caller should know that registers are
1116 gdb_assert (tdesc_has_registers (target_desc
));
1118 data
= (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1119 data
->arch_regs
= early_data
->arch_regs
;
1122 /* Build up a set of all registers, so that we can assign register
1123 numbers where needed. The hash table expands as necessary, so
1124 the initial size is arbitrary. */
1125 htab_up
reg_hash (htab_create (37, htab_hash_pointer
, htab_eq_pointer
,
1127 for (const tdesc_feature_up
&feature
: target_desc
->features
)
1128 for (const tdesc_reg_up
®
: feature
->registers
)
1130 void **slot
= htab_find_slot (reg_hash
.get (), reg
.get (), INSERT
);
1133 /* Add reggroup if its new. */
1134 if (!reg
->group
.empty ())
1135 if (reggroup_find (gdbarch
, reg
->group
.c_str ()) == NULL
)
1136 reggroup_add (gdbarch
, reggroup_gdbarch_new (gdbarch
,
1137 reg
->group
.c_str (),
1141 /* Remove any registers which were assigned numbers by the
1143 for (const tdesc_arch_reg
&arch_reg
: data
->arch_regs
)
1144 if (arch_reg
.reg
!= NULL
)
1145 htab_remove_elt (reg_hash
.get (), arch_reg
.reg
);
1147 /* Assign numbers to the remaining registers and add them to the
1148 list of registers. The new numbers are always above gdbarch_num_regs.
1149 Iterate over the features, not the hash table, so that the order
1150 matches that in the target description. */
1152 gdb_assert (data
->arch_regs
.size () <= num_regs
);
1153 while (data
->arch_regs
.size () < num_regs
)
1154 data
->arch_regs
.emplace_back (nullptr, nullptr);
1156 /* First we give the target a chance to number previously unknown
1157 registers. This allows targets to record the numbers assigned based
1158 on which feature the register was from. */
1159 if (unk_reg_cb
!= NULL
)
1161 for (const tdesc_feature_up
&feature
: target_desc
->features
)
1162 for (const tdesc_reg_up
®
: feature
->registers
)
1163 if (htab_find (reg_hash
.get (), reg
.get ()) != NULL
)
1165 int regno
= unk_reg_cb (gdbarch
, feature
.get (),
1166 reg
->name
.c_str (), num_regs
);
1167 gdb_assert (regno
== -1 || regno
>= num_regs
);
1170 while (regno
>= data
->arch_regs
.size ())
1171 data
->arch_regs
.emplace_back (nullptr, nullptr);
1172 data
->arch_regs
[regno
] = tdesc_arch_reg (reg
.get (), NULL
);
1173 num_regs
= regno
+ 1;
1174 htab_remove_elt (reg_hash
.get (), reg
.get ());
1179 /* Ensure the array was sized correctly above. */
1180 gdb_assert (data
->arch_regs
.size () == num_regs
);
1182 /* Now in a final pass we assign register numbers to any remaining
1183 unnumbered registers. */
1184 for (const tdesc_feature_up
&feature
: target_desc
->features
)
1185 for (const tdesc_reg_up
®
: feature
->registers
)
1186 if (htab_find (reg_hash
.get (), reg
.get ()) != NULL
)
1188 data
->arch_regs
.emplace_back (reg
.get (), nullptr);
1192 /* Update the architecture. */
1193 set_gdbarch_num_regs (gdbarch
, num_regs
);
1194 set_gdbarch_register_name (gdbarch
, tdesc_register_name
);
1195 set_gdbarch_register_type (gdbarch
, tdesc_register_type
);
1196 set_gdbarch_remote_register_number (gdbarch
,
1197 tdesc_remote_register_number
);
1198 set_gdbarch_register_reggroup_p (gdbarch
, tdesc_register_reggroup_p
);
1201 /* See gdbsupport/tdesc.h. */
1203 struct tdesc_feature
*
1204 tdesc_create_feature (struct target_desc
*tdesc
, const char *name
)
1206 struct tdesc_feature
*new_feature
= new tdesc_feature (name
);
1208 tdesc
->features
.emplace_back (new_feature
);
1213 /* See gdbsupport/tdesc.h. */
1215 struct target_desc
*
1216 allocate_target_description (void)
1218 return new target_desc ();
1221 /* See gdbsupport/tdesc.h. */
1224 target_desc_deleter::operator() (struct target_desc
*target_desc
) const
1230 tdesc_add_compatible (struct target_desc
*target_desc
,
1231 const struct bfd_arch_info
*compatible
)
1233 /* If this instance of GDB is compiled without BFD support for the
1234 compatible architecture, simply ignore it -- we would not be able
1235 to handle it anyway. */
1236 if (compatible
== NULL
)
1239 for (const tdesc_compatible_info_up
&compat
: target_desc
->compatible
)
1240 if (compat
->arch () == compatible
)
1241 internal_error (__FILE__
, __LINE__
,
1242 _("Attempted to add duplicate "
1243 "compatible architecture \"%s\""),
1244 compatible
->printable_name
);
1246 target_desc
->compatible
.push_back
1247 (std::unique_ptr
<tdesc_compatible_info
>
1248 (new tdesc_compatible_info (compatible
)));
1252 set_tdesc_property (struct target_desc
*target_desc
,
1253 const char *key
, const char *value
)
1255 gdb_assert (key
!= NULL
&& value
!= NULL
);
1257 if (tdesc_property (target_desc
, key
) != NULL
)
1258 internal_error (__FILE__
, __LINE__
,
1259 _("Attempted to add duplicate property \"%s\""), key
);
1261 target_desc
->properties
.emplace_back (key
, value
);
1264 /* See gdbsupport/tdesc.h. */
1267 set_tdesc_architecture (struct target_desc
*target_desc
,
1270 set_tdesc_architecture (target_desc
, bfd_scan_arch (name
));
1274 set_tdesc_architecture (struct target_desc
*target_desc
,
1275 const struct bfd_arch_info
*arch
)
1277 target_desc
->arch
= arch
;
1280 /* See gdbsupport/tdesc.h. */
1283 set_tdesc_osabi (struct target_desc
*target_desc
, const char *name
)
1285 set_tdesc_osabi (target_desc
, osabi_from_tdesc_string (name
));
1289 set_tdesc_osabi (struct target_desc
*target_desc
, enum gdb_osabi osabi
)
1291 target_desc
->osabi
= osabi
;
1295 static struct cmd_list_element
*tdesc_set_cmdlist
, *tdesc_show_cmdlist
;
1296 static struct cmd_list_element
*tdesc_unset_cmdlist
;
1298 /* Helper functions for the CLI commands. */
1301 set_tdesc_filename_cmd (const char *args
, int from_tty
,
1302 struct cmd_list_element
*c
)
1304 xfree (target_description_filename
);
1305 target_description_filename
= xstrdup (tdesc_filename_cmd_string
);
1307 target_clear_description ();
1308 target_find_description ();
1312 show_tdesc_filename_cmd (struct ui_file
*file
, int from_tty
,
1313 struct cmd_list_element
*c
,
1316 value
= target_description_filename
;
1318 if (value
!= NULL
&& *value
!= '\0')
1319 printf_filtered (_("The target description will be read from \"%s\".\n"),
1322 printf_filtered (_("The target description will be "
1323 "read from the target.\n"));
1327 unset_tdesc_filename_cmd (const char *args
, int from_tty
)
1329 xfree (target_description_filename
);
1330 target_description_filename
= NULL
;
1331 target_clear_description ();
1332 target_find_description ();
1335 /* Print target description in C. */
1337 class print_c_tdesc
: public tdesc_element_visitor
1340 print_c_tdesc (std::string
&filename_after_features
)
1341 : m_filename_after_features (filename_after_features
)
1345 const char *filename
= lbasename (m_filename_after_features
.c_str ());
1347 m_function
= (char *) xmalloc (strlen (filename
) + 1);
1348 for (inp
= filename
, outp
= m_function
; *inp
!= '\0'; inp
++)
1351 else if (*inp
== '-')
1353 else if (*inp
== ' ')
1359 /* Standard boilerplate. */
1360 printf_unfiltered ("/* THIS FILE IS GENERATED. "
1361 "-*- buffer-read-only: t -*- vi"
1370 void visit_pre (const target_desc
*e
) override
1372 printf_unfiltered (" Original: %s */\n\n",
1373 lbasename (m_filename_after_features
.c_str ()));
1375 printf_unfiltered ("#include \"defs.h\"\n");
1376 printf_unfiltered ("#include \"osabi.h\"\n");
1377 printf_unfiltered ("#include \"target-descriptions.h\"\n");
1378 printf_unfiltered ("\n");
1380 printf_unfiltered ("struct target_desc *tdesc_%s;\n", m_function
);
1381 printf_unfiltered ("static void\n");
1382 printf_unfiltered ("initialize_tdesc_%s (void)\n", m_function
);
1383 printf_unfiltered ("{\n");
1385 (" struct target_desc *result = allocate_target_description ();\n");
1387 if (tdesc_architecture (e
) != NULL
)
1390 (" set_tdesc_architecture (result, bfd_scan_arch (\"%s\"));\n",
1391 tdesc_architecture (e
)->printable_name
);
1392 printf_unfiltered ("\n");
1394 if (tdesc_osabi (e
) > GDB_OSABI_UNKNOWN
1395 && tdesc_osabi (e
) < GDB_OSABI_INVALID
)
1398 (" set_tdesc_osabi (result, osabi_from_tdesc_string (\"%s\"));\n",
1399 gdbarch_osabi_name (tdesc_osabi (e
)));
1400 printf_unfiltered ("\n");
1403 for (const tdesc_compatible_info_up
&compatible
: e
->compatible
)
1405 (" tdesc_add_compatible (result, bfd_scan_arch (\"%s\"));\n",
1406 compatible
->arch ()->printable_name
);
1408 if (!e
->compatible
.empty ())
1409 printf_unfiltered ("\n");
1411 for (const property
&prop
: e
->properties
)
1412 printf_unfiltered (" set_tdesc_property (result, \"%s\", \"%s\");\n",
1413 prop
.key
.c_str (), prop
.value
.c_str ());
1415 printf_unfiltered (" struct tdesc_feature *feature;\n");
1418 void visit_pre (const tdesc_feature
*e
) override
1420 printf_unfiltered ("\n feature = tdesc_create_feature (result, \"%s\");\n",
1424 void visit_post (const tdesc_feature
*e
) override
1427 void visit_post (const target_desc
*e
) override
1429 printf_unfiltered ("\n tdesc_%s = result;\n", m_function
);
1430 printf_unfiltered ("}\n");
1433 void visit (const tdesc_type_builtin
*type
) override
1435 error (_("C output is not supported type \"%s\"."), type
->name
.c_str ());
1438 void visit (const tdesc_type_vector
*type
) override
1440 if (!m_printed_element_type
)
1442 printf_unfiltered (" tdesc_type *element_type;\n");
1443 m_printed_element_type
= true;
1447 (" element_type = tdesc_named_type (feature, \"%s\");\n",
1448 type
->element_type
->name
.c_str ());
1450 (" tdesc_create_vector (feature, \"%s\", element_type, %d);\n",
1451 type
->name
.c_str (), type
->count
);
1453 printf_unfiltered ("\n");
1456 void visit (const tdesc_type_with_fields
*type
) override
1458 if (!m_printed_type_with_fields
)
1460 printf_unfiltered (" tdesc_type_with_fields *type_with_fields;\n");
1461 m_printed_type_with_fields
= true;
1466 case TDESC_TYPE_STRUCT
:
1467 case TDESC_TYPE_FLAGS
:
1468 if (type
->kind
== TDESC_TYPE_STRUCT
)
1471 (" type_with_fields = tdesc_create_struct (feature, \"%s\");\n",
1472 type
->name
.c_str ());
1473 if (type
->size
!= 0)
1475 (" tdesc_set_struct_size (type_with_fields, %d);\n", type
->size
);
1480 (" type_with_fields = tdesc_create_flags (feature, \"%s\", %d);\n",
1481 type
->name
.c_str (), type
->size
);
1483 for (const tdesc_type_field
&f
: type
->fields
)
1485 const char *type_name
;
1487 gdb_assert (f
.type
!= NULL
);
1488 type_name
= f
.type
->name
.c_str ();
1490 /* To minimize changes to generated files, don't emit type
1491 info for fields that have defaulted types. */
1494 gdb_assert (f
.end
!= -1);
1495 if (f
.type
->kind
== TDESC_TYPE_BOOL
)
1497 gdb_assert (f
.start
== f
.end
);
1499 (" tdesc_add_flag (type_with_fields, %d, \"%s\");\n",
1500 f
.start
, f
.name
.c_str ());
1502 else if ((type
->size
== 4 && f
.type
->kind
== TDESC_TYPE_UINT32
)
1504 && f
.type
->kind
== TDESC_TYPE_UINT64
))
1507 (" tdesc_add_bitfield (type_with_fields, \"%s\", %d, %d);\n",
1508 f
.name
.c_str (), f
.start
, f
.end
);
1512 printf_field_type_assignment
1513 ("tdesc_named_type (feature, \"%s\");\n",
1516 (" tdesc_add_typed_bitfield (type_with_fields, \"%s\","
1517 " %d, %d, field_type);\n",
1518 f
.name
.c_str (), f
.start
, f
.end
);
1521 else /* Not a bitfield. */
1523 gdb_assert (f
.end
== -1);
1524 gdb_assert (type
->kind
== TDESC_TYPE_STRUCT
);
1525 printf_field_type_assignment
1526 ("tdesc_named_type (feature, \"%s\");\n", type_name
);
1528 (" tdesc_add_field (type_with_fields, \"%s\", field_type);\n",
1533 case TDESC_TYPE_UNION
:
1535 (" type_with_fields = tdesc_create_union (feature, \"%s\");\n",
1536 type
->name
.c_str ());
1537 for (const tdesc_type_field
&f
: type
->fields
)
1539 printf_field_type_assignment
1540 ("tdesc_named_type (feature, \"%s\");\n", f
.type
->name
.c_str ());
1542 (" tdesc_add_field (type_with_fields, \"%s\", field_type);\n",
1546 case TDESC_TYPE_ENUM
:
1548 (" type_with_fields = tdesc_create_enum (feature, \"%s\", %d);\n",
1549 type
->name
.c_str (), type
->size
);
1550 for (const tdesc_type_field
&f
: type
->fields
)
1552 (" tdesc_add_enum_value (type_with_fields, %d, \"%s\");\n",
1553 f
.start
, f
.name
.c_str ());
1556 error (_("C output is not supported type \"%s\"."), type
->name
.c_str ());
1559 printf_unfiltered ("\n");
1562 void visit (const tdesc_reg
*reg
) override
1564 printf_unfiltered (" tdesc_create_reg (feature, \"%s\", %ld, %d, ",
1565 reg
->name
.c_str (), reg
->target_regnum
,
1567 if (!reg
->group
.empty ())
1568 printf_unfiltered ("\"%s\", ", reg
->group
.c_str ());
1570 printf_unfiltered ("NULL, ");
1571 printf_unfiltered ("%d, \"%s\");\n", reg
->bitsize
, reg
->type
.c_str ());
1575 std::string m_filename_after_features
;
1579 /* Print an assignment to the field_type variable. Print the declaration
1580 of field_type if that has not been done yet. */
1581 ATTRIBUTE_PRINTF (2, 3)
1582 void printf_field_type_assignment (const char *fmt
, ...)
1584 if (!m_printed_field_type
)
1586 printf_unfiltered (" tdesc_type *field_type;\n");
1587 m_printed_field_type
= true;
1590 printf_unfiltered (" field_type = ");
1593 va_start (args
, fmt
);
1594 vprintf_unfiltered (fmt
, args
);
1600 /* Did we print "struct tdesc_type *element_type;" yet? */
1601 bool m_printed_element_type
= false;
1603 /* Did we print "struct tdesc_type_with_fields *element_type;" yet? */
1604 bool m_printed_type_with_fields
= false;
1606 /* Did we print "struct tdesc_type *field_type;" yet? */
1607 bool m_printed_field_type
= false;
1610 /* Print target description feature in C. */
1612 class print_c_feature
: public print_c_tdesc
1615 print_c_feature (std::string
&file
)
1616 : print_c_tdesc (file
)
1619 auto const pos
= m_filename_after_features
.find_last_of ('.');
1621 m_filename_after_features
= m_filename_after_features
.substr (0, pos
);
1624 void visit_pre (const target_desc
*e
) override
1626 printf_unfiltered (" Original: %s */\n\n",
1627 lbasename (m_filename_after_features
.c_str ()));
1629 printf_unfiltered ("#include \"gdbsupport/tdesc.h\"\n");
1630 printf_unfiltered ("\n");
1633 void visit_post (const target_desc
*e
) override
1636 void visit_pre (const tdesc_feature
*e
) override
1638 std::string
name (m_filename_after_features
);
1640 auto pos
= name
.find_first_of ('.');
1642 name
= name
.substr (0, pos
);
1643 std::replace (name
.begin (), name
.end (), '/', '_');
1644 std::replace (name
.begin (), name
.end (), '-', '_');
1646 printf_unfiltered ("static int\n");
1647 printf_unfiltered ("create_feature_%s ", name
.c_str ());
1648 printf_unfiltered ("(struct target_desc *result, long regnum)\n");
1650 printf_unfiltered ("{\n");
1651 printf_unfiltered (" struct tdesc_feature *feature;\n");
1654 ("\n feature = tdesc_create_feature (result, \"%s\");\n",
1658 void visit_post (const tdesc_feature
*e
) override
1660 printf_unfiltered (" return regnum;\n");
1661 printf_unfiltered ("}\n");
1664 void visit (const tdesc_reg
*reg
) override
1666 /* Most "reg" in XML target descriptions don't have "regnum"
1667 attribute, so the register number is allocated sequentially.
1668 In case that reg has "regnum" attribute, register number
1669 should be set by that explicitly. */
1671 if (reg
->target_regnum
< m_next_regnum
)
1673 /* The integrity check, it can catch some errors on register
1674 number collision, like this,
1676 <reg name="x0" bitsize="32"/>
1677 <reg name="x1" bitsize="32"/>
1678 <reg name="x2" bitsize="32"/>
1679 <reg name="x3" bitsize="32"/>
1680 <reg name="ps" bitsize="32" regnum="3"/>
1682 but it also has false negatives. The target description
1685 <reg name="x1" bitsize="32" regnum="1"/>
1686 <reg name="x3" bitsize="32" regnum="3"/>
1687 <reg name="x2" bitsize="32" regnum="2"/>
1688 <reg name="x4" bitsize="32" regnum="4"/>
1690 but it is not a good practice, so still error on this,
1691 and also print the message so that it can be saved in the
1692 generated c file. */
1694 printf_unfiltered ("ERROR: \"regnum\" attribute %ld ",
1695 reg
->target_regnum
);
1696 printf_unfiltered ("is not the largest number (%d).\n",
1698 error (_("\"regnum\" attribute %ld is not the largest number (%d)."),
1699 reg
->target_regnum
, m_next_regnum
);
1702 if (reg
->target_regnum
> m_next_regnum
)
1704 printf_unfiltered (" regnum = %ld;\n", reg
->target_regnum
);
1705 m_next_regnum
= reg
->target_regnum
;
1708 printf_unfiltered (" tdesc_create_reg (feature, \"%s\", regnum++, %d, ",
1709 reg
->name
.c_str (), reg
->save_restore
);
1710 if (!reg
->group
.empty ())
1711 printf_unfiltered ("\"%s\", ", reg
->group
.c_str ());
1713 printf_unfiltered ("NULL, ");
1714 printf_unfiltered ("%d, \"%s\");\n", reg
->bitsize
, reg
->type
.c_str ());
1720 /* The register number to use for the next register we see. */
1721 int m_next_regnum
= 0;
1724 /* See gdbsupport/tdesc.h. */
1727 tdesc_get_features_xml (const target_desc
*tdesc
)
1729 if (tdesc
->xmltarget
== nullptr)
1731 std::string
buffer ("@");
1732 print_xml_feature
v (&buffer
);
1734 tdesc
->xmltarget
= xstrdup (buffer
.c_str ());
1736 return tdesc
->xmltarget
;
1740 maint_print_c_tdesc_cmd (const char *args
, int from_tty
)
1742 const struct target_desc
*tdesc
;
1743 const char *filename
;
1747 /* Use the global target-supplied description, not the current
1748 architecture's. This lets a GDB for one architecture generate C
1749 for another architecture's description, even though the gdbarch
1750 initialization code will reject the new description. */
1751 tdesc
= current_target_desc
;
1752 filename
= target_description_filename
;
1756 /* Use the target description from the XML file. */
1758 tdesc
= file_read_description_xml (filename
);
1762 error (_("There is no target description to print."));
1764 if (filename
== NULL
)
1765 filename
= "fetched from target";
1767 std::string
filename_after_features (filename
);
1768 auto loc
= filename_after_features
.rfind ("/features/");
1770 if (loc
!= std::string::npos
)
1771 filename_after_features
= filename_after_features
.substr (loc
+ 10);
1773 /* Print c files for target features instead of target descriptions,
1774 because c files got from target features are more flexible than the
1776 if (startswith (filename_after_features
.c_str (), "i386/32bit-")
1777 || startswith (filename_after_features
.c_str (), "i386/64bit-")
1778 || startswith (filename_after_features
.c_str (), "i386/x32-core.xml")
1779 || startswith (filename_after_features
.c_str (), "riscv/")
1780 || startswith (filename_after_features
.c_str (), "tic6x-")
1781 || startswith (filename_after_features
.c_str (), "aarch64")
1782 || startswith (filename_after_features
.c_str (), "arm/")
1783 || startswith (filename_after_features
.c_str (), "arc/"))
1785 print_c_feature
v (filename_after_features
);
1791 print_c_tdesc
v (filename_after_features
);
1797 /* Implement the maintenance print xml-tdesc command. */
1800 maint_print_xml_tdesc_cmd (const char *args
, int from_tty
)
1802 const struct target_desc
*tdesc
;
1806 /* Use the global target-supplied description, not the current
1807 architecture's. This lets a GDB for one architecture generate XML
1808 for another architecture's description, even though the gdbarch
1809 initialization code will reject the new description. */
1810 tdesc
= current_target_desc
;
1814 /* Use the target description from the XML file. */
1815 tdesc
= file_read_description_xml (args
);
1819 error (_("There is no target description to print."));
1822 print_xml_feature
v (&buf
);
1824 puts_unfiltered (buf
.c_str ());
1827 namespace selftests
{
1829 /* A reference target description, used for testing (see record_xml_tdesc). */
1831 struct xml_test_tdesc
1833 xml_test_tdesc (const char *name
, std::unique_ptr
<const target_desc
> &&tdesc
)
1834 : name (name
), tdesc (std::move (tdesc
))
1838 std::unique_ptr
<const target_desc
> tdesc
;
1841 static std::vector
<xml_test_tdesc
> xml_tdesc
;
1845 /* See target-descriptions.h. */
1848 record_xml_tdesc (const char *xml_file
, const struct target_desc
*tdesc
)
1850 xml_tdesc
.emplace_back (xml_file
, std::unique_ptr
<const target_desc
> (tdesc
));
1856 /* Test the conversion process of a target description to/from xml: Take a target
1857 description TDESC, convert to xml, back to a description, and confirm the new
1858 tdesc is identical to the original. */
1860 maintenance_check_tdesc_xml_convert (const target_desc
*tdesc
, const char *name
)
1862 const char *xml
= tdesc_get_features_xml (tdesc
);
1864 if (xml
== nullptr || *xml
!= '@')
1866 printf_filtered (_("Could not convert description for %s to xml.\n"),
1871 const target_desc
*tdesc_trans
= string_read_description_xml (xml
+ 1);
1873 if (tdesc_trans
== nullptr)
1875 printf_filtered (_("Could not convert description for %s from xml.\n"),
1879 else if (*tdesc
!= *tdesc_trans
)
1881 printf_filtered (_("Converted description for %s does not match.\n"),
1889 /* Check that the target descriptions created dynamically by
1890 architecture-specific code equal the descriptions created from XML files
1891 found in the specified directory DIR. */
1894 maintenance_check_xml_descriptions (const char *dir
, int from_tty
)
1897 error (_("Missing dir name"));
1899 gdb::unique_xmalloc_ptr
<char> dir1 (tilde_expand (dir
));
1900 std::string
feature_dir (dir1
.get ());
1901 unsigned int failed
= 0;
1903 for (auto const &e
: selftests::xml_tdesc
)
1905 std::string tdesc_xml
= (feature_dir
+ SLASH_STRING
+ e
.name
);
1906 const target_desc
*tdesc
1907 = file_read_description_xml (tdesc_xml
.data ());
1909 if (tdesc
== NULL
|| *tdesc
!= *e
.tdesc
)
1911 printf_filtered ( _("Descriptions for %s do not match.\n"), e
.name
);
1914 else if (!maintenance_check_tdesc_xml_convert (tdesc
, e
.name
)
1915 || !maintenance_check_tdesc_xml_convert (e
.tdesc
.get (), e
.name
))
1918 printf_filtered (_("Tested %lu XML files, %d failed\n"),
1919 (long) selftests::xml_tdesc
.size (), failed
);
1922 void _initialize_target_descriptions ();
1924 _initialize_target_descriptions ()
1926 cmd_list_element
*cmd
;
1928 tdesc_data
= gdbarch_data_register_pre_init (tdesc_data_init
);
1930 add_basic_prefix_cmd ("tdesc", class_maintenance
, _("\
1931 Set target description specific variables."),
1932 &tdesc_set_cmdlist
, "set tdesc ",
1933 0 /* allow-unknown */, &setlist
);
1934 add_show_prefix_cmd ("tdesc", class_maintenance
, _("\
1935 Show target description specific variables."),
1936 &tdesc_show_cmdlist
, "show tdesc ",
1937 0 /* allow-unknown */, &showlist
);
1938 add_basic_prefix_cmd ("tdesc", class_maintenance
, _("\
1939 Unset target description specific variables."),
1940 &tdesc_unset_cmdlist
, "unset tdesc ",
1941 0 /* allow-unknown */, &unsetlist
);
1943 add_setshow_filename_cmd ("filename", class_obscure
,
1944 &tdesc_filename_cmd_string
,
1946 Set the file to read for an XML target description."), _("\
1947 Show the file to read for an XML target description."), _("\
1948 When set, GDB will read the target description from a local\n\
1949 file instead of querying the remote target."),
1950 set_tdesc_filename_cmd
,
1951 show_tdesc_filename_cmd
,
1952 &tdesc_set_cmdlist
, &tdesc_show_cmdlist
);
1954 add_cmd ("filename", class_obscure
, unset_tdesc_filename_cmd
, _("\
1955 Unset the file to read for an XML target description.\n\
1956 When unset, GDB will read the description from the target."),
1957 &tdesc_unset_cmdlist
);
1959 cmd
= add_cmd ("c-tdesc", class_maintenance
, maint_print_c_tdesc_cmd
, _("\
1960 Print the current target description as a C source file."),
1961 &maintenanceprintlist
);
1962 set_cmd_completer (cmd
, filename_completer
);
1964 cmd
= add_cmd ("xml-tdesc", class_maintenance
, maint_print_xml_tdesc_cmd
, _("\
1965 Print the current target description as an XML file."),
1966 &maintenanceprintlist
);
1967 set_cmd_completer (cmd
, filename_completer
);
1969 cmd
= add_cmd ("xml-descriptions", class_maintenance
,
1970 maintenance_check_xml_descriptions
, _("\
1971 Check equality of GDB target descriptions and XML created descriptions.\n\
1972 Check the target descriptions created in GDB equal the descriptions\n\
1973 created from XML files in the directory.\n\
1974 The parameter is the directory name."),
1975 &maintenancechecklist
);
1976 set_cmd_completer (cmd
, filename_completer
);