1 /* Target description support for GDB.
3 Copyright (C) 2006-2018 Free Software Foundation, Inc.
5 Contributed by CodeSourcery.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "arch-utils.h"
26 #include "reggroups.h"
28 #include "target-descriptions.h"
30 #include "xml-support.h"
31 #include "xml-tdesc.h"
34 #include "gdb_obstack.h"
38 #include "completer.h"
39 #include "readline/tilde.h" /* tilde_expand */
45 property (const std::string
&key_
, const std::string
&value_
)
46 : key (key_
), value (value_
)
53 /* Convert a tdesc_type to a gdb type. */
56 make_gdb_type (struct gdbarch
*gdbarch
, struct tdesc_type
*ttype
)
58 class gdb_type_creator
: public tdesc_element_visitor
61 gdb_type_creator (struct gdbarch
*gdbarch
)
70 void visit (const tdesc_type_builtin
*e
) override
74 /* Predefined types. */
76 m_type
= builtin_type (m_gdbarch
)->builtin_bool
;
79 m_type
= builtin_type (m_gdbarch
)->builtin_int8
;
81 case TDESC_TYPE_INT16
:
82 m_type
= builtin_type (m_gdbarch
)->builtin_int16
;
84 case TDESC_TYPE_INT32
:
85 m_type
= builtin_type (m_gdbarch
)->builtin_int32
;
87 case TDESC_TYPE_INT64
:
88 m_type
= builtin_type (m_gdbarch
)->builtin_int64
;
90 case TDESC_TYPE_INT128
:
91 m_type
= builtin_type (m_gdbarch
)->builtin_int128
;
93 case TDESC_TYPE_UINT8
:
94 m_type
= builtin_type (m_gdbarch
)->builtin_uint8
;
96 case TDESC_TYPE_UINT16
:
97 m_type
= builtin_type (m_gdbarch
)->builtin_uint16
;
99 case TDESC_TYPE_UINT32
:
100 m_type
= builtin_type (m_gdbarch
)->builtin_uint32
;
102 case TDESC_TYPE_UINT64
:
103 m_type
= builtin_type (m_gdbarch
)->builtin_uint64
;
105 case TDESC_TYPE_UINT128
:
106 m_type
= builtin_type (m_gdbarch
)->builtin_uint128
;
108 case TDESC_TYPE_CODE_PTR
:
109 m_type
= builtin_type (m_gdbarch
)->builtin_func_ptr
;
111 case TDESC_TYPE_DATA_PTR
:
112 m_type
= builtin_type (m_gdbarch
)->builtin_data_ptr
;
116 m_type
= tdesc_find_type (m_gdbarch
, e
->name
.c_str ());
122 case TDESC_TYPE_IEEE_SINGLE
:
123 m_type
= arch_float_type (m_gdbarch
, -1, "builtin_type_ieee_single",
124 floatformats_ieee_single
);
127 case TDESC_TYPE_IEEE_DOUBLE
:
128 m_type
= arch_float_type (m_gdbarch
, -1, "builtin_type_ieee_double",
129 floatformats_ieee_double
);
131 case TDESC_TYPE_ARM_FPA_EXT
:
132 m_type
= arch_float_type (m_gdbarch
, -1, "builtin_type_arm_ext",
133 floatformats_arm_ext
);
136 case TDESC_TYPE_I387_EXT
:
137 m_type
= arch_float_type (m_gdbarch
, -1, "builtin_type_i387_ext",
138 floatformats_i387_ext
);
142 internal_error (__FILE__
, __LINE__
,
143 "Type \"%s\" has an unknown kind %d",
144 e
->name
.c_str (), e
->kind
);
147 void visit (const tdesc_type_vector
*e
) override
149 m_type
= tdesc_find_type (m_gdbarch
, e
->name
.c_str ());
153 type
*element_gdb_type
= make_gdb_type (m_gdbarch
, e
->element_type
);
154 m_type
= init_vector_type (element_gdb_type
, e
->count
);
155 TYPE_NAME (m_type
) = xstrdup (e
->name
.c_str ());
159 void visit (const tdesc_type_with_fields
*e
) override
161 m_type
= tdesc_find_type (m_gdbarch
, e
->name
.c_str ());
167 case TDESC_TYPE_STRUCT
:
168 make_gdb_type_struct (e
);
170 case TDESC_TYPE_UNION
:
171 make_gdb_type_union (e
);
173 case TDESC_TYPE_FLAGS
:
174 make_gdb_type_flags (e
);
176 case TDESC_TYPE_ENUM
:
177 make_gdb_type_enum (e
);
181 internal_error (__FILE__
, __LINE__
,
182 "Type \"%s\" has an unknown kind %d",
183 e
->name
.c_str (), e
->kind
);
188 void make_gdb_type_struct (const tdesc_type_with_fields
*e
)
190 m_type
= arch_composite_type (m_gdbarch
, NULL
, TYPE_CODE_STRUCT
);
191 TYPE_NAME (m_type
) = xstrdup (e
->name
.c_str ());
192 TYPE_TAG_NAME (m_type
) = TYPE_NAME (m_type
);
194 for (const tdesc_type_field
&f
: e
->fields
)
196 if (f
.start
!= -1 && f
.end
!= -1)
200 struct type
*field_gdb_type
;
201 int bitsize
, total_size
;
203 /* This invariant should be preserved while creating types. */
204 gdb_assert (e
->size
!= 0);
206 field_gdb_type
= make_gdb_type (m_gdbarch
, f
.type
);
207 else if (e
->size
> 4)
208 field_gdb_type
= builtin_type (m_gdbarch
)->builtin_uint64
;
210 field_gdb_type
= builtin_type (m_gdbarch
)->builtin_uint32
;
212 fld
= append_composite_type_field_raw
213 (m_type
, xstrdup (f
.name
.c_str ()), field_gdb_type
);
215 /* For little-endian, BITPOS counts from the LSB of
216 the structure and marks the LSB of the field. For
217 big-endian, BITPOS counts from the MSB of the
218 structure and marks the MSB of the field. Either
219 way, it is the number of bits to the "left" of the
220 field. To calculate this in big-endian, we need
221 the total size of the structure. */
222 bitsize
= f
.end
- f
.start
+ 1;
223 total_size
= e
->size
* TARGET_CHAR_BIT
;
224 if (gdbarch_bits_big_endian (m_gdbarch
))
225 SET_FIELD_BITPOS (fld
[0], total_size
- f
.start
- bitsize
);
227 SET_FIELD_BITPOS (fld
[0], f
.start
);
228 FIELD_BITSIZE (fld
[0]) = bitsize
;
232 gdb_assert (f
.start
== -1 && f
.end
== -1);
233 type
*field_gdb_type
= make_gdb_type (m_gdbarch
, f
.type
);
234 append_composite_type_field (m_type
,
235 xstrdup (f
.name
.c_str ()),
241 TYPE_LENGTH (m_type
) = e
->size
;
244 void make_gdb_type_union (const tdesc_type_with_fields
*e
)
246 m_type
= arch_composite_type (m_gdbarch
, NULL
, TYPE_CODE_UNION
);
247 TYPE_NAME (m_type
) = xstrdup (e
->name
.c_str ());
249 for (const tdesc_type_field
&f
: e
->fields
)
251 type
* field_gdb_type
= make_gdb_type (m_gdbarch
, f
.type
);
252 append_composite_type_field (m_type
, xstrdup (f
.name
.c_str ()),
255 /* If any of the children of a union are vectors, flag the
256 union as a vector also. This allows e.g. a union of two
257 vector types to show up automatically in "info vector". */
258 if (TYPE_VECTOR (field_gdb_type
))
259 TYPE_VECTOR (m_type
) = 1;
263 void make_gdb_type_flags (const tdesc_type_with_fields
*e
)
265 m_type
= arch_flags_type (m_gdbarch
, e
->name
.c_str (),
266 e
->size
* TARGET_CHAR_BIT
);
268 for (const tdesc_type_field
&f
: e
->fields
)
270 int bitsize
= f
.end
- f
.start
+ 1;
272 gdb_assert (f
.type
!= NULL
);
273 type
*field_gdb_type
= make_gdb_type (m_gdbarch
, f
.type
);
274 append_flags_type_field (m_type
, f
.start
, bitsize
,
275 field_gdb_type
, f
.name
.c_str ());
279 void make_gdb_type_enum (const tdesc_type_with_fields
*e
)
281 m_type
= arch_type (m_gdbarch
, TYPE_CODE_ENUM
, e
->size
* TARGET_CHAR_BIT
,
284 TYPE_UNSIGNED (m_type
) = 1;
285 for (const tdesc_type_field
&f
: e
->fields
)
288 = append_composite_type_field_raw (m_type
,
289 xstrdup (f
.name
.c_str ()),
292 SET_FIELD_BITPOS (fld
[0], f
.start
);
296 /* The gdbarch used. */
297 struct gdbarch
*m_gdbarch
;
299 /* The type created. */
303 gdb_type_creator
gdb_type (gdbarch
);
304 ttype
->accept (gdb_type
);
305 return gdb_type
.get_type ();
308 /* A target description. */
310 struct target_desc
: tdesc_element
315 virtual ~target_desc () = default;
317 target_desc (const target_desc
&) = delete;
318 void operator= (const target_desc
&) = delete;
320 /* The architecture reported by the target, if any. */
321 const struct bfd_arch_info
*arch
= NULL
;
323 /* The osabi reported by the target, if any; GDB_OSABI_UNKNOWN
325 enum gdb_osabi osabi
= GDB_OSABI_UNKNOWN
;
327 /* The list of compatible architectures reported by the target. */
328 std::vector
<const bfd_arch_info
*> compatible
;
330 /* Any architecture-specific properties specified by the target. */
331 std::vector
<property
> properties
;
333 /* The features associated with this target. */
334 std::vector
<tdesc_feature_up
> features
;
336 /* Used to cache the generated xml version of the target description. */
337 mutable char *xmltarget
= nullptr;
339 void accept (tdesc_element_visitor
&v
) const override
343 for (const tdesc_feature_up
&feature
: features
)
349 bool operator== (const target_desc
&other
) const
351 if (arch
!= other
.arch
)
354 if (osabi
!= other
.osabi
)
357 if (features
.size () != other
.features
.size ())
360 for (int ix
= 0; ix
< features
.size (); ix
++)
362 const tdesc_feature_up
&feature1
= features
[ix
];
363 const tdesc_feature_up
&feature2
= other
.features
[ix
];
365 if (feature1
!= feature2
&& *feature1
!= *feature2
)
372 bool operator!= (const target_desc
&other
) const
374 return !(*this == other
);
378 /* Per-architecture data associated with a target description. The
379 target description may be shared by multiple architectures, but
380 this data is private to one gdbarch. */
382 struct tdesc_arch_reg
384 tdesc_arch_reg (tdesc_reg
*reg_
, struct type
*type_
)
385 : reg (reg_
), type (type_
)
388 struct tdesc_reg
*reg
;
392 struct tdesc_arch_data
394 /* A list of register/type pairs, indexed by GDB's internal register number.
395 During initialization of the gdbarch this list is used to store
396 registers which the architecture assigns a fixed register number.
397 Registers which are NULL in this array, or off the end, are
398 treated as zero-sized and nameless (i.e. placeholders in the
400 std::vector
<tdesc_arch_reg
> arch_regs
;
402 /* Functions which report the register name, type, and reggroups for
404 gdbarch_register_name_ftype
*pseudo_register_name
= NULL
;
405 gdbarch_register_type_ftype
*pseudo_register_type
= NULL
;
406 gdbarch_register_reggroup_p_ftype
*pseudo_register_reggroup_p
= NULL
;
409 /* Info about an inferior's target description. There's one of these
410 for each inferior. */
412 struct target_desc_info
414 /* A flag indicating that a description has already been fetched
415 from the target, so it should not be queried again. */
419 /* The description fetched from the target, or NULL if the target
420 did not supply any description. Only valid when
421 target_desc_fetched is set. Only the description initialization
422 code should access this; normally, the description should be
423 accessed through the gdbarch object. */
425 const struct target_desc
*tdesc
;
427 /* The filename to read a target description from, as set by "set
428 tdesc filename ..." */
433 /* Get the inferior INF's target description info, allocating one on
434 the stop if necessary. */
436 static struct target_desc_info
*
437 get_tdesc_info (struct inferior
*inf
)
439 if (inf
->tdesc_info
== NULL
)
440 inf
->tdesc_info
= XCNEW (struct target_desc_info
);
441 return inf
->tdesc_info
;
444 /* A handle for architecture-specific data associated with the
445 target description (see struct tdesc_arch_data). */
447 static struct gdbarch_data
*tdesc_data
;
449 /* See target-descriptions.h. */
452 target_desc_info_from_user_p (struct target_desc_info
*info
)
454 return info
!= NULL
&& info
->filename
!= NULL
;
457 /* See target-descriptions.h. */
460 copy_inferior_target_desc_info (struct inferior
*destinf
, struct inferior
*srcinf
)
462 struct target_desc_info
*src
= get_tdesc_info (srcinf
);
463 struct target_desc_info
*dest
= get_tdesc_info (destinf
);
465 dest
->fetched
= src
->fetched
;
466 dest
->tdesc
= src
->tdesc
;
467 dest
->filename
= src
->filename
!= NULL
? xstrdup (src
->filename
) : NULL
;
470 /* See target-descriptions.h. */
473 target_desc_info_free (struct target_desc_info
*tdesc_info
)
475 if (tdesc_info
!= NULL
)
477 xfree (tdesc_info
->filename
);
482 /* Convenience helper macros. */
484 #define target_desc_fetched \
485 get_tdesc_info (current_inferior ())->fetched
486 #define current_target_desc \
487 get_tdesc_info (current_inferior ())->tdesc
488 #define target_description_filename \
489 get_tdesc_info (current_inferior ())->filename
491 /* The string manipulated by the "set tdesc filename ..." command. */
493 static char *tdesc_filename_cmd_string
;
495 /* Fetch the current target's description, and switch the current
496 architecture to one which incorporates that description. */
499 target_find_description (void)
501 /* If we've already fetched a description from the target, don't do
502 it again. This allows a target to fetch the description early,
503 during its to_open or to_create_inferior, if it needs extra
504 information about the target to initialize. */
505 if (target_desc_fetched
)
508 /* The current architecture should not have any target description
509 specified. It should have been cleared, e.g. when we
510 disconnected from the previous target. */
511 gdb_assert (gdbarch_target_desc (target_gdbarch ()) == NULL
);
513 /* First try to fetch an XML description from the user-specified
515 current_target_desc
= NULL
;
516 if (target_description_filename
!= NULL
517 && *target_description_filename
!= '\0')
519 = file_read_description_xml (target_description_filename
);
521 /* Next try to read the description from the current target using
523 if (current_target_desc
== NULL
)
524 current_target_desc
= target_read_description_xml (¤t_target
);
526 /* If that failed try a target-specific hook. */
527 if (current_target_desc
== NULL
)
528 current_target_desc
= target_read_description (¤t_target
);
530 /* If a non-NULL description was returned, then update the current
532 if (current_target_desc
)
534 struct gdbarch_info info
;
536 gdbarch_info_init (&info
);
537 info
.target_desc
= current_target_desc
;
538 if (!gdbarch_update_p (info
))
539 warning (_("Architecture rejected target-supplied description"));
542 struct tdesc_arch_data
*data
;
544 data
= ((struct tdesc_arch_data
*)
545 gdbarch_data (target_gdbarch (), tdesc_data
));
546 if (tdesc_has_registers (current_target_desc
)
547 && data
->arch_regs
.empty ())
548 warning (_("Target-supplied registers are not supported "
549 "by the current architecture"));
553 /* Now that we know this description is usable, record that we
555 target_desc_fetched
= 1;
558 /* Discard any description fetched from the current target, and switch
559 the current architecture to one with no target description. */
562 target_clear_description (void)
564 struct gdbarch_info info
;
566 if (!target_desc_fetched
)
569 target_desc_fetched
= 0;
570 current_target_desc
= NULL
;
572 gdbarch_info_init (&info
);
573 if (!gdbarch_update_p (info
))
574 internal_error (__FILE__
, __LINE__
,
575 _("Could not remove target-supplied description"));
578 /* Return the global current target description. This should only be
579 used by gdbarch initialization code; most access should be through
580 an existing gdbarch. */
582 const struct target_desc
*
583 target_current_description (void)
585 if (target_desc_fetched
)
586 return current_target_desc
;
591 /* Return non-zero if this target description is compatible
592 with the given BFD architecture. */
595 tdesc_compatible_p (const struct target_desc
*target_desc
,
596 const struct bfd_arch_info
*arch
)
598 for (const bfd_arch_info
*compat
: target_desc
->compatible
)
601 || arch
->compatible (arch
, compat
)
602 || compat
->compatible (compat
, arch
))
610 /* Direct accessors for target descriptions. */
612 /* Return the string value of a property named KEY, or NULL if the
613 property was not specified. */
616 tdesc_property (const struct target_desc
*target_desc
, const char *key
)
618 for (const property
&prop
: target_desc
->properties
)
620 return prop
.value
.c_str ();
625 /* Return the BFD architecture associated with this target
626 description, or NULL if no architecture was specified. */
628 const struct bfd_arch_info
*
629 tdesc_architecture (const struct target_desc
*target_desc
)
631 return target_desc
->arch
;
634 /* See common/tdesc.h. */
637 tdesc_architecture_name (const struct target_desc
*target_desc
)
639 return target_desc
->arch
->printable_name
;
642 /* Return the OSABI associated with this target description, or
643 GDB_OSABI_UNKNOWN if no osabi was specified. */
646 tdesc_osabi (const struct target_desc
*target_desc
)
648 return target_desc
->osabi
;
651 /* See common/tdesc.h. */
654 tdesc_osabi_name (const struct target_desc
*target_desc
)
656 enum gdb_osabi osabi
= tdesc_osabi (target_desc
);
657 if (osabi
> GDB_OSABI_UNKNOWN
&& osabi
< GDB_OSABI_INVALID
)
658 return gdbarch_osabi_name (osabi
);
662 /* Return 1 if this target description includes any registers. */
665 tdesc_has_registers (const struct target_desc
*target_desc
)
667 if (target_desc
== NULL
)
670 for (const tdesc_feature_up
&feature
: target_desc
->features
)
671 if (!feature
->registers
.empty ())
677 /* Return the feature with the given name, if present, or NULL if
678 the named feature is not found. */
680 const struct tdesc_feature
*
681 tdesc_find_feature (const struct target_desc
*target_desc
,
684 for (const tdesc_feature_up
&feature
: target_desc
->features
)
685 if (feature
->name
== name
)
686 return feature
.get ();
691 /* Return the name of FEATURE. */
694 tdesc_feature_name (const struct tdesc_feature
*feature
)
696 return feature
->name
.c_str ();
699 /* Lookup type associated with ID. */
702 tdesc_find_type (struct gdbarch
*gdbarch
, const char *id
)
704 tdesc_arch_data
*data
705 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
707 for (const tdesc_arch_reg
®
: data
->arch_regs
)
710 && reg
.reg
->tdesc_type
712 && reg
.reg
->tdesc_type
->name
== id
)
719 /* Support for registers from target descriptions. */
721 /* Construct the per-gdbarch data. */
724 tdesc_data_init (struct obstack
*obstack
)
726 struct tdesc_arch_data
*data
;
728 data
= OBSTACK_ZALLOC (obstack
, struct tdesc_arch_data
);
729 new (data
) tdesc_arch_data ();
734 /* Similar, but for the temporary copy used during architecture
737 struct tdesc_arch_data
*
738 tdesc_data_alloc (void)
740 return new tdesc_arch_data ();
743 /* Free something allocated by tdesc_data_alloc, if it is not going
744 to be used (for instance if it was unsuitable for the
748 tdesc_data_cleanup (void *data_untyped
)
750 struct tdesc_arch_data
*data
= (struct tdesc_arch_data
*) data_untyped
;
755 /* Search FEATURE for a register named NAME. */
757 static struct tdesc_reg
*
758 tdesc_find_register_early (const struct tdesc_feature
*feature
,
761 for (const tdesc_reg_up
®
: feature
->registers
)
762 if (strcasecmp (reg
->name
.c_str (), name
) == 0)
768 /* Search FEATURE for a register named NAME. Assign REGNO to it. */
771 tdesc_numbered_register (const struct tdesc_feature
*feature
,
772 struct tdesc_arch_data
*data
,
773 int regno
, const char *name
)
775 struct tdesc_reg
*reg
= tdesc_find_register_early (feature
, name
);
780 /* Make sure the vector includes a REGNO'th element. */
781 while (regno
>= data
->arch_regs
.size ())
782 data
->arch_regs
.emplace_back (nullptr, nullptr);
784 data
->arch_regs
[regno
] = tdesc_arch_reg (reg
, NULL
);
789 /* Search FEATURE for a register named NAME, but do not assign a fixed
790 register number to it. */
793 tdesc_unnumbered_register (const struct tdesc_feature
*feature
,
796 struct tdesc_reg
*reg
= tdesc_find_register_early (feature
, name
);
804 /* Search FEATURE for a register whose name is in NAMES and assign
808 tdesc_numbered_register_choices (const struct tdesc_feature
*feature
,
809 struct tdesc_arch_data
*data
,
810 int regno
, const char *const names
[])
814 for (i
= 0; names
[i
] != NULL
; i
++)
815 if (tdesc_numbered_register (feature
, data
, regno
, names
[i
]))
821 /* Search FEATURE for a register named NAME, and return its size in
822 bits. The register must exist. */
825 tdesc_register_size (const struct tdesc_feature
*feature
,
828 struct tdesc_reg
*reg
= tdesc_find_register_early (feature
, name
);
830 gdb_assert (reg
!= NULL
);
834 /* Look up a register by its GDB internal register number. */
836 static struct tdesc_arch_reg
*
837 tdesc_find_arch_register (struct gdbarch
*gdbarch
, int regno
)
839 struct tdesc_arch_data
*data
;
841 data
= (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
842 if (regno
< data
->arch_regs
.size ())
843 return &data
->arch_regs
[regno
];
848 static struct tdesc_reg
*
849 tdesc_find_register (struct gdbarch
*gdbarch
, int regno
)
851 struct tdesc_arch_reg
*reg
= tdesc_find_arch_register (gdbarch
, regno
);
853 return reg
? reg
->reg
: NULL
;
856 /* Return the name of register REGNO, from the target description or
857 from an architecture-provided pseudo_register_name method. */
860 tdesc_register_name (struct gdbarch
*gdbarch
, int regno
)
862 struct tdesc_reg
*reg
= tdesc_find_register (gdbarch
, regno
);
863 int num_regs
= gdbarch_num_regs (gdbarch
);
864 int num_pseudo_regs
= gdbarch_num_pseudo_regs (gdbarch
);
867 return reg
->name
.c_str ();
869 if (regno
>= num_regs
&& regno
< num_regs
+ num_pseudo_regs
)
871 struct tdesc_arch_data
*data
872 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
874 gdb_assert (data
->pseudo_register_name
!= NULL
);
875 return data
->pseudo_register_name (gdbarch
, regno
);
882 tdesc_register_type (struct gdbarch
*gdbarch
, int regno
)
884 struct tdesc_arch_reg
*arch_reg
= tdesc_find_arch_register (gdbarch
, regno
);
885 struct tdesc_reg
*reg
= arch_reg
? arch_reg
->reg
: NULL
;
886 int num_regs
= gdbarch_num_regs (gdbarch
);
887 int num_pseudo_regs
= gdbarch_num_pseudo_regs (gdbarch
);
889 if (reg
== NULL
&& regno
>= num_regs
&& regno
< num_regs
+ num_pseudo_regs
)
891 struct tdesc_arch_data
*data
892 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
894 gdb_assert (data
->pseudo_register_type
!= NULL
);
895 return data
->pseudo_register_type (gdbarch
, regno
);
899 /* Return "int0_t", since "void" has a misleading size of one. */
900 return builtin_type (gdbarch
)->builtin_int0
;
902 if (arch_reg
->type
== NULL
)
904 /* First check for a predefined or target defined type. */
906 arch_reg
->type
= make_gdb_type (gdbarch
, reg
->tdesc_type
);
908 /* Next try size-sensitive type shortcuts. */
909 else if (reg
->type
== "float")
911 if (reg
->bitsize
== gdbarch_float_bit (gdbarch
))
912 arch_reg
->type
= builtin_type (gdbarch
)->builtin_float
;
913 else if (reg
->bitsize
== gdbarch_double_bit (gdbarch
))
914 arch_reg
->type
= builtin_type (gdbarch
)->builtin_double
;
915 else if (reg
->bitsize
== gdbarch_long_double_bit (gdbarch
))
916 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long_double
;
919 warning (_("Register \"%s\" has an unsupported size (%d bits)"),
920 reg
->name
.c_str (), reg
->bitsize
);
921 arch_reg
->type
= builtin_type (gdbarch
)->builtin_double
;
924 else if (reg
->type
== "int")
926 if (reg
->bitsize
== gdbarch_long_bit (gdbarch
))
927 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long
;
928 else if (reg
->bitsize
== TARGET_CHAR_BIT
)
929 arch_reg
->type
= builtin_type (gdbarch
)->builtin_char
;
930 else if (reg
->bitsize
== gdbarch_short_bit (gdbarch
))
931 arch_reg
->type
= builtin_type (gdbarch
)->builtin_short
;
932 else if (reg
->bitsize
== gdbarch_int_bit (gdbarch
))
933 arch_reg
->type
= builtin_type (gdbarch
)->builtin_int
;
934 else if (reg
->bitsize
== gdbarch_long_long_bit (gdbarch
))
935 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long_long
;
936 else if (reg
->bitsize
== gdbarch_ptr_bit (gdbarch
))
937 /* A bit desperate by this point... */
938 arch_reg
->type
= builtin_type (gdbarch
)->builtin_data_ptr
;
941 warning (_("Register \"%s\" has an unsupported size (%d bits)"),
942 reg
->name
.c_str (), reg
->bitsize
);
943 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long
;
947 if (arch_reg
->type
== NULL
)
948 internal_error (__FILE__
, __LINE__
,
949 "Register \"%s\" has an unknown type \"%s\"",
950 reg
->name
.c_str (), reg
->type
.c_str ());
953 return arch_reg
->type
;
957 tdesc_remote_register_number (struct gdbarch
*gdbarch
, int regno
)
959 struct tdesc_reg
*reg
= tdesc_find_register (gdbarch
, regno
);
962 return reg
->target_regnum
;
967 /* Check whether REGNUM is a member of REGGROUP. Registers from the
968 target description may be classified as general, float, vector or other
969 register groups registered with reggroup_add(). Unlike a gdbarch
970 register_reggroup_p method, this function will return -1 if it does not
971 know; the caller should handle registers with no specified group.
973 The names of containing features are not used. This might be extended
974 to display registers in some more useful groupings.
976 The save-restore flag is also implemented here. */
979 tdesc_register_in_reggroup_p (struct gdbarch
*gdbarch
, int regno
,
980 struct reggroup
*reggroup
)
982 struct tdesc_reg
*reg
= tdesc_find_register (gdbarch
, regno
);
984 if (reg
!= NULL
&& !reg
->group
.empty ()
985 && (reg
->group
== reggroup_name (reggroup
)))
989 && (reggroup
== save_reggroup
|| reggroup
== restore_reggroup
))
990 return reg
->save_restore
;
995 /* Check whether REGNUM is a member of REGGROUP. Registers with no
996 group specified go to the default reggroup function and are handled
1000 tdesc_register_reggroup_p (struct gdbarch
*gdbarch
, int regno
,
1001 struct reggroup
*reggroup
)
1003 int num_regs
= gdbarch_num_regs (gdbarch
);
1004 int num_pseudo_regs
= gdbarch_num_pseudo_regs (gdbarch
);
1007 if (regno
>= num_regs
&& regno
< num_regs
+ num_pseudo_regs
)
1009 struct tdesc_arch_data
*data
1010 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1012 if (data
->pseudo_register_reggroup_p
!= NULL
)
1013 return data
->pseudo_register_reggroup_p (gdbarch
, regno
, reggroup
);
1014 /* Otherwise fall through to the default reggroup_p. */
1017 ret
= tdesc_register_in_reggroup_p (gdbarch
, regno
, reggroup
);
1021 return default_register_reggroup_p (gdbarch
, regno
, reggroup
);
1024 /* Record architecture-specific functions to call for pseudo-register
1028 set_tdesc_pseudo_register_name (struct gdbarch
*gdbarch
,
1029 gdbarch_register_name_ftype
*pseudo_name
)
1031 struct tdesc_arch_data
*data
1032 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1034 data
->pseudo_register_name
= pseudo_name
;
1038 set_tdesc_pseudo_register_type (struct gdbarch
*gdbarch
,
1039 gdbarch_register_type_ftype
*pseudo_type
)
1041 struct tdesc_arch_data
*data
1042 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1044 data
->pseudo_register_type
= pseudo_type
;
1048 set_tdesc_pseudo_register_reggroup_p
1049 (struct gdbarch
*gdbarch
,
1050 gdbarch_register_reggroup_p_ftype
*pseudo_reggroup_p
)
1052 struct tdesc_arch_data
*data
1053 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1055 data
->pseudo_register_reggroup_p
= pseudo_reggroup_p
;
1058 /* Update GDBARCH to use the target description for registers. */
1061 tdesc_use_registers (struct gdbarch
*gdbarch
,
1062 const struct target_desc
*target_desc
,
1063 struct tdesc_arch_data
*early_data
)
1065 int num_regs
= gdbarch_num_regs (gdbarch
);
1066 struct tdesc_arch_data
*data
;
1069 /* We can't use the description for registers if it doesn't describe
1070 any. This function should only be called after validating
1071 registers, so the caller should know that registers are
1073 gdb_assert (tdesc_has_registers (target_desc
));
1075 data
= (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1076 data
->arch_regs
= early_data
->arch_regs
;
1079 /* Build up a set of all registers, so that we can assign register
1080 numbers where needed. The hash table expands as necessary, so
1081 the initial size is arbitrary. */
1082 reg_hash
= htab_create (37, htab_hash_pointer
, htab_eq_pointer
, NULL
);
1083 for (const tdesc_feature_up
&feature
: target_desc
->features
)
1084 for (const tdesc_reg_up
®
: feature
->registers
)
1086 void **slot
= htab_find_slot (reg_hash
, reg
.get (), INSERT
);
1089 /* Add reggroup if its new. */
1090 if (!reg
->group
.empty ())
1091 if (reggroup_find (gdbarch
, reg
->group
.c_str ()) == NULL
)
1092 reggroup_add (gdbarch
, reggroup_gdbarch_new (gdbarch
,
1093 reg
->group
.c_str (),
1097 /* Remove any registers which were assigned numbers by the
1099 for (const tdesc_arch_reg
&arch_reg
: data
->arch_regs
)
1100 if (arch_reg
.reg
!= NULL
)
1101 htab_remove_elt (reg_hash
, arch_reg
.reg
);
1103 /* Assign numbers to the remaining registers and add them to the
1104 list of registers. The new numbers are always above gdbarch_num_regs.
1105 Iterate over the features, not the hash table, so that the order
1106 matches that in the target description. */
1108 gdb_assert (data
->arch_regs
.size () <= num_regs
);
1109 while (data
->arch_regs
.size () < num_regs
)
1110 data
->arch_regs
.emplace_back (nullptr, nullptr);
1112 for (const tdesc_feature_up
&feature
: target_desc
->features
)
1113 for (const tdesc_reg_up
®
: feature
->registers
)
1114 if (htab_find (reg_hash
, reg
.get ()) != NULL
)
1116 data
->arch_regs
.emplace_back (reg
.get (), nullptr);
1120 htab_delete (reg_hash
);
1122 /* Update the architecture. */
1123 set_gdbarch_num_regs (gdbarch
, num_regs
);
1124 set_gdbarch_register_name (gdbarch
, tdesc_register_name
);
1125 set_gdbarch_register_type (gdbarch
, tdesc_register_type
);
1126 set_gdbarch_remote_register_number (gdbarch
,
1127 tdesc_remote_register_number
);
1128 set_gdbarch_register_reggroup_p (gdbarch
, tdesc_register_reggroup_p
);
1131 /* See common/tdesc.h. */
1133 struct tdesc_feature
*
1134 tdesc_create_feature (struct target_desc
*tdesc
, const char *name
)
1136 struct tdesc_feature
*new_feature
= new tdesc_feature (name
);
1138 tdesc
->features
.emplace_back (new_feature
);
1143 struct target_desc
*
1144 allocate_target_description (void)
1146 return new target_desc ();
1150 free_target_description (void *arg
)
1152 struct target_desc
*target_desc
= (struct target_desc
*) arg
;
1158 make_cleanup_free_target_description (struct target_desc
*target_desc
)
1160 return make_cleanup (free_target_description
, target_desc
);
1164 tdesc_add_compatible (struct target_desc
*target_desc
,
1165 const struct bfd_arch_info
*compatible
)
1167 /* If this instance of GDB is compiled without BFD support for the
1168 compatible architecture, simply ignore it -- we would not be able
1169 to handle it anyway. */
1170 if (compatible
== NULL
)
1173 for (const bfd_arch_info
*compat
: target_desc
->compatible
)
1174 if (compat
== compatible
)
1175 internal_error (__FILE__
, __LINE__
,
1176 _("Attempted to add duplicate "
1177 "compatible architecture \"%s\""),
1178 compatible
->printable_name
);
1180 target_desc
->compatible
.push_back (compatible
);
1184 set_tdesc_property (struct target_desc
*target_desc
,
1185 const char *key
, const char *value
)
1187 gdb_assert (key
!= NULL
&& value
!= NULL
);
1189 if (tdesc_property (target_desc
, key
) != NULL
)
1190 internal_error (__FILE__
, __LINE__
,
1191 _("Attempted to add duplicate property \"%s\""), key
);
1193 target_desc
->properties
.emplace_back (key
, value
);
1196 /* See common/tdesc.h. */
1199 set_tdesc_architecture (struct target_desc
*target_desc
,
1202 set_tdesc_architecture (target_desc
, bfd_scan_arch (name
));
1206 set_tdesc_architecture (struct target_desc
*target_desc
,
1207 const struct bfd_arch_info
*arch
)
1209 target_desc
->arch
= arch
;
1212 /* See common/tdesc.h. */
1215 set_tdesc_osabi (struct target_desc
*target_desc
, const char *name
)
1217 set_tdesc_osabi (target_desc
, osabi_from_tdesc_string (name
));
1221 set_tdesc_osabi (struct target_desc
*target_desc
, enum gdb_osabi osabi
)
1223 target_desc
->osabi
= osabi
;
1227 static struct cmd_list_element
*tdesc_set_cmdlist
, *tdesc_show_cmdlist
;
1228 static struct cmd_list_element
*tdesc_unset_cmdlist
;
1230 /* Helper functions for the CLI commands. */
1233 set_tdesc_cmd (const char *args
, int from_tty
)
1235 help_list (tdesc_set_cmdlist
, "set tdesc ", all_commands
, gdb_stdout
);
1239 show_tdesc_cmd (const char *args
, int from_tty
)
1241 cmd_show_list (tdesc_show_cmdlist
, from_tty
, "");
1245 unset_tdesc_cmd (const char *args
, int from_tty
)
1247 help_list (tdesc_unset_cmdlist
, "unset tdesc ", all_commands
, gdb_stdout
);
1251 set_tdesc_filename_cmd (const char *args
, int from_tty
,
1252 struct cmd_list_element
*c
)
1254 xfree (target_description_filename
);
1255 target_description_filename
= xstrdup (tdesc_filename_cmd_string
);
1257 target_clear_description ();
1258 target_find_description ();
1262 show_tdesc_filename_cmd (struct ui_file
*file
, int from_tty
,
1263 struct cmd_list_element
*c
,
1266 value
= target_description_filename
;
1268 if (value
!= NULL
&& *value
!= '\0')
1269 printf_filtered (_("The target description will be read from \"%s\".\n"),
1272 printf_filtered (_("The target description will be "
1273 "read from the target.\n"));
1277 unset_tdesc_filename_cmd (const char *args
, int from_tty
)
1279 xfree (target_description_filename
);
1280 target_description_filename
= NULL
;
1281 target_clear_description ();
1282 target_find_description ();
1285 /* Print target description in C. */
1287 class print_c_tdesc
: public tdesc_element_visitor
1290 print_c_tdesc (std::string
&filename_after_features
)
1291 : m_filename_after_features (filename_after_features
)
1295 const char *filename
= lbasename (m_filename_after_features
.c_str ());
1297 m_function
= (char *) xmalloc (strlen (filename
) + 1);
1298 for (inp
= filename
, outp
= m_function
; *inp
!= '\0'; inp
++)
1301 else if (*inp
== '-')
1307 /* Standard boilerplate. */
1308 printf_unfiltered ("/* THIS FILE IS GENERATED. "
1309 "-*- buffer-read-only: t -*- vi"
1318 void visit_pre (const target_desc
*e
) override
1320 printf_unfiltered (" Original: %s */\n\n",
1321 lbasename (m_filename_after_features
.c_str ()));
1323 printf_unfiltered ("#include \"defs.h\"\n");
1324 printf_unfiltered ("#include \"osabi.h\"\n");
1325 printf_unfiltered ("#include \"target-descriptions.h\"\n");
1326 printf_unfiltered ("\n");
1328 printf_unfiltered ("struct target_desc *tdesc_%s;\n", m_function
);
1329 printf_unfiltered ("static void\n");
1330 printf_unfiltered ("initialize_tdesc_%s (void)\n", m_function
);
1331 printf_unfiltered ("{\n");
1333 (" struct target_desc *result = allocate_target_description ();\n");
1335 if (tdesc_architecture (e
) != NULL
)
1338 (" set_tdesc_architecture (result, bfd_scan_arch (\"%s\"));\n",
1339 tdesc_architecture (e
)->printable_name
);
1340 printf_unfiltered ("\n");
1342 if (tdesc_osabi (e
) > GDB_OSABI_UNKNOWN
1343 && tdesc_osabi (e
) < GDB_OSABI_INVALID
)
1346 (" set_tdesc_osabi (result, osabi_from_tdesc_string (\"%s\"));\n",
1347 gdbarch_osabi_name (tdesc_osabi (e
)));
1348 printf_unfiltered ("\n");
1351 for (const bfd_arch_info_type
*compatible
: e
->compatible
)
1353 (" tdesc_add_compatible (result, bfd_scan_arch (\"%s\"));\n",
1354 compatible
->printable_name
);
1356 if (!e
->compatible
.empty ())
1357 printf_unfiltered ("\n");
1359 for (const property
&prop
: e
->properties
)
1360 printf_unfiltered (" set_tdesc_property (result, \"%s\", \"%s\");\n",
1361 prop
.key
.c_str (), prop
.value
.c_str ());
1363 printf_unfiltered (" struct tdesc_feature *feature;\n");
1366 void visit_pre (const tdesc_feature
*e
) override
1368 printf_unfiltered ("\n feature = tdesc_create_feature (result, \"%s\");\n",
1372 void visit_post (const tdesc_feature
*e
) override
1375 void visit_post (const target_desc
*e
) override
1377 printf_unfiltered ("\n tdesc_%s = result;\n", m_function
);
1378 printf_unfiltered ("}\n");
1381 void visit (const tdesc_type_builtin
*type
) override
1383 error (_("C output is not supported type \"%s\"."), type
->name
.c_str ());
1386 void visit (const tdesc_type_vector
*type
) override
1388 if (!m_printed_element_type
)
1390 printf_unfiltered (" tdesc_type *element_type;\n");
1391 m_printed_element_type
= true;
1395 (" element_type = tdesc_named_type (feature, \"%s\");\n",
1396 type
->element_type
->name
.c_str ());
1398 (" tdesc_create_vector (feature, \"%s\", element_type, %d);\n",
1399 type
->name
.c_str (), type
->count
);
1401 printf_unfiltered ("\n");
1404 void visit (const tdesc_type_with_fields
*type
) override
1406 if (!m_printed_type_with_fields
)
1408 printf_unfiltered (" tdesc_type_with_fields *type_with_fields;\n");
1409 m_printed_type_with_fields
= true;
1414 case TDESC_TYPE_STRUCT
:
1415 case TDESC_TYPE_FLAGS
:
1416 if (type
->kind
== TDESC_TYPE_STRUCT
)
1419 (" type_with_fields = tdesc_create_struct (feature, \"%s\");\n",
1420 type
->name
.c_str ());
1421 if (type
->size
!= 0)
1423 (" tdesc_set_struct_size (type_with_fields, %d);\n", type
->size
);
1428 (" type_with_fields = tdesc_create_flags (feature, \"%s\", %d);\n",
1429 type
->name
.c_str (), type
->size
);
1431 for (const tdesc_type_field
&f
: type
->fields
)
1433 const char *type_name
;
1435 gdb_assert (f
.type
!= NULL
);
1436 type_name
= f
.type
->name
.c_str ();
1438 /* To minimize changes to generated files, don't emit type
1439 info for fields that have defaulted types. */
1442 gdb_assert (f
.end
!= -1);
1443 if (f
.type
->kind
== TDESC_TYPE_BOOL
)
1445 gdb_assert (f
.start
== f
.end
);
1447 (" tdesc_add_flag (type_with_fields, %d, \"%s\");\n",
1448 f
.start
, f
.name
.c_str ());
1450 else if ((type
->size
== 4 && f
.type
->kind
== TDESC_TYPE_UINT32
)
1452 && f
.type
->kind
== TDESC_TYPE_UINT64
))
1455 (" tdesc_add_bitfield (type_with_fields, \"%s\", %d, %d);\n",
1456 f
.name
.c_str (), f
.start
, f
.end
);
1460 printf_field_type_assignment
1461 ("tdesc_named_type (feature, \"%s\");\n",
1464 (" tdesc_add_typed_bitfield (type_with_fields, \"%s\","
1465 " %d, %d, field_type);\n",
1466 f
.name
.c_str (), f
.start
, f
.end
);
1469 else /* Not a bitfield. */
1471 gdb_assert (f
.end
== -1);
1472 gdb_assert (type
->kind
== TDESC_TYPE_STRUCT
);
1473 printf_field_type_assignment
1474 ("tdesc_named_type (feature, \"%s\");\n", type_name
);
1476 (" tdesc_add_field (type_with_fields, \"%s\", field_type);\n",
1481 case TDESC_TYPE_UNION
:
1483 (" type_with_fields = tdesc_create_union (feature, \"%s\");\n",
1484 type
->name
.c_str ());
1485 for (const tdesc_type_field
&f
: type
->fields
)
1487 printf_field_type_assignment
1488 ("tdesc_named_type (feature, \"%s\");\n", f
.type
->name
.c_str ());
1490 (" tdesc_add_field (type_with_fields, \"%s\", field_type);\n",
1494 case TDESC_TYPE_ENUM
:
1496 (" type_with_fields = tdesc_create_enum (feature, \"%s\", %d);\n",
1497 type
->name
.c_str (), type
->size
);
1498 for (const tdesc_type_field
&f
: type
->fields
)
1500 (" tdesc_add_enum_value (type_with_fields, %d, \"%s\");\n",
1501 f
.start
, f
.name
.c_str ());
1504 error (_("C output is not supported type \"%s\"."), type
->name
.c_str ());
1507 printf_unfiltered ("\n");
1510 void visit (const tdesc_reg
*reg
) override
1512 printf_unfiltered (" tdesc_create_reg (feature, \"%s\", %ld, %d, ",
1513 reg
->name
.c_str (), reg
->target_regnum
,
1515 if (!reg
->group
.empty ())
1516 printf_unfiltered ("\"%s\", ", reg
->group
.c_str ());
1518 printf_unfiltered ("NULL, ");
1519 printf_unfiltered ("%d, \"%s\");\n", reg
->bitsize
, reg
->type
.c_str ());
1523 std::string m_filename_after_features
;
1527 /* Print an assignment to the field_type variable. Print the declaration
1528 of field_type if that has not been done yet. */
1529 ATTRIBUTE_PRINTF (2, 3)
1530 void printf_field_type_assignment (const char *fmt
, ...)
1532 if (!m_printed_field_type
)
1534 printf_unfiltered (" tdesc_type *field_type;\n");
1535 m_printed_field_type
= true;
1538 printf_unfiltered (" field_type = ");
1541 va_start (args
, fmt
);
1542 vprintf_unfiltered (fmt
, args
);
1548 /* Did we print "struct tdesc_type *element_type;" yet? */
1549 bool m_printed_element_type
= false;
1551 /* Did we print "struct tdesc_type_with_fields *element_type;" yet? */
1552 bool m_printed_type_with_fields
= false;
1554 /* Did we print "struct tdesc_type *field_type;" yet? */
1555 bool m_printed_field_type
= false;
1558 /* Print target description feature in C. */
1560 class print_c_feature
: public print_c_tdesc
1563 print_c_feature (std::string
&file
)
1564 : print_c_tdesc (file
)
1567 auto const pos
= m_filename_after_features
.find_last_of ('.');
1569 m_filename_after_features
= m_filename_after_features
.substr (0, pos
);
1572 void visit_pre (const target_desc
*e
) override
1574 printf_unfiltered (" Original: %s */\n\n",
1575 lbasename (m_filename_after_features
.c_str ()));
1577 printf_unfiltered ("#include \"common/tdesc.h\"\n");
1578 printf_unfiltered ("\n");
1581 void visit_post (const target_desc
*e
) override
1584 void visit_pre (const tdesc_feature
*e
) override
1586 std::string
name (m_filename_after_features
);
1588 auto pos
= name
.find_first_of ('.');
1590 name
= name
.substr (0, pos
);
1591 std::replace (name
.begin (), name
.end (), '/', '_');
1592 std::replace (name
.begin (), name
.end (), '-', '_');
1594 printf_unfiltered ("static int\n");
1595 printf_unfiltered ("create_feature_%s ", name
.c_str ());
1596 printf_unfiltered ("(struct target_desc *result, long regnum)\n");
1598 printf_unfiltered ("{\n");
1599 printf_unfiltered (" struct tdesc_feature *feature;\n");
1602 ("\n feature = tdesc_create_feature (result, \"%s\");\n",
1606 void visit_post (const tdesc_feature
*e
) override
1608 printf_unfiltered (" return regnum;\n");
1609 printf_unfiltered ("}\n");
1612 void visit (const tdesc_reg
*reg
) override
1614 /* Most "reg" in XML target descriptions don't have "regnum"
1615 attribute, so the register number is allocated sequentially.
1616 In case that reg has "regnum" attribute, register number
1617 should be set by that explicitly. */
1619 if (reg
->target_regnum
< m_next_regnum
)
1621 /* The integrity check, it can catch some errors on register
1622 number collision, like this,
1624 <reg name="x0" bitsize="32"/>
1625 <reg name="x1" bitsize="32"/>
1626 <reg name="x2" bitsize="32"/>
1627 <reg name="x3" bitsize="32"/>
1628 <reg name="ps" bitsize="32" regnum="3"/>
1630 but it also has false negatives. The target description
1633 <reg name="x1" bitsize="32" regnum="1"/>
1634 <reg name="x3" bitsize="32" regnum="3"/>
1635 <reg name="x2" bitsize="32" regnum="2"/>
1636 <reg name="x4" bitsize="32" regnum="4"/>
1638 but it is not a good practice, so still error on this,
1639 and also print the message so that it can be saved in the
1640 generated c file. */
1642 printf_unfiltered ("ERROR: \"regnum\" attribute %ld ",
1643 reg
->target_regnum
);
1644 printf_unfiltered ("is not the largest number (%d).\n",
1646 error (_("\"regnum\" attribute %ld is not the largest number (%d)."),
1647 reg
->target_regnum
, m_next_regnum
);
1650 if (reg
->target_regnum
> m_next_regnum
)
1652 printf_unfiltered (" regnum = %ld;\n", reg
->target_regnum
);
1653 m_next_regnum
= reg
->target_regnum
;
1656 printf_unfiltered (" tdesc_create_reg (feature, \"%s\", regnum++, %d, ",
1657 reg
->name
.c_str (), reg
->save_restore
);
1658 if (!reg
->group
.empty ())
1659 printf_unfiltered ("\"%s\", ", reg
->group
.c_str ());
1661 printf_unfiltered ("NULL, ");
1662 printf_unfiltered ("%d, \"%s\");\n", reg
->bitsize
, reg
->type
.c_str ());
1668 /* The register number to use for the next register we see. */
1669 int m_next_regnum
= 0;
1672 /* See common/tdesc.h. */
1675 tdesc_get_features_xml (const target_desc
*tdesc
)
1677 if (tdesc
->xmltarget
== nullptr)
1679 std::string
buffer ("@");
1680 print_xml_feature
v (&buffer
);
1682 tdesc
->xmltarget
= xstrdup (buffer
.c_str ());
1684 return tdesc
->xmltarget
;
1688 maint_print_c_tdesc_cmd (const char *args
, int from_tty
)
1690 const struct target_desc
*tdesc
;
1691 const char *filename
;
1695 /* Use the global target-supplied description, not the current
1696 architecture's. This lets a GDB for one architecture generate C
1697 for another architecture's description, even though the gdbarch
1698 initialization code will reject the new description. */
1699 tdesc
= current_target_desc
;
1700 filename
= target_description_filename
;
1704 /* Use the target description from the XML file. */
1706 tdesc
= file_read_description_xml (filename
);
1710 error (_("There is no target description to print."));
1712 if (filename
== NULL
)
1713 error (_("The current target description did not come from an XML file."));
1715 std::string
filename_after_features (filename
);
1716 auto loc
= filename_after_features
.rfind ("/features/");
1718 if (loc
!= std::string::npos
)
1719 filename_after_features
= filename_after_features
.substr (loc
+ 10);
1721 /* Print c files for target features instead of target descriptions,
1722 because c files got from target features are more flexible than the
1724 if (startswith (filename_after_features
.c_str (), "i386/32bit-")
1725 || startswith (filename_after_features
.c_str (), "i386/64bit-")
1726 || startswith (filename_after_features
.c_str (), "i386/x32-core.xml")
1727 || startswith (filename_after_features
.c_str (), "tic6x-")
1728 || startswith (filename_after_features
.c_str (), "aarch64"))
1730 print_c_feature
v (filename_after_features
);
1736 print_c_tdesc
v (filename_after_features
);
1742 namespace selftests
{
1744 static std::vector
<std::pair
<const char*, const target_desc
*>> xml_tdesc
;
1748 /* See target-descritpions.h. */
1751 record_xml_tdesc (const char *xml_file
, const struct target_desc
*tdesc
)
1753 xml_tdesc
.emplace_back (xml_file
, tdesc
);
1759 /* Test the convesion process of a target description to/from xml: Take a target
1760 description TDESC, convert to xml, back to a description, and confirm the new
1761 tdesc is identical to the original. */
1763 maintenance_check_tdesc_xml_convert (const target_desc
*tdesc
, const char *name
)
1765 const char *xml
= tdesc_get_features_xml (tdesc
);
1767 if (xml
== nullptr || *xml
!= '@')
1769 printf_filtered (_("Could not convert description for %s to xml.\n"),
1774 const target_desc
*tdesc_trans
= string_read_description_xml (xml
+ 1);
1776 if (tdesc_trans
== nullptr)
1778 printf_filtered (_("Could not convert description for %s from xml.\n"),
1782 else if (*tdesc
!= *tdesc_trans
)
1784 printf_filtered (_("Converted description for %s does not match.\n"),
1792 /* Check that the target descriptions created dynamically by
1793 architecture-specific code equal the descriptions created from XML files
1794 found in the specified directory DIR. */
1797 maintenance_check_xml_descriptions (const char *dir
, int from_tty
)
1800 error (_("Missing dir name"));
1802 gdb::unique_xmalloc_ptr
<char> dir1 (tilde_expand (dir
));
1803 std::string
feature_dir (dir1
.get ());
1804 unsigned int failed
= 0;
1806 for (auto const &e
: selftests::xml_tdesc
)
1808 std::string tdesc_xml
= (feature_dir
+ SLASH_STRING
+ e
.first
);
1809 const target_desc
*tdesc
1810 = file_read_description_xml (tdesc_xml
.data ());
1812 if (tdesc
== NULL
|| *tdesc
!= *e
.second
)
1814 printf_filtered ( _("Descriptions for %s do not match.\n"), e
.first
);
1817 else if (!maintenance_check_tdesc_xml_convert (tdesc
, e
.first
)
1818 || !maintenance_check_tdesc_xml_convert (e
.second
, e
.first
))
1821 printf_filtered (_("Tested %lu XML files, %d failed\n"),
1822 (long) selftests::xml_tdesc
.size (), failed
);
1826 _initialize_target_descriptions (void)
1828 tdesc_data
= gdbarch_data_register_pre_init (tdesc_data_init
);
1830 add_prefix_cmd ("tdesc", class_maintenance
, set_tdesc_cmd
, _("\
1831 Set target description specific variables."),
1832 &tdesc_set_cmdlist
, "set tdesc ",
1833 0 /* allow-unknown */, &setlist
);
1834 add_prefix_cmd ("tdesc", class_maintenance
, show_tdesc_cmd
, _("\
1835 Show target description specific variables."),
1836 &tdesc_show_cmdlist
, "show tdesc ",
1837 0 /* allow-unknown */, &showlist
);
1838 add_prefix_cmd ("tdesc", class_maintenance
, unset_tdesc_cmd
, _("\
1839 Unset target description specific variables."),
1840 &tdesc_unset_cmdlist
, "unset tdesc ",
1841 0 /* allow-unknown */, &unsetlist
);
1843 add_setshow_filename_cmd ("filename", class_obscure
,
1844 &tdesc_filename_cmd_string
,
1846 Set the file to read for an XML target description"), _("\
1847 Show the file to read for an XML target description"), _("\
1848 When set, GDB will read the target description from a local\n\
1849 file instead of querying the remote target."),
1850 set_tdesc_filename_cmd
,
1851 show_tdesc_filename_cmd
,
1852 &tdesc_set_cmdlist
, &tdesc_show_cmdlist
);
1854 add_cmd ("filename", class_obscure
, unset_tdesc_filename_cmd
, _("\
1855 Unset the file to read for an XML target description. When unset,\n\
1856 GDB will read the description from the target."),
1857 &tdesc_unset_cmdlist
);
1859 add_cmd ("c-tdesc", class_maintenance
, maint_print_c_tdesc_cmd
, _("\
1860 Print the current target description as a C source file."),
1861 &maintenanceprintlist
);
1863 cmd_list_element
*cmd
;
1865 cmd
= add_cmd ("xml-descriptions", class_maintenance
,
1866 maintenance_check_xml_descriptions
, _("\
1867 Check the target descriptions created in GDB equal the descriptions\n\
1868 created from XML files in the directory.\n\
1869 The parameter is the directory name."),
1870 &maintenancechecklist
);
1871 set_cmd_completer (cmd
, filename_completer
);