1 /* Target description support for GDB.
3 Copyright (C) 2006-2015 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"
40 typedef struct property
45 DEF_VEC_O(property_s);
47 /* An individual register from a target description. */
49 typedef struct tdesc_reg
51 /* The name of this register. In standard features, it may be
52 recognized by the architecture support code, or it may be purely
56 /* The register number used by this target to refer to this
57 register. This is used for remote p/P packets and to determine
58 the ordering of registers in the remote g/G packets. */
61 /* If this flag is set, GDB should save and restore this register
62 around calls to an inferior function. */
65 /* The name of the register group containing this register, or NULL
66 if the group should be automatically determined from the
67 register's type. If this is "general", "float", or "vector", the
68 corresponding "info" command should display this register's
69 value. It can be an arbitrary string, but should be limited to
70 alphanumeric characters and internal hyphens. Currently other
71 strings are ignored (treated as NULL). */
74 /* The size of the register, in bits. */
77 /* The type of the register. This string corresponds to either
78 a named type from the target description or a predefined
82 /* The target-described type corresponding to TYPE, if found. */
83 struct tdesc_type *tdesc_type;
85 DEF_VEC_P(tdesc_reg_p);
87 /* A named type from a target description. */
89 typedef struct tdesc_type_field
92 struct tdesc_type *type;
95 DEF_VEC_O(tdesc_type_field);
97 typedef struct tdesc_type_flag
102 DEF_VEC_O(tdesc_type_flag);
106 /* Predefined types. */
119 TDESC_TYPE_IEEE_SINGLE,
120 TDESC_TYPE_IEEE_DOUBLE,
121 TDESC_TYPE_ARM_FPA_EXT,
124 /* Types defined by a target feature. */
131 typedef struct tdesc_type
133 /* The name of this type. */
136 /* Identify the kind of this type. */
137 enum tdesc_type_kind kind;
139 /* Kind-specific data. */
145 struct tdesc_type *type;
149 /* Struct or union type. */
152 VEC(tdesc_type_field) *fields;
159 VEC(tdesc_type_flag) *flags;
164 DEF_VEC_P(tdesc_type_p);
166 /* A feature from a target description. Each feature is a collection
167 of other elements, e.g. registers and types. */
169 typedef struct tdesc_feature
171 /* The name of this feature. It may be recognized by the architecture
175 /* The registers associated with this feature. */
176 VEC(tdesc_reg_p) *registers;
178 /* The types associated with this feature. */
179 VEC(tdesc_type_p) *types;
181 DEF_VEC_P(tdesc_feature_p);
183 /* A compatible architecture from a target description. */
184 typedef const struct bfd_arch_info *arch_p;
187 /* A target description. */
191 /* The architecture reported by the target, if any. */
192 const struct bfd_arch_info *arch;
194 /* The osabi reported by the target, if any; GDB_OSABI_UNKNOWN
196 enum gdb_osabi osabi;
198 /* The list of compatible architectures reported by the target. */
199 VEC(arch_p) *compatible;
201 /* Any architecture-specific properties specified by the target. */
202 VEC(property_s) *properties;
204 /* The features associated with this target. */
205 VEC(tdesc_feature_p) *features;
208 /* Per-architecture data associated with a target description. The
209 target description may be shared by multiple architectures, but
210 this data is private to one gdbarch. */
212 typedef struct tdesc_arch_reg
214 struct tdesc_reg *reg;
217 DEF_VEC_O(tdesc_arch_reg);
219 struct tdesc_arch_data
221 /* A list of register/type pairs, indexed by GDB's internal register number.
222 During initialization of the gdbarch this list is used to store
223 registers which the architecture assigns a fixed register number.
224 Registers which are NULL in this array, or off the end, are
225 treated as zero-sized and nameless (i.e. placeholders in the
227 VEC(tdesc_arch_reg) *arch_regs;
229 /* Functions which report the register name, type, and reggroups for
231 gdbarch_register_name_ftype *pseudo_register_name;
232 gdbarch_register_type_ftype *pseudo_register_type;
233 gdbarch_register_reggroup_p_ftype *pseudo_register_reggroup_p;
236 /* Info about an inferior's target description. There's one of these
237 for each inferior. */
239 struct target_desc_info
241 /* A flag indicating that a description has already been fetched
242 from the target, so it should not be queried again. */
246 /* The description fetched from the target, or NULL if the target
247 did not supply any description. Only valid when
248 target_desc_fetched is set. Only the description initialization
249 code should access this; normally, the description should be
250 accessed through the gdbarch object. */
252 const struct target_desc *tdesc;
254 /* The filename to read a target description from, as set by "set
255 tdesc filename ..." */
260 /* Get the inferior INF's target description info, allocating one on
261 the stop if necessary. */
263 static struct target_desc_info *
264 get_tdesc_info (struct inferior *inf)
266 if (inf->tdesc_info == NULL)
267 inf->tdesc_info = XCNEW (struct target_desc_info);
268 return inf->tdesc_info;
271 /* A handle for architecture-specific data associated with the
272 target description (see struct tdesc_arch_data). */
274 static struct gdbarch_data *tdesc_data;
276 /* See target-descriptions.h. */
279 target_desc_info_from_user_p (struct target_desc_info *info)
281 return info != NULL && info->filename != NULL;
284 /* See target-descriptions.h. */
287 copy_inferior_target_desc_info (struct inferior *destinf, struct inferior *srcinf)
289 struct target_desc_info *src = get_tdesc_info (srcinf);
290 struct target_desc_info *dest = get_tdesc_info (destinf);
292 dest->fetched = src->fetched;
293 dest->tdesc = src->tdesc;
294 dest->filename = src->filename != NULL ? xstrdup (src->filename) : NULL;
297 /* See target-descriptions.h. */
300 target_desc_info_free (struct target_desc_info *tdesc_info)
302 if (tdesc_info != NULL)
304 xfree (tdesc_info->filename);
309 /* Convenience helper macros. */
311 #define target_desc_fetched \
312 get_tdesc_info (current_inferior ())->fetched
313 #define current_target_desc \
314 get_tdesc_info (current_inferior ())->tdesc
315 #define target_description_filename \
316 get_tdesc_info (current_inferior ())->filename
318 /* The string manipulated by the "set tdesc filename ..." command. */
320 static char *tdesc_filename_cmd_string;
322 /* Fetch the current target's description, and switch the current
323 architecture to one which incorporates that description. */
326 target_find_description (void)
328 /* If we've already fetched a description from the target, don't do
329 it again. This allows a target to fetch the description early,
330 during its to_open or to_create_inferior, if it needs extra
331 information about the target to initialize. */
332 if (target_desc_fetched)
335 /* The current architecture should not have any target description
336 specified. It should have been cleared, e.g. when we
337 disconnected from the previous target. */
338 gdb_assert (gdbarch_target_desc (target_gdbarch ()) == NULL);
340 /* First try to fetch an XML description from the user-specified
342 current_target_desc = NULL;
343 if (target_description_filename != NULL
344 && *target_description_filename != '\0')
346 = file_read_description_xml (target_description_filename);
348 /* Next try to read the description from the current target using
350 if (current_target_desc == NULL)
351 current_target_desc = target_read_description_xml (¤t_target);
353 /* If that failed try a target-specific hook. */
354 if (current_target_desc == NULL)
355 current_target_desc = target_read_description (¤t_target);
357 /* If a non-NULL description was returned, then update the current
359 if (current_target_desc)
361 struct gdbarch_info info;
363 gdbarch_info_init (&info);
364 info.target_desc = current_target_desc;
365 if (!gdbarch_update_p (info))
366 warning (_("Architecture rejected target-supplied description"));
369 struct tdesc_arch_data *data;
371 data = ((struct tdesc_arch_data *)
372 gdbarch_data (target_gdbarch (), tdesc_data));
373 if (tdesc_has_registers (current_target_desc)
374 && data->arch_regs == NULL)
375 warning (_("Target-supplied registers are not supported "
376 "by the current architecture"));
380 /* Now that we know this description is usable, record that we
382 target_desc_fetched = 1;
385 /* Discard any description fetched from the current target, and switch
386 the current architecture to one with no target description. */
389 target_clear_description (void)
391 struct gdbarch_info info;
393 if (!target_desc_fetched)
396 target_desc_fetched = 0;
397 current_target_desc = NULL;
399 gdbarch_info_init (&info);
400 if (!gdbarch_update_p (info))
401 internal_error (__FILE__, __LINE__,
402 _("Could not remove target-supplied description"));
405 /* Return the global current target description. This should only be
406 used by gdbarch initialization code; most access should be through
407 an existing gdbarch. */
409 const struct target_desc *
410 target_current_description (void)
412 if (target_desc_fetched)
413 return current_target_desc;
418 /* Return non-zero if this target description is compatible
419 with the given BFD architecture. */
422 tdesc_compatible_p (const struct target_desc *target_desc,
423 const struct bfd_arch_info *arch)
425 const struct bfd_arch_info *compat;
428 for (ix = 0; VEC_iterate (arch_p, target_desc->compatible, ix, compat);
432 || arch->compatible (arch, compat)
433 || compat->compatible (compat, arch))
441 /* Direct accessors for target descriptions. */
443 /* Return the string value of a property named KEY, or NULL if the
444 property was not specified. */
447 tdesc_property (const struct target_desc *target_desc, const char *key)
449 struct property *prop;
452 for (ix = 0; VEC_iterate (property_s, target_desc->properties, ix, prop);
454 if (strcmp (prop->key, key) == 0)
460 /* Return the BFD architecture associated with this target
461 description, or NULL if no architecture was specified. */
463 const struct bfd_arch_info *
464 tdesc_architecture (const struct target_desc *target_desc)
466 return target_desc->arch;
469 /* Return the OSABI associated with this target description, or
470 GDB_OSABI_UNKNOWN if no osabi was specified. */
473 tdesc_osabi (const struct target_desc *target_desc)
475 return target_desc->osabi;
480 /* Return 1 if this target description includes any registers. */
483 tdesc_has_registers (const struct target_desc *target_desc)
486 struct tdesc_feature *feature;
488 if (target_desc == NULL)
492 VEC_iterate (tdesc_feature_p, target_desc->features, ix, feature);
494 if (! VEC_empty (tdesc_reg_p, feature->registers))
500 /* Return the feature with the given name, if present, or NULL if
501 the named feature is not found. */
503 const struct tdesc_feature *
504 tdesc_find_feature (const struct target_desc *target_desc,
508 struct tdesc_feature *feature;
511 VEC_iterate (tdesc_feature_p, target_desc->features, ix, feature);
513 if (strcmp (feature->name, name) == 0)
519 /* Return the name of FEATURE. */
522 tdesc_feature_name (const struct tdesc_feature *feature)
524 return feature->name;
527 /* Predefined types. */
528 static struct tdesc_type tdesc_predefined_types[] =
530 { "int8", TDESC_TYPE_INT8 },
531 { "int16", TDESC_TYPE_INT16 },
532 { "int32", TDESC_TYPE_INT32 },
533 { "int64", TDESC_TYPE_INT64 },
534 { "int128", TDESC_TYPE_INT128 },
535 { "uint8", TDESC_TYPE_UINT8 },
536 { "uint16", TDESC_TYPE_UINT16 },
537 { "uint32", TDESC_TYPE_UINT32 },
538 { "uint64", TDESC_TYPE_UINT64 },
539 { "uint128", TDESC_TYPE_UINT128 },
540 { "code_ptr", TDESC_TYPE_CODE_PTR },
541 { "data_ptr", TDESC_TYPE_DATA_PTR },
542 { "ieee_single", TDESC_TYPE_IEEE_SINGLE },
543 { "ieee_double", TDESC_TYPE_IEEE_DOUBLE },
544 { "arm_fpa_ext", TDESC_TYPE_ARM_FPA_EXT },
545 { "i387_ext", TDESC_TYPE_I387_EXT }
548 /* Return the type associated with ID in the context of FEATURE, or
552 tdesc_named_type (const struct tdesc_feature *feature, const char *id)
555 struct tdesc_type *type;
557 /* First try target-defined types. */
558 for (ix = 0; VEC_iterate (tdesc_type_p, feature->types, ix, type); ix++)
559 if (strcmp (type->name, id) == 0)
562 /* Next try the predefined types. */
563 for (ix = 0; ix < ARRAY_SIZE (tdesc_predefined_types); ix++)
564 if (strcmp (tdesc_predefined_types[ix].name, id) == 0)
565 return &tdesc_predefined_types[ix];
570 /* Lookup type associated with ID. */
573 tdesc_find_type (struct gdbarch *gdbarch, const char *id)
575 struct tdesc_arch_reg *reg;
576 struct tdesc_arch_data *data;
579 data = (struct tdesc_arch_data *) gdbarch_data (gdbarch, tdesc_data);
580 num_regs = VEC_length (tdesc_arch_reg, data->arch_regs);
581 for (i = 0; i < num_regs; i++)
583 reg = VEC_index (tdesc_arch_reg, data->arch_regs, i);
585 && reg->reg->tdesc_type
587 && strcmp (id, reg->reg->tdesc_type->name) == 0)
594 /* Construct, if necessary, and return the GDB type implementing target
595 type TDESC_TYPE for architecture GDBARCH. */
598 tdesc_gdb_type (struct gdbarch *gdbarch, struct tdesc_type *tdesc_type)
602 switch (tdesc_type->kind)
604 /* Predefined types. */
605 case TDESC_TYPE_INT8:
606 return builtin_type (gdbarch)->builtin_int8;
608 case TDESC_TYPE_INT16:
609 return builtin_type (gdbarch)->builtin_int16;
611 case TDESC_TYPE_INT32:
612 return builtin_type (gdbarch)->builtin_int32;
614 case TDESC_TYPE_INT64:
615 return builtin_type (gdbarch)->builtin_int64;
617 case TDESC_TYPE_INT128:
618 return builtin_type (gdbarch)->builtin_int128;
620 case TDESC_TYPE_UINT8:
621 return builtin_type (gdbarch)->builtin_uint8;
623 case TDESC_TYPE_UINT16:
624 return builtin_type (gdbarch)->builtin_uint16;
626 case TDESC_TYPE_UINT32:
627 return builtin_type (gdbarch)->builtin_uint32;
629 case TDESC_TYPE_UINT64:
630 return builtin_type (gdbarch)->builtin_uint64;
632 case TDESC_TYPE_UINT128:
633 return builtin_type (gdbarch)->builtin_uint128;
635 case TDESC_TYPE_CODE_PTR:
636 return builtin_type (gdbarch)->builtin_func_ptr;
638 case TDESC_TYPE_DATA_PTR:
639 return builtin_type (gdbarch)->builtin_data_ptr;
645 type = tdesc_find_type (gdbarch, tdesc_type->name);
649 switch (tdesc_type->kind)
651 case TDESC_TYPE_IEEE_SINGLE:
652 return arch_float_type (gdbarch, -1, "builtin_type_ieee_single",
653 floatformats_ieee_single);
655 case TDESC_TYPE_IEEE_DOUBLE:
656 return arch_float_type (gdbarch, -1, "builtin_type_ieee_double",
657 floatformats_ieee_double);
659 case TDESC_TYPE_ARM_FPA_EXT:
660 return arch_float_type (gdbarch, -1, "builtin_type_arm_ext",
661 floatformats_arm_ext);
663 case TDESC_TYPE_I387_EXT:
664 return arch_float_type (gdbarch, -1, "builtin_type_i387_ext",
665 floatformats_i387_ext);
667 /* Types defined by a target feature. */
668 case TDESC_TYPE_VECTOR:
670 struct type *type, *field_type;
672 field_type = tdesc_gdb_type (gdbarch, tdesc_type->u.v.type);
673 type = init_vector_type (field_type, tdesc_type->u.v.count);
674 TYPE_NAME (type) = xstrdup (tdesc_type->name);
679 case TDESC_TYPE_STRUCT:
681 struct type *type, *field_type;
682 struct tdesc_type_field *f;
685 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
686 TYPE_NAME (type) = xstrdup (tdesc_type->name);
687 TYPE_TAG_NAME (type) = TYPE_NAME (type);
690 VEC_iterate (tdesc_type_field, tdesc_type->u.u.fields, ix, f);
697 struct type *field_type;
698 int bitsize, total_size;
700 /* This invariant should be preserved while creating
702 gdb_assert (tdesc_type->u.u.size != 0);
703 if (tdesc_type->u.u.size > 4)
704 field_type = builtin_type (gdbarch)->builtin_uint64;
706 field_type = builtin_type (gdbarch)->builtin_uint32;
708 fld = append_composite_type_field_raw (type, xstrdup (f->name),
711 /* For little-endian, BITPOS counts from the LSB of
712 the structure and marks the LSB of the field. For
713 big-endian, BITPOS counts from the MSB of the
714 structure and marks the MSB of the field. Either
715 way, it is the number of bits to the "left" of the
716 field. To calculate this in big-endian, we need
717 the total size of the structure. */
718 bitsize = f->end - f->start + 1;
719 total_size = tdesc_type->u.u.size * TARGET_CHAR_BIT;
720 if (gdbarch_bits_big_endian (gdbarch))
721 SET_FIELD_BITPOS (fld[0], total_size - f->start - bitsize);
723 SET_FIELD_BITPOS (fld[0], f->start);
724 FIELD_BITSIZE (fld[0]) = bitsize;
728 field_type = tdesc_gdb_type (gdbarch, f->type);
729 append_composite_type_field (type, xstrdup (f->name),
734 if (tdesc_type->u.u.size != 0)
735 TYPE_LENGTH (type) = tdesc_type->u.u.size;
739 case TDESC_TYPE_UNION:
741 struct type *type, *field_type;
742 struct tdesc_type_field *f;
745 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION);
746 TYPE_NAME (type) = xstrdup (tdesc_type->name);
749 VEC_iterate (tdesc_type_field, tdesc_type->u.u.fields, ix, f);
752 field_type = tdesc_gdb_type (gdbarch, f->type);
753 append_composite_type_field (type, xstrdup (f->name), field_type);
755 /* If any of the children of a union are vectors, flag the
756 union as a vector also. This allows e.g. a union of two
757 vector types to show up automatically in "info vector". */
758 if (TYPE_VECTOR (field_type))
759 TYPE_VECTOR (type) = 1;
764 case TDESC_TYPE_FLAGS:
766 struct tdesc_type_flag *f;
769 type = arch_flags_type (gdbarch, tdesc_type->name,
770 tdesc_type->u.f.size);
772 VEC_iterate (tdesc_type_flag, tdesc_type->u.f.flags, ix, f);
774 /* Note that contrary to the function name, this call will
775 just set the properties of an already-allocated
777 append_flags_type_flag (type, f->start,
778 *f->name ? f->name : NULL);
784 internal_error (__FILE__, __LINE__,
785 "Type \"%s\" has an unknown kind %d",
786 tdesc_type->name, tdesc_type->kind);
790 /* Support for registers from target descriptions. */
792 /* Construct the per-gdbarch data. */
795 tdesc_data_init (struct obstack *obstack)
797 struct tdesc_arch_data *data;
799 data = OBSTACK_ZALLOC (obstack, struct tdesc_arch_data);
803 /* Similar, but for the temporary copy used during architecture
806 struct tdesc_arch_data *
807 tdesc_data_alloc (void)
809 return XCNEW (struct tdesc_arch_data);
812 /* Free something allocated by tdesc_data_alloc, if it is not going
813 to be used (for instance if it was unsuitable for the
817 tdesc_data_cleanup (void *data_untyped)
819 struct tdesc_arch_data *data = (struct tdesc_arch_data *) data_untyped;
821 VEC_free (tdesc_arch_reg, data->arch_regs);
825 /* Search FEATURE for a register named NAME. */
827 static struct tdesc_reg *
828 tdesc_find_register_early (const struct tdesc_feature *feature,
832 struct tdesc_reg *reg;
835 VEC_iterate (tdesc_reg_p, feature->registers, ixr, reg);
837 if (strcasecmp (reg->name, name) == 0)
843 /* Search FEATURE for a register named NAME. Assign REGNO to it. */
846 tdesc_numbered_register (const struct tdesc_feature *feature,
847 struct tdesc_arch_data *data,
848 int regno, const char *name)
850 struct tdesc_arch_reg arch_reg = { 0 };
851 struct tdesc_reg *reg = tdesc_find_register_early (feature, name);
856 /* Make sure the vector includes a REGNO'th element. */
857 while (regno >= VEC_length (tdesc_arch_reg, data->arch_regs))
858 VEC_safe_push (tdesc_arch_reg, data->arch_regs, &arch_reg);
861 VEC_replace (tdesc_arch_reg, data->arch_regs, regno, &arch_reg);
865 /* Search FEATURE for a register named NAME, but do not assign a fixed
866 register number to it. */
869 tdesc_unnumbered_register (const struct tdesc_feature *feature,
872 struct tdesc_reg *reg = tdesc_find_register_early (feature, name);
880 /* Search FEATURE for a register whose name is in NAMES and assign
884 tdesc_numbered_register_choices (const struct tdesc_feature *feature,
885 struct tdesc_arch_data *data,
886 int regno, const char *const names[])
890 for (i = 0; names[i] != NULL; i++)
891 if (tdesc_numbered_register (feature, data, regno, names[i]))
897 /* Search FEATURE for a register named NAME, and return its size in
898 bits. The register must exist. */
901 tdesc_register_size (const struct tdesc_feature *feature,
904 struct tdesc_reg *reg = tdesc_find_register_early (feature, name);
906 gdb_assert (reg != NULL);
910 /* Look up a register by its GDB internal register number. */
912 static struct tdesc_arch_reg *
913 tdesc_find_arch_register (struct gdbarch *gdbarch, int regno)
915 struct tdesc_arch_data *data;
917 data = (struct tdesc_arch_data *) gdbarch_data (gdbarch, tdesc_data);
918 if (regno < VEC_length (tdesc_arch_reg, data->arch_regs))
919 return VEC_index (tdesc_arch_reg, data->arch_regs, regno);
924 static struct tdesc_reg *
925 tdesc_find_register (struct gdbarch *gdbarch, int regno)
927 struct tdesc_arch_reg *reg = tdesc_find_arch_register (gdbarch, regno);
929 return reg? reg->reg : NULL;
932 /* Return the name of register REGNO, from the target description or
933 from an architecture-provided pseudo_register_name method. */
936 tdesc_register_name (struct gdbarch *gdbarch, int regno)
938 struct tdesc_reg *reg = tdesc_find_register (gdbarch, regno);
939 int num_regs = gdbarch_num_regs (gdbarch);
940 int num_pseudo_regs = gdbarch_num_pseudo_regs (gdbarch);
945 if (regno >= num_regs && regno < num_regs + num_pseudo_regs)
947 struct tdesc_arch_data *data
948 = (struct tdesc_arch_data *) gdbarch_data (gdbarch, tdesc_data);
950 gdb_assert (data->pseudo_register_name != NULL);
951 return data->pseudo_register_name (gdbarch, regno);
958 tdesc_register_type (struct gdbarch *gdbarch, int regno)
960 struct tdesc_arch_reg *arch_reg = tdesc_find_arch_register (gdbarch, regno);
961 struct tdesc_reg *reg = arch_reg? arch_reg->reg : NULL;
962 int num_regs = gdbarch_num_regs (gdbarch);
963 int num_pseudo_regs = gdbarch_num_pseudo_regs (gdbarch);
965 if (reg == NULL && regno >= num_regs && regno < num_regs + num_pseudo_regs)
967 struct tdesc_arch_data *data
968 = (struct tdesc_arch_data *) gdbarch_data (gdbarch, tdesc_data);
970 gdb_assert (data->pseudo_register_type != NULL);
971 return data->pseudo_register_type (gdbarch, regno);
975 /* Return "int0_t", since "void" has a misleading size of one. */
976 return builtin_type (gdbarch)->builtin_int0;
978 if (arch_reg->type == NULL)
980 /* First check for a predefined or target defined type. */
982 arch_reg->type = tdesc_gdb_type (gdbarch, reg->tdesc_type);
984 /* Next try size-sensitive type shortcuts. */
985 else if (strcmp (reg->type, "float") == 0)
987 if (reg->bitsize == gdbarch_float_bit (gdbarch))
988 arch_reg->type = builtin_type (gdbarch)->builtin_float;
989 else if (reg->bitsize == gdbarch_double_bit (gdbarch))
990 arch_reg->type = builtin_type (gdbarch)->builtin_double;
991 else if (reg->bitsize == gdbarch_long_double_bit (gdbarch))
992 arch_reg->type = builtin_type (gdbarch)->builtin_long_double;
995 warning (_("Register \"%s\" has an unsupported size (%d bits)"),
996 reg->name, reg->bitsize);
997 arch_reg->type = builtin_type (gdbarch)->builtin_double;
1000 else if (strcmp (reg->type, "int") == 0)
1002 if (reg->bitsize == gdbarch_long_bit (gdbarch))
1003 arch_reg->type = builtin_type (gdbarch)->builtin_long;
1004 else if (reg->bitsize == TARGET_CHAR_BIT)
1005 arch_reg->type = builtin_type (gdbarch)->builtin_char;
1006 else if (reg->bitsize == gdbarch_short_bit (gdbarch))
1007 arch_reg->type = builtin_type (gdbarch)->builtin_short;
1008 else if (reg->bitsize == gdbarch_int_bit (gdbarch))
1009 arch_reg->type = builtin_type (gdbarch)->builtin_int;
1010 else if (reg->bitsize == gdbarch_long_long_bit (gdbarch))
1011 arch_reg->type = builtin_type (gdbarch)->builtin_long_long;
1012 else if (reg->bitsize == gdbarch_ptr_bit (gdbarch))
1013 /* A bit desperate by this point... */
1014 arch_reg->type = builtin_type (gdbarch)->builtin_data_ptr;
1017 warning (_("Register \"%s\" has an unsupported size (%d bits)"),
1018 reg->name, reg->bitsize);
1019 arch_reg->type = builtin_type (gdbarch)->builtin_long;
1023 if (arch_reg->type == NULL)
1024 internal_error (__FILE__, __LINE__,
1025 "Register \"%s\" has an unknown type \"%s\"",
1026 reg->name, reg->type);
1029 return arch_reg->type;
1033 tdesc_remote_register_number (struct gdbarch *gdbarch, int regno)
1035 struct tdesc_reg *reg = tdesc_find_register (gdbarch, regno);
1038 return reg->target_regnum;
1043 /* Check whether REGNUM is a member of REGGROUP. Registers from the
1044 target description may be classified as general, float, or vector.
1045 Unlike a gdbarch register_reggroup_p method, this function will
1046 return -1 if it does not know; the caller should handle registers
1047 with no specified group.
1049 Arbitrary strings (other than "general", "float", and "vector")
1050 from the description are not used; they cause the register to be
1051 displayed in "info all-registers" but excluded from "info
1052 registers" et al. The names of containing features are also not
1053 used. This might be extended to display registers in some more
1056 The save-restore flag is also implemented here. */
1059 tdesc_register_in_reggroup_p (struct gdbarch *gdbarch, int regno,
1060 struct reggroup *reggroup)
1062 struct tdesc_reg *reg = tdesc_find_register (gdbarch, regno);
1064 if (reg != NULL && reg->group != NULL)
1066 int general_p = 0, float_p = 0, vector_p = 0;
1068 if (strcmp (reg->group, "general") == 0)
1070 else if (strcmp (reg->group, "float") == 0)
1072 else if (strcmp (reg->group, "vector") == 0)
1075 if (reggroup == float_reggroup)
1078 if (reggroup == vector_reggroup)
1081 if (reggroup == general_reggroup)
1086 && (reggroup == save_reggroup || reggroup == restore_reggroup))
1087 return reg->save_restore;
1092 /* Check whether REGNUM is a member of REGGROUP. Registers with no
1093 group specified go to the default reggroup function and are handled
1097 tdesc_register_reggroup_p (struct gdbarch *gdbarch, int regno,
1098 struct reggroup *reggroup)
1100 int num_regs = gdbarch_num_regs (gdbarch);
1101 int num_pseudo_regs = gdbarch_num_pseudo_regs (gdbarch);
1104 if (regno >= num_regs && regno < num_regs + num_pseudo_regs)
1106 struct tdesc_arch_data *data
1107 = (struct tdesc_arch_data *) gdbarch_data (gdbarch, tdesc_data);
1109 if (data->pseudo_register_reggroup_p != NULL)
1110 return data->pseudo_register_reggroup_p (gdbarch, regno, reggroup);
1111 /* Otherwise fall through to the default reggroup_p. */
1114 ret = tdesc_register_in_reggroup_p (gdbarch, regno, reggroup);
1118 return default_register_reggroup_p (gdbarch, regno, reggroup);
1121 /* Record architecture-specific functions to call for pseudo-register
1125 set_tdesc_pseudo_register_name (struct gdbarch *gdbarch,
1126 gdbarch_register_name_ftype *pseudo_name)
1128 struct tdesc_arch_data *data
1129 = (struct tdesc_arch_data *) gdbarch_data (gdbarch, tdesc_data);
1131 data->pseudo_register_name = pseudo_name;
1135 set_tdesc_pseudo_register_type (struct gdbarch *gdbarch,
1136 gdbarch_register_type_ftype *pseudo_type)
1138 struct tdesc_arch_data *data
1139 = (struct tdesc_arch_data *) gdbarch_data (gdbarch, tdesc_data);
1141 data->pseudo_register_type = pseudo_type;
1145 set_tdesc_pseudo_register_reggroup_p
1146 (struct gdbarch *gdbarch,
1147 gdbarch_register_reggroup_p_ftype *pseudo_reggroup_p)
1149 struct tdesc_arch_data *data
1150 = (struct tdesc_arch_data *) gdbarch_data (gdbarch, tdesc_data);
1152 data->pseudo_register_reggroup_p = pseudo_reggroup_p;
1155 /* Update GDBARCH to use the target description for registers. */
1158 tdesc_use_registers (struct gdbarch *gdbarch,
1159 const struct target_desc *target_desc,
1160 struct tdesc_arch_data *early_data)
1162 int num_regs = gdbarch_num_regs (gdbarch);
1164 struct tdesc_feature *feature;
1165 struct tdesc_reg *reg;
1166 struct tdesc_arch_data *data;
1167 struct tdesc_arch_reg *arch_reg, new_arch_reg = { 0 };
1170 /* We can't use the description for registers if it doesn't describe
1171 any. This function should only be called after validating
1172 registers, so the caller should know that registers are
1174 gdb_assert (tdesc_has_registers (target_desc));
1176 data = (struct tdesc_arch_data *) gdbarch_data (gdbarch, tdesc_data);
1177 data->arch_regs = early_data->arch_regs;
1180 /* Build up a set of all registers, so that we can assign register
1181 numbers where needed. The hash table expands as necessary, so
1182 the initial size is arbitrary. */
1183 reg_hash = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
1185 VEC_iterate (tdesc_feature_p, target_desc->features, ixf, feature);
1188 VEC_iterate (tdesc_reg_p, feature->registers, ixr, reg);
1191 void **slot = htab_find_slot (reg_hash, reg, INSERT);
1196 /* Remove any registers which were assigned numbers by the
1199 VEC_iterate (tdesc_arch_reg, data->arch_regs, ixr, arch_reg);
1202 htab_remove_elt (reg_hash, arch_reg->reg);
1204 /* Assign numbers to the remaining registers and add them to the
1205 list of registers. The new numbers are always above gdbarch_num_regs.
1206 Iterate over the features, not the hash table, so that the order
1207 matches that in the target description. */
1209 gdb_assert (VEC_length (tdesc_arch_reg, data->arch_regs) <= num_regs);
1210 while (VEC_length (tdesc_arch_reg, data->arch_regs) < num_regs)
1211 VEC_safe_push (tdesc_arch_reg, data->arch_regs, &new_arch_reg);
1213 VEC_iterate (tdesc_feature_p, target_desc->features, ixf, feature);
1216 VEC_iterate (tdesc_reg_p, feature->registers, ixr, reg);
1218 if (htab_find (reg_hash, reg) != NULL)
1220 new_arch_reg.reg = reg;
1221 VEC_safe_push (tdesc_arch_reg, data->arch_regs, &new_arch_reg);
1225 htab_delete (reg_hash);
1227 /* Update the architecture. */
1228 set_gdbarch_num_regs (gdbarch, num_regs);
1229 set_gdbarch_register_name (gdbarch, tdesc_register_name);
1230 set_gdbarch_register_type (gdbarch, tdesc_register_type);
1231 set_gdbarch_remote_register_number (gdbarch,
1232 tdesc_remote_register_number);
1233 set_gdbarch_register_reggroup_p (gdbarch, tdesc_register_reggroup_p);
1237 /* Methods for constructing a target description. */
1240 tdesc_free_reg (struct tdesc_reg *reg)
1249 tdesc_create_reg (struct tdesc_feature *feature, const char *name,
1250 int regnum, int save_restore, const char *group,
1251 int bitsize, const char *type)
1253 struct tdesc_reg *reg = XCNEW (struct tdesc_reg);
1255 reg->name = xstrdup (name);
1256 reg->target_regnum = regnum;
1257 reg->save_restore = save_restore;
1258 reg->group = group ? xstrdup (group) : NULL;
1259 reg->bitsize = bitsize;
1260 reg->type = type ? xstrdup (type) : xstrdup ("<unknown>");
1262 /* If the register's type is target-defined, look it up now. We may not
1263 have easy access to the containing feature when we want it later. */
1264 reg->tdesc_type = tdesc_named_type (feature, reg->type);
1266 VEC_safe_push (tdesc_reg_p, feature->registers, reg);
1270 tdesc_free_type (struct tdesc_type *type)
1274 case TDESC_TYPE_STRUCT:
1275 case TDESC_TYPE_UNION:
1277 struct tdesc_type_field *f;
1281 VEC_iterate (tdesc_type_field, type->u.u.fields, ix, f);
1285 VEC_free (tdesc_type_field, type->u.u.fields);
1289 case TDESC_TYPE_FLAGS:
1291 struct tdesc_type_flag *f;
1295 VEC_iterate (tdesc_type_flag, type->u.f.flags, ix, f);
1299 VEC_free (tdesc_type_flag, type->u.f.flags);
1312 tdesc_create_vector (struct tdesc_feature *feature, const char *name,
1313 struct tdesc_type *field_type, int count)
1315 struct tdesc_type *type = XCNEW (struct tdesc_type);
1317 type->name = xstrdup (name);
1318 type->kind = TDESC_TYPE_VECTOR;
1319 type->u.v.type = field_type;
1320 type->u.v.count = count;
1322 VEC_safe_push (tdesc_type_p, feature->types, type);
1327 tdesc_create_struct (struct tdesc_feature *feature, const char *name)
1329 struct tdesc_type *type = XCNEW (struct tdesc_type);
1331 type->name = xstrdup (name);
1332 type->kind = TDESC_TYPE_STRUCT;
1334 VEC_safe_push (tdesc_type_p, feature->types, type);
1338 /* Set the total length of TYPE. Structs which contain bitfields may
1339 omit the reserved bits, so the end of the last field may not
1343 tdesc_set_struct_size (struct tdesc_type *type, LONGEST size)
1345 gdb_assert (type->kind == TDESC_TYPE_STRUCT);
1346 type->u.u.size = size;
1350 tdesc_create_union (struct tdesc_feature *feature, const char *name)
1352 struct tdesc_type *type = XCNEW (struct tdesc_type);
1354 type->name = xstrdup (name);
1355 type->kind = TDESC_TYPE_UNION;
1357 VEC_safe_push (tdesc_type_p, feature->types, type);
1362 tdesc_create_flags (struct tdesc_feature *feature, const char *name,
1365 struct tdesc_type *type = XCNEW (struct tdesc_type);
1367 type->name = xstrdup (name);
1368 type->kind = TDESC_TYPE_FLAGS;
1369 type->u.f.size = size;
1371 VEC_safe_push (tdesc_type_p, feature->types, type);
1375 /* Add a new field. Return a temporary pointer to the field, which
1376 is only valid until the next call to tdesc_add_field (the vector
1377 might be reallocated). */
1380 tdesc_add_field (struct tdesc_type *type, const char *field_name,
1381 struct tdesc_type *field_type)
1383 struct tdesc_type_field f = { 0 };
1385 gdb_assert (type->kind == TDESC_TYPE_UNION
1386 || type->kind == TDESC_TYPE_STRUCT);
1388 f.name = xstrdup (field_name);
1389 f.type = field_type;
1391 VEC_safe_push (tdesc_type_field, type->u.u.fields, &f);
1394 /* Add a new bitfield. */
1397 tdesc_add_bitfield (struct tdesc_type *type, const char *field_name,
1400 struct tdesc_type_field f = { 0 };
1402 gdb_assert (type->kind == TDESC_TYPE_STRUCT);
1404 f.name = xstrdup (field_name);
1408 VEC_safe_push (tdesc_type_field, type->u.u.fields, &f);
1412 tdesc_add_flag (struct tdesc_type *type, int start,
1413 const char *flag_name)
1415 struct tdesc_type_flag f = { 0 };
1417 gdb_assert (type->kind == TDESC_TYPE_FLAGS);
1419 f.name = xstrdup (flag_name);
1422 VEC_safe_push (tdesc_type_flag, type->u.f.flags, &f);
1426 tdesc_free_feature (struct tdesc_feature *feature)
1428 struct tdesc_reg *reg;
1429 struct tdesc_type *type;
1432 for (ix = 0; VEC_iterate (tdesc_reg_p, feature->registers, ix, reg); ix++)
1433 tdesc_free_reg (reg);
1434 VEC_free (tdesc_reg_p, feature->registers);
1436 for (ix = 0; VEC_iterate (tdesc_type_p, feature->types, ix, type); ix++)
1437 tdesc_free_type (type);
1438 VEC_free (tdesc_type_p, feature->types);
1440 xfree (feature->name);
1444 struct tdesc_feature *
1445 tdesc_create_feature (struct target_desc *tdesc, const char *name)
1447 struct tdesc_feature *new_feature = XCNEW (struct tdesc_feature);
1449 new_feature->name = xstrdup (name);
1451 VEC_safe_push (tdesc_feature_p, tdesc->features, new_feature);
1455 struct target_desc *
1456 allocate_target_description (void)
1458 return XCNEW (struct target_desc);
1462 free_target_description (void *arg)
1464 struct target_desc *target_desc = (struct target_desc *) arg;
1465 struct tdesc_feature *feature;
1466 struct property *prop;
1470 VEC_iterate (tdesc_feature_p, target_desc->features, ix, feature);
1472 tdesc_free_feature (feature);
1473 VEC_free (tdesc_feature_p, target_desc->features);
1476 VEC_iterate (property_s, target_desc->properties, ix, prop);
1480 xfree (prop->value);
1482 VEC_free (property_s, target_desc->properties);
1484 VEC_free (arch_p, target_desc->compatible);
1486 xfree (target_desc);
1490 make_cleanup_free_target_description (struct target_desc *target_desc)
1492 return make_cleanup (free_target_description, target_desc);
1496 tdesc_add_compatible (struct target_desc *target_desc,
1497 const struct bfd_arch_info *compatible)
1499 const struct bfd_arch_info *compat;
1502 /* If this instance of GDB is compiled without BFD support for the
1503 compatible architecture, simply ignore it -- we would not be able
1504 to handle it anyway. */
1505 if (compatible == NULL)
1508 for (ix = 0; VEC_iterate (arch_p, target_desc->compatible, ix, compat);
1510 if (compat == compatible)
1511 internal_error (__FILE__, __LINE__,
1512 _("Attempted to add duplicate "
1513 "compatible architecture \"%s\""),
1514 compatible->printable_name);
1516 VEC_safe_push (arch_p, target_desc->compatible, compatible);
1520 set_tdesc_property (struct target_desc *target_desc,
1521 const char *key, const char *value)
1523 struct property *prop, new_prop;
1526 gdb_assert (key != NULL && value != NULL);
1528 for (ix = 0; VEC_iterate (property_s, target_desc->properties, ix, prop);
1530 if (strcmp (prop->key, key) == 0)
1531 internal_error (__FILE__, __LINE__,
1532 _("Attempted to add duplicate property \"%s\""), key);
1534 new_prop.key = xstrdup (key);
1535 new_prop.value = xstrdup (value);
1536 VEC_safe_push (property_s, target_desc->properties, &new_prop);
1540 set_tdesc_architecture (struct target_desc *target_desc,
1541 const struct bfd_arch_info *arch)
1543 target_desc->arch = arch;
1547 set_tdesc_osabi (struct target_desc *target_desc, enum gdb_osabi osabi)
1549 target_desc->osabi = osabi;
1553 static struct cmd_list_element *tdesc_set_cmdlist, *tdesc_show_cmdlist;
1554 static struct cmd_list_element *tdesc_unset_cmdlist;
1556 /* Helper functions for the CLI commands. */
1559 set_tdesc_cmd (char *args, int from_tty)
1561 help_list (tdesc_set_cmdlist, "set tdesc ", all_commands, gdb_stdout);
1565 show_tdesc_cmd (char *args, int from_tty)
1567 cmd_show_list (tdesc_show_cmdlist, from_tty, "");
1571 unset_tdesc_cmd (char *args, int from_tty)
1573 help_list (tdesc_unset_cmdlist, "unset tdesc ", all_commands, gdb_stdout);
1577 set_tdesc_filename_cmd (char *args, int from_tty,
1578 struct cmd_list_element *c)
1580 xfree (target_description_filename);
1581 target_description_filename = xstrdup (tdesc_filename_cmd_string);
1583 target_clear_description ();
1584 target_find_description ();
1588 show_tdesc_filename_cmd (struct ui_file *file, int from_tty,
1589 struct cmd_list_element *c,
1592 value = target_description_filename;
1594 if (value != NULL && *value != '\0')
1595 printf_filtered (_("The target description will be read from \"%s\".\n"),
1598 printf_filtered (_("The target description will be "
1599 "read from the target.\n"));
1603 unset_tdesc_filename_cmd (char *args, int from_tty)
1605 xfree (target_description_filename);
1606 target_description_filename = NULL;
1607 target_clear_description ();
1608 target_find_description ();
1612 maint_print_c_tdesc_cmd (char *args, int from_tty)
1614 const struct target_desc *tdesc;
1615 const struct bfd_arch_info *compatible;
1616 const char *filename, *inp;
1617 char *function, *outp;
1618 struct property *prop;
1619 struct tdesc_feature *feature;
1620 struct tdesc_reg *reg;
1621 struct tdesc_type *type;
1622 struct tdesc_type_field *f;
1623 struct tdesc_type_flag *flag;
1625 int printed_field_type = 0;
1627 /* Use the global target-supplied description, not the current
1628 architecture's. This lets a GDB for one architecture generate C
1629 for another architecture's description, even though the gdbarch
1630 initialization code will reject the new description. */
1631 tdesc = current_target_desc;
1633 error (_("There is no target description to print."));
1635 if (target_description_filename == NULL)
1636 error (_("The current target description did not come from an XML file."));
1638 filename = lbasename (target_description_filename);
1639 function = (char *) alloca (strlen (filename) + 1);
1640 for (inp = filename, outp = function; *inp != '\0'; inp++)
1643 else if (*inp == '-')
1649 /* Standard boilerplate. */
1650 printf_unfiltered ("/* THIS FILE IS GENERATED. "
1651 "-*- buffer-read-only: t -*- vi"
1653 printf_unfiltered (" Original: %s */\n\n", filename);
1654 printf_unfiltered ("#include \"defs.h\"\n");
1655 printf_unfiltered ("#include \"osabi.h\"\n");
1656 printf_unfiltered ("#include \"target-descriptions.h\"\n");
1657 printf_unfiltered ("\n");
1659 printf_unfiltered ("struct target_desc *tdesc_%s;\n", function);
1660 printf_unfiltered ("static void\n");
1661 printf_unfiltered ("initialize_tdesc_%s (void)\n", function);
1662 printf_unfiltered ("{\n");
1664 (" struct target_desc *result = allocate_target_description ();\n");
1665 printf_unfiltered (" struct tdesc_feature *feature;\n");
1667 /* Now we do some "filtering" in order to know which variables to
1668 declare. This is needed because otherwise we would declare unused
1669 variables `field_type' and `type'. */
1671 VEC_iterate (tdesc_feature_p, tdesc->features, ix, feature);
1674 int printed_desc_type = 0;
1677 VEC_iterate (tdesc_type_p, feature->types, ix2, type);
1680 if (!printed_field_type)
1682 printf_unfiltered (" struct tdesc_type *field_type;\n");
1683 printed_field_type = 1;
1686 if ((type->kind == TDESC_TYPE_UNION
1687 || type->kind == TDESC_TYPE_STRUCT)
1688 && VEC_length (tdesc_type_field, type->u.u.fields) > 0)
1690 printf_unfiltered (" struct tdesc_type *type;\n");
1691 printed_desc_type = 1;
1696 if (printed_desc_type)
1700 printf_unfiltered ("\n");
1702 if (tdesc_architecture (tdesc) != NULL)
1705 (" set_tdesc_architecture (result, bfd_scan_arch (\"%s\"));\n",
1706 tdesc_architecture (tdesc)->printable_name);
1707 printf_unfiltered ("\n");
1710 if (tdesc_osabi (tdesc) > GDB_OSABI_UNKNOWN
1711 && tdesc_osabi (tdesc) < GDB_OSABI_INVALID)
1714 (" set_tdesc_osabi (result, osabi_from_tdesc_string (\"%s\"));\n",
1715 gdbarch_osabi_name (tdesc_osabi (tdesc)));
1716 printf_unfiltered ("\n");
1719 for (ix = 0; VEC_iterate (arch_p, tdesc->compatible, ix, compatible);
1723 (" tdesc_add_compatible (result, bfd_scan_arch (\"%s\"));\n",
1724 compatible->printable_name);
1727 printf_unfiltered ("\n");
1729 for (ix = 0; VEC_iterate (property_s, tdesc->properties, ix, prop);
1732 printf_unfiltered (" set_tdesc_property (result, \"%s\", \"%s\");\n",
1733 prop->key, prop->value);
1737 VEC_iterate (tdesc_feature_p, tdesc->features, ix, feature);
1740 printf_unfiltered (" \
1741 feature = tdesc_create_feature (result, \"%s\");\n",
1745 VEC_iterate (tdesc_type_p, feature->types, ix2, type);
1750 case TDESC_TYPE_VECTOR:
1752 (" field_type = tdesc_named_type (feature, \"%s\");\n",
1753 type->u.v.type->name);
1755 (" tdesc_create_vector (feature, \"%s\", field_type, %d);\n",
1756 type->name, type->u.v.count);
1758 case TDESC_TYPE_STRUCT:
1760 (" type = tdesc_create_struct (feature, \"%s\");\n",
1762 if (type->u.u.size != 0)
1764 (" tdesc_set_struct_size (type, %s);\n",
1765 plongest (type->u.u.size));
1767 VEC_iterate (tdesc_type_field, type->u.u.fields, ix3, f);
1770 /* Going first for implicitly sized types, else part handles
1771 bitfields. As reported on xml-tdesc.c implicitly sized types
1772 cannot contain a bitfield. */
1773 if (f->type != NULL)
1776 (" field_type = tdesc_named_type (feature, \"%s\");\n",
1779 (" tdesc_add_field (type, \"%s\", field_type);\n",
1784 (" tdesc_add_bitfield (type, \"%s\", %d, %d);\n",
1785 f->name, f->start, f->end);
1788 case TDESC_TYPE_UNION:
1790 (" type = tdesc_create_union (feature, \"%s\");\n",
1793 VEC_iterate (tdesc_type_field, type->u.u.fields, ix3, f);
1797 (" field_type = tdesc_named_type (feature, \"%s\");\n",
1800 (" tdesc_add_field (type, \"%s\", field_type);\n",
1804 case TDESC_TYPE_FLAGS:
1806 (" field_type = tdesc_create_flags (feature, \"%s\", %d);\n",
1807 type->name, (int) type->u.f.size);
1809 VEC_iterate (tdesc_type_flag, type->u.f.flags, ix3,
1813 (" tdesc_add_flag (field_type, %d, \"%s\");\n",
1814 flag->start, flag->name);
1817 error (_("C output is not supported type \"%s\"."), type->name);
1819 printf_unfiltered ("\n");
1823 VEC_iterate (tdesc_reg_p, feature->registers, ix2, reg);
1826 printf_unfiltered (" tdesc_create_reg (feature, \"%s\", %ld, %d, ",
1827 reg->name, reg->target_regnum, reg->save_restore);
1829 printf_unfiltered ("\"%s\", ", reg->group);
1831 printf_unfiltered ("NULL, ");
1832 printf_unfiltered ("%d, \"%s\");\n", reg->bitsize, reg->type);
1835 printf_unfiltered ("\n");
1838 printf_unfiltered (" tdesc_%s = result;\n", function);
1839 printf_unfiltered ("}\n");
1842 /* Provide a prototype to silence -Wmissing-prototypes. */
1843 extern initialize_file_ftype _initialize_target_descriptions;
1846 _initialize_target_descriptions (void)
1848 tdesc_data = gdbarch_data_register_pre_init (tdesc_data_init);
1850 add_prefix_cmd ("tdesc", class_maintenance, set_tdesc_cmd, _("\
1851 Set target description specific variables."),
1852 &tdesc_set_cmdlist, "set tdesc ",
1853 0 /* allow-unknown */, &setlist);
1854 add_prefix_cmd ("tdesc", class_maintenance, show_tdesc_cmd, _("\
1855 Show target description specific variables."),
1856 &tdesc_show_cmdlist, "show tdesc ",
1857 0 /* allow-unknown */, &showlist);
1858 add_prefix_cmd ("tdesc", class_maintenance, unset_tdesc_cmd, _("\
1859 Unset target description specific variables."),
1860 &tdesc_unset_cmdlist, "unset tdesc ",
1861 0 /* allow-unknown */, &unsetlist);
1863 add_setshow_filename_cmd ("filename", class_obscure,
1864 &tdesc_filename_cmd_string,
1866 Set the file to read for an XML target description"), _("\
1867 Show the file to read for an XML target description"), _("\
1868 When set, GDB will read the target description from a local\n\
1869 file instead of querying the remote target."),
1870 set_tdesc_filename_cmd,
1871 show_tdesc_filename_cmd,
1872 &tdesc_set_cmdlist, &tdesc_show_cmdlist);
1874 add_cmd ("filename", class_obscure, unset_tdesc_filename_cmd, _("\
1875 Unset the file to read for an XML target description. When unset,\n\
1876 GDB will read the description from the target."),
1877 &tdesc_unset_cmdlist);
1879 add_cmd ("c-tdesc", class_maintenance, maint_print_c_tdesc_cmd, _("\
1880 Print the current target description as a C source file."),
1881 &maintenanceprintlist);