OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [gdb/] [target-descriptions.c] - Blame information for rev 24

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* Target description support for GDB.
2
 
3
   Copyright (C) 2006, 2007, 2008 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
 
33
#include "gdb_assert.h"
34
#include "gdb_obstack.h"
35
#include "hashtab.h"
36
 
37
/* Types.  */
38
 
39
typedef struct property
40
{
41
  char *key;
42
  char *value;
43
} property_s;
44
DEF_VEC_O(property_s);
45
 
46
/* An individual register from a target description.  */
47
 
48
typedef struct tdesc_reg
49
{
50
  /* The name of this register.  In standard features, it may be
51
     recognized by the architecture support code, or it may be purely
52
     for the user.  */
53
  char *name;
54
 
55
  /* The register number used by this target to refer to this
56
     register.  This is used for remote p/P packets and to determine
57
     the ordering of registers in the remote g/G packets.  */
58
  long target_regnum;
59
 
60
  /* If this flag is set, GDB should save and restore this register
61
     around calls to an inferior function.  */
62
  int save_restore;
63
 
64
  /* The name of the register group containing this register, or NULL
65
     if the group should be automatically determined from the
66
     register's type.  If this is "general", "float", or "vector", the
67
     corresponding "info" command should display this register's
68
     value.  It can be an arbitrary string, but should be limited to
69
     alphanumeric characters and internal hyphens.  Currently other
70
     strings are ignored (treated as NULL).  */
71
  char *group;
72
 
73
  /* The size of the register, in bits.  */
74
  int bitsize;
75
 
76
  /* The type of the register.  This string corresponds to either
77
     a named type from the target description or a predefined
78
     type from GDB.  */
79
  char *type;
80
 
81
  /* The target-described type corresponding to TYPE, if found.  */
82
  struct type *gdb_type;
83
} *tdesc_reg_p;
84
DEF_VEC_P(tdesc_reg_p);
85
 
86
/* A named type from a target description.  */
87
typedef struct type *type_p;
88
DEF_VEC_P(type_p);
89
 
90
/* A feature from a target description.  Each feature is a collection
91
   of other elements, e.g. registers and types.  */
92
 
93
typedef struct tdesc_feature
94
{
95
  /* The name of this feature.  It may be recognized by the architecture
96
     support code.  */
97
  char *name;
98
 
99
  /* The registers associated with this feature.  */
100
  VEC(tdesc_reg_p) *registers;
101
 
102
  /* The types associated with this feature.  */
103
  VEC(type_p) *types;
104
} *tdesc_feature_p;
105
DEF_VEC_P(tdesc_feature_p);
106
 
107
/* A target description.  */
108
 
109
struct target_desc
110
{
111
  /* The architecture reported by the target, if any.  */
112
  const struct bfd_arch_info *arch;
113
 
114
  /* Any architecture-specific properties specified by the target.  */
115
  VEC(property_s) *properties;
116
 
117
  /* The features associated with this target.  */
118
  VEC(tdesc_feature_p) *features;
119
};
120
 
121
/* Per-architecture data associated with a target description.  The
122
   target description may be shared by multiple architectures, but
123
   this data is private to one gdbarch.  */
124
 
125
struct tdesc_arch_data
126
{
127
  /* A list of registers, indexed by GDB's internal register number.
128
     During initialization of the gdbarch this list is used to store
129
     registers which the architecture assigns a fixed register number.
130
     Registers which are NULL in this array, or off the end, are
131
     treated as zero-sized and nameless (i.e. placeholders in the
132
     numbering).  */
133
  VEC(tdesc_reg_p) *registers;
134
 
135
  /* Functions which report the register name, type, and reggroups for
136
     pseudo-registers.  */
137
  gdbarch_register_name_ftype *pseudo_register_name;
138
  gdbarch_register_type_ftype *pseudo_register_type;
139
  gdbarch_register_reggroup_p_ftype *pseudo_register_reggroup_p;
140
};
141
 
142
/* Global state.  These variables are associated with the current
143
   target; if GDB adds support for multiple simultaneous targets, then
144
   these variables should become target-specific data.  */
145
 
146
/* A flag indicating that a description has already been fetched from
147
   the current target, so it should not be queried again.  */
148
 
149
static int target_desc_fetched;
150
 
151
/* The description fetched from the current target, or NULL if the
152
   current target did not supply any description.  Only valid when
153
   target_desc_fetched is set.  Only the description initialization
154
   code should access this; normally, the description should be
155
   accessed through the gdbarch object.  */
156
 
157
static const struct target_desc *current_target_desc;
158
 
159
/* Other global variables.  */
160
 
161
/* The filename to read a target description from.  */
162
 
163
static char *target_description_filename;
164
 
165
/* A handle for architecture-specific data associated with the
166
   target description (see struct tdesc_arch_data).  */
167
 
168
static struct gdbarch_data *tdesc_data;
169
 
170
/* Fetch the current target's description, and switch the current
171
   architecture to one which incorporates that description.  */
172
 
173
void
174
target_find_description (void)
175
{
176
  /* If we've already fetched a description from the target, don't do
177
     it again.  This allows a target to fetch the description early,
178
     during its to_open or to_create_inferior, if it needs extra
179
     information about the target to initialize.  */
180
  if (target_desc_fetched)
181
    return;
182
 
183
  /* The current architecture should not have any target description
184
     specified.  It should have been cleared, e.g. when we
185
     disconnected from the previous target.  */
186
  gdb_assert (gdbarch_target_desc (current_gdbarch) == NULL);
187
 
188
  /* First try to fetch an XML description from the user-specified
189
     file.  */
190
  current_target_desc = NULL;
191
  if (target_description_filename != NULL
192
      && *target_description_filename != '\0')
193
    current_target_desc
194
      = file_read_description_xml (target_description_filename);
195
 
196
  /* Next try to read the description from the current target using
197
     target objects.  */
198
  if (current_target_desc == NULL)
199
    current_target_desc = target_read_description_xml (&current_target);
200
 
201
  /* If that failed try a target-specific hook.  */
202
  if (current_target_desc == NULL)
203
    current_target_desc = target_read_description (&current_target);
204
 
205
  /* If a non-NULL description was returned, then update the current
206
     architecture.  */
207
  if (current_target_desc)
208
    {
209
      struct gdbarch_info info;
210
 
211
      gdbarch_info_init (&info);
212
      info.target_desc = current_target_desc;
213
      if (!gdbarch_update_p (info))
214
        warning (_("Architecture rejected target-supplied description"));
215
      else
216
        {
217
          struct tdesc_arch_data *data;
218
 
219
          data = gdbarch_data (current_gdbarch, tdesc_data);
220
          if (tdesc_has_registers (current_target_desc)
221
              && data->registers == NULL)
222
            warning (_("Target-supplied registers are not supported "
223
                       "by the current architecture"));
224
        }
225
    }
226
 
227
  /* Now that we know this description is usable, record that we
228
     fetched it.  */
229
  target_desc_fetched = 1;
230
}
231
 
232
/* Discard any description fetched from the current target, and switch
233
   the current architecture to one with no target description.  */
234
 
235
void
236
target_clear_description (void)
237
{
238
  struct gdbarch_info info;
239
 
240
  if (!target_desc_fetched)
241
    return;
242
 
243
  target_desc_fetched = 0;
244
  current_target_desc = NULL;
245
 
246
  gdbarch_info_init (&info);
247
  if (!gdbarch_update_p (info))
248
    internal_error (__FILE__, __LINE__,
249
                    _("Could not remove target-supplied description"));
250
}
251
 
252
/* Return the global current target description.  This should only be
253
   used by gdbarch initialization code; most access should be through
254
   an existing gdbarch.  */
255
 
256
const struct target_desc *
257
target_current_description (void)
258
{
259
  if (target_desc_fetched)
260
    return current_target_desc;
261
 
262
  return NULL;
263
}
264
 
265
 
266
/* Direct accessors for target descriptions.  */
267
 
268
/* Return the string value of a property named KEY, or NULL if the
269
   property was not specified.  */
270
 
271
const char *
272
tdesc_property (const struct target_desc *target_desc, const char *key)
273
{
274
  struct property *prop;
275
  int ix;
276
 
277
  for (ix = 0; VEC_iterate (property_s, target_desc->properties, ix, prop);
278
       ix++)
279
    if (strcmp (prop->key, key) == 0)
280
      return prop->value;
281
 
282
  return NULL;
283
}
284
 
285
/* Return the BFD architecture associated with this target
286
   description, or NULL if no architecture was specified.  */
287
 
288
const struct bfd_arch_info *
289
tdesc_architecture (const struct target_desc *target_desc)
290
{
291
  return target_desc->arch;
292
}
293
 
294
 
295
/* Return 1 if this target description includes any registers.  */
296
 
297
int
298
tdesc_has_registers (const struct target_desc *target_desc)
299
{
300
  int ix;
301
  struct tdesc_feature *feature;
302
 
303
  if (target_desc == NULL)
304
    return 0;
305
 
306
  for (ix = 0;
307
       VEC_iterate (tdesc_feature_p, target_desc->features, ix, feature);
308
       ix++)
309
    if (! VEC_empty (tdesc_reg_p, feature->registers))
310
      return 1;
311
 
312
  return 0;
313
}
314
 
315
/* Return the feature with the given name, if present, or NULL if
316
   the named feature is not found.  */
317
 
318
const struct tdesc_feature *
319
tdesc_find_feature (const struct target_desc *target_desc,
320
                    const char *name)
321
{
322
  int ix;
323
  struct tdesc_feature *feature;
324
 
325
  for (ix = 0;
326
       VEC_iterate (tdesc_feature_p, target_desc->features, ix, feature);
327
       ix++)
328
    if (strcmp (feature->name, name) == 0)
329
      return feature;
330
 
331
  return NULL;
332
}
333
 
334
/* Return the name of FEATURE.  */
335
 
336
const char *
337
tdesc_feature_name (const struct tdesc_feature *feature)
338
{
339
  return feature->name;
340
}
341
 
342
/* Predefined types.  Note that none of these types depend on the
343
   current architecture; some of the builtin_type_foo variables are
344
   swapped based on the architecture.  */
345
static struct
346
{
347
  const char *name;
348
  struct type **type;
349
} tdesc_predefined_types[] =
350
  {
351
    { "int8", &builtin_type_int8 },
352
    { "int16", &builtin_type_int16 },
353
    { "int32", &builtin_type_int32 },
354
    { "int64", &builtin_type_int64 },
355
    { "int128", &builtin_type_int128 },
356
    { "uint8", &builtin_type_uint8 },
357
    { "uint16", &builtin_type_uint16 },
358
    { "uint32", &builtin_type_uint32 },
359
    { "uint64", &builtin_type_uint64 },
360
    { "uint128", &builtin_type_uint128 },
361
    { "ieee_single", &builtin_type_ieee_single },
362
    { "ieee_double", &builtin_type_ieee_double },
363
    { "arm_fpa_ext", &builtin_type_arm_ext }
364
  };
365
 
366
/* Return the type associated with ID in the context of FEATURE, or
367
   NULL if none.  */
368
 
369
struct type *
370
tdesc_named_type (const struct tdesc_feature *feature, const char *id)
371
{
372
  int ix;
373
  struct type *gdb_type;
374
 
375
  /* First try target-defined types.  */
376
  for (ix = 0; VEC_iterate (type_p, feature->types, ix, gdb_type); ix++)
377
    if (strcmp (TYPE_NAME (gdb_type), id) == 0)
378
      return gdb_type;
379
 
380
  /* Next try the predefined types.  */
381
  for (ix = 0; ix < ARRAY_SIZE (tdesc_predefined_types); ix++)
382
    if (strcmp (tdesc_predefined_types[ix].name, id) == 0)
383
      return *tdesc_predefined_types[ix].type;
384
 
385
  return NULL;
386
}
387
 
388
 
389
/* Support for registers from target descriptions.  */
390
 
391
/* Construct the per-gdbarch data.  */
392
 
393
static void *
394
tdesc_data_init (struct obstack *obstack)
395
{
396
  struct tdesc_arch_data *data;
397
 
398
  data = OBSTACK_ZALLOC (obstack, struct tdesc_arch_data);
399
  return data;
400
}
401
 
402
/* Similar, but for the temporary copy used during architecture
403
   initialization.  */
404
 
405
struct tdesc_arch_data *
406
tdesc_data_alloc (void)
407
{
408
  return XZALLOC (struct tdesc_arch_data);
409
}
410
 
411
/* Free something allocated by tdesc_data_alloc, if it is not going
412
   to be used (for instance if it was unsuitable for the
413
   architecture).  */
414
 
415
void
416
tdesc_data_cleanup (void *data_untyped)
417
{
418
  struct tdesc_arch_data *data = data_untyped;
419
 
420
  VEC_free (tdesc_reg_p, data->registers);
421
  xfree (data);
422
}
423
 
424
/* Search FEATURE for a register named NAME.  */
425
 
426
static struct tdesc_reg *
427
tdesc_find_register_early (const struct tdesc_feature *feature,
428
                           const char *name)
429
{
430
  int ixr;
431
  struct tdesc_reg *reg;
432
 
433
  for (ixr = 0;
434
       VEC_iterate (tdesc_reg_p, feature->registers, ixr, reg);
435
       ixr++)
436
    if (strcasecmp (reg->name, name) == 0)
437
      return reg;
438
 
439
  return NULL;
440
}
441
 
442
/* Search FEATURE for a register named NAME.  Assign REGNO to it.  */
443
 
444
int
445
tdesc_numbered_register (const struct tdesc_feature *feature,
446
                         struct tdesc_arch_data *data,
447
                         int regno, const char *name)
448
{
449
  struct tdesc_reg *reg = tdesc_find_register_early (feature, name);
450
 
451
  if (reg == NULL)
452
    return 0;
453
 
454
  /* Make sure the vector includes a REGNO'th element.  */
455
  while (regno >= VEC_length (tdesc_reg_p, data->registers))
456
    VEC_safe_push (tdesc_reg_p, data->registers, NULL);
457
  VEC_replace (tdesc_reg_p, data->registers, regno, reg);
458
  return 1;
459
}
460
 
461
/* Search FEATURE for a register whose name is in NAMES and assign
462
   REGNO to it.  */
463
 
464
int
465
tdesc_numbered_register_choices (const struct tdesc_feature *feature,
466
                                 struct tdesc_arch_data *data,
467
                                 int regno, const char *const names[])
468
{
469
  int i;
470
 
471
  for (i = 0; names[i] != NULL; i++)
472
    if (tdesc_numbered_register (feature, data, regno, names[i]))
473
      return 1;
474
 
475
  return 0;
476
}
477
 
478
/* Search FEATURE for a register named NAME, and return its size in
479
   bits.  The register must exist.  */
480
 
481
int
482
tdesc_register_size (const struct tdesc_feature *feature,
483
                     const char *name)
484
{
485
  struct tdesc_reg *reg = tdesc_find_register_early (feature, name);
486
 
487
  gdb_assert (reg != NULL);
488
  return reg->bitsize;
489
}
490
 
491
/* Look up a register by its GDB internal register number.  */
492
 
493
static struct tdesc_reg *
494
tdesc_find_register (struct gdbarch *gdbarch, int regno)
495
{
496
  struct tdesc_reg *reg;
497
  struct tdesc_arch_data *data;
498
 
499
  data = gdbarch_data (gdbarch, tdesc_data);
500
  if (regno < VEC_length (tdesc_reg_p, data->registers))
501
    return VEC_index (tdesc_reg_p, data->registers, regno);
502
  else
503
    return NULL;
504
}
505
 
506
/* Return the name of register REGNO, from the target description or
507
   from an architecture-provided pseudo_register_name method.  */
508
 
509
const char *
510
tdesc_register_name (struct gdbarch *gdbarch, int regno)
511
{
512
  struct tdesc_reg *reg = tdesc_find_register (gdbarch, regno);
513
  int num_regs = gdbarch_num_regs (gdbarch);
514
  int num_pseudo_regs = gdbarch_num_pseudo_regs (gdbarch);
515
 
516
  if (reg != NULL)
517
    return reg->name;
518
 
519
  if (regno >= num_regs && regno < num_regs + num_pseudo_regs)
520
    {
521
      struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
522
      gdb_assert (data->pseudo_register_name != NULL);
523
      return data->pseudo_register_name (gdbarch, regno);
524
    }
525
 
526
  return "";
527
}
528
 
529
static struct type *
530
tdesc_register_type (struct gdbarch *gdbarch, int regno)
531
{
532
  struct tdesc_reg *reg = tdesc_find_register (gdbarch, regno);
533
  int num_regs = gdbarch_num_regs (gdbarch);
534
  int num_pseudo_regs = gdbarch_num_pseudo_regs (gdbarch);
535
 
536
  if (reg == NULL && regno >= num_regs && regno < num_regs + num_pseudo_regs)
537
    {
538
      struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
539
      gdb_assert (data->pseudo_register_type != NULL);
540
      return data->pseudo_register_type (gdbarch, regno);
541
    }
542
 
543
  if (reg == NULL)
544
    /* Return "int0_t", since "void" has a misleading size of one.  */
545
    return builtin_type_int0;
546
 
547
  /* First check for a predefined or target defined type.  */
548
  if (reg->gdb_type)
549
    return reg->gdb_type;
550
 
551
  /* Next try size-sensitive type shortcuts.  */
552
  if (strcmp (reg->type, "float") == 0)
553
    {
554
      if (reg->bitsize == gdbarch_float_bit (gdbarch))
555
        return builtin_type_float;
556
      else if (reg->bitsize == gdbarch_double_bit (gdbarch))
557
        return builtin_type_double;
558
      else if (reg->bitsize == gdbarch_long_double_bit (gdbarch))
559
        return builtin_type_long_double;
560
    }
561
  else if (strcmp (reg->type, "int") == 0)
562
    {
563
      if (reg->bitsize == gdbarch_long_bit (gdbarch))
564
        return builtin_type_long;
565
      else if (reg->bitsize == TARGET_CHAR_BIT)
566
        return builtin_type_char;
567
      else if (reg->bitsize == gdbarch_short_bit (gdbarch))
568
        return builtin_type_short;
569
      else if (reg->bitsize == gdbarch_int_bit (gdbarch))
570
        return builtin_type_int;
571
      else if (reg->bitsize == gdbarch_long_long_bit (gdbarch))
572
        return builtin_type_long_long;
573
      else if (reg->bitsize == gdbarch_ptr_bit (gdbarch))
574
        /* A bit desperate by this point... */
575
        return builtin_type_void_data_ptr;
576
    }
577
  else if (strcmp (reg->type, "code_ptr") == 0)
578
    return builtin_type_void_func_ptr;
579
  else if (strcmp (reg->type, "data_ptr") == 0)
580
    return builtin_type_void_data_ptr;
581
  else
582
    internal_error (__FILE__, __LINE__,
583
                    "Register \"%s\" has an unknown type \"%s\"",
584
                    reg->name, reg->type);
585
 
586
  warning (_("Register \"%s\" has an unsupported size (%d bits)"),
587
           reg->name, reg->bitsize);
588
  return builtin_type_long;
589
}
590
 
591
static int
592
tdesc_remote_register_number (struct gdbarch *gdbarch, int regno)
593
{
594
  struct tdesc_reg *reg = tdesc_find_register (gdbarch, regno);
595
 
596
  if (reg != NULL)
597
    return reg->target_regnum;
598
  else
599
    return -1;
600
}
601
 
602
/* Check whether REGNUM is a member of REGGROUP.  Registers from the
603
   target description may be classified as general, float, or vector.
604
   Unlike a gdbarch register_reggroup_p method, this function will
605
   return -1 if it does not know; the caller should handle registers
606
   with no specified group.
607
 
608
   Arbitrary strings (other than "general", "float", and "vector")
609
   from the description are not used; they cause the register to be
610
   displayed in "info all-registers" but excluded from "info
611
   registers" et al.  The names of containing features are also not
612
   used.  This might be extended to display registers in some more
613
   useful groupings.
614
 
615
   The save-restore flag is also implemented here.  */
616
 
617
int
618
tdesc_register_in_reggroup_p (struct gdbarch *gdbarch, int regno,
619
                              struct reggroup *reggroup)
620
{
621
  struct tdesc_reg *reg = tdesc_find_register (gdbarch, regno);
622
 
623
  if (reg != NULL && reg->group != NULL)
624
    {
625
      int general_p = 0, float_p = 0, vector_p = 0;
626
 
627
      if (strcmp (reg->group, "general") == 0)
628
        general_p = 1;
629
      else if (strcmp (reg->group, "float") == 0)
630
        float_p = 1;
631
      else if (strcmp (reg->group, "vector") == 0)
632
        vector_p = 1;
633
 
634
      if (reggroup == float_reggroup)
635
        return float_p;
636
 
637
      if (reggroup == vector_reggroup)
638
        return vector_p;
639
 
640
      if (reggroup == general_reggroup)
641
        return general_p;
642
    }
643
 
644
  if (reg != NULL
645
      && (reggroup == save_reggroup || reggroup == restore_reggroup))
646
    return reg->save_restore;
647
 
648
  return -1;
649
}
650
 
651
/* Check whether REGNUM is a member of REGGROUP.  Registers with no
652
   group specified go to the default reggroup function and are handled
653
   by type.  */
654
 
655
static int
656
tdesc_register_reggroup_p (struct gdbarch *gdbarch, int regno,
657
                           struct reggroup *reggroup)
658
{
659
  int num_regs = gdbarch_num_regs (gdbarch);
660
  int num_pseudo_regs = gdbarch_num_pseudo_regs (gdbarch);
661
  int ret;
662
 
663
  if (regno >= num_regs && regno < num_regs + num_pseudo_regs)
664
    {
665
      struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
666
      gdb_assert (data->pseudo_register_reggroup_p != NULL);
667
      return data->pseudo_register_reggroup_p (gdbarch, regno, reggroup);
668
    }
669
 
670
  ret = tdesc_register_in_reggroup_p (gdbarch, regno, reggroup);
671
  if (ret != -1)
672
    return ret;
673
 
674
  return default_register_reggroup_p (gdbarch, regno, reggroup);
675
}
676
 
677
/* Record architecture-specific functions to call for pseudo-register
678
   support.  */
679
 
680
void
681
set_tdesc_pseudo_register_name (struct gdbarch *gdbarch,
682
                                gdbarch_register_name_ftype *pseudo_name)
683
{
684
  struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
685
 
686
  data->pseudo_register_name = pseudo_name;
687
}
688
 
689
void
690
set_tdesc_pseudo_register_type (struct gdbarch *gdbarch,
691
                                gdbarch_register_type_ftype *pseudo_type)
692
{
693
  struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
694
 
695
  data->pseudo_register_type = pseudo_type;
696
}
697
 
698
void
699
set_tdesc_pseudo_register_reggroup_p
700
  (struct gdbarch *gdbarch,
701
   gdbarch_register_reggroup_p_ftype *pseudo_reggroup_p)
702
{
703
  struct tdesc_arch_data *data = gdbarch_data (gdbarch, tdesc_data);
704
 
705
  data->pseudo_register_reggroup_p = pseudo_reggroup_p;
706
}
707
 
708
/* Update GDBARCH to use the target description for registers.  */
709
 
710
void
711
tdesc_use_registers (struct gdbarch *gdbarch,
712
                     const struct target_desc *target_desc,
713
                     struct tdesc_arch_data *early_data)
714
{
715
  int num_regs = gdbarch_num_regs (gdbarch);
716
  int i, ixf, ixr;
717
  struct tdesc_feature *feature;
718
  struct tdesc_reg *reg;
719
  struct tdesc_arch_data *data;
720
  htab_t reg_hash;
721
 
722
  /* We can't use the description for registers if it doesn't describe
723
     any.  This function should only be called after validating
724
     registers, so the caller should know that registers are
725
     included.  */
726
  gdb_assert (tdesc_has_registers (target_desc));
727
 
728
  data = gdbarch_data (gdbarch, tdesc_data);
729
  data->registers = early_data->registers;
730
  xfree (early_data);
731
 
732
  /* Build up a set of all registers, so that we can assign register
733
     numbers where needed.  The hash table expands as necessary, so
734
     the initial size is arbitrary.  */
735
  reg_hash = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
736
  for (ixf = 0;
737
       VEC_iterate (tdesc_feature_p, target_desc->features, ixf, feature);
738
       ixf++)
739
    for (ixr = 0;
740
         VEC_iterate (tdesc_reg_p, feature->registers, ixr, reg);
741
         ixr++)
742
      {
743
        void **slot = htab_find_slot (reg_hash, reg, INSERT);
744
 
745
        *slot = reg;
746
      }
747
 
748
  /* Remove any registers which were assigned numbers by the
749
     architecture.  */
750
  for (ixr = 0; VEC_iterate (tdesc_reg_p, data->registers, ixr, reg); ixr++)
751
    if (reg)
752
      htab_remove_elt (reg_hash, reg);
753
 
754
  /* Assign numbers to the remaining registers and add them to the
755
     list of registers.  The new numbers are always above gdbarch_num_regs.
756
     Iterate over the features, not the hash table, so that the order
757
     matches that in the target description.  */
758
 
759
  gdb_assert (VEC_length (tdesc_reg_p, data->registers) <= num_regs);
760
  while (VEC_length (tdesc_reg_p, data->registers) < num_regs)
761
    VEC_safe_push (tdesc_reg_p, data->registers, NULL);
762
  for (ixf = 0;
763
       VEC_iterate (tdesc_feature_p, target_desc->features, ixf, feature);
764
       ixf++)
765
    for (ixr = 0;
766
         VEC_iterate (tdesc_reg_p, feature->registers, ixr, reg);
767
         ixr++)
768
      if (htab_find (reg_hash, reg) != NULL)
769
        {
770
          VEC_safe_push (tdesc_reg_p, data->registers, reg);
771
          num_regs++;
772
        }
773
 
774
  htab_delete (reg_hash);
775
 
776
  /* Update the architecture.  */
777
  set_gdbarch_num_regs (gdbarch, num_regs);
778
  set_gdbarch_register_name (gdbarch, tdesc_register_name);
779
  set_gdbarch_register_type (gdbarch, tdesc_register_type);
780
  set_gdbarch_remote_register_number (gdbarch,
781
                                      tdesc_remote_register_number);
782
  set_gdbarch_register_reggroup_p (gdbarch, tdesc_register_reggroup_p);
783
}
784
 
785
 
786
/* Methods for constructing a target description.  */
787
 
788
static void
789
tdesc_free_reg (struct tdesc_reg *reg)
790
{
791
  xfree (reg->name);
792
  xfree (reg->type);
793
  xfree (reg->group);
794
  xfree (reg);
795
}
796
 
797
void
798
tdesc_create_reg (struct tdesc_feature *feature, const char *name,
799
                  int regnum, int save_restore, const char *group,
800
                  int bitsize, const char *type)
801
{
802
  struct tdesc_reg *reg = XZALLOC (struct tdesc_reg);
803
 
804
  reg->name = xstrdup (name);
805
  reg->target_regnum = regnum;
806
  reg->save_restore = save_restore;
807
  reg->group = group ? xstrdup (group) : NULL;
808
  reg->bitsize = bitsize;
809
  reg->type = type ? xstrdup (type) : xstrdup ("<unknown>");
810
 
811
  /* If the register's type is target-defined, look it up now.  We may not
812
     have easy access to the containing feature when we want it later.  */
813
  reg->gdb_type = tdesc_named_type (feature, reg->type);
814
 
815
  VEC_safe_push (tdesc_reg_p, feature->registers, reg);
816
}
817
 
818
static void
819
tdesc_free_feature (struct tdesc_feature *feature)
820
{
821
  struct tdesc_reg *reg;
822
  int ix;
823
 
824
  for (ix = 0; VEC_iterate (tdesc_reg_p, feature->registers, ix, reg); ix++)
825
    tdesc_free_reg (reg);
826
  VEC_free (tdesc_reg_p, feature->registers);
827
 
828
  /* There is no easy way to free xmalloc-allocated types, nor is
829
     there a way to allocate types on an obstack not associated with
830
     an objfile.  Therefore we never free types.  Since we only ever
831
     parse an identical XML document once, this memory leak is mostly
832
     contained.  */
833
  VEC_free (type_p, feature->types);
834
 
835
  xfree (feature->name);
836
  xfree (feature);
837
}
838
 
839
struct tdesc_feature *
840
tdesc_create_feature (struct target_desc *tdesc, const char *name)
841
{
842
  struct tdesc_feature *new_feature = XZALLOC (struct tdesc_feature);
843
 
844
  new_feature->name = xstrdup (name);
845
 
846
  VEC_safe_push (tdesc_feature_p, tdesc->features, new_feature);
847
  return new_feature;
848
}
849
 
850
void
851
tdesc_record_type (struct tdesc_feature *feature, struct type *type)
852
{
853
  /* The type's ID should be used as its TYPE_NAME.  */
854
  gdb_assert (TYPE_NAME (type) != NULL);
855
 
856
  VEC_safe_push (type_p, feature->types, type);
857
}
858
 
859
struct target_desc *
860
allocate_target_description (void)
861
{
862
  return XZALLOC (struct target_desc);
863
}
864
 
865
static void
866
free_target_description (void *arg)
867
{
868
  struct target_desc *target_desc = arg;
869
  struct tdesc_feature *feature;
870
  struct property *prop;
871
  int ix;
872
 
873
  for (ix = 0;
874
       VEC_iterate (tdesc_feature_p, target_desc->features, ix, feature);
875
       ix++)
876
    tdesc_free_feature (feature);
877
  VEC_free (tdesc_feature_p, target_desc->features);
878
 
879
  for (ix = 0;
880
       VEC_iterate (property_s, target_desc->properties, ix, prop);
881
       ix++)
882
    {
883
      xfree (prop->key);
884
      xfree (prop->value);
885
    }
886
  VEC_free (property_s, target_desc->properties);
887
 
888
  xfree (target_desc);
889
}
890
 
891
struct cleanup *
892
make_cleanup_free_target_description (struct target_desc *target_desc)
893
{
894
  return make_cleanup (free_target_description, target_desc);
895
}
896
 
897
void
898
set_tdesc_property (struct target_desc *target_desc,
899
                    const char *key, const char *value)
900
{
901
  struct property *prop, new_prop;
902
  int ix;
903
 
904
  gdb_assert (key != NULL && value != NULL);
905
 
906
  for (ix = 0; VEC_iterate (property_s, target_desc->properties, ix, prop);
907
       ix++)
908
    if (strcmp (prop->key, key) == 0)
909
      internal_error (__FILE__, __LINE__,
910
                      _("Attempted to add duplicate property \"%s\""), key);
911
 
912
  new_prop.key = xstrdup (key);
913
  new_prop.value = xstrdup (value);
914
  VEC_safe_push (property_s, target_desc->properties, &new_prop);
915
}
916
 
917
void
918
set_tdesc_architecture (struct target_desc *target_desc,
919
                        const struct bfd_arch_info *arch)
920
{
921
  target_desc->arch = arch;
922
}
923
 
924
 
925
static struct cmd_list_element *tdesc_set_cmdlist, *tdesc_show_cmdlist;
926
static struct cmd_list_element *tdesc_unset_cmdlist;
927
 
928
/* Helper functions for the CLI commands.  */
929
 
930
static void
931
set_tdesc_cmd (char *args, int from_tty)
932
{
933
  help_list (tdesc_set_cmdlist, "set tdesc ", -1, gdb_stdout);
934
}
935
 
936
static void
937
show_tdesc_cmd (char *args, int from_tty)
938
{
939
  cmd_show_list (tdesc_show_cmdlist, from_tty, "");
940
}
941
 
942
static void
943
unset_tdesc_cmd (char *args, int from_tty)
944
{
945
  help_list (tdesc_unset_cmdlist, "unset tdesc ", -1, gdb_stdout);
946
}
947
 
948
static void
949
set_tdesc_filename_cmd (char *args, int from_tty,
950
                        struct cmd_list_element *c)
951
{
952
  target_clear_description ();
953
  target_find_description ();
954
}
955
 
956
static void
957
show_tdesc_filename_cmd (struct ui_file *file, int from_tty,
958
                         struct cmd_list_element *c,
959
                         const char *value)
960
{
961
  if (value != NULL && *value != '\0')
962
    printf_filtered (_("\
963
The target description will be read from \"%s\".\n"),
964
                     value);
965
  else
966
    printf_filtered (_("\
967
The target description will be read from the target.\n"));
968
}
969
 
970
static void
971
unset_tdesc_filename_cmd (char *args, int from_tty)
972
{
973
  xfree (target_description_filename);
974
  target_description_filename = NULL;
975
  target_clear_description ();
976
  target_find_description ();
977
}
978
 
979
static const char *
980
tdesc_type_id (struct type *type)
981
{
982
  int ix;
983
 
984
  for (ix = 0; ix < ARRAY_SIZE (tdesc_predefined_types); ix++)
985
    if (TYPE_MAIN_TYPE (*tdesc_predefined_types[ix].type)
986
        == TYPE_MAIN_TYPE (type))
987
      return tdesc_predefined_types[ix].name;
988
 
989
  return TYPE_NAME (type);
990
}
991
 
992
static void
993
maint_print_c_tdesc_cmd (char *args, int from_tty)
994
{
995
  const struct target_desc *tdesc;
996
  const char *filename, *inp;
997
  char *function, *outp;
998
  struct property *prop;
999
  struct tdesc_feature *feature;
1000
  struct tdesc_reg *reg;
1001
  struct type *type;
1002
  int ix, ix2, ix3;
1003
 
1004
  /* Use the global target-supplied description, not the current
1005
     architecture's.  This lets a GDB for one architecture generate C
1006
     for another architecture's description, even though the gdbarch
1007
     initialization code will reject the new description.  */
1008
  tdesc = current_target_desc;
1009
  if (tdesc == NULL)
1010
    error (_("There is no target description to print."));
1011
 
1012
  if (target_description_filename == NULL)
1013
    error (_("The current target description did not come from an XML file."));
1014
 
1015
  filename = lbasename (target_description_filename);
1016
  function = xmalloc (strlen (filename) + 1);
1017
  for (inp = filename, outp = function; *inp != '\0'; inp++)
1018
    if (*inp == '.')
1019
      break;
1020
    else if (*inp == '-')
1021
      *outp++ = '_';
1022
    else
1023
      *outp++ = *inp;
1024
  *outp = '\0';
1025
 
1026
  /* Standard boilerplate.  */
1027
  printf_unfiltered ("/* THIS FILE IS GENERATED.  Original: %s */\n\n",
1028
                     filename);
1029
  printf_unfiltered ("#include \"defs.h\"\n");
1030
  printf_unfiltered ("#include \"gdbtypes.h\"\n");
1031
  printf_unfiltered ("#include \"target-descriptions.h\"\n");
1032
  printf_unfiltered ("\n");
1033
 
1034
  printf_unfiltered ("struct target_desc *tdesc_%s;\n", function);
1035
  printf_unfiltered ("static void\n");
1036
  printf_unfiltered ("initialize_tdesc_%s (void)\n", function);
1037
  printf_unfiltered ("{\n");
1038
  printf_unfiltered
1039
    ("  struct target_desc *result = allocate_target_description ();\n");
1040
  printf_unfiltered ("  struct tdesc_feature *feature;\n");
1041
  printf_unfiltered ("  struct type *field_type, *type;\n");
1042
  printf_unfiltered ("\n");
1043
 
1044
  if (tdesc_architecture (tdesc) != NULL)
1045
    {
1046
      printf_unfiltered
1047
        ("  set_tdesc_architecture (result, bfd_scan_arch (\"%s\"));\n",
1048
         tdesc_architecture (tdesc)->printable_name);
1049
      printf_unfiltered ("\n");
1050
    }
1051
 
1052
  for (ix = 0; VEC_iterate (property_s, tdesc->properties, ix, prop);
1053
       ix++)
1054
    {
1055
      printf_unfiltered ("  set_tdesc_property (result, \"%s\", \"%s\");\n",
1056
              prop->key, prop->value);
1057
    }
1058
 
1059
  for (ix = 0;
1060
       VEC_iterate (tdesc_feature_p, tdesc->features, ix, feature);
1061
       ix++)
1062
    {
1063
      printf_unfiltered ("  feature = tdesc_create_feature (result, \"%s\");\n",
1064
                         feature->name);
1065
 
1066
      for (ix2 = 0;
1067
           VEC_iterate (type_p, feature->types, ix2, type);
1068
           ix2++)
1069
        {
1070
          switch (TYPE_CODE (type))
1071
            {
1072
            case TYPE_CODE_ARRAY:
1073
              printf_unfiltered
1074
                ("  field_type = tdesc_named_type (feature, \"%s\");\n",
1075
                 tdesc_type_id (TYPE_TARGET_TYPE (type)));
1076
              printf_unfiltered
1077
                ("  type = init_vector_type (field_type, %d);\n",
1078
                 TYPE_LENGTH (type) / TYPE_LENGTH (TYPE_TARGET_TYPE (type)));
1079
              printf_unfiltered
1080
                ("  TYPE_NAME (type) = xstrdup (\"%s\");\n", TYPE_NAME (type));
1081
              break;
1082
            case TYPE_CODE_UNION:
1083
              printf_unfiltered
1084
                ("  type = init_composite_type (NULL, TYPE_CODE_UNION);\n");
1085
              printf_unfiltered
1086
                ("  TYPE_NAME (type) = xstrdup (\"%s\");\n", TYPE_NAME (type));
1087
              for (ix3 = 0; ix3 < TYPE_NFIELDS (type); ix3++)
1088
                {
1089
                  printf_unfiltered
1090
                    ("  field_type = tdesc_named_type (feature, \"%s\");\n",
1091
                     tdesc_type_id (TYPE_FIELD_TYPE (type, ix3)));
1092
                  printf_unfiltered
1093
                    ("  append_composite_type_field (type, "
1094
                     "xstrdup (\"%s\"), field_type);\n",
1095
                     TYPE_FIELD_NAME (type, ix3));
1096
                }
1097
              if (TYPE_VECTOR (type))
1098
                printf_unfiltered
1099
                  ("  TYPE_FLAGS (type) |= TYPE_FLAG_VECTOR;\n");
1100
              break;
1101
            default:
1102
              error (_("C output is not supported type \"%s\"."), TYPE_NAME (type));
1103
            }
1104
          printf_unfiltered ("  tdesc_record_type (feature, type);\n");
1105
          printf_unfiltered ("\n");
1106
        }
1107
 
1108
      for (ix2 = 0;
1109
           VEC_iterate (tdesc_reg_p, feature->registers, ix2, reg);
1110
           ix2++)
1111
        {
1112
          printf_unfiltered ("  tdesc_create_reg (feature, \"%s\", %ld, %d, ",
1113
                             reg->name, reg->target_regnum, reg->save_restore);
1114
          if (reg->group)
1115
            printf_unfiltered ("\"%s\", ", reg->group);
1116
          else
1117
            printf_unfiltered ("NULL, ");
1118
          printf_unfiltered ("%d, \"%s\");\n", reg->bitsize, reg->type);
1119
        }
1120
 
1121
      printf_unfiltered ("\n");
1122
    }
1123
 
1124
  printf_unfiltered ("  tdesc_%s = result;\n", function);
1125
  printf_unfiltered ("}\n");
1126
}
1127
 
1128
void
1129
_initialize_target_descriptions (void)
1130
{
1131
  tdesc_data = gdbarch_data_register_pre_init (tdesc_data_init);
1132
 
1133
  add_prefix_cmd ("tdesc", class_maintenance, set_tdesc_cmd, _("\
1134
Set target description specific variables."),
1135
                  &tdesc_set_cmdlist, "set tdesc ",
1136
 
1137
  add_prefix_cmd ("tdesc", class_maintenance, show_tdesc_cmd, _("\
1138
Show target description specific variables."),
1139
                  &tdesc_show_cmdlist, "show tdesc ",
1140
 
1141
  add_prefix_cmd ("tdesc", class_maintenance, unset_tdesc_cmd, _("\
1142
Unset target description specific variables."),
1143
                  &tdesc_unset_cmdlist, "unset tdesc ",
1144
 
1145
 
1146
  add_setshow_filename_cmd ("filename", class_obscure,
1147
                            &target_description_filename,
1148
                            _("\
1149
Set the file to read for an XML target description"), _("\
1150
Show the file to read for an XML target description"), _("\
1151
When set, GDB will read the target description from a local\n\
1152
file instead of querying the remote target."),
1153
                            set_tdesc_filename_cmd,
1154
                            show_tdesc_filename_cmd,
1155
                            &tdesc_set_cmdlist, &tdesc_show_cmdlist);
1156
 
1157
  add_cmd ("filename", class_obscure, unset_tdesc_filename_cmd, _("\
1158
Unset the file to read for an XML target description.  When unset,\n\
1159
GDB will read the description from the target."),
1160
           &tdesc_unset_cmdlist);
1161
 
1162
  add_cmd ("c-tdesc", class_maintenance, maint_print_c_tdesc_cmd, _("\
1163
Print the current target description as a C source file."),
1164
           &maintenanceprintlist);
1165
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.