1 /* Target description support for GDB.
3 Copyright (C) 2006-2018 Free Software Foundation, Inc.
5 Contributed by CodeSourcery.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "arch-utils.h"
26 #include "reggroups.h"
28 #include "target-descriptions.h"
30 #include "xml-support.h"
31 #include "xml-tdesc.h"
34 #include "gdb_obstack.h"
38 #include "completer.h"
39 #include "readline/tilde.h" /* tilde_expand */
45 property (const std::string &key_, const std::string &value_)
46 : key (key_), value (value_)
53 /* Convert a tdesc_type to a gdb type. */
56 make_gdb_type (struct gdbarch *gdbarch, struct tdesc_type *ttype)
58 class gdb_type_creator : public tdesc_element_visitor
61 gdb_type_creator (struct gdbarch *gdbarch)
70 void visit (const tdesc_type_builtin *e) override
74 /* Predefined types. */
76 m_type = builtin_type (m_gdbarch)->builtin_bool;
79 m_type = builtin_type (m_gdbarch)->builtin_int8;
81 case TDESC_TYPE_INT16:
82 m_type = builtin_type (m_gdbarch)->builtin_int16;
84 case TDESC_TYPE_INT32:
85 m_type = builtin_type (m_gdbarch)->builtin_int32;
87 case TDESC_TYPE_INT64:
88 m_type = builtin_type (m_gdbarch)->builtin_int64;
90 case TDESC_TYPE_INT128:
91 m_type = builtin_type (m_gdbarch)->builtin_int128;
93 case TDESC_TYPE_UINT8:
94 m_type = builtin_type (m_gdbarch)->builtin_uint8;
96 case TDESC_TYPE_UINT16:
97 m_type = builtin_type (m_gdbarch)->builtin_uint16;
99 case TDESC_TYPE_UINT32:
100 m_type = builtin_type (m_gdbarch)->builtin_uint32;
102 case TDESC_TYPE_UINT64:
103 m_type = builtin_type (m_gdbarch)->builtin_uint64;
105 case TDESC_TYPE_UINT128:
106 m_type = builtin_type (m_gdbarch)->builtin_uint128;
108 case TDESC_TYPE_CODE_PTR:
109 m_type = builtin_type (m_gdbarch)->builtin_func_ptr;
111 case TDESC_TYPE_DATA_PTR:
112 m_type = builtin_type (m_gdbarch)->builtin_data_ptr;
116 m_type = tdesc_find_type (m_gdbarch, e->name.c_str ());
122 case TDESC_TYPE_IEEE_SINGLE:
123 m_type = arch_float_type (m_gdbarch, -1, "builtin_type_ieee_single",
124 floatformats_ieee_single);
127 case TDESC_TYPE_IEEE_DOUBLE:
128 m_type = arch_float_type (m_gdbarch, -1, "builtin_type_ieee_double",
129 floatformats_ieee_double);
131 case TDESC_TYPE_ARM_FPA_EXT:
132 m_type = arch_float_type (m_gdbarch, -1, "builtin_type_arm_ext",
133 floatformats_arm_ext);
136 case TDESC_TYPE_I387_EXT:
137 m_type = arch_float_type (m_gdbarch, -1, "builtin_type_i387_ext",
138 floatformats_i387_ext);
142 internal_error (__FILE__, __LINE__,
143 "Type \"%s\" has an unknown kind %d",
144 e->name.c_str (), e->kind);
147 void visit (const tdesc_type_vector *e) override
149 m_type = tdesc_find_type (m_gdbarch, e->name.c_str ());
153 type *element_gdb_type = make_gdb_type (m_gdbarch, e->element_type);
154 m_type = init_vector_type (element_gdb_type, e->count);
155 TYPE_NAME (m_type) = xstrdup (e->name.c_str ());
159 void visit (const tdesc_type_with_fields *e) override
161 m_type = tdesc_find_type (m_gdbarch, e->name.c_str ());
167 case TDESC_TYPE_STRUCT:
168 make_gdb_type_struct (e);
170 case TDESC_TYPE_UNION:
171 make_gdb_type_union (e);
173 case TDESC_TYPE_FLAGS:
174 make_gdb_type_flags (e);
176 case TDESC_TYPE_ENUM:
177 make_gdb_type_enum (e);
181 internal_error (__FILE__, __LINE__,
182 "Type \"%s\" has an unknown kind %d",
183 e->name.c_str (), e->kind);
188 void make_gdb_type_struct (const tdesc_type_with_fields *e)
190 m_type = arch_composite_type (m_gdbarch, NULL, TYPE_CODE_STRUCT);
191 TYPE_NAME (m_type) = xstrdup (e->name.c_str ());
192 TYPE_TAG_NAME (m_type) = TYPE_NAME (m_type);
194 for (const tdesc_type_field &f : e->fields)
196 if (f.start != -1 && f.end != -1)
200 struct type *field_gdb_type;
201 int bitsize, total_size;
203 /* This invariant should be preserved while creating types. */
204 gdb_assert (e->size != 0);
206 field_gdb_type = make_gdb_type (m_gdbarch, f.type);
207 else if (e->size > 4)
208 field_gdb_type = builtin_type (m_gdbarch)->builtin_uint64;
210 field_gdb_type = builtin_type (m_gdbarch)->builtin_uint32;
212 fld = append_composite_type_field_raw
213 (m_type, xstrdup (f.name.c_str ()), field_gdb_type);
215 /* For little-endian, BITPOS counts from the LSB of
216 the structure and marks the LSB of the field. For
217 big-endian, BITPOS counts from the MSB of the
218 structure and marks the MSB of the field. Either
219 way, it is the number of bits to the "left" of the
220 field. To calculate this in big-endian, we need
221 the total size of the structure. */
222 bitsize = f.end - f.start + 1;
223 total_size = e->size * TARGET_CHAR_BIT;
224 if (gdbarch_bits_big_endian (m_gdbarch))
225 SET_FIELD_BITPOS (fld[0], total_size - f.start - bitsize);
227 SET_FIELD_BITPOS (fld[0], f.start);
228 FIELD_BITSIZE (fld[0]) = bitsize;
232 gdb_assert (f.start == -1 && f.end == -1);
233 type *field_gdb_type = make_gdb_type (m_gdbarch, f.type);
234 append_composite_type_field (m_type,
235 xstrdup (f.name.c_str ()),
241 TYPE_LENGTH (m_type) = e->size;
244 void make_gdb_type_union (const tdesc_type_with_fields *e)
246 m_type = arch_composite_type (m_gdbarch, NULL, TYPE_CODE_UNION);
247 TYPE_NAME (m_type) = xstrdup (e->name.c_str ());
249 for (const tdesc_type_field &f : e->fields)
251 type* field_gdb_type = make_gdb_type (m_gdbarch, f.type);
252 append_composite_type_field (m_type, xstrdup (f.name.c_str ()),
255 /* If any of the children of a union are vectors, flag the
256 union as a vector also. This allows e.g. a union of two
257 vector types to show up automatically in "info vector". */
258 if (TYPE_VECTOR (field_gdb_type))
259 TYPE_VECTOR (m_type) = 1;
263 void make_gdb_type_flags (const tdesc_type_with_fields *e)
265 m_type = arch_flags_type (m_gdbarch, e->name.c_str (),
266 e->size * TARGET_CHAR_BIT);
268 for (const tdesc_type_field &f : e->fields)
270 int bitsize = f.end - f.start + 1;
272 gdb_assert (f.type != NULL);
273 type *field_gdb_type = make_gdb_type (m_gdbarch, f.type);
274 append_flags_type_field (m_type, f.start, bitsize,
275 field_gdb_type, f.name.c_str ());
279 void make_gdb_type_enum (const tdesc_type_with_fields *e)
281 m_type = arch_type (m_gdbarch, TYPE_CODE_ENUM, e->size * TARGET_CHAR_BIT,
284 TYPE_UNSIGNED (m_type) = 1;
285 for (const tdesc_type_field &f : e->fields)
288 = append_composite_type_field_raw (m_type,
289 xstrdup (f.name.c_str ()),
292 SET_FIELD_BITPOS (fld[0], f.start);
296 /* The gdbarch used. */
297 struct gdbarch *m_gdbarch;
299 /* The type created. */
303 gdb_type_creator gdb_type (gdbarch);
304 ttype->accept (gdb_type);
305 return gdb_type.get_type ();
308 /* A target description. */
310 struct target_desc : tdesc_element
315 virtual ~target_desc () = default;
317 target_desc (const target_desc &) = delete;
318 void operator= (const target_desc &) = delete;
320 /* The architecture reported by the target, if any. */
321 const struct bfd_arch_info *arch = NULL;
323 /* The osabi reported by the target, if any; GDB_OSABI_UNKNOWN
325 enum gdb_osabi osabi = GDB_OSABI_UNKNOWN;
327 /* The list of compatible architectures reported by the target. */
328 std::vector<const bfd_arch_info *> compatible;
330 /* Any architecture-specific properties specified by the target. */
331 std::vector<property> properties;
333 /* The features associated with this target. */
334 std::vector<tdesc_feature_up> features;
336 /* Used to cache the generated xml version of the target description. */
337 mutable char *xmltarget = nullptr;
339 void accept (tdesc_element_visitor &v) const override
343 for (const tdesc_feature_up &feature : features)
349 bool operator== (const target_desc &other) const
351 if (arch != other.arch)
354 if (osabi != other.osabi)
357 if (features.size () != other.features.size ())
360 for (int ix = 0; ix < features.size (); ix++)
362 const tdesc_feature_up &feature1 = features[ix];
363 const tdesc_feature_up &feature2 = other.features[ix];
365 if (feature1 != feature2 && *feature1 != *feature2)
372 bool operator!= (const target_desc &other) const
374 return !(*this == other);
378 /* Per-architecture data associated with a target description. The
379 target description may be shared by multiple architectures, but
380 this data is private to one gdbarch. */
382 struct tdesc_arch_reg
384 tdesc_arch_reg (tdesc_reg *reg_, struct type *type_)
385 : reg (reg_), type (type_)
388 struct tdesc_reg *reg;
392 struct tdesc_arch_data
394 /* A list of register/type pairs, indexed by GDB's internal register number.
395 During initialization of the gdbarch this list is used to store
396 registers which the architecture assigns a fixed register number.
397 Registers which are NULL in this array, or off the end, are
398 treated as zero-sized and nameless (i.e. placeholders in the
400 std::vector<tdesc_arch_reg> arch_regs;
402 /* Functions which report the register name, type, and reggroups for
404 gdbarch_register_name_ftype *pseudo_register_name = NULL;
405 gdbarch_register_type_ftype *pseudo_register_type = NULL;
406 gdbarch_register_reggroup_p_ftype *pseudo_register_reggroup_p = NULL;
409 /* Info about an inferior's target description. There's one of these
410 for each inferior. */
412 struct target_desc_info
414 /* A flag indicating that a description has already been fetched
415 from the target, so it should not be queried again. */
419 /* The description fetched from the target, or NULL if the target
420 did not supply any description. Only valid when
421 target_desc_fetched is set. Only the description initialization
422 code should access this; normally, the description should be
423 accessed through the gdbarch object. */
425 const struct target_desc *tdesc;
427 /* The filename to read a target description from, as set by "set
428 tdesc filename ..." */
433 /* Get the inferior INF's target description info, allocating one on
434 the stop if necessary. */
436 static struct target_desc_info *
437 get_tdesc_info (struct inferior *inf)
439 if (inf->tdesc_info == NULL)
440 inf->tdesc_info = XCNEW (struct target_desc_info);
441 return inf->tdesc_info;
444 /* A handle for architecture-specific data associated with the
445 target description (see struct tdesc_arch_data). */
447 static struct gdbarch_data *tdesc_data;
449 /* See target-descriptions.h. */
452 target_desc_info_from_user_p (struct target_desc_info *info)
454 return info != NULL && info->filename != NULL;
457 /* See target-descriptions.h. */
460 copy_inferior_target_desc_info (struct inferior *destinf, struct inferior *srcinf)
462 struct target_desc_info *src = get_tdesc_info (srcinf);
463 struct target_desc_info *dest = get_tdesc_info (destinf);
465 dest->fetched = src->fetched;
466 dest->tdesc = src->tdesc;
467 dest->filename = src->filename != NULL ? xstrdup (src->filename) : NULL;
470 /* See target-descriptions.h. */
473 target_desc_info_free (struct target_desc_info *tdesc_info)
475 if (tdesc_info != NULL)
477 xfree (tdesc_info->filename);
482 /* Convenience helper macros. */
484 #define target_desc_fetched \
485 get_tdesc_info (current_inferior ())->fetched
486 #define current_target_desc \
487 get_tdesc_info (current_inferior ())->tdesc
488 #define target_description_filename \
489 get_tdesc_info (current_inferior ())->filename
491 /* The string manipulated by the "set tdesc filename ..." command. */
493 static char *tdesc_filename_cmd_string;
495 /* Fetch the current target's description, and switch the current
496 architecture to one which incorporates that description. */
499 target_find_description (void)
501 /* If we've already fetched a description from the target, don't do
502 it again. This allows a target to fetch the description early,
503 during its to_open or to_create_inferior, if it needs extra
504 information about the target to initialize. */
505 if (target_desc_fetched)
508 /* The current architecture should not have any target description
509 specified. It should have been cleared, e.g. when we
510 disconnected from the previous target. */
511 gdb_assert (gdbarch_target_desc (target_gdbarch ()) == NULL);
513 /* First try to fetch an XML description from the user-specified
515 current_target_desc = NULL;
516 if (target_description_filename != NULL
517 && *target_description_filename != '\0')
519 = file_read_description_xml (target_description_filename);
521 /* Next try to read the description from the current target using
523 if (current_target_desc == NULL)
524 current_target_desc = target_read_description_xml (target_stack);
526 /* If that failed try a target-specific hook. */
527 if (current_target_desc == NULL)
528 current_target_desc = target_read_description (target_stack);
530 /* If a non-NULL description was returned, then update the current
532 if (current_target_desc)
534 struct gdbarch_info info;
536 gdbarch_info_init (&info);
537 info.target_desc = current_target_desc;
538 if (!gdbarch_update_p (info))
539 warning (_("Architecture rejected target-supplied description"));
542 struct tdesc_arch_data *data;
544 data = ((struct tdesc_arch_data *)
545 gdbarch_data (target_gdbarch (), tdesc_data));
546 if (tdesc_has_registers (current_target_desc)
547 && data->arch_regs.empty ())
548 warning (_("Target-supplied registers are not supported "
549 "by the current architecture"));
553 /* Now that we know this description is usable, record that we
555 target_desc_fetched = 1;
558 /* Discard any description fetched from the current target, and switch
559 the current architecture to one with no target description. */
562 target_clear_description (void)
564 struct gdbarch_info info;
566 if (!target_desc_fetched)
569 target_desc_fetched = 0;
570 current_target_desc = NULL;
572 gdbarch_info_init (&info);
573 if (!gdbarch_update_p (info))
574 internal_error (__FILE__, __LINE__,
575 _("Could not remove target-supplied description"));
578 /* Return the global current target description. This should only be
579 used by gdbarch initialization code; most access should be through
580 an existing gdbarch. */
582 const struct target_desc *
583 target_current_description (void)
585 if (target_desc_fetched)
586 return current_target_desc;
591 /* Return non-zero if this target description is compatible
592 with the given BFD architecture. */
595 tdesc_compatible_p (const struct target_desc *target_desc,
596 const struct bfd_arch_info *arch)
598 for (const bfd_arch_info *compat : target_desc->compatible)
601 || arch->compatible (arch, compat)
602 || compat->compatible (compat, arch))
610 /* Direct accessors for target descriptions. */
612 /* Return the string value of a property named KEY, or NULL if the
613 property was not specified. */
616 tdesc_property (const struct target_desc *target_desc, const char *key)
618 for (const property &prop : target_desc->properties)
620 return prop.value.c_str ();
625 /* Return the BFD architecture associated with this target
626 description, or NULL if no architecture was specified. */
628 const struct bfd_arch_info *
629 tdesc_architecture (const struct target_desc *target_desc)
631 return target_desc->arch;
634 /* See common/tdesc.h. */
637 tdesc_architecture_name (const struct target_desc *target_desc)
639 return target_desc->arch->printable_name;
642 /* Return the OSABI associated with this target description, or
643 GDB_OSABI_UNKNOWN if no osabi was specified. */
646 tdesc_osabi (const struct target_desc *target_desc)
648 return target_desc->osabi;
651 /* See common/tdesc.h. */
654 tdesc_osabi_name (const struct target_desc *target_desc)
656 enum gdb_osabi osabi = tdesc_osabi (target_desc);
657 if (osabi > GDB_OSABI_UNKNOWN && osabi < GDB_OSABI_INVALID)
658 return gdbarch_osabi_name (osabi);
662 /* Return 1 if this target description includes any registers. */
665 tdesc_has_registers (const struct target_desc *target_desc)
667 if (target_desc == NULL)
670 for (const tdesc_feature_up &feature : target_desc->features)
671 if (!feature->registers.empty ())
677 /* Return the feature with the given name, if present, or NULL if
678 the named feature is not found. */
680 const struct tdesc_feature *
681 tdesc_find_feature (const struct target_desc *target_desc,
684 for (const tdesc_feature_up &feature : target_desc->features)
685 if (feature->name == name)
686 return feature.get ();
691 /* Return the name of FEATURE. */
694 tdesc_feature_name (const struct tdesc_feature *feature)
696 return feature->name.c_str ();
699 /* Lookup type associated with ID. */
702 tdesc_find_type (struct gdbarch *gdbarch, const char *id)
704 tdesc_arch_data *data
705 = (struct tdesc_arch_data *) gdbarch_data (gdbarch, tdesc_data);
707 for (const tdesc_arch_reg ® : data->arch_regs)
710 && reg.reg->tdesc_type
712 && reg.reg->tdesc_type->name == id)
719 /* Support for registers from target descriptions. */
721 /* Construct the per-gdbarch data. */
724 tdesc_data_init (struct obstack *obstack)
726 return obstack_new<tdesc_arch_data> (obstack);
729 /* Similar, but for the temporary copy used during architecture
732 struct tdesc_arch_data *
733 tdesc_data_alloc (void)
735 return new tdesc_arch_data ();
738 /* Free something allocated by tdesc_data_alloc, if it is not going
739 to be used (for instance if it was unsuitable for the
743 tdesc_data_cleanup (void *data_untyped)
745 struct tdesc_arch_data *data = (struct tdesc_arch_data *) data_untyped;
750 /* Search FEATURE for a register named NAME. */
752 static struct tdesc_reg *
753 tdesc_find_register_early (const struct tdesc_feature *feature,
756 for (const tdesc_reg_up ® : feature->registers)
757 if (strcasecmp (reg->name.c_str (), name) == 0)
763 /* Search FEATURE for a register named NAME. Assign REGNO to it. */
766 tdesc_numbered_register (const struct tdesc_feature *feature,
767 struct tdesc_arch_data *data,
768 int regno, const char *name)
770 struct tdesc_reg *reg = tdesc_find_register_early (feature, name);
775 /* Make sure the vector includes a REGNO'th element. */
776 while (regno >= data->arch_regs.size ())
777 data->arch_regs.emplace_back (nullptr, nullptr);
779 data->arch_regs[regno] = tdesc_arch_reg (reg, NULL);
784 /* Search FEATURE for a register named NAME, but do not assign a fixed
785 register number to it. */
788 tdesc_unnumbered_register (const struct tdesc_feature *feature,
791 struct tdesc_reg *reg = tdesc_find_register_early (feature, name);
799 /* Search FEATURE for a register whose name is in NAMES and assign
803 tdesc_numbered_register_choices (const struct tdesc_feature *feature,
804 struct tdesc_arch_data *data,
805 int regno, const char *const names[])
809 for (i = 0; names[i] != NULL; i++)
810 if (tdesc_numbered_register (feature, data, regno, names[i]))
816 /* Search FEATURE for a register named NAME, and return its size in
817 bits. The register must exist. */
820 tdesc_register_size (const struct tdesc_feature *feature,
823 struct tdesc_reg *reg = tdesc_find_register_early (feature, name);
825 gdb_assert (reg != NULL);
829 /* Look up a register by its GDB internal register number. */
831 static struct tdesc_arch_reg *
832 tdesc_find_arch_register (struct gdbarch *gdbarch, int regno)
834 struct tdesc_arch_data *data;
836 data = (struct tdesc_arch_data *) gdbarch_data (gdbarch, tdesc_data);
837 if (regno < data->arch_regs.size ())
838 return &data->arch_regs[regno];
843 static struct tdesc_reg *
844 tdesc_find_register (struct gdbarch *gdbarch, int regno)
846 struct tdesc_arch_reg *reg = tdesc_find_arch_register (gdbarch, regno);
848 return reg? reg->reg : NULL;
851 /* Return the name of register REGNO, from the target description or
852 from an architecture-provided pseudo_register_name method. */
855 tdesc_register_name (struct gdbarch *gdbarch, int regno)
857 struct tdesc_reg *reg = tdesc_find_register (gdbarch, regno);
858 int num_regs = gdbarch_num_regs (gdbarch);
859 int num_pseudo_regs = gdbarch_num_pseudo_regs (gdbarch);
862 return reg->name.c_str ();
864 if (regno >= num_regs && regno < num_regs + num_pseudo_regs)
866 struct tdesc_arch_data *data
867 = (struct tdesc_arch_data *) gdbarch_data (gdbarch, tdesc_data);
869 gdb_assert (data->pseudo_register_name != NULL);
870 return data->pseudo_register_name (gdbarch, regno);
877 tdesc_register_type (struct gdbarch *gdbarch, int regno)
879 struct tdesc_arch_reg *arch_reg = tdesc_find_arch_register (gdbarch, regno);
880 struct tdesc_reg *reg = arch_reg? arch_reg->reg : NULL;
881 int num_regs = gdbarch_num_regs (gdbarch);
882 int num_pseudo_regs = gdbarch_num_pseudo_regs (gdbarch);
884 if (reg == NULL && regno >= num_regs && regno < num_regs + num_pseudo_regs)
886 struct tdesc_arch_data *data
887 = (struct tdesc_arch_data *) gdbarch_data (gdbarch, tdesc_data);
889 gdb_assert (data->pseudo_register_type != NULL);
890 return data->pseudo_register_type (gdbarch, regno);
894 /* Return "int0_t", since "void" has a misleading size of one. */
895 return builtin_type (gdbarch)->builtin_int0;
897 if (arch_reg->type == NULL)
899 /* First check for a predefined or target defined type. */
901 arch_reg->type = make_gdb_type (gdbarch, reg->tdesc_type);
903 /* Next try size-sensitive type shortcuts. */
904 else if (reg->type == "float")
906 if (reg->bitsize == gdbarch_float_bit (gdbarch))
907 arch_reg->type = builtin_type (gdbarch)->builtin_float;
908 else if (reg->bitsize == gdbarch_double_bit (gdbarch))
909 arch_reg->type = builtin_type (gdbarch)->builtin_double;
910 else if (reg->bitsize == gdbarch_long_double_bit (gdbarch))
911 arch_reg->type = builtin_type (gdbarch)->builtin_long_double;
914 warning (_("Register \"%s\" has an unsupported size (%d bits)"),
915 reg->name.c_str (), reg->bitsize);
916 arch_reg->type = builtin_type (gdbarch)->builtin_double;
919 else if (reg->type == "int")
921 if (reg->bitsize == gdbarch_long_bit (gdbarch))
922 arch_reg->type = builtin_type (gdbarch)->builtin_long;
923 else if (reg->bitsize == TARGET_CHAR_BIT)
924 arch_reg->type = builtin_type (gdbarch)->builtin_char;
925 else if (reg->bitsize == gdbarch_short_bit (gdbarch))
926 arch_reg->type = builtin_type (gdbarch)->builtin_short;
927 else if (reg->bitsize == gdbarch_int_bit (gdbarch))
928 arch_reg->type = builtin_type (gdbarch)->builtin_int;
929 else if (reg->bitsize == gdbarch_long_long_bit (gdbarch))
930 arch_reg->type = builtin_type (gdbarch)->builtin_long_long;
931 else if (reg->bitsize == gdbarch_ptr_bit (gdbarch))
932 /* A bit desperate by this point... */
933 arch_reg->type = builtin_type (gdbarch)->builtin_data_ptr;
936 warning (_("Register \"%s\" has an unsupported size (%d bits)"),
937 reg->name.c_str (), reg->bitsize);
938 arch_reg->type = builtin_type (gdbarch)->builtin_long;
942 if (arch_reg->type == NULL)
943 internal_error (__FILE__, __LINE__,
944 "Register \"%s\" has an unknown type \"%s\"",
945 reg->name.c_str (), reg->type.c_str ());
948 return arch_reg->type;
952 tdesc_remote_register_number (struct gdbarch *gdbarch, int regno)
954 struct tdesc_reg *reg = tdesc_find_register (gdbarch, regno);
957 return reg->target_regnum;
962 /* Check whether REGNUM is a member of REGGROUP. Registers from the
963 target description may be classified as general, float, vector or other
964 register groups registered with reggroup_add(). Unlike a gdbarch
965 register_reggroup_p method, this function will return -1 if it does not
966 know; the caller should handle registers with no specified group.
968 The names of containing features are not used. This might be extended
969 to display registers in some more useful groupings.
971 The save-restore flag is also implemented here. */
974 tdesc_register_in_reggroup_p (struct gdbarch *gdbarch, int regno,
975 struct reggroup *reggroup)
977 struct tdesc_reg *reg = tdesc_find_register (gdbarch, regno);
979 if (reg != NULL && !reg->group.empty ()
980 && (reg->group == reggroup_name (reggroup)))
984 && (reggroup == save_reggroup || reggroup == restore_reggroup))
985 return reg->save_restore;
990 /* Check whether REGNUM is a member of REGGROUP. Registers with no
991 group specified go to the default reggroup function and are handled
995 tdesc_register_reggroup_p (struct gdbarch *gdbarch, int regno,
996 struct reggroup *reggroup)
998 int num_regs = gdbarch_num_regs (gdbarch);
999 int num_pseudo_regs = gdbarch_num_pseudo_regs (gdbarch);
1002 if (regno >= num_regs && regno < num_regs + num_pseudo_regs)
1004 struct tdesc_arch_data *data
1005 = (struct tdesc_arch_data *) gdbarch_data (gdbarch, tdesc_data);
1007 if (data->pseudo_register_reggroup_p != NULL)
1008 return data->pseudo_register_reggroup_p (gdbarch, regno, reggroup);
1009 /* Otherwise fall through to the default reggroup_p. */
1012 ret = tdesc_register_in_reggroup_p (gdbarch, regno, reggroup);
1016 return default_register_reggroup_p (gdbarch, regno, reggroup);
1019 /* Record architecture-specific functions to call for pseudo-register
1023 set_tdesc_pseudo_register_name (struct gdbarch *gdbarch,
1024 gdbarch_register_name_ftype *pseudo_name)
1026 struct tdesc_arch_data *data
1027 = (struct tdesc_arch_data *) gdbarch_data (gdbarch, tdesc_data);
1029 data->pseudo_register_name = pseudo_name;
1033 set_tdesc_pseudo_register_type (struct gdbarch *gdbarch,
1034 gdbarch_register_type_ftype *pseudo_type)
1036 struct tdesc_arch_data *data
1037 = (struct tdesc_arch_data *) gdbarch_data (gdbarch, tdesc_data);
1039 data->pseudo_register_type = pseudo_type;
1043 set_tdesc_pseudo_register_reggroup_p
1044 (struct gdbarch *gdbarch,
1045 gdbarch_register_reggroup_p_ftype *pseudo_reggroup_p)
1047 struct tdesc_arch_data *data
1048 = (struct tdesc_arch_data *) gdbarch_data (gdbarch, tdesc_data);
1050 data->pseudo_register_reggroup_p = pseudo_reggroup_p;
1053 /* Update GDBARCH to use the target description for registers. */
1056 tdesc_use_registers (struct gdbarch *gdbarch,
1057 const struct target_desc *target_desc,
1058 struct tdesc_arch_data *early_data)
1060 int num_regs = gdbarch_num_regs (gdbarch);
1061 struct tdesc_arch_data *data;
1064 /* We can't use the description for registers if it doesn't describe
1065 any. This function should only be called after validating
1066 registers, so the caller should know that registers are
1068 gdb_assert (tdesc_has_registers (target_desc));
1070 data = (struct tdesc_arch_data *) gdbarch_data (gdbarch, tdesc_data);
1071 data->arch_regs = early_data->arch_regs;
1074 /* Build up a set of all registers, so that we can assign register
1075 numbers where needed. The hash table expands as necessary, so
1076 the initial size is arbitrary. */
1077 reg_hash = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
1078 for (const tdesc_feature_up &feature : target_desc->features)
1079 for (const tdesc_reg_up ® : feature->registers)
1081 void **slot = htab_find_slot (reg_hash, reg.get (), INSERT);
1084 /* Add reggroup if its new. */
1085 if (!reg->group.empty ())
1086 if (reggroup_find (gdbarch, reg->group.c_str ()) == NULL)
1087 reggroup_add (gdbarch, reggroup_gdbarch_new (gdbarch,
1088 reg->group.c_str (),
1092 /* Remove any registers which were assigned numbers by the
1094 for (const tdesc_arch_reg &arch_reg : data->arch_regs)
1095 if (arch_reg.reg != NULL)
1096 htab_remove_elt (reg_hash, arch_reg.reg);
1098 /* Assign numbers to the remaining registers and add them to the
1099 list of registers. The new numbers are always above gdbarch_num_regs.
1100 Iterate over the features, not the hash table, so that the order
1101 matches that in the target description. */
1103 gdb_assert (data->arch_regs.size () <= num_regs);
1104 while (data->arch_regs.size () < num_regs)
1105 data->arch_regs.emplace_back (nullptr, nullptr);
1107 for (const tdesc_feature_up &feature : target_desc->features)
1108 for (const tdesc_reg_up ® : feature->registers)
1109 if (htab_find (reg_hash, reg.get ()) != NULL)
1111 data->arch_regs.emplace_back (reg.get (), nullptr);
1115 htab_delete (reg_hash);
1117 /* Update the architecture. */
1118 set_gdbarch_num_regs (gdbarch, num_regs);
1119 set_gdbarch_register_name (gdbarch, tdesc_register_name);
1120 set_gdbarch_register_type (gdbarch, tdesc_register_type);
1121 set_gdbarch_remote_register_number (gdbarch,
1122 tdesc_remote_register_number);
1123 set_gdbarch_register_reggroup_p (gdbarch, tdesc_register_reggroup_p);
1126 /* See common/tdesc.h. */
1128 struct tdesc_feature *
1129 tdesc_create_feature (struct target_desc *tdesc, const char *name)
1131 struct tdesc_feature *new_feature = new tdesc_feature (name);
1133 tdesc->features.emplace_back (new_feature);
1138 struct target_desc *
1139 allocate_target_description (void)
1141 return new target_desc ();
1145 free_target_description (void *arg)
1147 struct target_desc *target_desc = (struct target_desc *) arg;
1153 make_cleanup_free_target_description (struct target_desc *target_desc)
1155 return make_cleanup (free_target_description, target_desc);
1159 tdesc_add_compatible (struct target_desc *target_desc,
1160 const struct bfd_arch_info *compatible)
1162 /* If this instance of GDB is compiled without BFD support for the
1163 compatible architecture, simply ignore it -- we would not be able
1164 to handle it anyway. */
1165 if (compatible == NULL)
1168 for (const bfd_arch_info *compat : target_desc->compatible)
1169 if (compat == compatible)
1170 internal_error (__FILE__, __LINE__,
1171 _("Attempted to add duplicate "
1172 "compatible architecture \"%s\""),
1173 compatible->printable_name);
1175 target_desc->compatible.push_back (compatible);
1179 set_tdesc_property (struct target_desc *target_desc,
1180 const char *key, const char *value)
1182 gdb_assert (key != NULL && value != NULL);
1184 if (tdesc_property (target_desc, key) != NULL)
1185 internal_error (__FILE__, __LINE__,
1186 _("Attempted to add duplicate property \"%s\""), key);
1188 target_desc->properties.emplace_back (key, value);
1191 /* See common/tdesc.h. */
1194 set_tdesc_architecture (struct target_desc *target_desc,
1197 set_tdesc_architecture (target_desc, bfd_scan_arch (name));
1201 set_tdesc_architecture (struct target_desc *target_desc,
1202 const struct bfd_arch_info *arch)
1204 target_desc->arch = arch;
1207 /* See common/tdesc.h. */
1210 set_tdesc_osabi (struct target_desc *target_desc, const char *name)
1212 set_tdesc_osabi (target_desc, osabi_from_tdesc_string (name));
1216 set_tdesc_osabi (struct target_desc *target_desc, enum gdb_osabi osabi)
1218 target_desc->osabi = osabi;
1222 static struct cmd_list_element *tdesc_set_cmdlist, *tdesc_show_cmdlist;
1223 static struct cmd_list_element *tdesc_unset_cmdlist;
1225 /* Helper functions for the CLI commands. */
1228 set_tdesc_cmd (const char *args, int from_tty)
1230 help_list (tdesc_set_cmdlist, "set tdesc ", all_commands, gdb_stdout);
1234 show_tdesc_cmd (const char *args, int from_tty)
1236 cmd_show_list (tdesc_show_cmdlist, from_tty, "");
1240 unset_tdesc_cmd (const char *args, int from_tty)
1242 help_list (tdesc_unset_cmdlist, "unset tdesc ", all_commands, gdb_stdout);
1246 set_tdesc_filename_cmd (const char *args, int from_tty,
1247 struct cmd_list_element *c)
1249 xfree (target_description_filename);
1250 target_description_filename = xstrdup (tdesc_filename_cmd_string);
1252 target_clear_description ();
1253 target_find_description ();
1257 show_tdesc_filename_cmd (struct ui_file *file, int from_tty,
1258 struct cmd_list_element *c,
1261 value = target_description_filename;
1263 if (value != NULL && *value != '\0')
1264 printf_filtered (_("The target description will be read from \"%s\".\n"),
1267 printf_filtered (_("The target description will be "
1268 "read from the target.\n"));
1272 unset_tdesc_filename_cmd (const char *args, int from_tty)
1274 xfree (target_description_filename);
1275 target_description_filename = NULL;
1276 target_clear_description ();
1277 target_find_description ();
1280 /* Print target description in C. */
1282 class print_c_tdesc : public tdesc_element_visitor
1285 print_c_tdesc (std::string &filename_after_features)
1286 : m_filename_after_features (filename_after_features)
1290 const char *filename = lbasename (m_filename_after_features.c_str ());
1292 m_function = (char *) xmalloc (strlen (filename) + 1);
1293 for (inp = filename, outp = m_function; *inp != '\0'; inp++)
1296 else if (*inp == '-')
1302 /* Standard boilerplate. */
1303 printf_unfiltered ("/* THIS FILE IS GENERATED. "
1304 "-*- buffer-read-only: t -*- vi"
1313 void visit_pre (const target_desc *e) override
1315 printf_unfiltered (" Original: %s */\n\n",
1316 lbasename (m_filename_after_features.c_str ()));
1318 printf_unfiltered ("#include \"defs.h\"\n");
1319 printf_unfiltered ("#include \"osabi.h\"\n");
1320 printf_unfiltered ("#include \"target-descriptions.h\"\n");
1321 printf_unfiltered ("\n");
1323 printf_unfiltered ("struct target_desc *tdesc_%s;\n", m_function);
1324 printf_unfiltered ("static void\n");
1325 printf_unfiltered ("initialize_tdesc_%s (void)\n", m_function);
1326 printf_unfiltered ("{\n");
1328 (" struct target_desc *result = allocate_target_description ();\n");
1330 if (tdesc_architecture (e) != NULL)
1333 (" set_tdesc_architecture (result, bfd_scan_arch (\"%s\"));\n",
1334 tdesc_architecture (e)->printable_name);
1335 printf_unfiltered ("\n");
1337 if (tdesc_osabi (e) > GDB_OSABI_UNKNOWN
1338 && tdesc_osabi (e) < GDB_OSABI_INVALID)
1341 (" set_tdesc_osabi (result, osabi_from_tdesc_string (\"%s\"));\n",
1342 gdbarch_osabi_name (tdesc_osabi (e)));
1343 printf_unfiltered ("\n");
1346 for (const bfd_arch_info_type *compatible : e->compatible)
1348 (" tdesc_add_compatible (result, bfd_scan_arch (\"%s\"));\n",
1349 compatible->printable_name);
1351 if (!e->compatible.empty ())
1352 printf_unfiltered ("\n");
1354 for (const property &prop : e->properties)
1355 printf_unfiltered (" set_tdesc_property (result, \"%s\", \"%s\");\n",
1356 prop.key.c_str (), prop.value.c_str ());
1358 printf_unfiltered (" struct tdesc_feature *feature;\n");
1361 void visit_pre (const tdesc_feature *e) override
1363 printf_unfiltered ("\n feature = tdesc_create_feature (result, \"%s\");\n",
1367 void visit_post (const tdesc_feature *e) override
1370 void visit_post (const target_desc *e) override
1372 printf_unfiltered ("\n tdesc_%s = result;\n", m_function);
1373 printf_unfiltered ("}\n");
1376 void visit (const tdesc_type_builtin *type) override
1378 error (_("C output is not supported type \"%s\"."), type->name.c_str ());
1381 void visit (const tdesc_type_vector *type) override
1383 if (!m_printed_element_type)
1385 printf_unfiltered (" tdesc_type *element_type;\n");
1386 m_printed_element_type = true;
1390 (" element_type = tdesc_named_type (feature, \"%s\");\n",
1391 type->element_type->name.c_str ());
1393 (" tdesc_create_vector (feature, \"%s\", element_type, %d);\n",
1394 type->name.c_str (), type->count);
1396 printf_unfiltered ("\n");
1399 void visit (const tdesc_type_with_fields *type) override
1401 if (!m_printed_type_with_fields)
1403 printf_unfiltered (" tdesc_type_with_fields *type_with_fields;\n");
1404 m_printed_type_with_fields = true;
1409 case TDESC_TYPE_STRUCT:
1410 case TDESC_TYPE_FLAGS:
1411 if (type->kind == TDESC_TYPE_STRUCT)
1414 (" type_with_fields = tdesc_create_struct (feature, \"%s\");\n",
1415 type->name.c_str ());
1416 if (type->size != 0)
1418 (" tdesc_set_struct_size (type_with_fields, %d);\n", type->size);
1423 (" type_with_fields = tdesc_create_flags (feature, \"%s\", %d);\n",
1424 type->name.c_str (), type->size);
1426 for (const tdesc_type_field &f : type->fields)
1428 const char *type_name;
1430 gdb_assert (f.type != NULL);
1431 type_name = f.type->name.c_str ();
1433 /* To minimize changes to generated files, don't emit type
1434 info for fields that have defaulted types. */
1437 gdb_assert (f.end != -1);
1438 if (f.type->kind == TDESC_TYPE_BOOL)
1440 gdb_assert (f.start == f.end);
1442 (" tdesc_add_flag (type_with_fields, %d, \"%s\");\n",
1443 f.start, f.name.c_str ());
1445 else if ((type->size == 4 && f.type->kind == TDESC_TYPE_UINT32)
1447 && f.type->kind == TDESC_TYPE_UINT64))
1450 (" tdesc_add_bitfield (type_with_fields, \"%s\", %d, %d);\n",
1451 f.name.c_str (), f.start, f.end);
1455 printf_field_type_assignment
1456 ("tdesc_named_type (feature, \"%s\");\n",
1459 (" tdesc_add_typed_bitfield (type_with_fields, \"%s\","
1460 " %d, %d, field_type);\n",
1461 f.name.c_str (), f.start, f.end);
1464 else /* Not a bitfield. */
1466 gdb_assert (f.end == -1);
1467 gdb_assert (type->kind == TDESC_TYPE_STRUCT);
1468 printf_field_type_assignment
1469 ("tdesc_named_type (feature, \"%s\");\n", type_name);
1471 (" tdesc_add_field (type_with_fields, \"%s\", field_type);\n",
1476 case TDESC_TYPE_UNION:
1478 (" type_with_fields = tdesc_create_union (feature, \"%s\");\n",
1479 type->name.c_str ());
1480 for (const tdesc_type_field &f : type->fields)
1482 printf_field_type_assignment
1483 ("tdesc_named_type (feature, \"%s\");\n", f.type->name.c_str ());
1485 (" tdesc_add_field (type_with_fields, \"%s\", field_type);\n",
1489 case TDESC_TYPE_ENUM:
1491 (" type_with_fields = tdesc_create_enum (feature, \"%s\", %d);\n",
1492 type->name.c_str (), type->size);
1493 for (const tdesc_type_field &f : type->fields)
1495 (" tdesc_add_enum_value (type_with_fields, %d, \"%s\");\n",
1496 f.start, f.name.c_str ());
1499 error (_("C output is not supported type \"%s\"."), type->name.c_str ());
1502 printf_unfiltered ("\n");
1505 void visit (const tdesc_reg *reg) override
1507 printf_unfiltered (" tdesc_create_reg (feature, \"%s\", %ld, %d, ",
1508 reg->name.c_str (), reg->target_regnum,
1510 if (!reg->group.empty ())
1511 printf_unfiltered ("\"%s\", ", reg->group.c_str ());
1513 printf_unfiltered ("NULL, ");
1514 printf_unfiltered ("%d, \"%s\");\n", reg->bitsize, reg->type.c_str ());
1518 std::string m_filename_after_features;
1522 /* Print an assignment to the field_type variable. Print the declaration
1523 of field_type if that has not been done yet. */
1524 ATTRIBUTE_PRINTF (2, 3)
1525 void printf_field_type_assignment (const char *fmt, ...)
1527 if (!m_printed_field_type)
1529 printf_unfiltered (" tdesc_type *field_type;\n");
1530 m_printed_field_type = true;
1533 printf_unfiltered (" field_type = ");
1536 va_start (args, fmt);
1537 vprintf_unfiltered (fmt, args);
1543 /* Did we print "struct tdesc_type *element_type;" yet? */
1544 bool m_printed_element_type = false;
1546 /* Did we print "struct tdesc_type_with_fields *element_type;" yet? */
1547 bool m_printed_type_with_fields = false;
1549 /* Did we print "struct tdesc_type *field_type;" yet? */
1550 bool m_printed_field_type = false;
1553 /* Print target description feature in C. */
1555 class print_c_feature : public print_c_tdesc
1558 print_c_feature (std::string &file)
1559 : print_c_tdesc (file)
1562 auto const pos = m_filename_after_features.find_last_of ('.');
1564 m_filename_after_features = m_filename_after_features.substr (0, pos);
1567 void visit_pre (const target_desc *e) override
1569 printf_unfiltered (" Original: %s */\n\n",
1570 lbasename (m_filename_after_features.c_str ()));
1572 printf_unfiltered ("#include \"common/tdesc.h\"\n");
1573 printf_unfiltered ("\n");
1576 void visit_post (const target_desc *e) override
1579 void visit_pre (const tdesc_feature *e) override
1581 std::string name (m_filename_after_features);
1583 auto pos = name.find_first_of ('.');
1585 name = name.substr (0, pos);
1586 std::replace (name.begin (), name.end (), '/', '_');
1587 std::replace (name.begin (), name.end (), '-', '_');
1589 printf_unfiltered ("static int\n");
1590 printf_unfiltered ("create_feature_%s ", name.c_str ());
1591 printf_unfiltered ("(struct target_desc *result, long regnum)\n");
1593 printf_unfiltered ("{\n");
1594 printf_unfiltered (" struct tdesc_feature *feature;\n");
1597 ("\n feature = tdesc_create_feature (result, \"%s\");\n",
1601 void visit_post (const tdesc_feature *e) override
1603 printf_unfiltered (" return regnum;\n");
1604 printf_unfiltered ("}\n");
1607 void visit (const tdesc_reg *reg) override
1609 /* Most "reg" in XML target descriptions don't have "regnum"
1610 attribute, so the register number is allocated sequentially.
1611 In case that reg has "regnum" attribute, register number
1612 should be set by that explicitly. */
1614 if (reg->target_regnum < m_next_regnum)
1616 /* The integrity check, it can catch some errors on register
1617 number collision, like this,
1619 <reg name="x0" bitsize="32"/>
1620 <reg name="x1" bitsize="32"/>
1621 <reg name="x2" bitsize="32"/>
1622 <reg name="x3" bitsize="32"/>
1623 <reg name="ps" bitsize="32" regnum="3"/>
1625 but it also has false negatives. The target description
1628 <reg name="x1" bitsize="32" regnum="1"/>
1629 <reg name="x3" bitsize="32" regnum="3"/>
1630 <reg name="x2" bitsize="32" regnum="2"/>
1631 <reg name="x4" bitsize="32" regnum="4"/>
1633 but it is not a good practice, so still error on this,
1634 and also print the message so that it can be saved in the
1635 generated c file. */
1637 printf_unfiltered ("ERROR: \"regnum\" attribute %ld ",
1638 reg->target_regnum);
1639 printf_unfiltered ("is not the largest number (%d).\n",
1641 error (_("\"regnum\" attribute %ld is not the largest number (%d)."),
1642 reg->target_regnum, m_next_regnum);
1645 if (reg->target_regnum > m_next_regnum)
1647 printf_unfiltered (" regnum = %ld;\n", reg->target_regnum);
1648 m_next_regnum = reg->target_regnum;
1651 printf_unfiltered (" tdesc_create_reg (feature, \"%s\", regnum++, %d, ",
1652 reg->name.c_str (), reg->save_restore);
1653 if (!reg->group.empty ())
1654 printf_unfiltered ("\"%s\", ", reg->group.c_str ());
1656 printf_unfiltered ("NULL, ");
1657 printf_unfiltered ("%d, \"%s\");\n", reg->bitsize, reg->type.c_str ());
1663 /* The register number to use for the next register we see. */
1664 int m_next_regnum = 0;
1667 /* See common/tdesc.h. */
1670 tdesc_get_features_xml (const target_desc *tdesc)
1672 if (tdesc->xmltarget == nullptr)
1674 std::string buffer ("@");
1675 print_xml_feature v (&buffer);
1677 tdesc->xmltarget = xstrdup (buffer.c_str ());
1679 return tdesc->xmltarget;
1683 maint_print_c_tdesc_cmd (const char *args, int from_tty)
1685 const struct target_desc *tdesc;
1686 const char *filename;
1690 /* Use the global target-supplied description, not the current
1691 architecture's. This lets a GDB for one architecture generate C
1692 for another architecture's description, even though the gdbarch
1693 initialization code will reject the new description. */
1694 tdesc = current_target_desc;
1695 filename = target_description_filename;
1699 /* Use the target description from the XML file. */
1701 tdesc = file_read_description_xml (filename);
1705 error (_("There is no target description to print."));
1707 if (filename == NULL)
1708 error (_("The current target description did not come from an XML file."));
1710 std::string filename_after_features (filename);
1711 auto loc = filename_after_features.rfind ("/features/");
1713 if (loc != std::string::npos)
1714 filename_after_features = filename_after_features.substr (loc + 10);
1716 /* Print c files for target features instead of target descriptions,
1717 because c files got from target features are more flexible than the
1719 if (startswith (filename_after_features.c_str (), "i386/32bit-")
1720 || startswith (filename_after_features.c_str (), "i386/64bit-")
1721 || startswith (filename_after_features.c_str (), "i386/x32-core.xml")
1722 || startswith (filename_after_features.c_str (), "tic6x-")
1723 || startswith (filename_after_features.c_str (), "aarch64"))
1725 print_c_feature v (filename_after_features);
1731 print_c_tdesc v (filename_after_features);
1737 namespace selftests {
1739 static std::vector<std::pair<const char*, const target_desc *>> xml_tdesc;
1743 /* See target-descritpions.h. */
1746 record_xml_tdesc (const char *xml_file, const struct target_desc *tdesc)
1748 xml_tdesc.emplace_back (xml_file, tdesc);
1754 /* Test the convesion process of a target description to/from xml: Take a target
1755 description TDESC, convert to xml, back to a description, and confirm the new
1756 tdesc is identical to the original. */
1758 maintenance_check_tdesc_xml_convert (const target_desc *tdesc, const char *name)
1760 const char *xml = tdesc_get_features_xml (tdesc);
1762 if (xml == nullptr || *xml != '@')
1764 printf_filtered (_("Could not convert description for %s to xml.\n"),
1769 const target_desc *tdesc_trans = string_read_description_xml (xml + 1);
1771 if (tdesc_trans == nullptr)
1773 printf_filtered (_("Could not convert description for %s from xml.\n"),
1777 else if (*tdesc != *tdesc_trans)
1779 printf_filtered (_("Converted description for %s does not match.\n"),
1787 /* Check that the target descriptions created dynamically by
1788 architecture-specific code equal the descriptions created from XML files
1789 found in the specified directory DIR. */
1792 maintenance_check_xml_descriptions (const char *dir, int from_tty)
1795 error (_("Missing dir name"));
1797 gdb::unique_xmalloc_ptr<char> dir1 (tilde_expand (dir));
1798 std::string feature_dir (dir1.get ());
1799 unsigned int failed = 0;
1801 for (auto const &e : selftests::xml_tdesc)
1803 std::string tdesc_xml = (feature_dir + SLASH_STRING + e.first);
1804 const target_desc *tdesc
1805 = file_read_description_xml (tdesc_xml.data ());
1807 if (tdesc == NULL || *tdesc != *e.second)
1809 printf_filtered ( _("Descriptions for %s do not match.\n"), e.first);
1812 else if (!maintenance_check_tdesc_xml_convert (tdesc, e.first)
1813 || !maintenance_check_tdesc_xml_convert (e.second, e.first))
1816 printf_filtered (_("Tested %lu XML files, %d failed\n"),
1817 (long) selftests::xml_tdesc.size (), failed);
1821 _initialize_target_descriptions (void)
1823 tdesc_data = gdbarch_data_register_pre_init (tdesc_data_init);
1825 add_prefix_cmd ("tdesc", class_maintenance, set_tdesc_cmd, _("\
1826 Set target description specific variables."),
1827 &tdesc_set_cmdlist, "set tdesc ",
1828 0 /* allow-unknown */, &setlist);
1829 add_prefix_cmd ("tdesc", class_maintenance, show_tdesc_cmd, _("\
1830 Show target description specific variables."),
1831 &tdesc_show_cmdlist, "show tdesc ",
1832 0 /* allow-unknown */, &showlist);
1833 add_prefix_cmd ("tdesc", class_maintenance, unset_tdesc_cmd, _("\
1834 Unset target description specific variables."),
1835 &tdesc_unset_cmdlist, "unset tdesc ",
1836 0 /* allow-unknown */, &unsetlist);
1838 add_setshow_filename_cmd ("filename", class_obscure,
1839 &tdesc_filename_cmd_string,
1841 Set the file to read for an XML target description"), _("\
1842 Show the file to read for an XML target description"), _("\
1843 When set, GDB will read the target description from a local\n\
1844 file instead of querying the remote target."),
1845 set_tdesc_filename_cmd,
1846 show_tdesc_filename_cmd,
1847 &tdesc_set_cmdlist, &tdesc_show_cmdlist);
1849 add_cmd ("filename", class_obscure, unset_tdesc_filename_cmd, _("\
1850 Unset the file to read for an XML target description. When unset,\n\
1851 GDB will read the description from the target."),
1852 &tdesc_unset_cmdlist);
1854 add_cmd ("c-tdesc", class_maintenance, maint_print_c_tdesc_cmd, _("\
1855 Print the current target description as a C source file."),
1856 &maintenanceprintlist);
1858 cmd_list_element *cmd;
1860 cmd = add_cmd ("xml-descriptions", class_maintenance,
1861 maintenance_check_xml_descriptions, _("\
1862 Check the target descriptions created in GDB equal the descriptions\n\
1863 created from XML files in the directory.\n\
1864 The parameter is the directory name."),
1865 &maintenancechecklist);
1866 set_cmd_completer (cmd, filename_completer);