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 typedef struct tdesc_reg
: tdesc_element
78 tdesc_reg (struct tdesc_feature
*feature
, const char *name_
,
79 int regnum
, int save_restore_
, const char *group_
,
80 int bitsize_
, const char *type_
)
81 : name (xstrdup (name_
)), target_regnum (regnum
),
82 save_restore (save_restore_
),
83 group (group_
!= NULL
? xstrdup (group_
) : NULL
),
85 type (type_
!= NULL
? xstrdup (type_
) : xstrdup ("<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
);
99 DISABLE_COPY_AND_ASSIGN (tdesc_reg
);
101 /* The name of this register. In standard features, it may be
102 recognized by the architecture support code, or it may be purely
106 /* The register number used by this target to refer to this
107 register. This is used for remote p/P packets and to determine
108 the ordering of registers in the remote g/G packets. */
111 /* If this flag is set, GDB should save and restore this register
112 around calls to an inferior function. */
115 /* The name of the register group containing this register, or NULL
116 if the group should be automatically determined from the
117 register's type. If this is "general", "float", or "vector", the
118 corresponding "info" command should display this register's
119 value. It can be an arbitrary string, but should be limited to
120 alphanumeric characters and internal hyphens. Currently other
121 strings are ignored (treated as NULL). */
124 /* The size of the register, in bits. */
127 /* The type of the register. This string corresponds to either
128 a named type from the target description or a predefined
132 /* The target-described type corresponding to TYPE, if found. */
133 struct tdesc_type
*tdesc_type
;
135 void accept (tdesc_element_visitor
&v
) const override
140 bool operator== (const tdesc_reg
&other
) const
142 return (streq (name
, other
.name
)
143 && target_regnum
== other
.target_regnum
144 && save_restore
== other
.save_restore
145 && bitsize
== other
.bitsize
146 && (group
== other
.group
|| streq (group
, other
.group
))
147 && streq (type
, other
.type
));
150 bool operator!= (const tdesc_reg
&other
) const
152 return !(*this == other
);
155 DEF_VEC_P(tdesc_reg_p
);
157 /* A named type from a target description. */
159 typedef struct tdesc_type_field
162 struct tdesc_type
*type
;
163 /* For non-enum-values, either both are -1 (non-bitfield), or both are
164 not -1 (bitfield). For enum values, start is the value (which could be
168 DEF_VEC_O(tdesc_type_field
);
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 typedef struct tdesc_type
: tdesc_element
201 tdesc_type (const char *name_
, enum tdesc_type_kind kind_
)
202 : name (xstrdup (name_
)), kind (kind_
)
204 memset (&u
, 0, sizeof (u
));
207 virtual ~tdesc_type ()
211 case TDESC_TYPE_STRUCT
:
212 case TDESC_TYPE_UNION
:
213 case TDESC_TYPE_FLAGS
:
214 case TDESC_TYPE_ENUM
:
216 struct tdesc_type_field
*f
;
220 VEC_iterate (tdesc_type_field
, u
.u
.fields
, ix
, f
);
224 VEC_free (tdesc_type_field
, u
.u
.fields
);
231 xfree ((char *) name
);
234 DISABLE_COPY_AND_ASSIGN (tdesc_type
);
236 /* The name of this type. If this type is a built-in type, this is
237 a pointer to a constant string. Otherwise, it's a
238 malloc-allocated string (and thus must be freed). */
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 VEC(tdesc_type_field
) *fields
;
262 void accept (tdesc_element_visitor
&v
) const override
267 bool operator== (const tdesc_type
&other
) const
269 return (streq (name
, other
.name
) && kind
== other
.kind
);
272 bool operator!= (const tdesc_type
&other
) const
274 return !(*this == other
);
277 DEF_VEC_P(tdesc_type_p
);
279 /* A feature from a target description. Each feature is a collection
280 of other elements, e.g. registers and types. */
282 struct tdesc_feature
: tdesc_element
284 tdesc_feature (const char *name_
)
285 : name (xstrdup (name_
))
288 virtual ~tdesc_feature ()
290 struct tdesc_reg
*reg
;
291 struct tdesc_type
*type
;
294 for (ix
= 0; VEC_iterate (tdesc_reg_p
, registers
, ix
, reg
); ix
++)
296 VEC_free (tdesc_reg_p
, registers
);
298 for (ix
= 0; VEC_iterate (tdesc_type_p
, types
, ix
, type
); ix
++)
300 VEC_free (tdesc_type_p
, types
);
305 DISABLE_COPY_AND_ASSIGN (tdesc_feature
);
307 /* The name of this feature. It may be recognized by the architecture
311 /* The registers associated with this feature. */
312 VEC(tdesc_reg_p
) *registers
= NULL
;
314 /* The types associated with this feature. */
315 VEC(tdesc_type_p
) *types
= NULL
;
317 void accept (tdesc_element_visitor
&v
) const override
321 struct tdesc_type
*type
;
324 VEC_iterate (tdesc_type_p
, types
, ix
, type
);
328 struct tdesc_reg
*reg
;
331 VEC_iterate (tdesc_reg_p
, registers
, ix
, reg
);
339 bool operator== (const tdesc_feature
&other
) const
341 if (strcmp (name
, other
.name
) != 0)
344 if (VEC_length (tdesc_reg_p
, registers
)
345 != VEC_length (tdesc_reg_p
, other
.registers
))
348 struct tdesc_reg
*reg
;
351 VEC_iterate (tdesc_reg_p
, registers
, ix
, reg
);
355 = VEC_index (tdesc_reg_p
, other
.registers
, ix
);
357 if (reg
!= reg2
&& *reg
!= *reg2
)
361 if (VEC_length (tdesc_type_p
, types
)
362 != VEC_length (tdesc_type_p
, other
.types
))
368 VEC_iterate (tdesc_type_p
, types
, ix
, type
);
372 = VEC_index (tdesc_type_p
, other
.types
, ix
);
374 if (type
!= type2
&& *type
!= *type2
)
381 bool operator!= (const tdesc_feature
&other
) const
383 return !(*this == other
);
388 typedef std::unique_ptr
<tdesc_feature
> tdesc_feature_up
;
390 /* A target description. */
392 struct target_desc
: tdesc_element
397 virtual ~target_desc () = default;
399 target_desc (const target_desc
&) = delete;
400 void operator= (const target_desc
&) = delete;
402 /* The architecture reported by the target, if any. */
403 const struct bfd_arch_info
*arch
= NULL
;
405 /* The osabi reported by the target, if any; GDB_OSABI_UNKNOWN
407 enum gdb_osabi osabi
= GDB_OSABI_UNKNOWN
;
409 /* The list of compatible architectures reported by the target. */
410 std::vector
<const bfd_arch_info
*> compatible
;
412 /* Any architecture-specific properties specified by the target. */
413 std::vector
<property
> properties
;
415 /* The features associated with this target. */
416 std::vector
<std::unique_ptr
<tdesc_feature
>> features
;
418 void accept (tdesc_element_visitor
&v
) const override
422 for (const tdesc_feature_up
&feature
: features
)
428 bool operator== (const target_desc
&other
) const
430 if (arch
!= other
.arch
)
433 if (osabi
!= other
.osabi
)
436 if (features
.size () != other
.features
.size ())
439 for (int ix
= 0; ix
< features
.size (); ix
++)
441 const tdesc_feature_up
&feature1
= features
[ix
];
442 const tdesc_feature_up
&feature2
= other
.features
[ix
];
444 if (feature1
!= feature2
&& *feature1
!= *feature2
)
451 bool operator!= (const target_desc
&other
) const
453 return !(*this == other
);
457 /* Per-architecture data associated with a target description. The
458 target description may be shared by multiple architectures, but
459 this data is private to one gdbarch. */
461 typedef struct tdesc_arch_reg
463 struct tdesc_reg
*reg
;
466 DEF_VEC_O(tdesc_arch_reg
);
468 struct tdesc_arch_data
470 /* A list of register/type pairs, indexed by GDB's internal register number.
471 During initialization of the gdbarch this list is used to store
472 registers which the architecture assigns a fixed register number.
473 Registers which are NULL in this array, or off the end, are
474 treated as zero-sized and nameless (i.e. placeholders in the
476 VEC(tdesc_arch_reg
) *arch_regs
;
478 /* Functions which report the register name, type, and reggroups for
480 gdbarch_register_name_ftype
*pseudo_register_name
;
481 gdbarch_register_type_ftype
*pseudo_register_type
;
482 gdbarch_register_reggroup_p_ftype
*pseudo_register_reggroup_p
;
485 /* Info about an inferior's target description. There's one of these
486 for each inferior. */
488 struct target_desc_info
490 /* A flag indicating that a description has already been fetched
491 from the target, so it should not be queried again. */
495 /* The description fetched from the target, or NULL if the target
496 did not supply any description. Only valid when
497 target_desc_fetched is set. Only the description initialization
498 code should access this; normally, the description should be
499 accessed through the gdbarch object. */
501 const struct target_desc
*tdesc
;
503 /* The filename to read a target description from, as set by "set
504 tdesc filename ..." */
509 /* Get the inferior INF's target description info, allocating one on
510 the stop if necessary. */
512 static struct target_desc_info
*
513 get_tdesc_info (struct inferior
*inf
)
515 if (inf
->tdesc_info
== NULL
)
516 inf
->tdesc_info
= XCNEW (struct target_desc_info
);
517 return inf
->tdesc_info
;
520 /* A handle for architecture-specific data associated with the
521 target description (see struct tdesc_arch_data). */
523 static struct gdbarch_data
*tdesc_data
;
525 /* See target-descriptions.h. */
528 target_desc_info_from_user_p (struct target_desc_info
*info
)
530 return info
!= NULL
&& info
->filename
!= NULL
;
533 /* See target-descriptions.h. */
536 copy_inferior_target_desc_info (struct inferior
*destinf
, struct inferior
*srcinf
)
538 struct target_desc_info
*src
= get_tdesc_info (srcinf
);
539 struct target_desc_info
*dest
= get_tdesc_info (destinf
);
541 dest
->fetched
= src
->fetched
;
542 dest
->tdesc
= src
->tdesc
;
543 dest
->filename
= src
->filename
!= NULL
? xstrdup (src
->filename
) : NULL
;
546 /* See target-descriptions.h. */
549 target_desc_info_free (struct target_desc_info
*tdesc_info
)
551 if (tdesc_info
!= NULL
)
553 xfree (tdesc_info
->filename
);
558 /* Convenience helper macros. */
560 #define target_desc_fetched \
561 get_tdesc_info (current_inferior ())->fetched
562 #define current_target_desc \
563 get_tdesc_info (current_inferior ())->tdesc
564 #define target_description_filename \
565 get_tdesc_info (current_inferior ())->filename
567 /* The string manipulated by the "set tdesc filename ..." command. */
569 static char *tdesc_filename_cmd_string
;
571 /* Fetch the current target's description, and switch the current
572 architecture to one which incorporates that description. */
575 target_find_description (void)
577 /* If we've already fetched a description from the target, don't do
578 it again. This allows a target to fetch the description early,
579 during its to_open or to_create_inferior, if it needs extra
580 information about the target to initialize. */
581 if (target_desc_fetched
)
584 /* The current architecture should not have any target description
585 specified. It should have been cleared, e.g. when we
586 disconnected from the previous target. */
587 gdb_assert (gdbarch_target_desc (target_gdbarch ()) == NULL
);
589 /* First try to fetch an XML description from the user-specified
591 current_target_desc
= NULL
;
592 if (target_description_filename
!= NULL
593 && *target_description_filename
!= '\0')
595 = file_read_description_xml (target_description_filename
);
597 /* Next try to read the description from the current target using
599 if (current_target_desc
== NULL
)
600 current_target_desc
= target_read_description_xml (¤t_target
);
602 /* If that failed try a target-specific hook. */
603 if (current_target_desc
== NULL
)
604 current_target_desc
= target_read_description (¤t_target
);
606 /* If a non-NULL description was returned, then update the current
608 if (current_target_desc
)
610 struct gdbarch_info info
;
612 gdbarch_info_init (&info
);
613 info
.target_desc
= current_target_desc
;
614 if (!gdbarch_update_p (info
))
615 warning (_("Architecture rejected target-supplied description"));
618 struct tdesc_arch_data
*data
;
620 data
= ((struct tdesc_arch_data
*)
621 gdbarch_data (target_gdbarch (), tdesc_data
));
622 if (tdesc_has_registers (current_target_desc
)
623 && data
->arch_regs
== NULL
)
624 warning (_("Target-supplied registers are not supported "
625 "by the current architecture"));
629 /* Now that we know this description is usable, record that we
631 target_desc_fetched
= 1;
634 /* Discard any description fetched from the current target, and switch
635 the current architecture to one with no target description. */
638 target_clear_description (void)
640 struct gdbarch_info info
;
642 if (!target_desc_fetched
)
645 target_desc_fetched
= 0;
646 current_target_desc
= NULL
;
648 gdbarch_info_init (&info
);
649 if (!gdbarch_update_p (info
))
650 internal_error (__FILE__
, __LINE__
,
651 _("Could not remove target-supplied description"));
654 /* Return the global current target description. This should only be
655 used by gdbarch initialization code; most access should be through
656 an existing gdbarch. */
658 const struct target_desc
*
659 target_current_description (void)
661 if (target_desc_fetched
)
662 return current_target_desc
;
667 /* Return non-zero if this target description is compatible
668 with the given BFD architecture. */
671 tdesc_compatible_p (const struct target_desc
*target_desc
,
672 const struct bfd_arch_info
*arch
)
674 for (const bfd_arch_info
*compat
: target_desc
->compatible
)
677 || arch
->compatible (arch
, compat
)
678 || compat
->compatible (compat
, arch
))
686 /* Direct accessors for target descriptions. */
688 /* Return the string value of a property named KEY, or NULL if the
689 property was not specified. */
692 tdesc_property (const struct target_desc
*target_desc
, const char *key
)
694 for (const property
&prop
: target_desc
->properties
)
696 return prop
.value
.c_str ();
701 /* Return the BFD architecture associated with this target
702 description, or NULL if no architecture was specified. */
704 const struct bfd_arch_info
*
705 tdesc_architecture (const struct target_desc
*target_desc
)
707 return target_desc
->arch
;
710 /* Return the OSABI associated with this target description, or
711 GDB_OSABI_UNKNOWN if no osabi was specified. */
714 tdesc_osabi (const struct target_desc
*target_desc
)
716 return target_desc
->osabi
;
721 /* Return 1 if this target description includes any registers. */
724 tdesc_has_registers (const struct target_desc
*target_desc
)
726 if (target_desc
== NULL
)
729 for (const tdesc_feature_up
&feature
: target_desc
->features
)
730 if (! VEC_empty (tdesc_reg_p
, feature
->registers
))
736 /* Return the feature with the given name, if present, or NULL if
737 the named feature is not found. */
739 const struct tdesc_feature
*
740 tdesc_find_feature (const struct target_desc
*target_desc
,
743 for (const tdesc_feature_up
&feature
: target_desc
->features
)
744 if (strcmp (feature
->name
, name
) == 0)
745 return feature
.get ();
750 /* Return the name of FEATURE. */
753 tdesc_feature_name (const struct tdesc_feature
*feature
)
755 return feature
->name
;
758 /* Predefined types. */
759 static struct tdesc_type tdesc_predefined_types
[] =
761 { "bool", TDESC_TYPE_BOOL
},
762 { "int8", TDESC_TYPE_INT8
},
763 { "int16", TDESC_TYPE_INT16
},
764 { "int32", TDESC_TYPE_INT32
},
765 { "int64", TDESC_TYPE_INT64
},
766 { "int128", TDESC_TYPE_INT128
},
767 { "uint8", TDESC_TYPE_UINT8
},
768 { "uint16", TDESC_TYPE_UINT16
},
769 { "uint32", TDESC_TYPE_UINT32
},
770 { "uint64", TDESC_TYPE_UINT64
},
771 { "uint128", TDESC_TYPE_UINT128
},
772 { "code_ptr", TDESC_TYPE_CODE_PTR
},
773 { "data_ptr", TDESC_TYPE_DATA_PTR
},
774 { "ieee_single", TDESC_TYPE_IEEE_SINGLE
},
775 { "ieee_double", TDESC_TYPE_IEEE_DOUBLE
},
776 { "arm_fpa_ext", TDESC_TYPE_ARM_FPA_EXT
},
777 { "i387_ext", TDESC_TYPE_I387_EXT
}
780 /* Lookup a predefined type. */
782 static struct tdesc_type
*
783 tdesc_predefined_type (enum tdesc_type_kind kind
)
785 for (int ix
= 0; ix
< ARRAY_SIZE (tdesc_predefined_types
); ix
++)
786 if (tdesc_predefined_types
[ix
].kind
== kind
)
787 return &tdesc_predefined_types
[ix
];
789 gdb_assert_not_reached ("bad predefined tdesc type");
792 /* See arch/tdesc.h. */
795 tdesc_named_type (const struct tdesc_feature
*feature
, const char *id
)
798 struct tdesc_type
*type
;
800 /* First try target-defined types. */
801 for (ix
= 0; VEC_iterate (tdesc_type_p
, feature
->types
, ix
, type
); ix
++)
802 if (strcmp (type
->name
, id
) == 0)
805 /* Next try the predefined types. */
806 for (ix
= 0; ix
< ARRAY_SIZE (tdesc_predefined_types
); ix
++)
807 if (strcmp (tdesc_predefined_types
[ix
].name
, id
) == 0)
808 return &tdesc_predefined_types
[ix
];
813 /* Lookup type associated with ID. */
816 tdesc_find_type (struct gdbarch
*gdbarch
, const char *id
)
818 struct tdesc_arch_reg
*reg
;
819 struct tdesc_arch_data
*data
;
822 data
= (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
823 num_regs
= VEC_length (tdesc_arch_reg
, data
->arch_regs
);
824 for (i
= 0; i
< num_regs
; i
++)
826 reg
= VEC_index (tdesc_arch_reg
, data
->arch_regs
, i
);
828 && reg
->reg
->tdesc_type
830 && strcmp (id
, reg
->reg
->tdesc_type
->name
) == 0)
837 /* Construct, if necessary, and return the GDB type implementing target
838 type TDESC_TYPE for architecture GDBARCH. */
841 tdesc_gdb_type (struct gdbarch
*gdbarch
, struct tdesc_type
*tdesc_type
)
845 switch (tdesc_type
->kind
)
847 /* Predefined types. */
848 case TDESC_TYPE_BOOL
:
849 return builtin_type (gdbarch
)->builtin_bool
;
851 case TDESC_TYPE_INT8
:
852 return builtin_type (gdbarch
)->builtin_int8
;
854 case TDESC_TYPE_INT16
:
855 return builtin_type (gdbarch
)->builtin_int16
;
857 case TDESC_TYPE_INT32
:
858 return builtin_type (gdbarch
)->builtin_int32
;
860 case TDESC_TYPE_INT64
:
861 return builtin_type (gdbarch
)->builtin_int64
;
863 case TDESC_TYPE_INT128
:
864 return builtin_type (gdbarch
)->builtin_int128
;
866 case TDESC_TYPE_UINT8
:
867 return builtin_type (gdbarch
)->builtin_uint8
;
869 case TDESC_TYPE_UINT16
:
870 return builtin_type (gdbarch
)->builtin_uint16
;
872 case TDESC_TYPE_UINT32
:
873 return builtin_type (gdbarch
)->builtin_uint32
;
875 case TDESC_TYPE_UINT64
:
876 return builtin_type (gdbarch
)->builtin_uint64
;
878 case TDESC_TYPE_UINT128
:
879 return builtin_type (gdbarch
)->builtin_uint128
;
881 case TDESC_TYPE_CODE_PTR
:
882 return builtin_type (gdbarch
)->builtin_func_ptr
;
884 case TDESC_TYPE_DATA_PTR
:
885 return builtin_type (gdbarch
)->builtin_data_ptr
;
891 type
= tdesc_find_type (gdbarch
, tdesc_type
->name
);
895 switch (tdesc_type
->kind
)
897 case TDESC_TYPE_IEEE_SINGLE
:
898 return arch_float_type (gdbarch
, -1, "builtin_type_ieee_single",
899 floatformats_ieee_single
);
901 case TDESC_TYPE_IEEE_DOUBLE
:
902 return arch_float_type (gdbarch
, -1, "builtin_type_ieee_double",
903 floatformats_ieee_double
);
905 case TDESC_TYPE_ARM_FPA_EXT
:
906 return arch_float_type (gdbarch
, -1, "builtin_type_arm_ext",
907 floatformats_arm_ext
);
909 case TDESC_TYPE_I387_EXT
:
910 return arch_float_type (gdbarch
, -1, "builtin_type_i387_ext",
911 floatformats_i387_ext
);
913 /* Types defined by a target feature. */
914 case TDESC_TYPE_VECTOR
:
916 struct type
*type
, *field_type
;
918 field_type
= tdesc_gdb_type (gdbarch
, tdesc_type
->u
.v
.type
);
919 type
= init_vector_type (field_type
, tdesc_type
->u
.v
.count
);
920 TYPE_NAME (type
) = xstrdup (tdesc_type
->name
);
925 case TDESC_TYPE_STRUCT
:
927 struct type
*type
, *field_type
;
928 struct tdesc_type_field
*f
;
931 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_STRUCT
);
932 TYPE_NAME (type
) = xstrdup (tdesc_type
->name
);
933 TYPE_TAG_NAME (type
) = TYPE_NAME (type
);
936 VEC_iterate (tdesc_type_field
, tdesc_type
->u
.u
.fields
, ix
, f
);
939 if (f
->start
!= -1 && f
->end
!= -1)
943 struct type
*field_type
;
944 int bitsize
, total_size
;
946 /* This invariant should be preserved while creating types. */
947 gdb_assert (tdesc_type
->u
.u
.size
!= 0);
949 field_type
= tdesc_gdb_type (gdbarch
, f
->type
);
950 else if (tdesc_type
->u
.u
.size
> 4)
951 field_type
= builtin_type (gdbarch
)->builtin_uint64
;
953 field_type
= builtin_type (gdbarch
)->builtin_uint32
;
955 fld
= append_composite_type_field_raw (type
, xstrdup (f
->name
),
958 /* For little-endian, BITPOS counts from the LSB of
959 the structure and marks the LSB of the field. For
960 big-endian, BITPOS counts from the MSB of the
961 structure and marks the MSB of the field. Either
962 way, it is the number of bits to the "left" of the
963 field. To calculate this in big-endian, we need
964 the total size of the structure. */
965 bitsize
= f
->end
- f
->start
+ 1;
966 total_size
= tdesc_type
->u
.u
.size
* TARGET_CHAR_BIT
;
967 if (gdbarch_bits_big_endian (gdbarch
))
968 SET_FIELD_BITPOS (fld
[0], total_size
- f
->start
- bitsize
);
970 SET_FIELD_BITPOS (fld
[0], f
->start
);
971 FIELD_BITSIZE (fld
[0]) = bitsize
;
975 gdb_assert (f
->start
== -1 && f
->end
== -1);
976 field_type
= tdesc_gdb_type (gdbarch
, f
->type
);
977 append_composite_type_field (type
, xstrdup (f
->name
),
982 if (tdesc_type
->u
.u
.size
!= 0)
983 TYPE_LENGTH (type
) = tdesc_type
->u
.u
.size
;
987 case TDESC_TYPE_UNION
:
989 struct type
*type
, *field_type
;
990 struct tdesc_type_field
*f
;
993 type
= arch_composite_type (gdbarch
, NULL
, TYPE_CODE_UNION
);
994 TYPE_NAME (type
) = xstrdup (tdesc_type
->name
);
997 VEC_iterate (tdesc_type_field
, tdesc_type
->u
.u
.fields
, ix
, f
);
1000 field_type
= tdesc_gdb_type (gdbarch
, f
->type
);
1001 append_composite_type_field (type
, xstrdup (f
->name
), field_type
);
1003 /* If any of the children of a union are vectors, flag the
1004 union as a vector also. This allows e.g. a union of two
1005 vector types to show up automatically in "info vector". */
1006 if (TYPE_VECTOR (field_type
))
1007 TYPE_VECTOR (type
) = 1;
1012 case TDESC_TYPE_FLAGS
:
1014 struct tdesc_type_field
*f
;
1017 type
= arch_flags_type (gdbarch
, tdesc_type
->name
,
1018 tdesc_type
->u
.u
.size
* TARGET_CHAR_BIT
);
1020 VEC_iterate (tdesc_type_field
, tdesc_type
->u
.u
.fields
, ix
, f
);
1023 struct type
*field_type
;
1024 int bitsize
= f
->end
- f
->start
+ 1;
1026 gdb_assert (f
->type
!= NULL
);
1027 field_type
= tdesc_gdb_type (gdbarch
, f
->type
);
1028 append_flags_type_field (type
, f
->start
, bitsize
,
1029 field_type
, f
->name
);
1035 case TDESC_TYPE_ENUM
:
1037 struct tdesc_type_field
*f
;
1040 type
= arch_type (gdbarch
, TYPE_CODE_ENUM
,
1041 tdesc_type
->u
.u
.size
* TARGET_CHAR_BIT
,
1043 TYPE_UNSIGNED (type
) = 1;
1045 VEC_iterate (tdesc_type_field
, tdesc_type
->u
.u
.fields
, ix
, f
);
1049 = append_composite_type_field_raw (type
, xstrdup (f
->name
),
1052 SET_FIELD_BITPOS (fld
[0], f
->start
);
1059 internal_error (__FILE__
, __LINE__
,
1060 "Type \"%s\" has an unknown kind %d",
1061 tdesc_type
->name
, tdesc_type
->kind
);
1065 /* Support for registers from target descriptions. */
1067 /* Construct the per-gdbarch data. */
1070 tdesc_data_init (struct obstack
*obstack
)
1072 struct tdesc_arch_data
*data
;
1074 data
= OBSTACK_ZALLOC (obstack
, struct tdesc_arch_data
);
1078 /* Similar, but for the temporary copy used during architecture
1081 struct tdesc_arch_data
*
1082 tdesc_data_alloc (void)
1084 return XCNEW (struct tdesc_arch_data
);
1087 /* Free something allocated by tdesc_data_alloc, if it is not going
1088 to be used (for instance if it was unsuitable for the
1092 tdesc_data_cleanup (void *data_untyped
)
1094 struct tdesc_arch_data
*data
= (struct tdesc_arch_data
*) data_untyped
;
1096 VEC_free (tdesc_arch_reg
, data
->arch_regs
);
1100 /* Search FEATURE for a register named NAME. */
1102 static struct tdesc_reg
*
1103 tdesc_find_register_early (const struct tdesc_feature
*feature
,
1107 struct tdesc_reg
*reg
;
1110 VEC_iterate (tdesc_reg_p
, feature
->registers
, ixr
, reg
);
1112 if (strcasecmp (reg
->name
, name
) == 0)
1118 /* Search FEATURE for a register named NAME. Assign REGNO to it. */
1121 tdesc_numbered_register (const struct tdesc_feature
*feature
,
1122 struct tdesc_arch_data
*data
,
1123 int regno
, const char *name
)
1125 struct tdesc_arch_reg arch_reg
= { 0 };
1126 struct tdesc_reg
*reg
= tdesc_find_register_early (feature
, name
);
1131 /* Make sure the vector includes a REGNO'th element. */
1132 while (regno
>= VEC_length (tdesc_arch_reg
, data
->arch_regs
))
1133 VEC_safe_push (tdesc_arch_reg
, data
->arch_regs
, &arch_reg
);
1136 VEC_replace (tdesc_arch_reg
, data
->arch_regs
, regno
, &arch_reg
);
1140 /* Search FEATURE for a register named NAME, but do not assign a fixed
1141 register number to it. */
1144 tdesc_unnumbered_register (const struct tdesc_feature
*feature
,
1147 struct tdesc_reg
*reg
= tdesc_find_register_early (feature
, name
);
1155 /* Search FEATURE for a register whose name is in NAMES and assign
1159 tdesc_numbered_register_choices (const struct tdesc_feature
*feature
,
1160 struct tdesc_arch_data
*data
,
1161 int regno
, const char *const names
[])
1165 for (i
= 0; names
[i
] != NULL
; i
++)
1166 if (tdesc_numbered_register (feature
, data
, regno
, names
[i
]))
1172 /* Search FEATURE for a register named NAME, and return its size in
1173 bits. The register must exist. */
1176 tdesc_register_size (const struct tdesc_feature
*feature
,
1179 struct tdesc_reg
*reg
= tdesc_find_register_early (feature
, name
);
1181 gdb_assert (reg
!= NULL
);
1182 return reg
->bitsize
;
1185 /* Look up a register by its GDB internal register number. */
1187 static struct tdesc_arch_reg
*
1188 tdesc_find_arch_register (struct gdbarch
*gdbarch
, int regno
)
1190 struct tdesc_arch_data
*data
;
1192 data
= (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1193 if (regno
< VEC_length (tdesc_arch_reg
, data
->arch_regs
))
1194 return VEC_index (tdesc_arch_reg
, data
->arch_regs
, regno
);
1199 static struct tdesc_reg
*
1200 tdesc_find_register (struct gdbarch
*gdbarch
, int regno
)
1202 struct tdesc_arch_reg
*reg
= tdesc_find_arch_register (gdbarch
, regno
);
1204 return reg
? reg
->reg
: NULL
;
1207 /* Return the name of register REGNO, from the target description or
1208 from an architecture-provided pseudo_register_name method. */
1211 tdesc_register_name (struct gdbarch
*gdbarch
, int regno
)
1213 struct tdesc_reg
*reg
= tdesc_find_register (gdbarch
, regno
);
1214 int num_regs
= gdbarch_num_regs (gdbarch
);
1215 int num_pseudo_regs
= gdbarch_num_pseudo_regs (gdbarch
);
1220 if (regno
>= num_regs
&& regno
< num_regs
+ num_pseudo_regs
)
1222 struct tdesc_arch_data
*data
1223 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1225 gdb_assert (data
->pseudo_register_name
!= NULL
);
1226 return data
->pseudo_register_name (gdbarch
, regno
);
1233 tdesc_register_type (struct gdbarch
*gdbarch
, int regno
)
1235 struct tdesc_arch_reg
*arch_reg
= tdesc_find_arch_register (gdbarch
, regno
);
1236 struct tdesc_reg
*reg
= arch_reg
? arch_reg
->reg
: NULL
;
1237 int num_regs
= gdbarch_num_regs (gdbarch
);
1238 int num_pseudo_regs
= gdbarch_num_pseudo_regs (gdbarch
);
1240 if (reg
== NULL
&& regno
>= num_regs
&& regno
< num_regs
+ num_pseudo_regs
)
1242 struct tdesc_arch_data
*data
1243 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1245 gdb_assert (data
->pseudo_register_type
!= NULL
);
1246 return data
->pseudo_register_type (gdbarch
, regno
);
1250 /* Return "int0_t", since "void" has a misleading size of one. */
1251 return builtin_type (gdbarch
)->builtin_int0
;
1253 if (arch_reg
->type
== NULL
)
1255 /* First check for a predefined or target defined type. */
1256 if (reg
->tdesc_type
)
1257 arch_reg
->type
= tdesc_gdb_type (gdbarch
, reg
->tdesc_type
);
1259 /* Next try size-sensitive type shortcuts. */
1260 else if (strcmp (reg
->type
, "float") == 0)
1262 if (reg
->bitsize
== gdbarch_float_bit (gdbarch
))
1263 arch_reg
->type
= builtin_type (gdbarch
)->builtin_float
;
1264 else if (reg
->bitsize
== gdbarch_double_bit (gdbarch
))
1265 arch_reg
->type
= builtin_type (gdbarch
)->builtin_double
;
1266 else if (reg
->bitsize
== gdbarch_long_double_bit (gdbarch
))
1267 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long_double
;
1270 warning (_("Register \"%s\" has an unsupported size (%d bits)"),
1271 reg
->name
, reg
->bitsize
);
1272 arch_reg
->type
= builtin_type (gdbarch
)->builtin_double
;
1275 else if (strcmp (reg
->type
, "int") == 0)
1277 if (reg
->bitsize
== gdbarch_long_bit (gdbarch
))
1278 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long
;
1279 else if (reg
->bitsize
== TARGET_CHAR_BIT
)
1280 arch_reg
->type
= builtin_type (gdbarch
)->builtin_char
;
1281 else if (reg
->bitsize
== gdbarch_short_bit (gdbarch
))
1282 arch_reg
->type
= builtin_type (gdbarch
)->builtin_short
;
1283 else if (reg
->bitsize
== gdbarch_int_bit (gdbarch
))
1284 arch_reg
->type
= builtin_type (gdbarch
)->builtin_int
;
1285 else if (reg
->bitsize
== gdbarch_long_long_bit (gdbarch
))
1286 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long_long
;
1287 else if (reg
->bitsize
== gdbarch_ptr_bit (gdbarch
))
1288 /* A bit desperate by this point... */
1289 arch_reg
->type
= builtin_type (gdbarch
)->builtin_data_ptr
;
1292 warning (_("Register \"%s\" has an unsupported size (%d bits)"),
1293 reg
->name
, reg
->bitsize
);
1294 arch_reg
->type
= builtin_type (gdbarch
)->builtin_long
;
1298 if (arch_reg
->type
== NULL
)
1299 internal_error (__FILE__
, __LINE__
,
1300 "Register \"%s\" has an unknown type \"%s\"",
1301 reg
->name
, reg
->type
);
1304 return arch_reg
->type
;
1308 tdesc_remote_register_number (struct gdbarch
*gdbarch
, int regno
)
1310 struct tdesc_reg
*reg
= tdesc_find_register (gdbarch
, regno
);
1313 return reg
->target_regnum
;
1318 /* Check whether REGNUM is a member of REGGROUP. Registers from the
1319 target description may be classified as general, float, or vector.
1320 Unlike a gdbarch register_reggroup_p method, this function will
1321 return -1 if it does not know; the caller should handle registers
1322 with no specified group.
1324 Arbitrary strings (other than "general", "float", and "vector")
1325 from the description are not used; they cause the register to be
1326 displayed in "info all-registers" but excluded from "info
1327 registers" et al. The names of containing features are also not
1328 used. This might be extended to display registers in some more
1331 The save-restore flag is also implemented here. */
1334 tdesc_register_in_reggroup_p (struct gdbarch
*gdbarch
, int regno
,
1335 struct reggroup
*reggroup
)
1337 struct tdesc_reg
*reg
= tdesc_find_register (gdbarch
, regno
);
1339 if (reg
!= NULL
&& reg
->group
!= NULL
)
1341 int general_p
= 0, float_p
= 0, vector_p
= 0;
1343 if (strcmp (reg
->group
, "general") == 0)
1345 else if (strcmp (reg
->group
, "float") == 0)
1347 else if (strcmp (reg
->group
, "vector") == 0)
1350 if (reggroup
== float_reggroup
)
1353 if (reggroup
== vector_reggroup
)
1356 if (reggroup
== general_reggroup
)
1361 && (reggroup
== save_reggroup
|| reggroup
== restore_reggroup
))
1362 return reg
->save_restore
;
1367 /* Check whether REGNUM is a member of REGGROUP. Registers with no
1368 group specified go to the default reggroup function and are handled
1372 tdesc_register_reggroup_p (struct gdbarch
*gdbarch
, int regno
,
1373 struct reggroup
*reggroup
)
1375 int num_regs
= gdbarch_num_regs (gdbarch
);
1376 int num_pseudo_regs
= gdbarch_num_pseudo_regs (gdbarch
);
1379 if (regno
>= num_regs
&& regno
< num_regs
+ num_pseudo_regs
)
1381 struct tdesc_arch_data
*data
1382 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1384 if (data
->pseudo_register_reggroup_p
!= NULL
)
1385 return data
->pseudo_register_reggroup_p (gdbarch
, regno
, reggroup
);
1386 /* Otherwise fall through to the default reggroup_p. */
1389 ret
= tdesc_register_in_reggroup_p (gdbarch
, regno
, reggroup
);
1393 return default_register_reggroup_p (gdbarch
, regno
, reggroup
);
1396 /* Record architecture-specific functions to call for pseudo-register
1400 set_tdesc_pseudo_register_name (struct gdbarch
*gdbarch
,
1401 gdbarch_register_name_ftype
*pseudo_name
)
1403 struct tdesc_arch_data
*data
1404 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1406 data
->pseudo_register_name
= pseudo_name
;
1410 set_tdesc_pseudo_register_type (struct gdbarch
*gdbarch
,
1411 gdbarch_register_type_ftype
*pseudo_type
)
1413 struct tdesc_arch_data
*data
1414 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1416 data
->pseudo_register_type
= pseudo_type
;
1420 set_tdesc_pseudo_register_reggroup_p
1421 (struct gdbarch
*gdbarch
,
1422 gdbarch_register_reggroup_p_ftype
*pseudo_reggroup_p
)
1424 struct tdesc_arch_data
*data
1425 = (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1427 data
->pseudo_register_reggroup_p
= pseudo_reggroup_p
;
1430 /* Update GDBARCH to use the target description for registers. */
1433 tdesc_use_registers (struct gdbarch
*gdbarch
,
1434 const struct target_desc
*target_desc
,
1435 struct tdesc_arch_data
*early_data
)
1437 int num_regs
= gdbarch_num_regs (gdbarch
);
1439 struct tdesc_reg
*reg
;
1440 struct tdesc_arch_data
*data
;
1441 struct tdesc_arch_reg
*arch_reg
, new_arch_reg
= { 0 };
1444 /* We can't use the description for registers if it doesn't describe
1445 any. This function should only be called after validating
1446 registers, so the caller should know that registers are
1448 gdb_assert (tdesc_has_registers (target_desc
));
1450 data
= (struct tdesc_arch_data
*) gdbarch_data (gdbarch
, tdesc_data
);
1451 data
->arch_regs
= early_data
->arch_regs
;
1454 /* Build up a set of all registers, so that we can assign register
1455 numbers where needed. The hash table expands as necessary, so
1456 the initial size is arbitrary. */
1457 reg_hash
= htab_create (37, htab_hash_pointer
, htab_eq_pointer
, NULL
);
1458 for (const tdesc_feature_up
&feature
: target_desc
->features
)
1460 VEC_iterate (tdesc_reg_p
, feature
->registers
, ixr
, reg
);
1463 void **slot
= htab_find_slot (reg_hash
, reg
, INSERT
);
1468 /* Remove any registers which were assigned numbers by the
1471 VEC_iterate (tdesc_arch_reg
, data
->arch_regs
, ixr
, arch_reg
);
1474 htab_remove_elt (reg_hash
, arch_reg
->reg
);
1476 /* Assign numbers to the remaining registers and add them to the
1477 list of registers. The new numbers are always above gdbarch_num_regs.
1478 Iterate over the features, not the hash table, so that the order
1479 matches that in the target description. */
1481 gdb_assert (VEC_length (tdesc_arch_reg
, data
->arch_regs
) <= num_regs
);
1482 while (VEC_length (tdesc_arch_reg
, data
->arch_regs
) < num_regs
)
1483 VEC_safe_push (tdesc_arch_reg
, data
->arch_regs
, &new_arch_reg
);
1484 for (const tdesc_feature_up
&feature
: target_desc
->features
)
1486 VEC_iterate (tdesc_reg_p
, feature
->registers
, ixr
, reg
);
1488 if (htab_find (reg_hash
, reg
) != NULL
)
1490 new_arch_reg
.reg
= reg
;
1491 VEC_safe_push (tdesc_arch_reg
, data
->arch_regs
, &new_arch_reg
);
1495 htab_delete (reg_hash
);
1497 /* Update the architecture. */
1498 set_gdbarch_num_regs (gdbarch
, num_regs
);
1499 set_gdbarch_register_name (gdbarch
, tdesc_register_name
);
1500 set_gdbarch_register_type (gdbarch
, tdesc_register_type
);
1501 set_gdbarch_remote_register_number (gdbarch
,
1502 tdesc_remote_register_number
);
1503 set_gdbarch_register_reggroup_p (gdbarch
, tdesc_register_reggroup_p
);
1507 /* See arch/tdesc.h. */
1510 tdesc_create_reg (struct tdesc_feature
*feature
, const char *name
,
1511 int regnum
, int save_restore
, const char *group
,
1512 int bitsize
, const char *type
)
1514 tdesc_reg
*reg
= new tdesc_reg (feature
, name
, regnum
, save_restore
,
1515 group
, bitsize
, type
);
1517 VEC_safe_push (tdesc_reg_p
, feature
->registers
, reg
);
1520 /* See arch/tdesc.h. */
1523 tdesc_create_vector (struct tdesc_feature
*feature
, const char *name
,
1524 struct tdesc_type
*field_type
, int count
)
1526 struct tdesc_type
*type
= new tdesc_type (name
, TDESC_TYPE_VECTOR
);
1528 type
->u
.v
.type
= field_type
;
1529 type
->u
.v
.count
= count
;
1531 VEC_safe_push (tdesc_type_p
, feature
->types
, type
);
1535 /* See arch/tdesc.h. */
1538 tdesc_create_struct (struct tdesc_feature
*feature
, const char *name
)
1540 struct tdesc_type
*type
= new tdesc_type (name
, TDESC_TYPE_STRUCT
);
1542 VEC_safe_push (tdesc_type_p
, feature
->types
, type
);
1546 /* See arch/tdesc.h. */
1549 tdesc_set_struct_size (struct tdesc_type
*type
, int size
)
1551 gdb_assert (type
->kind
== TDESC_TYPE_STRUCT
);
1552 gdb_assert (size
> 0);
1553 type
->u
.u
.size
= size
;
1556 /* See arch/tdesc.h. */
1559 tdesc_create_union (struct tdesc_feature
*feature
, const char *name
)
1561 struct tdesc_type
*type
= new tdesc_type (name
, TDESC_TYPE_UNION
);
1563 VEC_safe_push (tdesc_type_p
, feature
->types
, type
);
1567 /* See arch/tdesc.h. */
1570 tdesc_create_flags (struct tdesc_feature
*feature
, const char *name
,
1573 struct tdesc_type
*type
= new tdesc_type (name
, TDESC_TYPE_FLAGS
);
1575 gdb_assert (size
> 0);
1577 type
->u
.u
.size
= size
;
1579 VEC_safe_push (tdesc_type_p
, feature
->types
, type
);
1584 tdesc_create_enum (struct tdesc_feature
*feature
, const char *name
,
1587 struct tdesc_type
*type
= new tdesc_type (name
, TDESC_TYPE_ENUM
);
1589 gdb_assert (size
> 0);
1591 type
->u
.u
.size
= size
;
1593 VEC_safe_push (tdesc_type_p
, feature
->types
, type
);
1597 /* See arch/tdesc.h. */
1600 tdesc_add_field (struct tdesc_type
*type
, const char *field_name
,
1601 struct tdesc_type
*field_type
)
1603 struct tdesc_type_field f
= { 0 };
1605 gdb_assert (type
->kind
== TDESC_TYPE_UNION
1606 || type
->kind
== TDESC_TYPE_STRUCT
);
1608 f
.name
= xstrdup (field_name
);
1609 f
.type
= field_type
;
1610 /* Initialize these values so we know this is not a bit-field
1611 when we print-c-tdesc. */
1615 VEC_safe_push (tdesc_type_field
, type
->u
.u
.fields
, &f
);
1619 tdesc_add_typed_bitfield (struct tdesc_type
*type
, const char *field_name
,
1620 int start
, int end
, struct tdesc_type
*field_type
)
1622 struct tdesc_type_field f
= { 0 };
1624 gdb_assert (type
->kind
== TDESC_TYPE_STRUCT
1625 || type
->kind
== TDESC_TYPE_FLAGS
);
1626 gdb_assert (start
>= 0 && end
>= start
);
1628 f
.name
= xstrdup (field_name
);
1631 f
.type
= field_type
;
1633 VEC_safe_push (tdesc_type_field
, type
->u
.u
.fields
, &f
);
1636 /* See arch/tdesc.h. */
1639 tdesc_add_bitfield (struct tdesc_type
*type
, const char *field_name
,
1642 struct tdesc_type
*field_type
;
1644 gdb_assert (start
>= 0 && end
>= start
);
1646 if (type
->u
.u
.size
> 4)
1647 field_type
= tdesc_predefined_type (TDESC_TYPE_UINT64
);
1649 field_type
= tdesc_predefined_type (TDESC_TYPE_UINT32
);
1651 tdesc_add_typed_bitfield (type
, field_name
, start
, end
, field_type
);
1654 /* See arch/tdesc.h. */
1657 tdesc_add_flag (struct tdesc_type
*type
, int start
,
1658 const char *flag_name
)
1660 struct tdesc_type_field f
= { 0 };
1662 gdb_assert (type
->kind
== TDESC_TYPE_FLAGS
1663 || type
->kind
== TDESC_TYPE_STRUCT
);
1665 f
.name
= xstrdup (flag_name
);
1668 f
.type
= tdesc_predefined_type (TDESC_TYPE_BOOL
);
1670 VEC_safe_push (tdesc_type_field
, type
->u
.u
.fields
, &f
);
1674 tdesc_add_enum_value (struct tdesc_type
*type
, int value
,
1677 struct tdesc_type_field f
= { 0 };
1679 gdb_assert (type
->kind
== TDESC_TYPE_ENUM
);
1681 f
.name
= xstrdup (name
);
1684 f
.type
= tdesc_predefined_type (TDESC_TYPE_INT32
);
1686 VEC_safe_push (tdesc_type_field
, type
->u
.u
.fields
, &f
);
1689 /* See arch/tdesc.h. */
1691 struct tdesc_feature
*
1692 tdesc_create_feature (struct target_desc
*tdesc
, const char *name
,
1695 struct tdesc_feature
*new_feature
= new tdesc_feature (name
);
1697 tdesc
->features
.emplace_back (new_feature
);
1702 struct target_desc
*
1703 allocate_target_description (void)
1705 return new target_desc ();
1709 free_target_description (void *arg
)
1711 struct target_desc
*target_desc
= (struct target_desc
*) arg
;
1717 make_cleanup_free_target_description (struct target_desc
*target_desc
)
1719 return make_cleanup (free_target_description
, target_desc
);
1723 tdesc_add_compatible (struct target_desc
*target_desc
,
1724 const struct bfd_arch_info
*compatible
)
1726 /* If this instance of GDB is compiled without BFD support for the
1727 compatible architecture, simply ignore it -- we would not be able
1728 to handle it anyway. */
1729 if (compatible
== NULL
)
1732 for (const bfd_arch_info
*compat
: target_desc
->compatible
)
1733 if (compat
== compatible
)
1734 internal_error (__FILE__
, __LINE__
,
1735 _("Attempted to add duplicate "
1736 "compatible architecture \"%s\""),
1737 compatible
->printable_name
);
1739 target_desc
->compatible
.push_back (compatible
);
1743 set_tdesc_property (struct target_desc
*target_desc
,
1744 const char *key
, const char *value
)
1746 gdb_assert (key
!= NULL
&& value
!= NULL
);
1748 if (tdesc_property (target_desc
, key
) != NULL
)
1749 internal_error (__FILE__
, __LINE__
,
1750 _("Attempted to add duplicate property \"%s\""), key
);
1752 target_desc
->properties
.emplace_back (key
, value
);
1755 /* See arch/tdesc.h. */
1758 set_tdesc_architecture (struct target_desc
*target_desc
,
1761 set_tdesc_architecture (target_desc
, bfd_scan_arch (name
));
1765 set_tdesc_architecture (struct target_desc
*target_desc
,
1766 const struct bfd_arch_info
*arch
)
1768 target_desc
->arch
= arch
;
1771 /* See arch/tdesc.h. */
1774 set_tdesc_osabi (struct target_desc
*target_desc
, const char *name
)
1776 set_tdesc_osabi (target_desc
, osabi_from_tdesc_string (name
));
1780 set_tdesc_osabi (struct target_desc
*target_desc
, enum gdb_osabi osabi
)
1782 target_desc
->osabi
= osabi
;
1786 static struct cmd_list_element
*tdesc_set_cmdlist
, *tdesc_show_cmdlist
;
1787 static struct cmd_list_element
*tdesc_unset_cmdlist
;
1789 /* Helper functions for the CLI commands. */
1792 set_tdesc_cmd (const char *args
, int from_tty
)
1794 help_list (tdesc_set_cmdlist
, "set tdesc ", all_commands
, gdb_stdout
);
1798 show_tdesc_cmd (const char *args
, int from_tty
)
1800 cmd_show_list (tdesc_show_cmdlist
, from_tty
, "");
1804 unset_tdesc_cmd (const char *args
, int from_tty
)
1806 help_list (tdesc_unset_cmdlist
, "unset tdesc ", all_commands
, gdb_stdout
);
1810 set_tdesc_filename_cmd (const char *args
, int from_tty
,
1811 struct cmd_list_element
*c
)
1813 xfree (target_description_filename
);
1814 target_description_filename
= xstrdup (tdesc_filename_cmd_string
);
1816 target_clear_description ();
1817 target_find_description ();
1821 show_tdesc_filename_cmd (struct ui_file
*file
, int from_tty
,
1822 struct cmd_list_element
*c
,
1825 value
= target_description_filename
;
1827 if (value
!= NULL
&& *value
!= '\0')
1828 printf_filtered (_("The target description will be read from \"%s\".\n"),
1831 printf_filtered (_("The target description will be "
1832 "read from the target.\n"));
1836 unset_tdesc_filename_cmd (const char *args
, int from_tty
)
1838 xfree (target_description_filename
);
1839 target_description_filename
= NULL
;
1840 target_clear_description ();
1841 target_find_description ();
1844 /* Print target description in C. */
1846 class print_c_tdesc
: public tdesc_element_visitor
1849 print_c_tdesc (std::string
&filename_after_features
)
1850 : m_filename_after_features (filename_after_features
)
1854 const char *filename
= lbasename (m_filename_after_features
.c_str ());
1856 m_function
= (char *) xmalloc (strlen (filename
) + 1);
1857 for (inp
= filename
, outp
= m_function
; *inp
!= '\0'; inp
++)
1860 else if (*inp
== '-')
1866 /* Standard boilerplate. */
1867 printf_unfiltered ("/* THIS FILE IS GENERATED. "
1868 "-*- buffer-read-only: t -*- vi"
1877 void visit_pre (const target_desc
*e
) override
1879 printf_unfiltered (" Original: %s */\n\n",
1880 lbasename (m_filename_after_features
.c_str ()));
1882 printf_unfiltered ("#include \"defs.h\"\n");
1883 printf_unfiltered ("#include \"osabi.h\"\n");
1884 printf_unfiltered ("#include \"target-descriptions.h\"\n");
1885 printf_unfiltered ("\n");
1887 printf_unfiltered ("struct target_desc *tdesc_%s;\n", m_function
);
1888 printf_unfiltered ("static void\n");
1889 printf_unfiltered ("initialize_tdesc_%s (void)\n", m_function
);
1890 printf_unfiltered ("{\n");
1892 (" struct target_desc *result = allocate_target_description ();\n");
1894 if (tdesc_architecture (e
) != NULL
)
1897 (" set_tdesc_architecture (result, bfd_scan_arch (\"%s\"));\n",
1898 tdesc_architecture (e
)->printable_name
);
1899 printf_unfiltered ("\n");
1901 if (tdesc_osabi (e
) > GDB_OSABI_UNKNOWN
1902 && tdesc_osabi (e
) < GDB_OSABI_INVALID
)
1905 (" set_tdesc_osabi (result, osabi_from_tdesc_string (\"%s\"));\n",
1906 gdbarch_osabi_name (tdesc_osabi (e
)));
1907 printf_unfiltered ("\n");
1910 for (const struct bfd_arch_info
*compatible
: e
->compatible
)
1912 (" tdesc_add_compatible (result, bfd_scan_arch (\"%s\"));\n",
1913 compatible
->printable_name
);
1915 if (!e
->compatible
.empty ())
1916 printf_unfiltered ("\n");
1918 for (const property
&prop
: e
->properties
)
1919 printf_unfiltered (" set_tdesc_property (result, \"%s\", \"%s\");\n",
1920 prop
.key
.c_str (), prop
.value
.c_str ());
1922 printf_unfiltered (" struct tdesc_feature *feature;\n");
1925 void visit_pre (const tdesc_feature
*e
) override
1927 printf_unfiltered ("\n feature = tdesc_create_feature (result, \"%s\");\n",
1931 void visit_post (const tdesc_feature
*e
) override
1934 void visit_post (const target_desc
*e
) override
1936 printf_unfiltered ("\n tdesc_%s = result;\n", m_function
);
1937 printf_unfiltered ("}\n");
1940 void visit (const tdesc_type
*type
) override
1942 struct tdesc_type_field
*f
;
1944 /* Now we do some "filtering" in order to know which variables to
1945 declare. This is needed because otherwise we would declare unused
1946 variables `field_type' and `type'. */
1947 if (!m_printed_field_type
)
1949 printf_unfiltered (" struct tdesc_type *field_type;\n");
1950 m_printed_field_type
= true;
1953 if ((type
->kind
== TDESC_TYPE_UNION
1954 || type
->kind
== TDESC_TYPE_STRUCT
1955 || type
->kind
== TDESC_TYPE_FLAGS
1956 || type
->kind
== TDESC_TYPE_ENUM
)
1957 && VEC_length (tdesc_type_field
, type
->u
.u
.fields
) > 0
1960 printf_unfiltered (" struct tdesc_type *type;\n");
1961 m_printed_type
= true;
1966 case TDESC_TYPE_VECTOR
:
1968 (" field_type = tdesc_named_type (feature, \"%s\");\n",
1969 type
->u
.v
.type
->name
);
1971 (" tdesc_create_vector (feature, \"%s\", field_type, %d);\n",
1972 type
->name
, type
->u
.v
.count
);
1974 case TDESC_TYPE_STRUCT
:
1975 case TDESC_TYPE_FLAGS
:
1976 if (type
->kind
== TDESC_TYPE_STRUCT
)
1979 (" type = tdesc_create_struct (feature, \"%s\");\n",
1981 if (type
->u
.u
.size
!= 0)
1983 (" tdesc_set_struct_size (type, %d);\n",
1989 (" type = tdesc_create_flags (feature, \"%s\", %d);\n",
1990 type
->name
, type
->u
.u
.size
);
1993 VEC_iterate (tdesc_type_field
, type
->u
.u
.fields
, ix3
, f
);
1996 const char *type_name
;
1998 gdb_assert (f
->type
!= NULL
);
1999 type_name
= f
->type
->name
;
2001 /* To minimize changes to generated files, don't emit type
2002 info for fields that have defaulted types. */
2005 gdb_assert (f
->end
!= -1);
2006 if (f
->type
->kind
== TDESC_TYPE_BOOL
)
2008 gdb_assert (f
->start
== f
->end
);
2010 (" tdesc_add_flag (type, %d, \"%s\");\n",
2013 else if ((type
->u
.u
.size
== 4
2014 && f
->type
->kind
== TDESC_TYPE_UINT32
)
2015 || (type
->u
.u
.size
== 8
2016 && f
->type
->kind
== TDESC_TYPE_UINT64
))
2019 (" tdesc_add_bitfield (type, \"%s\", %d, %d);\n",
2020 f
->name
, f
->start
, f
->end
);
2025 (" field_type = tdesc_named_type (feature,"
2029 (" tdesc_add_typed_bitfield (type, \"%s\","
2030 " %d, %d, field_type);\n",
2031 f
->name
, f
->start
, f
->end
);
2034 else /* Not a bitfield. */
2036 gdb_assert (f
->end
== -1);
2037 gdb_assert (type
->kind
== TDESC_TYPE_STRUCT
);
2039 (" field_type = tdesc_named_type (feature,"
2043 (" tdesc_add_field (type, \"%s\", field_type);\n",
2048 case TDESC_TYPE_UNION
:
2050 (" type = tdesc_create_union (feature, \"%s\");\n",
2053 VEC_iterate (tdesc_type_field
, type
->u
.u
.fields
, ix3
, f
);
2057 (" field_type = tdesc_named_type (feature, \"%s\");\n",
2060 (" tdesc_add_field (type, \"%s\", field_type);\n",
2064 case TDESC_TYPE_ENUM
:
2066 (" type = tdesc_create_enum (feature, \"%s\", %d);\n",
2067 type
->name
, type
->u
.u
.size
);
2069 VEC_iterate (tdesc_type_field
, type
->u
.u
.fields
, ix3
, f
);
2072 (" tdesc_add_enum_value (type, %d, \"%s\");\n",
2076 error (_("C output is not supported type \"%s\"."), type
->name
);
2078 printf_unfiltered ("\n");
2081 void visit (const tdesc_reg
*reg
) override
2083 printf_unfiltered (" tdesc_create_reg (feature, \"%s\", %ld, %d, ",
2084 reg
->name
, reg
->target_regnum
, reg
->save_restore
);
2086 printf_unfiltered ("\"%s\", ", reg
->group
);
2088 printf_unfiltered ("NULL, ");
2089 printf_unfiltered ("%d, \"%s\");\n", reg
->bitsize
, reg
->type
);
2093 std::string m_filename_after_features
;
2097 bool m_printed_field_type
= false;
2098 bool m_printed_type
= false;
2101 /* Print target description feature in C. */
2103 class print_c_feature
: public print_c_tdesc
2106 print_c_feature (std::string
&file
)
2107 : print_c_tdesc (file
)
2110 auto const pos
= m_filename_after_features
.find_last_of ('.');
2112 m_filename_after_features
= m_filename_after_features
.substr (0, pos
);
2115 void visit_pre (const target_desc
*e
) override
2117 printf_unfiltered (" Original: %s */\n\n",
2118 lbasename (m_filename_after_features
.c_str ()));
2120 printf_unfiltered ("#include \"arch/tdesc.h\"\n");
2121 printf_unfiltered ("\n");
2124 void visit_post (const target_desc
*e
) override
2127 void visit_pre (const tdesc_feature
*e
) override
2129 std::string
name (m_filename_after_features
);
2131 auto pos
= name
.find_first_of ('.');
2133 name
= name
.substr (0, pos
);
2134 std::replace (name
.begin (), name
.end (), '/', '_');
2135 std::replace (name
.begin (), name
.end (), '-', '_');
2137 printf_unfiltered ("static int\n");
2138 printf_unfiltered ("create_feature_%s ", name
.c_str ());
2139 printf_unfiltered ("(struct target_desc *result, long regnum)\n");
2141 printf_unfiltered ("{\n");
2142 printf_unfiltered (" struct tdesc_feature *feature;\n");
2145 ("\n feature = tdesc_create_feature (result, \"%s\", \"%s\");\n",
2146 e
->name
, lbasename (m_filename_after_features
.c_str ()));
2149 void visit_post (const tdesc_feature
*e
) override
2151 printf_unfiltered (" return regnum;\n");
2152 printf_unfiltered ("}\n");
2155 void visit (const tdesc_reg
*reg
) override
2157 /* Most "reg" in XML target descriptions don't have "regnum"
2158 attribute, so the register number is allocated sequentially.
2159 In case that reg has "regnum" attribute, register number
2160 should be set by that explicitly. */
2162 if (reg
->target_regnum
< m_next_regnum
)
2164 /* The integrity check, it can catch some errors on register
2165 number collision, like this,
2167 <reg name="x0" bitsize="32"/>
2168 <reg name="x1" bitsize="32"/>
2169 <reg name="x2" bitsize="32"/>
2170 <reg name="x3" bitsize="32"/>
2171 <reg name="ps" bitsize="32" regnum="3"/>
2173 but it also has false negatives. The target description
2176 <reg name="x1" bitsize="32" regnum="1"/>
2177 <reg name="x3" bitsize="32" regnum="3"/>
2178 <reg name="x2" bitsize="32" regnum="2"/>
2179 <reg name="x4" bitsize="32" regnum="4"/>
2181 but it is not a good practice, so still error on this,
2182 and also print the message so that it can be saved in the
2183 generated c file. */
2185 printf_unfiltered ("ERROR: \"regnum\" attribute %ld ",
2186 reg
->target_regnum
);
2187 printf_unfiltered ("is not the largest number (%d).\n",
2189 error (_("\"regnum\" attribute %ld is not the largest number (%d)."),
2190 reg
->target_regnum
, m_next_regnum
);
2193 if (reg
->target_regnum
> m_next_regnum
)
2195 printf_unfiltered (" regnum = %ld;\n", reg
->target_regnum
);
2196 m_next_regnum
= reg
->target_regnum
;
2199 printf_unfiltered (" tdesc_create_reg (feature, \"%s\", regnum++, %d, ",
2200 reg
->name
, reg
->save_restore
);
2202 printf_unfiltered ("\"%s\", ", reg
->group
);
2204 printf_unfiltered ("NULL, ");
2205 printf_unfiltered ("%d, \"%s\");\n", reg
->bitsize
, reg
->type
);
2211 /* The register number to use for the next register we see. */
2212 int m_next_regnum
= 0;
2216 maint_print_c_tdesc_cmd (const char *args
, int from_tty
)
2218 const struct target_desc
*tdesc
;
2219 const char *filename
;
2223 /* Use the global target-supplied description, not the current
2224 architecture's. This lets a GDB for one architecture generate C
2225 for another architecture's description, even though the gdbarch
2226 initialization code will reject the new description. */
2227 tdesc
= current_target_desc
;
2228 filename
= target_description_filename
;
2232 /* Use the target description from the XML file. */
2234 tdesc
= file_read_description_xml (filename
);
2238 error (_("There is no target description to print."));
2240 if (filename
== NULL
)
2241 error (_("The current target description did not come from an XML file."));
2243 std::string
filename_after_features (filename
);
2244 auto loc
= filename_after_features
.rfind ("/features/");
2246 if (loc
!= std::string::npos
)
2247 filename_after_features
= filename_after_features
.substr (loc
+ 10);
2249 /* Print c files for target features instead of target descriptions,
2250 because c files got from target features are more flexible than the
2252 if (startswith (filename_after_features
.c_str (), "i386/32bit-")
2253 || startswith (filename_after_features
.c_str (), "i386/64bit-")
2254 || startswith (filename_after_features
.c_str (), "i386/x32-core.xml")
2255 || startswith (filename_after_features
.c_str (), "tic6x-")
2256 || startswith (filename_after_features
.c_str (), "aarch64"))
2258 print_c_feature
v (filename_after_features
);
2264 print_c_tdesc
v (filename_after_features
);
2270 namespace selftests
{
2272 static std::vector
<std::pair
<const char*, const target_desc
*>> xml_tdesc
;
2276 /* See target-descritpions.h. */
2279 record_xml_tdesc (const char *xml_file
, const struct target_desc
*tdesc
)
2281 xml_tdesc
.emplace_back (xml_file
, tdesc
);
2287 /* Check that the target descriptions created dynamically by
2288 architecture-specific code equal the descriptions created from XML files
2289 found in the specified directory DIR. */
2292 maintenance_check_xml_descriptions (const char *dir
, int from_tty
)
2295 error (_("Missing dir name"));
2297 gdb::unique_xmalloc_ptr
<char> dir1 (tilde_expand (dir
));
2298 std::string
feature_dir (dir1
.get ());
2299 unsigned int failed
= 0;
2301 for (auto const &e
: selftests::xml_tdesc
)
2303 std::string tdesc_xml
= (feature_dir
+ SLASH_STRING
+ e
.first
);
2304 const target_desc
*tdesc
2305 = file_read_description_xml (tdesc_xml
.data ());
2307 if (tdesc
== NULL
|| *tdesc
!= *e
.second
)
2310 printf_filtered (_("Tested %lu XML files, %d failed\n"),
2311 (long) selftests::xml_tdesc
.size (), failed
);
2315 _initialize_target_descriptions (void)
2317 tdesc_data
= gdbarch_data_register_pre_init (tdesc_data_init
);
2319 add_prefix_cmd ("tdesc", class_maintenance
, set_tdesc_cmd
, _("\
2320 Set target description specific variables."),
2321 &tdesc_set_cmdlist
, "set tdesc ",
2322 0 /* allow-unknown */, &setlist
);
2323 add_prefix_cmd ("tdesc", class_maintenance
, show_tdesc_cmd
, _("\
2324 Show target description specific variables."),
2325 &tdesc_show_cmdlist
, "show tdesc ",
2326 0 /* allow-unknown */, &showlist
);
2327 add_prefix_cmd ("tdesc", class_maintenance
, unset_tdesc_cmd
, _("\
2328 Unset target description specific variables."),
2329 &tdesc_unset_cmdlist
, "unset tdesc ",
2330 0 /* allow-unknown */, &unsetlist
);
2332 add_setshow_filename_cmd ("filename", class_obscure
,
2333 &tdesc_filename_cmd_string
,
2335 Set the file to read for an XML target description"), _("\
2336 Show the file to read for an XML target description"), _("\
2337 When set, GDB will read the target description from a local\n\
2338 file instead of querying the remote target."),
2339 set_tdesc_filename_cmd
,
2340 show_tdesc_filename_cmd
,
2341 &tdesc_set_cmdlist
, &tdesc_show_cmdlist
);
2343 add_cmd ("filename", class_obscure
, unset_tdesc_filename_cmd
, _("\
2344 Unset the file to read for an XML target description. When unset,\n\
2345 GDB will read the description from the target."),
2346 &tdesc_unset_cmdlist
);
2348 add_cmd ("c-tdesc", class_maintenance
, maint_print_c_tdesc_cmd
, _("\
2349 Print the current target description as a C source file."),
2350 &maintenanceprintlist
);
2352 cmd_list_element
*cmd
;
2354 cmd
= add_cmd ("xml-descriptions", class_maintenance
,
2355 maintenance_check_xml_descriptions
, _("\
2356 Check the target descriptions created in GDB equal the descriptions\n\
2357 created from XML files in the directory.\n\
2358 The parameter is the directory name."),
2359 &maintenancechecklist
);
2360 set_cmd_completer (cmd
, filename_completer
);