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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [gdb/] [reggroups.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
/* Register groupings for GDB, the GNU debugger.
2
 
3
   Copyright (C) 2002, 2003, 2007, 2008 Free Software Foundation, Inc.
4
 
5
   Contributed by Red Hat.
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 "reggroups.h"
24
#include "gdbtypes.h"
25
#include "gdb_assert.h"
26
#include "regcache.h"
27
#include "command.h"
28
#include "gdbcmd.h"             /* For maintenanceprintlist.  */
29
 
30
/* Individual register groups.  */
31
 
32
struct reggroup
33
{
34
  const char *name;
35
  enum reggroup_type type;
36
};
37
 
38
struct reggroup *
39
reggroup_new (const char *name, enum reggroup_type type)
40
{
41
  struct reggroup *group = XMALLOC (struct reggroup);
42
  group->name = name;
43
  group->type = type;
44
  return group;
45
}
46
 
47
/* Register group attributes.  */
48
 
49
const char *
50
reggroup_name (struct reggroup *group)
51
{
52
  return group->name;
53
}
54
 
55
enum reggroup_type
56
reggroup_type (struct reggroup *group)
57
{
58
  return group->type;
59
}
60
 
61
/* A linked list of groups for the given architecture.  */
62
 
63
struct reggroup_el
64
{
65
  struct reggroup *group;
66
  struct reggroup_el *next;
67
};
68
 
69
struct reggroups
70
{
71
  struct reggroup_el *first;
72
  struct reggroup_el **last;
73
};
74
 
75
static struct gdbarch_data *reggroups_data;
76
 
77
static void *
78
reggroups_init (struct gdbarch *gdbarch)
79
{
80
  struct reggroups *groups = GDBARCH_OBSTACK_ZALLOC (gdbarch,
81
                                                     struct reggroups);
82
  groups->last = &groups->first;
83
  return groups;
84
}
85
 
86
/* Add a register group (with attribute values) to the pre-defined
87
   list.  */
88
 
89
static void
90
add_group (struct reggroups *groups, struct reggroup *group,
91
           struct reggroup_el *el)
92
{
93
  gdb_assert (group != NULL);
94
  el->group = group;
95
  el->next = NULL;
96
  (*groups->last) = el;
97
  groups->last = &el->next;
98
}
99
 
100
void
101
reggroup_add (struct gdbarch *gdbarch, struct reggroup *group)
102
{
103
  struct reggroups *groups = gdbarch_data (gdbarch, reggroups_data);
104
 
105
  if (groups == NULL)
106
    {
107
      /* ULGH, called during architecture initialization.  Patch
108
         things up.  */
109
      groups = reggroups_init (gdbarch);
110
      deprecated_set_gdbarch_data (gdbarch, reggroups_data, groups);
111
    }
112
  add_group (groups, group,
113
             GDBARCH_OBSTACK_ZALLOC (gdbarch, struct reggroup_el));
114
}
115
 
116
/* The default register groups for an architecture.  */
117
 
118
static struct reggroups default_groups = { NULL, &default_groups.first };
119
 
120
/* A register group iterator.  */
121
 
122
struct reggroup *
123
reggroup_next (struct gdbarch *gdbarch, struct reggroup *last)
124
{
125
  struct reggroups *groups;
126
  struct reggroup_el *el;
127
 
128
  /* Don't allow this function to be called during architecture
129
     creation.  If there are no groups, use the default groups list.  */
130
  groups = gdbarch_data (gdbarch, reggroups_data);
131
  gdb_assert (groups != NULL);
132
  if (groups->first == NULL)
133
    groups = &default_groups;
134
 
135
  /* Return the first/next reggroup.  */
136
  if (last == NULL)
137
    return groups->first->group;
138
  for (el = groups->first; el != NULL; el = el->next)
139
    {
140
      if (el->group == last)
141
        {
142
          if (el->next != NULL)
143
            return el->next->group;
144
          else
145
            return NULL;
146
        }
147
    }
148
  return NULL;
149
}
150
 
151
/* Is REGNUM a member of REGGROUP?  */
152
int
153
default_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
154
                             struct reggroup *group)
155
{
156
  int vector_p;
157
  int float_p;
158
  int raw_p;
159
 
160
  if (gdbarch_register_name (gdbarch, regnum) == NULL
161
      || *gdbarch_register_name (gdbarch, regnum) == '\0')
162
    return 0;
163
  if (group == all_reggroup)
164
    return 1;
165
  vector_p = TYPE_VECTOR (register_type (gdbarch, regnum));
166
  float_p = TYPE_CODE (register_type (gdbarch, regnum)) == TYPE_CODE_FLT;
167
  raw_p = regnum < gdbarch_num_regs (gdbarch);
168
  if (group == float_reggroup)
169
    return float_p;
170
  if (group == vector_reggroup)
171
    return vector_p;
172
  if (group == general_reggroup)
173
    return (!vector_p && !float_p);
174
  if (group == save_reggroup || group == restore_reggroup)
175
    return raw_p;
176
  return 0;
177
}
178
 
179
/* Dump out a table of register groups for the current architecture.  */
180
 
181
static void
182
reggroups_dump (struct gdbarch *gdbarch, struct ui_file *file)
183
{
184
  struct reggroup *group = NULL;
185
 
186
  do
187
    {
188
      /* Group name.  */
189
      {
190
        const char *name;
191
        if (group == NULL)
192
          name = "Group";
193
        else
194
          name = reggroup_name (group);
195
        fprintf_unfiltered (file, " %-10s", name);
196
      }
197
 
198
      /* Group type.  */
199
      {
200
        const char *type;
201
        if (group == NULL)
202
          type = "Type";
203
        else
204
          {
205
            switch (reggroup_type (group))
206
              {
207
              case USER_REGGROUP:
208
                type = "user";
209
                break;
210
              case INTERNAL_REGGROUP:
211
                type = "internal";
212
                break;
213
              default:
214
                internal_error (__FILE__, __LINE__, _("bad switch"));
215
              }
216
          }
217
        fprintf_unfiltered (file, " %-10s", type);
218
      }
219
 
220
      /* Note: If you change this, be sure to also update the
221
         documentation.  */
222
 
223
      fprintf_unfiltered (file, "\n");
224
 
225
      group = reggroup_next (gdbarch, group);
226
    }
227
  while (group != NULL);
228
}
229
 
230
static void
231
maintenance_print_reggroups (char *args, int from_tty)
232
{
233
  if (args == NULL)
234
    reggroups_dump (current_gdbarch, gdb_stdout);
235
  else
236
    {
237
      struct ui_file *file = gdb_fopen (args, "w");
238
      if (file == NULL)
239
        perror_with_name (_("maintenance print reggroups"));
240
      reggroups_dump (current_gdbarch, file);
241
      ui_file_delete (file);
242
    }
243
}
244
 
245
/* Pre-defined register groups.  */
246
static struct reggroup general_group = { "general", USER_REGGROUP };
247
static struct reggroup float_group = { "float", USER_REGGROUP };
248
static struct reggroup system_group = { "system", USER_REGGROUP };
249
static struct reggroup vector_group = { "vector", USER_REGGROUP };
250
static struct reggroup all_group = { "all", USER_REGGROUP };
251
static struct reggroup save_group = { "save", INTERNAL_REGGROUP };
252
static struct reggroup restore_group = { "restore", INTERNAL_REGGROUP };
253
 
254
struct reggroup *const general_reggroup = &general_group;
255
struct reggroup *const float_reggroup = &float_group;
256
struct reggroup *const system_reggroup = &system_group;
257
struct reggroup *const vector_reggroup = &vector_group;
258
struct reggroup *const all_reggroup = &all_group;
259
struct reggroup *const save_reggroup = &save_group;
260
struct reggroup *const restore_reggroup = &restore_group;
261
 
262
extern initialize_file_ftype _initialize_reggroup; /* -Wmissing-prototypes */
263
 
264
void
265
_initialize_reggroup (void)
266
{
267
  reggroups_data = gdbarch_data_register_post_init (reggroups_init);
268
 
269
  /* The pre-defined list of groups.  */
270
  add_group (&default_groups, general_reggroup, XMALLOC (struct reggroup_el));
271
  add_group (&default_groups, float_reggroup, XMALLOC (struct reggroup_el));
272
  add_group (&default_groups, system_reggroup, XMALLOC (struct reggroup_el));
273
  add_group (&default_groups, vector_reggroup, XMALLOC (struct reggroup_el));
274
  add_group (&default_groups, all_reggroup, XMALLOC (struct reggroup_el));
275
  add_group (&default_groups, save_reggroup, XMALLOC (struct reggroup_el));
276
  add_group (&default_groups, restore_reggroup, XMALLOC (struct reggroup_el));
277
 
278
  add_cmd ("reggroups", class_maintenance,
279
           maintenance_print_reggroups, _("\
280
Print the internal register group names.\n\
281
Takes an optional file parameter."),
282
           &maintenanceprintlist);
283
 
284
}

powered by: WebSVN 2.1.0

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