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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [gdb/] [libunwind-frame.c] - Blame information for rev 258

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

Line No. Rev Author Line
1 24 jeremybenn
/* Frame unwinder for frames using the libunwind library.
2
 
3
   Copyright (C) 2003, 2004, 2006, 2007, 2008 Free Software Foundation, Inc.
4
 
5
   Written by Jeff Johnston, contributed by Red Hat Inc.
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
 
24
#include "inferior.h"
25
#include "frame.h"
26
#include "frame-base.h"
27
#include "frame-unwind.h"
28
#include "gdbcore.h"
29
#include "gdbtypes.h"
30
#include "symtab.h"
31
#include "objfiles.h"
32
#include "regcache.h"
33
 
34
#include <dlfcn.h>
35
 
36
#include "gdb_assert.h"
37
#include "gdb_string.h"
38
 
39
#include "libunwind-frame.h"
40
 
41
#include "complaints.h"
42
 
43
static int libunwind_initialized;
44
static struct gdbarch_data *libunwind_descr_handle;
45
 
46
/* Required function pointers from libunwind.  */
47
static int (*unw_get_reg_p) (unw_cursor_t *, unw_regnum_t, unw_word_t *);
48
static int (*unw_get_fpreg_p) (unw_cursor_t *, unw_regnum_t, unw_fpreg_t *);
49
static int (*unw_get_saveloc_p) (unw_cursor_t *, unw_regnum_t, unw_save_loc_t *);
50
static int (*unw_is_signal_frame_p) (unw_cursor_t *);
51
static int (*unw_step_p) (unw_cursor_t *);
52
static int (*unw_init_remote_p) (unw_cursor_t *, unw_addr_space_t, void *);
53
static unw_addr_space_t (*unw_create_addr_space_p) (unw_accessors_t *, int);
54
static void (*unw_destroy_addr_space_p) (unw_addr_space_t);
55
static int (*unw_search_unwind_table_p) (unw_addr_space_t, unw_word_t, unw_dyn_info_t *,
56
                                         unw_proc_info_t *, int, void *);
57
static unw_word_t (*unw_find_dyn_list_p) (unw_addr_space_t, unw_dyn_info_t *,
58
                                          void *);
59
 
60
 
61
struct libunwind_frame_cache
62
{
63
  CORE_ADDR base;
64
  CORE_ADDR func_addr;
65
  unw_cursor_t cursor;
66
  unw_addr_space_t as;
67
};
68
 
69
/* We need to qualify the function names with a platform-specific prefix to match
70
   the names used by the libunwind library.  The UNW_OBJ macro is provided by the
71
   libunwind.h header file.  */
72
#define STRINGIFY2(name)        #name
73
#define STRINGIFY(name)         STRINGIFY2(name)
74
 
75
#ifndef LIBUNWIND_SO
76
/* Use the stable ABI major version number.  `libunwind-ia64.so' is a link time
77
   only library, not a runtime one.  */
78
#define LIBUNWIND_SO "libunwind-" STRINGIFY(UNW_TARGET) ".so.7"
79
#endif
80
 
81
static char *get_reg_name = STRINGIFY(UNW_OBJ(get_reg));
82
static char *get_fpreg_name = STRINGIFY(UNW_OBJ(get_fpreg));
83
static char *get_saveloc_name = STRINGIFY(UNW_OBJ(get_save_loc));
84
static char *is_signal_frame_name = STRINGIFY(UNW_OBJ(is_signal_frame));
85
static char *step_name = STRINGIFY(UNW_OBJ(step));
86
static char *init_remote_name = STRINGIFY(UNW_OBJ(init_remote));
87
static char *create_addr_space_name = STRINGIFY(UNW_OBJ(create_addr_space));
88
static char *destroy_addr_space_name = STRINGIFY(UNW_OBJ(destroy_addr_space));
89
static char *search_unwind_table_name = STRINGIFY(UNW_OBJ(search_unwind_table));
90
static char *find_dyn_list_name = STRINGIFY(UNW_OBJ(find_dyn_list));
91
 
92
static struct libunwind_descr *
93
libunwind_descr (struct gdbarch *gdbarch)
94
{
95
  return gdbarch_data (gdbarch, libunwind_descr_handle);
96
}
97
 
98
static void *
99
libunwind_descr_init (struct gdbarch *gdbarch)
100
{
101
  struct libunwind_descr *descr = GDBARCH_OBSTACK_ZALLOC (gdbarch,
102
                                                          struct libunwind_descr);
103
  return descr;
104
}
105
 
106
void
107
libunwind_frame_set_descr (struct gdbarch *gdbarch, struct libunwind_descr *descr)
108
{
109
  struct libunwind_descr *arch_descr;
110
 
111
  gdb_assert (gdbarch != NULL);
112
 
113
  arch_descr = gdbarch_data (gdbarch, libunwind_descr_handle);
114
 
115
  if (arch_descr == NULL)
116
    {
117
      /* First time here.  Must initialize data area.  */
118
      arch_descr = libunwind_descr_init (gdbarch);
119
      deprecated_set_gdbarch_data (gdbarch, libunwind_descr_handle, arch_descr);
120
    }
121
 
122
  /* Copy new descriptor info into arch descriptor.  */
123
  arch_descr->gdb2uw = descr->gdb2uw;
124
  arch_descr->uw2gdb = descr->uw2gdb;
125
  arch_descr->is_fpreg = descr->is_fpreg;
126
  arch_descr->accessors = descr->accessors;
127
  arch_descr->special_accessors = descr->special_accessors;
128
}
129
 
130
static struct libunwind_frame_cache *
131
libunwind_frame_cache (struct frame_info *next_frame, void **this_cache)
132
{
133
  unw_accessors_t *acc;
134
  unw_addr_space_t as;
135
  unw_word_t fp;
136
  unw_regnum_t uw_sp_regnum;
137
  struct libunwind_frame_cache *cache;
138
  struct libunwind_descr *descr;
139
  struct gdbarch *gdbarch = get_frame_arch (next_frame);
140
  int i, ret;
141
 
142
  if (*this_cache)
143
    return *this_cache;
144
 
145
  /* Allocate a new cache.  */
146
  cache = FRAME_OBSTACK_ZALLOC (struct libunwind_frame_cache);
147
 
148
  /* We can assume we are unwinding a normal frame.  Even if this is
149
     for a signal trampoline, ia64 signal "trampolines" use a normal
150
     subroutine call to start the signal handler.  */
151
  cache->func_addr = frame_func_unwind (next_frame, NORMAL_FRAME);
152
  if (cache->func_addr == 0
153
      && frame_relative_level (next_frame) > 0
154
      && get_frame_type (next_frame) != SIGTRAMP_FRAME)
155
    return NULL;
156
 
157
  /* Get a libunwind cursor to the previous frame.  We do this by initializing
158
     a cursor.  Libunwind treats a new cursor as the top of stack and will get
159
     the current register set via the libunwind register accessor.  Now, we
160
     provide the platform-specific accessors and we set up the register accessor to use
161
     the frame register unwinding interfaces so that we properly get the registers for
162
     the current frame rather than the top.  We then use the  unw_step function to
163
     move the libunwind cursor back one frame.  We can later use this cursor to find previous
164
     registers via the unw_get_reg interface which will invoke libunwind's special logic.  */
165
  descr = libunwind_descr (gdbarch);
166
  acc = descr->accessors;
167
  as =  unw_create_addr_space_p (acc,
168
                                 gdbarch_byte_order (gdbarch)
169
                                 == BFD_ENDIAN_BIG
170
                                 ? __BIG_ENDIAN
171
                                 : __LITTLE_ENDIAN);
172
 
173
  unw_init_remote_p (&cache->cursor, as, next_frame);
174
  if (unw_step_p (&cache->cursor) < 0)
175
    {
176
      unw_destroy_addr_space_p (as);
177
      return NULL;
178
    }
179
 
180
  /* To get base address, get sp from previous frame.  */
181
  uw_sp_regnum = descr->gdb2uw (gdbarch_sp_regnum (gdbarch));
182
  ret = unw_get_reg_p (&cache->cursor, uw_sp_regnum, &fp);
183
  if (ret < 0)
184
    {
185
      unw_destroy_addr_space_p (as);
186
      error (_("Can't get libunwind sp register."));
187
    }
188
 
189
  cache->base = (CORE_ADDR)fp;
190
  cache->as = as;
191
 
192
  *this_cache = cache;
193
  return cache;
194
}
195
 
196
void
197
libunwind_frame_dealloc_cache (struct frame_info *self, void *this_cache)
198
{
199
  struct libunwind_frame_cache *cache = this_cache;
200
  if (cache->as)
201
    unw_destroy_addr_space_p (cache->as);
202
}
203
 
204
unw_word_t
205
libunwind_find_dyn_list (unw_addr_space_t as, unw_dyn_info_t *di, void *arg)
206
{
207
  return unw_find_dyn_list_p (as, di, arg);
208
}
209
 
210
static const struct frame_unwind libunwind_frame_unwind =
211
{
212
  NORMAL_FRAME,
213
  libunwind_frame_this_id,
214
  libunwind_frame_prev_register,
215
  NULL,
216
  NULL,
217
  NULL,
218
  libunwind_frame_dealloc_cache
219
};
220
 
221
/* Verify if there is sufficient libunwind information for the frame to use
222
   libunwind frame unwinding.  */
223
const struct frame_unwind *
224
libunwind_frame_sniffer (struct frame_info *next_frame)
225
{
226
  unw_cursor_t cursor;
227
  unw_accessors_t *acc;
228
  unw_addr_space_t as;
229
  struct libunwind_descr *descr;
230
  struct gdbarch *gdbarch = get_frame_arch (next_frame);
231
  int i, ret;
232
 
233
  /* To test for libunwind unwind support, initialize a cursor to the current frame and try to back
234
     up.  We use this same method when setting up the frame cache (see libunwind_frame_cache()).
235
     If libunwind returns success for this operation, it means that it has found sufficient
236
     libunwind unwinding information to do so.  */
237
 
238
  descr = libunwind_descr (gdbarch);
239
  acc = descr->accessors;
240
  as =  unw_create_addr_space_p (acc,
241
                                 gdbarch_byte_order (gdbarch)
242
                                 == BFD_ENDIAN_BIG
243
                                 ? __BIG_ENDIAN
244
                                 : __LITTLE_ENDIAN);
245
 
246
  ret = unw_init_remote_p (&cursor, as, next_frame);
247
 
248
  if (ret < 0)
249
    {
250
      unw_destroy_addr_space_p (as);
251
      return NULL;
252
    }
253
 
254
 
255
  /* Check to see if we have libunwind info by checking if we are in a
256
     signal frame.  If it doesn't return an error, we have libunwind info
257
     and can use libunwind.  */
258
  ret = unw_is_signal_frame_p (&cursor);
259
  unw_destroy_addr_space_p (as);
260
 
261
  if (ret < 0)
262
    return NULL;
263
 
264
  return &libunwind_frame_unwind;
265
}
266
 
267
void
268
libunwind_frame_this_id (struct frame_info *next_frame, void **this_cache,
269
                      struct frame_id *this_id)
270
{
271
  struct libunwind_frame_cache *cache =
272
    libunwind_frame_cache (next_frame, this_cache);
273
 
274
  if (cache != NULL)
275
    (*this_id) = frame_id_build (cache->base, cache->func_addr);
276
  else
277
    (*this_id) = null_frame_id;
278
}
279
 
280
void
281
libunwind_frame_prev_register (struct frame_info *next_frame, void **this_cache,
282
                               int regnum, int *optimizedp,
283
                               enum lval_type *lvalp, CORE_ADDR *addrp,
284
                               int *realnump, gdb_byte *valuep)
285
{
286
  struct libunwind_frame_cache *cache =
287
    libunwind_frame_cache (next_frame, this_cache);
288
  struct gdbarch *gdbarch = get_frame_arch (next_frame);
289
 
290
  void *ptr;
291
  unw_cursor_t *c;
292
  unw_save_loc_t sl;
293
  int i, ret;
294
  unw_word_t intval;
295
  unw_fpreg_t fpval;
296
  unw_regnum_t uw_regnum;
297
  struct libunwind_descr *descr;
298
 
299
  if (cache == NULL)
300
    return;
301
 
302
  /* Convert from gdb register number to libunwind register number.  */
303
  descr = libunwind_descr (get_frame_arch (next_frame));
304
  uw_regnum = descr->gdb2uw (regnum);
305
 
306
  gdb_assert (regnum >= 0);
307
 
308
  if (!target_has_registers)
309
    error (_("No registers."));
310
 
311
  *optimizedp = 0;
312
  *addrp = 0;
313
  *lvalp = not_lval;
314
  *realnump = -1;
315
 
316
  if (valuep)
317
    memset (valuep, 0, register_size (gdbarch, regnum));
318
 
319
  if (uw_regnum < 0)
320
    return;
321
 
322
  /* To get the previous register, we use the libunwind register APIs with
323
     the cursor we have already pushed back to the previous frame.  */
324
 
325
  if (descr->is_fpreg (uw_regnum))
326
    {
327
      ret = unw_get_fpreg_p (&cache->cursor, uw_regnum, &fpval);
328
      ptr = &fpval;
329
    }
330
  else
331
    {
332
      ret = unw_get_reg_p (&cache->cursor, uw_regnum, &intval);
333
      ptr = &intval;
334
    }
335
 
336
  if (ret < 0)
337
    return;
338
 
339
  if (valuep)
340
    memcpy (valuep, ptr, register_size (gdbarch, regnum));
341
 
342
  if (unw_get_saveloc_p (&cache->cursor, uw_regnum, &sl) < 0)
343
    return;
344
 
345
  switch (sl.type)
346
    {
347
    case UNW_SLT_NONE:
348
      *optimizedp = 1;
349
      break;
350
 
351
    case UNW_SLT_MEMORY:
352
      *lvalp = lval_memory;
353
      *addrp = sl.u.addr;
354
      break;
355
 
356
    case UNW_SLT_REG:
357
      *lvalp = lval_register;
358
      *realnump = regnum;
359
      break;
360
    }
361
}
362
 
363
CORE_ADDR
364
libunwind_frame_base_address (struct frame_info *next_frame, void **this_cache)
365
{
366
  struct libunwind_frame_cache *cache =
367
    libunwind_frame_cache (next_frame, this_cache);
368
 
369
  if (cache == NULL)
370
    return (CORE_ADDR)NULL;
371
  return cache->base;
372
}
373
 
374
/* The following is a glue routine to call the libunwind unwind table
375
   search function to get unwind information for a specified ip address.  */
376
int
377
libunwind_search_unwind_table (void *as, long ip, void *di,
378
                               void *pi, int need_unwind_info, void *args)
379
{
380
  return unw_search_unwind_table_p (*(unw_addr_space_t *)as, (unw_word_t )ip,
381
                                    di, pi, need_unwind_info, args);
382
}
383
 
384
/* Verify if we are in a sigtramp frame and we can use libunwind to unwind.  */
385
const struct frame_unwind *
386
libunwind_sigtramp_frame_sniffer (struct frame_info *next_frame)
387
{
388
  unw_cursor_t cursor;
389
  unw_accessors_t *acc;
390
  unw_addr_space_t as;
391
  struct libunwind_descr *descr;
392
  struct gdbarch *gdbarch = get_frame_arch (next_frame);
393
  int i, ret;
394
 
395
  /* To test for libunwind unwind support, initialize a cursor to the
396
     current frame and try to back up.  We use this same method when
397
     setting up the frame cache (see libunwind_frame_cache()).  If
398
     libunwind returns success for this operation, it means that it
399
     has found sufficient libunwind unwinding information to do
400
     so.  */
401
 
402
  descr = libunwind_descr (gdbarch);
403
  acc = descr->accessors;
404
  as =  unw_create_addr_space_p (acc,
405
                                 gdbarch_byte_order (gdbarch)
406
                                 == BFD_ENDIAN_BIG
407
                                 ? __BIG_ENDIAN
408
                                 : __LITTLE_ENDIAN);
409
 
410
  ret = unw_init_remote_p (&cursor, as, next_frame);
411
 
412
  if (ret < 0)
413
    {
414
      unw_destroy_addr_space_p (as);
415
      return NULL;
416
    }
417
 
418
  /* Check to see if we are in a signal frame.  */
419
  ret = unw_is_signal_frame_p (&cursor);
420
  unw_destroy_addr_space_p (as);
421
  if (ret > 0)
422
    return &libunwind_frame_unwind;
423
 
424
  return NULL;
425
}
426
 
427
/* The following routine is for accessing special registers of the top frame.
428
   A special set of accessors must be given that work without frame info.
429
   This is used by ia64 to access the rse registers r32-r127.  While they
430
   are usually located at BOF, this is not always true and only the libunwind
431
   info can decipher where they actually are.  */
432
int
433
libunwind_get_reg_special (struct gdbarch *gdbarch, struct regcache *regcache,
434
                           int regnum, void *buf)
435
{
436
  unw_cursor_t cursor;
437
  unw_accessors_t *acc;
438
  unw_addr_space_t as;
439
  struct libunwind_descr *descr;
440
  int ret;
441
  unw_regnum_t uw_regnum;
442
  unw_word_t intval;
443
  unw_fpreg_t fpval;
444
  void *ptr;
445
 
446
 
447
  descr = libunwind_descr (gdbarch);
448
  acc = descr->special_accessors;
449
  as =  unw_create_addr_space_p (acc,
450
                                 gdbarch_byte_order (gdbarch)
451
                                 == BFD_ENDIAN_BIG
452
                                 ? __BIG_ENDIAN
453
                                 : __LITTLE_ENDIAN);
454
 
455
  ret = unw_init_remote_p (&cursor, as, regcache);
456
  if (ret < 0)
457
    {
458
      unw_destroy_addr_space_p (as);
459
      return -1;
460
    }
461
 
462
  uw_regnum = descr->gdb2uw (regnum);
463
 
464
  if (descr->is_fpreg (uw_regnum))
465
    {
466
      ret = unw_get_fpreg_p (&cursor, uw_regnum, &fpval);
467
      ptr = &fpval;
468
    }
469
  else
470
    {
471
      ret = unw_get_reg_p (&cursor, uw_regnum, &intval);
472
      ptr = &intval;
473
    }
474
 
475
  unw_destroy_addr_space_p (as);
476
 
477
  if (ret < 0)
478
    return -1;
479
 
480
  if (buf)
481
    memcpy (buf, ptr, register_size (gdbarch, regnum));
482
 
483
  return 0;
484
}
485
 
486
static int
487
libunwind_load (void)
488
{
489
  void *handle;
490
 
491
  handle = dlopen (LIBUNWIND_SO, RTLD_NOW);
492
  if (handle == NULL)
493
    return 0;
494
 
495
  /* Initialize pointers to the dynamic library functions we will use.  */
496
 
497
  unw_get_reg_p = dlsym (handle, get_reg_name);
498
  if (unw_get_reg_p == NULL)
499
    return 0;
500
 
501
  unw_get_fpreg_p = dlsym (handle, get_fpreg_name);
502
  if (unw_get_fpreg_p == NULL)
503
    return 0;
504
 
505
  unw_get_saveloc_p = dlsym (handle, get_saveloc_name);
506
  if (unw_get_saveloc_p == NULL)
507
    return 0;
508
 
509
  unw_is_signal_frame_p = dlsym (handle, is_signal_frame_name);
510
  if (unw_is_signal_frame_p == NULL)
511
    return 0;
512
 
513
  unw_step_p = dlsym (handle, step_name);
514
  if (unw_step_p == NULL)
515
    return 0;
516
 
517
  unw_init_remote_p = dlsym (handle, init_remote_name);
518
  if (unw_init_remote_p == NULL)
519
    return 0;
520
 
521
  unw_create_addr_space_p = dlsym (handle, create_addr_space_name);
522
  if (unw_create_addr_space_p == NULL)
523
    return 0;
524
 
525
  unw_destroy_addr_space_p = dlsym (handle, destroy_addr_space_name);
526
  if (unw_destroy_addr_space_p == NULL)
527
    return 0;
528
 
529
  unw_search_unwind_table_p = dlsym (handle, search_unwind_table_name);
530
  if (unw_search_unwind_table_p == NULL)
531
    return 0;
532
 
533
  unw_find_dyn_list_p = dlsym (handle, find_dyn_list_name);
534
  if (unw_find_dyn_list_p == NULL)
535
    return 0;
536
 
537
  return 1;
538
}
539
 
540
int
541
libunwind_is_initialized (void)
542
{
543
  return libunwind_initialized;
544
}
545
 
546
/* Provide a prototype to silence -Wmissing-prototypes.  */
547
void _initialize_libunwind_frame (void);
548
 
549
void
550
_initialize_libunwind_frame (void)
551
{
552
  libunwind_descr_handle = gdbarch_data_register_post_init (libunwind_descr_init);
553
 
554
  libunwind_initialized = libunwind_load ();
555
}

powered by: WebSVN 2.1.0

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