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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [gdb/] [gdbserver/] [inferiors.c] - Blame information for rev 157

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* Inferior process information for the remote server for GDB.
2
   Copyright (C) 2002, 2005, 2007, 2008 Free Software Foundation, Inc.
3
 
4
   Contributed by MontaVista Software.
5
 
6
   This file is part of GDB.
7
 
8
   This program is free software; you can redistribute it and/or modify
9
   it under the terms of the GNU General Public License as published by
10
   the Free Software Foundation; either version 3 of the License, or
11
   (at your option) any later version.
12
 
13
   This program is distributed in the hope that it will be useful,
14
   but WITHOUT ANY WARRANTY; without even the implied warranty of
15
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
   GNU General Public License for more details.
17
 
18
   You should have received a copy of the GNU General Public License
19
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
20
 
21
#include <stdlib.h>
22
 
23
#include "server.h"
24
 
25
struct thread_info
26
{
27
  struct inferior_list_entry entry;
28
  void *target_data;
29
  void *regcache_data;
30
  unsigned int gdb_id;
31
};
32
 
33
struct inferior_list all_threads;
34
struct inferior_list all_dlls;
35
int dlls_changed;
36
 
37
struct thread_info *current_inferior;
38
 
39
#define get_thread(inf) ((struct thread_info *)(inf))
40
#define get_dll(inf) ((struct dll_info *)(inf))
41
 
42
void
43
add_inferior_to_list (struct inferior_list *list,
44
                      struct inferior_list_entry *new_inferior)
45
{
46
  new_inferior->next = NULL;
47
  if (list->tail != NULL)
48
    list->tail->next = new_inferior;
49
  else
50
    list->head = new_inferior;
51
  list->tail = new_inferior;
52
}
53
 
54
void
55
for_each_inferior (struct inferior_list *list,
56
                   void (*action) (struct inferior_list_entry *))
57
{
58
  struct inferior_list_entry *cur = list->head, *next;
59
 
60
  while (cur != NULL)
61
    {
62
      next = cur->next;
63
      (*action) (cur);
64
      cur = next;
65
    }
66
}
67
 
68
void
69
remove_inferior (struct inferior_list *list,
70
                 struct inferior_list_entry *entry)
71
{
72
  struct inferior_list_entry **cur;
73
 
74
  if (list->head == entry)
75
    {
76
      list->head = entry->next;
77
      if (list->tail == entry)
78
        list->tail = list->head;
79
      return;
80
    }
81
 
82
  cur = &list->head;
83
  while (*cur && (*cur)->next != entry)
84
    cur = &(*cur)->next;
85
 
86
  if (*cur == NULL)
87
    return;
88
 
89
  (*cur)->next = entry->next;
90
 
91
  if (list->tail == entry)
92
    list->tail = *cur;
93
}
94
 
95
void
96
add_thread (unsigned long thread_id, void *target_data, unsigned int gdb_id)
97
{
98
  struct thread_info *new_thread = malloc (sizeof (*new_thread));
99
 
100
  memset (new_thread, 0, sizeof (*new_thread));
101
 
102
  new_thread->entry.id = thread_id;
103
 
104
  add_inferior_to_list (&all_threads, & new_thread->entry);
105
 
106
  if (current_inferior == NULL)
107
    current_inferior = new_thread;
108
 
109
  new_thread->target_data = target_data;
110
  set_inferior_regcache_data (new_thread, new_register_cache ());
111
  new_thread->gdb_id = gdb_id;
112
}
113
 
114
unsigned int
115
thread_id_to_gdb_id (unsigned long thread_id)
116
{
117
  struct inferior_list_entry *inf = all_threads.head;
118
 
119
  while (inf != NULL)
120
    {
121
      struct thread_info *thread = get_thread (inf);
122
      if (inf->id == thread_id)
123
        return thread->gdb_id;
124
      inf = inf->next;
125
    }
126
 
127
  return 0;
128
}
129
 
130
unsigned int
131
thread_to_gdb_id (struct thread_info *thread)
132
{
133
  return thread->gdb_id;
134
}
135
 
136
struct thread_info *
137
gdb_id_to_thread (unsigned int gdb_id)
138
{
139
  struct inferior_list_entry *inf = all_threads.head;
140
 
141
  while (inf != NULL)
142
    {
143
      struct thread_info *thread = get_thread (inf);
144
      if (thread->gdb_id == gdb_id)
145
        return thread;
146
      inf = inf->next;
147
    }
148
 
149
  return NULL;
150
}
151
 
152
unsigned long
153
gdb_id_to_thread_id (unsigned int gdb_id)
154
{
155
  struct thread_info *thread = gdb_id_to_thread (gdb_id);
156
 
157
  return thread ? thread->entry.id : 0;
158
}
159
 
160
static void
161
free_one_thread (struct inferior_list_entry *inf)
162
{
163
  struct thread_info *thread = get_thread (inf);
164
  free_register_cache (inferior_regcache_data (thread));
165
  free (thread);
166
}
167
 
168
void
169
remove_thread (struct thread_info *thread)
170
{
171
  remove_inferior (&all_threads, (struct inferior_list_entry *) thread);
172
  free_one_thread (&thread->entry);
173
}
174
 
175
struct inferior_list_entry *
176
find_inferior (struct inferior_list *list,
177
               int (*func) (struct inferior_list_entry *, void *), void *arg)
178
{
179
  struct inferior_list_entry *inf = list->head;
180
 
181
  while (inf != NULL)
182
    {
183
      if ((*func) (inf, arg))
184
        return inf;
185
      inf = inf->next;
186
    }
187
 
188
  return NULL;
189
}
190
 
191
struct inferior_list_entry *
192
find_inferior_id (struct inferior_list *list, unsigned long id)
193
{
194
  struct inferior_list_entry *inf = list->head;
195
 
196
  while (inf != NULL)
197
    {
198
      if (inf->id == id)
199
        return inf;
200
      inf = inf->next;
201
    }
202
 
203
  return NULL;
204
}
205
 
206
void *
207
inferior_target_data (struct thread_info *inferior)
208
{
209
  return inferior->target_data;
210
}
211
 
212
void
213
set_inferior_target_data (struct thread_info *inferior, void *data)
214
{
215
  inferior->target_data = data;
216
}
217
 
218
void *
219
inferior_regcache_data (struct thread_info *inferior)
220
{
221
  return inferior->regcache_data;
222
}
223
 
224
void
225
set_inferior_regcache_data (struct thread_info *inferior, void *data)
226
{
227
  inferior->regcache_data = data;
228
}
229
 
230
static void
231
free_one_dll (struct inferior_list_entry *inf)
232
{
233
  struct dll_info *dll = get_dll (inf);
234
  if (dll->name != NULL)
235
    free (dll->name);
236
  free (dll);
237
}
238
 
239
/* Find a DLL with the same name and/or base address.  A NULL name in
240
   the key is ignored; so is an all-ones base address.  */
241
 
242
static int
243
match_dll (struct inferior_list_entry *inf, void *arg)
244
{
245
  struct dll_info *iter = (void *) inf;
246
  struct dll_info *key = arg;
247
 
248
  if (key->base_addr != ~(CORE_ADDR) 0
249
      && iter->base_addr == key->base_addr)
250
    return 1;
251
  else if (key->name != NULL
252
           && iter->name != NULL
253
           && strcmp (key->name, iter->name) == 0)
254
    return 1;
255
 
256
  return 0;
257
}
258
 
259
/* Record a newly loaded DLL at BASE_ADDR.  */
260
 
261
void
262
loaded_dll (const char *name, CORE_ADDR base_addr)
263
{
264
  struct dll_info *new_dll = malloc (sizeof (*new_dll));
265
  memset (new_dll, 0, sizeof (*new_dll));
266
 
267
  new_dll->entry.id = -1;
268
 
269
  new_dll->name = strdup (name);
270
  new_dll->base_addr = base_addr;
271
 
272
  add_inferior_to_list (&all_dlls, &new_dll->entry);
273
  dlls_changed = 1;
274
}
275
 
276
/* Record that the DLL with NAME and BASE_ADDR has been unloaded.  */
277
 
278
void
279
unloaded_dll (const char *name, CORE_ADDR base_addr)
280
{
281
  struct dll_info *dll;
282
  struct dll_info key_dll;
283
 
284
  /* Be careful not to put the key DLL in any list.  */
285
  key_dll.name = (char *) name;
286
  key_dll.base_addr = base_addr;
287
 
288
  dll = (void *) find_inferior (&all_dlls, match_dll, &key_dll);
289
  remove_inferior (&all_dlls, &dll->entry);
290
  free_one_dll (&dll->entry);
291
  dlls_changed = 1;
292
}
293
 
294
#define clear_list(LIST) \
295
  do { (LIST)->head = (LIST)->tail = NULL; } while (0)
296
 
297
void
298
clear_inferiors (void)
299
{
300
  for_each_inferior (&all_threads, free_one_thread);
301
  for_each_inferior (&all_dlls, free_one_dll);
302
 
303
  clear_list (&all_threads);
304
  clear_list (&all_dlls);
305
}
306
 
307
/* Two utility functions for a truly degenerate inferior_list: a simple
308
   PID listing.  */
309
 
310
void
311
add_pid_to_list (struct inferior_list *list, unsigned long pid)
312
{
313
  struct inferior_list_entry *new_entry;
314
 
315
  new_entry = malloc (sizeof (struct inferior_list_entry));
316
  new_entry->id = pid;
317
  add_inferior_to_list (list, new_entry);
318
}
319
 
320
int
321
pull_pid_from_list (struct inferior_list *list, unsigned long pid)
322
{
323
  struct inferior_list_entry *new_entry;
324
 
325
  new_entry = find_inferior_id (list, pid);
326
  if (new_entry == NULL)
327
    return 0;
328
  else
329
    {
330
      remove_inferior (list, new_entry);
331
      free (new_entry);
332
      return 1;
333
    }
334
}

powered by: WebSVN 2.1.0

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