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