GDB (xrefs)
Loading...
Searching...
No Matches
target-descriptions.c
Go to the documentation of this file.
1/* Target description support for GDB.
2
3 Copyright (C) 2006-2023 Free Software Foundation, Inc.
4
5 Contributed by CodeSourcery.
6
7 This file is part of GDB.
8
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.
13
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.
18
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/>. */
21
22#include "defs.h"
23#include "arch-utils.h"
24#include "gdbcmd.h"
25#include "gdbtypes.h"
26#include "reggroups.h"
27#include "target.h"
28#include "target-descriptions.h"
29#include "xml-support.h"
30#include "xml-tdesc.h"
31#include "osabi.h"
32
33#include "gdbsupport/gdb_obstack.h"
34#include "hashtab.h"
35#include "inferior.h"
36#include <algorithm>
37#include "completer.h"
38#include "readline/tilde.h"
39
40/* Types. */
41
43{
44 property (const std::string &key_, const std::string &value_)
45 : key (key_), value (value_)
46 {}
47
48 std::string key;
49 std::string value;
50};
51
52/* Convert a tdesc_type to a gdb type. */
53
54static type *
55make_gdb_type (struct gdbarch *gdbarch, struct tdesc_type *ttype)
56{
57 class gdb_type_creator : public tdesc_element_visitor
58 {
59 public:
60 gdb_type_creator (struct gdbarch *gdbarch)
61 : m_gdbarch (gdbarch)
62 {}
63
64 type *get_type ()
65 {
66 return m_type;
67 }
68
69 void visit (const tdesc_type_builtin *e) override
70 {
71 switch (e->kind)
72 {
73 /* Predefined types. */
74 case TDESC_TYPE_BOOL:
75 m_type = builtin_type (m_gdbarch)->builtin_bool;
76 return;
77 case TDESC_TYPE_INT8:
78 m_type = builtin_type (m_gdbarch)->builtin_int8;
79 return;
80 case TDESC_TYPE_INT16:
81 m_type = builtin_type (m_gdbarch)->builtin_int16;
82 return;
83 case TDESC_TYPE_INT32:
84 m_type = builtin_type (m_gdbarch)->builtin_int32;
85 return;
86 case TDESC_TYPE_INT64:
87 m_type = builtin_type (m_gdbarch)->builtin_int64;
88 return;
89 case TDESC_TYPE_INT128:
90 m_type = builtin_type (m_gdbarch)->builtin_int128;
91 return;
92 case TDESC_TYPE_UINT8:
93 m_type = builtin_type (m_gdbarch)->builtin_uint8;
94 return;
95 case TDESC_TYPE_UINT16:
96 m_type = builtin_type (m_gdbarch)->builtin_uint16;
97 return;
98 case TDESC_TYPE_UINT32:
99 m_type = builtin_type (m_gdbarch)->builtin_uint32;
100 return;
101 case TDESC_TYPE_UINT64:
102 m_type = builtin_type (m_gdbarch)->builtin_uint64;
103 return;
104 case TDESC_TYPE_UINT128:
105 m_type = builtin_type (m_gdbarch)->builtin_uint128;
106 return;
107 case TDESC_TYPE_CODE_PTR:
108 m_type = builtin_type (m_gdbarch)->builtin_func_ptr;
109 return;
110 case TDESC_TYPE_DATA_PTR:
111 m_type = builtin_type (m_gdbarch)->builtin_data_ptr;
112 return;
113 }
114
115 m_type = tdesc_find_type (m_gdbarch, e->name.c_str ());
116 if (m_type != NULL)
117 return;
118
119 type_allocator alloc (m_gdbarch);
120 switch (e->kind)
121 {
122 case TDESC_TYPE_IEEE_HALF:
123 m_type = init_float_type (alloc, -1, "builtin_type_ieee_half",
125 return;
126
127 case TDESC_TYPE_IEEE_SINGLE:
128 m_type = init_float_type (alloc, -1, "builtin_type_ieee_single",
130 return;
131
132 case TDESC_TYPE_IEEE_DOUBLE:
133 m_type = init_float_type (alloc, -1, "builtin_type_ieee_double",
135 return;
136 case TDESC_TYPE_ARM_FPA_EXT:
137 m_type = init_float_type (alloc, -1, "builtin_type_arm_ext",
139 return;
140
141 case TDESC_TYPE_I387_EXT:
142 m_type = init_float_type (alloc, -1, "builtin_type_i387_ext",
144 return;
145
146 case TDESC_TYPE_BFLOAT16:
147 m_type = init_float_type (alloc, -1, "builtin_type_bfloat16",
149 return;
150 }
151
152 internal_error ("Type \"%s\" has an unknown kind %d",
153 e->name.c_str (), e->kind);
154 }
155
156 void visit (const tdesc_type_vector *e) override
157 {
158 m_type = tdesc_find_type (m_gdbarch, e->name.c_str ());
159 if (m_type != NULL)
160 return;
161
162 type *element_gdb_type = make_gdb_type (m_gdbarch, e->element_type);
163 m_type = init_vector_type (element_gdb_type, e->count);
164 m_type->set_name (xstrdup (e->name.c_str ()));
165 return;
166 }
167
168 void visit (const tdesc_type_with_fields *e) override
169 {
170 m_type = tdesc_find_type (m_gdbarch, e->name.c_str ());
171 if (m_type != NULL)
172 return;
173
174 switch (e->kind)
175 {
176 case TDESC_TYPE_STRUCT:
177 make_gdb_type_struct (e);
178 return;
179 case TDESC_TYPE_UNION:
180 make_gdb_type_union (e);
181 return;
182 case TDESC_TYPE_FLAGS:
183 make_gdb_type_flags (e);
184 return;
185 case TDESC_TYPE_ENUM:
186 make_gdb_type_enum (e);
187 return;
188 }
189
190 internal_error ("Type \"%s\" has an unknown kind %d",
191 e->name.c_str (), e->kind);
192 }
193
194 private:
195
196 void make_gdb_type_struct (const tdesc_type_with_fields *e)
197 {
198 m_type = arch_composite_type (m_gdbarch, NULL, TYPE_CODE_STRUCT);
199 m_type->set_name (xstrdup (e->name.c_str ()));
200
201 for (const tdesc_type_field &f : e->fields)
202 {
203 if (f.start != -1 && f.end != -1)
204 {
205 /* Bitfield. */
206 struct field *fld;
207 struct type *field_gdb_type;
208 int bitsize, total_size;
209
210 /* This invariant should be preserved while creating types. */
211 gdb_assert (e->size != 0);
212 if (f.type != NULL)
213 field_gdb_type = make_gdb_type (m_gdbarch, f.type);
214 else if (e->size > 4)
215 field_gdb_type = builtin_type (m_gdbarch)->builtin_uint64;
216 else
217 field_gdb_type = builtin_type (m_gdbarch)->builtin_uint32;
218
220 (m_type, xstrdup (f.name.c_str ()), field_gdb_type);
221
222 /* For little-endian, BITPOS counts from the LSB of
223 the structure and marks the LSB of the field. For
224 big-endian, BITPOS counts from the MSB of the
225 structure and marks the MSB of the field. Either
226 way, it is the number of bits to the "left" of the
227 field. To calculate this in big-endian, we need
228 the total size of the structure. */
229 bitsize = f.end - f.start + 1;
230 total_size = e->size * TARGET_CHAR_BIT;
231 if (gdbarch_byte_order (m_gdbarch) == BFD_ENDIAN_BIG)
232 fld->set_loc_bitpos (total_size - f.start - bitsize);
233 else
234 fld->set_loc_bitpos (f.start);
235 fld->set_bitsize (bitsize);
236 }
237 else
238 {
239 gdb_assert (f.start == -1 && f.end == -1);
240 type *field_gdb_type = make_gdb_type (m_gdbarch, f.type);
242 xstrdup (f.name.c_str ()),
243 field_gdb_type);
244 }
245 }
246
247 if (e->size != 0)
248 m_type->set_length (e->size);
249 }
250
251 void make_gdb_type_union (const tdesc_type_with_fields *e)
252 {
253 m_type = arch_composite_type (m_gdbarch, NULL, TYPE_CODE_UNION);
254 m_type->set_name (xstrdup (e->name.c_str ()));
255
256 for (const tdesc_type_field &f : e->fields)
257 {
258 type* field_gdb_type = make_gdb_type (m_gdbarch, f.type);
259 append_composite_type_field (m_type, xstrdup (f.name.c_str ()),
260 field_gdb_type);
261
262 /* If any of the children of a union are vectors, flag the
263 union as a vector also. This allows e.g. a union of two
264 vector types to show up automatically in "info vector". */
265 if (field_gdb_type->is_vector ())
266 m_type->set_is_vector (true);
267 }
268 }
269
270 void make_gdb_type_flags (const tdesc_type_with_fields *e)
271 {
272 m_type = arch_flags_type (m_gdbarch, e->name.c_str (),
273 e->size * TARGET_CHAR_BIT);
274
275 for (const tdesc_type_field &f : e->fields)
276 {
277 int bitsize = f.end - f.start + 1;
278
279 gdb_assert (f.type != NULL);
280 type *field_gdb_type = make_gdb_type (m_gdbarch, f.type);
281 append_flags_type_field (m_type, f.start, bitsize,
282 field_gdb_type, f.name.c_str ());
283 }
284 }
285
286 void make_gdb_type_enum (const tdesc_type_with_fields *e)
287 {
288 m_type = (type_allocator (m_gdbarch)
289 .new_type (TYPE_CODE_ENUM, e->size * TARGET_CHAR_BIT,
290 e->name.c_str ()));
291
292 m_type->set_is_unsigned (true);
293
294 for (const tdesc_type_field &f : e->fields)
295 {
296 struct field *fld
298 xstrdup (f.name.c_str ()),
299 NULL);
300
301 fld->set_loc_enumval (f.start);
302 }
303 }
304
305 /* The gdbarch used. */
306 struct gdbarch *m_gdbarch;
307
308 /* The type created. */
309 type *m_type;
310 };
311
312 gdb_type_creator gdb_type (gdbarch);
313 ttype->accept (gdb_type);
314 return gdb_type.get_type ();
315}
316
317/* Wrapper around bfd_arch_info_type. A class with this name is used in
318 the API that is shared between gdb and gdbserver code, but gdbserver
319 doesn't use compatibility information, so its version of this class is
320 empty. */
321
323{
324public:
325 /* Constructor. */
326 explicit tdesc_compatible_info (const bfd_arch_info_type *arch)
327 : m_arch (arch)
328 { /* Nothing. */ }
329
330 /* Access the contained pointer. */
331 const bfd_arch_info_type *arch () const
332 { return m_arch; }
333
334private:
335 /* Architecture information looked up from the <compatible> entity within
336 a target description. */
337 const bfd_arch_info_type *m_arch;
338};
339
340/* A target description. */
341
342struct target_desc : tdesc_element
343{
345 {}
346
347 virtual ~target_desc () = default;
348
349 target_desc (const target_desc &) = delete;
350 void operator= (const target_desc &) = delete;
351
352 /* The architecture reported by the target, if any. */
353 const struct bfd_arch_info *arch = NULL;
354
355 /* The osabi reported by the target, if any; GDB_OSABI_UNKNOWN
356 otherwise. */
358
359 /* The list of compatible architectures reported by the target. */
360 std::vector<tdesc_compatible_info_up> compatible;
361
362 /* Any architecture-specific properties specified by the target. */
363 std::vector<property> properties;
364
365 /* The features associated with this target. */
366 std::vector<tdesc_feature_up> features;
367
368 /* Used to cache the generated xml version of the target description. */
369 mutable char *xmltarget = nullptr;
370
371 void accept (tdesc_element_visitor &v) const override
372 {
373 v.visit_pre (this);
374
375 for (const tdesc_feature_up &feature : features)
376 feature->accept (v);
377
378 v.visit_post (this);
379 }
380
381 bool operator== (const target_desc &other) const
382 {
383 if (arch != other.arch)
384 return false;
385
386 if (osabi != other.osabi)
387 return false;
388
389 if (features.size () != other.features.size ())
390 return false;
391
392 for (int ix = 0; ix < features.size (); ix++)
393 {
394 const tdesc_feature_up &feature1 = features[ix];
395 const tdesc_feature_up &feature2 = other.features[ix];
396
397 if (feature1 != feature2 && *feature1 != *feature2)
398 return false;
399 }
400
401 return true;
402 }
403
404 bool operator!= (const target_desc &other) const
405 {
406 return !(*this == other);
407 }
408};
409
410/* Per-architecture data associated with a target description. The
411 target description may be shared by multiple architectures, but
412 this data is private to one gdbarch. */
413
415{
416 tdesc_arch_reg (tdesc_reg *reg_, struct type *type_)
417 : reg (reg_), type (type_)
418 {}
419
420 struct tdesc_reg *reg;
421 struct type *type;
422};
423
425{
426 /* A list of register/type pairs, indexed by GDB's internal register number.
427 During initialization of the gdbarch this list is used to store
428 registers which the architecture assigns a fixed register number.
429 Registers which are NULL in this array, or off the end, are
430 treated as zero-sized and nameless (i.e. placeholders in the
431 numbering). */
432 std::vector<tdesc_arch_reg> arch_regs;
433
434 /* Functions which report the register name, type, and reggroups for
435 pseudo-registers. */
439};
440
441/* A handle for architecture-specific data associated with the
442 target description (see struct tdesc_arch_data). */
443
445
446/* Get or create the tdesc_data. */
447static tdesc_arch_data *
449{
451 if (result == nullptr)
452 result = tdesc_data.emplace (gdbarch);
453 return result;
454}
455
456/* The string manipulated by the "set tdesc filename ..." command. */
457
458static std::string tdesc_filename_cmd_string;
459
460/* Fetch the current target's description, and switch the current
461 architecture to one which incorporates that description. */
462
463void
465{
467
468 /* If we've already fetched a description from the target, don't do
469 it again. This allows a target to fetch the description early,
470 during its to_open or to_create_inferior, if it needs extra
471 information about the target to initialize. */
472 if (tdesc_info->fetched)
473 return;
474
475 /* The current architecture should not have any target description
476 specified. It should have been cleared, e.g. when we
477 disconnected from the previous target. */
478 gdb_assert (gdbarch_target_desc (target_gdbarch ()) == NULL);
479
480 /* First try to fetch an XML description from the user-specified
481 file. */
482 tdesc_info->tdesc = nullptr;
483 if (!tdesc_info->filename.empty ())
484 tdesc_info->tdesc = file_read_description_xml (tdesc_info->filename.data ());
485
486 /* Next try to read the description from the current target using
487 target objects. */
488 if (tdesc_info->tdesc == nullptr)
490 (current_inferior ()->top_target ());
491
492 /* If that failed try a target-specific hook. */
493 if (tdesc_info->tdesc == nullptr)
494 tdesc_info->tdesc = target_read_description
495 (current_inferior ()->top_target ());
496
497 /* If a non-NULL description was returned, then update the current
498 architecture. */
499 if (tdesc_info->tdesc != nullptr)
500 {
501 struct gdbarch_info info;
502
503 info.target_desc = tdesc_info->tdesc;
504 if (!gdbarch_update_p (info))
505 {
506 warning (_("Architecture rejected target-supplied description"));
507 tdesc_info->tdesc = nullptr;
508 }
509 else
510 {
511 struct tdesc_arch_data *data;
512
513 data = get_arch_data (target_gdbarch ());
514 if (tdesc_has_registers (tdesc_info->tdesc)
515 && data->arch_regs.empty ())
516 warning (_("Target-supplied registers are not supported "
517 "by the current architecture"));
518 }
519 }
520
521 /* Now that we know this description is usable, record that we
522 fetched it. */
523 tdesc_info->fetched = true;
524}
525
526/* Discard any description fetched from the current target, and switch
527 the current architecture to one with no target description. */
528
529void
531{
533
534 if (!tdesc_info->fetched)
535 return;
536
537 tdesc_info->fetched = false;
538 tdesc_info->tdesc = nullptr;
539
540 gdbarch_info info;
541 if (!gdbarch_update_p (info))
542 internal_error (_("Could not remove target-supplied description"));
543}
544
545/* Return the global current target description. This should only be
546 used by gdbarch initialization code; most access should be through
547 an existing gdbarch. */
548
549const struct target_desc *
551{
553
554 if (tdesc_info->fetched)
555 return tdesc_info->tdesc;
556
557 return NULL;
558}
559
560/* Return non-zero if this target description is compatible
561 with the given BFD architecture. */
562
563int
565 const struct bfd_arch_info *arch)
566{
567 for (const tdesc_compatible_info_up &compat : target_desc->compatible)
568 {
569 if (compat->arch () == arch
570 || arch->compatible (arch, compat->arch ())
571 || compat->arch ()->compatible (compat->arch (), arch))
572 return 1;
573 }
574
575 return 0;
576}
577
578
579/* Direct accessors for target descriptions. */
580
581/* Return the string value of a property named KEY, or NULL if the
582 property was not specified. */
583
584const char *
585tdesc_property (const struct target_desc *target_desc, const char *key)
586{
587 for (const property &prop : target_desc->properties)
588 if (prop.key == key)
589 return prop.value.c_str ();
590
591 return NULL;
592}
593
594/* Return the BFD architecture associated with this target
595 description, or NULL if no architecture was specified. */
596
597const struct bfd_arch_info *
599{
600 return target_desc->arch;
601}
602
603/* See gdbsupport/tdesc.h. */
604
605const char *
607{
608 if (target_desc->arch != NULL)
609 return target_desc->arch->printable_name;
610 return NULL;
611}
612
613/* See gdbsupport/tdesc.h. */
614
615const std::vector<tdesc_compatible_info_up> &
620
621/* See gdbsupport/tdesc.h. */
622
623const char *
624tdesc_compatible_info_arch_name (const tdesc_compatible_info_up &compatible)
625{
626 return compatible->arch ()->printable_name;
627}
628
629/* Return the OSABI associated with this target description, or
630 GDB_OSABI_UNKNOWN if no osabi was specified. */
631
632enum gdb_osabi
634{
635 return target_desc->osabi;
636}
637
638/* See gdbsupport/tdesc.h. */
639
640const char *
642{
643 enum gdb_osabi osabi = tdesc_osabi (target_desc);
644 if (osabi > GDB_OSABI_UNKNOWN && osabi < GDB_OSABI_INVALID)
645 return gdbarch_osabi_name (osabi);
646 return nullptr;
647}
648
649/* Return 1 if this target description includes any registers. */
650
651int
653{
654 if (target_desc == NULL)
655 return 0;
656
657 for (const tdesc_feature_up &feature : target_desc->features)
658 if (!feature->registers.empty ())
659 return 1;
660
661 return 0;
662}
663
664/* Return the feature with the given name, if present, or NULL if
665 the named feature is not found. */
666
667const struct tdesc_feature *
669 const char *name)
670{
671 for (const tdesc_feature_up &feature : target_desc->features)
672 if (feature->name == name)
673 return feature.get ();
674
675 return NULL;
676}
677
678/* Return the name of FEATURE. */
679
680const char *
681tdesc_feature_name (const struct tdesc_feature *feature)
682{
683 return feature->name.c_str ();
684}
685
686/* Lookup type associated with ID. */
687
688struct type *
689tdesc_find_type (struct gdbarch *gdbarch, const char *id)
690{
692
693 for (const tdesc_arch_reg &reg : data->arch_regs)
694 {
695 if (reg.reg
696 && reg.reg->tdesc_type
697 && reg.type
698 && reg.reg->tdesc_type->name == id)
699 return reg.type;
700 }
701
702 return NULL;
703}
704
705/* Support for registers from target descriptions. */
706
707/* Construct the per-gdbarch data. */
708
711{
712 return tdesc_arch_data_up (new tdesc_arch_data ());
713}
714
715/* See target-descriptions.h. */
716
717void
719{
720 delete data;
721}
722
723/* Search FEATURE for a register named NAME. */
724
725static struct tdesc_reg *
726tdesc_find_register_early (const struct tdesc_feature *feature,
727 const char *name)
728{
729 for (const tdesc_reg_up &reg : feature->registers)
730 if (strcasecmp (reg->name.c_str (), name) == 0)
731 return reg.get ();
732
733 return NULL;
734}
735
736/* Search FEATURE for a register named NAME. Assign REGNO to it. */
737
738int
739tdesc_numbered_register (const struct tdesc_feature *feature,
740 struct tdesc_arch_data *data,
741 int regno, const char *name)
742{
743 struct tdesc_reg *reg = tdesc_find_register_early (feature, name);
744
745 if (reg == NULL)
746 return 0;
747
748 /* Make sure the vector includes a REGNO'th element. */
749 while (regno >= data->arch_regs.size ())
750 data->arch_regs.emplace_back (nullptr, nullptr);
751
752 data->arch_regs[regno] = tdesc_arch_reg (reg, NULL);
753
754 return 1;
755}
756
757/* Search FEATURE for a register named NAME, but do not assign a fixed
758 register number to it. */
759
760int
761tdesc_unnumbered_register (const struct tdesc_feature *feature,
762 const char *name)
763{
764 struct tdesc_reg *reg = tdesc_find_register_early (feature, name);
765
766 if (reg == NULL)
767 return 0;
768
769 return 1;
770}
771
772/* Search FEATURE for a register whose name is in NAMES and assign
773 REGNO to it. */
774
775int
776tdesc_numbered_register_choices (const struct tdesc_feature *feature,
777 struct tdesc_arch_data *data,
778 int regno, const char *const names[])
779{
780 int i;
781
782 for (i = 0; names[i] != NULL; i++)
783 if (tdesc_numbered_register (feature, data, regno, names[i]))
784 return 1;
785
786 return 0;
787}
788
789/* See target-descriptions.h. */
790
791bool
792tdesc_found_register (struct tdesc_arch_data *data, int regno)
793{
794 gdb_assert (regno >= 0);
795
796 return (regno < data->arch_regs.size ()
797 && data->arch_regs[regno].reg != nullptr);
798}
799
800/* Search FEATURE for a register named NAME, and return its size in
801 bits. The register must exist. */
802
803int
804tdesc_register_bitsize (const struct tdesc_feature *feature, const char *name)
805{
806 struct tdesc_reg *reg = tdesc_find_register_early (feature, name);
807
808 gdb_assert (reg != NULL);
809 return reg->bitsize;
810}
811
812/* Look up a register by its GDB internal register number. */
813
814static struct tdesc_arch_reg *
816{
817 struct tdesc_arch_data *data = get_arch_data (gdbarch);
818
819 if (regno < data->arch_regs.size ())
820 return &data->arch_regs[regno];
821 else
822 return NULL;
823}
824
825static struct tdesc_reg *
827{
829
830 return reg? reg->reg : NULL;
831}
832
833/* Return the name of register REGNO, from the target description or
834 from an architecture-provided pseudo_register_name method. */
835
836const char *
838{
839 struct tdesc_reg *reg = tdesc_find_register (gdbarch, regno);
840 int num_regs = gdbarch_num_regs (gdbarch);
841
842 if (reg != NULL)
843 return reg->name.c_str ();
844
845 if (regno >= num_regs && regno < gdbarch_num_cooked_regs (gdbarch))
846 {
847 struct tdesc_arch_data *data = get_arch_data (gdbarch);
848
849 gdb_assert (data->pseudo_register_name != NULL);
850 return data->pseudo_register_name (gdbarch, regno);
851 }
852
853 return "";
854}
855
856struct type *
858{
859 struct tdesc_arch_reg *arch_reg = tdesc_find_arch_register (gdbarch, regno);
860 struct tdesc_reg *reg = arch_reg? arch_reg->reg : NULL;
861 int num_regs = gdbarch_num_regs (gdbarch);
862 int num_pseudo_regs = gdbarch_num_pseudo_regs (gdbarch);
863
864 if (reg == NULL && regno >= num_regs && regno < num_regs + num_pseudo_regs)
865 {
866 struct tdesc_arch_data *data = get_arch_data (gdbarch);
867
868 gdb_assert (data->pseudo_register_type != NULL);
869 return data->pseudo_register_type (gdbarch, regno);
870 }
871
872 if (reg == NULL)
873 /* Return "int0_t", since "void" has a misleading size of one. */
875
876 if (arch_reg->type == NULL)
877 {
878 /* First check for a predefined or target defined type. */
879 if (reg->tdesc_type)
880 arch_reg->type = make_gdb_type (gdbarch, reg->tdesc_type);
881
882 /* Next try size-sensitive type shortcuts. */
883 else if (reg->type == "float")
884 {
885 if (reg->bitsize == gdbarch_float_bit (gdbarch))
886 arch_reg->type = builtin_type (gdbarch)->builtin_float;
887 else if (reg->bitsize == gdbarch_double_bit (gdbarch))
889 else if (reg->bitsize == gdbarch_long_double_bit (gdbarch))
891 else
892 {
893 warning (_("Register \"%s\" has an unsupported size (%d bits)"),
894 reg->name.c_str (), reg->bitsize);
896 }
897 }
898 else if (reg->type == "int")
899 {
900 if (reg->bitsize == gdbarch_long_bit (gdbarch))
901 arch_reg->type = builtin_type (gdbarch)->builtin_long;
902 else if (reg->bitsize == TARGET_CHAR_BIT)
903 arch_reg->type = builtin_type (gdbarch)->builtin_char;
904 else if (reg->bitsize == gdbarch_short_bit (gdbarch))
905 arch_reg->type = builtin_type (gdbarch)->builtin_short;
906 else if (reg->bitsize == gdbarch_int_bit (gdbarch))
907 arch_reg->type = builtin_type (gdbarch)->builtin_int;
908 else if (reg->bitsize == gdbarch_long_long_bit (gdbarch))
910 else if (reg->bitsize == gdbarch_ptr_bit (gdbarch))
911 /* A bit desperate by this point... */
913 else
914 {
915 warning (_("Register \"%s\" has an unsupported size (%d bits)"),
916 reg->name.c_str (), reg->bitsize);
917 arch_reg->type = builtin_type (gdbarch)->builtin_long;
918 }
919 }
920
921 if (arch_reg->type == NULL)
922 internal_error ("Register \"%s\" has an unknown type \"%s\"",
923 reg->name.c_str (), reg->type.c_str ());
924 }
925
926 return arch_reg->type;
927}
928
929static int
931{
932 struct tdesc_reg *reg = tdesc_find_register (gdbarch, regno);
933
934 if (reg != NULL)
935 return reg->target_regnum;
936 else
937 return -1;
938}
939
940/* Check whether REGNUM is a member of REGGROUP. Registers from the
941 target description may be classified as general, float, vector or other
942 register groups registered with reggroup_add(). Unlike a gdbarch
943 register_reggroup_p method, this function will return -1 if it does not
944 know; the caller should handle registers with no specified group.
945
946 The names of containing features are not used. This might be extended
947 to display registers in some more useful groupings.
948
949 The save-restore flag is also implemented here. */
950
951int
953 const struct reggroup *reggroup)
954{
955 struct tdesc_reg *reg = tdesc_find_register (gdbarch, regno);
956
957 if (reg != NULL && !reg->group.empty ()
958 && (reg->group == reggroup->name ()))
959 return 1;
960
961 if (reg != NULL
963 return reg->save_restore;
964
965 return -1;
966}
967
968/* Check whether REGNUM is a member of REGGROUP. Registers with no
969 group specified go to the default reggroup function and are handled
970 by type. */
971
972static int
974 const struct reggroup *reggroup)
975{
976 int num_regs = gdbarch_num_regs (gdbarch);
977 int num_pseudo_regs = gdbarch_num_pseudo_regs (gdbarch);
978 int ret;
979
980 if (regno >= num_regs && regno < num_regs + num_pseudo_regs)
981 {
982 struct tdesc_arch_data *data = get_arch_data (gdbarch);
983
984 if (data->pseudo_register_reggroup_p != NULL)
985 return data->pseudo_register_reggroup_p (gdbarch, regno, reggroup);
986 /* Otherwise fall through to the default reggroup_p. */
987 }
988
990 if (ret != -1)
991 return ret;
992
994}
995
996/* Record architecture-specific functions to call for pseudo-register
997 support. */
998
999void
1001 gdbarch_register_name_ftype *pseudo_name)
1002{
1003 struct tdesc_arch_data *data = get_arch_data (gdbarch);
1004
1005 data->pseudo_register_name = pseudo_name;
1006}
1007
1008void
1010 gdbarch_register_type_ftype *pseudo_type)
1011{
1012 struct tdesc_arch_data *data = get_arch_data (gdbarch);
1013
1014 data->pseudo_register_type = pseudo_type;
1015}
1016
1017void
1019 (struct gdbarch *gdbarch,
1020 gdbarch_register_reggroup_p_ftype *pseudo_reggroup_p)
1021{
1022 struct tdesc_arch_data *data = get_arch_data (gdbarch);
1023
1024 data->pseudo_register_reggroup_p = pseudo_reggroup_p;
1025}
1026
1027/* Update GDBARCH to use the target description for registers. */
1028
1029void
1031 const struct target_desc *target_desc,
1032 tdesc_arch_data_up &&early_data,
1034{
1035 int num_regs = gdbarch_num_regs (gdbarch);
1036 struct tdesc_arch_data *data;
1037
1038 /* We can't use the description for registers if it doesn't describe
1039 any. This function should only be called after validating
1040 registers, so the caller should know that registers are
1041 included. */
1042 gdb_assert (tdesc_has_registers (target_desc));
1043
1044 data = get_arch_data (gdbarch);
1045 data->arch_regs = std::move (early_data->arch_regs);
1046
1047 /* Build up a set of all registers, so that we can assign register
1048 numbers where needed. The hash table expands as necessary, so
1049 the initial size is arbitrary. */
1050 htab_up reg_hash (htab_create (37, htab_hash_pointer, htab_eq_pointer,
1051 NULL));
1052 for (const tdesc_feature_up &feature : target_desc->features)
1053 for (const tdesc_reg_up &reg : feature->registers)
1054 {
1055 void **slot = htab_find_slot (reg_hash.get (), reg.get (), INSERT);
1056
1057 *slot = reg.get ();
1058 /* Add reggroup if its new. */
1059 if (!reg->group.empty ())
1060 if (reggroup_find (gdbarch, reg->group.c_str ()) == NULL)
1062 reg->group.c_str (),
1063 USER_REGGROUP));
1064 }
1065
1066 /* Remove any registers which were assigned numbers by the
1067 architecture. */
1068 for (const tdesc_arch_reg &arch_reg : data->arch_regs)
1069 if (arch_reg.reg != NULL)
1070 htab_remove_elt (reg_hash.get (), arch_reg.reg);
1071
1072 /* Assign numbers to the remaining registers and add them to the
1073 list of registers. The new numbers are always above gdbarch_num_regs.
1074 Iterate over the features, not the hash table, so that the order
1075 matches that in the target description. */
1076
1077 gdb_assert (data->arch_regs.size () <= num_regs);
1078 while (data->arch_regs.size () < num_regs)
1079 data->arch_regs.emplace_back (nullptr, nullptr);
1080
1081 /* First we give the target a chance to number previously unknown
1082 registers. This allows targets to record the numbers assigned based
1083 on which feature the register was from. */
1084 if (unk_reg_cb != NULL)
1085 {
1086 for (const tdesc_feature_up &feature : target_desc->features)
1087 for (const tdesc_reg_up &reg : feature->registers)
1088 if (htab_find (reg_hash.get (), reg.get ()) != NULL)
1089 {
1090 int regno = unk_reg_cb (gdbarch, feature.get (),
1091 reg->name.c_str (), num_regs);
1092 gdb_assert (regno == -1 || regno >= num_regs);
1093 if (regno != -1)
1094 {
1095 while (regno >= data->arch_regs.size ())
1096 data->arch_regs.emplace_back (nullptr, nullptr);
1097 data->arch_regs[regno] = tdesc_arch_reg (reg.get (), NULL);
1098 num_regs = regno + 1;
1099 htab_remove_elt (reg_hash.get (), reg.get ());
1100 }
1101 }
1102 }
1103
1104 /* Ensure the array was sized correctly above. */
1105 gdb_assert (data->arch_regs.size () == num_regs);
1106
1107 /* Now in a final pass we assign register numbers to any remaining
1108 unnumbered registers. */
1109 for (const tdesc_feature_up &feature : target_desc->features)
1110 for (const tdesc_reg_up &reg : feature->registers)
1111 if (htab_find (reg_hash.get (), reg.get ()) != NULL)
1112 {
1113 data->arch_regs.emplace_back (reg.get (), nullptr);
1114 num_regs++;
1115 }
1116
1117 /* Update the architecture. */
1118 set_gdbarch_num_regs (gdbarch, num_regs);
1124}
1125
1126/* See gdbsupport/tdesc.h. */
1127
1128struct tdesc_feature *
1129tdesc_create_feature (struct target_desc *tdesc, const char *name)
1130{
1131 struct tdesc_feature *new_feature = new tdesc_feature (name);
1132
1133 tdesc->features.emplace_back (new_feature);
1134
1135 return new_feature;
1136}
1137
1138/* See gdbsupport/tdesc.h. */
1139
1140target_desc_up
1142{
1143 return target_desc_up (new target_desc ());
1144}
1145
1146/* See gdbsupport/tdesc.h. */
1147
1148void
1149target_desc_deleter::operator() (struct target_desc *target_desc) const
1150{
1151 delete target_desc;
1152}
1153
1154void
1156 const struct bfd_arch_info *compatible)
1157{
1158 /* If this instance of GDB is compiled without BFD support for the
1159 compatible architecture, simply ignore it -- we would not be able
1160 to handle it anyway. */
1161 if (compatible == NULL)
1162 return;
1163
1164 for (const tdesc_compatible_info_up &compat : target_desc->compatible)
1165 if (compat->arch () == compatible)
1166 internal_error (_("Attempted to add duplicate "
1167 "compatible architecture \"%s\""),
1168 compatible->printable_name);
1169
1170 target_desc->compatible.push_back
1171 (std::unique_ptr<tdesc_compatible_info>
1172 (new tdesc_compatible_info (compatible)));
1173}
1174
1175void
1177 const char *key, const char *value)
1178{
1179 gdb_assert (key != NULL && value != NULL);
1180
1181 if (tdesc_property (target_desc, key) != NULL)
1182 internal_error (_("Attempted to add duplicate property \"%s\""), key);
1183
1184 target_desc->properties.emplace_back (key, value);
1185}
1186
1187/* See gdbsupport/tdesc.h. */
1188
1189void
1191 const char *name)
1192{
1193 set_tdesc_architecture (target_desc, bfd_scan_arch (name));
1194}
1195
1196void
1198 const struct bfd_arch_info *arch)
1199{
1200 target_desc->arch = arch;
1201}
1202
1203/* See gdbsupport/tdesc.h. */
1204
1205void
1210
1211void
1213{
1214 target_desc->osabi = osabi;
1215}
1216
1217
1220
1221/* Helper functions for the CLI commands. */
1222
1223static void
1224set_tdesc_filename_cmd (const char *args, int from_tty,
1225 struct cmd_list_element *c)
1226{
1227 target_desc_info *tdesc_info = &current_inferior ()->tdesc_info;
1228
1229 tdesc_info->filename = tdesc_filename_cmd_string;
1230
1233}
1234
1235static void
1236show_tdesc_filename_cmd (struct ui_file *file, int from_tty,
1237 struct cmd_list_element *c,
1238 const char *value)
1239{
1241
1242 if (value != NULL && *value != '\0')
1243 gdb_printf (file,
1244 _("The target description will be read from \"%s\".\n"),
1245 value);
1246 else
1247 gdb_printf (file,
1248 _("The target description will be "
1249 "read from the target.\n"));
1250}
1251
1252static void
1253unset_tdesc_filename_cmd (const char *args, int from_tty)
1254{
1255 target_desc_info *tdesc_info = &current_inferior ()->tdesc_info;
1256
1257 tdesc_info->filename.clear ();
1260}
1261
1262/* Print target description in C. */
1263
1264class print_c_tdesc : public tdesc_element_visitor
1265{
1266public:
1267 print_c_tdesc (std::string &filename_after_features)
1268 : m_filename_after_features (filename_after_features)
1269 {
1270 const char *inp;
1271 char *outp;
1272 const char *filename = lbasename (m_filename_after_features.c_str ());
1273
1274 m_function = (char *) xmalloc (strlen (filename) + 1);
1275 for (inp = filename, outp = m_function; *inp != '\0'; inp++)
1276 if (*inp == '.')
1277 break;
1278 else if (*inp == '-')
1279 *outp++ = '_';
1280 else if (*inp == ' ')
1281 *outp++ = '_';
1282 else
1283 *outp++ = *inp;
1284 *outp = '\0';
1285
1286 /* Standard boilerplate. */
1287 gdb_printf ("/* THIS FILE IS GENERATED. "
1288 "-*- buffer-read-only: t -*- vi"
1289 ":set ro:\n");
1290 }
1291
1293 {
1294 xfree (m_function);
1295 }
1296
1297 void visit_pre (const target_desc *e) override
1298 {
1299 gdb_printf (" Original: %s */\n\n",
1300 lbasename (m_filename_after_features.c_str ()));
1301
1302 gdb_printf ("#include \"defs.h\"\n");
1303 gdb_printf ("#include \"osabi.h\"\n");
1304 gdb_printf ("#include \"target-descriptions.h\"\n");
1305 gdb_printf ("\n");
1306
1307 gdb_printf ("const struct target_desc *tdesc_%s;\n", m_function);
1308 gdb_printf ("static void\n");
1309 gdb_printf ("initialize_tdesc_%s (void)\n", m_function);
1310 gdb_printf ("{\n");
1312 (" target_desc_up result = allocate_target_description ();\n");
1313
1314 if (tdesc_architecture (e) != NULL)
1315 {
1317 (" set_tdesc_architecture (result.get (), bfd_scan_arch (\"%s\"));\n",
1318 tdesc_architecture (e)->printable_name);
1319 gdb_printf ("\n");
1320 }
1323 {
1325 (" set_tdesc_osabi (result.get (), osabi_from_tdesc_string (\"%s\"));\n",
1327 gdb_printf ("\n");
1328 }
1329
1330 for (const tdesc_compatible_info_up &compatible : e->compatible)
1332 (" tdesc_add_compatible (result.get (), bfd_scan_arch (\"%s\"));\n",
1333 compatible->arch ()->printable_name);
1334
1335 if (!e->compatible.empty ())
1336 gdb_printf ("\n");
1337
1338 for (const property &prop : e->properties)
1339 gdb_printf (" set_tdesc_property (result.get (), \"%s\", \"%s\");\n",
1340 prop.key.c_str (), prop.value.c_str ());
1341
1342 gdb_printf (" struct tdesc_feature *feature;\n");
1343 }
1344
1345 void visit_pre (const tdesc_feature *e) override
1346 {
1347 gdb_printf ("\n feature = tdesc_create_feature (result.get (), \"%s\");\n",
1348 e->name.c_str ());
1349 }
1350
1351 void visit_post (const tdesc_feature *e) override
1352 {}
1353
1354 void visit_post (const target_desc *e) override
1355 {
1356 gdb_printf ("\n tdesc_%s = result.release ();\n", m_function);
1357 gdb_printf ("}\n");
1358 }
1359
1360 void visit (const tdesc_type_builtin *type) override
1361 {
1362 error (_("C output is not supported type \"%s\"."), type->name.c_str ());
1363 }
1364
1365 void visit (const tdesc_type_vector *type) override
1366 {
1368 {
1369 gdb_printf (" tdesc_type *element_type;\n");
1371 }
1372
1374 (" element_type = tdesc_named_type (feature, \"%s\");\n",
1375 type->element_type->name.c_str ());
1377 (" tdesc_create_vector (feature, \"%s\", element_type, %d);\n",
1378 type->name.c_str (), type->count);
1379
1380 gdb_printf ("\n");
1381 }
1382
1383 void visit (const tdesc_type_with_fields *type) override
1384 {
1386 {
1387 gdb_printf (" tdesc_type_with_fields *type_with_fields;\n");
1389 }
1390
1391 switch (type->kind)
1392 {
1393 case TDESC_TYPE_STRUCT:
1394 case TDESC_TYPE_FLAGS:
1395 if (type->kind == TDESC_TYPE_STRUCT)
1396 {
1398 (" type_with_fields = tdesc_create_struct (feature, \"%s\");\n",
1399 type->name.c_str ());
1400 if (type->size != 0)
1402 (" tdesc_set_struct_size (type_with_fields, %d);\n", type->size);
1403 }
1404 else
1405 {
1407 (" type_with_fields = tdesc_create_flags (feature, \"%s\", %d);\n",
1408 type->name.c_str (), type->size);
1409 }
1410 for (const tdesc_type_field &f : type->fields)
1411 {
1412 const char *type_name;
1413
1414 gdb_assert (f.type != NULL);
1415 type_name = f.type->name.c_str ();
1416
1417 /* To minimize changes to generated files, don't emit type
1418 info for fields that have defaulted types. */
1419 if (f.start != -1)
1420 {
1421 gdb_assert (f.end != -1);
1422 if (f.type->kind == TDESC_TYPE_BOOL)
1423 {
1424 gdb_assert (f.start == f.end);
1426 (" tdesc_add_flag (type_with_fields, %d, \"%s\");\n",
1427 f.start, f.name.c_str ());
1428 }
1429 else if ((type->size == 4 && f.type->kind == TDESC_TYPE_UINT32)
1430 || (type->size == 8
1431 && f.type->kind == TDESC_TYPE_UINT64))
1432 {
1434 (" tdesc_add_bitfield (type_with_fields, \"%s\", %d, %d);\n",
1435 f.name.c_str (), f.start, f.end);
1436 }
1437 else
1438 {
1440 ("tdesc_named_type (feature, \"%s\");\n",
1441 type_name);
1443 (" tdesc_add_typed_bitfield (type_with_fields, \"%s\","
1444 " %d, %d, field_type);\n",
1445 f.name.c_str (), f.start, f.end);
1446 }
1447 }
1448 else /* Not a bitfield. */
1449 {
1450 gdb_assert (f.end == -1);
1451 gdb_assert (type->kind == TDESC_TYPE_STRUCT);
1453 ("tdesc_named_type (feature, \"%s\");\n", type_name);
1455 (" tdesc_add_field (type_with_fields, \"%s\", field_type);\n",
1456 f.name.c_str ());
1457 }
1458 }
1459 break;
1460 case TDESC_TYPE_UNION:
1462 (" type_with_fields = tdesc_create_union (feature, \"%s\");\n",
1463 type->name.c_str ());
1464 for (const tdesc_type_field &f : type->fields)
1465 {
1467 ("tdesc_named_type (feature, \"%s\");\n", f.type->name.c_str ());
1469 (" tdesc_add_field (type_with_fields, \"%s\", field_type);\n",
1470 f.name.c_str ());
1471 }
1472 break;
1473 case TDESC_TYPE_ENUM:
1475 (" type_with_fields = tdesc_create_enum (feature, \"%s\", %d);\n",
1476 type->name.c_str (), type->size);
1477 for (const tdesc_type_field &f : type->fields)
1479 (" tdesc_add_enum_value (type_with_fields, %d, \"%s\");\n",
1480 f.start, f.name.c_str ());
1481 break;
1482 default:
1483 error (_("C output is not supported type \"%s\"."), type->name.c_str ());
1484 }
1485
1486 gdb_printf ("\n");
1487 }
1488
1489 void visit (const tdesc_reg *reg) override
1490 {
1491 gdb_printf (" tdesc_create_reg (feature, \"%s\", %ld, %d, ",
1492 reg->name.c_str (), reg->target_regnum,
1493 reg->save_restore);
1494 if (!reg->group.empty ())
1495 gdb_printf ("\"%s\", ", reg->group.c_str ());
1496 else
1497 gdb_printf ("NULL, ");
1498 gdb_printf ("%d, \"%s\");\n", reg->bitsize, reg->type.c_str ());
1499 }
1500
1501protected:
1503
1504private:
1505
1506 /* Print an assignment to the field_type variable. Print the declaration
1507 of field_type if that has not been done yet. */
1508 ATTRIBUTE_PRINTF (2, 3)
1509 void printf_field_type_assignment (const char *fmt, ...)
1510 {
1512 {
1513 gdb_printf (" tdesc_type *field_type;\n");
1514 m_printed_field_type = true;
1515 }
1516
1517 gdb_printf (" field_type = ");
1518
1519 va_list args;
1520 va_start (args, fmt);
1521 gdb_vprintf (fmt, args);
1522 va_end (args);
1523 }
1524
1526
1527 /* Did we print "struct tdesc_type *element_type;" yet? */
1529
1530 /* Did we print "struct tdesc_type_with_fields *element_type;" yet? */
1532
1533 /* Did we print "struct tdesc_type *field_type;" yet? */
1535};
1536
1537/* Print target description feature in C. */
1538
1540{
1541public:
1542 print_c_feature (std::string &file)
1543 : print_c_tdesc (file)
1544 {
1545 /* Trim ".tmp". */
1546 auto const pos = m_filename_after_features.find_last_of ('.');
1547
1549 }
1550
1551 void visit_pre (const target_desc *e) override
1552 {
1553 gdb_printf (" Original: %s */\n\n",
1554 lbasename (m_filename_after_features.c_str ()));
1555
1556 gdb_printf ("#include \"gdbsupport/tdesc.h\"\n");
1557 gdb_printf ("\n");
1558 }
1559
1560 void visit_post (const target_desc *e) override
1561 {}
1562
1563 void visit_pre (const tdesc_feature *e) override
1564 {
1565 std::string name (m_filename_after_features);
1566
1567 auto pos = name.find_first_of ('.');
1568
1569 name = name.substr (0, pos);
1570 std::replace (name.begin (), name.end (), '/', '_');
1571 std::replace (name.begin (), name.end (), '-', '_');
1572
1573 gdb_printf ("static int\n");
1574 gdb_printf ("create_feature_%s ", name.c_str ());
1575 gdb_printf ("(struct target_desc *result, long regnum)\n");
1576
1577 gdb_printf ("{\n");
1578 gdb_printf (" struct tdesc_feature *feature;\n");
1579
1581 ("\n feature = tdesc_create_feature (result, \"%s\");\n",
1582 e->name.c_str ());
1583 }
1584
1585 void visit_post (const tdesc_feature *e) override
1586 {
1587 gdb_printf (" return regnum;\n");
1588 gdb_printf ("}\n");
1589 }
1590
1591 void visit (const tdesc_reg *reg) override
1592 {
1593 /* Most "reg" in XML target descriptions don't have "regnum"
1594 attribute, so the register number is allocated sequentially.
1595 In case that reg has "regnum" attribute, register number
1596 should be set by that explicitly. */
1597
1598 if (reg->target_regnum < m_next_regnum)
1599 {
1600 /* The integrity check, it can catch some errors on register
1601 number collision, like this,
1602
1603 <reg name="x0" bitsize="32"/>
1604 <reg name="x1" bitsize="32"/>
1605 <reg name="x2" bitsize="32"/>
1606 <reg name="x3" bitsize="32"/>
1607 <reg name="ps" bitsize="32" regnum="3"/>
1608
1609 but it also has false negatives. The target description
1610 below is correct,
1611
1612 <reg name="x1" bitsize="32" regnum="1"/>
1613 <reg name="x3" bitsize="32" regnum="3"/>
1614 <reg name="x2" bitsize="32" regnum="2"/>
1615 <reg name="x4" bitsize="32" regnum="4"/>
1616
1617 but it is not a good practice, so still error on this,
1618 and also print the message so that it can be saved in the
1619 generated c file. */
1620
1621 gdb_printf ("ERROR: \"regnum\" attribute %ld ",
1622 reg->target_regnum);
1623 gdb_printf ("is not the largest number (%d).\n",
1625 error (_("\"regnum\" attribute %ld is not the largest number (%d)."),
1626 reg->target_regnum, m_next_regnum);
1627 }
1628
1629 if (reg->target_regnum > m_next_regnum)
1630 {
1631 gdb_printf (" regnum = %ld;\n", reg->target_regnum);
1632 m_next_regnum = reg->target_regnum;
1633 }
1634
1635 gdb_printf (" tdesc_create_reg (feature, \"%s\", regnum++, %d, ",
1636 reg->name.c_str (), reg->save_restore);
1637 if (!reg->group.empty ())
1638 gdb_printf ("\"%s\", ", reg->group.c_str ());
1639 else
1640 gdb_printf ("NULL, ");
1641 gdb_printf ("%d, \"%s\");\n", reg->bitsize, reg->type.c_str ());
1642
1643 m_next_regnum++;
1644 }
1645
1646private:
1647 /* The register number to use for the next register we see. */
1649};
1650
1651/* See gdbsupport/tdesc.h. */
1652
1653const char *
1655{
1656 if (tdesc->xmltarget == nullptr)
1657 {
1658 std::string buffer ("@");
1659 print_xml_feature v (&buffer);
1660 tdesc->accept (v);
1661 tdesc->xmltarget = xstrdup (buffer.c_str ());
1662 }
1663 return tdesc->xmltarget;
1664}
1665
1666/* Data structures and functions to setup the option flags for 'maintenance
1667 print c-tdesc command. */
1668
1670{
1671 /* True when the '-single-feature' flag was passed. */
1672 bool single_feature = false;
1673};
1674
1680 "single-feature",
1681 [] (maint_print_c_tdesc_options *opt) { return &opt->single_feature; },
1682 N_("Print C description of just a single feature.")
1683 },
1684};
1685
1690}
1691
1692/* Implement 'maintenance print c-tdesc' command. */
1693
1694static void
1695maint_print_c_tdesc_cmd (const char *args, int from_tty)
1696{
1697 const struct target_desc *tdesc;
1698 const char *filename;
1699
1704
1705 if (args == NULL)
1706 {
1707 /* Use the global target-supplied description, not the current
1708 architecture's. This lets a GDB for one architecture generate C
1709 for another architecture's description, even though the gdbarch
1710 initialization code will reject the new description. */
1711 target_desc_info *tdesc_info = &current_inferior ()->tdesc_info;
1712 tdesc = tdesc_info->tdesc;
1713 filename = tdesc_info->filename.data ();
1714 }
1715 else
1716 {
1717 /* Use the target description from the XML file. */
1718 filename = args;
1719 tdesc = file_read_description_xml (filename);
1720 }
1721
1722 if (tdesc == NULL)
1723 error (_("There is no target description to print."));
1724
1725 if (filename == NULL)
1726 filename = "fetched from target";
1727
1728 std::string filename_after_features (filename);
1729 auto loc = filename_after_features.rfind ("/features/");
1730
1731 if (loc != std::string::npos)
1732 filename_after_features = filename_after_features.substr (loc + 10);
1733
1734 /* Print c files for target features instead of target descriptions,
1735 because c files got from target features are more flexible than the
1736 counterparts. */
1737 if (opts.single_feature)
1738 {
1739 if (tdesc->features.size () != 1)
1740 error (_("only target descriptions with 1 feature can be used "
1741 "with -single-feature option"));
1742
1743 print_c_feature v (filename_after_features);
1744
1745 tdesc->accept (v);
1746 }
1747 else
1748 {
1749 print_c_tdesc v (filename_after_features);
1750
1751 tdesc->accept (v);
1752 }
1753}
1754
1755/* Completer for the "backtrace" command. */
1756
1757static void
1759 completion_tracker &tracker,
1760 const char *text, const char *word)
1761{
1762 auto grp = make_maint_print_c_tdesc_options_def_group (nullptr);
1764 (tracker, &text, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR, grp))
1765 return;
1766
1767 word = advance_to_filename_complete_word_point (tracker, text);
1768 filename_completer (ignore, tracker, text, word);
1769}
1770
1771/* Implement the maintenance print xml-tdesc command. */
1772
1773static void
1774maint_print_xml_tdesc_cmd (const char *args, int from_tty)
1775{
1776 const struct target_desc *tdesc;
1777
1778 if (args == NULL)
1779 {
1780 /* Use the global target-supplied description, not the current
1781 architecture's. This lets a GDB for one architecture generate XML
1782 for another architecture's description, even though the gdbarch
1783 initialization code will reject the new description. */
1784 tdesc = current_inferior ()->tdesc_info.tdesc;
1785 }
1786 else
1787 {
1788 /* Use the target description from the XML file. */
1789 tdesc = file_read_description_xml (args);
1790 }
1791
1792 if (tdesc == NULL)
1793 error (_("There is no target description to print."));
1794
1795 std::string buf;
1796 print_xml_feature v (&buf);
1797 tdesc->accept (v);
1798 gdb_puts (buf.c_str ());
1799}
1800
1801namespace selftests {
1802
1803/* A reference target description, used for testing (see record_xml_tdesc). */
1805struct xml_test_tdesc
1807 xml_test_tdesc (const char *name, std::unique_ptr<const target_desc> &&tdesc)
1808 : name (name), tdesc (std::move (tdesc))
1809 {}
1811 const char *name;
1812 std::unique_ptr<const target_desc> tdesc;
1813};
1815static std::vector<xml_test_tdesc> xml_tdesc;
1816
1817#if GDB_SELF_TEST
1818
1819/* See target-descriptions.h. */
1820
1821void
1822record_xml_tdesc (const char *xml_file, const struct target_desc *tdesc)
1823{
1824 xml_tdesc.emplace_back (xml_file, std::unique_ptr<const target_desc> (tdesc));
1825}
1826#endif
1827
1828}
1829
1830/* Test the conversion process of a target description to/from xml: Take a target
1831 description TDESC, convert to xml, back to a description, and confirm the new
1832 tdesc is identical to the original. */
1833static bool
1834maintenance_check_tdesc_xml_convert (const target_desc *tdesc, const char *name)
1835{
1836 const char *xml = tdesc_get_features_xml (tdesc);
1837
1838 if (xml == nullptr || *xml != '@')
1839 {
1840 gdb_printf (_("Could not convert description for %s to xml.\n"),
1841 name);
1842 return false;
1843 }
1844
1845 const target_desc *tdesc_trans = string_read_description_xml (xml + 1);
1846
1847 if (tdesc_trans == nullptr)
1848 {
1849 gdb_printf (_("Could not convert description for %s from xml.\n"),
1850 name);
1851 return false;
1852 }
1853 else if (*tdesc != *tdesc_trans)
1854 {
1855 gdb_printf (_("Converted description for %s does not match.\n"),
1856 name);
1857 return false;
1858 }
1859 return true;
1860}
1861
1862
1863/* Check that the target descriptions created dynamically by
1864 architecture-specific code equal the descriptions created from XML files
1865 found in the specified directory DIR. */
1866
1867static void
1868maintenance_check_xml_descriptions (const char *dir, int from_tty)
1869{
1870 if (dir == NULL)
1871 error (_("Missing dir name"));
1872
1873 gdb::unique_xmalloc_ptr<char> dir1 (tilde_expand (dir));
1874 std::string feature_dir (dir1.get ());
1875 unsigned int failed = 0;
1876
1877 for (auto const &e : selftests::xml_tdesc)
1878 {
1879 std::string tdesc_xml = (feature_dir + SLASH_STRING + e.name);
1880 const target_desc *tdesc
1881 = file_read_description_xml (tdesc_xml.data ());
1882
1883 if (tdesc == NULL || *tdesc != *e.tdesc)
1884 {
1885 gdb_printf ( _("Descriptions for %s do not match.\n"), e.name);
1886 failed++;
1887 }
1888 else if (!maintenance_check_tdesc_xml_convert (tdesc, e.name)
1889 || !maintenance_check_tdesc_xml_convert (e.tdesc.get (), e.name))
1890 failed++;
1891 }
1892 gdb_printf (_("Tested %lu XML files, %d failed\n"),
1893 (long) selftests::xml_tdesc.size (), failed);
1894}
1895
1897void
1899{
1900 cmd_list_element *cmd;
1901
1903 _("Set target description specific variables."),
1904 _("Show target description specific variables."),
1906 &setlist, &showlist);
1907
1909Unset target description specific variables."),
1911 0 /* allow-unknown */, &unsetlist);
1912
1915 _("\
1916Set the file to read for an XML target description."), _("\
1917Show the file to read for an XML target description."), _("\
1918When set, GDB will read the target description from a local\n\
1919file instead of querying the remote target."),
1923
1925Unset the file to read for an XML target description.\n\
1926When unset, GDB will read the description from the target."),
1928
1929 auto grp = make_maint_print_c_tdesc_options_def_group (nullptr);
1930 static std::string help_text
1932Print the current target description as a C source file.\n\
1933Usage: maintenance print c-tdesc [OPTION] [FILENAME]\n\
1934\n\
1935Options:\n\
1936%OPTIONS%\n\
1937\n\
1938When FILENAME is not provided then print the current target\n\
1939description, otherwise an XML target description is read from\n\
1940FILENAME and printed as a C function.\n\
1941\n\
1942When '-single-feature' is used then the target description should\n\
1943contain a single feature and the generated C code will only create\n\
1944that feature within an already existing target_desc object."), grp);
1946 help_text.c_str (), &maintenanceprintlist);
1948
1949 cmd = add_cmd ("xml-tdesc", class_maintenance, maint_print_xml_tdesc_cmd, _("\
1950Print the current target description as an XML file."),
1953
1954 cmd = add_cmd ("xml-descriptions", class_maintenance,
1956Check equality of GDB target descriptions and XML created descriptions.\n\
1957Check the target descriptions created in GDB equal the descriptions\n\
1958created from XML files in the directory.\n\
1959The parameter is the directory name."),
1962}
const char *const name
void * xmalloc(YYSIZE_T)
void xfree(void *)
int gdbarch_update_p(struct gdbarch_info info)
Definition arch-utils.c:585
struct gdbarch * target_gdbarch(void)
void f()
Definition 1.cc:36
static struct type * get_type(const struct varobj *var)
Definition c-varobj.c:463
target_desc_info tdesc_info
Definition inferior.h:648
void visit(const tdesc_reg *reg) override
void visit_post(const tdesc_feature *e) override
void visit_pre(const target_desc *e) override
void visit_post(const target_desc *e) override
print_c_feature(std::string &file)
void visit_pre(const tdesc_feature *e) override
void visit_pre(const tdesc_feature *e) override
print_c_tdesc(std::string &filename_after_features)
void visit_post(const tdesc_feature *e) override
void printf_field_type_assignment(const char *fmt,...)
void visit_post(const target_desc *e) override
void visit(const tdesc_type_with_fields *type) override
void visit_pre(const target_desc *e) override
void visit(const tdesc_type_builtin *type) override
void visit(const tdesc_reg *reg) override
void visit(const tdesc_type_vector *type) override
std::string m_filename_after_features
void * get(unsigned key)
Definition registry.h:211
const bfd_arch_info_type * arch() const
tdesc_compatible_info(const bfd_arch_info_type *arch)
const bfd_arch_info_type * m_arch
type * new_type()
Definition gdbtypes.c:208
struct cmd_list_element * showlist
Definition cli-cmds.c:127
struct cmd_list_element * maintenanceprintlist
Definition cli-cmds.c:151
struct cmd_list_element * maintenancechecklist
Definition cli-cmds.c:155
struct cmd_list_element * setlist
Definition cli-cmds.c:119
struct cmd_list_element * unsetlist
Definition cli-cmds.c:123
set_show_commands add_setshow_filename_cmd(const char *name, enum command_class theclass, std::string *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition cli-decode.c:855
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, const char *doc, struct cmd_list_element **list)
Definition cli-decode.c:233
void set_cmd_completer_handle_brkchars(struct cmd_list_element *cmd, completer_handle_brkchars_ftype *func)
Definition cli-decode.c:125
void set_cmd_completer(struct cmd_list_element *cmd, completer_ftype *completer)
Definition cli-decode.c:117
set_show_commands add_setshow_prefix_cmd(const char *name, command_class theclass, const char *set_doc, const char *show_doc, cmd_list_element **set_subcommands_list, cmd_list_element **show_subcommands_list, cmd_list_element **set_list, cmd_list_element **show_list)
Definition cli-decode.c:428
struct cmd_list_element * add_basic_prefix_cmd(const char *name, enum command_class theclass, const char *doc, struct cmd_list_element **subcommands, int allow_unknown, struct cmd_list_element **list)
Definition cli-decode.c:391
@ class_obscure
Definition command.h:64
@ class_maintenance
Definition command.h:65
const char * advance_to_filename_complete_word_point(completion_tracker &tracker, const char *text)
Definition completer.c:432
void filename_completer(struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *word)
Definition completer.c:204
static void ATTRIBUTE_PRINTF(1, 0)
Definition gdb_bfd.c:1154
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition gdbarch.c:1396
void set_gdbarch_register_name(struct gdbarch *gdbarch, gdbarch_register_name_ftype *register_name)
int gdbarch_long_long_bit(struct gdbarch *gdbarch)
Definition gdbarch.c:1483
int gdbarch_register_reggroup_p_ftype(struct gdbarch *gdbarch, int regnum, const struct reggroup *reggroup)
int gdbarch_short_bit(struct gdbarch *gdbarch)
Definition gdbarch.c:1432
int gdbarch_num_regs(struct gdbarch *gdbarch)
Definition gdbarch.c:1930
int gdbarch_int_bit(struct gdbarch *gdbarch)
Definition gdbarch.c:1449
int gdbarch_float_bit(struct gdbarch *gdbarch)
Definition gdbarch.c:1568
void set_gdbarch_register_reggroup_p(struct gdbarch *gdbarch, gdbarch_register_reggroup_p_ftype *register_reggroup_p)
struct type * gdbarch_register_type_ftype(struct gdbarch *gdbarch, int reg_nr)
int gdbarch_num_pseudo_regs(struct gdbarch *gdbarch)
Definition gdbarch.c:1948
void set_gdbarch_register_type(struct gdbarch *gdbarch, gdbarch_register_type_ftype *register_type)
const struct target_desc * gdbarch_target_desc(struct gdbarch *gdbarch)
Definition gdbarch.c:1423
void set_gdbarch_remote_register_number(struct gdbarch *gdbarch, gdbarch_remote_register_number_ftype *remote_register_number)
int gdbarch_long_double_bit(struct gdbarch *gdbarch)
Definition gdbarch.c:1636
void set_gdbarch_num_regs(struct gdbarch *gdbarch, int num_regs)
Definition gdbarch.c:1941
int gdbarch_long_bit(struct gdbarch *gdbarch)
Definition gdbarch.c:1466
const char * gdbarch_register_name_ftype(struct gdbarch *gdbarch, int regnr)
int gdbarch_ptr_bit(struct gdbarch *gdbarch)
Definition gdbarch.c:1722
int gdbarch_double_bit(struct gdbarch *gdbarch)
Definition gdbarch.c:1602
static int gdbarch_num_cooked_regs(gdbarch *arch)
Definition gdbarch.h:390
struct type * arch_composite_type(struct gdbarch *gdbarch, const char *name, enum type_code code)
Definition gdbtypes.c:5734
struct type * arch_flags_type(struct gdbarch *gdbarch, const char *name, int bit)
Definition gdbtypes.c:5681
struct type * init_vector_type(struct type *elt_type, int n)
Definition gdbtypes.c:1491
void append_flags_type_field(struct type *type, int start_bitpos, int nr_bits, struct type *field_type, const char *name)
Definition gdbtypes.c:5699
const struct floatformat * floatformats_bfloat16[BFD_ENDIAN_UNKNOWN]
Definition gdbtypes.c:129
const struct floatformat * floatformats_ieee_single[BFD_ENDIAN_UNKNOWN]
Definition gdbtypes.c:85
struct type * init_float_type(type_allocator &alloc, int bit, const char *name, const struct floatformat **floatformats, enum bfd_endian byte_order)
Definition gdbtypes.c:3408
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition gdbtypes.c:6168
const struct floatformat * floatformats_arm_ext[BFD_ENDIAN_UNKNOWN]
Definition gdbtypes.c:109
struct field * append_composite_type_field_raw(struct type *t, const char *name, struct type *field)
Definition gdbtypes.c:5751
const struct floatformat * floatformats_ieee_half[BFD_ENDIAN_UNKNOWN]
Definition gdbtypes.c:81
const struct floatformat * floatformats_ieee_double[BFD_ENDIAN_UNKNOWN]
Definition gdbtypes.c:89
void append_composite_type_field(struct type *t, const char *name, struct type *field)
Definition gdbtypes.c:5810
const struct floatformat * floatformats_i387_ext[BFD_ENDIAN_UNKNOWN]
Definition gdbtypes.c:101
size_t size
Definition go32-nat.c:239
struct inferior * current_inferior(void)
Definition inferior.c:55
bool process_options(const char **args, process_options_mode mode, gdb::array_view< const option_def_group > options_group)
Definition cli-option.c:627
@ PROCESS_OPTIONS_UNKNOWN_IS_ERROR
Definition cli-option.h:333
std::string build_help(const char *help_tmpl, gdb::array_view< const option_def_group > options_group)
Definition cli-option.c:766
bool complete_options(completion_tracker &tracker, const char **args, process_options_mode mode, gdb::array_view< const option_def_group > options_group)
Definition cli-option.c:467
static std::vector< xml_test_tdesc > xml_tdesc
const char * gdbarch_osabi_name(enum gdb_osabi osabi)
Definition osabi.c:90
enum gdb_osabi osabi_from_tdesc_string(const char *name)
Definition osabi.c:113
gdb_osabi
Definition osabi.h:25
@ GDB_OSABI_INVALID
Definition osabi.h:50
@ GDB_OSABI_UNKNOWN
Definition osabi.h:26
int default_register_reggroup_p(struct gdbarch *gdbarch, int regnum, const struct reggroup *group)
Definition reggroups.c:147
const reggroup * reggroup_find(struct gdbarch *gdbarch, const char *name)
Definition reggroups.c:177
const reggroup *const save_reggroup
Definition reggroups.c:256
void reggroup_add(struct gdbarch *gdbarch, const reggroup *group)
Definition reggroups.c:124
const reggroup *const restore_reggroup
Definition reggroups.c:257
const reggroup * reggroup_gdbarch_new(struct gdbarch *gdbarch, const char *name, enum reggroup_type type)
Definition reggroups.c:42
@ USER_REGGROUP
Definition reggroups.h:32
struct type * builtin_long_long
Definition gdbtypes.h:2096
struct type * builtin_int0
Definition gdbtypes.h:2112
struct type * builtin_uint16
Definition gdbtypes.h:2116
struct type * builtin_double
Definition gdbtypes.h:2090
struct type * builtin_int8
Definition gdbtypes.h:2113
struct type * builtin_func_ptr
Definition gdbtypes.h:2146
struct type * builtin_uint128
Definition gdbtypes.h:2124
struct type * builtin_long
Definition gdbtypes.h:2081
struct type * builtin_data_ptr
Definition gdbtypes.h:2135
struct type * builtin_bool
Definition gdbtypes.h:2095
struct type * builtin_long_double
Definition gdbtypes.h:2091
struct type * builtin_uint32
Definition gdbtypes.h:2120
struct type * builtin_uint64
Definition gdbtypes.h:2122
struct type * builtin_short
Definition gdbtypes.h:2079
struct type * builtin_int64
Definition gdbtypes.h:2121
struct type * builtin_char
Definition gdbtypes.h:2078
struct type * builtin_int
Definition gdbtypes.h:2080
struct type * builtin_int32
Definition gdbtypes.h:2119
struct type * builtin_uint8
Definition gdbtypes.h:2114
struct type * builtin_int128
Definition gdbtypes.h:2123
struct type * builtin_int16
Definition gdbtypes.h:2115
struct type * builtin_float
Definition gdbtypes.h:2089
void set_loc_bitpos(LONGEST bitpos)
Definition gdbtypes.h:617
void set_bitsize(unsigned int bitsize)
Definition gdbtypes.h:582
void set_loc_enumval(LONGEST enumval)
Definition gdbtypes.h:629
std::string key
std::string value
property(const std::string &key_, const std::string &value_)
const char * name() const
Definition reggroups.h:51
xml_test_tdesc(const char *name, std::unique_ptr< const target_desc > &&tdesc)
std::unique_ptr< const target_desc > tdesc
const struct target_desc * tdesc
Definition inferior.h:364
std::string filename
Definition inferior.h:370
target_desc(const target_desc &)=delete
bool operator==(const target_desc &other) const
enum gdb_osabi osabi
void accept(tdesc_element_visitor &v) const override
std::vector< tdesc_feature_up > features
std::vector< property > properties
std::vector< tdesc_compatible_info_up > compatible
virtual ~target_desc()=default
bool operator!=(const target_desc &other) const
void operator=(const target_desc &)=delete
const struct bfd_arch_info * arch
void operator()(struct tdesc_arch_data *data) const
std::vector< tdesc_arch_reg > arch_regs
gdbarch_register_reggroup_p_ftype * pseudo_register_reggroup_p
gdbarch_register_name_ftype * pseudo_register_name
gdbarch_register_type_ftype * pseudo_register_type
tdesc_arch_reg(tdesc_reg *reg_, struct type *type_)
struct tdesc_reg * reg
bool is_vector() const
Definition gdbtypes.h:1186
struct field * fields() const
Definition gdbtypes.h:1006
const char * name() const
Definition gdbtypes.h:968
Definition value.h:130
tdesc_arch_data_up tdesc_data_alloc(void)
const struct tdesc_feature * tdesc_find_feature(const struct target_desc *target_desc, const char *name)
const char * tdesc_osabi_name(const struct target_desc *target_desc)
void tdesc_add_compatible(struct target_desc *target_desc, const struct bfd_arch_info *compatible)
void set_tdesc_architecture(struct target_desc *target_desc, const char *name)
void target_find_description(void)
static struct cmd_list_element * tdesc_show_cmdlist
void set_tdesc_osabi(struct target_desc *target_desc, const char *name)
static struct tdesc_arch_reg * tdesc_find_arch_register(struct gdbarch *gdbarch, int regno)
int tdesc_numbered_register(const struct tdesc_feature *feature, struct tdesc_arch_data *data, int regno, const char *name)
static const registry< gdbarch >::key< tdesc_arch_data > tdesc_data
static std::string tdesc_filename_cmd_string
void target_clear_description(void)
static struct cmd_list_element * tdesc_set_cmdlist
const std::vector< tdesc_compatible_info_up > & tdesc_compatible_info_list(const target_desc *target_desc)
static void unset_tdesc_filename_cmd(const char *args, int from_tty)
void tdesc_use_registers(struct gdbarch *gdbarch, const struct target_desc *target_desc, tdesc_arch_data_up &&early_data, tdesc_unknown_register_ftype unk_reg_cb)
void set_tdesc_pseudo_register_name(struct gdbarch *gdbarch, gdbarch_register_name_ftype *pseudo_name)
static void maint_print_c_tdesc_cmd(const char *args, int from_tty)
static const gdb::option::option_def maint_print_c_tdesc_opt_defs[]
static struct tdesc_reg * tdesc_find_register_early(const struct tdesc_feature *feature, const char *name)
int tdesc_has_registers(const struct target_desc *target_desc)
static struct cmd_list_element * tdesc_unset_cmdlist
static bool maintenance_check_tdesc_xml_convert(const target_desc *tdesc, const char *name)
static tdesc_arch_data * get_arch_data(struct gdbarch *gdbarch)
const char * tdesc_compatible_info_arch_name(const tdesc_compatible_info_up &compatible)
const char * tdesc_feature_name(const struct tdesc_feature *feature)
void set_tdesc_pseudo_register_type(struct gdbarch *gdbarch, gdbarch_register_type_ftype *pseudo_type)
static struct tdesc_reg * tdesc_find_register(struct gdbarch *gdbarch, int regno)
struct type * tdesc_register_type(struct gdbarch *gdbarch, int regno)
int tdesc_numbered_register_choices(const struct tdesc_feature *feature, struct tdesc_arch_data *data, int regno, const char *const names[])
static gdb::option::option_def_group make_maint_print_c_tdesc_options_def_group(maint_print_c_tdesc_options *opts)
static void maint_print_c_tdesc_cmd_completer(struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *word)
int tdesc_register_bitsize(const struct tdesc_feature *feature, const char *name)
const struct bfd_arch_info * tdesc_architecture(const struct target_desc *target_desc)
static void show_tdesc_filename_cmd(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
struct tdesc_feature * tdesc_create_feature(struct target_desc *tdesc, const char *name)
target_desc_up allocate_target_description(void)
const struct target_desc * target_current_description(void)
const char * tdesc_register_name(struct gdbarch *gdbarch, int regno)
static void set_tdesc_filename_cmd(const char *args, int from_tty, struct cmd_list_element *c)
const char * tdesc_architecture_name(const struct target_desc *target_desc)
int tdesc_unnumbered_register(const struct tdesc_feature *feature, const char *name)
void _initialize_target_descriptions()
static void maint_print_xml_tdesc_cmd(const char *args, int from_tty)
static int tdesc_register_reggroup_p(struct gdbarch *gdbarch, int regno, const struct reggroup *reggroup)
enum gdb_osabi tdesc_osabi(const struct target_desc *target_desc)
static int tdesc_remote_register_number(struct gdbarch *gdbarch, int regno)
static type * make_gdb_type(struct gdbarch *gdbarch, struct tdesc_type *ttype)
bool tdesc_found_register(struct tdesc_arch_data *data, int regno)
int tdesc_compatible_p(const struct target_desc *target_desc, const struct bfd_arch_info *arch)
int tdesc_register_in_reggroup_p(struct gdbarch *gdbarch, int regno, const struct reggroup *reggroup)
void set_tdesc_pseudo_register_reggroup_p(struct gdbarch *gdbarch, gdbarch_register_reggroup_p_ftype *pseudo_reggroup_p)
const char * tdesc_get_features_xml(const target_desc *tdesc)
struct type * tdesc_find_type(struct gdbarch *gdbarch, const char *id)
const char * tdesc_property(const struct target_desc *target_desc, const char *key)
static void maintenance_check_xml_descriptions(const char *dir, int from_tty)
void set_tdesc_property(struct target_desc *target_desc, const char *key, const char *value)
std::unique_ptr< tdesc_arch_data, tdesc_arch_data_deleter > tdesc_arch_data_up
int(* tdesc_unknown_register_ftype)(struct gdbarch *gdbarch, tdesc_feature *feature, const char *reg_name, int possible_regnum)
const struct target_desc * target_read_description(struct target_ops *target)
Definition target.c:2773
void gdb_vprintf(struct ui_file *stream, const char *format, va_list args)
Definition utils.c:1874
void gdb_printf(struct ui_file *stream, const char *format,...)
Definition utils.c:1886
void gdb_puts(const char *linebuffer, struct ui_file *stream)
Definition utils.c:1809
const struct target_desc * string_read_description_xml(const char *xml)
Definition xml-tdesc.c:763
const struct target_desc * target_read_description_xml(struct target_ops *ops)
Definition xml-tdesc.c:705
const struct target_desc * file_read_description_xml(const char *filename)
Definition xml-tdesc.c:664