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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [gdb/] [libunwind-frame.c] - Blame information for rev 842

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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