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 void accept (tdesc_element_visitor
&v
) const override
340 for (const tdesc_feature_up
&feature
: features
)
346 bool operator== (const target_desc
&other
) const
348 if (arch
!= other
.arch
)
351 if (osabi
!= other
.osabi
)
354 if (features
.size () != other
.features
.size ())
357 for (int ix
= 0; ix
< features
.size (); ix
++)
359 const tdesc_feature_up
&feature1
= features
[ix
];
360 const tdesc_feature_up
&feature2
= other
.features
[ix
];
362 if (feature1
!= feature2
&& *feature1
!= *feature2
)
369 bool operator!= (const target_desc
&other
) const
371 return !(*this == other
);
375 /* Per-architecture data associated with a target description. The
376 target description may be shared by multiple architectures, but
377 this data is private to one gdbarch. */
379 struct tdesc_arch_reg
381 tdesc_arch_reg (tdesc_reg
*reg_
, struct type
*type_
)
382 : reg (reg_
), type (type_
)
385 struct tdesc_reg
*reg
;
389 struct tdesc_arch_data
391 /* A list of register/type pairs, indexed by GDB's internal register number.
392 During initialization of the gdbarch this list is used to store
393 registers which the architecture assigns a fixed register number.
394 Registers which are NULL in this array, or off the end, are
395 treated as zero-sized and nameless (i.e. placeholders in the
397 std::vector
<tdesc_arch_reg
> arch_regs
;
399 /* Functions which report the register name, type, and reggroups for
401 gdbarch_register_name_ftype
*pseudo_register_name
= NULL
;
402 gdbarch_register_type_ftype
*pseudo_register_type
= NULL
;
403 gdbarch_register_reggroup_p_ftype
*pseudo_register_reggroup_p
= NULL
;
406 /* Info about an inferior's target description. There's one of these
407 for each inferior. */
409 struct target_desc_info
411 /* A flag indicating that a description has already been fetched
412 from the target, so it should not be queried again. */
416 /* The description fetched from the target, or NULL if the target
417 did not supply any description. Only valid when
418 target_desc_fetched is set. Only the description initialization
419 code should access this; normally, the description should be
420 accessed through the gdbarch object. */
422 const struct target_desc
*tdesc
;
424 /* The filename to read a target description from, as set by "set
425 tdesc filename ..." */
430 /* Get the inferior INF's target description info, allocating one on
431 the stop if necessary. */
433 static struct target_desc_info
*
434 get_tdesc_info (struct inferior
*inf
)
436 if (inf
->tdesc_info
== NULL
)
437 inf
->tdesc_info
= XCNEW (struct target_desc_info
);
438 return inf
->tdesc_info
;
441 /* A handle for architecture-specific data associated with the
442 target description (see struct tdesc_arch_data). */
444 static struct gdbarch_data
*tdesc_data
;
446 /* See target-descriptions.h. */
449 target_desc_info_from_user_p (struct target_desc_info
*info
)
451 return info
!= NULL
&& info
->filename
!= NULL
;
454 /* See target-descriptions.h. */
457 copy_inferior_target_desc_info (struct inferior
*destinf
, struct inferior
*srcinf
)
459 struct target_desc_info
*src
= get_tdesc_info (srcinf
);
460 struct target_desc_info
*dest
= get_tdesc_info (destinf
);
462 dest
->fetched
= src
->fetched
;
463 dest
->tdesc
= src
->tdesc
;
464 dest
->filename
= src
->filename
!= NULL
? xstrdup (src
->filename
) : NULL
;
467 /* See target-descriptions.h. */
470 target_desc_info_free (struct target_desc_info
*tdesc_info
)
472 if (tdesc_info
!= NULL
)
474 xfree (tdesc_info
->filename
);
479 /* Convenience helper macros. */
481 #define target_desc_fetched \
482 get_tdesc_info (current_inferior ())->fetched
483 #define current_target_desc \
484 get_tdesc_info (current_inferior ())->tdesc
485 #define target_description_filename \
486 get_tdesc_info (current_inferior ())->filename
488 /* The string manipulated by the "set tdesc filename ..." command. */
490 static char *tdesc_filename_cmd_string
;
492 /* Fetch the current target's description, and switch the current
493 architecture to one which incorporates that description. */
496 target_find_description (void)
498 /* If we've already fetched a description from the target, don't do
499 it again. This allows a target to fetch the description early,
500 during its to_open or to_create_inferior, if it needs extra
501 information about the target to initialize. */
502 if (target_desc_fetched
)
505 /* The current architecture should not have any target description
506 specified. It should have been cleared, e.g. when we
507 disconnected from the previous target. */
508 gdb_assert (gdbarch_target_desc (target_gdbarch ()) == NULL
);
510 /* First try to fetch an XML description from the user-specified
512 current_target_desc
= NULL
;
513 if (target_description_filename
!= NULL
514 && *target_description_filename
!= '\0')
516 = file_read_description_xml (target_description_filename
);
518 /* Next try to read the description from the current target using
520 if (current_target_desc
== NULL
)
521 current_target_desc
= target_read_description_xml (¤t_target
);
523 /* If that failed try a target-specific hook. */
524 if (current_target_desc
== NULL
)
525 current_target_desc
= target_read_description (¤t_target
);
527 /* If a non-NULL description was returned, then update the current
529 if (current_target_desc
)
531 struct gdbarch_info info
;
533 gdbarch_info_init (&info
);
534 info
.target_desc
= current_target_desc
;
535 if (!gdbarch_update_p (info
))
536 warning (_("Architecture rejected target-supplied description"));
539 struct tdesc_arch_data
*data
;
541 data
= ((struct tdesc_arch_data
*)
542 gdbarch_data (target_gdbarch (), tdesc_data
));
543 if (tdesc_has_registers (current_target_desc
)
544 && data
->arch_regs
.empty ())
545 warning (_("Target-supplied registers are not supported "
546 "by the current architecture"));
550 /* Now that we know this description is usable, record that we
552 target_desc_fetched
= 1;
555 /* Discard any description fetched from the current target, and switch
556 the current architecture to one with no target description. */
559 target_clear_description (void)
561 struct gdbarch_info info
;
563 if (!target_desc_fetched
)
566 target_desc_fetched
= 0;
567 current_target_desc
= NULL
;
569 gdbarch_info_init (&info
);
570 if (!gdbarch_update_p (info
))
571 internal_error (__FILE__
, __LINE__
,
572 _("Could not remove target-supplied description"));
575 /* Return the global current target description. This should only be
576 used by gdbarch initialization code; most access should be through
577 an existing gdbarch. */
579 const struct target_desc
*
580 target_current_description (void)
582 if (target_desc_fetched
)
583 return current_target_desc
;
588 /* Return non-zero if this target description is compatible
589 with the given BFD architecture. */
592 tdesc_compatible_p (const struct target_desc
*target_desc
,
593 const struct bfd_arch_info
*arch
)
595 for (const bfd_arch_info
*compat
: target_desc
->compatible
)
598 || arch
->compatible (arch
, compat
)
599 || compat
->compatible (compat
, arch
))
607 /* Direct accessors for target descriptions. */
609 /* Return the string value of a property named KEY, or NULL if the
610 property was not specified. */
613 tdesc_property (const struct target_desc
*target_desc
, const char *key
)
615 for (const property
&prop
: target_desc
->properties
)
617 return prop
.value
.c_str ();
622 /* Return the BFD architecture associated with this target
623 description, or NULL if no architecture was specified. */
625 const struct bfd_arch_info
*
626 tdesc_architecture (const struct target_desc
*target_desc
)
628 return target_desc
->arch
;
631 /* Return the OSABI associated with this target description, or
632 GDB_OSABI_UNKNOWN if no osabi was specified. */
635 tdesc_osabi (const struct target_desc
*target_desc
)
637 return target_desc
->osabi
;
642 /* Return 1 if this target description includes any registers. */
645 tdesc_has_registers (const struct target_desc
*target_desc
)
647 if (target_desc
== NULL
)
650 for (const tdesc_feature_up
&feature
: target_desc
->features
)
651 if (!feature
->registers
.empty ())
657 /* Return the feature with the given name, if present, or NULL if
658 the named feature is not found. */
660 const struct tdesc_feature
*
661 tdesc_find_feature (const struct target_desc
*target_desc
,
664 for (const tdesc_feature_up
&feature
: target_desc
->features
)
665 if (feature
->name
== name
)
666 return feature
.get ();
671 /* Return the name of FEATURE. */
674 tdesc_feature_name (const struct tdesc_feature
*feature
)
676 return feature
->name
.c_str ();
679 /* Lookup type associated with ID. */
682 tdesc_find_type (struct gdbarch
*gdbarch
, const char *id
)
684 tdesc_arch_data
*data
685 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
687 for (const tdesc_arch_reg
®
: data
->arch_regs
)
690 && reg
.reg
->tdesc_type
692 && reg
.reg
->tdesc_type
->name
== id
)
699 /* Support for registers from target descriptions. */
701 /* Construct the per-gdbarch data. */
704 tdesc_data_init (struct obstack
*obstack
)
706 struct tdesc_arch_data
*data
;
708 data
= OBSTACK_ZALLOC (obstack
, struct tdesc_arch_data
);
709 new (data
) tdesc_arch_data ();
714 /* Similar, but for the temporary copy used during architecture
717 struct tdesc_arch_data
*
718 tdesc_data_alloc (void)
720 return new tdesc_arch_data ();
723 /* Free something allocated by tdesc_data_alloc, if it is not going
724 to be used (for instance if it was unsuitable for the
728 tdesc_data_cleanup (void *data_untyped
)
730 struct tdesc_arch_data
*data
= (struct tdesc_arch_data
*) data_untyped
;
735 /* Search FEATURE for a register named NAME. */
737 static struct tdesc_reg
*
738 tdesc_find_register_early (const struct tdesc_feature
*feature
,
741 for (const tdesc_reg_up
®
: feature
->registers
)
742 if (strcasecmp (reg
->name
.c_str (), name
) == 0)
748 /* Search FEATURE for a register named NAME. Assign REGNO to it. */
751 tdesc_numbered_register (const struct tdesc_feature
*feature
,
752 struct tdesc_arch_data
*data
,
753 int regno
, const char *name
)
755 struct tdesc_reg
*reg
= tdesc_find_register_early (feature
, name
);
760 /* Make sure the vector includes a REGNO'th element. */
761 while (regno
>= data
->arch_regs
.size ())
762 data
->arch_regs
.emplace_back (nullptr, nullptr);
764 data
->arch_regs
[regno
] = tdesc_arch_reg (reg
, NULL
);
769 /* Search FEATURE for a register named NAME, but do not assign a fixed
770 register number to it. */
773 tdesc_unnumbered_register (const struct tdesc_feature
*feature
,
776 struct tdesc_reg
*reg
= tdesc_find_register_early (feature
, name
);
784 /* Search FEATURE for a register whose name is in NAMES and assign
788 tdesc_numbered_register_choices (const struct tdesc_feature
*feature
,
789 struct tdesc_arch_data
*data
,
790 int regno
, const char *const names
[])
794 for (i
= 0; names
[i
] != NULL
; i
++)
795 if (tdesc_numbered_register (feature
, data
, regno
, names
[i
]))
801 /* Search FEATURE for a register named NAME, and return its size in
802 bits. The register must exist. */
805 tdesc_register_size (const struct tdesc_feature
*feature
,
808 struct tdesc_reg
*reg
= tdesc_find_register_early (feature
, name
);
810 gdb_assert (reg
!= NULL
);
814 /* Look up a register by its GDB internal register number. */
816 static struct tdesc_arch_reg
*
817 tdesc_find_arch_register (struct gdbarch
*gdbarch
, int regno
)
819 struct tdesc_arch_data
*data
;
821 data
= (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
822 if (regno
< data
->arch_regs
.size ())
823 return &data
->arch_regs
[regno
];
828 static struct tdesc_reg
*
829 tdesc_find_register (struct gdbarch
*gdbarch
, int regno
)
831 struct tdesc_arch_reg
*reg
= tdesc_find_arch_register (gdbarch
, regno
);
833 return reg
? reg
->reg
: NULL
;
836 /* Return the name of register REGNO, from the target description or
837 from an architecture-provided pseudo_register_name method. */
840 tdesc_register_name (struct gdbarch
*gdbarch
, int regno
)
842 struct tdesc_reg
*reg
= tdesc_find_register (gdbarch
, regno
);
843 int num_regs
= gdbarch_num_regs (gdbarch
);
844 int num_pseudo_regs
= gdbarch_num_pseudo_regs (gdbarch
);
847 return reg
->name
.c_str ();
849 if (regno
>= num_regs
&& regno
< num_regs
+ num_pseudo_regs
)
851 struct tdesc_arch_data
*data
852 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
854 gdb_assert (data
->pseudo_register_name
!= NULL
);
855 return data
->pseudo_register_name (gdbarch
, regno
);
862 tdesc_register_type (struct gdbarch
*gdbarch
, int regno
)
864 struct tdesc_arch_reg
*arch_reg
= tdesc_find_arch_register (gdbarch
, regno
);
865 struct tdesc_reg
*reg
= arch_reg
? arch_reg
->reg
: NULL
;
866 int num_regs
= gdbarch_num_regs (gdbarch
);
867 int num_pseudo_regs
= gdbarch_num_pseudo_regs (gdbarch
);
869 if (reg
== NULL
&& 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_type
!= NULL
);
875 return data
->pseudo_register_type (gdbarch
, regno
);
879 /* Return "int0_t", since "void" has a misleading size of one. */
880 return builtin_type (gdbarch
)->builtin_int0
;
882 if (arch_reg
->type
== NULL
)
884 /* First check for a predefined or target defined type. */
886 arch_reg
->type
= make_gdb_type (gdbarch
, reg
->tdesc_type
);
888 /* Next try size-sensitive type shortcuts. */
889 else if (reg
->type
== "float")
891 if (reg
->bitsize
== gdbarch_float_bit (gdbarch
))
892 arch_reg
->type
= builtin_type (gdbarch
)->builtin_float
;
893 else if (reg
->bitsize
== gdbarch_double_bit (gdbarch
))
894 arch_reg
->type
= builtin_type (gdbarch
)->builtin_double
;
895 else if (reg
->bitsize
== gdbarch_long_double_bit (gdbarch
))
896 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long_double
;
899 warning (_("Register \"%s\" has an unsupported size (%d bits)"),
900 reg
->name
.c_str (), reg
->bitsize
);
901 arch_reg
->type
= builtin_type (gdbarch
)->builtin_double
;
904 else if (reg
->type
== "int")
906 if (reg
->bitsize
== gdbarch_long_bit (gdbarch
))
907 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long
;
908 else if (reg
->bitsize
== TARGET_CHAR_BIT
)
909 arch_reg
->type
= builtin_type (gdbarch
)->builtin_char
;
910 else if (reg
->bitsize
== gdbarch_short_bit (gdbarch
))
911 arch_reg
->type
= builtin_type (gdbarch
)->builtin_short
;
912 else if (reg
->bitsize
== gdbarch_int_bit (gdbarch
))
913 arch_reg
->type
= builtin_type (gdbarch
)->builtin_int
;
914 else if (reg
->bitsize
== gdbarch_long_long_bit (gdbarch
))
915 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long_long
;
916 else if (reg
->bitsize
== gdbarch_ptr_bit (gdbarch
))
917 /* A bit desperate by this point... */
918 arch_reg
->type
= builtin_type (gdbarch
)->builtin_data_ptr
;
921 warning (_("Register \"%s\" has an unsupported size (%d bits)"),
922 reg
->name
.c_str (), reg
->bitsize
);
923 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long
;
927 if (arch_reg
->type
== NULL
)
928 internal_error (__FILE__
, __LINE__
,
929 "Register \"%s\" has an unknown type \"%s\"",
930 reg
->name
.c_str (), reg
->type
.c_str ());
933 return arch_reg
->type
;
937 tdesc_remote_register_number (struct gdbarch
*gdbarch
, int regno
)
939 struct tdesc_reg
*reg
= tdesc_find_register (gdbarch
, regno
);
942 return reg
->target_regnum
;
947 /* Check whether REGNUM is a member of REGGROUP. Registers from the
948 target description may be classified as general, float, vector or other
949 register groups registered with reggroup_add(). Unlike a gdbarch
950 register_reggroup_p method, this function will return -1 if it does not
951 know; the caller should handle registers with no specified group.
953 The names of containing features are not used. This might be extended
954 to display registers in some more useful groupings.
956 The save-restore flag is also implemented here. */
959 tdesc_register_in_reggroup_p (struct gdbarch
*gdbarch
, int regno
,
960 struct reggroup
*reggroup
)
962 struct tdesc_reg
*reg
= tdesc_find_register (gdbarch
, regno
);
964 if (reg
!= NULL
&& !reg
->group
.empty ()
965 && (reg
->group
== reggroup_name (reggroup
)))
969 && (reggroup
== save_reggroup
|| reggroup
== restore_reggroup
))
970 return reg
->save_restore
;
975 /* Check whether REGNUM is a member of REGGROUP. Registers with no
976 group specified go to the default reggroup function and are handled
980 tdesc_register_reggroup_p (struct gdbarch
*gdbarch
, int regno
,
981 struct reggroup
*reggroup
)
983 int num_regs
= gdbarch_num_regs (gdbarch
);
984 int num_pseudo_regs
= gdbarch_num_pseudo_regs (gdbarch
);
987 if (regno
>= num_regs
&& regno
< num_regs
+ num_pseudo_regs
)
989 struct tdesc_arch_data
*data
990 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
992 if (data
->pseudo_register_reggroup_p
!= NULL
)
993 return data
->pseudo_register_reggroup_p (gdbarch
, regno
, reggroup
);
994 /* Otherwise fall through to the default reggroup_p. */
997 ret
= tdesc_register_in_reggroup_p (gdbarch
, regno
, reggroup
);
1001 return default_register_reggroup_p (gdbarch
, regno
, reggroup
);
1004 /* Record architecture-specific functions to call for pseudo-register
1008 set_tdesc_pseudo_register_name (struct gdbarch
*gdbarch
,
1009 gdbarch_register_name_ftype
*pseudo_name
)
1011 struct tdesc_arch_data
*data
1012 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1014 data
->pseudo_register_name
= pseudo_name
;
1018 set_tdesc_pseudo_register_type (struct gdbarch
*gdbarch
,
1019 gdbarch_register_type_ftype
*pseudo_type
)
1021 struct tdesc_arch_data
*data
1022 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1024 data
->pseudo_register_type
= pseudo_type
;
1028 set_tdesc_pseudo_register_reggroup_p
1029 (struct gdbarch
*gdbarch
,
1030 gdbarch_register_reggroup_p_ftype
*pseudo_reggroup_p
)
1032 struct tdesc_arch_data
*data
1033 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1035 data
->pseudo_register_reggroup_p
= pseudo_reggroup_p
;
1038 /* Update GDBARCH to use the target description for registers. */
1041 tdesc_use_registers (struct gdbarch
*gdbarch
,
1042 const struct target_desc
*target_desc
,
1043 struct tdesc_arch_data
*early_data
)
1045 int num_regs
= gdbarch_num_regs (gdbarch
);
1046 struct tdesc_arch_data
*data
;
1049 /* We can't use the description for registers if it doesn't describe
1050 any. This function should only be called after validating
1051 registers, so the caller should know that registers are
1053 gdb_assert (tdesc_has_registers (target_desc
));
1055 data
= (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1056 data
->arch_regs
= early_data
->arch_regs
;
1059 /* Build up a set of all registers, so that we can assign register
1060 numbers where needed. The hash table expands as necessary, so
1061 the initial size is arbitrary. */
1062 reg_hash
= htab_create (37, htab_hash_pointer
, htab_eq_pointer
, NULL
);
1063 for (const tdesc_feature_up
&feature
: target_desc
->features
)
1064 for (const tdesc_reg_up
®
: feature
->registers
)
1066 void **slot
= htab_find_slot (reg_hash
, reg
.get (), INSERT
);
1069 /* Add reggroup if its new. */
1070 if (!reg
->group
.empty ())
1071 if (reggroup_find (gdbarch
, reg
->group
.c_str ()) == NULL
)
1072 reggroup_add (gdbarch
, reggroup_gdbarch_new (gdbarch
,
1073 reg
->group
.c_str (),
1077 /* Remove any registers which were assigned numbers by the
1079 for (const tdesc_arch_reg
&arch_reg
: data
->arch_regs
)
1080 if (arch_reg
.reg
!= NULL
)
1081 htab_remove_elt (reg_hash
, arch_reg
.reg
);
1083 /* Assign numbers to the remaining registers and add them to the
1084 list of registers. The new numbers are always above gdbarch_num_regs.
1085 Iterate over the features, not the hash table, so that the order
1086 matches that in the target description. */
1088 gdb_assert (data
->arch_regs
.size () <= num_regs
);
1089 while (data
->arch_regs
.size () < num_regs
)
1090 data
->arch_regs
.emplace_back (nullptr, nullptr);
1092 for (const tdesc_feature_up
&feature
: target_desc
->features
)
1093 for (const tdesc_reg_up
®
: feature
->registers
)
1094 if (htab_find (reg_hash
, reg
.get ()) != NULL
)
1096 data
->arch_regs
.emplace_back (reg
.get (), nullptr);
1100 htab_delete (reg_hash
);
1102 /* Update the architecture. */
1103 set_gdbarch_num_regs (gdbarch
, num_regs
);
1104 set_gdbarch_register_name (gdbarch
, tdesc_register_name
);
1105 set_gdbarch_register_type (gdbarch
, tdesc_register_type
);
1106 set_gdbarch_remote_register_number (gdbarch
,
1107 tdesc_remote_register_number
);
1108 set_gdbarch_register_reggroup_p (gdbarch
, tdesc_register_reggroup_p
);
1111 /* See common/tdesc.h. */
1113 struct tdesc_feature
*
1114 tdesc_create_feature (struct target_desc
*tdesc
, const char *name
,
1117 struct tdesc_feature
*new_feature
= new tdesc_feature (name
);
1119 tdesc
->features
.emplace_back (new_feature
);
1124 struct target_desc
*
1125 allocate_target_description (void)
1127 return new target_desc ();
1131 free_target_description (void *arg
)
1133 struct target_desc
*target_desc
= (struct target_desc
*) arg
;
1139 make_cleanup_free_target_description (struct target_desc
*target_desc
)
1141 return make_cleanup (free_target_description
, target_desc
);
1145 tdesc_add_compatible (struct target_desc
*target_desc
,
1146 const struct bfd_arch_info
*compatible
)
1148 /* If this instance of GDB is compiled without BFD support for the
1149 compatible architecture, simply ignore it -- we would not be able
1150 to handle it anyway. */
1151 if (compatible
== NULL
)
1154 for (const bfd_arch_info
*compat
: target_desc
->compatible
)
1155 if (compat
== compatible
)
1156 internal_error (__FILE__
, __LINE__
,
1157 _("Attempted to add duplicate "
1158 "compatible architecture \"%s\""),
1159 compatible
->printable_name
);
1161 target_desc
->compatible
.push_back (compatible
);
1165 set_tdesc_property (struct target_desc
*target_desc
,
1166 const char *key
, const char *value
)
1168 gdb_assert (key
!= NULL
&& value
!= NULL
);
1170 if (tdesc_property (target_desc
, key
) != NULL
)
1171 internal_error (__FILE__
, __LINE__
,
1172 _("Attempted to add duplicate property \"%s\""), key
);
1174 target_desc
->properties
.emplace_back (key
, value
);
1177 /* See common/tdesc.h. */
1180 set_tdesc_architecture (struct target_desc
*target_desc
,
1183 set_tdesc_architecture (target_desc
, bfd_scan_arch (name
));
1187 set_tdesc_architecture (struct target_desc
*target_desc
,
1188 const struct bfd_arch_info
*arch
)
1190 target_desc
->arch
= arch
;
1193 /* See common/tdesc.h. */
1196 set_tdesc_osabi (struct target_desc
*target_desc
, const char *name
)
1198 set_tdesc_osabi (target_desc
, osabi_from_tdesc_string (name
));
1202 set_tdesc_osabi (struct target_desc
*target_desc
, enum gdb_osabi osabi
)
1204 target_desc
->osabi
= osabi
;
1208 static struct cmd_list_element
*tdesc_set_cmdlist
, *tdesc_show_cmdlist
;
1209 static struct cmd_list_element
*tdesc_unset_cmdlist
;
1211 /* Helper functions for the CLI commands. */
1214 set_tdesc_cmd (const char *args
, int from_tty
)
1216 help_list (tdesc_set_cmdlist
, "set tdesc ", all_commands
, gdb_stdout
);
1220 show_tdesc_cmd (const char *args
, int from_tty
)
1222 cmd_show_list (tdesc_show_cmdlist
, from_tty
, "");
1226 unset_tdesc_cmd (const char *args
, int from_tty
)
1228 help_list (tdesc_unset_cmdlist
, "unset tdesc ", all_commands
, gdb_stdout
);
1232 set_tdesc_filename_cmd (const char *args
, int from_tty
,
1233 struct cmd_list_element
*c
)
1235 xfree (target_description_filename
);
1236 target_description_filename
= xstrdup (tdesc_filename_cmd_string
);
1238 target_clear_description ();
1239 target_find_description ();
1243 show_tdesc_filename_cmd (struct ui_file
*file
, int from_tty
,
1244 struct cmd_list_element
*c
,
1247 value
= target_description_filename
;
1249 if (value
!= NULL
&& *value
!= '\0')
1250 printf_filtered (_("The target description will be read from \"%s\".\n"),
1253 printf_filtered (_("The target description will be "
1254 "read from the target.\n"));
1258 unset_tdesc_filename_cmd (const char *args
, int from_tty
)
1260 xfree (target_description_filename
);
1261 target_description_filename
= NULL
;
1262 target_clear_description ();
1263 target_find_description ();
1266 /* Print target description in C. */
1268 class print_c_tdesc
: public tdesc_element_visitor
1271 print_c_tdesc (std::string
&filename_after_features
)
1272 : m_filename_after_features (filename_after_features
)
1276 const char *filename
= lbasename (m_filename_after_features
.c_str ());
1278 m_function
= (char *) xmalloc (strlen (filename
) + 1);
1279 for (inp
= filename
, outp
= m_function
; *inp
!= '\0'; inp
++)
1282 else if (*inp
== '-')
1288 /* Standard boilerplate. */
1289 printf_unfiltered ("/* THIS FILE IS GENERATED. "
1290 "-*- buffer-read-only: t -*- vi"
1299 void visit_pre (const target_desc
*e
) override
1301 printf_unfiltered (" Original: %s */\n\n",
1302 lbasename (m_filename_after_features
.c_str ()));
1304 printf_unfiltered ("#include \"defs.h\"\n");
1305 printf_unfiltered ("#include \"osabi.h\"\n");
1306 printf_unfiltered ("#include \"target-descriptions.h\"\n");
1307 printf_unfiltered ("\n");
1309 printf_unfiltered ("struct target_desc *tdesc_%s;\n", m_function
);
1310 printf_unfiltered ("static void\n");
1311 printf_unfiltered ("initialize_tdesc_%s (void)\n", m_function
);
1312 printf_unfiltered ("{\n");
1314 (" struct target_desc *result = allocate_target_description ();\n");
1316 if (tdesc_architecture (e
) != NULL
)
1319 (" set_tdesc_architecture (result, bfd_scan_arch (\"%s\"));\n",
1320 tdesc_architecture (e
)->printable_name
);
1321 printf_unfiltered ("\n");
1323 if (tdesc_osabi (e
) > GDB_OSABI_UNKNOWN
1324 && tdesc_osabi (e
) < GDB_OSABI_INVALID
)
1327 (" set_tdesc_osabi (result, osabi_from_tdesc_string (\"%s\"));\n",
1328 gdbarch_osabi_name (tdesc_osabi (e
)));
1329 printf_unfiltered ("\n");
1332 for (const bfd_arch_info_type
*compatible
: e
->compatible
)
1334 (" tdesc_add_compatible (result, bfd_scan_arch (\"%s\"));\n",
1335 compatible
->printable_name
);
1337 if (!e
->compatible
.empty ())
1338 printf_unfiltered ("\n");
1340 for (const property
&prop
: e
->properties
)
1341 printf_unfiltered (" set_tdesc_property (result, \"%s\", \"%s\");\n",
1342 prop
.key
.c_str (), prop
.value
.c_str ());
1344 printf_unfiltered (" struct tdesc_feature *feature;\n");
1347 void visit_pre (const tdesc_feature
*e
) override
1349 printf_unfiltered ("\n feature = tdesc_create_feature (result, \"%s\");\n",
1353 void visit_post (const tdesc_feature
*e
) override
1356 void visit_post (const target_desc
*e
) override
1358 printf_unfiltered ("\n tdesc_%s = result;\n", m_function
);
1359 printf_unfiltered ("}\n");
1362 void visit (const tdesc_type_builtin
*type
) override
1364 error (_("C output is not supported type \"%s\"."), type
->name
.c_str ());
1367 void visit (const tdesc_type_vector
*type
) override
1369 if (!m_printed_element_type
)
1371 printf_unfiltered (" tdesc_type *element_type;\n");
1372 m_printed_element_type
= true;
1376 (" element_type = tdesc_named_type (feature, \"%s\");\n",
1377 type
->element_type
->name
.c_str ());
1379 (" tdesc_create_vector (feature, \"%s\", element_type, %d);\n",
1380 type
->name
.c_str (), type
->count
);
1382 printf_unfiltered ("\n");
1385 void visit (const tdesc_type_with_fields
*type
) override
1387 if (!m_printed_type_with_fields
)
1389 printf_unfiltered (" tdesc_type_with_fields *type_with_fields;\n");
1390 m_printed_type_with_fields
= true;
1395 case TDESC_TYPE_STRUCT
:
1396 case TDESC_TYPE_FLAGS
:
1397 if (type
->kind
== TDESC_TYPE_STRUCT
)
1400 (" type_with_fields = tdesc_create_struct (feature, \"%s\");\n",
1401 type
->name
.c_str ());
1402 if (type
->size
!= 0)
1404 (" tdesc_set_struct_size (type_with_fields, %d);\n", type
->size
);
1409 (" type_with_fields = tdesc_create_flags (feature, \"%s\", %d);\n",
1410 type
->name
.c_str (), type
->size
);
1412 for (const tdesc_type_field
&f
: type
->fields
)
1414 const char *type_name
;
1416 gdb_assert (f
.type
!= NULL
);
1417 type_name
= f
.type
->name
.c_str ();
1419 /* To minimize changes to generated files, don't emit type
1420 info for fields that have defaulted types. */
1423 gdb_assert (f
.end
!= -1);
1424 if (f
.type
->kind
== TDESC_TYPE_BOOL
)
1426 gdb_assert (f
.start
== f
.end
);
1428 (" tdesc_add_flag (type_with_fields, %d, \"%s\");\n",
1429 f
.start
, f
.name
.c_str ());
1431 else if ((type
->size
== 4 && f
.type
->kind
== TDESC_TYPE_UINT32
)
1433 && f
.type
->kind
== TDESC_TYPE_UINT64
))
1436 (" tdesc_add_bitfield (type_with_fields, \"%s\", %d, %d);\n",
1437 f
.name
.c_str (), f
.start
, f
.end
);
1441 printf_field_type_assignment
1442 ("tdesc_named_type (feature, \"%s\");\n",
1445 (" tdesc_add_typed_bitfield (type_with_fields, \"%s\","
1446 " %d, %d, field_type);\n",
1447 f
.name
.c_str (), f
.start
, f
.end
);
1450 else /* Not a bitfield. */
1452 gdb_assert (f
.end
== -1);
1453 gdb_assert (type
->kind
== TDESC_TYPE_STRUCT
);
1454 printf_field_type_assignment
1455 ("tdesc_named_type (feature, \"%s\");\n", type_name
);
1457 (" tdesc_add_field (type_with_fields, \"%s\", field_type);\n",
1462 case TDESC_TYPE_UNION
:
1464 (" type_with_fields = tdesc_create_union (feature, \"%s\");\n",
1465 type
->name
.c_str ());
1466 for (const tdesc_type_field
&f
: type
->fields
)
1468 printf_field_type_assignment
1469 ("tdesc_named_type (feature, \"%s\");\n", f
.type
->name
.c_str ());
1471 (" tdesc_add_field (type_with_fields, \"%s\", field_type);\n",
1475 case TDESC_TYPE_ENUM
:
1477 (" type_with_fields = tdesc_create_enum (feature, \"%s\", %d);\n",
1478 type
->name
.c_str (), type
->size
);
1479 for (const tdesc_type_field
&f
: type
->fields
)
1481 (" tdesc_add_enum_value (type_with_fields, %d, \"%s\");\n",
1482 f
.start
, f
.name
.c_str ());
1485 error (_("C output is not supported type \"%s\"."), type
->name
.c_str ());
1488 printf_unfiltered ("\n");
1491 void visit (const tdesc_reg
*reg
) override
1493 printf_unfiltered (" tdesc_create_reg (feature, \"%s\", %ld, %d, ",
1494 reg
->name
.c_str (), reg
->target_regnum
,
1496 if (!reg
->group
.empty ())
1497 printf_unfiltered ("\"%s\", ", reg
->group
.c_str ());
1499 printf_unfiltered ("NULL, ");
1500 printf_unfiltered ("%d, \"%s\");\n", reg
->bitsize
, reg
->type
.c_str ());
1504 std::string m_filename_after_features
;
1508 /* Print an assignment to the field_type variable. Print the declaration
1509 of field_type if that has not been done yet. */
1510 ATTRIBUTE_PRINTF (2, 3)
1511 void printf_field_type_assignment (const char *fmt
, ...)
1513 if (!m_printed_field_type
)
1515 printf_unfiltered (" tdesc_type *field_type;\n");
1516 m_printed_field_type
= true;
1519 printf_unfiltered (" field_type = ");
1522 va_start (args
, fmt
);
1523 vprintf_unfiltered (fmt
, args
);
1529 /* Did we print "struct tdesc_type *element_type;" yet? */
1530 bool m_printed_element_type
= false;
1532 /* Did we print "struct tdesc_type_with_fields *element_type;" yet? */
1533 bool m_printed_type_with_fields
= false;
1535 /* Did we print "struct tdesc_type *field_type;" yet? */
1536 bool m_printed_field_type
= false;
1539 /* Print target description feature in C. */
1541 class print_c_feature
: public print_c_tdesc
1544 print_c_feature (std::string
&file
)
1545 : print_c_tdesc (file
)
1548 auto const pos
= m_filename_after_features
.find_last_of ('.');
1550 m_filename_after_features
= m_filename_after_features
.substr (0, pos
);
1553 void visit_pre (const target_desc
*e
) override
1555 printf_unfiltered (" Original: %s */\n\n",
1556 lbasename (m_filename_after_features
.c_str ()));
1558 printf_unfiltered ("#include \"common/tdesc.h\"\n");
1559 printf_unfiltered ("\n");
1562 void visit_post (const target_desc
*e
) override
1565 void visit_pre (const tdesc_feature
*e
) override
1567 std::string
name (m_filename_after_features
);
1569 auto pos
= name
.find_first_of ('.');
1571 name
= name
.substr (0, pos
);
1572 std::replace (name
.begin (), name
.end (), '/', '_');
1573 std::replace (name
.begin (), name
.end (), '-', '_');
1575 printf_unfiltered ("static int\n");
1576 printf_unfiltered ("create_feature_%s ", name
.c_str ());
1577 printf_unfiltered ("(struct target_desc *result, long regnum)\n");
1579 printf_unfiltered ("{\n");
1580 printf_unfiltered (" struct tdesc_feature *feature;\n");
1583 ("\n feature = tdesc_create_feature (result, \"%s\", \"%s\");\n",
1584 e
->name
.c_str (), lbasename (m_filename_after_features
.c_str ()));
1587 void visit_post (const tdesc_feature
*e
) override
1589 printf_unfiltered (" return regnum;\n");
1590 printf_unfiltered ("}\n");
1593 void visit (const tdesc_reg
*reg
) override
1595 /* Most "reg" in XML target descriptions don't have "regnum"
1596 attribute, so the register number is allocated sequentially.
1597 In case that reg has "regnum" attribute, register number
1598 should be set by that explicitly. */
1600 if (reg
->target_regnum
< m_next_regnum
)
1602 /* The integrity check, it can catch some errors on register
1603 number collision, like this,
1605 <reg name="x0" bitsize="32"/>
1606 <reg name="x1" bitsize="32"/>
1607 <reg name="x2" bitsize="32"/>
1608 <reg name="x3" bitsize="32"/>
1609 <reg name="ps" bitsize="32" regnum="3"/>
1611 but it also has false negatives. The target description
1614 <reg name="x1" bitsize="32" regnum="1"/>
1615 <reg name="x3" bitsize="32" regnum="3"/>
1616 <reg name="x2" bitsize="32" regnum="2"/>
1617 <reg name="x4" bitsize="32" regnum="4"/>
1619 but it is not a good practice, so still error on this,
1620 and also print the message so that it can be saved in the
1621 generated c file. */
1623 printf_unfiltered ("ERROR: \"regnum\" attribute %ld ",
1624 reg
->target_regnum
);
1625 printf_unfiltered ("is not the largest number (%d).\n",
1627 error (_("\"regnum\" attribute %ld is not the largest number (%d)."),
1628 reg
->target_regnum
, m_next_regnum
);
1631 if (reg
->target_regnum
> m_next_regnum
)
1633 printf_unfiltered (" regnum = %ld;\n", reg
->target_regnum
);
1634 m_next_regnum
= reg
->target_regnum
;
1637 printf_unfiltered (" tdesc_create_reg (feature, \"%s\", regnum++, %d, ",
1638 reg
->name
.c_str (), reg
->save_restore
);
1639 if (!reg
->group
.empty ())
1640 printf_unfiltered ("\"%s\", ", reg
->group
.c_str ());
1642 printf_unfiltered ("NULL, ");
1643 printf_unfiltered ("%d, \"%s\");\n", reg
->bitsize
, reg
->type
.c_str ());
1649 /* The register number to use for the next register we see. */
1650 int m_next_regnum
= 0;
1654 maint_print_c_tdesc_cmd (const char *args
, int from_tty
)
1656 const struct target_desc
*tdesc
;
1657 const char *filename
;
1661 /* Use the global target-supplied description, not the current
1662 architecture's. This lets a GDB for one architecture generate C
1663 for another architecture's description, even though the gdbarch
1664 initialization code will reject the new description. */
1665 tdesc
= current_target_desc
;
1666 filename
= target_description_filename
;
1670 /* Use the target description from the XML file. */
1672 tdesc
= file_read_description_xml (filename
);
1676 error (_("There is no target description to print."));
1678 if (filename
== NULL
)
1679 error (_("The current target description did not come from an XML file."));
1681 std::string
filename_after_features (filename
);
1682 auto loc
= filename_after_features
.rfind ("/features/");
1684 if (loc
!= std::string::npos
)
1685 filename_after_features
= filename_after_features
.substr (loc
+ 10);
1687 /* Print c files for target features instead of target descriptions,
1688 because c files got from target features are more flexible than the
1690 if (startswith (filename_after_features
.c_str (), "i386/32bit-")
1691 || startswith (filename_after_features
.c_str (), "i386/64bit-")
1692 || startswith (filename_after_features
.c_str (), "i386/x32-core.xml")
1693 || startswith (filename_after_features
.c_str (), "tic6x-")
1694 || startswith (filename_after_features
.c_str (), "aarch64"))
1696 print_c_feature
v (filename_after_features
);
1702 print_c_tdesc
v (filename_after_features
);
1708 namespace selftests
{
1710 static std::vector
<std::pair
<const char*, const target_desc
*>> xml_tdesc
;
1714 /* See target-descritpions.h. */
1717 record_xml_tdesc (const char *xml_file
, const struct target_desc
*tdesc
)
1719 xml_tdesc
.emplace_back (xml_file
, tdesc
);
1725 /* Check that the target descriptions created dynamically by
1726 architecture-specific code equal the descriptions created from XML files
1727 found in the specified directory DIR. */
1730 maintenance_check_xml_descriptions (const char *dir
, int from_tty
)
1733 error (_("Missing dir name"));
1735 gdb::unique_xmalloc_ptr
<char> dir1 (tilde_expand (dir
));
1736 std::string
feature_dir (dir1
.get ());
1737 unsigned int failed
= 0;
1739 for (auto const &e
: selftests::xml_tdesc
)
1741 std::string tdesc_xml
= (feature_dir
+ SLASH_STRING
+ e
.first
);
1742 const target_desc
*tdesc
1743 = file_read_description_xml (tdesc_xml
.data ());
1745 if (tdesc
== NULL
|| *tdesc
!= *e
.second
)
1748 printf_filtered (_("Tested %lu XML files, %d failed\n"),
1749 (long) selftests::xml_tdesc
.size (), failed
);
1753 _initialize_target_descriptions (void)
1755 tdesc_data
= gdbarch_data_register_pre_init (tdesc_data_init
);
1757 add_prefix_cmd ("tdesc", class_maintenance
, set_tdesc_cmd
, _("\
1758 Set target description specific variables."),
1759 &tdesc_set_cmdlist
, "set tdesc ",
1760 0 /* allow-unknown */, &setlist
);
1761 add_prefix_cmd ("tdesc", class_maintenance
, show_tdesc_cmd
, _("\
1762 Show target description specific variables."),
1763 &tdesc_show_cmdlist
, "show tdesc ",
1764 0 /* allow-unknown */, &showlist
);
1765 add_prefix_cmd ("tdesc", class_maintenance
, unset_tdesc_cmd
, _("\
1766 Unset target description specific variables."),
1767 &tdesc_unset_cmdlist
, "unset tdesc ",
1768 0 /* allow-unknown */, &unsetlist
);
1770 add_setshow_filename_cmd ("filename", class_obscure
,
1771 &tdesc_filename_cmd_string
,
1773 Set the file to read for an XML target description"), _("\
1774 Show the file to read for an XML target description"), _("\
1775 When set, GDB will read the target description from a local\n\
1776 file instead of querying the remote target."),
1777 set_tdesc_filename_cmd
,
1778 show_tdesc_filename_cmd
,
1779 &tdesc_set_cmdlist
, &tdesc_show_cmdlist
);
1781 add_cmd ("filename", class_obscure
, unset_tdesc_filename_cmd
, _("\
1782 Unset the file to read for an XML target description. When unset,\n\
1783 GDB will read the description from the target."),
1784 &tdesc_unset_cmdlist
);
1786 add_cmd ("c-tdesc", class_maintenance
, maint_print_c_tdesc_cmd
, _("\
1787 Print the current target description as a C source file."),
1788 &maintenanceprintlist
);
1790 cmd_list_element
*cmd
;
1792 cmd
= add_cmd ("xml-descriptions", class_maintenance
,
1793 maintenance_check_xml_descriptions
, _("\
1794 Check the target descriptions created in GDB equal the descriptions\n\
1795 created from XML files in the directory.\n\
1796 The parameter is the directory name."),
1797 &maintenancechecklist
);
1798 set_cmd_completer (cmd
, filename_completer
);