Copyright year update in most files of the GDB Project.
[external/binutils.git] / gdb / target-descriptions.c
1 /* Target description support for GDB.
2
3    Copyright (C) 2006-2012 Free Software Foundation, Inc.
4
5    Contributed by CodeSourcery.
6
7    This file is part of GDB.
8
9    This program is free software; you can redistribute it and/or modify
10    it under the terms of the GNU General Public License as published by
11    the Free Software Foundation; either version 3 of the License, or
12    (at your option) any later version.
13
14    This program is distributed in the hope that it will be useful,
15    but WITHOUT ANY WARRANTY; without even the implied warranty of
16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17    GNU General Public License for more details.
18
19    You should have received a copy of the GNU General Public License
20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
21
22 #include "defs.h"
23 #include "arch-utils.h"
24 #include "gdbcmd.h"
25 #include "gdbtypes.h"
26 #include "reggroups.h"
27 #include "target.h"
28 #include "target-descriptions.h"
29 #include "vec.h"
30 #include "xml-support.h"
31 #include "xml-tdesc.h"
32 #include "osabi.h"
33
34 #include "gdb_assert.h"
35 #include "gdb_obstack.h"
36 #include "hashtab.h"
37
38 /* Types.  */
39
40 typedef struct property
41 {
42   char *key;
43   char *value;
44 } property_s;
45 DEF_VEC_O(property_s);
46
47 /* An individual register from a target description.  */
48
49 typedef struct tdesc_reg
50 {
51   /* The name of this register.  In standard features, it may be
52      recognized by the architecture support code, or it may be purely
53      for the user.  */
54   char *name;
55
56   /* The register number used by this target to refer to this
57      register.  This is used for remote p/P packets and to determine
58      the ordering of registers in the remote g/G packets.  */
59   long target_regnum;
60
61   /* If this flag is set, GDB should save and restore this register
62      around calls to an inferior function.  */
63   int save_restore;
64
65   /* The name of the register group containing this register, or NULL
66      if the group should be automatically determined from the
67      register's type.  If this is "general", "float", or "vector", the
68      corresponding "info" command should display this register's
69      value.  It can be an arbitrary string, but should be limited to
70      alphanumeric characters and internal hyphens.  Currently other
71      strings are ignored (treated as NULL).  */
72   char *group;
73
74   /* The size of the register, in bits.  */
75   int bitsize;
76
77   /* The type of the register.  This string corresponds to either
78      a named type from the target description or a predefined
79      type from GDB.  */
80   char *type;
81
82   /* The target-described type corresponding to TYPE, if found.  */
83   struct tdesc_type *tdesc_type;
84 } *tdesc_reg_p;
85 DEF_VEC_P(tdesc_reg_p);
86
87 /* A named type from a target description.  */
88
89 typedef struct tdesc_type_field
90 {
91   char *name;
92   struct tdesc_type *type;
93   int start, end;
94 } tdesc_type_field;
95 DEF_VEC_O(tdesc_type_field);
96
97 typedef struct tdesc_type_flag
98 {
99   char *name;
100   int start;
101 } tdesc_type_flag;
102 DEF_VEC_O(tdesc_type_flag);
103
104 typedef struct tdesc_type
105 {
106   /* The name of this type.  */
107   char *name;
108
109   /* Identify the kind of this type.  */
110   enum
111   {
112     /* Predefined types.  */
113     TDESC_TYPE_INT8,
114     TDESC_TYPE_INT16,
115     TDESC_TYPE_INT32,
116     TDESC_TYPE_INT64,
117     TDESC_TYPE_INT128,
118     TDESC_TYPE_UINT8,
119     TDESC_TYPE_UINT16,
120     TDESC_TYPE_UINT32,
121     TDESC_TYPE_UINT64,
122     TDESC_TYPE_UINT128,
123     TDESC_TYPE_CODE_PTR,
124     TDESC_TYPE_DATA_PTR,
125     TDESC_TYPE_IEEE_SINGLE,
126     TDESC_TYPE_IEEE_DOUBLE,
127     TDESC_TYPE_ARM_FPA_EXT,
128     TDESC_TYPE_I387_EXT,
129
130     /* Types defined by a target feature.  */
131     TDESC_TYPE_VECTOR,
132     TDESC_TYPE_STRUCT,
133     TDESC_TYPE_UNION,
134     TDESC_TYPE_FLAGS
135   } kind;
136
137   /* Kind-specific data.  */
138   union
139   {
140     /* Vector type.  */
141     struct
142     {
143       struct tdesc_type *type;
144       int count;
145     } v;
146
147     /* Struct or union type.  */
148     struct
149     {
150       VEC(tdesc_type_field) *fields;
151       LONGEST size;
152     } u;
153
154     /* Flags type.  */
155     struct
156     {
157       VEC(tdesc_type_flag) *flags;
158       LONGEST size;
159     } f;
160   } u;
161 } *tdesc_type_p;
162 DEF_VEC_P(tdesc_type_p);
163
164 /* A feature from a target description.  Each feature is a collection
165    of other elements, e.g. registers and types.  */
166
167 typedef struct tdesc_feature
168 {
169   /* The name of this feature.  It may be recognized by the architecture
170      support code.  */
171   char *name;
172
173   /* The registers associated with this feature.  */
174   VEC(tdesc_reg_p) *registers;
175
176   /* The types associated with this feature.  */
177   VEC(tdesc_type_p) *types;
178 } *tdesc_feature_p;
179 DEF_VEC_P(tdesc_feature_p);
180
181 /* A compatible architecture from a target description.  */
182 typedef const struct bfd_arch_info *arch_p;
183 DEF_VEC_P(arch_p);
184
185 /* A target description.  */
186
187 struct target_desc
188 {
189   /* The architecture reported by the target, if any.  */
190   const struct bfd_arch_info *arch;
191
192   /* The osabi reported by the target, if any; GDB_OSABI_UNKNOWN
193      otherwise.  */
194   enum gdb_osabi osabi;
195
196   /* The list of compatible architectures reported by the target.  */
197   VEC(arch_p) *compatible;
198
199   /* Any architecture-specific properties specified by the target.  */
200   VEC(property_s) *properties;
201
202   /* The features associated with this target.  */
203   VEC(tdesc_feature_p) *features;
204 };
205
206 /* Per-architecture data associated with a target description.  The
207    target description may be shared by multiple architectures, but
208    this data is private to one gdbarch.  */
209
210 typedef struct tdesc_arch_reg
211 {
212   struct tdesc_reg *reg;
213   struct type *type;
214 } tdesc_arch_reg;
215 DEF_VEC_O(tdesc_arch_reg);
216
217 struct tdesc_arch_data
218 {
219   /* A list of register/type pairs, indexed by GDB's internal register number.
220      During initialization of the gdbarch this list is used to store
221      registers which the architecture assigns a fixed register number.
222      Registers which are NULL in this array, or off the end, are
223      treated as zero-sized and nameless (i.e. placeholders in the
224      numbering).  */
225   VEC(tdesc_arch_reg) *arch_regs;
226
227   /* Functions which report the register name, type, and reggroups for
228      pseudo-registers.  */
229   gdbarch_register_name_ftype *pseudo_register_name;
230   gdbarch_register_type_ftype *pseudo_register_type;
231   gdbarch_register_reggroup_p_ftype *pseudo_register_reggroup_p;
232 };
233
234 /* Global state.  These variables are associated with the current
235    target; if GDB adds support for multiple simultaneous targets, then
236    these variables should become target-specific data.  */
237
238 /* A flag indicating that a description has already been fetched from
239    the current target, so it should not be queried again.  */
240
241 static int target_desc_fetched;
242
243 /* The description fetched from the current target, or NULL if the
244    current target did not supply any description.  Only valid when
245    target_desc_fetched is set.  Only the description initialization
246    code should access this; normally, the description should be
247    accessed through the gdbarch object.  */
248
249 static const struct target_desc *current_target_desc;
250
251 /* Other global variables.  */
252
253 /* The filename to read a target description from.  */
254
255 static char *target_description_filename;
256
257 /* A handle for architecture-specific data associated with the
258    target description (see struct tdesc_arch_data).  */
259
260 static struct gdbarch_data *tdesc_data;
261
262 /* Fetch the current target's description, and switch the current
263    architecture to one which incorporates that description.  */
264
265 void
266 target_find_description (void)
267 {
268   /* If we've already fetched a description from the target, don't do
269      it again.  This allows a target to fetch the description early,
270      during its to_open or to_create_inferior, if it needs extra
271      information about the target to initialize.  */
272   if (target_desc_fetched)
273     return;
274
275   /* The current architecture should not have any target description
276      specified.  It should have been cleared, e.g. when we
277      disconnected from the previous target.  */
278   gdb_assert (gdbarch_target_desc (target_gdbarch) == NULL);
279
280   /* First try to fetch an XML description from the user-specified
281      file.  */
282   current_target_desc = NULL;
283   if (target_description_filename != NULL
284       && *target_description_filename != '\0')
285     current_target_desc
286       = file_read_description_xml (target_description_filename);
287
288   /* Next try to read the description from the current target using
289      target objects.  */
290   if (current_target_desc == NULL)
291     current_target_desc = target_read_description_xml (&current_target);
292
293   /* If that failed try a target-specific hook.  */
294   if (current_target_desc == NULL)
295     current_target_desc = target_read_description (&current_target);
296
297   /* If a non-NULL description was returned, then update the current
298      architecture.  */
299   if (current_target_desc)
300     {
301       struct gdbarch_info info;
302
303       gdbarch_info_init (&info);
304       info.target_desc = current_target_desc;
305       if (!gdbarch_update_p (info))
306         warning (_("Architecture rejected target-supplied description"));
307       else
308         {
309           struct tdesc_arch_data *data;
310
311           data = gdbarch_data (target_gdbarch, tdesc_data);
312           if (tdesc_has_registers (current_target_desc)
313               && data->arch_regs == NULL)
314             warning (_("Target-supplied registers are not supported "
315                        "by the current architecture"));
316         }
317     }
318
319   /* Now that we know this description is usable, record that we
320      fetched it.  */
321   target_desc_fetched = 1;
322 }
323
324 /* Discard any description fetched from the current target, and switch
325    the current architecture to one with no target description.  */
326
327 void
328 target_clear_description (void)
329 {
330   struct gdbarch_info info;
331
332   if (!target_desc_fetched)
333     return;
334
335   target_desc_fetched = 0;
336   current_target_desc = NULL;
337
338   gdbarch_info_init (&info);
339   if (!gdbarch_update_p (info))
340     internal_error (__FILE__, __LINE__,
341                     _("Could not remove target-supplied description"));
342 }
343
344 /* Return the global current target description.  This should only be
345    used by gdbarch initialization code; most access should be through
346    an existing gdbarch.  */
347
348 const struct target_desc *
349 target_current_description (void)
350 {
351   if (target_desc_fetched)
352     return current_target_desc;
353
354   return NULL;
355 }
356
357 /* Return non-zero if this target description is compatible
358    with the given BFD architecture.  */
359
360 int
361 tdesc_compatible_p (const struct target_desc *target_desc,
362                     const struct bfd_arch_info *arch)
363 {
364   const struct bfd_arch_info *compat;
365   int ix;
366
367   for (ix = 0; VEC_iterate (arch_p, target_desc->compatible, ix, compat);
368        ix++)
369     {
370       if (compat == arch
371           || arch->compatible (arch, compat)
372           || compat->compatible (compat, arch))
373         return 1;
374     }
375
376   return 0;
377 }
378 \f
379
380 /* Direct accessors for target descriptions.  */
381
382 /* Return the string value of a property named KEY, or NULL if the
383    property was not specified.  */
384
385 const char *
386 tdesc_property (const struct target_desc *target_desc, const char *key)
387 {
388   struct property *prop;
389   int ix;
390
391   for (ix = 0; VEC_iterate (property_s, target_desc->properties, ix, prop);
392        ix++)
393     if (strcmp (prop->key, key) == 0)
394       return prop->value;
395
396   return NULL;
397 }
398
399 /* Return the BFD architecture associated with this target
400    description, or NULL if no architecture was specified.  */
401
402 const struct bfd_arch_info *
403 tdesc_architecture (const struct target_desc *target_desc)
404 {
405   return target_desc->arch;
406 }
407
408 /* Return the OSABI associated with this target description, or
409    GDB_OSABI_UNKNOWN if no osabi was specified.  */
410
411 enum gdb_osabi
412 tdesc_osabi (const struct target_desc *target_desc)
413 {
414   return target_desc->osabi;
415 }
416
417 \f
418
419 /* Return 1 if this target description includes any registers.  */
420
421 int
422 tdesc_has_registers (const struct target_desc *target_desc)
423 {
424   int ix;
425   struct tdesc_feature *feature;
426
427   if (target_desc == NULL)
428     return 0;
429
430   for (ix = 0;
431        VEC_iterate (tdesc_feature_p, target_desc->features, ix, feature);
432        ix++)
433     if (! VEC_empty (tdesc_reg_p, feature->registers))
434       return 1;
435
436   return 0;
437 }
438
439 /* Return the feature with the given name, if present, or NULL if
440    the named feature is not found.  */
441
442 const struct tdesc_feature *
443 tdesc_find_feature (const struct target_desc *target_desc,
444                     const char *name)
445 {
446   int ix;
447   struct tdesc_feature *feature;
448
449   for (ix = 0;
450        VEC_iterate (tdesc_feature_p, target_desc->features, ix, feature);
451        ix++)
452     if (strcmp (feature->name, name) == 0)
453       return feature;
454
455   return NULL;
456 }
457
458 /* Return the name of FEATURE.  */
459
460 const char *
461 tdesc_feature_name (const struct tdesc_feature *feature)
462 {
463   return feature->name;
464 }
465
466 /* Predefined types.  */
467 static struct tdesc_type tdesc_predefined_types[] =
468 {
469   { "int8", TDESC_TYPE_INT8 },
470   { "int16", TDESC_TYPE_INT16 },
471   { "int32", TDESC_TYPE_INT32 },
472   { "int64", TDESC_TYPE_INT64 },
473   { "int128", TDESC_TYPE_INT128 },
474   { "uint8", TDESC_TYPE_UINT8 },
475   { "uint16", TDESC_TYPE_UINT16 },
476   { "uint32", TDESC_TYPE_UINT32 },
477   { "uint64", TDESC_TYPE_UINT64 },
478   { "uint128", TDESC_TYPE_UINT128 },
479   { "code_ptr", TDESC_TYPE_CODE_PTR },
480   { "data_ptr", TDESC_TYPE_DATA_PTR },
481   { "ieee_single", TDESC_TYPE_IEEE_SINGLE },
482   { "ieee_double", TDESC_TYPE_IEEE_DOUBLE },
483   { "arm_fpa_ext", TDESC_TYPE_ARM_FPA_EXT },
484   { "i387_ext", TDESC_TYPE_I387_EXT }
485 };
486
487 /* Return the type associated with ID in the context of FEATURE, or
488    NULL if none.  */
489
490 struct tdesc_type *
491 tdesc_named_type (const struct tdesc_feature *feature, const char *id)
492 {
493   int ix;
494   struct tdesc_type *type;
495
496   /* First try target-defined types.  */
497   for (ix = 0; VEC_iterate (tdesc_type_p, feature->types, ix, type); ix++)
498     if (strcmp (type->name, id) == 0)
499       return type;
500
501   /* Next try the predefined types.  */
502   for (ix = 0; ix < ARRAY_SIZE (tdesc_predefined_types); ix++)
503     if (strcmp (tdesc_predefined_types[ix].name, id) == 0)
504       return &tdesc_predefined_types[ix];
505
506   return NULL;
507 }
508
509 /* Lookup type associated with ID.  */
510
511 struct type *
512 tdesc_find_type (struct gdbarch *gdbarch, const char *id)
513 {
514   struct tdesc_arch_reg *reg;
515   struct tdesc_arch_data *data;
516   int i, num_regs;
517
518   data = gdbarch_data (gdbarch, tdesc_data);
519   num_regs = VEC_length (tdesc_arch_reg, data->arch_regs);
520   for (i = 0; i < num_regs; i++)
521     {
522       reg = VEC_index (tdesc_arch_reg, data->arch_regs, i);
523       if (reg->reg
524           && reg->reg->tdesc_type
525           && reg->type
526           && strcmp (id, reg->reg->tdesc_type->name) == 0)
527         return reg->type;
528     }
529
530   return NULL;
531 }
532
533 /* Construct, if necessary, and return the GDB type implementing target
534    type TDESC_TYPE for architecture GDBARCH.  */
535
536 static struct type *
537 tdesc_gdb_type (struct gdbarch *gdbarch, struct tdesc_type *tdesc_type)
538 {
539   struct type *type;
540
541   switch (tdesc_type->kind)
542     {
543     /* Predefined types.  */
544     case TDESC_TYPE_INT8:
545       return builtin_type (gdbarch)->builtin_int8;
546
547     case TDESC_TYPE_INT16:
548       return builtin_type (gdbarch)->builtin_int16;
549
550     case TDESC_TYPE_INT32:
551       return builtin_type (gdbarch)->builtin_int32;
552
553     case TDESC_TYPE_INT64:
554       return builtin_type (gdbarch)->builtin_int64;
555
556     case TDESC_TYPE_INT128:
557       return builtin_type (gdbarch)->builtin_int128;
558
559     case TDESC_TYPE_UINT8:
560       return builtin_type (gdbarch)->builtin_uint8;
561
562     case TDESC_TYPE_UINT16:
563       return builtin_type (gdbarch)->builtin_uint16;
564
565     case TDESC_TYPE_UINT32:
566       return builtin_type (gdbarch)->builtin_uint32;
567
568     case TDESC_TYPE_UINT64:
569       return builtin_type (gdbarch)->builtin_uint64;
570
571     case TDESC_TYPE_UINT128:
572       return builtin_type (gdbarch)->builtin_uint128;
573
574     case TDESC_TYPE_CODE_PTR:
575       return builtin_type (gdbarch)->builtin_func_ptr;
576
577     case TDESC_TYPE_DATA_PTR:
578       return builtin_type (gdbarch)->builtin_data_ptr;
579
580     default:
581       break;
582     }
583
584   type = tdesc_find_type (gdbarch, tdesc_type->name);
585   if (type)
586     return type;
587
588   switch (tdesc_type->kind)
589     {
590     case TDESC_TYPE_IEEE_SINGLE:
591       return arch_float_type (gdbarch, -1, "builtin_type_ieee_single",
592                               floatformats_ieee_single);
593
594     case TDESC_TYPE_IEEE_DOUBLE:
595       return arch_float_type (gdbarch, -1, "builtin_type_ieee_double",
596                               floatformats_ieee_double);
597
598     case TDESC_TYPE_ARM_FPA_EXT:
599       return arch_float_type (gdbarch, -1, "builtin_type_arm_ext",
600                               floatformats_arm_ext);
601
602     case TDESC_TYPE_I387_EXT:
603       return arch_float_type (gdbarch, -1, "builtin_type_i387_ext",
604                               floatformats_i387_ext);
605
606     /* Types defined by a target feature.  */
607     case TDESC_TYPE_VECTOR:
608       {
609         struct type *type, *field_type;
610
611         field_type = tdesc_gdb_type (gdbarch, tdesc_type->u.v.type);
612         type = init_vector_type (field_type, tdesc_type->u.v.count);
613         TYPE_NAME (type) = xstrdup (tdesc_type->name);
614
615         return type;
616       }
617
618     case TDESC_TYPE_STRUCT:
619       {
620         struct type *type, *field_type;
621         struct tdesc_type_field *f;
622         int ix;
623
624         type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT);
625         TYPE_NAME (type) = xstrdup (tdesc_type->name);
626         TYPE_TAG_NAME (type) = TYPE_NAME (type);
627
628         for (ix = 0;
629              VEC_iterate (tdesc_type_field, tdesc_type->u.u.fields, ix, f);
630              ix++)
631           {
632             if (f->type == NULL)
633               {
634                 /* Bitfield.  */
635                 struct field *fld;
636                 struct type *field_type;
637                 int bitsize, total_size;
638
639                 /* This invariant should be preserved while creating
640                    types.  */
641                 gdb_assert (tdesc_type->u.u.size != 0);
642                 if (tdesc_type->u.u.size > 4)
643                   field_type = builtin_type (gdbarch)->builtin_uint64;
644                 else
645                   field_type = builtin_type (gdbarch)->builtin_uint32;
646
647                 fld = append_composite_type_field_raw (type, xstrdup (f->name),
648                                                        field_type);
649
650                 /* For little-endian, BITPOS counts from the LSB of
651                    the structure and marks the LSB of the field.  For
652                    big-endian, BITPOS counts from the MSB of the
653                    structure and marks the MSB of the field.  Either
654                    way, it is the number of bits to the "left" of the
655                    field.  To calculate this in big-endian, we need
656                    the total size of the structure.  */
657                 bitsize = f->end - f->start + 1;
658                 total_size = tdesc_type->u.u.size * TARGET_CHAR_BIT;
659                 if (gdbarch_bits_big_endian (gdbarch))
660                   FIELD_BITPOS (fld[0]) = total_size - f->start - bitsize;
661                 else
662                   FIELD_BITPOS (fld[0]) = f->start;
663                 FIELD_BITSIZE (fld[0]) = bitsize;
664               }
665             else
666               {
667                 field_type = tdesc_gdb_type (gdbarch, f->type);
668                 append_composite_type_field (type, xstrdup (f->name),
669                                              field_type);
670               }
671           }
672
673         if (tdesc_type->u.u.size != 0)
674           TYPE_LENGTH (type) = tdesc_type->u.u.size;
675         return type;
676       }
677
678     case TDESC_TYPE_UNION:
679       {
680         struct type *type, *field_type;
681         struct tdesc_type_field *f;
682         int ix;
683
684         type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION);
685         TYPE_NAME (type) = xstrdup (tdesc_type->name);
686
687         for (ix = 0;
688              VEC_iterate (tdesc_type_field, tdesc_type->u.u.fields, ix, f);
689              ix++)
690           {
691             field_type = tdesc_gdb_type (gdbarch, f->type);
692             append_composite_type_field (type, xstrdup (f->name), field_type);
693
694             /* If any of the children of a union are vectors, flag the
695                union as a vector also.  This allows e.g. a union of two
696                vector types to show up automatically in "info vector".  */
697             if (TYPE_VECTOR (field_type))
698               TYPE_VECTOR (type) = 1;
699           }
700         return type;
701       }
702
703     case TDESC_TYPE_FLAGS:
704       {
705         struct tdesc_type_flag *f;
706         int ix;
707
708         type = arch_flags_type (gdbarch, tdesc_type->name,
709                                 tdesc_type->u.f.size);
710         for (ix = 0;
711              VEC_iterate (tdesc_type_flag, tdesc_type->u.f.flags, ix, f);
712              ix++)
713           /* Note that contrary to the function name, this call will
714              just set the properties of an already-allocated
715              field.  */
716           append_flags_type_flag (type, f->start,
717                                   *f->name ? f->name : NULL);
718
719         return type;
720       }
721     }
722
723   internal_error (__FILE__, __LINE__,
724                   "Type \"%s\" has an unknown kind %d",
725                   tdesc_type->name, tdesc_type->kind);
726 }
727 \f
728
729 /* Support for registers from target descriptions.  */
730
731 /* Construct the per-gdbarch data.  */
732
733 static void *
734 tdesc_data_init (struct obstack *obstack)
735 {
736   struct tdesc_arch_data *data;
737
738   data = OBSTACK_ZALLOC (obstack, struct tdesc_arch_data);
739   return data;
740 }
741
742 /* Similar, but for the temporary copy used during architecture
743    initialization.  */
744
745 struct tdesc_arch_data *
746 tdesc_data_alloc (void)
747 {
748   return XZALLOC (struct tdesc_arch_data);
749 }
750
751 /* Free something allocated by tdesc_data_alloc, if it is not going
752    to be used (for instance if it was unsuitable for the
753    architecture).  */
754
755 void
756 tdesc_data_cleanup (void *data_untyped)
757 {
758   struct tdesc_arch_data *data = data_untyped;
759
760   VEC_free (tdesc_arch_reg, data->arch_regs);
761   xfree (data);
762 }
763
764 /* Search FEATURE for a register named NAME.  */
765
766 static struct tdesc_reg *
767 tdesc_find_register_early (const struct tdesc_feature *feature,
768                            const char *name)
769 {
770   int ixr;
771   struct tdesc_reg *reg;
772
773   for (ixr = 0;
774        VEC_iterate (tdesc_reg_p, feature->registers, ixr, reg);
775        ixr++)
776     if (strcasecmp (reg->name, name) == 0)
777       return reg;
778
779   return NULL;
780 }
781
782 /* Search FEATURE for a register named NAME.  Assign REGNO to it.  */
783
784 int
785 tdesc_numbered_register (const struct tdesc_feature *feature,
786                          struct tdesc_arch_data *data,
787                          int regno, const char *name)
788 {
789   struct tdesc_arch_reg arch_reg = { 0 };
790   struct tdesc_reg *reg = tdesc_find_register_early (feature, name);
791
792   if (reg == NULL)
793     return 0;
794
795   /* Make sure the vector includes a REGNO'th element.  */
796   while (regno >= VEC_length (tdesc_arch_reg, data->arch_regs))
797     VEC_safe_push (tdesc_arch_reg, data->arch_regs, &arch_reg);
798
799   arch_reg.reg = reg;
800   VEC_replace (tdesc_arch_reg, data->arch_regs, regno, &arch_reg);
801   return 1;
802 }
803
804 /* Search FEATURE for a register named NAME, but do not assign a fixed
805    register number to it.  */
806
807 int
808 tdesc_unnumbered_register (const struct tdesc_feature *feature,
809                            const char *name)
810 {
811   struct tdesc_reg *reg = tdesc_find_register_early (feature, name);
812
813   if (reg == NULL)
814     return 0;
815
816   return 1;
817 }
818
819 /* Search FEATURE for a register whose name is in NAMES and assign
820    REGNO to it.  */
821
822 int
823 tdesc_numbered_register_choices (const struct tdesc_feature *feature,
824                                  struct tdesc_arch_data *data,
825                                  int regno, const char *const names[])
826 {
827   int i;
828
829   for (i = 0; names[i] != NULL; i++)
830     if (tdesc_numbered_register (feature, data, regno, names[i]))
831       return 1;
832
833   return 0;
834 }
835
836 /* Search FEATURE for a register named NAME, and return its size in
837    bits.  The register must exist.  */
838
839 int
840 tdesc_register_size (const struct tdesc_feature *feature,
841                      const char *name)
842 {
843   struct tdesc_reg *reg = tdesc_find_register_early (feature, name);
844
845   gdb_assert (reg != NULL);
846   return reg->bitsize;
847 }
848
849 /* Look up a register by its GDB internal register number.  */
850
851 static struct tdesc_arch_reg *
852 tdesc_find_arch_register (struct gdbarch *gdbarch, int regno)
853 {
854   struct tdesc_arch_data *data;
855
856   data = gdbarch_data (gdbarch, tdesc_data);
857   if (regno < VEC_length (tdesc_arch_reg, data->arch_regs))
858     return VEC_index (tdesc_arch_reg, data->arch_regs, regno);
859   else
860     return NULL;
861 }
862
863 static struct tdesc_reg *
864 tdesc_find_register (struct gdbarch *gdbarch, int regno)
865 {
866   struct tdesc_arch_reg *reg = tdesc_find_arch_register (gdbarch, regno);
867
868   return reg? reg->reg : NULL;
869 }
870
871 /* Return the name of register REGNO, from the target description or
872    from an architecture-provided pseudo_register_name method.  */
873
874 const char *
875 tdesc_register_name (struct gdbarch *gdbarch, int regno)
876 {
877   struct tdesc_reg *reg = tdesc_find_register (gdbarch, regno);
878   int num_regs = gdbarch_num_regs (gdbarch);
879   int num_pseudo_regs = gdbarch_num_pseudo_regs (gdbarch);
880
881   if (reg != NULL)
882     return reg->name;
883
884   if (regno >= num_regs && regno < num_regs + num_pseudo_regs)
885     {
886       struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
887
888       gdb_assert (data->pseudo_register_name != NULL);
889       return data->pseudo_register_name (gdbarch, regno);
890     }
891
892   return "";
893 }
894
895 struct type *
896 tdesc_register_type (struct gdbarch *gdbarch, int regno)
897 {
898   struct tdesc_arch_reg *arch_reg = tdesc_find_arch_register (gdbarch, regno);
899   struct tdesc_reg *reg = arch_reg? arch_reg->reg : NULL;
900   int num_regs = gdbarch_num_regs (gdbarch);
901   int num_pseudo_regs = gdbarch_num_pseudo_regs (gdbarch);
902
903   if (reg == NULL && regno >= num_regs && regno < num_regs + num_pseudo_regs)
904     {
905       struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
906
907       gdb_assert (data->pseudo_register_type != NULL);
908       return data->pseudo_register_type (gdbarch, regno);
909     }
910
911   if (reg == NULL)
912     /* Return "int0_t", since "void" has a misleading size of one.  */
913     return builtin_type (gdbarch)->builtin_int0;
914
915   if (arch_reg->type == NULL)
916     {
917       /* First check for a predefined or target defined type.  */
918       if (reg->tdesc_type)
919         arch_reg->type = tdesc_gdb_type (gdbarch, reg->tdesc_type);
920
921       /* Next try size-sensitive type shortcuts.  */
922       else if (strcmp (reg->type, "float") == 0)
923         {
924           if (reg->bitsize == gdbarch_float_bit (gdbarch))
925             arch_reg->type = builtin_type (gdbarch)->builtin_float;
926           else if (reg->bitsize == gdbarch_double_bit (gdbarch))
927             arch_reg->type = builtin_type (gdbarch)->builtin_double;
928           else if (reg->bitsize == gdbarch_long_double_bit (gdbarch))
929             arch_reg->type = builtin_type (gdbarch)->builtin_long_double;
930           else
931             {
932               warning (_("Register \"%s\" has an unsupported size (%d bits)"),
933                        reg->name, reg->bitsize);
934               arch_reg->type = builtin_type (gdbarch)->builtin_double;
935             }
936         }
937       else if (strcmp (reg->type, "int") == 0)
938         {
939           if (reg->bitsize == gdbarch_long_bit (gdbarch))
940             arch_reg->type = builtin_type (gdbarch)->builtin_long;
941           else if (reg->bitsize == TARGET_CHAR_BIT)
942             arch_reg->type = builtin_type (gdbarch)->builtin_char;
943           else if (reg->bitsize == gdbarch_short_bit (gdbarch))
944             arch_reg->type = builtin_type (gdbarch)->builtin_short;
945           else if (reg->bitsize == gdbarch_int_bit (gdbarch))
946             arch_reg->type = builtin_type (gdbarch)->builtin_int;
947           else if (reg->bitsize == gdbarch_long_long_bit (gdbarch))
948             arch_reg->type = builtin_type (gdbarch)->builtin_long_long;
949           else if (reg->bitsize == gdbarch_ptr_bit (gdbarch))
950           /* A bit desperate by this point...  */
951             arch_reg->type = builtin_type (gdbarch)->builtin_data_ptr;
952           else
953             {
954               warning (_("Register \"%s\" has an unsupported size (%d bits)"),
955                        reg->name, reg->bitsize);
956               arch_reg->type = builtin_type (gdbarch)->builtin_long;
957             }
958         }
959
960       if (arch_reg->type == NULL)
961         internal_error (__FILE__, __LINE__,
962                         "Register \"%s\" has an unknown type \"%s\"",
963                         reg->name, reg->type);
964     }
965
966   return arch_reg->type;
967 }
968
969 static int
970 tdesc_remote_register_number (struct gdbarch *gdbarch, int regno)
971 {
972   struct tdesc_reg *reg = tdesc_find_register (gdbarch, regno);
973
974   if (reg != NULL)
975     return reg->target_regnum;
976   else
977     return -1;
978 }
979
980 /* Check whether REGNUM is a member of REGGROUP.  Registers from the
981    target description may be classified as general, float, or vector.
982    Unlike a gdbarch register_reggroup_p method, this function will
983    return -1 if it does not know; the caller should handle registers
984    with no specified group.
985
986    Arbitrary strings (other than "general", "float", and "vector")
987    from the description are not used; they cause the register to be
988    displayed in "info all-registers" but excluded from "info
989    registers" et al.  The names of containing features are also not
990    used.  This might be extended to display registers in some more
991    useful groupings.
992
993    The save-restore flag is also implemented here.  */
994
995 int
996 tdesc_register_in_reggroup_p (struct gdbarch *gdbarch, int regno,
997                               struct reggroup *reggroup)
998 {
999   struct tdesc_reg *reg = tdesc_find_register (gdbarch, regno);
1000
1001   if (reg != NULL && reg->group != NULL)
1002     {
1003       int general_p = 0, float_p = 0, vector_p = 0;
1004
1005       if (strcmp (reg->group, "general") == 0)
1006         general_p = 1;
1007       else if (strcmp (reg->group, "float") == 0)
1008         float_p = 1;
1009       else if (strcmp (reg->group, "vector") == 0)
1010         vector_p = 1;
1011
1012       if (reggroup == float_reggroup)
1013         return float_p;
1014
1015       if (reggroup == vector_reggroup)
1016         return vector_p;
1017
1018       if (reggroup == general_reggroup)
1019         return general_p;
1020     }
1021
1022   if (reg != NULL
1023       && (reggroup == save_reggroup || reggroup == restore_reggroup))
1024     return reg->save_restore;
1025
1026   return -1;
1027 }
1028
1029 /* Check whether REGNUM is a member of REGGROUP.  Registers with no
1030    group specified go to the default reggroup function and are handled
1031    by type.  */
1032
1033 static int
1034 tdesc_register_reggroup_p (struct gdbarch *gdbarch, int regno,
1035                            struct reggroup *reggroup)
1036 {
1037   int num_regs = gdbarch_num_regs (gdbarch);
1038   int num_pseudo_regs = gdbarch_num_pseudo_regs (gdbarch);
1039   int ret;
1040
1041   if (regno >= num_regs && regno < num_regs + num_pseudo_regs)
1042     {
1043       struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
1044
1045       if (data->pseudo_register_reggroup_p != NULL)
1046         return data->pseudo_register_reggroup_p (gdbarch, regno, reggroup);
1047       /* Otherwise fall through to the default reggroup_p.  */
1048     }
1049
1050   ret = tdesc_register_in_reggroup_p (gdbarch, regno, reggroup);
1051   if (ret != -1)
1052     return ret;
1053
1054   return default_register_reggroup_p (gdbarch, regno, reggroup);
1055 }
1056
1057 /* Record architecture-specific functions to call for pseudo-register
1058    support.  */
1059
1060 void
1061 set_tdesc_pseudo_register_name (struct gdbarch *gdbarch,
1062                                 gdbarch_register_name_ftype *pseudo_name)
1063 {
1064   struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
1065
1066   data->pseudo_register_name = pseudo_name;
1067 }
1068
1069 void
1070 set_tdesc_pseudo_register_type (struct gdbarch *gdbarch,
1071                                 gdbarch_register_type_ftype *pseudo_type)
1072 {
1073   struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
1074
1075   data->pseudo_register_type = pseudo_type;
1076 }
1077
1078 void
1079 set_tdesc_pseudo_register_reggroup_p
1080   (struct gdbarch *gdbarch,
1081    gdbarch_register_reggroup_p_ftype *pseudo_reggroup_p)
1082 {
1083   struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
1084
1085   data->pseudo_register_reggroup_p = pseudo_reggroup_p;
1086 }
1087
1088 /* Update GDBARCH to use the target description for registers.  */
1089
1090 void
1091 tdesc_use_registers (struct gdbarch *gdbarch,
1092                      const struct target_desc *target_desc,
1093                      struct tdesc_arch_data *early_data)
1094 {
1095   int num_regs = gdbarch_num_regs (gdbarch);
1096   int ixf, ixr;
1097   struct tdesc_feature *feature;
1098   struct tdesc_reg *reg;
1099   struct tdesc_arch_data *data;
1100   struct tdesc_arch_reg *arch_reg, new_arch_reg = { 0 };
1101   htab_t reg_hash;
1102
1103   /* We can't use the description for registers if it doesn't describe
1104      any.  This function should only be called after validating
1105      registers, so the caller should know that registers are
1106      included.  */
1107   gdb_assert (tdesc_has_registers (target_desc));
1108
1109   data = gdbarch_data (gdbarch, tdesc_data);
1110   data->arch_regs = early_data->arch_regs;
1111   xfree (early_data);
1112
1113   /* Build up a set of all registers, so that we can assign register
1114      numbers where needed.  The hash table expands as necessary, so
1115      the initial size is arbitrary.  */
1116   reg_hash = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
1117   for (ixf = 0;
1118        VEC_iterate (tdesc_feature_p, target_desc->features, ixf, feature);
1119        ixf++)
1120     for (ixr = 0;
1121          VEC_iterate (tdesc_reg_p, feature->registers, ixr, reg);
1122          ixr++)
1123       {
1124         void **slot = htab_find_slot (reg_hash, reg, INSERT);
1125
1126         *slot = reg;
1127       }
1128
1129   /* Remove any registers which were assigned numbers by the
1130      architecture.  */
1131   for (ixr = 0;
1132        VEC_iterate (tdesc_arch_reg, data->arch_regs, ixr, arch_reg);
1133        ixr++)
1134     if (arch_reg->reg)
1135       htab_remove_elt (reg_hash, arch_reg->reg);
1136
1137   /* Assign numbers to the remaining registers and add them to the
1138      list of registers.  The new numbers are always above gdbarch_num_regs.
1139      Iterate over the features, not the hash table, so that the order
1140      matches that in the target description.  */
1141
1142   gdb_assert (VEC_length (tdesc_arch_reg, data->arch_regs) <= num_regs);
1143   while (VEC_length (tdesc_arch_reg, data->arch_regs) < num_regs)
1144     VEC_safe_push (tdesc_arch_reg, data->arch_regs, &new_arch_reg);
1145   for (ixf = 0;
1146        VEC_iterate (tdesc_feature_p, target_desc->features, ixf, feature);
1147        ixf++)
1148     for (ixr = 0;
1149          VEC_iterate (tdesc_reg_p, feature->registers, ixr, reg);
1150          ixr++)
1151       if (htab_find (reg_hash, reg) != NULL)
1152         {
1153           new_arch_reg.reg = reg;
1154           VEC_safe_push (tdesc_arch_reg, data->arch_regs, &new_arch_reg);
1155           num_regs++;
1156         }
1157
1158   htab_delete (reg_hash);
1159
1160   /* Update the architecture.  */
1161   set_gdbarch_num_regs (gdbarch, num_regs);
1162   set_gdbarch_register_name (gdbarch, tdesc_register_name);
1163   set_gdbarch_register_type (gdbarch, tdesc_register_type);
1164   set_gdbarch_remote_register_number (gdbarch,
1165                                       tdesc_remote_register_number);
1166   set_gdbarch_register_reggroup_p (gdbarch, tdesc_register_reggroup_p);
1167 }
1168 \f
1169
1170 /* Methods for constructing a target description.  */
1171
1172 static void
1173 tdesc_free_reg (struct tdesc_reg *reg)
1174 {
1175   xfree (reg->name);
1176   xfree (reg->type);
1177   xfree (reg->group);
1178   xfree (reg);
1179 }
1180
1181 void
1182 tdesc_create_reg (struct tdesc_feature *feature, const char *name,
1183                   int regnum, int save_restore, const char *group,
1184                   int bitsize, const char *type)
1185 {
1186   struct tdesc_reg *reg = XZALLOC (struct tdesc_reg);
1187
1188   reg->name = xstrdup (name);
1189   reg->target_regnum = regnum;
1190   reg->save_restore = save_restore;
1191   reg->group = group ? xstrdup (group) : NULL;
1192   reg->bitsize = bitsize;
1193   reg->type = type ? xstrdup (type) : xstrdup ("<unknown>");
1194
1195   /* If the register's type is target-defined, look it up now.  We may not
1196      have easy access to the containing feature when we want it later.  */
1197   reg->tdesc_type = tdesc_named_type (feature, reg->type);
1198
1199   VEC_safe_push (tdesc_reg_p, feature->registers, reg);
1200 }
1201
1202 static void
1203 tdesc_free_type (struct tdesc_type *type)
1204 {
1205   switch (type->kind)
1206     {
1207     case TDESC_TYPE_STRUCT:
1208     case TDESC_TYPE_UNION:
1209       {
1210         struct tdesc_type_field *f;
1211         int ix;
1212
1213         for (ix = 0;
1214              VEC_iterate (tdesc_type_field, type->u.u.fields, ix, f);
1215              ix++)
1216           xfree (f->name);
1217
1218         VEC_free (tdesc_type_field, type->u.u.fields);
1219       }
1220       break;
1221
1222     case TDESC_TYPE_FLAGS:
1223       {
1224         struct tdesc_type_flag *f;
1225         int ix;
1226
1227         for (ix = 0;
1228              VEC_iterate (tdesc_type_flag, type->u.f.flags, ix, f);
1229              ix++)
1230           xfree (f->name);
1231
1232         VEC_free (tdesc_type_flag, type->u.f.flags);
1233       }
1234       break;
1235
1236     default:
1237       break;
1238     }
1239
1240   xfree (type->name);
1241   xfree (type);
1242 }
1243
1244 struct tdesc_type *
1245 tdesc_create_vector (struct tdesc_feature *feature, const char *name,
1246                      struct tdesc_type *field_type, int count)
1247 {
1248   struct tdesc_type *type = XZALLOC (struct tdesc_type);
1249
1250   type->name = xstrdup (name);
1251   type->kind = TDESC_TYPE_VECTOR;
1252   type->u.v.type = field_type;
1253   type->u.v.count = count;
1254
1255   VEC_safe_push (tdesc_type_p, feature->types, type);
1256   return type;
1257 }
1258
1259 struct tdesc_type *
1260 tdesc_create_struct (struct tdesc_feature *feature, const char *name)
1261 {
1262   struct tdesc_type *type = XZALLOC (struct tdesc_type);
1263
1264   type->name = xstrdup (name);
1265   type->kind = TDESC_TYPE_STRUCT;
1266
1267   VEC_safe_push (tdesc_type_p, feature->types, type);
1268   return type;
1269 }
1270
1271 /* Set the total length of TYPE.  Structs which contain bitfields may
1272    omit the reserved bits, so the end of the last field may not
1273    suffice.  */
1274
1275 void
1276 tdesc_set_struct_size (struct tdesc_type *type, LONGEST size)
1277 {
1278   gdb_assert (type->kind == TDESC_TYPE_STRUCT);
1279   type->u.u.size = size;
1280 }
1281
1282 struct tdesc_type *
1283 tdesc_create_union (struct tdesc_feature *feature, const char *name)
1284 {
1285   struct tdesc_type *type = XZALLOC (struct tdesc_type);
1286
1287   type->name = xstrdup (name);
1288   type->kind = TDESC_TYPE_UNION;
1289
1290   VEC_safe_push (tdesc_type_p, feature->types, type);
1291   return type;
1292 }
1293
1294 struct tdesc_type *
1295 tdesc_create_flags (struct tdesc_feature *feature, const char *name,
1296                     LONGEST size)
1297 {
1298   struct tdesc_type *type = XZALLOC (struct tdesc_type);
1299
1300   type->name = xstrdup (name);
1301   type->kind = TDESC_TYPE_FLAGS;
1302   type->u.f.size = size;
1303
1304   VEC_safe_push (tdesc_type_p, feature->types, type);
1305   return type;
1306 }
1307
1308 /* Add a new field.  Return a temporary pointer to the field, which
1309    is only valid until the next call to tdesc_add_field (the vector
1310    might be reallocated).  */
1311
1312 void
1313 tdesc_add_field (struct tdesc_type *type, const char *field_name,
1314                  struct tdesc_type *field_type)
1315 {
1316   struct tdesc_type_field f = { 0 };
1317
1318   gdb_assert (type->kind == TDESC_TYPE_UNION
1319               || type->kind == TDESC_TYPE_STRUCT);
1320
1321   f.name = xstrdup (field_name);
1322   f.type = field_type;
1323
1324   VEC_safe_push (tdesc_type_field, type->u.u.fields, &f);
1325 }
1326
1327 /* Add a new bitfield.  */
1328
1329 void
1330 tdesc_add_bitfield (struct tdesc_type *type, const char *field_name,
1331                     int start, int end)
1332 {
1333   struct tdesc_type_field f = { 0 };
1334
1335   gdb_assert (type->kind == TDESC_TYPE_STRUCT);
1336
1337   f.name = xstrdup (field_name);
1338   f.start = start;
1339   f.end = end;
1340
1341   VEC_safe_push (tdesc_type_field, type->u.u.fields, &f);
1342 }
1343
1344 void
1345 tdesc_add_flag (struct tdesc_type *type, int start,
1346                 const char *flag_name)
1347 {
1348   struct tdesc_type_flag f = { 0 };
1349
1350   gdb_assert (type->kind == TDESC_TYPE_FLAGS);
1351
1352   f.name = xstrdup (flag_name);
1353   f.start = start;
1354
1355   VEC_safe_push (tdesc_type_flag, type->u.f.flags, &f);
1356 }
1357
1358 static void
1359 tdesc_free_feature (struct tdesc_feature *feature)
1360 {
1361   struct tdesc_reg *reg;
1362   struct tdesc_type *type;
1363   int ix;
1364
1365   for (ix = 0; VEC_iterate (tdesc_reg_p, feature->registers, ix, reg); ix++)
1366     tdesc_free_reg (reg);
1367   VEC_free (tdesc_reg_p, feature->registers);
1368
1369   for (ix = 0; VEC_iterate (tdesc_type_p, feature->types, ix, type); ix++)
1370     tdesc_free_type (type);
1371   VEC_free (tdesc_type_p, feature->types);
1372
1373   xfree (feature->name);
1374   xfree (feature);
1375 }
1376
1377 struct tdesc_feature *
1378 tdesc_create_feature (struct target_desc *tdesc, const char *name)
1379 {
1380   struct tdesc_feature *new_feature = XZALLOC (struct tdesc_feature);
1381
1382   new_feature->name = xstrdup (name);
1383
1384   VEC_safe_push (tdesc_feature_p, tdesc->features, new_feature);
1385   return new_feature;
1386 }
1387
1388 struct target_desc *
1389 allocate_target_description (void)
1390 {
1391   return XZALLOC (struct target_desc);
1392 }
1393
1394 static void
1395 free_target_description (void *arg)
1396 {
1397   struct target_desc *target_desc = arg;
1398   struct tdesc_feature *feature;
1399   struct property *prop;
1400   int ix;
1401
1402   for (ix = 0;
1403        VEC_iterate (tdesc_feature_p, target_desc->features, ix, feature);
1404        ix++)
1405     tdesc_free_feature (feature);
1406   VEC_free (tdesc_feature_p, target_desc->features);
1407
1408   for (ix = 0;
1409        VEC_iterate (property_s, target_desc->properties, ix, prop);
1410        ix++)
1411     {
1412       xfree (prop->key);
1413       xfree (prop->value);
1414     }
1415   VEC_free (property_s, target_desc->properties);
1416
1417   VEC_free (arch_p, target_desc->compatible);
1418
1419   xfree (target_desc);
1420 }
1421
1422 struct cleanup *
1423 make_cleanup_free_target_description (struct target_desc *target_desc)
1424 {
1425   return make_cleanup (free_target_description, target_desc);
1426 }
1427
1428 void
1429 tdesc_add_compatible (struct target_desc *target_desc,
1430                       const struct bfd_arch_info *compatible)
1431 {
1432   const struct bfd_arch_info *compat;
1433   int ix;
1434
1435   /* If this instance of GDB is compiled without BFD support for the
1436      compatible architecture, simply ignore it -- we would not be able
1437      to handle it anyway.  */
1438   if (compatible == NULL)
1439     return;
1440
1441   for (ix = 0; VEC_iterate (arch_p, target_desc->compatible, ix, compat);
1442        ix++)
1443     if (compat == compatible)
1444       internal_error (__FILE__, __LINE__,
1445                       _("Attempted to add duplicate "
1446                         "compatible architecture \"%s\""),
1447                       compatible->printable_name);
1448
1449   VEC_safe_push (arch_p, target_desc->compatible, compatible);
1450 }
1451
1452 void
1453 set_tdesc_property (struct target_desc *target_desc,
1454                     const char *key, const char *value)
1455 {
1456   struct property *prop, new_prop;
1457   int ix;
1458
1459   gdb_assert (key != NULL && value != NULL);
1460
1461   for (ix = 0; VEC_iterate (property_s, target_desc->properties, ix, prop);
1462        ix++)
1463     if (strcmp (prop->key, key) == 0)
1464       internal_error (__FILE__, __LINE__,
1465                       _("Attempted to add duplicate property \"%s\""), key);
1466
1467   new_prop.key = xstrdup (key);
1468   new_prop.value = xstrdup (value);
1469   VEC_safe_push (property_s, target_desc->properties, &new_prop);
1470 }
1471
1472 void
1473 set_tdesc_architecture (struct target_desc *target_desc,
1474                         const struct bfd_arch_info *arch)
1475 {
1476   target_desc->arch = arch;
1477 }
1478
1479 void
1480 set_tdesc_osabi (struct target_desc *target_desc, enum gdb_osabi osabi)
1481 {
1482   target_desc->osabi = osabi;
1483 }
1484 \f
1485
1486 static struct cmd_list_element *tdesc_set_cmdlist, *tdesc_show_cmdlist;
1487 static struct cmd_list_element *tdesc_unset_cmdlist;
1488
1489 /* Helper functions for the CLI commands.  */
1490
1491 static void
1492 set_tdesc_cmd (char *args, int from_tty)
1493 {
1494   help_list (tdesc_set_cmdlist, "set tdesc ", -1, gdb_stdout);
1495 }
1496
1497 static void
1498 show_tdesc_cmd (char *args, int from_tty)
1499 {
1500   cmd_show_list (tdesc_show_cmdlist, from_tty, "");
1501 }
1502
1503 static void
1504 unset_tdesc_cmd (char *args, int from_tty)
1505 {
1506   help_list (tdesc_unset_cmdlist, "unset tdesc ", -1, gdb_stdout);
1507 }
1508
1509 static void
1510 set_tdesc_filename_cmd (char *args, int from_tty,
1511                         struct cmd_list_element *c)
1512 {
1513   target_clear_description ();
1514   target_find_description ();
1515 }
1516
1517 static void
1518 show_tdesc_filename_cmd (struct ui_file *file, int from_tty,
1519                          struct cmd_list_element *c,
1520                          const char *value)
1521 {
1522   if (value != NULL && *value != '\0')
1523     printf_filtered (_("The target description will be read from \"%s\".\n"),
1524                      value);
1525   else
1526     printf_filtered (_("The target description will be "
1527                        "read from the target.\n"));
1528 }
1529
1530 static void
1531 unset_tdesc_filename_cmd (char *args, int from_tty)
1532 {
1533   xfree (target_description_filename);
1534   target_description_filename = NULL;
1535   target_clear_description ();
1536   target_find_description ();
1537 }
1538
1539 static void
1540 maint_print_c_tdesc_cmd (char *args, int from_tty)
1541 {
1542   const struct target_desc *tdesc;
1543   const struct bfd_arch_info *compatible;
1544   const char *filename, *inp;
1545   char *function, *outp;
1546   struct property *prop;
1547   struct tdesc_feature *feature;
1548   struct tdesc_reg *reg;
1549   struct tdesc_type *type;
1550   struct tdesc_type_field *f;
1551   struct tdesc_type_flag *flag;
1552   int ix, ix2, ix3;
1553
1554   /* Use the global target-supplied description, not the current
1555      architecture's.  This lets a GDB for one architecture generate C
1556      for another architecture's description, even though the gdbarch
1557      initialization code will reject the new description.  */
1558   tdesc = current_target_desc;
1559   if (tdesc == NULL)
1560     error (_("There is no target description to print."));
1561
1562   if (target_description_filename == NULL)
1563     error (_("The current target description did not come from an XML file."));
1564
1565   filename = lbasename (target_description_filename);
1566   function = alloca (strlen (filename) + 1);
1567   for (inp = filename, outp = function; *inp != '\0'; inp++)
1568     if (*inp == '.')
1569       break;
1570     else if (*inp == '-')
1571       *outp++ = '_';
1572     else
1573       *outp++ = *inp;
1574   *outp = '\0';
1575
1576   /* Standard boilerplate.  */
1577   printf_unfiltered ("/* THIS FILE IS GENERATED.  Original: %s */\n\n",
1578                      filename);
1579   printf_unfiltered ("#include \"defs.h\"\n");
1580   printf_unfiltered ("#include \"osabi.h\"\n");
1581   printf_unfiltered ("#include \"target-descriptions.h\"\n");
1582   printf_unfiltered ("\n");
1583
1584   printf_unfiltered ("struct target_desc *tdesc_%s;\n", function);
1585   printf_unfiltered ("static void\n");
1586   printf_unfiltered ("initialize_tdesc_%s (void)\n", function);
1587   printf_unfiltered ("{\n");
1588   printf_unfiltered
1589     ("  struct target_desc *result = allocate_target_description ();\n");
1590   printf_unfiltered ("  struct tdesc_feature *feature;\n");
1591   printf_unfiltered ("  struct tdesc_type *field_type, *type;\n");
1592   printf_unfiltered ("\n");
1593
1594   if (tdesc_architecture (tdesc) != NULL)
1595     {
1596       printf_unfiltered
1597         ("  set_tdesc_architecture (result, bfd_scan_arch (\"%s\"));\n",
1598          tdesc_architecture (tdesc)->printable_name);
1599       printf_unfiltered ("\n");
1600     }
1601
1602   if (tdesc_osabi (tdesc) > GDB_OSABI_UNKNOWN
1603       && tdesc_osabi (tdesc) < GDB_OSABI_INVALID)
1604     {
1605       printf_unfiltered
1606         ("  set_tdesc_osabi (result, osabi_from_tdesc_string (\"%s\"));\n",
1607          gdbarch_osabi_name (tdesc_osabi (tdesc)));
1608       printf_unfiltered ("\n");
1609     }
1610
1611   for (ix = 0; VEC_iterate (arch_p, tdesc->compatible, ix, compatible);
1612        ix++)
1613     {
1614       printf_unfiltered
1615         ("  tdesc_add_compatible (result, bfd_scan_arch (\"%s\"));\n",
1616          compatible->printable_name);
1617     }
1618   if (ix)
1619     printf_unfiltered ("\n");
1620
1621   for (ix = 0; VEC_iterate (property_s, tdesc->properties, ix, prop);
1622        ix++)
1623     {
1624       printf_unfiltered ("  set_tdesc_property (result, \"%s\", \"%s\");\n",
1625               prop->key, prop->value);
1626     }
1627
1628   for (ix = 0;
1629        VEC_iterate (tdesc_feature_p, tdesc->features, ix, feature);
1630        ix++)
1631     {
1632       printf_unfiltered ("  \
1633 feature = tdesc_create_feature (result, \"%s\");\n",
1634                          feature->name);
1635
1636       for (ix2 = 0;
1637            VEC_iterate (tdesc_type_p, feature->types, ix2, type);
1638            ix2++)
1639         {
1640           switch (type->kind)
1641             {
1642             case TDESC_TYPE_VECTOR:
1643               printf_unfiltered
1644                 ("  field_type = tdesc_named_type (feature, \"%s\");\n",
1645                  type->u.v.type->name);
1646               printf_unfiltered
1647                 ("  tdesc_create_vector (feature, \"%s\", field_type, %d);\n",
1648                  type->name, type->u.v.count);
1649               break;
1650             case TDESC_TYPE_UNION:
1651               printf_unfiltered
1652                 ("  type = tdesc_create_union (feature, \"%s\");\n",
1653                  type->name);
1654               for (ix3 = 0;
1655                    VEC_iterate (tdesc_type_field, type->u.u.fields, ix3, f);
1656                    ix3++)
1657                 {
1658                   printf_unfiltered
1659                     ("  field_type = tdesc_named_type (feature, \"%s\");\n",
1660                      f->type->name);
1661                   printf_unfiltered
1662                     ("  tdesc_add_field (type, \"%s\", field_type);\n",
1663                      f->name);
1664                 }
1665               break;
1666             case TDESC_TYPE_FLAGS:
1667               printf_unfiltered
1668                 ("  field_type = tdesc_create_flags (feature, \"%s\", %d);\n",
1669                  type->name, (int) type->u.f.size);
1670               for (ix3 = 0;
1671                    VEC_iterate (tdesc_type_flag, type->u.f.flags, ix3,
1672                                 flag);
1673                    ix3++)
1674                 printf_unfiltered
1675                   ("  tdesc_add_flag (field_type, %d, \"%s\");\n",
1676                    flag->start, flag->name);
1677               break;
1678             default:
1679               error (_("C output is not supported type \"%s\"."), type->name);
1680             }
1681           printf_unfiltered ("\n");
1682         }
1683
1684       for (ix2 = 0;
1685            VEC_iterate (tdesc_reg_p, feature->registers, ix2, reg);
1686            ix2++)
1687         {
1688           printf_unfiltered ("  tdesc_create_reg (feature, \"%s\", %ld, %d, ",
1689                              reg->name, reg->target_regnum, reg->save_restore);
1690           if (reg->group)
1691             printf_unfiltered ("\"%s\", ", reg->group);
1692           else
1693             printf_unfiltered ("NULL, ");
1694           printf_unfiltered ("%d, \"%s\");\n", reg->bitsize, reg->type);
1695         }
1696
1697       printf_unfiltered ("\n");
1698     }
1699
1700   printf_unfiltered ("  tdesc_%s = result;\n", function);
1701   printf_unfiltered ("}\n");
1702 }
1703
1704 /* Provide a prototype to silence -Wmissing-prototypes.  */
1705 extern initialize_file_ftype _initialize_target_descriptions;
1706
1707 void
1708 _initialize_target_descriptions (void)
1709 {
1710   tdesc_data = gdbarch_data_register_pre_init (tdesc_data_init);
1711
1712   add_prefix_cmd ("tdesc", class_maintenance, set_tdesc_cmd, _("\
1713 Set target description specific variables."),
1714                   &tdesc_set_cmdlist, "set tdesc ",
1715                   0 /* allow-unknown */, &setlist);
1716   add_prefix_cmd ("tdesc", class_maintenance, show_tdesc_cmd, _("\
1717 Show target description specific variables."),
1718                   &tdesc_show_cmdlist, "show tdesc ",
1719                   0 /* allow-unknown */, &showlist);
1720   add_prefix_cmd ("tdesc", class_maintenance, unset_tdesc_cmd, _("\
1721 Unset target description specific variables."),
1722                   &tdesc_unset_cmdlist, "unset tdesc ",
1723                   0 /* allow-unknown */, &unsetlist);
1724
1725   add_setshow_filename_cmd ("filename", class_obscure,
1726                             &target_description_filename,
1727                             _("\
1728 Set the file to read for an XML target description"), _("\
1729 Show the file to read for an XML target description"), _("\
1730 When set, GDB will read the target description from a local\n\
1731 file instead of querying the remote target."),
1732                             set_tdesc_filename_cmd,
1733                             show_tdesc_filename_cmd,
1734                             &tdesc_set_cmdlist, &tdesc_show_cmdlist);
1735
1736   add_cmd ("filename", class_obscure, unset_tdesc_filename_cmd, _("\
1737 Unset the file to read for an XML target description.  When unset,\n\
1738 GDB will read the description from the target."),
1739            &tdesc_unset_cmdlist);
1740
1741   add_cmd ("c-tdesc", class_maintenance, maint_print_c_tdesc_cmd, _("\
1742 Print the current target description as a C source file."),
1743            &maintenanceprintlist);
1744 }