1 /* Target description support for GDB.
3 Copyright (C) 2006-2017 Free Software Foundation, Inc.
5 Contributed by CodeSourcery.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "arch-utils.h"
26 #include "reggroups.h"
28 #include "target-descriptions.h"
30 #include "xml-support.h"
31 #include "xml-tdesc.h"
34 #include "gdb_obstack.h"
38 #include "completer.h"
39 #include "readline/tilde.h" /* tilde_expand */
41 /* The interface to visit different elements of target description. */
43 class tdesc_element_visitor
46 virtual void visit_pre (const target_desc *e) = 0;
47 virtual void visit_post (const target_desc *e) = 0;
49 virtual void visit_pre (const tdesc_feature *e) = 0;
50 virtual void visit_post (const tdesc_feature *e) = 0;
52 virtual void visit (const tdesc_type *e) = 0;
53 virtual void visit (const tdesc_reg *e) = 0;
59 virtual void accept (tdesc_element_visitor &v) const = 0;
66 property (const std::string &key_, const std::string &value_)
67 : key (key_), value (value_)
74 /* An individual register from a target description. */
76 struct tdesc_reg : tdesc_element
78 tdesc_reg (struct tdesc_feature *feature, const std::string &name_,
79 int regnum, int save_restore_, const char *group_,
80 int bitsize_, const char *type_)
81 : name (name_), target_regnum (regnum),
82 save_restore (save_restore_),
83 group (group_ != NULL ? group_ : ""),
85 type (type_ != NULL ? type_ : "<unknown>")
87 /* If the register's type is target-defined, look it up now. We may not
88 have easy access to the containing feature when we want it later. */
89 tdesc_type = tdesc_named_type (feature, type.c_str ());
92 virtual ~tdesc_reg () = default;
94 DISABLE_COPY_AND_ASSIGN (tdesc_reg);
96 /* The name of this register. In standard features, it may be
97 recognized by the architecture support code, or it may be purely
101 /* The register number used by this target to refer to this
102 register. This is used for remote p/P packets and to determine
103 the ordering of registers in the remote g/G packets. */
106 /* If this flag is set, GDB should save and restore this register
107 around calls to an inferior function. */
110 /* The name of the register group containing this register, or empty
111 if the group should be automatically determined from the
112 register's type. If this is "general", "float", or "vector", the
113 corresponding "info" command should display this register's
114 value. It can be an arbitrary string, but should be limited to
115 alphanumeric characters and internal hyphens. Currently other
116 strings are ignored (treated as empty). */
119 /* The size of the register, in bits. */
122 /* The type of the register. This string corresponds to either
123 a named type from the target description or a predefined
127 /* The target-described type corresponding to TYPE, if found. */
128 struct tdesc_type *tdesc_type;
130 void accept (tdesc_element_visitor &v) const override
135 bool operator== (const tdesc_reg &other) const
137 return (name == other.name
138 && target_regnum == other.target_regnum
139 && save_restore == other.save_restore
140 && bitsize == other.bitsize
141 && group == other.group
142 && type == other.type);
145 bool operator!= (const tdesc_reg &other) const
147 return !(*this == other);
151 typedef std::unique_ptr<tdesc_reg> tdesc_reg_up;
153 /* A named type from a target description. */
155 struct tdesc_type_field
157 tdesc_type_field (const std::string &name_, tdesc_type *type_,
158 int start_, int end_)
159 : name (name_), type (type_), start (start_), end (end_)
163 struct tdesc_type *type;
164 /* For non-enum-values, either both are -1 (non-bitfield), or both are
165 not -1 (bitfield). For enum values, start is the value (which could be
172 /* Predefined types. */
186 TDESC_TYPE_IEEE_SINGLE,
187 TDESC_TYPE_IEEE_DOUBLE,
188 TDESC_TYPE_ARM_FPA_EXT,
191 /* Types defined by a target feature. */
199 struct tdesc_type : tdesc_element
201 tdesc_type (const std::string &name_, enum tdesc_type_kind kind_)
202 : name (name_), kind (kind_)
204 memset (&u, 0, sizeof (u));
208 case TDESC_TYPE_STRUCT:
209 case TDESC_TYPE_UNION:
210 case TDESC_TYPE_FLAGS:
211 case TDESC_TYPE_ENUM:
212 u.u.fields = new std::vector<tdesc_type_field> ();
220 virtual ~tdesc_type ()
224 case TDESC_TYPE_STRUCT:
225 case TDESC_TYPE_UNION:
226 case TDESC_TYPE_FLAGS:
227 case TDESC_TYPE_ENUM:
236 DISABLE_COPY_AND_ASSIGN (tdesc_type);
238 /* The name of this type. */
241 /* Identify the kind of this type. */
242 enum tdesc_type_kind kind;
244 /* Kind-specific data. */
250 struct tdesc_type *type;
254 /* Struct, union, flags, or enum type. */
257 std::vector<tdesc_type_field> *fields;
262 void accept (tdesc_element_visitor &v) const override
267 bool operator== (const tdesc_type &other) const
269 return name == other.name && kind == other.kind;
272 bool operator!= (const tdesc_type &other) const
274 return !(*this == other);
278 typedef std::unique_ptr<tdesc_type> tdesc_type_up;
280 /* A feature from a target description. Each feature is a collection
281 of other elements, e.g. registers and types. */
283 struct tdesc_feature : tdesc_element
285 tdesc_feature (const std::string &name_)
289 virtual ~tdesc_feature () = default;
291 DISABLE_COPY_AND_ASSIGN (tdesc_feature);
293 /* The name of this feature. It may be recognized by the architecture
297 /* The registers associated with this feature. */
298 std::vector<std::unique_ptr<tdesc_reg>> registers;
300 /* The types associated with this feature. */
301 std::vector<tdesc_type_up> types;
303 void accept (tdesc_element_visitor &v) const override
307 for (const tdesc_type_up &type : types)
310 for (const tdesc_reg_up ® : registers)
316 bool operator== (const tdesc_feature &other) const
318 if (name != other.name)
321 if (registers.size () != other.registers.size ())
324 for (int ix = 0; ix < registers.size (); ix++)
326 const tdesc_reg_up ®1 = registers[ix];
327 const tdesc_reg_up ®2 = other.registers[ix];
329 if (reg1 != reg2 && *reg1 != *reg2)
333 if (types.size () != other.types.size ())
336 for (int ix = 0; ix < types.size (); ix++)
338 const tdesc_type_up &type1 = types[ix];
339 const tdesc_type_up &type2 = other.types[ix];
341 if (type1 != type2 && *type1 != *type2)
348 bool operator!= (const tdesc_feature &other) const
350 return !(*this == other);
354 typedef std::unique_ptr<tdesc_feature> tdesc_feature_up;
356 /* A target description. */
358 struct target_desc : tdesc_element
363 virtual ~target_desc () = default;
365 target_desc (const target_desc &) = delete;
366 void operator= (const target_desc &) = delete;
368 /* The architecture reported by the target, if any. */
369 const struct bfd_arch_info *arch = NULL;
371 /* The osabi reported by the target, if any; GDB_OSABI_UNKNOWN
373 enum gdb_osabi osabi = GDB_OSABI_UNKNOWN;
375 /* The list of compatible architectures reported by the target. */
376 std::vector<const bfd_arch_info *> compatible;
378 /* Any architecture-specific properties specified by the target. */
379 std::vector<property> properties;
381 /* The features associated with this target. */
382 std::vector<std::unique_ptr<tdesc_feature>> features;
384 void accept (tdesc_element_visitor &v) const override
388 for (const tdesc_feature_up &feature : features)
394 bool operator== (const target_desc &other) const
396 if (arch != other.arch)
399 if (osabi != other.osabi)
402 if (features.size () != other.features.size ())
405 for (int ix = 0; ix < features.size (); ix++)
407 const tdesc_feature_up &feature1 = features[ix];
408 const tdesc_feature_up &feature2 = other.features[ix];
410 if (feature1 != feature2 && *feature1 != *feature2)
417 bool operator!= (const target_desc &other) const
419 return !(*this == other);
423 /* Per-architecture data associated with a target description. The
424 target description may be shared by multiple architectures, but
425 this data is private to one gdbarch. */
427 typedef struct tdesc_arch_reg
429 struct tdesc_reg *reg;
432 DEF_VEC_O(tdesc_arch_reg);
434 struct tdesc_arch_data
436 /* A list of register/type pairs, indexed by GDB's internal register number.
437 During initialization of the gdbarch this list is used to store
438 registers which the architecture assigns a fixed register number.
439 Registers which are NULL in this array, or off the end, are
440 treated as zero-sized and nameless (i.e. placeholders in the
442 VEC(tdesc_arch_reg) *arch_regs;
444 /* Functions which report the register name, type, and reggroups for
446 gdbarch_register_name_ftype *pseudo_register_name;
447 gdbarch_register_type_ftype *pseudo_register_type;
448 gdbarch_register_reggroup_p_ftype *pseudo_register_reggroup_p;
451 /* Info about an inferior's target description. There's one of these
452 for each inferior. */
454 struct target_desc_info
456 /* A flag indicating that a description has already been fetched
457 from the target, so it should not be queried again. */
461 /* The description fetched from the target, or NULL if the target
462 did not supply any description. Only valid when
463 target_desc_fetched is set. Only the description initialization
464 code should access this; normally, the description should be
465 accessed through the gdbarch object. */
467 const struct target_desc *tdesc;
469 /* The filename to read a target description from, as set by "set
470 tdesc filename ..." */
475 /* Get the inferior INF's target description info, allocating one on
476 the stop if necessary. */
478 static struct target_desc_info *
479 get_tdesc_info (struct inferior *inf)
481 if (inf->tdesc_info == NULL)
482 inf->tdesc_info = XCNEW (struct target_desc_info);
483 return inf->tdesc_info;
486 /* A handle for architecture-specific data associated with the
487 target description (see struct tdesc_arch_data). */
489 static struct gdbarch_data *tdesc_data;
491 /* See target-descriptions.h. */
494 target_desc_info_from_user_p (struct target_desc_info *info)
496 return info != NULL && info->filename != NULL;
499 /* See target-descriptions.h. */
502 copy_inferior_target_desc_info (struct inferior *destinf, struct inferior *srcinf)
504 struct target_desc_info *src = get_tdesc_info (srcinf);
505 struct target_desc_info *dest = get_tdesc_info (destinf);
507 dest->fetched = src->fetched;
508 dest->tdesc = src->tdesc;
509 dest->filename = src->filename != NULL ? xstrdup (src->filename) : NULL;
512 /* See target-descriptions.h. */
515 target_desc_info_free (struct target_desc_info *tdesc_info)
517 if (tdesc_info != NULL)
519 xfree (tdesc_info->filename);
524 /* Convenience helper macros. */
526 #define target_desc_fetched \
527 get_tdesc_info (current_inferior ())->fetched
528 #define current_target_desc \
529 get_tdesc_info (current_inferior ())->tdesc
530 #define target_description_filename \
531 get_tdesc_info (current_inferior ())->filename
533 /* The string manipulated by the "set tdesc filename ..." command. */
535 static char *tdesc_filename_cmd_string;
537 /* Fetch the current target's description, and switch the current
538 architecture to one which incorporates that description. */
541 target_find_description (void)
543 /* If we've already fetched a description from the target, don't do
544 it again. This allows a target to fetch the description early,
545 during its to_open or to_create_inferior, if it needs extra
546 information about the target to initialize. */
547 if (target_desc_fetched)
550 /* The current architecture should not have any target description
551 specified. It should have been cleared, e.g. when we
552 disconnected from the previous target. */
553 gdb_assert (gdbarch_target_desc (target_gdbarch ()) == NULL);
555 /* First try to fetch an XML description from the user-specified
557 current_target_desc = NULL;
558 if (target_description_filename != NULL
559 && *target_description_filename != '\0')
561 = file_read_description_xml (target_description_filename);
563 /* Next try to read the description from the current target using
565 if (current_target_desc == NULL)
566 current_target_desc = target_read_description_xml (¤t_target);
568 /* If that failed try a target-specific hook. */
569 if (current_target_desc == NULL)
570 current_target_desc = target_read_description (¤t_target);
572 /* If a non-NULL description was returned, then update the current
574 if (current_target_desc)
576 struct gdbarch_info info;
578 gdbarch_info_init (&info);
579 info.target_desc = current_target_desc;
580 if (!gdbarch_update_p (info))
581 warning (_("Architecture rejected target-supplied description"));
584 struct tdesc_arch_data *data;
586 data = ((struct tdesc_arch_data *)
587 gdbarch_data (target_gdbarch (), tdesc_data));
588 if (tdesc_has_registers (current_target_desc)
589 && data->arch_regs == NULL)
590 warning (_("Target-supplied registers are not supported "
591 "by the current architecture"));
595 /* Now that we know this description is usable, record that we
597 target_desc_fetched = 1;
600 /* Discard any description fetched from the current target, and switch
601 the current architecture to one with no target description. */
604 target_clear_description (void)
606 struct gdbarch_info info;
608 if (!target_desc_fetched)
611 target_desc_fetched = 0;
612 current_target_desc = NULL;
614 gdbarch_info_init (&info);
615 if (!gdbarch_update_p (info))
616 internal_error (__FILE__, __LINE__,
617 _("Could not remove target-supplied description"));
620 /* Return the global current target description. This should only be
621 used by gdbarch initialization code; most access should be through
622 an existing gdbarch. */
624 const struct target_desc *
625 target_current_description (void)
627 if (target_desc_fetched)
628 return current_target_desc;
633 /* Return non-zero if this target description is compatible
634 with the given BFD architecture. */
637 tdesc_compatible_p (const struct target_desc *target_desc,
638 const struct bfd_arch_info *arch)
640 for (const bfd_arch_info *compat : target_desc->compatible)
643 || arch->compatible (arch, compat)
644 || compat->compatible (compat, arch))
652 /* Direct accessors for target descriptions. */
654 /* Return the string value of a property named KEY, or NULL if the
655 property was not specified. */
658 tdesc_property (const struct target_desc *target_desc, const char *key)
660 for (const property &prop : target_desc->properties)
662 return prop.value.c_str ();
667 /* Return the BFD architecture associated with this target
668 description, or NULL if no architecture was specified. */
670 const struct bfd_arch_info *
671 tdesc_architecture (const struct target_desc *target_desc)
673 return target_desc->arch;
676 /* Return the OSABI associated with this target description, or
677 GDB_OSABI_UNKNOWN if no osabi was specified. */
680 tdesc_osabi (const struct target_desc *target_desc)
682 return target_desc->osabi;
687 /* Return 1 if this target description includes any registers. */
690 tdesc_has_registers (const struct target_desc *target_desc)
692 if (target_desc == NULL)
695 for (const tdesc_feature_up &feature : target_desc->features)
696 if (!feature->registers.empty ())
702 /* Return the feature with the given name, if present, or NULL if
703 the named feature is not found. */
705 const struct tdesc_feature *
706 tdesc_find_feature (const struct target_desc *target_desc,
709 for (const tdesc_feature_up &feature : target_desc->features)
710 if (feature->name == name)
711 return feature.get ();
716 /* Return the name of FEATURE. */
719 tdesc_feature_name (const struct tdesc_feature *feature)
721 return feature->name.c_str ();
724 /* Predefined types. */
725 static struct tdesc_type tdesc_predefined_types[] =
727 { "bool", TDESC_TYPE_BOOL },
728 { "int8", TDESC_TYPE_INT8 },
729 { "int16", TDESC_TYPE_INT16 },
730 { "int32", TDESC_TYPE_INT32 },
731 { "int64", TDESC_TYPE_INT64 },
732 { "int128", TDESC_TYPE_INT128 },
733 { "uint8", TDESC_TYPE_UINT8 },
734 { "uint16", TDESC_TYPE_UINT16 },
735 { "uint32", TDESC_TYPE_UINT32 },
736 { "uint64", TDESC_TYPE_UINT64 },
737 { "uint128", TDESC_TYPE_UINT128 },
738 { "code_ptr", TDESC_TYPE_CODE_PTR },
739 { "data_ptr", TDESC_TYPE_DATA_PTR },
740 { "ieee_single", TDESC_TYPE_IEEE_SINGLE },
741 { "ieee_double", TDESC_TYPE_IEEE_DOUBLE },
742 { "arm_fpa_ext", TDESC_TYPE_ARM_FPA_EXT },
743 { "i387_ext", TDESC_TYPE_I387_EXT }
746 /* Lookup a predefined type. */
748 static struct tdesc_type *
749 tdesc_predefined_type (enum tdesc_type_kind kind)
751 for (int ix = 0; ix < ARRAY_SIZE (tdesc_predefined_types); ix++)
752 if (tdesc_predefined_types[ix].kind == kind)
753 return &tdesc_predefined_types[ix];
755 gdb_assert_not_reached ("bad predefined tdesc type");
758 /* See arch/tdesc.h. */
761 tdesc_named_type (const struct tdesc_feature *feature, const char *id)
763 /* First try target-defined types. */
764 for (const tdesc_type_up &type : feature->types)
765 if (type->name == id)
768 /* Next try the predefined types. */
769 for (int ix = 0; ix < ARRAY_SIZE (tdesc_predefined_types); ix++)
770 if (tdesc_predefined_types[ix].name == id)
771 return &tdesc_predefined_types[ix];
776 /* Lookup type associated with ID. */
779 tdesc_find_type (struct gdbarch *gdbarch, const char *id)
781 struct tdesc_arch_reg *reg;
782 struct tdesc_arch_data *data;
785 data = (struct tdesc_arch_data *) gdbarch_data (gdbarch, tdesc_data);
786 num_regs = VEC_length (tdesc_arch_reg, data->arch_regs);
787 for (i = 0; i < num_regs; i++)
789 reg = VEC_index (tdesc_arch_reg, data->arch_regs, i);
791 && reg->reg->tdesc_type
793 && reg->reg->tdesc_type->name == id)
800 /* Construct, if necessary, and return the GDB type implementing target
801 type TDESC_TYPE for architecture GDBARCH. */
804 tdesc_gdb_type (struct gdbarch *gdbarch, struct tdesc_type *tdesc_type)
808 switch (tdesc_type->kind)
810 /* Predefined types. */
811 case TDESC_TYPE_BOOL:
812 return builtin_type (gdbarch)->builtin_bool;
814 case TDESC_TYPE_INT8:
815 return builtin_type (gdbarch)->builtin_int8;
817 case TDESC_TYPE_INT16:
818 return builtin_type (gdbarch)->builtin_int16;
820 case TDESC_TYPE_INT32:
821 return builtin_type (gdbarch)->builtin_int32;
823 case TDESC_TYPE_INT64:
824 return builtin_type (gdbarch)->builtin_int64;
826 case TDESC_TYPE_INT128:
827 return builtin_type (gdbarch)->builtin_int128;
829 case TDESC_TYPE_UINT8:
830 return builtin_type (gdbarch)->builtin_uint8;
832 case TDESC_TYPE_UINT16:
833 return builtin_type (gdbarch)->builtin_uint16;
835 case TDESC_TYPE_UINT32:
836 return builtin_type (gdbarch)->builtin_uint32;
838 case TDESC_TYPE_UINT64:
839 return builtin_type (gdbarch)->builtin_uint64;
841 case TDESC_TYPE_UINT128:
842 return builtin_type (gdbarch)->builtin_uint128;
844 case TDESC_TYPE_CODE_PTR:
845 return builtin_type (gdbarch)->builtin_func_ptr;
847 case TDESC_TYPE_DATA_PTR:
848 return builtin_type (gdbarch)->builtin_data_ptr;
854 type = tdesc_find_type (gdbarch, tdesc_type->name.c_str ());
858 switch (tdesc_type->kind)
860 case TDESC_TYPE_IEEE_SINGLE:
861 return arch_float_type (gdbarch, -1, "builtin_type_ieee_single",
862 floatformats_ieee_single);
864 case TDESC_TYPE_IEEE_DOUBLE:
865 return arch_float_type (gdbarch, -1, "builtin_type_ieee_double",
866 floatformats_ieee_double);
868 case TDESC_TYPE_ARM_FPA_EXT:
869 return arch_float_type (gdbarch, -1, "builtin_type_arm_ext",
870 floatformats_arm_ext);
872 case TDESC_TYPE_I387_EXT:
873 return arch_float_type (gdbarch, -1, "builtin_type_i387_ext",
874 floatformats_i387_ext);
876 /* Types defined by a target feature. */
877 case TDESC_TYPE_VECTOR:
879 struct type *type, *field_type;
881 field_type = tdesc_gdb_type (gdbarch, tdesc_type->u.v.type);
882 type = init_vector_type (field_type, tdesc_type->u.v.count);
883 TYPE_NAME (type) = xstrdup (tdesc_type->name.c_str ());
888 case TDESC_TYPE_STRUCT:
890 struct type *type, *field_type;
892 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
893 TYPE_NAME (type) = xstrdup (tdesc_type->name.c_str ());
894 TYPE_TAG_NAME (type) = TYPE_NAME (type);
896 for (const tdesc_type_field &f : *tdesc_type->u.u.fields)
898 if (f.start != -1 && f.end != -1)
902 struct type *field_type;
903 int bitsize, total_size;
905 /* This invariant should be preserved while creating types. */
906 gdb_assert (tdesc_type->u.u.size != 0);
908 field_type = tdesc_gdb_type (gdbarch, f.type);
909 else if (tdesc_type->u.u.size > 4)
910 field_type = builtin_type (gdbarch)->builtin_uint64;
912 field_type = builtin_type (gdbarch)->builtin_uint32;
914 fld = append_composite_type_field_raw
915 (type, xstrdup (f.name.c_str ()), field_type);
917 /* For little-endian, BITPOS counts from the LSB of
918 the structure and marks the LSB of the field. For
919 big-endian, BITPOS counts from the MSB of the
920 structure and marks the MSB of the field. Either
921 way, it is the number of bits to the "left" of the
922 field. To calculate this in big-endian, we need
923 the total size of the structure. */
924 bitsize = f.end - f.start + 1;
925 total_size = tdesc_type->u.u.size * TARGET_CHAR_BIT;
926 if (gdbarch_bits_big_endian (gdbarch))
927 SET_FIELD_BITPOS (fld[0], total_size - f.start - bitsize);
929 SET_FIELD_BITPOS (fld[0], f.start);
930 FIELD_BITSIZE (fld[0]) = bitsize;
934 gdb_assert (f.start == -1 && f.end == -1);
935 field_type = tdesc_gdb_type (gdbarch, f.type);
936 append_composite_type_field (type, xstrdup (f.name.c_str ()),
941 if (tdesc_type->u.u.size != 0)
942 TYPE_LENGTH (type) = tdesc_type->u.u.size;
946 case TDESC_TYPE_UNION:
948 struct type *type, *field_type;
950 type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION);
951 TYPE_NAME (type) = xstrdup (tdesc_type->name.c_str ());
953 for (const tdesc_type_field &f : *tdesc_type->u.u.fields)
955 field_type = tdesc_gdb_type (gdbarch, f.type);
956 append_composite_type_field (type, xstrdup (f.name.c_str ()),
959 /* If any of the children of a union are vectors, flag the
960 union as a vector also. This allows e.g. a union of two
961 vector types to show up automatically in "info vector". */
962 if (TYPE_VECTOR (field_type))
963 TYPE_VECTOR (type) = 1;
968 case TDESC_TYPE_FLAGS:
970 type = arch_flags_type (gdbarch, tdesc_type->name.c_str (),
971 tdesc_type->u.u.size * TARGET_CHAR_BIT);
972 for (const tdesc_type_field &f : *tdesc_type->u.u.fields)
974 struct type *field_type;
975 int bitsize = f.end - f.start + 1;
977 gdb_assert (f.type != NULL);
978 field_type = tdesc_gdb_type (gdbarch, f.type);
979 append_flags_type_field (type, f.start, bitsize,
980 field_type, f.name.c_str ());
986 case TDESC_TYPE_ENUM:
988 type = arch_type (gdbarch, TYPE_CODE_ENUM,
989 tdesc_type->u.u.size * TARGET_CHAR_BIT,
990 tdesc_type->name.c_str ());
991 TYPE_UNSIGNED (type) = 1;
992 for (const tdesc_type_field &f : *tdesc_type->u.u.fields)
995 = append_composite_type_field_raw (type,
996 xstrdup (f.name.c_str ()),
999 SET_FIELD_BITPOS (fld[0], f.start);
1006 internal_error (__FILE__, __LINE__,
1007 "Type \"%s\" has an unknown kind %d",
1008 tdesc_type->name.c_str (), tdesc_type->kind);
1012 /* Support for registers from target descriptions. */
1014 /* Construct the per-gdbarch data. */
1017 tdesc_data_init (struct obstack *obstack)
1019 struct tdesc_arch_data *data;
1021 data = OBSTACK_ZALLOC (obstack, struct tdesc_arch_data);
1025 /* Similar, but for the temporary copy used during architecture
1028 struct tdesc_arch_data *
1029 tdesc_data_alloc (void)
1031 return XCNEW (struct tdesc_arch_data);
1034 /* Free something allocated by tdesc_data_alloc, if it is not going
1035 to be used (for instance if it was unsuitable for the
1039 tdesc_data_cleanup (void *data_untyped)
1041 struct tdesc_arch_data *data = (struct tdesc_arch_data *) data_untyped;
1043 VEC_free (tdesc_arch_reg, data->arch_regs);
1047 /* Search FEATURE for a register named NAME. */
1049 static struct tdesc_reg *
1050 tdesc_find_register_early (const struct tdesc_feature *feature,
1053 for (const tdesc_reg_up ® : feature->registers)
1054 if (strcasecmp (reg->name.c_str (), name) == 0)
1060 /* Search FEATURE for a register named NAME. Assign REGNO to it. */
1063 tdesc_numbered_register (const struct tdesc_feature *feature,
1064 struct tdesc_arch_data *data,
1065 int regno, const char *name)
1067 struct tdesc_arch_reg arch_reg = { 0 };
1068 struct tdesc_reg *reg = tdesc_find_register_early (feature, name);
1073 /* Make sure the vector includes a REGNO'th element. */
1074 while (regno >= VEC_length (tdesc_arch_reg, data->arch_regs))
1075 VEC_safe_push (tdesc_arch_reg, data->arch_regs, &arch_reg);
1078 VEC_replace (tdesc_arch_reg, data->arch_regs, regno, &arch_reg);
1082 /* Search FEATURE for a register named NAME, but do not assign a fixed
1083 register number to it. */
1086 tdesc_unnumbered_register (const struct tdesc_feature *feature,
1089 struct tdesc_reg *reg = tdesc_find_register_early (feature, name);
1097 /* Search FEATURE for a register whose name is in NAMES and assign
1101 tdesc_numbered_register_choices (const struct tdesc_feature *feature,
1102 struct tdesc_arch_data *data,
1103 int regno, const char *const names[])
1107 for (i = 0; names[i] != NULL; i++)
1108 if (tdesc_numbered_register (feature, data, regno, names[i]))
1114 /* Search FEATURE for a register named NAME, and return its size in
1115 bits. The register must exist. */
1118 tdesc_register_size (const struct tdesc_feature *feature,
1121 struct tdesc_reg *reg = tdesc_find_register_early (feature, name);
1123 gdb_assert (reg != NULL);
1124 return reg->bitsize;
1127 /* Look up a register by its GDB internal register number. */
1129 static struct tdesc_arch_reg *
1130 tdesc_find_arch_register (struct gdbarch *gdbarch, int regno)
1132 struct tdesc_arch_data *data;
1134 data = (struct tdesc_arch_data *) gdbarch_data (gdbarch, tdesc_data);
1135 if (regno < VEC_length (tdesc_arch_reg, data->arch_regs))
1136 return VEC_index (tdesc_arch_reg, data->arch_regs, regno);
1141 static struct tdesc_reg *
1142 tdesc_find_register (struct gdbarch *gdbarch, int regno)
1144 struct tdesc_arch_reg *reg = tdesc_find_arch_register (gdbarch, regno);
1146 return reg? reg->reg : NULL;
1149 /* Return the name of register REGNO, from the target description or
1150 from an architecture-provided pseudo_register_name method. */
1153 tdesc_register_name (struct gdbarch *gdbarch, int regno)
1155 struct tdesc_reg *reg = tdesc_find_register (gdbarch, regno);
1156 int num_regs = gdbarch_num_regs (gdbarch);
1157 int num_pseudo_regs = gdbarch_num_pseudo_regs (gdbarch);
1160 return reg->name.c_str ();
1162 if (regno >= num_regs && regno < num_regs + num_pseudo_regs)
1164 struct tdesc_arch_data *data
1165 = (struct tdesc_arch_data *) gdbarch_data (gdbarch, tdesc_data);
1167 gdb_assert (data->pseudo_register_name != NULL);
1168 return data->pseudo_register_name (gdbarch, regno);
1175 tdesc_register_type (struct gdbarch *gdbarch, int regno)
1177 struct tdesc_arch_reg *arch_reg = tdesc_find_arch_register (gdbarch, regno);
1178 struct tdesc_reg *reg = arch_reg? arch_reg->reg : NULL;
1179 int num_regs = gdbarch_num_regs (gdbarch);
1180 int num_pseudo_regs = gdbarch_num_pseudo_regs (gdbarch);
1182 if (reg == NULL && regno >= num_regs && regno < num_regs + num_pseudo_regs)
1184 struct tdesc_arch_data *data
1185 = (struct tdesc_arch_data *) gdbarch_data (gdbarch, tdesc_data);
1187 gdb_assert (data->pseudo_register_type != NULL);
1188 return data->pseudo_register_type (gdbarch, regno);
1192 /* Return "int0_t", since "void" has a misleading size of one. */
1193 return builtin_type (gdbarch)->builtin_int0;
1195 if (arch_reg->type == NULL)
1197 /* First check for a predefined or target defined type. */
1198 if (reg->tdesc_type)
1199 arch_reg->type = tdesc_gdb_type (gdbarch, reg->tdesc_type);
1201 /* Next try size-sensitive type shortcuts. */
1202 else if (reg->type == "float")
1204 if (reg->bitsize == gdbarch_float_bit (gdbarch))
1205 arch_reg->type = builtin_type (gdbarch)->builtin_float;
1206 else if (reg->bitsize == gdbarch_double_bit (gdbarch))
1207 arch_reg->type = builtin_type (gdbarch)->builtin_double;
1208 else if (reg->bitsize == gdbarch_long_double_bit (gdbarch))
1209 arch_reg->type = builtin_type (gdbarch)->builtin_long_double;
1212 warning (_("Register \"%s\" has an unsupported size (%d bits)"),
1213 reg->name.c_str (), reg->bitsize);
1214 arch_reg->type = builtin_type (gdbarch)->builtin_double;
1217 else if (reg->type == "int")
1219 if (reg->bitsize == gdbarch_long_bit (gdbarch))
1220 arch_reg->type = builtin_type (gdbarch)->builtin_long;
1221 else if (reg->bitsize == TARGET_CHAR_BIT)
1222 arch_reg->type = builtin_type (gdbarch)->builtin_char;
1223 else if (reg->bitsize == gdbarch_short_bit (gdbarch))
1224 arch_reg->type = builtin_type (gdbarch)->builtin_short;
1225 else if (reg->bitsize == gdbarch_int_bit (gdbarch))
1226 arch_reg->type = builtin_type (gdbarch)->builtin_int;
1227 else if (reg->bitsize == gdbarch_long_long_bit (gdbarch))
1228 arch_reg->type = builtin_type (gdbarch)->builtin_long_long;
1229 else if (reg->bitsize == gdbarch_ptr_bit (gdbarch))
1230 /* A bit desperate by this point... */
1231 arch_reg->type = builtin_type (gdbarch)->builtin_data_ptr;
1234 warning (_("Register \"%s\" has an unsupported size (%d bits)"),
1235 reg->name.c_str (), reg->bitsize);
1236 arch_reg->type = builtin_type (gdbarch)->builtin_long;
1240 if (arch_reg->type == NULL)
1241 internal_error (__FILE__, __LINE__,
1242 "Register \"%s\" has an unknown type \"%s\"",
1243 reg->name.c_str (), reg->type.c_str ());
1246 return arch_reg->type;
1250 tdesc_remote_register_number (struct gdbarch *gdbarch, int regno)
1252 struct tdesc_reg *reg = tdesc_find_register (gdbarch, regno);
1255 return reg->target_regnum;
1260 /* Check whether REGNUM is a member of REGGROUP. Registers from the
1261 target description may be classified as general, float, or vector.
1262 Unlike a gdbarch register_reggroup_p method, this function will
1263 return -1 if it does not know; the caller should handle registers
1264 with no specified group.
1266 Arbitrary strings (other than "general", "float", and "vector")
1267 from the description are not used; they cause the register to be
1268 displayed in "info all-registers" but excluded from "info
1269 registers" et al. The names of containing features are also not
1270 used. This might be extended to display registers in some more
1273 The save-restore flag is also implemented here. */
1276 tdesc_register_in_reggroup_p (struct gdbarch *gdbarch, int regno,
1277 struct reggroup *reggroup)
1279 struct tdesc_reg *reg = tdesc_find_register (gdbarch, regno);
1281 if (reg != NULL && !reg->group.empty ())
1283 int general_p = 0, float_p = 0, vector_p = 0;
1285 if (reg->group == "general")
1287 else if (reg->group == "float")
1289 else if (reg->group == "vector")
1292 if (reggroup == float_reggroup)
1295 if (reggroup == vector_reggroup)
1298 if (reggroup == general_reggroup)
1303 && (reggroup == save_reggroup || reggroup == restore_reggroup))
1304 return reg->save_restore;
1309 /* Check whether REGNUM is a member of REGGROUP. Registers with no
1310 group specified go to the default reggroup function and are handled
1314 tdesc_register_reggroup_p (struct gdbarch *gdbarch, int regno,
1315 struct reggroup *reggroup)
1317 int num_regs = gdbarch_num_regs (gdbarch);
1318 int num_pseudo_regs = gdbarch_num_pseudo_regs (gdbarch);
1321 if (regno >= num_regs && regno < num_regs + num_pseudo_regs)
1323 struct tdesc_arch_data *data
1324 = (struct tdesc_arch_data *) gdbarch_data (gdbarch, tdesc_data);
1326 if (data->pseudo_register_reggroup_p != NULL)
1327 return data->pseudo_register_reggroup_p (gdbarch, regno, reggroup);
1328 /* Otherwise fall through to the default reggroup_p. */
1331 ret = tdesc_register_in_reggroup_p (gdbarch, regno, reggroup);
1335 return default_register_reggroup_p (gdbarch, regno, reggroup);
1338 /* Record architecture-specific functions to call for pseudo-register
1342 set_tdesc_pseudo_register_name (struct gdbarch *gdbarch,
1343 gdbarch_register_name_ftype *pseudo_name)
1345 struct tdesc_arch_data *data
1346 = (struct tdesc_arch_data *) gdbarch_data (gdbarch, tdesc_data);
1348 data->pseudo_register_name = pseudo_name;
1352 set_tdesc_pseudo_register_type (struct gdbarch *gdbarch,
1353 gdbarch_register_type_ftype *pseudo_type)
1355 struct tdesc_arch_data *data
1356 = (struct tdesc_arch_data *) gdbarch_data (gdbarch, tdesc_data);
1358 data->pseudo_register_type = pseudo_type;
1362 set_tdesc_pseudo_register_reggroup_p
1363 (struct gdbarch *gdbarch,
1364 gdbarch_register_reggroup_p_ftype *pseudo_reggroup_p)
1366 struct tdesc_arch_data *data
1367 = (struct tdesc_arch_data *) gdbarch_data (gdbarch, tdesc_data);
1369 data->pseudo_register_reggroup_p = pseudo_reggroup_p;
1372 /* Update GDBARCH to use the target description for registers. */
1375 tdesc_use_registers (struct gdbarch *gdbarch,
1376 const struct target_desc *target_desc,
1377 struct tdesc_arch_data *early_data)
1379 int num_regs = gdbarch_num_regs (gdbarch);
1380 struct tdesc_arch_data *data;
1381 struct tdesc_arch_reg *arch_reg, new_arch_reg = { 0 };
1384 /* We can't use the description for registers if it doesn't describe
1385 any. This function should only be called after validating
1386 registers, so the caller should know that registers are
1388 gdb_assert (tdesc_has_registers (target_desc));
1390 data = (struct tdesc_arch_data *) gdbarch_data (gdbarch, tdesc_data);
1391 data->arch_regs = early_data->arch_regs;
1394 /* Build up a set of all registers, so that we can assign register
1395 numbers where needed. The hash table expands as necessary, so
1396 the initial size is arbitrary. */
1397 reg_hash = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
1398 for (const tdesc_feature_up &feature : target_desc->features)
1399 for (const tdesc_reg_up ® : feature->registers)
1401 void **slot = htab_find_slot (reg_hash, reg.get (), INSERT);
1406 /* Remove any registers which were assigned numbers by the
1409 VEC_iterate (tdesc_arch_reg, data->arch_regs, ixr, arch_reg);
1412 htab_remove_elt (reg_hash, arch_reg->reg);
1414 /* Assign numbers to the remaining registers and add them to the
1415 list of registers. The new numbers are always above gdbarch_num_regs.
1416 Iterate over the features, not the hash table, so that the order
1417 matches that in the target description. */
1419 gdb_assert (VEC_length (tdesc_arch_reg, data->arch_regs) <= num_regs);
1420 while (VEC_length (tdesc_arch_reg, data->arch_regs) < num_regs)
1421 VEC_safe_push (tdesc_arch_reg, data->arch_regs, &new_arch_reg);
1422 for (const tdesc_feature_up &feature : target_desc->features)
1423 for (const tdesc_reg_up ® : feature->registers)
1424 if (htab_find (reg_hash, reg.get ()) != NULL)
1426 new_arch_reg.reg = reg.get ();
1427 VEC_safe_push (tdesc_arch_reg, data->arch_regs, &new_arch_reg);
1431 htab_delete (reg_hash);
1433 /* Update the architecture. */
1434 set_gdbarch_num_regs (gdbarch, num_regs);
1435 set_gdbarch_register_name (gdbarch, tdesc_register_name);
1436 set_gdbarch_register_type (gdbarch, tdesc_register_type);
1437 set_gdbarch_remote_register_number (gdbarch,
1438 tdesc_remote_register_number);
1439 set_gdbarch_register_reggroup_p (gdbarch, tdesc_register_reggroup_p);
1443 /* See arch/tdesc.h. */
1446 tdesc_create_reg (struct tdesc_feature *feature, const char *name,
1447 int regnum, int save_restore, const char *group,
1448 int bitsize, const char *type)
1450 tdesc_reg *reg = new tdesc_reg (feature, name, regnum, save_restore,
1451 group, bitsize, type);
1453 feature->registers.emplace_back (reg);
1456 /* See arch/tdesc.h. */
1459 tdesc_create_vector (struct tdesc_feature *feature, const char *name,
1460 struct tdesc_type *field_type, int count)
1462 struct tdesc_type *type = new tdesc_type (name, TDESC_TYPE_VECTOR);
1464 type->u.v.type = field_type;
1465 type->u.v.count = count;
1467 feature->types.emplace_back (type);
1471 /* See arch/tdesc.h. */
1474 tdesc_create_struct (struct tdesc_feature *feature, const char *name)
1476 struct tdesc_type *type = new tdesc_type (name, TDESC_TYPE_STRUCT);
1478 feature->types.emplace_back (type);
1482 /* See arch/tdesc.h. */
1485 tdesc_set_struct_size (struct tdesc_type *type, int size)
1487 gdb_assert (type->kind == TDESC_TYPE_STRUCT);
1488 gdb_assert (size > 0);
1489 type->u.u.size = size;
1492 /* See arch/tdesc.h. */
1495 tdesc_create_union (struct tdesc_feature *feature, const char *name)
1497 struct tdesc_type *type = new tdesc_type (name, TDESC_TYPE_UNION);
1499 feature->types.emplace_back (type);
1503 /* See arch/tdesc.h. */
1506 tdesc_create_flags (struct tdesc_feature *feature, const char *name,
1509 struct tdesc_type *type = new tdesc_type (name, TDESC_TYPE_FLAGS);
1511 gdb_assert (size > 0);
1513 type->u.u.size = size;
1515 feature->types.emplace_back (type);
1520 tdesc_create_enum (struct tdesc_feature *feature, const char *name,
1523 struct tdesc_type *type = new tdesc_type (name, TDESC_TYPE_ENUM);
1525 gdb_assert (size > 0);
1527 type->u.u.size = size;
1529 feature->types.emplace_back (type);
1533 /* See arch/tdesc.h. */
1536 tdesc_add_field (struct tdesc_type *type, const char *field_name,
1537 struct tdesc_type *field_type)
1539 gdb_assert (type->kind == TDESC_TYPE_UNION
1540 || type->kind == TDESC_TYPE_STRUCT);
1542 /* Initialize start and end so we know this is not a bit-field
1543 when we print-c-tdesc. */
1544 type->u.u.fields->emplace_back (field_name, field_type, -1, -1);
1548 tdesc_add_typed_bitfield (struct tdesc_type *type, const char *field_name,
1549 int start, int end, struct tdesc_type *field_type)
1551 gdb_assert (type->kind == TDESC_TYPE_STRUCT
1552 || type->kind == TDESC_TYPE_FLAGS);
1553 gdb_assert (start >= 0 && end >= start);
1555 type->u.u.fields->emplace_back (field_name, field_type, start, end);
1558 /* See arch/tdesc.h. */
1561 tdesc_add_bitfield (struct tdesc_type *type, const char *field_name,
1564 struct tdesc_type *field_type;
1566 gdb_assert (start >= 0 && end >= start);
1568 if (type->u.u.size > 4)
1569 field_type = tdesc_predefined_type (TDESC_TYPE_UINT64);
1571 field_type = tdesc_predefined_type (TDESC_TYPE_UINT32);
1573 tdesc_add_typed_bitfield (type, field_name, start, end, field_type);
1576 /* See arch/tdesc.h. */
1579 tdesc_add_flag (struct tdesc_type *type, int start,
1580 const char *flag_name)
1582 gdb_assert (type->kind == TDESC_TYPE_FLAGS
1583 || type->kind == TDESC_TYPE_STRUCT);
1585 type->u.u.fields->emplace_back (flag_name,
1586 tdesc_predefined_type (TDESC_TYPE_BOOL),
1591 tdesc_add_enum_value (struct tdesc_type *type, int value,
1594 gdb_assert (type->kind == TDESC_TYPE_ENUM);
1596 type->u.u.fields->emplace_back (name,
1597 tdesc_predefined_type (TDESC_TYPE_INT32),
1601 /* See arch/tdesc.h. */
1603 struct tdesc_feature *
1604 tdesc_create_feature (struct target_desc *tdesc, const char *name,
1607 struct tdesc_feature *new_feature = new tdesc_feature (name);
1609 tdesc->features.emplace_back (new_feature);
1614 struct target_desc *
1615 allocate_target_description (void)
1617 return new target_desc ();
1621 free_target_description (void *arg)
1623 struct target_desc *target_desc = (struct target_desc *) arg;
1629 make_cleanup_free_target_description (struct target_desc *target_desc)
1631 return make_cleanup (free_target_description, target_desc);
1635 tdesc_add_compatible (struct target_desc *target_desc,
1636 const struct bfd_arch_info *compatible)
1638 /* If this instance of GDB is compiled without BFD support for the
1639 compatible architecture, simply ignore it -- we would not be able
1640 to handle it anyway. */
1641 if (compatible == NULL)
1644 for (const bfd_arch_info *compat : target_desc->compatible)
1645 if (compat == compatible)
1646 internal_error (__FILE__, __LINE__,
1647 _("Attempted to add duplicate "
1648 "compatible architecture \"%s\""),
1649 compatible->printable_name);
1651 target_desc->compatible.push_back (compatible);
1655 set_tdesc_property (struct target_desc *target_desc,
1656 const char *key, const char *value)
1658 gdb_assert (key != NULL && value != NULL);
1660 if (tdesc_property (target_desc, key) != NULL)
1661 internal_error (__FILE__, __LINE__,
1662 _("Attempted to add duplicate property \"%s\""), key);
1664 target_desc->properties.emplace_back (key, value);
1667 /* See arch/tdesc.h. */
1670 set_tdesc_architecture (struct target_desc *target_desc,
1673 set_tdesc_architecture (target_desc, bfd_scan_arch (name));
1677 set_tdesc_architecture (struct target_desc *target_desc,
1678 const struct bfd_arch_info *arch)
1680 target_desc->arch = arch;
1683 /* See arch/tdesc.h. */
1686 set_tdesc_osabi (struct target_desc *target_desc, const char *name)
1688 set_tdesc_osabi (target_desc, osabi_from_tdesc_string (name));
1692 set_tdesc_osabi (struct target_desc *target_desc, enum gdb_osabi osabi)
1694 target_desc->osabi = osabi;
1698 static struct cmd_list_element *tdesc_set_cmdlist, *tdesc_show_cmdlist;
1699 static struct cmd_list_element *tdesc_unset_cmdlist;
1701 /* Helper functions for the CLI commands. */
1704 set_tdesc_cmd (const char *args, int from_tty)
1706 help_list (tdesc_set_cmdlist, "set tdesc ", all_commands, gdb_stdout);
1710 show_tdesc_cmd (const char *args, int from_tty)
1712 cmd_show_list (tdesc_show_cmdlist, from_tty, "");
1716 unset_tdesc_cmd (const char *args, int from_tty)
1718 help_list (tdesc_unset_cmdlist, "unset tdesc ", all_commands, gdb_stdout);
1722 set_tdesc_filename_cmd (const char *args, int from_tty,
1723 struct cmd_list_element *c)
1725 xfree (target_description_filename);
1726 target_description_filename = xstrdup (tdesc_filename_cmd_string);
1728 target_clear_description ();
1729 target_find_description ();
1733 show_tdesc_filename_cmd (struct ui_file *file, int from_tty,
1734 struct cmd_list_element *c,
1737 value = target_description_filename;
1739 if (value != NULL && *value != '\0')
1740 printf_filtered (_("The target description will be read from \"%s\".\n"),
1743 printf_filtered (_("The target description will be "
1744 "read from the target.\n"));
1748 unset_tdesc_filename_cmd (const char *args, int from_tty)
1750 xfree (target_description_filename);
1751 target_description_filename = NULL;
1752 target_clear_description ();
1753 target_find_description ();
1756 /* Print target description in C. */
1758 class print_c_tdesc : public tdesc_element_visitor
1761 print_c_tdesc (std::string &filename_after_features)
1762 : m_filename_after_features (filename_after_features)
1766 const char *filename = lbasename (m_filename_after_features.c_str ());
1768 m_function = (char *) xmalloc (strlen (filename) + 1);
1769 for (inp = filename, outp = m_function; *inp != '\0'; inp++)
1772 else if (*inp == '-')
1778 /* Standard boilerplate. */
1779 printf_unfiltered ("/* THIS FILE IS GENERATED. "
1780 "-*- buffer-read-only: t -*- vi"
1789 void visit_pre (const target_desc *e) override
1791 printf_unfiltered (" Original: %s */\n\n",
1792 lbasename (m_filename_after_features.c_str ()));
1794 printf_unfiltered ("#include \"defs.h\"\n");
1795 printf_unfiltered ("#include \"osabi.h\"\n");
1796 printf_unfiltered ("#include \"target-descriptions.h\"\n");
1797 printf_unfiltered ("\n");
1799 printf_unfiltered ("struct target_desc *tdesc_%s;\n", m_function);
1800 printf_unfiltered ("static void\n");
1801 printf_unfiltered ("initialize_tdesc_%s (void)\n", m_function);
1802 printf_unfiltered ("{\n");
1804 (" struct target_desc *result = allocate_target_description ();\n");
1806 if (tdesc_architecture (e) != NULL)
1809 (" set_tdesc_architecture (result, bfd_scan_arch (\"%s\"));\n",
1810 tdesc_architecture (e)->printable_name);
1811 printf_unfiltered ("\n");
1813 if (tdesc_osabi (e) > GDB_OSABI_UNKNOWN
1814 && tdesc_osabi (e) < GDB_OSABI_INVALID)
1817 (" set_tdesc_osabi (result, osabi_from_tdesc_string (\"%s\"));\n",
1818 gdbarch_osabi_name (tdesc_osabi (e)));
1819 printf_unfiltered ("\n");
1822 for (const struct bfd_arch_info *compatible : e->compatible)
1824 (" tdesc_add_compatible (result, bfd_scan_arch (\"%s\"));\n",
1825 compatible->printable_name);
1827 if (!e->compatible.empty ())
1828 printf_unfiltered ("\n");
1830 for (const property &prop : e->properties)
1831 printf_unfiltered (" set_tdesc_property (result, \"%s\", \"%s\");\n",
1832 prop.key.c_str (), prop.value.c_str ());
1834 printf_unfiltered (" struct tdesc_feature *feature;\n");
1837 void visit_pre (const tdesc_feature *e) override
1839 printf_unfiltered ("\n feature = tdesc_create_feature (result, \"%s\");\n",
1843 void visit_post (const tdesc_feature *e) override
1846 void visit_post (const target_desc *e) override
1848 printf_unfiltered ("\n tdesc_%s = result;\n", m_function);
1849 printf_unfiltered ("}\n");
1852 void visit (const tdesc_type *type) override
1854 /* Now we do some "filtering" in order to know which variables to
1855 declare. This is needed because otherwise we would declare unused
1856 variables `field_type' and `type'. */
1857 if (!m_printed_field_type)
1859 printf_unfiltered (" struct tdesc_type *field_type;\n");
1860 m_printed_field_type = true;
1863 if ((type->kind == TDESC_TYPE_UNION
1864 || type->kind == TDESC_TYPE_STRUCT
1865 || type->kind == TDESC_TYPE_FLAGS
1866 || type->kind == TDESC_TYPE_ENUM)
1867 && !type->u.u.fields->empty ()
1870 printf_unfiltered (" struct tdesc_type *type;\n");
1871 m_printed_type = true;
1876 case TDESC_TYPE_VECTOR:
1878 (" field_type = tdesc_named_type (feature, \"%s\");\n",
1879 type->u.v.type->name.c_str ());
1881 (" tdesc_create_vector (feature, \"%s\", field_type, %d);\n",
1882 type->name.c_str (), type->u.v.count);
1884 case TDESC_TYPE_STRUCT:
1885 case TDESC_TYPE_FLAGS:
1886 if (type->kind == TDESC_TYPE_STRUCT)
1889 (" type = tdesc_create_struct (feature, \"%s\");\n",
1890 type->name.c_str ());
1891 if (type->u.u.size != 0)
1893 (" tdesc_set_struct_size (type, %d);\n",
1899 (" type = tdesc_create_flags (feature, \"%s\", %d);\n",
1900 type->name.c_str (), type->u.u.size);
1902 for (const tdesc_type_field &f : *type->u.u.fields)
1904 const char *type_name;
1906 gdb_assert (f.type != NULL);
1907 type_name = f.type->name.c_str ();
1909 /* To minimize changes to generated files, don't emit type
1910 info for fields that have defaulted types. */
1913 gdb_assert (f.end != -1);
1914 if (f.type->kind == TDESC_TYPE_BOOL)
1916 gdb_assert (f.start == f.end);
1918 (" tdesc_add_flag (type, %d, \"%s\");\n",
1919 f.start, f.name.c_str ());
1921 else if ((type->u.u.size == 4
1922 && f.type->kind == TDESC_TYPE_UINT32)
1923 || (type->u.u.size == 8
1924 && f.type->kind == TDESC_TYPE_UINT64))
1927 (" tdesc_add_bitfield (type, \"%s\", %d, %d);\n",
1928 f.name.c_str (), f.start, f.end);
1933 (" field_type = tdesc_named_type (feature,"
1937 (" tdesc_add_typed_bitfield (type, \"%s\","
1938 " %d, %d, field_type);\n",
1939 f.name.c_str (), f.start, f.end);
1942 else /* Not a bitfield. */
1944 gdb_assert (f.end == -1);
1945 gdb_assert (type->kind == TDESC_TYPE_STRUCT);
1947 (" field_type = tdesc_named_type (feature,"
1951 (" tdesc_add_field (type, \"%s\", field_type);\n",
1956 case TDESC_TYPE_UNION:
1958 (" type = tdesc_create_union (feature, \"%s\");\n",
1959 type->name.c_str ());
1960 for (const tdesc_type_field &f : *type->u.u.fields)
1963 (" field_type = tdesc_named_type (feature, \"%s\");\n",
1964 f.type->name.c_str ());
1966 (" tdesc_add_field (type, \"%s\", field_type);\n",
1970 case TDESC_TYPE_ENUM:
1972 (" type = tdesc_create_enum (feature, \"%s\", %d);\n",
1973 type->name.c_str (), type->u.u.size);
1974 for (const tdesc_type_field &f : *type->u.u.fields)
1976 (" tdesc_add_enum_value (type, %d, \"%s\");\n",
1977 f.start, f.name.c_str ());
1980 error (_("C output is not supported type \"%s\"."), type->name.c_str ());
1982 printf_unfiltered ("\n");
1985 void visit (const tdesc_reg *reg) override
1987 printf_unfiltered (" tdesc_create_reg (feature, \"%s\", %ld, %d, ",
1988 reg->name.c_str (), reg->target_regnum,
1990 if (!reg->group.empty ())
1991 printf_unfiltered ("\"%s\", ", reg->group.c_str ());
1993 printf_unfiltered ("NULL, ");
1994 printf_unfiltered ("%d, \"%s\");\n", reg->bitsize, reg->type.c_str ());
1998 std::string m_filename_after_features;
2002 bool m_printed_field_type = false;
2003 bool m_printed_type = false;
2006 /* Print target description feature in C. */
2008 class print_c_feature : public print_c_tdesc
2011 print_c_feature (std::string &file)
2012 : print_c_tdesc (file)
2015 auto const pos = m_filename_after_features.find_last_of ('.');
2017 m_filename_after_features = m_filename_after_features.substr (0, pos);
2020 void visit_pre (const target_desc *e) override
2022 printf_unfiltered (" Original: %s */\n\n",
2023 lbasename (m_filename_after_features.c_str ()));
2025 printf_unfiltered ("#include \"arch/tdesc.h\"\n");
2026 printf_unfiltered ("\n");
2029 void visit_post (const target_desc *e) override
2032 void visit_pre (const tdesc_feature *e) override
2034 std::string name (m_filename_after_features);
2036 auto pos = name.find_first_of ('.');
2038 name = name.substr (0, pos);
2039 std::replace (name.begin (), name.end (), '/', '_');
2040 std::replace (name.begin (), name.end (), '-', '_');
2042 printf_unfiltered ("static int\n");
2043 printf_unfiltered ("create_feature_%s ", name.c_str ());
2044 printf_unfiltered ("(struct target_desc *result, long regnum)\n");
2046 printf_unfiltered ("{\n");
2047 printf_unfiltered (" struct tdesc_feature *feature;\n");
2050 ("\n feature = tdesc_create_feature (result, \"%s\", \"%s\");\n",
2051 e->name.c_str (), lbasename (m_filename_after_features.c_str ()));
2054 void visit_post (const tdesc_feature *e) override
2056 printf_unfiltered (" return regnum;\n");
2057 printf_unfiltered ("}\n");
2060 void visit (const tdesc_reg *reg) override
2062 /* Most "reg" in XML target descriptions don't have "regnum"
2063 attribute, so the register number is allocated sequentially.
2064 In case that reg has "regnum" attribute, register number
2065 should be set by that explicitly. */
2067 if (reg->target_regnum < m_next_regnum)
2069 /* The integrity check, it can catch some errors on register
2070 number collision, like this,
2072 <reg name="x0" bitsize="32"/>
2073 <reg name="x1" bitsize="32"/>
2074 <reg name="x2" bitsize="32"/>
2075 <reg name="x3" bitsize="32"/>
2076 <reg name="ps" bitsize="32" regnum="3"/>
2078 but it also has false negatives. The target description
2081 <reg name="x1" bitsize="32" regnum="1"/>
2082 <reg name="x3" bitsize="32" regnum="3"/>
2083 <reg name="x2" bitsize="32" regnum="2"/>
2084 <reg name="x4" bitsize="32" regnum="4"/>
2086 but it is not a good practice, so still error on this,
2087 and also print the message so that it can be saved in the
2088 generated c file. */
2090 printf_unfiltered ("ERROR: \"regnum\" attribute %ld ",
2091 reg->target_regnum);
2092 printf_unfiltered ("is not the largest number (%d).\n",
2094 error (_("\"regnum\" attribute %ld is not the largest number (%d)."),
2095 reg->target_regnum, m_next_regnum);
2098 if (reg->target_regnum > m_next_regnum)
2100 printf_unfiltered (" regnum = %ld;\n", reg->target_regnum);
2101 m_next_regnum = reg->target_regnum;
2104 printf_unfiltered (" tdesc_create_reg (feature, \"%s\", regnum++, %d, ",
2105 reg->name.c_str (), reg->save_restore);
2106 if (!reg->group.empty ())
2107 printf_unfiltered ("\"%s\", ", reg->group.c_str ());
2109 printf_unfiltered ("NULL, ");
2110 printf_unfiltered ("%d, \"%s\");\n", reg->bitsize, reg->type.c_str ());
2116 /* The register number to use for the next register we see. */
2117 int m_next_regnum = 0;
2121 maint_print_c_tdesc_cmd (const char *args, int from_tty)
2123 const struct target_desc *tdesc;
2124 const char *filename;
2128 /* Use the global target-supplied description, not the current
2129 architecture's. This lets a GDB for one architecture generate C
2130 for another architecture's description, even though the gdbarch
2131 initialization code will reject the new description. */
2132 tdesc = current_target_desc;
2133 filename = target_description_filename;
2137 /* Use the target description from the XML file. */
2139 tdesc = file_read_description_xml (filename);
2143 error (_("There is no target description to print."));
2145 if (filename == NULL)
2146 error (_("The current target description did not come from an XML file."));
2148 std::string filename_after_features (filename);
2149 auto loc = filename_after_features.rfind ("/features/");
2151 if (loc != std::string::npos)
2152 filename_after_features = filename_after_features.substr (loc + 10);
2154 /* Print c files for target features instead of target descriptions,
2155 because c files got from target features are more flexible than the
2157 if (startswith (filename_after_features.c_str (), "i386/32bit-")
2158 || startswith (filename_after_features.c_str (), "i386/64bit-")
2159 || startswith (filename_after_features.c_str (), "i386/x32-core.xml")
2160 || startswith (filename_after_features.c_str (), "tic6x-")
2161 || startswith (filename_after_features.c_str (), "aarch64"))
2163 print_c_feature v (filename_after_features);
2169 print_c_tdesc v (filename_after_features);
2175 namespace selftests {
2177 static std::vector<std::pair<const char*, const target_desc *>> xml_tdesc;
2181 /* See target-descritpions.h. */
2184 record_xml_tdesc (const char *xml_file, const struct target_desc *tdesc)
2186 xml_tdesc.emplace_back (xml_file, tdesc);
2192 /* Check that the target descriptions created dynamically by
2193 architecture-specific code equal the descriptions created from XML files
2194 found in the specified directory DIR. */
2197 maintenance_check_xml_descriptions (const char *dir, int from_tty)
2200 error (_("Missing dir name"));
2202 gdb::unique_xmalloc_ptr<char> dir1 (tilde_expand (dir));
2203 std::string feature_dir (dir1.get ());
2204 unsigned int failed = 0;
2206 for (auto const &e : selftests::xml_tdesc)
2208 std::string tdesc_xml = (feature_dir + SLASH_STRING + e.first);
2209 const target_desc *tdesc
2210 = file_read_description_xml (tdesc_xml.data ());
2212 if (tdesc == NULL || *tdesc != *e.second)
2215 printf_filtered (_("Tested %lu XML files, %d failed\n"),
2216 (long) selftests::xml_tdesc.size (), failed);
2220 _initialize_target_descriptions (void)
2222 tdesc_data = gdbarch_data_register_pre_init (tdesc_data_init);
2224 add_prefix_cmd ("tdesc", class_maintenance, set_tdesc_cmd, _("\
2225 Set target description specific variables."),
2226 &tdesc_set_cmdlist, "set tdesc ",
2227 0 /* allow-unknown */, &setlist);
2228 add_prefix_cmd ("tdesc", class_maintenance, show_tdesc_cmd, _("\
2229 Show target description specific variables."),
2230 &tdesc_show_cmdlist, "show tdesc ",
2231 0 /* allow-unknown */, &showlist);
2232 add_prefix_cmd ("tdesc", class_maintenance, unset_tdesc_cmd, _("\
2233 Unset target description specific variables."),
2234 &tdesc_unset_cmdlist, "unset tdesc ",
2235 0 /* allow-unknown */, &unsetlist);
2237 add_setshow_filename_cmd ("filename", class_obscure,
2238 &tdesc_filename_cmd_string,
2240 Set the file to read for an XML target description"), _("\
2241 Show the file to read for an XML target description"), _("\
2242 When set, GDB will read the target description from a local\n\
2243 file instead of querying the remote target."),
2244 set_tdesc_filename_cmd,
2245 show_tdesc_filename_cmd,
2246 &tdesc_set_cmdlist, &tdesc_show_cmdlist);
2248 add_cmd ("filename", class_obscure, unset_tdesc_filename_cmd, _("\
2249 Unset the file to read for an XML target description. When unset,\n\
2250 GDB will read the description from the target."),
2251 &tdesc_unset_cmdlist);
2253 add_cmd ("c-tdesc", class_maintenance, maint_print_c_tdesc_cmd, _("\
2254 Print the current target description as a C source file."),
2255 &maintenanceprintlist);
2257 cmd_list_element *cmd;
2259 cmd = add_cmd ("xml-descriptions", class_maintenance,
2260 maintenance_check_xml_descriptions, _("\
2261 Check the target descriptions created in GDB equal the descriptions\n\
2262 created from XML files in the directory.\n\
2263 The parameter is the directory name."),
2264 &maintenancechecklist);
2265 set_cmd_completer (cmd, filename_completer);