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 ());
193 for (const tdesc_type_field
&f
: e
->fields
)
195 if (f
.start
!= -1 && f
.end
!= -1)
199 struct type
*field_gdb_type
;
200 int bitsize
, total_size
;
202 /* This invariant should be preserved while creating types. */
203 gdb_assert (e
->size
!= 0);
205 field_gdb_type
= make_gdb_type (m_gdbarch
, f
.type
);
206 else if (e
->size
> 4)
207 field_gdb_type
= builtin_type (m_gdbarch
)->builtin_uint64
;
209 field_gdb_type
= builtin_type (m_gdbarch
)->builtin_uint32
;
211 fld
= append_composite_type_field_raw
212 (m_type
, xstrdup (f
.name
.c_str ()), field_gdb_type
);
214 /* For little-endian, BITPOS counts from the LSB of
215 the structure and marks the LSB of the field. For
216 big-endian, BITPOS counts from the MSB of the
217 structure and marks the MSB of the field. Either
218 way, it is the number of bits to the "left" of the
219 field. To calculate this in big-endian, we need
220 the total size of the structure. */
221 bitsize
= f
.end
- f
.start
+ 1;
222 total_size
= e
->size
* TARGET_CHAR_BIT
;
223 if (gdbarch_bits_big_endian (m_gdbarch
))
224 SET_FIELD_BITPOS (fld
[0], total_size
- f
.start
- bitsize
);
226 SET_FIELD_BITPOS (fld
[0], f
.start
);
227 FIELD_BITSIZE (fld
[0]) = bitsize
;
231 gdb_assert (f
.start
== -1 && f
.end
== -1);
232 type
*field_gdb_type
= make_gdb_type (m_gdbarch
, f
.type
);
233 append_composite_type_field (m_type
,
234 xstrdup (f
.name
.c_str ()),
240 TYPE_LENGTH (m_type
) = e
->size
;
243 void make_gdb_type_union (const tdesc_type_with_fields
*e
)
245 m_type
= arch_composite_type (m_gdbarch
, NULL
, TYPE_CODE_UNION
);
246 TYPE_NAME (m_type
) = xstrdup (e
->name
.c_str ());
248 for (const tdesc_type_field
&f
: e
->fields
)
250 type
* field_gdb_type
= make_gdb_type (m_gdbarch
, f
.type
);
251 append_composite_type_field (m_type
, xstrdup (f
.name
.c_str ()),
254 /* If any of the children of a union are vectors, flag the
255 union as a vector also. This allows e.g. a union of two
256 vector types to show up automatically in "info vector". */
257 if (TYPE_VECTOR (field_gdb_type
))
258 TYPE_VECTOR (m_type
) = 1;
262 void make_gdb_type_flags (const tdesc_type_with_fields
*e
)
264 m_type
= arch_flags_type (m_gdbarch
, e
->name
.c_str (),
265 e
->size
* TARGET_CHAR_BIT
);
267 for (const tdesc_type_field
&f
: e
->fields
)
269 int bitsize
= f
.end
- f
.start
+ 1;
271 gdb_assert (f
.type
!= NULL
);
272 type
*field_gdb_type
= make_gdb_type (m_gdbarch
, f
.type
);
273 append_flags_type_field (m_type
, f
.start
, bitsize
,
274 field_gdb_type
, f
.name
.c_str ());
278 void make_gdb_type_enum (const tdesc_type_with_fields
*e
)
280 m_type
= arch_type (m_gdbarch
, TYPE_CODE_ENUM
, e
->size
* TARGET_CHAR_BIT
,
283 TYPE_UNSIGNED (m_type
) = 1;
284 for (const tdesc_type_field
&f
: e
->fields
)
287 = append_composite_type_field_raw (m_type
,
288 xstrdup (f
.name
.c_str ()),
291 SET_FIELD_BITPOS (fld
[0], f
.start
);
295 /* The gdbarch used. */
296 struct gdbarch
*m_gdbarch
;
298 /* The type created. */
302 gdb_type_creator
gdb_type (gdbarch
);
303 ttype
->accept (gdb_type
);
304 return gdb_type
.get_type ();
307 /* A target description. */
309 struct target_desc
: tdesc_element
314 virtual ~target_desc () = default;
316 target_desc (const target_desc
&) = delete;
317 void operator= (const target_desc
&) = delete;
319 /* The architecture reported by the target, if any. */
320 const struct bfd_arch_info
*arch
= NULL
;
322 /* The osabi reported by the target, if any; GDB_OSABI_UNKNOWN
324 enum gdb_osabi osabi
= GDB_OSABI_UNKNOWN
;
326 /* The list of compatible architectures reported by the target. */
327 std::vector
<const bfd_arch_info
*> compatible
;
329 /* Any architecture-specific properties specified by the target. */
330 std::vector
<property
> properties
;
332 /* The features associated with this target. */
333 std::vector
<tdesc_feature_up
> features
;
335 /* Used to cache the generated xml version of the target description. */
336 mutable char *xmltarget
= nullptr;
338 void accept (tdesc_element_visitor
&v
) const override
342 for (const tdesc_feature_up
&feature
: features
)
348 bool operator== (const target_desc
&other
) const
350 if (arch
!= other
.arch
)
353 if (osabi
!= other
.osabi
)
356 if (features
.size () != other
.features
.size ())
359 for (int ix
= 0; ix
< features
.size (); ix
++)
361 const tdesc_feature_up
&feature1
= features
[ix
];
362 const tdesc_feature_up
&feature2
= other
.features
[ix
];
364 if (feature1
!= feature2
&& *feature1
!= *feature2
)
371 bool operator!= (const target_desc
&other
) const
373 return !(*this == other
);
377 /* Per-architecture data associated with a target description. The
378 target description may be shared by multiple architectures, but
379 this data is private to one gdbarch. */
381 struct tdesc_arch_reg
383 tdesc_arch_reg (tdesc_reg
*reg_
, struct type
*type_
)
384 : reg (reg_
), type (type_
)
387 struct tdesc_reg
*reg
;
391 struct tdesc_arch_data
393 /* A list of register/type pairs, indexed by GDB's internal register number.
394 During initialization of the gdbarch this list is used to store
395 registers which the architecture assigns a fixed register number.
396 Registers which are NULL in this array, or off the end, are
397 treated as zero-sized and nameless (i.e. placeholders in the
399 std::vector
<tdesc_arch_reg
> arch_regs
;
401 /* Functions which report the register name, type, and reggroups for
403 gdbarch_register_name_ftype
*pseudo_register_name
= NULL
;
404 gdbarch_register_type_ftype
*pseudo_register_type
= NULL
;
405 gdbarch_register_reggroup_p_ftype
*pseudo_register_reggroup_p
= NULL
;
408 /* Info about an inferior's target description. There's one of these
409 for each inferior. */
411 struct target_desc_info
413 /* A flag indicating that a description has already been fetched
414 from the target, so it should not be queried again. */
418 /* The description fetched from the target, or NULL if the target
419 did not supply any description. Only valid when
420 target_desc_fetched is set. Only the description initialization
421 code should access this; normally, the description should be
422 accessed through the gdbarch object. */
424 const struct target_desc
*tdesc
;
426 /* The filename to read a target description from, as set by "set
427 tdesc filename ..." */
432 /* Get the inferior INF's target description info, allocating one on
433 the stop if necessary. */
435 static struct target_desc_info
*
436 get_tdesc_info (struct inferior
*inf
)
438 if (inf
->tdesc_info
== NULL
)
439 inf
->tdesc_info
= XCNEW (struct target_desc_info
);
440 return inf
->tdesc_info
;
443 /* A handle for architecture-specific data associated with the
444 target description (see struct tdesc_arch_data). */
446 static struct gdbarch_data
*tdesc_data
;
448 /* See target-descriptions.h. */
451 target_desc_info_from_user_p (struct target_desc_info
*info
)
453 return info
!= NULL
&& info
->filename
!= NULL
;
456 /* See target-descriptions.h. */
459 copy_inferior_target_desc_info (struct inferior
*destinf
, struct inferior
*srcinf
)
461 struct target_desc_info
*src
= get_tdesc_info (srcinf
);
462 struct target_desc_info
*dest
= get_tdesc_info (destinf
);
464 dest
->fetched
= src
->fetched
;
465 dest
->tdesc
= src
->tdesc
;
466 dest
->filename
= src
->filename
!= NULL
? xstrdup (src
->filename
) : NULL
;
469 /* See target-descriptions.h. */
472 target_desc_info_free (struct target_desc_info
*tdesc_info
)
474 if (tdesc_info
!= NULL
)
476 xfree (tdesc_info
->filename
);
481 /* Convenience helper macros. */
483 #define target_desc_fetched \
484 get_tdesc_info (current_inferior ())->fetched
485 #define current_target_desc \
486 get_tdesc_info (current_inferior ())->tdesc
487 #define target_description_filename \
488 get_tdesc_info (current_inferior ())->filename
490 /* The string manipulated by the "set tdesc filename ..." command. */
492 static char *tdesc_filename_cmd_string
;
494 /* Fetch the current target's description, and switch the current
495 architecture to one which incorporates that description. */
498 target_find_description (void)
500 /* If we've already fetched a description from the target, don't do
501 it again. This allows a target to fetch the description early,
502 during its to_open or to_create_inferior, if it needs extra
503 information about the target to initialize. */
504 if (target_desc_fetched
)
507 /* The current architecture should not have any target description
508 specified. It should have been cleared, e.g. when we
509 disconnected from the previous target. */
510 gdb_assert (gdbarch_target_desc (target_gdbarch ()) == NULL
);
512 /* First try to fetch an XML description from the user-specified
514 current_target_desc
= NULL
;
515 if (target_description_filename
!= NULL
516 && *target_description_filename
!= '\0')
518 = file_read_description_xml (target_description_filename
);
520 /* Next try to read the description from the current target using
522 if (current_target_desc
== NULL
)
523 current_target_desc
= target_read_description_xml (current_top_target ());
525 /* If that failed try a target-specific hook. */
526 if (current_target_desc
== NULL
)
527 current_target_desc
= target_read_description (current_top_target ());
529 /* If a non-NULL description was returned, then update the current
531 if (current_target_desc
)
533 struct gdbarch_info info
;
535 gdbarch_info_init (&info
);
536 info
.target_desc
= current_target_desc
;
537 if (!gdbarch_update_p (info
))
538 warning (_("Architecture rejected target-supplied description"));
541 struct tdesc_arch_data
*data
;
543 data
= ((struct tdesc_arch_data
*)
544 gdbarch_data (target_gdbarch (), tdesc_data
));
545 if (tdesc_has_registers (current_target_desc
)
546 && data
->arch_regs
.empty ())
547 warning (_("Target-supplied registers are not supported "
548 "by the current architecture"));
552 /* Now that we know this description is usable, record that we
554 target_desc_fetched
= 1;
557 /* Discard any description fetched from the current target, and switch
558 the current architecture to one with no target description. */
561 target_clear_description (void)
563 struct gdbarch_info info
;
565 if (!target_desc_fetched
)
568 target_desc_fetched
= 0;
569 current_target_desc
= NULL
;
571 gdbarch_info_init (&info
);
572 if (!gdbarch_update_p (info
))
573 internal_error (__FILE__
, __LINE__
,
574 _("Could not remove target-supplied description"));
577 /* Return the global current target description. This should only be
578 used by gdbarch initialization code; most access should be through
579 an existing gdbarch. */
581 const struct target_desc
*
582 target_current_description (void)
584 if (target_desc_fetched
)
585 return current_target_desc
;
590 /* Return non-zero if this target description is compatible
591 with the given BFD architecture. */
594 tdesc_compatible_p (const struct target_desc
*target_desc
,
595 const struct bfd_arch_info
*arch
)
597 for (const bfd_arch_info
*compat
: target_desc
->compatible
)
600 || arch
->compatible (arch
, compat
)
601 || compat
->compatible (compat
, arch
))
609 /* Direct accessors for target descriptions. */
611 /* Return the string value of a property named KEY, or NULL if the
612 property was not specified. */
615 tdesc_property (const struct target_desc
*target_desc
, const char *key
)
617 for (const property
&prop
: target_desc
->properties
)
619 return prop
.value
.c_str ();
624 /* Return the BFD architecture associated with this target
625 description, or NULL if no architecture was specified. */
627 const struct bfd_arch_info
*
628 tdesc_architecture (const struct target_desc
*target_desc
)
630 return target_desc
->arch
;
633 /* See common/tdesc.h. */
636 tdesc_architecture_name (const struct target_desc
*target_desc
)
638 return target_desc
->arch
->printable_name
;
641 /* Return the OSABI associated with this target description, or
642 GDB_OSABI_UNKNOWN if no osabi was specified. */
645 tdesc_osabi (const struct target_desc
*target_desc
)
647 return target_desc
->osabi
;
650 /* See common/tdesc.h. */
653 tdesc_osabi_name (const struct target_desc
*target_desc
)
655 enum gdb_osabi osabi
= tdesc_osabi (target_desc
);
656 if (osabi
> GDB_OSABI_UNKNOWN
&& osabi
< GDB_OSABI_INVALID
)
657 return gdbarch_osabi_name (osabi
);
661 /* Return 1 if this target description includes any registers. */
664 tdesc_has_registers (const struct target_desc
*target_desc
)
666 if (target_desc
== NULL
)
669 for (const tdesc_feature_up
&feature
: target_desc
->features
)
670 if (!feature
->registers
.empty ())
676 /* Return the feature with the given name, if present, or NULL if
677 the named feature is not found. */
679 const struct tdesc_feature
*
680 tdesc_find_feature (const struct target_desc
*target_desc
,
683 for (const tdesc_feature_up
&feature
: target_desc
->features
)
684 if (feature
->name
== name
)
685 return feature
.get ();
690 /* Return the name of FEATURE. */
693 tdesc_feature_name (const struct tdesc_feature
*feature
)
695 return feature
->name
.c_str ();
698 /* Lookup type associated with ID. */
701 tdesc_find_type (struct gdbarch
*gdbarch
, const char *id
)
703 tdesc_arch_data
*data
704 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
706 for (const tdesc_arch_reg
®
: data
->arch_regs
)
709 && reg
.reg
->tdesc_type
711 && reg
.reg
->tdesc_type
->name
== id
)
718 /* Support for registers from target descriptions. */
720 /* Construct the per-gdbarch data. */
723 tdesc_data_init (struct obstack
*obstack
)
725 return obstack_new
<tdesc_arch_data
> (obstack
);
728 /* Similar, but for the temporary copy used during architecture
731 struct tdesc_arch_data
*
732 tdesc_data_alloc (void)
734 return new tdesc_arch_data ();
737 /* Free something allocated by tdesc_data_alloc, if it is not going
738 to be used (for instance if it was unsuitable for the
742 tdesc_data_cleanup (void *data_untyped
)
744 struct tdesc_arch_data
*data
= (struct tdesc_arch_data
*) data_untyped
;
749 /* Search FEATURE for a register named NAME. */
751 static struct tdesc_reg
*
752 tdesc_find_register_early (const struct tdesc_feature
*feature
,
755 for (const tdesc_reg_up
®
: feature
->registers
)
756 if (strcasecmp (reg
->name
.c_str (), name
) == 0)
762 /* Search FEATURE for a register named NAME. Assign REGNO to it. */
765 tdesc_numbered_register (const struct tdesc_feature
*feature
,
766 struct tdesc_arch_data
*data
,
767 int regno
, const char *name
)
769 struct tdesc_reg
*reg
= tdesc_find_register_early (feature
, name
);
774 /* Make sure the vector includes a REGNO'th element. */
775 while (regno
>= data
->arch_regs
.size ())
776 data
->arch_regs
.emplace_back (nullptr, nullptr);
778 data
->arch_regs
[regno
] = tdesc_arch_reg (reg
, NULL
);
783 /* Search FEATURE for a register named NAME, but do not assign a fixed
784 register number to it. */
787 tdesc_unnumbered_register (const struct tdesc_feature
*feature
,
790 struct tdesc_reg
*reg
= tdesc_find_register_early (feature
, name
);
798 /* Search FEATURE for a register whose name is in NAMES and assign
802 tdesc_numbered_register_choices (const struct tdesc_feature
*feature
,
803 struct tdesc_arch_data
*data
,
804 int regno
, const char *const names
[])
808 for (i
= 0; names
[i
] != NULL
; i
++)
809 if (tdesc_numbered_register (feature
, data
, regno
, names
[i
]))
815 /* Search FEATURE for a register named NAME, and return its size in
816 bits. The register must exist. */
819 tdesc_register_bitsize (const struct tdesc_feature
*feature
, const char *name
)
821 struct tdesc_reg
*reg
= tdesc_find_register_early (feature
, name
);
823 gdb_assert (reg
!= NULL
);
827 /* Look up a register by its GDB internal register number. */
829 static struct tdesc_arch_reg
*
830 tdesc_find_arch_register (struct gdbarch
*gdbarch
, int regno
)
832 struct tdesc_arch_data
*data
;
834 data
= (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
835 if (regno
< data
->arch_regs
.size ())
836 return &data
->arch_regs
[regno
];
841 static struct tdesc_reg
*
842 tdesc_find_register (struct gdbarch
*gdbarch
, int regno
)
844 struct tdesc_arch_reg
*reg
= tdesc_find_arch_register (gdbarch
, regno
);
846 return reg
? reg
->reg
: NULL
;
849 /* Return the name of register REGNO, from the target description or
850 from an architecture-provided pseudo_register_name method. */
853 tdesc_register_name (struct gdbarch
*gdbarch
, int regno
)
855 struct tdesc_reg
*reg
= tdesc_find_register (gdbarch
, regno
);
856 int num_regs
= gdbarch_num_regs (gdbarch
);
857 int num_pseudo_regs
= gdbarch_num_pseudo_regs (gdbarch
);
860 return reg
->name
.c_str ();
862 if (regno
>= num_regs
&& regno
< num_regs
+ num_pseudo_regs
)
864 struct tdesc_arch_data
*data
865 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
867 gdb_assert (data
->pseudo_register_name
!= NULL
);
868 return data
->pseudo_register_name (gdbarch
, regno
);
875 tdesc_register_type (struct gdbarch
*gdbarch
, int regno
)
877 struct tdesc_arch_reg
*arch_reg
= tdesc_find_arch_register (gdbarch
, regno
);
878 struct tdesc_reg
*reg
= arch_reg
? arch_reg
->reg
: NULL
;
879 int num_regs
= gdbarch_num_regs (gdbarch
);
880 int num_pseudo_regs
= gdbarch_num_pseudo_regs (gdbarch
);
882 if (reg
== NULL
&& regno
>= num_regs
&& regno
< num_regs
+ num_pseudo_regs
)
884 struct tdesc_arch_data
*data
885 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
887 gdb_assert (data
->pseudo_register_type
!= NULL
);
888 return data
->pseudo_register_type (gdbarch
, regno
);
892 /* Return "int0_t", since "void" has a misleading size of one. */
893 return builtin_type (gdbarch
)->builtin_int0
;
895 if (arch_reg
->type
== NULL
)
897 /* First check for a predefined or target defined type. */
899 arch_reg
->type
= make_gdb_type (gdbarch
, reg
->tdesc_type
);
901 /* Next try size-sensitive type shortcuts. */
902 else if (reg
->type
== "float")
904 if (reg
->bitsize
== gdbarch_float_bit (gdbarch
))
905 arch_reg
->type
= builtin_type (gdbarch
)->builtin_float
;
906 else if (reg
->bitsize
== gdbarch_double_bit (gdbarch
))
907 arch_reg
->type
= builtin_type (gdbarch
)->builtin_double
;
908 else if (reg
->bitsize
== gdbarch_long_double_bit (gdbarch
))
909 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long_double
;
912 warning (_("Register \"%s\" has an unsupported size (%d bits)"),
913 reg
->name
.c_str (), reg
->bitsize
);
914 arch_reg
->type
= builtin_type (gdbarch
)->builtin_double
;
917 else if (reg
->type
== "int")
919 if (reg
->bitsize
== gdbarch_long_bit (gdbarch
))
920 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long
;
921 else if (reg
->bitsize
== TARGET_CHAR_BIT
)
922 arch_reg
->type
= builtin_type (gdbarch
)->builtin_char
;
923 else if (reg
->bitsize
== gdbarch_short_bit (gdbarch
))
924 arch_reg
->type
= builtin_type (gdbarch
)->builtin_short
;
925 else if (reg
->bitsize
== gdbarch_int_bit (gdbarch
))
926 arch_reg
->type
= builtin_type (gdbarch
)->builtin_int
;
927 else if (reg
->bitsize
== gdbarch_long_long_bit (gdbarch
))
928 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long_long
;
929 else if (reg
->bitsize
== gdbarch_ptr_bit (gdbarch
))
930 /* A bit desperate by this point... */
931 arch_reg
->type
= builtin_type (gdbarch
)->builtin_data_ptr
;
934 warning (_("Register \"%s\" has an unsupported size (%d bits)"),
935 reg
->name
.c_str (), reg
->bitsize
);
936 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long
;
940 if (arch_reg
->type
== NULL
)
941 internal_error (__FILE__
, __LINE__
,
942 "Register \"%s\" has an unknown type \"%s\"",
943 reg
->name
.c_str (), reg
->type
.c_str ());
946 return arch_reg
->type
;
950 tdesc_remote_register_number (struct gdbarch
*gdbarch
, int regno
)
952 struct tdesc_reg
*reg
= tdesc_find_register (gdbarch
, regno
);
955 return reg
->target_regnum
;
960 /* Check whether REGNUM is a member of REGGROUP. Registers from the
961 target description may be classified as general, float, vector or other
962 register groups registered with reggroup_add(). Unlike a gdbarch
963 register_reggroup_p method, this function will return -1 if it does not
964 know; the caller should handle registers with no specified group.
966 The names of containing features are not used. This might be extended
967 to display registers in some more useful groupings.
969 The save-restore flag is also implemented here. */
972 tdesc_register_in_reggroup_p (struct gdbarch
*gdbarch
, int regno
,
973 struct reggroup
*reggroup
)
975 struct tdesc_reg
*reg
= tdesc_find_register (gdbarch
, regno
);
977 if (reg
!= NULL
&& !reg
->group
.empty ()
978 && (reg
->group
== reggroup_name (reggroup
)))
982 && (reggroup
== save_reggroup
|| reggroup
== restore_reggroup
))
983 return reg
->save_restore
;
988 /* Check whether REGNUM is a member of REGGROUP. Registers with no
989 group specified go to the default reggroup function and are handled
993 tdesc_register_reggroup_p (struct gdbarch
*gdbarch
, int regno
,
994 struct reggroup
*reggroup
)
996 int num_regs
= gdbarch_num_regs (gdbarch
);
997 int num_pseudo_regs
= gdbarch_num_pseudo_regs (gdbarch
);
1000 if (regno
>= num_regs
&& regno
< num_regs
+ num_pseudo_regs
)
1002 struct tdesc_arch_data
*data
1003 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1005 if (data
->pseudo_register_reggroup_p
!= NULL
)
1006 return data
->pseudo_register_reggroup_p (gdbarch
, regno
, reggroup
);
1007 /* Otherwise fall through to the default reggroup_p. */
1010 ret
= tdesc_register_in_reggroup_p (gdbarch
, regno
, reggroup
);
1014 return default_register_reggroup_p (gdbarch
, regno
, reggroup
);
1017 /* Record architecture-specific functions to call for pseudo-register
1021 set_tdesc_pseudo_register_name (struct gdbarch
*gdbarch
,
1022 gdbarch_register_name_ftype
*pseudo_name
)
1024 struct tdesc_arch_data
*data
1025 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1027 data
->pseudo_register_name
= pseudo_name
;
1031 set_tdesc_pseudo_register_type (struct gdbarch
*gdbarch
,
1032 gdbarch_register_type_ftype
*pseudo_type
)
1034 struct tdesc_arch_data
*data
1035 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1037 data
->pseudo_register_type
= pseudo_type
;
1041 set_tdesc_pseudo_register_reggroup_p
1042 (struct gdbarch
*gdbarch
,
1043 gdbarch_register_reggroup_p_ftype
*pseudo_reggroup_p
)
1045 struct tdesc_arch_data
*data
1046 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1048 data
->pseudo_register_reggroup_p
= pseudo_reggroup_p
;
1051 /* Update GDBARCH to use the target description for registers. */
1054 tdesc_use_registers (struct gdbarch
*gdbarch
,
1055 const struct target_desc
*target_desc
,
1056 struct tdesc_arch_data
*early_data
)
1058 int num_regs
= gdbarch_num_regs (gdbarch
);
1059 struct tdesc_arch_data
*data
;
1062 /* We can't use the description for registers if it doesn't describe
1063 any. This function should only be called after validating
1064 registers, so the caller should know that registers are
1066 gdb_assert (tdesc_has_registers (target_desc
));
1068 data
= (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1069 data
->arch_regs
= early_data
->arch_regs
;
1072 /* Build up a set of all registers, so that we can assign register
1073 numbers where needed. The hash table expands as necessary, so
1074 the initial size is arbitrary. */
1075 reg_hash
= htab_create (37, htab_hash_pointer
, htab_eq_pointer
, NULL
);
1076 for (const tdesc_feature_up
&feature
: target_desc
->features
)
1077 for (const tdesc_reg_up
®
: feature
->registers
)
1079 void **slot
= htab_find_slot (reg_hash
, reg
.get (), INSERT
);
1082 /* Add reggroup if its new. */
1083 if (!reg
->group
.empty ())
1084 if (reggroup_find (gdbarch
, reg
->group
.c_str ()) == NULL
)
1085 reggroup_add (gdbarch
, reggroup_gdbarch_new (gdbarch
,
1086 reg
->group
.c_str (),
1090 /* Remove any registers which were assigned numbers by the
1092 for (const tdesc_arch_reg
&arch_reg
: data
->arch_regs
)
1093 if (arch_reg
.reg
!= NULL
)
1094 htab_remove_elt (reg_hash
, arch_reg
.reg
);
1096 /* Assign numbers to the remaining registers and add them to the
1097 list of registers. The new numbers are always above gdbarch_num_regs.
1098 Iterate over the features, not the hash table, so that the order
1099 matches that in the target description. */
1101 gdb_assert (data
->arch_regs
.size () <= num_regs
);
1102 while (data
->arch_regs
.size () < num_regs
)
1103 data
->arch_regs
.emplace_back (nullptr, nullptr);
1105 for (const tdesc_feature_up
&feature
: target_desc
->features
)
1106 for (const tdesc_reg_up
®
: feature
->registers
)
1107 if (htab_find (reg_hash
, reg
.get ()) != NULL
)
1109 data
->arch_regs
.emplace_back (reg
.get (), nullptr);
1113 htab_delete (reg_hash
);
1115 /* Update the architecture. */
1116 set_gdbarch_num_regs (gdbarch
, num_regs
);
1117 set_gdbarch_register_name (gdbarch
, tdesc_register_name
);
1118 set_gdbarch_register_type (gdbarch
, tdesc_register_type
);
1119 set_gdbarch_remote_register_number (gdbarch
,
1120 tdesc_remote_register_number
);
1121 set_gdbarch_register_reggroup_p (gdbarch
, tdesc_register_reggroup_p
);
1124 /* See common/tdesc.h. */
1126 struct tdesc_feature
*
1127 tdesc_create_feature (struct target_desc
*tdesc
, const char *name
)
1129 struct tdesc_feature
*new_feature
= new tdesc_feature (name
);
1131 tdesc
->features
.emplace_back (new_feature
);
1136 struct target_desc
*
1137 allocate_target_description (void)
1139 return new target_desc ();
1143 free_target_description (void *arg
)
1145 struct target_desc
*target_desc
= (struct target_desc
*) arg
;
1151 make_cleanup_free_target_description (struct target_desc
*target_desc
)
1153 return make_cleanup (free_target_description
, target_desc
);
1157 tdesc_add_compatible (struct target_desc
*target_desc
,
1158 const struct bfd_arch_info
*compatible
)
1160 /* If this instance of GDB is compiled without BFD support for the
1161 compatible architecture, simply ignore it -- we would not be able
1162 to handle it anyway. */
1163 if (compatible
== NULL
)
1166 for (const bfd_arch_info
*compat
: target_desc
->compatible
)
1167 if (compat
== compatible
)
1168 internal_error (__FILE__
, __LINE__
,
1169 _("Attempted to add duplicate "
1170 "compatible architecture \"%s\""),
1171 compatible
->printable_name
);
1173 target_desc
->compatible
.push_back (compatible
);
1177 set_tdesc_property (struct target_desc
*target_desc
,
1178 const char *key
, const char *value
)
1180 gdb_assert (key
!= NULL
&& value
!= NULL
);
1182 if (tdesc_property (target_desc
, key
) != NULL
)
1183 internal_error (__FILE__
, __LINE__
,
1184 _("Attempted to add duplicate property \"%s\""), key
);
1186 target_desc
->properties
.emplace_back (key
, value
);
1189 /* See common/tdesc.h. */
1192 set_tdesc_architecture (struct target_desc
*target_desc
,
1195 set_tdesc_architecture (target_desc
, bfd_scan_arch (name
));
1199 set_tdesc_architecture (struct target_desc
*target_desc
,
1200 const struct bfd_arch_info
*arch
)
1202 target_desc
->arch
= arch
;
1205 /* See common/tdesc.h. */
1208 set_tdesc_osabi (struct target_desc
*target_desc
, const char *name
)
1210 set_tdesc_osabi (target_desc
, osabi_from_tdesc_string (name
));
1214 set_tdesc_osabi (struct target_desc
*target_desc
, enum gdb_osabi osabi
)
1216 target_desc
->osabi
= osabi
;
1220 static struct cmd_list_element
*tdesc_set_cmdlist
, *tdesc_show_cmdlist
;
1221 static struct cmd_list_element
*tdesc_unset_cmdlist
;
1223 /* Helper functions for the CLI commands. */
1226 set_tdesc_cmd (const char *args
, int from_tty
)
1228 help_list (tdesc_set_cmdlist
, "set tdesc ", all_commands
, gdb_stdout
);
1232 show_tdesc_cmd (const char *args
, int from_tty
)
1234 cmd_show_list (tdesc_show_cmdlist
, from_tty
, "");
1238 unset_tdesc_cmd (const char *args
, int from_tty
)
1240 help_list (tdesc_unset_cmdlist
, "unset tdesc ", all_commands
, gdb_stdout
);
1244 set_tdesc_filename_cmd (const char *args
, int from_tty
,
1245 struct cmd_list_element
*c
)
1247 xfree (target_description_filename
);
1248 target_description_filename
= xstrdup (tdesc_filename_cmd_string
);
1250 target_clear_description ();
1251 target_find_description ();
1255 show_tdesc_filename_cmd (struct ui_file
*file
, int from_tty
,
1256 struct cmd_list_element
*c
,
1259 value
= target_description_filename
;
1261 if (value
!= NULL
&& *value
!= '\0')
1262 printf_filtered (_("The target description will be read from \"%s\".\n"),
1265 printf_filtered (_("The target description will be "
1266 "read from the target.\n"));
1270 unset_tdesc_filename_cmd (const char *args
, int from_tty
)
1272 xfree (target_description_filename
);
1273 target_description_filename
= NULL
;
1274 target_clear_description ();
1275 target_find_description ();
1278 /* Print target description in C. */
1280 class print_c_tdesc
: public tdesc_element_visitor
1283 print_c_tdesc (std::string
&filename_after_features
)
1284 : m_filename_after_features (filename_after_features
)
1288 const char *filename
= lbasename (m_filename_after_features
.c_str ());
1290 m_function
= (char *) xmalloc (strlen (filename
) + 1);
1291 for (inp
= filename
, outp
= m_function
; *inp
!= '\0'; inp
++)
1294 else if (*inp
== '-')
1300 /* Standard boilerplate. */
1301 printf_unfiltered ("/* THIS FILE IS GENERATED. "
1302 "-*- buffer-read-only: t -*- vi"
1311 void visit_pre (const target_desc
*e
) override
1313 printf_unfiltered (" Original: %s */\n\n",
1314 lbasename (m_filename_after_features
.c_str ()));
1316 printf_unfiltered ("#include \"defs.h\"\n");
1317 printf_unfiltered ("#include \"osabi.h\"\n");
1318 printf_unfiltered ("#include \"target-descriptions.h\"\n");
1319 printf_unfiltered ("\n");
1321 printf_unfiltered ("struct target_desc *tdesc_%s;\n", m_function
);
1322 printf_unfiltered ("static void\n");
1323 printf_unfiltered ("initialize_tdesc_%s (void)\n", m_function
);
1324 printf_unfiltered ("{\n");
1326 (" struct target_desc *result = allocate_target_description ();\n");
1328 if (tdesc_architecture (e
) != NULL
)
1331 (" set_tdesc_architecture (result, bfd_scan_arch (\"%s\"));\n",
1332 tdesc_architecture (e
)->printable_name
);
1333 printf_unfiltered ("\n");
1335 if (tdesc_osabi (e
) > GDB_OSABI_UNKNOWN
1336 && tdesc_osabi (e
) < GDB_OSABI_INVALID
)
1339 (" set_tdesc_osabi (result, osabi_from_tdesc_string (\"%s\"));\n",
1340 gdbarch_osabi_name (tdesc_osabi (e
)));
1341 printf_unfiltered ("\n");
1344 for (const bfd_arch_info_type
*compatible
: e
->compatible
)
1346 (" tdesc_add_compatible (result, bfd_scan_arch (\"%s\"));\n",
1347 compatible
->printable_name
);
1349 if (!e
->compatible
.empty ())
1350 printf_unfiltered ("\n");
1352 for (const property
&prop
: e
->properties
)
1353 printf_unfiltered (" set_tdesc_property (result, \"%s\", \"%s\");\n",
1354 prop
.key
.c_str (), prop
.value
.c_str ());
1356 printf_unfiltered (" struct tdesc_feature *feature;\n");
1359 void visit_pre (const tdesc_feature
*e
) override
1361 printf_unfiltered ("\n feature = tdesc_create_feature (result, \"%s\");\n",
1365 void visit_post (const tdesc_feature
*e
) override
1368 void visit_post (const target_desc
*e
) override
1370 printf_unfiltered ("\n tdesc_%s = result;\n", m_function
);
1371 printf_unfiltered ("}\n");
1374 void visit (const tdesc_type_builtin
*type
) override
1376 error (_("C output is not supported type \"%s\"."), type
->name
.c_str ());
1379 void visit (const tdesc_type_vector
*type
) override
1381 if (!m_printed_element_type
)
1383 printf_unfiltered (" tdesc_type *element_type;\n");
1384 m_printed_element_type
= true;
1388 (" element_type = tdesc_named_type (feature, \"%s\");\n",
1389 type
->element_type
->name
.c_str ());
1391 (" tdesc_create_vector (feature, \"%s\", element_type, %d);\n",
1392 type
->name
.c_str (), type
->count
);
1394 printf_unfiltered ("\n");
1397 void visit (const tdesc_type_with_fields
*type
) override
1399 if (!m_printed_type_with_fields
)
1401 printf_unfiltered (" tdesc_type_with_fields *type_with_fields;\n");
1402 m_printed_type_with_fields
= true;
1407 case TDESC_TYPE_STRUCT
:
1408 case TDESC_TYPE_FLAGS
:
1409 if (type
->kind
== TDESC_TYPE_STRUCT
)
1412 (" type_with_fields = tdesc_create_struct (feature, \"%s\");\n",
1413 type
->name
.c_str ());
1414 if (type
->size
!= 0)
1416 (" tdesc_set_struct_size (type_with_fields, %d);\n", type
->size
);
1421 (" type_with_fields = tdesc_create_flags (feature, \"%s\", %d);\n",
1422 type
->name
.c_str (), type
->size
);
1424 for (const tdesc_type_field
&f
: type
->fields
)
1426 const char *type_name
;
1428 gdb_assert (f
.type
!= NULL
);
1429 type_name
= f
.type
->name
.c_str ();
1431 /* To minimize changes to generated files, don't emit type
1432 info for fields that have defaulted types. */
1435 gdb_assert (f
.end
!= -1);
1436 if (f
.type
->kind
== TDESC_TYPE_BOOL
)
1438 gdb_assert (f
.start
== f
.end
);
1440 (" tdesc_add_flag (type_with_fields, %d, \"%s\");\n",
1441 f
.start
, f
.name
.c_str ());
1443 else if ((type
->size
== 4 && f
.type
->kind
== TDESC_TYPE_UINT32
)
1445 && f
.type
->kind
== TDESC_TYPE_UINT64
))
1448 (" tdesc_add_bitfield (type_with_fields, \"%s\", %d, %d);\n",
1449 f
.name
.c_str (), f
.start
, f
.end
);
1453 printf_field_type_assignment
1454 ("tdesc_named_type (feature, \"%s\");\n",
1457 (" tdesc_add_typed_bitfield (type_with_fields, \"%s\","
1458 " %d, %d, field_type);\n",
1459 f
.name
.c_str (), f
.start
, f
.end
);
1462 else /* Not a bitfield. */
1464 gdb_assert (f
.end
== -1);
1465 gdb_assert (type
->kind
== TDESC_TYPE_STRUCT
);
1466 printf_field_type_assignment
1467 ("tdesc_named_type (feature, \"%s\");\n", type_name
);
1469 (" tdesc_add_field (type_with_fields, \"%s\", field_type);\n",
1474 case TDESC_TYPE_UNION
:
1476 (" type_with_fields = tdesc_create_union (feature, \"%s\");\n",
1477 type
->name
.c_str ());
1478 for (const tdesc_type_field
&f
: type
->fields
)
1480 printf_field_type_assignment
1481 ("tdesc_named_type (feature, \"%s\");\n", f
.type
->name
.c_str ());
1483 (" tdesc_add_field (type_with_fields, \"%s\", field_type);\n",
1487 case TDESC_TYPE_ENUM
:
1489 (" type_with_fields = tdesc_create_enum (feature, \"%s\", %d);\n",
1490 type
->name
.c_str (), type
->size
);
1491 for (const tdesc_type_field
&f
: type
->fields
)
1493 (" tdesc_add_enum_value (type_with_fields, %d, \"%s\");\n",
1494 f
.start
, f
.name
.c_str ());
1497 error (_("C output is not supported type \"%s\"."), type
->name
.c_str ());
1500 printf_unfiltered ("\n");
1503 void visit (const tdesc_reg
*reg
) override
1505 printf_unfiltered (" tdesc_create_reg (feature, \"%s\", %ld, %d, ",
1506 reg
->name
.c_str (), reg
->target_regnum
,
1508 if (!reg
->group
.empty ())
1509 printf_unfiltered ("\"%s\", ", reg
->group
.c_str ());
1511 printf_unfiltered ("NULL, ");
1512 printf_unfiltered ("%d, \"%s\");\n", reg
->bitsize
, reg
->type
.c_str ());
1516 std::string m_filename_after_features
;
1520 /* Print an assignment to the field_type variable. Print the declaration
1521 of field_type if that has not been done yet. */
1522 ATTRIBUTE_PRINTF (2, 3)
1523 void printf_field_type_assignment (const char *fmt
, ...)
1525 if (!m_printed_field_type
)
1527 printf_unfiltered (" tdesc_type *field_type;\n");
1528 m_printed_field_type
= true;
1531 printf_unfiltered (" field_type = ");
1534 va_start (args
, fmt
);
1535 vprintf_unfiltered (fmt
, args
);
1541 /* Did we print "struct tdesc_type *element_type;" yet? */
1542 bool m_printed_element_type
= false;
1544 /* Did we print "struct tdesc_type_with_fields *element_type;" yet? */
1545 bool m_printed_type_with_fields
= false;
1547 /* Did we print "struct tdesc_type *field_type;" yet? */
1548 bool m_printed_field_type
= false;
1551 /* Print target description feature in C. */
1553 class print_c_feature
: public print_c_tdesc
1556 print_c_feature (std::string
&file
)
1557 : print_c_tdesc (file
)
1560 auto const pos
= m_filename_after_features
.find_last_of ('.');
1562 m_filename_after_features
= m_filename_after_features
.substr (0, pos
);
1565 void visit_pre (const target_desc
*e
) override
1567 printf_unfiltered (" Original: %s */\n\n",
1568 lbasename (m_filename_after_features
.c_str ()));
1570 printf_unfiltered ("#include \"common/tdesc.h\"\n");
1571 printf_unfiltered ("\n");
1574 void visit_post (const target_desc
*e
) override
1577 void visit_pre (const tdesc_feature
*e
) override
1579 std::string
name (m_filename_after_features
);
1581 auto pos
= name
.find_first_of ('.');
1583 name
= name
.substr (0, pos
);
1584 std::replace (name
.begin (), name
.end (), '/', '_');
1585 std::replace (name
.begin (), name
.end (), '-', '_');
1587 printf_unfiltered ("static int\n");
1588 printf_unfiltered ("create_feature_%s ", name
.c_str ());
1589 printf_unfiltered ("(struct target_desc *result, long regnum)\n");
1591 printf_unfiltered ("{\n");
1592 printf_unfiltered (" struct tdesc_feature *feature;\n");
1595 ("\n feature = tdesc_create_feature (result, \"%s\");\n",
1599 void visit_post (const tdesc_feature
*e
) override
1601 printf_unfiltered (" return regnum;\n");
1602 printf_unfiltered ("}\n");
1605 void visit (const tdesc_reg
*reg
) override
1607 /* Most "reg" in XML target descriptions don't have "regnum"
1608 attribute, so the register number is allocated sequentially.
1609 In case that reg has "regnum" attribute, register number
1610 should be set by that explicitly. */
1612 if (reg
->target_regnum
< m_next_regnum
)
1614 /* The integrity check, it can catch some errors on register
1615 number collision, like this,
1617 <reg name="x0" bitsize="32"/>
1618 <reg name="x1" bitsize="32"/>
1619 <reg name="x2" bitsize="32"/>
1620 <reg name="x3" bitsize="32"/>
1621 <reg name="ps" bitsize="32" regnum="3"/>
1623 but it also has false negatives. The target description
1626 <reg name="x1" bitsize="32" regnum="1"/>
1627 <reg name="x3" bitsize="32" regnum="3"/>
1628 <reg name="x2" bitsize="32" regnum="2"/>
1629 <reg name="x4" bitsize="32" regnum="4"/>
1631 but it is not a good practice, so still error on this,
1632 and also print the message so that it can be saved in the
1633 generated c file. */
1635 printf_unfiltered ("ERROR: \"regnum\" attribute %ld ",
1636 reg
->target_regnum
);
1637 printf_unfiltered ("is not the largest number (%d).\n",
1639 error (_("\"regnum\" attribute %ld is not the largest number (%d)."),
1640 reg
->target_regnum
, m_next_regnum
);
1643 if (reg
->target_regnum
> m_next_regnum
)
1645 printf_unfiltered (" regnum = %ld;\n", reg
->target_regnum
);
1646 m_next_regnum
= reg
->target_regnum
;
1649 printf_unfiltered (" tdesc_create_reg (feature, \"%s\", regnum++, %d, ",
1650 reg
->name
.c_str (), reg
->save_restore
);
1651 if (!reg
->group
.empty ())
1652 printf_unfiltered ("\"%s\", ", reg
->group
.c_str ());
1654 printf_unfiltered ("NULL, ");
1655 printf_unfiltered ("%d, \"%s\");\n", reg
->bitsize
, reg
->type
.c_str ());
1661 /* The register number to use for the next register we see. */
1662 int m_next_regnum
= 0;
1665 /* See common/tdesc.h. */
1668 tdesc_get_features_xml (const target_desc
*tdesc
)
1670 if (tdesc
->xmltarget
== nullptr)
1672 std::string
buffer ("@");
1673 print_xml_feature
v (&buffer
);
1675 tdesc
->xmltarget
= xstrdup (buffer
.c_str ());
1677 return tdesc
->xmltarget
;
1681 maint_print_c_tdesc_cmd (const char *args
, int from_tty
)
1683 const struct target_desc
*tdesc
;
1684 const char *filename
;
1688 /* Use the global target-supplied description, not the current
1689 architecture's. This lets a GDB for one architecture generate C
1690 for another architecture's description, even though the gdbarch
1691 initialization code will reject the new description. */
1692 tdesc
= current_target_desc
;
1693 filename
= target_description_filename
;
1697 /* Use the target description from the XML file. */
1699 tdesc
= file_read_description_xml (filename
);
1703 error (_("There is no target description to print."));
1705 if (filename
== NULL
)
1706 error (_("The current target description did not come from an XML file."));
1708 std::string
filename_after_features (filename
);
1709 auto loc
= filename_after_features
.rfind ("/features/");
1711 if (loc
!= std::string::npos
)
1712 filename_after_features
= filename_after_features
.substr (loc
+ 10);
1714 /* Print c files for target features instead of target descriptions,
1715 because c files got from target features are more flexible than the
1717 if (startswith (filename_after_features
.c_str (), "i386/32bit-")
1718 || startswith (filename_after_features
.c_str (), "i386/64bit-")
1719 || startswith (filename_after_features
.c_str (), "i386/x32-core.xml")
1720 || startswith (filename_after_features
.c_str (), "tic6x-")
1721 || startswith (filename_after_features
.c_str (), "aarch64"))
1723 print_c_feature
v (filename_after_features
);
1729 print_c_tdesc
v (filename_after_features
);
1735 namespace selftests
{
1737 /* A reference target description, used for testing (see record_xml_tdesc). */
1739 struct xml_test_tdesc
1741 xml_test_tdesc (const char *name
, std::unique_ptr
<const target_desc
> &&tdesc
)
1742 : name (name
), tdesc (std::move (tdesc
))
1746 std::unique_ptr
<const target_desc
> tdesc
;
1749 static std::vector
<xml_test_tdesc
> xml_tdesc
;
1753 /* See target-descritpions.h. */
1756 record_xml_tdesc (const char *xml_file
, const struct target_desc
*tdesc
)
1758 xml_tdesc
.emplace_back (xml_file
, std::unique_ptr
<const target_desc
> (tdesc
));
1764 /* Test the convesion process of a target description to/from xml: Take a target
1765 description TDESC, convert to xml, back to a description, and confirm the new
1766 tdesc is identical to the original. */
1768 maintenance_check_tdesc_xml_convert (const target_desc
*tdesc
, const char *name
)
1770 const char *xml
= tdesc_get_features_xml (tdesc
);
1772 if (xml
== nullptr || *xml
!= '@')
1774 printf_filtered (_("Could not convert description for %s to xml.\n"),
1779 const target_desc
*tdesc_trans
= string_read_description_xml (xml
+ 1);
1781 if (tdesc_trans
== nullptr)
1783 printf_filtered (_("Could not convert description for %s from xml.\n"),
1787 else if (*tdesc
!= *tdesc_trans
)
1789 printf_filtered (_("Converted description for %s does not match.\n"),
1797 /* Check that the target descriptions created dynamically by
1798 architecture-specific code equal the descriptions created from XML files
1799 found in the specified directory DIR. */
1802 maintenance_check_xml_descriptions (const char *dir
, int from_tty
)
1805 error (_("Missing dir name"));
1807 gdb::unique_xmalloc_ptr
<char> dir1 (tilde_expand (dir
));
1808 std::string
feature_dir (dir1
.get ());
1809 unsigned int failed
= 0;
1811 for (auto const &e
: selftests::xml_tdesc
)
1813 std::string tdesc_xml
= (feature_dir
+ SLASH_STRING
+ e
.name
);
1814 const target_desc
*tdesc
1815 = file_read_description_xml (tdesc_xml
.data ());
1817 if (tdesc
== NULL
|| *tdesc
!= *e
.tdesc
)
1819 printf_filtered ( _("Descriptions for %s do not match.\n"), e
.name
);
1822 else if (!maintenance_check_tdesc_xml_convert (tdesc
, e
.name
)
1823 || !maintenance_check_tdesc_xml_convert (e
.tdesc
.get (), e
.name
))
1826 printf_filtered (_("Tested %lu XML files, %d failed\n"),
1827 (long) selftests::xml_tdesc
.size (), failed
);
1831 _initialize_target_descriptions (void)
1833 tdesc_data
= gdbarch_data_register_pre_init (tdesc_data_init
);
1835 add_prefix_cmd ("tdesc", class_maintenance
, set_tdesc_cmd
, _("\
1836 Set target description specific variables."),
1837 &tdesc_set_cmdlist
, "set tdesc ",
1838 0 /* allow-unknown */, &setlist
);
1839 add_prefix_cmd ("tdesc", class_maintenance
, show_tdesc_cmd
, _("\
1840 Show target description specific variables."),
1841 &tdesc_show_cmdlist
, "show tdesc ",
1842 0 /* allow-unknown */, &showlist
);
1843 add_prefix_cmd ("tdesc", class_maintenance
, unset_tdesc_cmd
, _("\
1844 Unset target description specific variables."),
1845 &tdesc_unset_cmdlist
, "unset tdesc ",
1846 0 /* allow-unknown */, &unsetlist
);
1848 add_setshow_filename_cmd ("filename", class_obscure
,
1849 &tdesc_filename_cmd_string
,
1851 Set the file to read for an XML target description"), _("\
1852 Show the file to read for an XML target description"), _("\
1853 When set, GDB will read the target description from a local\n\
1854 file instead of querying the remote target."),
1855 set_tdesc_filename_cmd
,
1856 show_tdesc_filename_cmd
,
1857 &tdesc_set_cmdlist
, &tdesc_show_cmdlist
);
1859 add_cmd ("filename", class_obscure
, unset_tdesc_filename_cmd
, _("\
1860 Unset the file to read for an XML target description. When unset,\n\
1861 GDB will read the description from the target."),
1862 &tdesc_unset_cmdlist
);
1864 add_cmd ("c-tdesc", class_maintenance
, maint_print_c_tdesc_cmd
, _("\
1865 Print the current target description as a C source file."),
1866 &maintenanceprintlist
);
1868 cmd_list_element
*cmd
;
1870 cmd
= add_cmd ("xml-descriptions", class_maintenance
,
1871 maintenance_check_xml_descriptions
, _("\
1872 Check the target descriptions created in GDB equal the descriptions\n\
1873 created from XML files in the directory.\n\
1874 The parameter is the directory name."),
1875 &maintenancechecklist
);
1876 set_cmd_completer (cmd
, filename_completer
);