1 /* Target description support for GDB.
3 Copyright (C) 2006-2021 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
783 tdesc_data_alloc (void)
785 return tdesc_arch_data_up (new tdesc_arch_data ());
788 /* See target-descriptions.h. */
791 tdesc_arch_data_deleter::operator() (struct tdesc_arch_data
*data
) const
796 /* Search FEATURE for a register named NAME. */
798 static struct tdesc_reg
*
799 tdesc_find_register_early (const struct tdesc_feature
*feature
,
802 for (const tdesc_reg_up
®
: feature
->registers
)
803 if (strcasecmp (reg
->name
.c_str (), name
) == 0)
809 /* Search FEATURE for a register named NAME. Assign REGNO to it. */
812 tdesc_numbered_register (const struct tdesc_feature
*feature
,
813 struct tdesc_arch_data
*data
,
814 int regno
, const char *name
)
816 struct tdesc_reg
*reg
= tdesc_find_register_early (feature
, name
);
821 /* Make sure the vector includes a REGNO'th element. */
822 while (regno
>= data
->arch_regs
.size ())
823 data
->arch_regs
.emplace_back (nullptr, nullptr);
825 data
->arch_regs
[regno
] = tdesc_arch_reg (reg
, NULL
);
830 /* Search FEATURE for a register named NAME, but do not assign a fixed
831 register number to it. */
834 tdesc_unnumbered_register (const struct tdesc_feature
*feature
,
837 struct tdesc_reg
*reg
= tdesc_find_register_early (feature
, name
);
845 /* Search FEATURE for a register whose name is in NAMES and assign
849 tdesc_numbered_register_choices (const struct tdesc_feature
*feature
,
850 struct tdesc_arch_data
*data
,
851 int regno
, const char *const names
[])
855 for (i
= 0; names
[i
] != NULL
; i
++)
856 if (tdesc_numbered_register (feature
, data
, regno
, names
[i
]))
862 /* Search FEATURE for a register named NAME, and return its size in
863 bits. The register must exist. */
866 tdesc_register_bitsize (const struct tdesc_feature
*feature
, const char *name
)
868 struct tdesc_reg
*reg
= tdesc_find_register_early (feature
, name
);
870 gdb_assert (reg
!= NULL
);
874 /* Look up a register by its GDB internal register number. */
876 static struct tdesc_arch_reg
*
877 tdesc_find_arch_register (struct gdbarch
*gdbarch
, int regno
)
879 struct tdesc_arch_data
*data
;
881 data
= (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
882 if (regno
< data
->arch_regs
.size ())
883 return &data
->arch_regs
[regno
];
888 static struct tdesc_reg
*
889 tdesc_find_register (struct gdbarch
*gdbarch
, int regno
)
891 struct tdesc_arch_reg
*reg
= tdesc_find_arch_register (gdbarch
, regno
);
893 return reg
? reg
->reg
: NULL
;
896 /* Return the name of register REGNO, from the target description or
897 from an architecture-provided pseudo_register_name method. */
900 tdesc_register_name (struct gdbarch
*gdbarch
, int regno
)
902 struct tdesc_reg
*reg
= tdesc_find_register (gdbarch
, regno
);
903 int num_regs
= gdbarch_num_regs (gdbarch
);
906 return reg
->name
.c_str ();
908 if (regno
>= num_regs
&& regno
< gdbarch_num_cooked_regs (gdbarch
))
910 struct tdesc_arch_data
*data
911 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
913 gdb_assert (data
->pseudo_register_name
!= NULL
);
914 return data
->pseudo_register_name (gdbarch
, regno
);
921 tdesc_register_type (struct gdbarch
*gdbarch
, int regno
)
923 struct tdesc_arch_reg
*arch_reg
= tdesc_find_arch_register (gdbarch
, regno
);
924 struct tdesc_reg
*reg
= arch_reg
? arch_reg
->reg
: NULL
;
925 int num_regs
= gdbarch_num_regs (gdbarch
);
926 int num_pseudo_regs
= gdbarch_num_pseudo_regs (gdbarch
);
928 if (reg
== NULL
&& regno
>= num_regs
&& regno
< num_regs
+ num_pseudo_regs
)
930 struct tdesc_arch_data
*data
931 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
933 gdb_assert (data
->pseudo_register_type
!= NULL
);
934 return data
->pseudo_register_type (gdbarch
, regno
);
938 /* Return "int0_t", since "void" has a misleading size of one. */
939 return builtin_type (gdbarch
)->builtin_int0
;
941 if (arch_reg
->type
== NULL
)
943 /* First check for a predefined or target defined type. */
945 arch_reg
->type
= make_gdb_type (gdbarch
, reg
->tdesc_type
);
947 /* Next try size-sensitive type shortcuts. */
948 else if (reg
->type
== "float")
950 if (reg
->bitsize
== gdbarch_float_bit (gdbarch
))
951 arch_reg
->type
= builtin_type (gdbarch
)->builtin_float
;
952 else if (reg
->bitsize
== gdbarch_double_bit (gdbarch
))
953 arch_reg
->type
= builtin_type (gdbarch
)->builtin_double
;
954 else if (reg
->bitsize
== gdbarch_long_double_bit (gdbarch
))
955 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long_double
;
958 warning (_("Register \"%s\" has an unsupported size (%d bits)"),
959 reg
->name
.c_str (), reg
->bitsize
);
960 arch_reg
->type
= builtin_type (gdbarch
)->builtin_double
;
963 else if (reg
->type
== "int")
965 if (reg
->bitsize
== gdbarch_long_bit (gdbarch
))
966 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long
;
967 else if (reg
->bitsize
== TARGET_CHAR_BIT
)
968 arch_reg
->type
= builtin_type (gdbarch
)->builtin_char
;
969 else if (reg
->bitsize
== gdbarch_short_bit (gdbarch
))
970 arch_reg
->type
= builtin_type (gdbarch
)->builtin_short
;
971 else if (reg
->bitsize
== gdbarch_int_bit (gdbarch
))
972 arch_reg
->type
= builtin_type (gdbarch
)->builtin_int
;
973 else if (reg
->bitsize
== gdbarch_long_long_bit (gdbarch
))
974 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long_long
;
975 else if (reg
->bitsize
== gdbarch_ptr_bit (gdbarch
))
976 /* A bit desperate by this point... */
977 arch_reg
->type
= builtin_type (gdbarch
)->builtin_data_ptr
;
980 warning (_("Register \"%s\" has an unsupported size (%d bits)"),
981 reg
->name
.c_str (), reg
->bitsize
);
982 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long
;
986 if (arch_reg
->type
== NULL
)
987 internal_error (__FILE__
, __LINE__
,
988 "Register \"%s\" has an unknown type \"%s\"",
989 reg
->name
.c_str (), reg
->type
.c_str ());
992 return arch_reg
->type
;
996 tdesc_remote_register_number (struct gdbarch
*gdbarch
, int regno
)
998 struct tdesc_reg
*reg
= tdesc_find_register (gdbarch
, regno
);
1001 return reg
->target_regnum
;
1006 /* Check whether REGNUM is a member of REGGROUP. Registers from the
1007 target description may be classified as general, float, vector or other
1008 register groups registered with reggroup_add(). Unlike a gdbarch
1009 register_reggroup_p method, this function will return -1 if it does not
1010 know; the caller should handle registers with no specified group.
1012 The names of containing features are not used. This might be extended
1013 to display registers in some more useful groupings.
1015 The save-restore flag is also implemented here. */
1018 tdesc_register_in_reggroup_p (struct gdbarch
*gdbarch
, int regno
,
1019 struct reggroup
*reggroup
)
1021 struct tdesc_reg
*reg
= tdesc_find_register (gdbarch
, regno
);
1023 if (reg
!= NULL
&& !reg
->group
.empty ()
1024 && (reg
->group
== reggroup_name (reggroup
)))
1028 && (reggroup
== save_reggroup
|| reggroup
== restore_reggroup
))
1029 return reg
->save_restore
;
1034 /* Check whether REGNUM is a member of REGGROUP. Registers with no
1035 group specified go to the default reggroup function and are handled
1039 tdesc_register_reggroup_p (struct gdbarch
*gdbarch
, int regno
,
1040 struct reggroup
*reggroup
)
1042 int num_regs
= gdbarch_num_regs (gdbarch
);
1043 int num_pseudo_regs
= gdbarch_num_pseudo_regs (gdbarch
);
1046 if (regno
>= num_regs
&& regno
< num_regs
+ num_pseudo_regs
)
1048 struct tdesc_arch_data
*data
1049 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1051 if (data
->pseudo_register_reggroup_p
!= NULL
)
1052 return data
->pseudo_register_reggroup_p (gdbarch
, regno
, reggroup
);
1053 /* Otherwise fall through to the default reggroup_p. */
1056 ret
= tdesc_register_in_reggroup_p (gdbarch
, regno
, reggroup
);
1060 return default_register_reggroup_p (gdbarch
, regno
, reggroup
);
1063 /* Record architecture-specific functions to call for pseudo-register
1067 set_tdesc_pseudo_register_name (struct gdbarch
*gdbarch
,
1068 gdbarch_register_name_ftype
*pseudo_name
)
1070 struct tdesc_arch_data
*data
1071 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1073 data
->pseudo_register_name
= pseudo_name
;
1077 set_tdesc_pseudo_register_type (struct gdbarch
*gdbarch
,
1078 gdbarch_register_type_ftype
*pseudo_type
)
1080 struct tdesc_arch_data
*data
1081 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1083 data
->pseudo_register_type
= pseudo_type
;
1087 set_tdesc_pseudo_register_reggroup_p
1088 (struct gdbarch
*gdbarch
,
1089 gdbarch_register_reggroup_p_ftype
*pseudo_reggroup_p
)
1091 struct tdesc_arch_data
*data
1092 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1094 data
->pseudo_register_reggroup_p
= pseudo_reggroup_p
;
1097 /* Update GDBARCH to use the target description for registers. */
1100 tdesc_use_registers (struct gdbarch
*gdbarch
,
1101 const struct target_desc
*target_desc
,
1102 tdesc_arch_data_up
&&early_data
,
1103 tdesc_unknown_register_ftype unk_reg_cb
)
1105 int num_regs
= gdbarch_num_regs (gdbarch
);
1106 struct tdesc_arch_data
*data
;
1108 /* We can't use the description for registers if it doesn't describe
1109 any. This function should only be called after validating
1110 registers, so the caller should know that registers are
1112 gdb_assert (tdesc_has_registers (target_desc
));
1114 data
= (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1115 data
->arch_regs
= std::move (early_data
->arch_regs
);
1117 /* Build up a set of all registers, so that we can assign register
1118 numbers where needed. The hash table expands as necessary, so
1119 the initial size is arbitrary. */
1120 htab_up
reg_hash (htab_create (37, htab_hash_pointer
, htab_eq_pointer
,
1122 for (const tdesc_feature_up
&feature
: target_desc
->features
)
1123 for (const tdesc_reg_up
®
: feature
->registers
)
1125 void **slot
= htab_find_slot (reg_hash
.get (), reg
.get (), INSERT
);
1128 /* Add reggroup if its new. */
1129 if (!reg
->group
.empty ())
1130 if (reggroup_find (gdbarch
, reg
->group
.c_str ()) == NULL
)
1131 reggroup_add (gdbarch
, reggroup_gdbarch_new (gdbarch
,
1132 reg
->group
.c_str (),
1136 /* Remove any registers which were assigned numbers by the
1138 for (const tdesc_arch_reg
&arch_reg
: data
->arch_regs
)
1139 if (arch_reg
.reg
!= NULL
)
1140 htab_remove_elt (reg_hash
.get (), arch_reg
.reg
);
1142 /* Assign numbers to the remaining registers and add them to the
1143 list of registers. The new numbers are always above gdbarch_num_regs.
1144 Iterate over the features, not the hash table, so that the order
1145 matches that in the target description. */
1147 gdb_assert (data
->arch_regs
.size () <= num_regs
);
1148 while (data
->arch_regs
.size () < num_regs
)
1149 data
->arch_regs
.emplace_back (nullptr, nullptr);
1151 /* First we give the target a chance to number previously unknown
1152 registers. This allows targets to record the numbers assigned based
1153 on which feature the register was from. */
1154 if (unk_reg_cb
!= NULL
)
1156 for (const tdesc_feature_up
&feature
: target_desc
->features
)
1157 for (const tdesc_reg_up
®
: feature
->registers
)
1158 if (htab_find (reg_hash
.get (), reg
.get ()) != NULL
)
1160 int regno
= unk_reg_cb (gdbarch
, feature
.get (),
1161 reg
->name
.c_str (), num_regs
);
1162 gdb_assert (regno
== -1 || regno
>= num_regs
);
1165 while (regno
>= data
->arch_regs
.size ())
1166 data
->arch_regs
.emplace_back (nullptr, nullptr);
1167 data
->arch_regs
[regno
] = tdesc_arch_reg (reg
.get (), NULL
);
1168 num_regs
= regno
+ 1;
1169 htab_remove_elt (reg_hash
.get (), reg
.get ());
1174 /* Ensure the array was sized correctly above. */
1175 gdb_assert (data
->arch_regs
.size () == num_regs
);
1177 /* Now in a final pass we assign register numbers to any remaining
1178 unnumbered registers. */
1179 for (const tdesc_feature_up
&feature
: target_desc
->features
)
1180 for (const tdesc_reg_up
®
: feature
->registers
)
1181 if (htab_find (reg_hash
.get (), reg
.get ()) != NULL
)
1183 data
->arch_regs
.emplace_back (reg
.get (), nullptr);
1187 /* Update the architecture. */
1188 set_gdbarch_num_regs (gdbarch
, num_regs
);
1189 set_gdbarch_register_name (gdbarch
, tdesc_register_name
);
1190 set_gdbarch_register_type (gdbarch
, tdesc_register_type
);
1191 set_gdbarch_remote_register_number (gdbarch
,
1192 tdesc_remote_register_number
);
1193 set_gdbarch_register_reggroup_p (gdbarch
, tdesc_register_reggroup_p
);
1196 /* See gdbsupport/tdesc.h. */
1198 struct tdesc_feature
*
1199 tdesc_create_feature (struct target_desc
*tdesc
, const char *name
)
1201 struct tdesc_feature
*new_feature
= new tdesc_feature (name
);
1203 tdesc
->features
.emplace_back (new_feature
);
1208 /* See gdbsupport/tdesc.h. */
1211 allocate_target_description (void)
1213 return target_desc_up (new target_desc ());
1216 /* See gdbsupport/tdesc.h. */
1219 target_desc_deleter::operator() (struct target_desc
*target_desc
) const
1225 tdesc_add_compatible (struct target_desc
*target_desc
,
1226 const struct bfd_arch_info
*compatible
)
1228 /* If this instance of GDB is compiled without BFD support for the
1229 compatible architecture, simply ignore it -- we would not be able
1230 to handle it anyway. */
1231 if (compatible
== NULL
)
1234 for (const tdesc_compatible_info_up
&compat
: target_desc
->compatible
)
1235 if (compat
->arch () == compatible
)
1236 internal_error (__FILE__
, __LINE__
,
1237 _("Attempted to add duplicate "
1238 "compatible architecture \"%s\""),
1239 compatible
->printable_name
);
1241 target_desc
->compatible
.push_back
1242 (std::unique_ptr
<tdesc_compatible_info
>
1243 (new tdesc_compatible_info (compatible
)));
1247 set_tdesc_property (struct target_desc
*target_desc
,
1248 const char *key
, const char *value
)
1250 gdb_assert (key
!= NULL
&& value
!= NULL
);
1252 if (tdesc_property (target_desc
, key
) != NULL
)
1253 internal_error (__FILE__
, __LINE__
,
1254 _("Attempted to add duplicate property \"%s\""), key
);
1256 target_desc
->properties
.emplace_back (key
, value
);
1259 /* See gdbsupport/tdesc.h. */
1262 set_tdesc_architecture (struct target_desc
*target_desc
,
1265 set_tdesc_architecture (target_desc
, bfd_scan_arch (name
));
1269 set_tdesc_architecture (struct target_desc
*target_desc
,
1270 const struct bfd_arch_info
*arch
)
1272 target_desc
->arch
= arch
;
1275 /* See gdbsupport/tdesc.h. */
1278 set_tdesc_osabi (struct target_desc
*target_desc
, const char *name
)
1280 set_tdesc_osabi (target_desc
, osabi_from_tdesc_string (name
));
1284 set_tdesc_osabi (struct target_desc
*target_desc
, enum gdb_osabi osabi
)
1286 target_desc
->osabi
= osabi
;
1290 static struct cmd_list_element
*tdesc_set_cmdlist
, *tdesc_show_cmdlist
;
1291 static struct cmd_list_element
*tdesc_unset_cmdlist
;
1293 /* Helper functions for the CLI commands. */
1296 set_tdesc_filename_cmd (const char *args
, int from_tty
,
1297 struct cmd_list_element
*c
)
1299 xfree (target_description_filename
);
1300 target_description_filename
= xstrdup (tdesc_filename_cmd_string
);
1302 target_clear_description ();
1303 target_find_description ();
1307 show_tdesc_filename_cmd (struct ui_file
*file
, int from_tty
,
1308 struct cmd_list_element
*c
,
1311 value
= target_description_filename
;
1313 if (value
!= NULL
&& *value
!= '\0')
1314 printf_filtered (_("The target description will be read from \"%s\".\n"),
1317 printf_filtered (_("The target description will be "
1318 "read from the target.\n"));
1322 unset_tdesc_filename_cmd (const char *args
, int from_tty
)
1324 xfree (target_description_filename
);
1325 target_description_filename
= NULL
;
1326 target_clear_description ();
1327 target_find_description ();
1330 /* Print target description in C. */
1332 class print_c_tdesc
: public tdesc_element_visitor
1335 print_c_tdesc (std::string
&filename_after_features
)
1336 : m_filename_after_features (filename_after_features
)
1340 const char *filename
= lbasename (m_filename_after_features
.c_str ());
1342 m_function
= (char *) xmalloc (strlen (filename
) + 1);
1343 for (inp
= filename
, outp
= m_function
; *inp
!= '\0'; inp
++)
1346 else if (*inp
== '-')
1348 else if (*inp
== ' ')
1354 /* Standard boilerplate. */
1355 printf_unfiltered ("/* THIS FILE IS GENERATED. "
1356 "-*- buffer-read-only: t -*- vi"
1365 void visit_pre (const target_desc
*e
) override
1367 printf_unfiltered (" Original: %s */\n\n",
1368 lbasename (m_filename_after_features
.c_str ()));
1370 printf_unfiltered ("#include \"defs.h\"\n");
1371 printf_unfiltered ("#include \"osabi.h\"\n");
1372 printf_unfiltered ("#include \"target-descriptions.h\"\n");
1373 printf_unfiltered ("\n");
1375 printf_unfiltered ("struct target_desc *tdesc_%s;\n", m_function
);
1376 printf_unfiltered ("static void\n");
1377 printf_unfiltered ("initialize_tdesc_%s (void)\n", m_function
);
1378 printf_unfiltered ("{\n");
1380 (" target_desc_up result = allocate_target_description ();\n");
1382 if (tdesc_architecture (e
) != NULL
)
1385 (" set_tdesc_architecture (result.get (), bfd_scan_arch (\"%s\"));\n",
1386 tdesc_architecture (e
)->printable_name
);
1387 printf_unfiltered ("\n");
1389 if (tdesc_osabi (e
) > GDB_OSABI_UNKNOWN
1390 && tdesc_osabi (e
) < GDB_OSABI_INVALID
)
1393 (" set_tdesc_osabi (result.get (), osabi_from_tdesc_string (\"%s\"));\n",
1394 gdbarch_osabi_name (tdesc_osabi (e
)));
1395 printf_unfiltered ("\n");
1398 for (const tdesc_compatible_info_up
&compatible
: e
->compatible
)
1400 (" tdesc_add_compatible (result.get (), bfd_scan_arch (\"%s\"));\n",
1401 compatible
->arch ()->printable_name
);
1403 if (!e
->compatible
.empty ())
1404 printf_unfiltered ("\n");
1406 for (const property
&prop
: e
->properties
)
1407 printf_unfiltered (" set_tdesc_property (result.get (), \"%s\", \"%s\");\n",
1408 prop
.key
.c_str (), prop
.value
.c_str ());
1410 printf_unfiltered (" struct tdesc_feature *feature;\n");
1413 void visit_pre (const tdesc_feature
*e
) override
1415 printf_unfiltered ("\n feature = tdesc_create_feature (result.get (), \"%s\");\n",
1419 void visit_post (const tdesc_feature
*e
) override
1422 void visit_post (const target_desc
*e
) override
1424 printf_unfiltered ("\n tdesc_%s = result.release ();\n", m_function
);
1425 printf_unfiltered ("}\n");
1428 void visit (const tdesc_type_builtin
*type
) override
1430 error (_("C output is not supported type \"%s\"."), type
->name
.c_str ());
1433 void visit (const tdesc_type_vector
*type
) override
1435 if (!m_printed_element_type
)
1437 printf_unfiltered (" tdesc_type *element_type;\n");
1438 m_printed_element_type
= true;
1442 (" element_type = tdesc_named_type (feature, \"%s\");\n",
1443 type
->element_type
->name
.c_str ());
1445 (" tdesc_create_vector (feature, \"%s\", element_type, %d);\n",
1446 type
->name
.c_str (), type
->count
);
1448 printf_unfiltered ("\n");
1451 void visit (const tdesc_type_with_fields
*type
) override
1453 if (!m_printed_type_with_fields
)
1455 printf_unfiltered (" tdesc_type_with_fields *type_with_fields;\n");
1456 m_printed_type_with_fields
= true;
1461 case TDESC_TYPE_STRUCT
:
1462 case TDESC_TYPE_FLAGS
:
1463 if (type
->kind
== TDESC_TYPE_STRUCT
)
1466 (" type_with_fields = tdesc_create_struct (feature, \"%s\");\n",
1467 type
->name
.c_str ());
1468 if (type
->size
!= 0)
1470 (" tdesc_set_struct_size (type_with_fields, %d);\n", type
->size
);
1475 (" type_with_fields = tdesc_create_flags (feature, \"%s\", %d);\n",
1476 type
->name
.c_str (), type
->size
);
1478 for (const tdesc_type_field
&f
: type
->fields
)
1480 const char *type_name
;
1482 gdb_assert (f
.type
!= NULL
);
1483 type_name
= f
.type
->name
.c_str ();
1485 /* To minimize changes to generated files, don't emit type
1486 info for fields that have defaulted types. */
1489 gdb_assert (f
.end
!= -1);
1490 if (f
.type
->kind
== TDESC_TYPE_BOOL
)
1492 gdb_assert (f
.start
== f
.end
);
1494 (" tdesc_add_flag (type_with_fields, %d, \"%s\");\n",
1495 f
.start
, f
.name
.c_str ());
1497 else if ((type
->size
== 4 && f
.type
->kind
== TDESC_TYPE_UINT32
)
1499 && f
.type
->kind
== TDESC_TYPE_UINT64
))
1502 (" tdesc_add_bitfield (type_with_fields, \"%s\", %d, %d);\n",
1503 f
.name
.c_str (), f
.start
, f
.end
);
1507 printf_field_type_assignment
1508 ("tdesc_named_type (feature, \"%s\");\n",
1511 (" tdesc_add_typed_bitfield (type_with_fields, \"%s\","
1512 " %d, %d, field_type);\n",
1513 f
.name
.c_str (), f
.start
, f
.end
);
1516 else /* Not a bitfield. */
1518 gdb_assert (f
.end
== -1);
1519 gdb_assert (type
->kind
== TDESC_TYPE_STRUCT
);
1520 printf_field_type_assignment
1521 ("tdesc_named_type (feature, \"%s\");\n", type_name
);
1523 (" tdesc_add_field (type_with_fields, \"%s\", field_type);\n",
1528 case TDESC_TYPE_UNION
:
1530 (" type_with_fields = tdesc_create_union (feature, \"%s\");\n",
1531 type
->name
.c_str ());
1532 for (const tdesc_type_field
&f
: type
->fields
)
1534 printf_field_type_assignment
1535 ("tdesc_named_type (feature, \"%s\");\n", f
.type
->name
.c_str ());
1537 (" tdesc_add_field (type_with_fields, \"%s\", field_type);\n",
1541 case TDESC_TYPE_ENUM
:
1543 (" type_with_fields = tdesc_create_enum (feature, \"%s\", %d);\n",
1544 type
->name
.c_str (), type
->size
);
1545 for (const tdesc_type_field
&f
: type
->fields
)
1547 (" tdesc_add_enum_value (type_with_fields, %d, \"%s\");\n",
1548 f
.start
, f
.name
.c_str ());
1551 error (_("C output is not supported type \"%s\"."), type
->name
.c_str ());
1554 printf_unfiltered ("\n");
1557 void visit (const tdesc_reg
*reg
) override
1559 printf_unfiltered (" tdesc_create_reg (feature, \"%s\", %ld, %d, ",
1560 reg
->name
.c_str (), reg
->target_regnum
,
1562 if (!reg
->group
.empty ())
1563 printf_unfiltered ("\"%s\", ", reg
->group
.c_str ());
1565 printf_unfiltered ("NULL, ");
1566 printf_unfiltered ("%d, \"%s\");\n", reg
->bitsize
, reg
->type
.c_str ());
1570 std::string m_filename_after_features
;
1574 /* Print an assignment to the field_type variable. Print the declaration
1575 of field_type if that has not been done yet. */
1576 ATTRIBUTE_PRINTF (2, 3)
1577 void printf_field_type_assignment (const char *fmt
, ...)
1579 if (!m_printed_field_type
)
1581 printf_unfiltered (" tdesc_type *field_type;\n");
1582 m_printed_field_type
= true;
1585 printf_unfiltered (" field_type = ");
1588 va_start (args
, fmt
);
1589 vprintf_unfiltered (fmt
, args
);
1595 /* Did we print "struct tdesc_type *element_type;" yet? */
1596 bool m_printed_element_type
= false;
1598 /* Did we print "struct tdesc_type_with_fields *element_type;" yet? */
1599 bool m_printed_type_with_fields
= false;
1601 /* Did we print "struct tdesc_type *field_type;" yet? */
1602 bool m_printed_field_type
= false;
1605 /* Print target description feature in C. */
1607 class print_c_feature
: public print_c_tdesc
1610 print_c_feature (std::string
&file
)
1611 : print_c_tdesc (file
)
1614 auto const pos
= m_filename_after_features
.find_last_of ('.');
1616 m_filename_after_features
= m_filename_after_features
.substr (0, pos
);
1619 void visit_pre (const target_desc
*e
) override
1621 printf_unfiltered (" Original: %s */\n\n",
1622 lbasename (m_filename_after_features
.c_str ()));
1624 printf_unfiltered ("#include \"gdbsupport/tdesc.h\"\n");
1625 printf_unfiltered ("\n");
1628 void visit_post (const target_desc
*e
) override
1631 void visit_pre (const tdesc_feature
*e
) override
1633 std::string
name (m_filename_after_features
);
1635 auto pos
= name
.find_first_of ('.');
1637 name
= name
.substr (0, pos
);
1638 std::replace (name
.begin (), name
.end (), '/', '_');
1639 std::replace (name
.begin (), name
.end (), '-', '_');
1641 printf_unfiltered ("static int\n");
1642 printf_unfiltered ("create_feature_%s ", name
.c_str ());
1643 printf_unfiltered ("(struct target_desc *result, long regnum)\n");
1645 printf_unfiltered ("{\n");
1646 printf_unfiltered (" struct tdesc_feature *feature;\n");
1649 ("\n feature = tdesc_create_feature (result, \"%s\");\n",
1653 void visit_post (const tdesc_feature
*e
) override
1655 printf_unfiltered (" return regnum;\n");
1656 printf_unfiltered ("}\n");
1659 void visit (const tdesc_reg
*reg
) override
1661 /* Most "reg" in XML target descriptions don't have "regnum"
1662 attribute, so the register number is allocated sequentially.
1663 In case that reg has "regnum" attribute, register number
1664 should be set by that explicitly. */
1666 if (reg
->target_regnum
< m_next_regnum
)
1668 /* The integrity check, it can catch some errors on register
1669 number collision, like this,
1671 <reg name="x0" bitsize="32"/>
1672 <reg name="x1" bitsize="32"/>
1673 <reg name="x2" bitsize="32"/>
1674 <reg name="x3" bitsize="32"/>
1675 <reg name="ps" bitsize="32" regnum="3"/>
1677 but it also has false negatives. The target description
1680 <reg name="x1" bitsize="32" regnum="1"/>
1681 <reg name="x3" bitsize="32" regnum="3"/>
1682 <reg name="x2" bitsize="32" regnum="2"/>
1683 <reg name="x4" bitsize="32" regnum="4"/>
1685 but it is not a good practice, so still error on this,
1686 and also print the message so that it can be saved in the
1687 generated c file. */
1689 printf_unfiltered ("ERROR: \"regnum\" attribute %ld ",
1690 reg
->target_regnum
);
1691 printf_unfiltered ("is not the largest number (%d).\n",
1693 error (_("\"regnum\" attribute %ld is not the largest number (%d)."),
1694 reg
->target_regnum
, m_next_regnum
);
1697 if (reg
->target_regnum
> m_next_regnum
)
1699 printf_unfiltered (" regnum = %ld;\n", reg
->target_regnum
);
1700 m_next_regnum
= reg
->target_regnum
;
1703 printf_unfiltered (" tdesc_create_reg (feature, \"%s\", regnum++, %d, ",
1704 reg
->name
.c_str (), reg
->save_restore
);
1705 if (!reg
->group
.empty ())
1706 printf_unfiltered ("\"%s\", ", reg
->group
.c_str ());
1708 printf_unfiltered ("NULL, ");
1709 printf_unfiltered ("%d, \"%s\");\n", reg
->bitsize
, reg
->type
.c_str ());
1715 /* The register number to use for the next register we see. */
1716 int m_next_regnum
= 0;
1719 /* See gdbsupport/tdesc.h. */
1722 tdesc_get_features_xml (const target_desc
*tdesc
)
1724 if (tdesc
->xmltarget
== nullptr)
1726 std::string
buffer ("@");
1727 print_xml_feature
v (&buffer
);
1729 tdesc
->xmltarget
= xstrdup (buffer
.c_str ());
1731 return tdesc
->xmltarget
;
1734 /* Data structures and functions to setup the option flags for 'maintenance
1735 print c-tdesc command. */
1737 struct maint_print_c_tdesc_options
1739 /* True when the '-single-feature' flag was passed. */
1740 bool single_feature
= false;
1743 using maint_print_c_tdesc_opt_def
1744 = gdb::option::flag_option_def
<maint_print_c_tdesc_options
>;
1746 static const gdb::option::option_def maint_print_c_tdesc_opt_defs
[] = {
1747 maint_print_c_tdesc_opt_def
{
1749 [] (maint_print_c_tdesc_options
*opt
) { return &opt
->single_feature
; },
1750 N_("Print C description of just a single feature.")
1754 static inline gdb::option::option_def_group
1755 make_maint_print_c_tdesc_options_def_group (maint_print_c_tdesc_options
*opts
)
1757 return {{maint_print_c_tdesc_opt_defs
}, opts
};
1760 /* Implement 'maintenance print c-tdesc' command. */
1763 maint_print_c_tdesc_cmd (const char *args
, int from_tty
)
1765 const struct target_desc
*tdesc
;
1766 const char *filename
;
1768 maint_print_c_tdesc_options opts
;
1769 auto grp
= make_maint_print_c_tdesc_options_def_group (&opts
);
1770 gdb::option::process_options
1771 (&args
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR
, grp
);
1775 /* Use the global target-supplied description, not the current
1776 architecture's. This lets a GDB for one architecture generate C
1777 for another architecture's description, even though the gdbarch
1778 initialization code will reject the new description. */
1779 tdesc
= current_target_desc
;
1780 filename
= target_description_filename
;
1784 /* Use the target description from the XML file. */
1786 tdesc
= file_read_description_xml (filename
);
1790 error (_("There is no target description to print."));
1792 if (filename
== NULL
)
1793 filename
= "fetched from target";
1795 std::string
filename_after_features (filename
);
1796 auto loc
= filename_after_features
.rfind ("/features/");
1798 if (loc
!= std::string::npos
)
1799 filename_after_features
= filename_after_features
.substr (loc
+ 10);
1801 /* Print c files for target features instead of target descriptions,
1802 because c files got from target features are more flexible than the
1804 if (opts
.single_feature
)
1806 if (tdesc
->features
.size () != 1)
1807 error (_("only target descriptions with 1 feature can be used "
1808 "with -single-feature option"));
1810 print_c_feature
v (filename_after_features
);
1816 print_c_tdesc
v (filename_after_features
);
1822 /* Completer for the "backtrace" command. */
1825 maint_print_c_tdesc_cmd_completer (struct cmd_list_element
*ignore
,
1826 completion_tracker
&tracker
,
1827 const char *text
, const char *word
)
1829 auto grp
= make_maint_print_c_tdesc_options_def_group (nullptr);
1830 if (gdb::option::complete_options
1831 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR
, grp
))
1834 word
= advance_to_filename_complete_word_point (tracker
, text
);
1835 filename_completer (ignore
, tracker
, text
, word
);
1838 /* Implement the maintenance print xml-tdesc command. */
1841 maint_print_xml_tdesc_cmd (const char *args
, int from_tty
)
1843 const struct target_desc
*tdesc
;
1847 /* Use the global target-supplied description, not the current
1848 architecture's. This lets a GDB for one architecture generate XML
1849 for another architecture's description, even though the gdbarch
1850 initialization code will reject the new description. */
1851 tdesc
= current_target_desc
;
1855 /* Use the target description from the XML file. */
1856 tdesc
= file_read_description_xml (args
);
1860 error (_("There is no target description to print."));
1863 print_xml_feature
v (&buf
);
1865 puts_unfiltered (buf
.c_str ());
1868 namespace selftests
{
1870 /* A reference target description, used for testing (see record_xml_tdesc). */
1872 struct xml_test_tdesc
1874 xml_test_tdesc (const char *name
, std::unique_ptr
<const target_desc
> &&tdesc
)
1875 : name (name
), tdesc (std::move (tdesc
))
1879 std::unique_ptr
<const target_desc
> tdesc
;
1882 static std::vector
<xml_test_tdesc
> xml_tdesc
;
1886 /* See target-descriptions.h. */
1889 record_xml_tdesc (const char *xml_file
, const struct target_desc
*tdesc
)
1891 xml_tdesc
.emplace_back (xml_file
, std::unique_ptr
<const target_desc
> (tdesc
));
1897 /* Test the conversion process of a target description to/from xml: Take a target
1898 description TDESC, convert to xml, back to a description, and confirm the new
1899 tdesc is identical to the original. */
1901 maintenance_check_tdesc_xml_convert (const target_desc
*tdesc
, const char *name
)
1903 const char *xml
= tdesc_get_features_xml (tdesc
);
1905 if (xml
== nullptr || *xml
!= '@')
1907 printf_filtered (_("Could not convert description for %s to xml.\n"),
1912 const target_desc
*tdesc_trans
= string_read_description_xml (xml
+ 1);
1914 if (tdesc_trans
== nullptr)
1916 printf_filtered (_("Could not convert description for %s from xml.\n"),
1920 else if (*tdesc
!= *tdesc_trans
)
1922 printf_filtered (_("Converted description for %s does not match.\n"),
1930 /* Check that the target descriptions created dynamically by
1931 architecture-specific code equal the descriptions created from XML files
1932 found in the specified directory DIR. */
1935 maintenance_check_xml_descriptions (const char *dir
, int from_tty
)
1938 error (_("Missing dir name"));
1940 gdb::unique_xmalloc_ptr
<char> dir1 (tilde_expand (dir
));
1941 std::string
feature_dir (dir1
.get ());
1942 unsigned int failed
= 0;
1944 for (auto const &e
: selftests::xml_tdesc
)
1946 std::string tdesc_xml
= (feature_dir
+ SLASH_STRING
+ e
.name
);
1947 const target_desc
*tdesc
1948 = file_read_description_xml (tdesc_xml
.data ());
1950 if (tdesc
== NULL
|| *tdesc
!= *e
.tdesc
)
1952 printf_filtered ( _("Descriptions for %s do not match.\n"), e
.name
);
1955 else if (!maintenance_check_tdesc_xml_convert (tdesc
, e
.name
)
1956 || !maintenance_check_tdesc_xml_convert (e
.tdesc
.get (), e
.name
))
1959 printf_filtered (_("Tested %lu XML files, %d failed\n"),
1960 (long) selftests::xml_tdesc
.size (), failed
);
1963 void _initialize_target_descriptions ();
1965 _initialize_target_descriptions ()
1967 cmd_list_element
*cmd
;
1969 tdesc_data
= gdbarch_data_register_pre_init (tdesc_data_init
);
1971 add_basic_prefix_cmd ("tdesc", class_maintenance
, _("\
1972 Set target description specific variables."),
1973 &tdesc_set_cmdlist
, "set tdesc ",
1974 0 /* allow-unknown */, &setlist
);
1975 add_show_prefix_cmd ("tdesc", class_maintenance
, _("\
1976 Show target description specific variables."),
1977 &tdesc_show_cmdlist
, "show tdesc ",
1978 0 /* allow-unknown */, &showlist
);
1979 add_basic_prefix_cmd ("tdesc", class_maintenance
, _("\
1980 Unset target description specific variables."),
1981 &tdesc_unset_cmdlist
, "unset tdesc ",
1982 0 /* allow-unknown */, &unsetlist
);
1984 add_setshow_filename_cmd ("filename", class_obscure
,
1985 &tdesc_filename_cmd_string
,
1987 Set the file to read for an XML target description."), _("\
1988 Show the file to read for an XML target description."), _("\
1989 When set, GDB will read the target description from a local\n\
1990 file instead of querying the remote target."),
1991 set_tdesc_filename_cmd
,
1992 show_tdesc_filename_cmd
,
1993 &tdesc_set_cmdlist
, &tdesc_show_cmdlist
);
1995 add_cmd ("filename", class_obscure
, unset_tdesc_filename_cmd
, _("\
1996 Unset the file to read for an XML target description.\n\
1997 When unset, GDB will read the description from the target."),
1998 &tdesc_unset_cmdlist
);
2000 auto grp
= make_maint_print_c_tdesc_options_def_group (nullptr);
2001 static std::string help_text
2002 = gdb::option::build_help (_("\
2003 Print the current target description as a C source file.\n\
2004 Usage: maintenance print c-tdesc [OPTION] [FILENAME]\n\
2009 When FILENAME is not provided then print the current target\n\
2010 description, otherwise an XML target description is read from\n\
2011 FILENAME and printed as a C function.\n\
2013 When '-single-feature' is used then the target description should\n\
2014 contain a single feature and the generated C code will only create\n\
2015 that feature within an already existing target_desc object."), grp
);
2016 cmd
= add_cmd ("c-tdesc", class_maintenance
, maint_print_c_tdesc_cmd
,
2017 help_text
.c_str (), &maintenanceprintlist
);
2018 set_cmd_completer_handle_brkchars (cmd
, maint_print_c_tdesc_cmd_completer
);
2020 cmd
= add_cmd ("xml-tdesc", class_maintenance
, maint_print_xml_tdesc_cmd
, _("\
2021 Print the current target description as an XML file."),
2022 &maintenanceprintlist
);
2023 set_cmd_completer (cmd
, filename_completer
);
2025 cmd
= add_cmd ("xml-descriptions", class_maintenance
,
2026 maintenance_check_xml_descriptions
, _("\
2027 Check equality of GDB target descriptions and XML created descriptions.\n\
2028 Check the target descriptions created in GDB equal the descriptions\n\
2029 created from XML files in the directory.\n\
2030 The parameter is the directory name."),
2031 &maintenancechecklist
);
2032 set_cmd_completer (cmd
, filename_completer
);