1 /* Target description support for GDB.
3 Copyright (C) 2006-2024 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 "gdbsupport/gdb_obstack.h"
37 #include "completer.h"
38 #include "readline/tilde.h"
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 ());
119 type_allocator
alloc (m_gdbarch
);
122 case TDESC_TYPE_IEEE_HALF
:
123 m_type
= init_float_type (alloc
, -1, "builtin_type_ieee_half",
124 floatformats_ieee_half
);
127 case TDESC_TYPE_IEEE_SINGLE
:
128 m_type
= init_float_type (alloc
, -1, "builtin_type_ieee_single",
129 floatformats_ieee_single
);
132 case TDESC_TYPE_IEEE_DOUBLE
:
133 m_type
= init_float_type (alloc
, -1, "builtin_type_ieee_double",
134 floatformats_ieee_double
);
136 case TDESC_TYPE_ARM_FPA_EXT
:
137 m_type
= init_float_type (alloc
, -1, "builtin_type_arm_ext",
138 floatformats_arm_ext
);
141 case TDESC_TYPE_I387_EXT
:
142 m_type
= init_float_type (alloc
, -1, "builtin_type_i387_ext",
143 floatformats_i387_ext
);
146 case TDESC_TYPE_BFLOAT16
:
147 m_type
= init_float_type (alloc
, -1, "builtin_type_bfloat16",
148 floatformats_bfloat16
);
152 internal_error ("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 ("Type \"%s\" has an unknown kind %d",
191 e
->name
.c_str (), e
->kind
);
196 void make_gdb_type_struct (const tdesc_type_with_fields
*e
)
198 m_type
= arch_composite_type (m_gdbarch
, NULL
, TYPE_CODE_STRUCT
);
199 m_type
->set_name (xstrdup (e
->name
.c_str ()));
201 for (const tdesc_type_field
&f
: e
->fields
)
203 if (f
.start
!= -1 && f
.end
!= -1)
207 struct type
*field_gdb_type
;
208 int bitsize
, total_size
;
210 /* This invariant should be preserved while creating types. */
211 gdb_assert (e
->size
!= 0);
213 field_gdb_type
= make_gdb_type (m_gdbarch
, f
.type
);
214 else if (e
->size
> 4)
215 field_gdb_type
= builtin_type (m_gdbarch
)->builtin_uint64
;
217 field_gdb_type
= builtin_type (m_gdbarch
)->builtin_uint32
;
219 fld
= append_composite_type_field_raw
220 (m_type
, xstrdup (f
.name
.c_str ()), field_gdb_type
);
222 /* For little-endian, BITPOS counts from the LSB of
223 the structure and marks the LSB of the field. For
224 big-endian, BITPOS counts from the MSB of the
225 structure and marks the MSB of the field. Either
226 way, it is the number of bits to the "left" of the
227 field. To calculate this in big-endian, we need
228 the total size of the structure. */
229 bitsize
= f
.end
- f
.start
+ 1;
230 total_size
= e
->size
* TARGET_CHAR_BIT
;
231 if (gdbarch_byte_order (m_gdbarch
) == BFD_ENDIAN_BIG
)
232 fld
->set_loc_bitpos (total_size
- f
.start
- bitsize
);
234 fld
->set_loc_bitpos (f
.start
);
235 fld
->set_bitsize (bitsize
);
239 gdb_assert (f
.start
== -1 && f
.end
== -1);
240 type
*field_gdb_type
= make_gdb_type (m_gdbarch
, f
.type
);
241 append_composite_type_field (m_type
,
242 xstrdup (f
.name
.c_str ()),
248 m_type
->set_length (e
->size
);
251 void make_gdb_type_union (const tdesc_type_with_fields
*e
)
253 m_type
= arch_composite_type (m_gdbarch
, NULL
, TYPE_CODE_UNION
);
254 m_type
->set_name (xstrdup (e
->name
.c_str ()));
256 for (const tdesc_type_field
&f
: e
->fields
)
258 type
* field_gdb_type
= make_gdb_type (m_gdbarch
, f
.type
);
259 append_composite_type_field (m_type
, xstrdup (f
.name
.c_str ()),
262 /* If any of the children of a union are vectors, flag the
263 union as a vector also. This allows e.g. a union of two
264 vector types to show up automatically in "info vector". */
265 if (field_gdb_type
->is_vector ())
266 m_type
->set_is_vector (true);
270 void make_gdb_type_flags (const tdesc_type_with_fields
*e
)
272 m_type
= arch_flags_type (m_gdbarch
, e
->name
.c_str (),
273 e
->size
* TARGET_CHAR_BIT
);
275 for (const tdesc_type_field
&f
: e
->fields
)
277 int bitsize
= f
.end
- f
.start
+ 1;
279 gdb_assert (f
.type
!= NULL
);
280 type
*field_gdb_type
= make_gdb_type (m_gdbarch
, f
.type
);
281 append_flags_type_field (m_type
, f
.start
, bitsize
,
282 field_gdb_type
, f
.name
.c_str ());
286 void make_gdb_type_enum (const tdesc_type_with_fields
*e
)
288 m_type
= (type_allocator (m_gdbarch
)
289 .new_type (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 fld
->set_loc_enumval (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 /* A handle for architecture-specific data associated with the
442 target description (see struct tdesc_arch_data). */
444 static const registry
<gdbarch
>::key
<tdesc_arch_data
> tdesc_data
;
446 /* Get or create the tdesc_data. */
447 static tdesc_arch_data
*
448 get_arch_data (struct gdbarch
*gdbarch
)
450 tdesc_arch_data
*result
= tdesc_data
.get (gdbarch
);
451 if (result
== nullptr)
452 result
= tdesc_data
.emplace (gdbarch
);
456 /* The string manipulated by the "set tdesc filename ..." command. */
458 static std::string tdesc_filename_cmd_string
;
460 /* Fetch the current target's description, and switch the current
461 architecture to one which incorporates that description. */
464 target_find_description (void)
466 target_desc_info
*tdesc_info
= ¤t_inferior ()->tdesc_info
;
468 /* If we've already fetched a description from the target, don't do
469 it again. This allows a target to fetch the description early,
470 during its to_open or to_create_inferior, if it needs extra
471 information about the target to initialize. */
472 if (tdesc_info
->fetched
)
475 /* The current architecture should not have any target description
476 specified. It should have been cleared, e.g. when we
477 disconnected from the previous target. */
478 gdb_assert (gdbarch_target_desc (current_inferior ()->arch ()) == NULL
);
480 /* First try to fetch an XML description from the user-specified
482 tdesc_info
->tdesc
= nullptr;
483 if (!tdesc_info
->filename
.empty ())
484 tdesc_info
->tdesc
= file_read_description_xml (tdesc_info
->filename
.data ());
486 /* Next try to read the description from the current target using
488 if (tdesc_info
->tdesc
== nullptr)
489 tdesc_info
->tdesc
= target_read_description_xml
490 (current_inferior ()->top_target ());
492 /* If that failed try a target-specific hook. */
493 if (tdesc_info
->tdesc
== nullptr)
494 tdesc_info
->tdesc
= target_read_description
495 (current_inferior ()->top_target ());
497 /* If a non-NULL description was returned, then update the current
499 if (tdesc_info
->tdesc
!= nullptr)
501 struct gdbarch_info info
;
503 info
.target_desc
= tdesc_info
->tdesc
;
504 if (!gdbarch_update_p (info
))
506 warning (_("Architecture rejected target-supplied description"));
507 tdesc_info
->tdesc
= nullptr;
511 struct tdesc_arch_data
*data
;
513 data
= get_arch_data (current_inferior ()->arch ());
514 if (tdesc_has_registers (tdesc_info
->tdesc
)
515 && data
->arch_regs
.empty ())
516 warning (_("Target-supplied registers are not supported "
517 "by the current architecture"));
521 /* Now that we know this description is usable, record that we
523 tdesc_info
->fetched
= true;
526 /* Discard any description fetched from the current target, and switch
527 the current architecture to one with no target description. */
530 target_clear_description (void)
532 target_desc_info
*tdesc_info
= ¤t_inferior ()->tdesc_info
;
534 if (!tdesc_info
->fetched
)
537 tdesc_info
->fetched
= false;
538 tdesc_info
->tdesc
= nullptr;
541 if (!gdbarch_update_p (info
))
542 internal_error (_("Could not remove target-supplied description"));
545 /* Return the global current target description. This should only be
546 used by gdbarch initialization code; most access should be through
547 an existing gdbarch. */
549 const struct target_desc
*
550 target_current_description (void)
552 target_desc_info
*tdesc_info
= ¤t_inferior ()->tdesc_info
;
554 if (tdesc_info
->fetched
)
555 return tdesc_info
->tdesc
;
560 /* Return non-zero if this target description is compatible
561 with the given BFD architecture. */
564 tdesc_compatible_p (const struct target_desc
*target_desc
,
565 const struct bfd_arch_info
*arch
)
567 for (const tdesc_compatible_info_up
&compat
: target_desc
->compatible
)
569 if (compat
->arch () == arch
570 || arch
->compatible (arch
, compat
->arch ())
571 || compat
->arch ()->compatible (compat
->arch (), arch
))
579 /* Direct accessors for target descriptions. */
581 /* Return the string value of a property named KEY, or NULL if the
582 property was not specified. */
585 tdesc_property (const struct target_desc
*target_desc
, const char *key
)
587 for (const property
&prop
: target_desc
->properties
)
589 return prop
.value
.c_str ();
594 /* Return the BFD architecture associated with this target
595 description, or NULL if no architecture was specified. */
597 const struct bfd_arch_info
*
598 tdesc_architecture (const struct target_desc
*target_desc
)
600 return target_desc
->arch
;
603 /* See gdbsupport/tdesc.h. */
606 tdesc_architecture_name (const struct target_desc
*target_desc
)
608 if (target_desc
->arch
!= NULL
)
609 return target_desc
->arch
->printable_name
;
613 /* See gdbsupport/tdesc.h. */
615 const std::vector
<tdesc_compatible_info_up
> &
616 tdesc_compatible_info_list (const target_desc
*target_desc
)
618 return target_desc
->compatible
;
621 /* See gdbsupport/tdesc.h. */
624 tdesc_compatible_info_arch_name (const tdesc_compatible_info_up
&compatible
)
626 return compatible
->arch ()->printable_name
;
629 /* Return the OSABI associated with this target description, or
630 GDB_OSABI_UNKNOWN if no osabi was specified. */
633 tdesc_osabi (const struct target_desc
*target_desc
)
635 return target_desc
->osabi
;
638 /* See gdbsupport/tdesc.h. */
641 tdesc_osabi_name (const struct target_desc
*target_desc
)
643 enum gdb_osabi osabi
= tdesc_osabi (target_desc
);
644 if (osabi
> GDB_OSABI_UNKNOWN
&& osabi
< GDB_OSABI_INVALID
)
645 return gdbarch_osabi_name (osabi
);
649 /* Return 1 if this target description includes any registers. */
652 tdesc_has_registers (const struct target_desc
*target_desc
)
654 if (target_desc
== NULL
)
657 for (const tdesc_feature_up
&feature
: target_desc
->features
)
658 if (!feature
->registers
.empty ())
664 /* Return the feature with the given name, if present, or NULL if
665 the named feature is not found. */
667 const struct tdesc_feature
*
668 tdesc_find_feature (const struct target_desc
*target_desc
,
671 for (const tdesc_feature_up
&feature
: target_desc
->features
)
672 if (feature
->name
== name
)
673 return feature
.get ();
678 /* Return the name of FEATURE. */
681 tdesc_feature_name (const struct tdesc_feature
*feature
)
683 return feature
->name
.c_str ();
686 /* Lookup type associated with ID. */
689 tdesc_find_type (struct gdbarch
*gdbarch
, const char *id
)
691 tdesc_arch_data
*data
= get_arch_data (gdbarch
);
693 for (const tdesc_arch_reg
®
: data
->arch_regs
)
696 && reg
.reg
->tdesc_type
698 && reg
.reg
->tdesc_type
->name
== id
)
705 /* Support for registers from target descriptions. */
707 /* Construct the per-gdbarch data. */
710 tdesc_data_alloc (void)
712 return tdesc_arch_data_up (new tdesc_arch_data ());
715 /* See target-descriptions.h. */
718 tdesc_arch_data_deleter::operator() (struct tdesc_arch_data
*data
) const
723 /* Search FEATURE for a register named NAME. */
725 static struct tdesc_reg
*
726 tdesc_find_register_early (const struct tdesc_feature
*feature
,
729 for (const tdesc_reg_up
®
: feature
->registers
)
730 if (strcasecmp (reg
->name
.c_str (), name
) == 0)
736 /* Search FEATURE for a register named NAME. Assign REGNO to it. */
739 tdesc_numbered_register (const struct tdesc_feature
*feature
,
740 struct tdesc_arch_data
*data
,
741 int regno
, const char *name
)
743 struct tdesc_reg
*reg
= tdesc_find_register_early (feature
, name
);
748 /* Make sure the vector includes a REGNO'th element. */
749 while (regno
>= data
->arch_regs
.size ())
750 data
->arch_regs
.emplace_back (nullptr, nullptr);
752 data
->arch_regs
[regno
] = tdesc_arch_reg (reg
, NULL
);
757 /* Search FEATURE for a register named NAME, but do not assign a fixed
758 register number to it. */
761 tdesc_unnumbered_register (const struct tdesc_feature
*feature
,
764 struct tdesc_reg
*reg
= tdesc_find_register_early (feature
, name
);
772 /* Search FEATURE for a register whose name is in NAMES and assign
776 tdesc_numbered_register_choices (const struct tdesc_feature
*feature
,
777 struct tdesc_arch_data
*data
,
778 int regno
, const char *const names
[])
782 for (i
= 0; names
[i
] != NULL
; i
++)
783 if (tdesc_numbered_register (feature
, data
, regno
, names
[i
]))
789 /* See target-descriptions.h. */
792 tdesc_found_register (struct tdesc_arch_data
*data
, int regno
)
794 gdb_assert (regno
>= 0);
796 return (regno
< data
->arch_regs
.size ()
797 && data
->arch_regs
[regno
].reg
!= nullptr);
800 /* Search FEATURE for a register named NAME, and return its size in
801 bits. The register must exist. */
804 tdesc_register_bitsize (const struct tdesc_feature
*feature
, const char *name
)
806 struct tdesc_reg
*reg
= tdesc_find_register_early (feature
, name
);
808 gdb_assert (reg
!= NULL
);
812 /* Look up a register by its GDB internal register number. */
814 static struct tdesc_arch_reg
*
815 tdesc_find_arch_register (struct gdbarch
*gdbarch
, int regno
)
817 struct tdesc_arch_data
*data
= get_arch_data (gdbarch
);
819 if (regno
< data
->arch_regs
.size ())
820 return &data
->arch_regs
[regno
];
825 static struct tdesc_reg
*
826 tdesc_find_register (struct gdbarch
*gdbarch
, int regno
)
828 struct tdesc_arch_reg
*reg
= tdesc_find_arch_register (gdbarch
, regno
);
830 return reg
? reg
->reg
: NULL
;
833 /* Return the name of register REGNO, from the target description or
834 from an architecture-provided pseudo_register_name method. */
837 tdesc_register_name (struct gdbarch
*gdbarch
, int regno
)
839 struct tdesc_reg
*reg
= tdesc_find_register (gdbarch
, regno
);
840 int num_regs
= gdbarch_num_regs (gdbarch
);
843 return reg
->name
.c_str ();
845 if (regno
>= num_regs
&& regno
< gdbarch_num_cooked_regs (gdbarch
))
847 struct tdesc_arch_data
*data
= get_arch_data (gdbarch
);
849 gdb_assert (data
->pseudo_register_name
!= NULL
);
850 return data
->pseudo_register_name (gdbarch
, regno
);
857 tdesc_register_type (struct gdbarch
*gdbarch
, int regno
)
859 struct tdesc_arch_reg
*arch_reg
= tdesc_find_arch_register (gdbarch
, regno
);
860 struct tdesc_reg
*reg
= arch_reg
? arch_reg
->reg
: NULL
;
861 int num_regs
= gdbarch_num_regs (gdbarch
);
862 int num_pseudo_regs
= gdbarch_num_pseudo_regs (gdbarch
);
864 if (reg
== NULL
&& regno
>= num_regs
&& regno
< num_regs
+ num_pseudo_regs
)
866 struct tdesc_arch_data
*data
= get_arch_data (gdbarch
);
868 gdb_assert (data
->pseudo_register_type
!= NULL
);
869 return data
->pseudo_register_type (gdbarch
, regno
);
873 /* Return "int0_t", since "void" has a misleading size of one. */
874 return builtin_type (gdbarch
)->builtin_int0
;
876 if (arch_reg
->type
== NULL
)
878 /* First check for a predefined or target defined type. */
880 arch_reg
->type
= make_gdb_type (gdbarch
, reg
->tdesc_type
);
882 /* Next try size-sensitive type shortcuts. */
883 else if (reg
->type
== "float")
885 if (reg
->bitsize
== gdbarch_float_bit (gdbarch
))
886 arch_reg
->type
= builtin_type (gdbarch
)->builtin_float
;
887 else if (reg
->bitsize
== gdbarch_double_bit (gdbarch
))
888 arch_reg
->type
= builtin_type (gdbarch
)->builtin_double
;
889 else if (reg
->bitsize
== gdbarch_long_double_bit (gdbarch
))
890 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long_double
;
893 warning (_("Register \"%s\" has an unsupported size (%d bits)"),
894 reg
->name
.c_str (), reg
->bitsize
);
895 arch_reg
->type
= builtin_type (gdbarch
)->builtin_double
;
898 else if (reg
->type
== "int")
900 if (reg
->bitsize
== gdbarch_long_bit (gdbarch
))
901 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long
;
902 else if (reg
->bitsize
== TARGET_CHAR_BIT
)
903 arch_reg
->type
= builtin_type (gdbarch
)->builtin_char
;
904 else if (reg
->bitsize
== gdbarch_short_bit (gdbarch
))
905 arch_reg
->type
= builtin_type (gdbarch
)->builtin_short
;
906 else if (reg
->bitsize
== gdbarch_int_bit (gdbarch
))
907 arch_reg
->type
= builtin_type (gdbarch
)->builtin_int
;
908 else if (reg
->bitsize
== gdbarch_long_long_bit (gdbarch
))
909 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long_long
;
910 else if (reg
->bitsize
== gdbarch_ptr_bit (gdbarch
))
911 /* A bit desperate by this point... */
912 arch_reg
->type
= builtin_type (gdbarch
)->builtin_data_ptr
;
915 warning (_("Register \"%s\" has an unsupported size (%d bits)"),
916 reg
->name
.c_str (), reg
->bitsize
);
917 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long
;
921 if (arch_reg
->type
== NULL
)
922 internal_error ("Register \"%s\" has an unknown type \"%s\"",
923 reg
->name
.c_str (), reg
->type
.c_str ());
926 return arch_reg
->type
;
930 tdesc_remote_register_number (struct gdbarch
*gdbarch
, int regno
)
932 struct tdesc_reg
*reg
= tdesc_find_register (gdbarch
, regno
);
935 return reg
->target_regnum
;
940 /* Check whether REGNUM is a member of REGGROUP. Registers from the
941 target description may be classified as general, float, vector or other
942 register groups registered with reggroup_add(). Unlike a gdbarch
943 register_reggroup_p method, this function will return -1 if it does not
944 know; the caller should handle registers with no specified group.
946 The names of containing features are not used. This might be extended
947 to display registers in some more useful groupings.
949 The save-restore flag is also implemented here. */
952 tdesc_register_in_reggroup_p (struct gdbarch
*gdbarch
, int regno
,
953 const struct reggroup
*reggroup
)
955 struct tdesc_reg
*reg
= tdesc_find_register (gdbarch
, regno
);
957 if (reg
!= NULL
&& !reg
->group
.empty ()
958 && (reg
->group
== reggroup
->name ()))
962 && (reggroup
== save_reggroup
|| reggroup
== restore_reggroup
))
963 return reg
->save_restore
;
968 /* Check whether REGNUM is a member of REGGROUP. Registers with no
969 group specified go to the default reggroup function and are handled
973 tdesc_register_reggroup_p (struct gdbarch
*gdbarch
, int regno
,
974 const struct reggroup
*reggroup
)
976 int num_regs
= gdbarch_num_regs (gdbarch
);
977 int num_pseudo_regs
= gdbarch_num_pseudo_regs (gdbarch
);
980 if (regno
>= num_regs
&& regno
< num_regs
+ num_pseudo_regs
)
982 struct tdesc_arch_data
*data
= get_arch_data (gdbarch
);
984 if (data
->pseudo_register_reggroup_p
!= NULL
)
985 return data
->pseudo_register_reggroup_p (gdbarch
, regno
, reggroup
);
986 /* Otherwise fall through to the default reggroup_p. */
989 ret
= tdesc_register_in_reggroup_p (gdbarch
, regno
, reggroup
);
993 return default_register_reggroup_p (gdbarch
, regno
, reggroup
);
996 /* Record architecture-specific functions to call for pseudo-register
1000 set_tdesc_pseudo_register_name (struct gdbarch
*gdbarch
,
1001 gdbarch_register_name_ftype
*pseudo_name
)
1003 struct tdesc_arch_data
*data
= get_arch_data (gdbarch
);
1005 data
->pseudo_register_name
= pseudo_name
;
1009 set_tdesc_pseudo_register_type (struct gdbarch
*gdbarch
,
1010 gdbarch_register_type_ftype
*pseudo_type
)
1012 struct tdesc_arch_data
*data
= get_arch_data (gdbarch
);
1014 data
->pseudo_register_type
= pseudo_type
;
1018 set_tdesc_pseudo_register_reggroup_p
1019 (struct gdbarch
*gdbarch
,
1020 gdbarch_register_reggroup_p_ftype
*pseudo_reggroup_p
)
1022 struct tdesc_arch_data
*data
= get_arch_data (gdbarch
);
1024 data
->pseudo_register_reggroup_p
= pseudo_reggroup_p
;
1027 /* Update GDBARCH to use the target description for registers. */
1030 tdesc_use_registers (struct gdbarch
*gdbarch
,
1031 const struct target_desc
*target_desc
,
1032 tdesc_arch_data_up
&&early_data
,
1033 tdesc_unknown_register_ftype unk_reg_cb
)
1035 int num_regs
= gdbarch_num_regs (gdbarch
);
1036 struct tdesc_arch_data
*data
;
1038 /* We can't use the description for registers if it doesn't describe
1039 any. This function should only be called after validating
1040 registers, so the caller should know that registers are
1042 gdb_assert (tdesc_has_registers (target_desc
));
1044 data
= get_arch_data (gdbarch
);
1045 data
->arch_regs
= std::move (early_data
->arch_regs
);
1047 /* Build up a set of all registers, so that we can assign register
1048 numbers where needed. The hash table expands as necessary, so
1049 the initial size is arbitrary. */
1050 htab_up
reg_hash (htab_create (37, htab_hash_pointer
, htab_eq_pointer
,
1052 for (const tdesc_feature_up
&feature
: target_desc
->features
)
1053 for (const tdesc_reg_up
®
: feature
->registers
)
1055 void **slot
= htab_find_slot (reg_hash
.get (), reg
.get (), INSERT
);
1058 /* Add reggroup if its new. */
1059 if (!reg
->group
.empty ())
1060 if (reggroup_find (gdbarch
, reg
->group
.c_str ()) == NULL
)
1061 reggroup_add (gdbarch
, reggroup_gdbarch_new (gdbarch
,
1062 reg
->group
.c_str (),
1066 /* Remove any registers which were assigned numbers by the
1068 for (const tdesc_arch_reg
&arch_reg
: data
->arch_regs
)
1069 if (arch_reg
.reg
!= NULL
)
1070 htab_remove_elt (reg_hash
.get (), arch_reg
.reg
);
1072 /* Assign numbers to the remaining registers and add them to the
1073 list of registers. The new numbers are always above gdbarch_num_regs.
1074 Iterate over the features, not the hash table, so that the order
1075 matches that in the target description. */
1077 gdb_assert (data
->arch_regs
.size () <= num_regs
);
1078 while (data
->arch_regs
.size () < num_regs
)
1079 data
->arch_regs
.emplace_back (nullptr, nullptr);
1081 /* First we give the target a chance to number previously unknown
1082 registers. This allows targets to record the numbers assigned based
1083 on which feature the register was from. */
1084 if (unk_reg_cb
!= NULL
)
1086 for (const tdesc_feature_up
&feature
: target_desc
->features
)
1087 for (const tdesc_reg_up
®
: feature
->registers
)
1088 if (htab_find (reg_hash
.get (), reg
.get ()) != NULL
)
1090 int regno
= unk_reg_cb (gdbarch
, feature
.get (),
1091 reg
->name
.c_str (), num_regs
);
1092 gdb_assert (regno
== -1 || regno
>= num_regs
);
1095 while (regno
>= data
->arch_regs
.size ())
1096 data
->arch_regs
.emplace_back (nullptr, nullptr);
1097 data
->arch_regs
[regno
] = tdesc_arch_reg (reg
.get (), NULL
);
1098 num_regs
= regno
+ 1;
1099 htab_remove_elt (reg_hash
.get (), reg
.get ());
1104 /* Ensure the array was sized correctly above. */
1105 gdb_assert (data
->arch_regs
.size () == num_regs
);
1107 /* Now in a final pass we assign register numbers to any remaining
1108 unnumbered registers. */
1109 for (const tdesc_feature_up
&feature
: target_desc
->features
)
1110 for (const tdesc_reg_up
®
: feature
->registers
)
1111 if (htab_find (reg_hash
.get (), reg
.get ()) != NULL
)
1113 data
->arch_regs
.emplace_back (reg
.get (), nullptr);
1117 /* Update the architecture. */
1118 set_gdbarch_num_regs (gdbarch
, num_regs
);
1119 set_gdbarch_register_name (gdbarch
, tdesc_register_name
);
1120 set_gdbarch_register_type (gdbarch
, tdesc_register_type
);
1121 set_gdbarch_remote_register_number (gdbarch
,
1122 tdesc_remote_register_number
);
1123 set_gdbarch_register_reggroup_p (gdbarch
, tdesc_register_reggroup_p
);
1126 /* See gdbsupport/tdesc.h. */
1128 struct tdesc_feature
*
1129 tdesc_create_feature (struct target_desc
*tdesc
, const char *name
)
1131 struct tdesc_feature
*new_feature
= new tdesc_feature (name
);
1133 tdesc
->features
.emplace_back (new_feature
);
1138 /* See gdbsupport/tdesc.h. */
1141 allocate_target_description (void)
1143 return target_desc_up (new target_desc ());
1146 /* See gdbsupport/tdesc.h. */
1149 target_desc_deleter::operator() (struct target_desc
*target_desc
) const
1155 tdesc_add_compatible (struct target_desc
*target_desc
,
1156 const struct bfd_arch_info
*compatible
)
1158 /* If this instance of GDB is compiled without BFD support for the
1159 compatible architecture, simply ignore it -- we would not be able
1160 to handle it anyway. */
1161 if (compatible
== NULL
)
1164 for (const tdesc_compatible_info_up
&compat
: target_desc
->compatible
)
1165 if (compat
->arch () == compatible
)
1166 internal_error (_("Attempted to add duplicate "
1167 "compatible architecture \"%s\""),
1168 compatible
->printable_name
);
1170 target_desc
->compatible
.push_back
1171 (std::unique_ptr
<tdesc_compatible_info
>
1172 (new tdesc_compatible_info (compatible
)));
1176 set_tdesc_property (struct target_desc
*target_desc
,
1177 const char *key
, const char *value
)
1179 gdb_assert (key
!= NULL
&& value
!= NULL
);
1181 if (tdesc_property (target_desc
, key
) != NULL
)
1182 internal_error (_("Attempted to add duplicate property \"%s\""), key
);
1184 target_desc
->properties
.emplace_back (key
, value
);
1187 /* See gdbsupport/tdesc.h. */
1190 set_tdesc_architecture (struct target_desc
*target_desc
,
1193 set_tdesc_architecture (target_desc
, bfd_scan_arch (name
));
1197 set_tdesc_architecture (struct target_desc
*target_desc
,
1198 const struct bfd_arch_info
*arch
)
1200 target_desc
->arch
= arch
;
1203 /* See gdbsupport/tdesc.h. */
1206 set_tdesc_osabi (struct target_desc
*target_desc
, const char *name
)
1208 set_tdesc_osabi (target_desc
, osabi_from_tdesc_string (name
));
1212 set_tdesc_osabi (struct target_desc
*target_desc
, enum gdb_osabi osabi
)
1214 target_desc
->osabi
= osabi
;
1218 static struct cmd_list_element
*tdesc_set_cmdlist
, *tdesc_show_cmdlist
;
1219 static struct cmd_list_element
*tdesc_unset_cmdlist
;
1221 /* Helper functions for the CLI commands. */
1224 set_tdesc_filename_cmd (const char *args
, int from_tty
,
1225 struct cmd_list_element
*c
)
1227 target_desc_info
*tdesc_info
= ¤t_inferior ()->tdesc_info
;
1229 tdesc_info
->filename
= tdesc_filename_cmd_string
;
1231 target_clear_description ();
1232 target_find_description ();
1236 show_tdesc_filename_cmd (struct ui_file
*file
, int from_tty
,
1237 struct cmd_list_element
*c
,
1240 value
= current_inferior ()->tdesc_info
.filename
.data ();
1242 if (value
!= NULL
&& *value
!= '\0')
1244 _("The target description will be read from \"%s\".\n"),
1248 _("The target description will be "
1249 "read from the target.\n"));
1253 unset_tdesc_filename_cmd (const char *args
, int from_tty
)
1255 target_desc_info
*tdesc_info
= ¤t_inferior ()->tdesc_info
;
1257 tdesc_info
->filename
.clear ();
1258 target_clear_description ();
1259 target_find_description ();
1262 /* Print target description in C. */
1264 class print_c_tdesc
: public tdesc_element_visitor
1267 print_c_tdesc (std::string
&filename_after_features
)
1268 : m_filename_after_features (filename_after_features
)
1272 const char *filename
= lbasename (m_filename_after_features
.c_str ());
1274 m_function
= (char *) xmalloc (strlen (filename
) + 1);
1275 for (inp
= filename
, outp
= m_function
; *inp
!= '\0'; inp
++)
1278 else if (*inp
== '-')
1280 else if (*inp
== ' ')
1286 /* Standard boilerplate. */
1287 gdb_printf ("/* THIS FILE IS GENERATED. "
1288 "-*- buffer-read-only: t -*- vi"
1297 void visit_pre (const target_desc
*e
) override
1299 gdb_printf (" Original: %s */\n\n",
1300 lbasename (m_filename_after_features
.c_str ()));
1302 gdb_printf ("#include \"defs.h\"\n");
1303 gdb_printf ("#include \"osabi.h\"\n");
1304 gdb_printf ("#include \"target-descriptions.h\"\n");
1307 gdb_printf ("const struct target_desc *tdesc_%s;\n", m_function
);
1308 gdb_printf ("static void\n");
1309 gdb_printf ("initialize_tdesc_%s (void)\n", m_function
);
1312 (" target_desc_up result = allocate_target_description ();\n");
1314 if (tdesc_architecture (e
) != NULL
)
1317 (" set_tdesc_architecture (result.get (), bfd_scan_arch (\"%s\"));\n",
1318 tdesc_architecture (e
)->printable_name
);
1321 if (tdesc_osabi (e
) > GDB_OSABI_UNKNOWN
1322 && tdesc_osabi (e
) < GDB_OSABI_INVALID
)
1325 (" set_tdesc_osabi (result.get (), osabi_from_tdesc_string (\"%s\"));\n",
1326 gdbarch_osabi_name (tdesc_osabi (e
)));
1330 for (const tdesc_compatible_info_up
&compatible
: e
->compatible
)
1332 (" tdesc_add_compatible (result.get (), bfd_scan_arch (\"%s\"));\n",
1333 compatible
->arch ()->printable_name
);
1335 if (!e
->compatible
.empty ())
1338 for (const property
&prop
: e
->properties
)
1339 gdb_printf (" set_tdesc_property (result.get (), \"%s\", \"%s\");\n",
1340 prop
.key
.c_str (), prop
.value
.c_str ());
1342 gdb_printf (" struct tdesc_feature *feature;\n");
1345 void visit_pre (const tdesc_feature
*e
) override
1347 gdb_printf ("\n feature = tdesc_create_feature (result.get (), \"%s\");\n",
1351 void visit_post (const tdesc_feature
*e
) override
1354 void visit_post (const target_desc
*e
) override
1356 gdb_printf ("\n tdesc_%s = result.release ();\n", m_function
);
1360 void visit (const tdesc_type_builtin
*type
) override
1362 error (_("C output is not supported type \"%s\"."), type
->name
.c_str ());
1365 void visit (const tdesc_type_vector
*type
) override
1367 if (!m_printed_element_type
)
1369 gdb_printf (" tdesc_type *element_type;\n");
1370 m_printed_element_type
= true;
1374 (" element_type = tdesc_named_type (feature, \"%s\");\n",
1375 type
->element_type
->name
.c_str ());
1377 (" tdesc_create_vector (feature, \"%s\", element_type, %d);\n",
1378 type
->name
.c_str (), type
->count
);
1383 void visit (const tdesc_type_with_fields
*type
) override
1385 if (!m_printed_type_with_fields
)
1387 gdb_printf (" tdesc_type_with_fields *type_with_fields;\n");
1388 m_printed_type_with_fields
= true;
1393 case TDESC_TYPE_STRUCT
:
1394 case TDESC_TYPE_FLAGS
:
1395 if (type
->kind
== TDESC_TYPE_STRUCT
)
1398 (" type_with_fields = tdesc_create_struct (feature, \"%s\");\n",
1399 type
->name
.c_str ());
1400 if (type
->size
!= 0)
1402 (" tdesc_set_struct_size (type_with_fields, %d);\n", type
->size
);
1407 (" type_with_fields = tdesc_create_flags (feature, \"%s\", %d);\n",
1408 type
->name
.c_str (), type
->size
);
1410 for (const tdesc_type_field
&f
: type
->fields
)
1412 const char *type_name
;
1414 gdb_assert (f
.type
!= NULL
);
1415 type_name
= f
.type
->name
.c_str ();
1417 /* To minimize changes to generated files, don't emit type
1418 info for fields that have defaulted types. */
1421 gdb_assert (f
.end
!= -1);
1422 if (f
.type
->kind
== TDESC_TYPE_BOOL
)
1424 gdb_assert (f
.start
== f
.end
);
1426 (" tdesc_add_flag (type_with_fields, %d, \"%s\");\n",
1427 f
.start
, f
.name
.c_str ());
1429 else if ((type
->size
== 4 && f
.type
->kind
== TDESC_TYPE_UINT32
)
1431 && f
.type
->kind
== TDESC_TYPE_UINT64
))
1434 (" tdesc_add_bitfield (type_with_fields, \"%s\", %d, %d);\n",
1435 f
.name
.c_str (), f
.start
, f
.end
);
1439 printf_field_type_assignment
1440 ("tdesc_named_type (feature, \"%s\");\n",
1443 (" tdesc_add_typed_bitfield (type_with_fields, \"%s\","
1444 " %d, %d, field_type);\n",
1445 f
.name
.c_str (), f
.start
, f
.end
);
1448 else /* Not a bitfield. */
1450 gdb_assert (f
.end
== -1);
1451 gdb_assert (type
->kind
== TDESC_TYPE_STRUCT
);
1452 printf_field_type_assignment
1453 ("tdesc_named_type (feature, \"%s\");\n", type_name
);
1455 (" tdesc_add_field (type_with_fields, \"%s\", field_type);\n",
1460 case TDESC_TYPE_UNION
:
1462 (" type_with_fields = tdesc_create_union (feature, \"%s\");\n",
1463 type
->name
.c_str ());
1464 for (const tdesc_type_field
&f
: type
->fields
)
1466 printf_field_type_assignment
1467 ("tdesc_named_type (feature, \"%s\");\n", f
.type
->name
.c_str ());
1469 (" tdesc_add_field (type_with_fields, \"%s\", field_type);\n",
1473 case TDESC_TYPE_ENUM
:
1475 (" type_with_fields = tdesc_create_enum (feature, \"%s\", %d);\n",
1476 type
->name
.c_str (), type
->size
);
1477 for (const tdesc_type_field
&f
: type
->fields
)
1479 (" tdesc_add_enum_value (type_with_fields, %d, \"%s\");\n",
1480 f
.start
, f
.name
.c_str ());
1483 error (_("C output is not supported type \"%s\"."), type
->name
.c_str ());
1489 void visit (const tdesc_reg
*reg
) override
1491 gdb_printf (" tdesc_create_reg (feature, \"%s\", %ld, %d, ",
1492 reg
->name
.c_str (), reg
->target_regnum
,
1494 if (!reg
->group
.empty ())
1495 gdb_printf ("\"%s\", ", reg
->group
.c_str ());
1497 gdb_printf ("NULL, ");
1498 gdb_printf ("%d, \"%s\");\n", reg
->bitsize
, reg
->type
.c_str ());
1502 std::string m_filename_after_features
;
1506 /* Print an assignment to the field_type variable. Print the declaration
1507 of field_type if that has not been done yet. */
1508 ATTRIBUTE_PRINTF (2, 3)
1509 void printf_field_type_assignment (const char *fmt
, ...)
1511 if (!m_printed_field_type
)
1513 gdb_printf (" tdesc_type *field_type;\n");
1514 m_printed_field_type
= true;
1517 gdb_printf (" field_type = ");
1520 va_start (args
, fmt
);
1521 gdb_vprintf (fmt
, args
);
1527 /* Did we print "struct tdesc_type *element_type;" yet? */
1528 bool m_printed_element_type
= false;
1530 /* Did we print "struct tdesc_type_with_fields *element_type;" yet? */
1531 bool m_printed_type_with_fields
= false;
1533 /* Did we print "struct tdesc_type *field_type;" yet? */
1534 bool m_printed_field_type
= false;
1537 /* Print target description feature in C. */
1539 class print_c_feature
: public print_c_tdesc
1542 print_c_feature (std::string
&file
)
1543 : print_c_tdesc (file
)
1546 auto const pos
= m_filename_after_features
.find_last_of ('.');
1548 m_filename_after_features
= m_filename_after_features
.substr (0, pos
);
1551 void visit_pre (const target_desc
*e
) override
1553 gdb_printf (" Original: %s */\n\n",
1554 lbasename (m_filename_after_features
.c_str ()));
1556 gdb_printf ("#include \"gdbsupport/tdesc.h\"\n");
1560 void visit_post (const target_desc
*e
) override
1563 void visit_pre (const tdesc_feature
*e
) override
1565 std::string
name (m_filename_after_features
);
1567 auto pos
= name
.find_first_of ('.');
1569 name
= name
.substr (0, pos
);
1570 std::replace (name
.begin (), name
.end (), '/', '_');
1571 std::replace (name
.begin (), name
.end (), '-', '_');
1573 gdb_printf ("static int\n");
1574 gdb_printf ("create_feature_%s ", name
.c_str ());
1575 gdb_printf ("(struct target_desc *result, long regnum)\n");
1578 gdb_printf (" struct tdesc_feature *feature;\n");
1581 ("\n feature = tdesc_create_feature (result, \"%s\");\n",
1585 void visit_post (const tdesc_feature
*e
) override
1587 gdb_printf (" return regnum;\n");
1591 void visit (const tdesc_reg
*reg
) override
1593 /* Most "reg" in XML target descriptions don't have "regnum"
1594 attribute, so the register number is allocated sequentially.
1595 In case that reg has "regnum" attribute, register number
1596 should be set by that explicitly. */
1598 if (reg
->target_regnum
< m_next_regnum
)
1600 /* The integrity check, it can catch some errors on register
1601 number collision, like this,
1603 <reg name="x0" bitsize="32"/>
1604 <reg name="x1" bitsize="32"/>
1605 <reg name="x2" bitsize="32"/>
1606 <reg name="x3" bitsize="32"/>
1607 <reg name="ps" bitsize="32" regnum="3"/>
1609 but it also has false negatives. The target description
1612 <reg name="x1" bitsize="32" regnum="1"/>
1613 <reg name="x3" bitsize="32" regnum="3"/>
1614 <reg name="x2" bitsize="32" regnum="2"/>
1615 <reg name="x4" bitsize="32" regnum="4"/>
1617 but it is not a good practice, so still error on this,
1618 and also print the message so that it can be saved in the
1619 generated c file. */
1621 gdb_printf ("ERROR: \"regnum\" attribute %ld ",
1622 reg
->target_regnum
);
1623 gdb_printf ("is not the largest number (%d).\n",
1625 error (_("\"regnum\" attribute %ld is not the largest number (%d)."),
1626 reg
->target_regnum
, m_next_regnum
);
1629 if (reg
->target_regnum
> m_next_regnum
)
1631 gdb_printf (" regnum = %ld;\n", reg
->target_regnum
);
1632 m_next_regnum
= reg
->target_regnum
;
1635 gdb_printf (" tdesc_create_reg (feature, \"%s\", regnum++, %d, ",
1636 reg
->name
.c_str (), reg
->save_restore
);
1637 if (!reg
->group
.empty ())
1638 gdb_printf ("\"%s\", ", reg
->group
.c_str ());
1640 gdb_printf ("NULL, ");
1641 gdb_printf ("%d, \"%s\");\n", reg
->bitsize
, reg
->type
.c_str ());
1647 /* The register number to use for the next register we see. */
1648 int m_next_regnum
= 0;
1651 /* See gdbsupport/tdesc.h. */
1654 tdesc_get_features_xml (const target_desc
*tdesc
)
1656 if (tdesc
->xmltarget
== nullptr)
1658 std::string
buffer ("@");
1659 print_xml_feature
v (&buffer
);
1661 tdesc
->xmltarget
= xstrdup (buffer
.c_str ());
1663 return tdesc
->xmltarget
;
1666 /* Data structures and functions to setup the option flags for 'maintenance
1667 print c-tdesc command. */
1669 struct maint_print_c_tdesc_options
1671 /* True when the '-single-feature' flag was passed. */
1672 bool single_feature
= false;
1675 using maint_print_c_tdesc_opt_def
1676 = gdb::option::flag_option_def
<maint_print_c_tdesc_options
>;
1678 static const gdb::option::option_def maint_print_c_tdesc_opt_defs
[] = {
1679 maint_print_c_tdesc_opt_def
{
1681 [] (maint_print_c_tdesc_options
*opt
) { return &opt
->single_feature
; },
1682 N_("Print C description of just a single feature.")
1686 static inline gdb::option::option_def_group
1687 make_maint_print_c_tdesc_options_def_group (maint_print_c_tdesc_options
*opts
)
1689 return {{maint_print_c_tdesc_opt_defs
}, opts
};
1692 /* Implement 'maintenance print c-tdesc' command. */
1695 maint_print_c_tdesc_cmd (const char *args
, int from_tty
)
1697 const struct target_desc
*tdesc
;
1698 const char *filename
;
1700 maint_print_c_tdesc_options opts
;
1701 auto grp
= make_maint_print_c_tdesc_options_def_group (&opts
);
1702 gdb::option::process_options
1703 (&args
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR
, grp
);
1707 /* Use the global target-supplied description, not the current
1708 architecture's. This lets a GDB for one architecture generate C
1709 for another architecture's description, even though the gdbarch
1710 initialization code will reject the new description. */
1711 target_desc_info
*tdesc_info
= ¤t_inferior ()->tdesc_info
;
1712 tdesc
= tdesc_info
->tdesc
;
1713 filename
= tdesc_info
->filename
.data ();
1717 /* Use the target description from the XML file. */
1719 tdesc
= file_read_description_xml (filename
);
1723 error (_("There is no target description to print."));
1725 if (filename
== NULL
)
1726 filename
= "fetched from target";
1728 std::string
filename_after_features (filename
);
1729 auto loc
= filename_after_features
.rfind ("/features/");
1731 if (loc
!= std::string::npos
)
1732 filename_after_features
= filename_after_features
.substr (loc
+ 10);
1734 /* Print c files for target features instead of target descriptions,
1735 because c files got from target features are more flexible than the
1737 if (opts
.single_feature
)
1739 if (tdesc
->features
.size () != 1)
1740 error (_("only target descriptions with 1 feature can be used "
1741 "with -single-feature option"));
1743 print_c_feature
v (filename_after_features
);
1749 print_c_tdesc
v (filename_after_features
);
1755 /* Completer for the "backtrace" command. */
1758 maint_print_c_tdesc_cmd_completer (struct cmd_list_element
*ignore
,
1759 completion_tracker
&tracker
,
1760 const char *text
, const char *word
)
1762 auto grp
= make_maint_print_c_tdesc_options_def_group (nullptr);
1763 if (gdb::option::complete_options
1764 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR
, grp
))
1767 word
= advance_to_filename_complete_word_point (tracker
, text
);
1768 filename_completer (ignore
, tracker
, text
, word
);
1771 /* Implement the maintenance print xml-tdesc command. */
1774 maint_print_xml_tdesc_cmd (const char *args
, int from_tty
)
1776 const struct target_desc
*tdesc
;
1780 /* Use the global target-supplied description, not the current
1781 architecture's. This lets a GDB for one architecture generate XML
1782 for another architecture's description, even though the gdbarch
1783 initialization code will reject the new description. */
1784 tdesc
= current_inferior ()->tdesc_info
.tdesc
;
1788 /* Use the target description from the XML file. */
1789 tdesc
= file_read_description_xml (args
);
1793 error (_("There is no target description to print."));
1796 print_xml_feature
v (&buf
);
1798 gdb_puts (buf
.c_str ());
1801 namespace selftests
{
1803 /* A reference target description, used for testing (see record_xml_tdesc). */
1805 struct xml_test_tdesc
1807 xml_test_tdesc (const char *name
, std::unique_ptr
<const target_desc
> &&tdesc
)
1808 : name (name
), tdesc (std::move (tdesc
))
1812 std::unique_ptr
<const target_desc
> tdesc
;
1815 static std::vector
<xml_test_tdesc
> xml_tdesc
;
1819 /* See target-descriptions.h. */
1822 record_xml_tdesc (const char *xml_file
, const struct target_desc
*tdesc
)
1824 xml_tdesc
.emplace_back (xml_file
, std::unique_ptr
<const target_desc
> (tdesc
));
1830 /* Test the conversion process of a target description to/from xml: Take a target
1831 description TDESC, convert to xml, back to a description, and confirm the new
1832 tdesc is identical to the original. */
1834 maintenance_check_tdesc_xml_convert (const target_desc
*tdesc
, const char *name
)
1836 const char *xml
= tdesc_get_features_xml (tdesc
);
1838 if (xml
== nullptr || *xml
!= '@')
1840 gdb_printf (_("Could not convert description for %s to xml.\n"),
1845 const target_desc
*tdesc_trans
= string_read_description_xml (xml
+ 1);
1847 if (tdesc_trans
== nullptr)
1849 gdb_printf (_("Could not convert description for %s from xml.\n"),
1853 else if (*tdesc
!= *tdesc_trans
)
1855 gdb_printf (_("Converted description for %s does not match.\n"),
1863 /* Check that the target descriptions created dynamically by
1864 architecture-specific code equal the descriptions created from XML files
1865 found in the specified directory DIR. */
1868 maintenance_check_xml_descriptions (const char *dir
, int from_tty
)
1871 error (_("Missing dir name"));
1873 gdb::unique_xmalloc_ptr
<char> dir1 (tilde_expand (dir
));
1874 std::string
feature_dir (dir1
.get ());
1875 unsigned int failed
= 0;
1877 for (auto const &e
: selftests::xml_tdesc
)
1879 std::string tdesc_xml
= (feature_dir
+ SLASH_STRING
+ e
.name
);
1880 const target_desc
*tdesc
1881 = file_read_description_xml (tdesc_xml
.data ());
1883 if (tdesc
== NULL
|| *tdesc
!= *e
.tdesc
)
1885 gdb_printf ( _("Descriptions for %s do not match.\n"), e
.name
);
1888 else if (!maintenance_check_tdesc_xml_convert (tdesc
, e
.name
)
1889 || !maintenance_check_tdesc_xml_convert (e
.tdesc
.get (), e
.name
))
1892 gdb_printf (_("Tested %lu XML files, %d failed\n"),
1893 (long) selftests::xml_tdesc
.size (), failed
);
1896 void _initialize_target_descriptions ();
1898 _initialize_target_descriptions ()
1900 cmd_list_element
*cmd
;
1902 add_setshow_prefix_cmd ("tdesc", class_maintenance
,
1903 _("Set target description specific variables."),
1904 _("Show target description specific variables."),
1905 &tdesc_set_cmdlist
, &tdesc_show_cmdlist
,
1906 &setlist
, &showlist
);
1908 add_basic_prefix_cmd ("tdesc", class_maintenance
, _("\
1909 Unset target description specific variables."),
1910 &tdesc_unset_cmdlist
,
1911 0 /* allow-unknown */, &unsetlist
);
1913 add_setshow_filename_cmd ("filename", class_obscure
,
1914 &tdesc_filename_cmd_string
,
1916 Set the file to read for an XML target description."), _("\
1917 Show the file to read for an XML target description."), _("\
1918 When set, GDB will read the target description from a local\n\
1919 file instead of querying the remote target."),
1920 set_tdesc_filename_cmd
,
1921 show_tdesc_filename_cmd
,
1922 &tdesc_set_cmdlist
, &tdesc_show_cmdlist
);
1924 add_cmd ("filename", class_obscure
, unset_tdesc_filename_cmd
, _("\
1925 Unset the file to read for an XML target description.\n\
1926 When unset, GDB will read the description from the target."),
1927 &tdesc_unset_cmdlist
);
1929 auto grp
= make_maint_print_c_tdesc_options_def_group (nullptr);
1930 static std::string help_text
1931 = gdb::option::build_help (_("\
1932 Print the current target description as a C source file.\n\
1933 Usage: maintenance print c-tdesc [OPTION] [FILENAME]\n\
1938 When FILENAME is not provided then print the current target\n\
1939 description, otherwise an XML target description is read from\n\
1940 FILENAME and printed as a C function.\n\
1942 When '-single-feature' is used then the target description should\n\
1943 contain a single feature and the generated C code will only create\n\
1944 that feature within an already existing target_desc object."), grp
);
1945 cmd
= add_cmd ("c-tdesc", class_maintenance
, maint_print_c_tdesc_cmd
,
1946 help_text
.c_str (), &maintenanceprintlist
);
1947 set_cmd_completer_handle_brkchars (cmd
, maint_print_c_tdesc_cmd_completer
);
1949 cmd
= add_cmd ("xml-tdesc", class_maintenance
, maint_print_xml_tdesc_cmd
, _("\
1950 Print the current target description as an XML file."),
1951 &maintenanceprintlist
);
1952 set_cmd_completer (cmd
, filename_completer
);
1954 cmd
= add_cmd ("xml-descriptions", class_maintenance
,
1955 maintenance_check_xml_descriptions
, _("\
1956 Check equality of GDB target descriptions and XML created descriptions.\n\
1957 Check the target descriptions created in GDB equal the descriptions\n\
1958 created from XML files in the directory.\n\
1959 The parameter is the directory name."),
1960 &maintenancechecklist
);
1961 set_cmd_completer (cmd
, filename_completer
);