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

Subversion Repositories openrisc_me

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

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* Cache and manage frames for GDB, the GNU debugger.
2
 
3
   Copyright (C) 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000, 2001,
4
   2002, 2003, 2004, 2007, 2008 Free Software Foundation, Inc.
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 "defs.h"
22
#include "frame.h"
23
#include "target.h"
24
#include "value.h"
25
#include "inferior.h"   /* for inferior_ptid */
26
#include "regcache.h"
27
#include "gdb_assert.h"
28
#include "gdb_string.h"
29
#include "user-regs.h"
30
#include "gdb_obstack.h"
31
#include "dummy-frame.h"
32
#include "sentinel-frame.h"
33
#include "gdbcore.h"
34
#include "annotate.h"
35
#include "language.h"
36
#include "frame-unwind.h"
37
#include "frame-base.h"
38
#include "command.h"
39
#include "gdbcmd.h"
40
#include "observer.h"
41
#include "objfiles.h"
42
#include "exceptions.h"
43
 
44
static struct frame_info *get_prev_frame_1 (struct frame_info *this_frame);
45
 
46
/* We keep a cache of stack frames, each of which is a "struct
47
   frame_info".  The innermost one gets allocated (in
48
   wait_for_inferior) each time the inferior stops; current_frame
49
   points to it.  Additional frames get allocated (in get_prev_frame)
50
   as needed, and are chained through the next and prev fields.  Any
51
   time that the frame cache becomes invalid (most notably when we
52
   execute something, but also if we change how we interpret the
53
   frames (e.g. "set heuristic-fence-post" in mips-tdep.c, or anything
54
   which reads new symbols)), we should call reinit_frame_cache.  */
55
 
56
struct frame_info
57
{
58
  /* Level of this frame.  The inner-most (youngest) frame is at level
59
     0.  As you move towards the outer-most (oldest) frame, the level
60
     increases.  This is a cached value.  It could just as easily be
61
     computed by counting back from the selected frame to the inner
62
     most frame.  */
63
  /* NOTE: cagney/2002-04-05: Perhaps a level of ``-1'' should be
64
     reserved to indicate a bogus frame - one that has been created
65
     just to keep GDB happy (GDB always needs a frame).  For the
66
     moment leave this as speculation.  */
67
  int level;
68
 
69
  /* The frame's low-level unwinder and corresponding cache.  The
70
     low-level unwinder is responsible for unwinding register values
71
     for the previous frame.  The low-level unwind methods are
72
     selected based on the presence, or otherwise, of register unwind
73
     information such as CFI.  */
74
  void *prologue_cache;
75
  const struct frame_unwind *unwind;
76
 
77
  /* Cached copy of the previous frame's resume address.  */
78
  struct {
79
    int p;
80
    CORE_ADDR value;
81
  } prev_pc;
82
 
83
  /* Cached copy of the previous frame's function address.  */
84
  struct
85
  {
86
    CORE_ADDR addr;
87
    int p;
88
  } prev_func;
89
 
90
  /* This frame's ID.  */
91
  struct
92
  {
93
    int p;
94
    struct frame_id value;
95
  } this_id;
96
 
97
  /* The frame's high-level base methods, and corresponding cache.
98
     The high level base methods are selected based on the frame's
99
     debug info.  */
100
  const struct frame_base *base;
101
  void *base_cache;
102
 
103
  /* Pointers to the next (down, inner, younger) and previous (up,
104
     outer, older) frame_info's in the frame cache.  */
105
  struct frame_info *next; /* down, inner, younger */
106
  int prev_p;
107
  struct frame_info *prev; /* up, outer, older */
108
 
109
  /* The reason why we could not set PREV, or UNWIND_NO_REASON if we
110
     could.  Only valid when PREV_P is set.  */
111
  enum unwind_stop_reason stop_reason;
112
};
113
 
114
/* Flag to control debugging.  */
115
 
116
static int frame_debug;
117
static void
118
show_frame_debug (struct ui_file *file, int from_tty,
119
                  struct cmd_list_element *c, const char *value)
120
{
121
  fprintf_filtered (file, _("Frame debugging is %s.\n"), value);
122
}
123
 
124
/* Flag to indicate whether backtraces should stop at main et.al.  */
125
 
126
static int backtrace_past_main;
127
static void
128
show_backtrace_past_main (struct ui_file *file, int from_tty,
129
                          struct cmd_list_element *c, const char *value)
130
{
131
  fprintf_filtered (file, _("\
132
Whether backtraces should continue past \"main\" is %s.\n"),
133
                    value);
134
}
135
 
136
static int backtrace_past_entry;
137
static void
138
show_backtrace_past_entry (struct ui_file *file, int from_tty,
139
                           struct cmd_list_element *c, const char *value)
140
{
141
  fprintf_filtered (file, _("\
142
Whether backtraces should continue past the entry point of a program is %s.\n"),
143
                    value);
144
}
145
 
146
static int backtrace_limit = INT_MAX;
147
static void
148
show_backtrace_limit (struct ui_file *file, int from_tty,
149
                      struct cmd_list_element *c, const char *value)
150
{
151
  fprintf_filtered (file, _("\
152
An upper bound on the number of backtrace levels is %s.\n"),
153
                    value);
154
}
155
 
156
 
157
static void
158
fprint_field (struct ui_file *file, const char *name, int p, CORE_ADDR addr)
159
{
160
  if (p)
161
    fprintf_unfiltered (file, "%s=0x%s", name, paddr_nz (addr));
162
  else
163
    fprintf_unfiltered (file, "!%s", name);
164
}
165
 
166
void
167
fprint_frame_id (struct ui_file *file, struct frame_id id)
168
{
169
  fprintf_unfiltered (file, "{");
170
  fprint_field (file, "stack", id.stack_addr_p, id.stack_addr);
171
  fprintf_unfiltered (file, ",");
172
  fprint_field (file, "code", id.code_addr_p, id.code_addr);
173
  fprintf_unfiltered (file, ",");
174
  fprint_field (file, "special", id.special_addr_p, id.special_addr);
175
  fprintf_unfiltered (file, "}");
176
}
177
 
178
static void
179
fprint_frame_type (struct ui_file *file, enum frame_type type)
180
{
181
  switch (type)
182
    {
183
    case NORMAL_FRAME:
184
      fprintf_unfiltered (file, "NORMAL_FRAME");
185
      return;
186
    case DUMMY_FRAME:
187
      fprintf_unfiltered (file, "DUMMY_FRAME");
188
      return;
189
    case SIGTRAMP_FRAME:
190
      fprintf_unfiltered (file, "SIGTRAMP_FRAME");
191
      return;
192
    default:
193
      fprintf_unfiltered (file, "<unknown type>");
194
      return;
195
    };
196
}
197
 
198
static void
199
fprint_frame (struct ui_file *file, struct frame_info *fi)
200
{
201
  if (fi == NULL)
202
    {
203
      fprintf_unfiltered (file, "<NULL frame>");
204
      return;
205
    }
206
  fprintf_unfiltered (file, "{");
207
  fprintf_unfiltered (file, "level=%d", fi->level);
208
  fprintf_unfiltered (file, ",");
209
  fprintf_unfiltered (file, "type=");
210
  if (fi->unwind != NULL)
211
    fprint_frame_type (file, fi->unwind->type);
212
  else
213
    fprintf_unfiltered (file, "<unknown>");
214
  fprintf_unfiltered (file, ",");
215
  fprintf_unfiltered (file, "unwind=");
216
  if (fi->unwind != NULL)
217
    gdb_print_host_address (fi->unwind, file);
218
  else
219
    fprintf_unfiltered (file, "<unknown>");
220
  fprintf_unfiltered (file, ",");
221
  fprintf_unfiltered (file, "pc=");
222
  if (fi->next != NULL && fi->next->prev_pc.p)
223
    fprintf_unfiltered (file, "0x%s", paddr_nz (fi->next->prev_pc.value));
224
  else
225
    fprintf_unfiltered (file, "<unknown>");
226
  fprintf_unfiltered (file, ",");
227
  fprintf_unfiltered (file, "id=");
228
  if (fi->this_id.p)
229
    fprint_frame_id (file, fi->this_id.value);
230
  else
231
    fprintf_unfiltered (file, "<unknown>");
232
  fprintf_unfiltered (file, ",");
233
  fprintf_unfiltered (file, "func=");
234
  if (fi->next != NULL && fi->next->prev_func.p)
235
    fprintf_unfiltered (file, "0x%s", paddr_nz (fi->next->prev_func.addr));
236
  else
237
    fprintf_unfiltered (file, "<unknown>");
238
  fprintf_unfiltered (file, "}");
239
}
240
 
241
/* Return a frame uniq ID that can be used to, later, re-find the
242
   frame.  */
243
 
244
struct frame_id
245
get_frame_id (struct frame_info *fi)
246
{
247
  if (fi == NULL)
248
    {
249
      return null_frame_id;
250
    }
251
  if (!fi->this_id.p)
252
    {
253
      if (frame_debug)
254
        fprintf_unfiltered (gdb_stdlog, "{ get_frame_id (fi=%d) ",
255
                            fi->level);
256
      /* Find the unwinder.  */
257
      if (fi->unwind == NULL)
258
        fi->unwind = frame_unwind_find_by_frame (fi->next,
259
                                                 &fi->prologue_cache);
260
      /* Find THIS frame's ID.  */
261
      fi->unwind->this_id (fi->next, &fi->prologue_cache, &fi->this_id.value);
262
      fi->this_id.p = 1;
263
      if (frame_debug)
264
        {
265
          fprintf_unfiltered (gdb_stdlog, "-> ");
266
          fprint_frame_id (gdb_stdlog, fi->this_id.value);
267
          fprintf_unfiltered (gdb_stdlog, " }\n");
268
        }
269
    }
270
  return fi->this_id.value;
271
}
272
 
273
struct frame_id
274
frame_unwind_id (struct frame_info *next_frame)
275
{
276
  /* Use prev_frame, and not get_prev_frame.  The latter will truncate
277
     the frame chain, leading to this function unintentionally
278
     returning a null_frame_id (e.g., when a caller requests the frame
279
     ID of "main()"s caller.  */
280
  return get_frame_id (get_prev_frame_1 (next_frame));
281
}
282
 
283
const struct frame_id null_frame_id; /* All zeros.  */
284
 
285
struct frame_id
286
frame_id_build_special (CORE_ADDR stack_addr, CORE_ADDR code_addr,
287
                        CORE_ADDR special_addr)
288
{
289
  struct frame_id id = null_frame_id;
290
  id.stack_addr = stack_addr;
291
  id.stack_addr_p = 1;
292
  id.code_addr = code_addr;
293
  id.code_addr_p = 1;
294
  id.special_addr = special_addr;
295
  id.special_addr_p = 1;
296
  return id;
297
}
298
 
299
struct frame_id
300
frame_id_build (CORE_ADDR stack_addr, CORE_ADDR code_addr)
301
{
302
  struct frame_id id = null_frame_id;
303
  id.stack_addr = stack_addr;
304
  id.stack_addr_p = 1;
305
  id.code_addr = code_addr;
306
  id.code_addr_p = 1;
307
  return id;
308
}
309
 
310
struct frame_id
311
frame_id_build_wild (CORE_ADDR stack_addr)
312
{
313
  struct frame_id id = null_frame_id;
314
  id.stack_addr = stack_addr;
315
  id.stack_addr_p = 1;
316
  return id;
317
}
318
 
319
int
320
frame_id_p (struct frame_id l)
321
{
322
  int p;
323
  /* The frame is valid iff it has a valid stack address.  */
324
  p = l.stack_addr_p;
325
  if (frame_debug)
326
    {
327
      fprintf_unfiltered (gdb_stdlog, "{ frame_id_p (l=");
328
      fprint_frame_id (gdb_stdlog, l);
329
      fprintf_unfiltered (gdb_stdlog, ") -> %d }\n", p);
330
    }
331
  return p;
332
}
333
 
334
int
335
frame_id_eq (struct frame_id l, struct frame_id r)
336
{
337
  int eq;
338
  if (!l.stack_addr_p || !r.stack_addr_p)
339
    /* Like a NaN, if either ID is invalid, the result is false.
340
       Note that a frame ID is invalid iff it is the null frame ID.  */
341
    eq = 0;
342
  else if (l.stack_addr != r.stack_addr)
343
    /* If .stack addresses are different, the frames are different.  */
344
    eq = 0;
345
  else if (!l.code_addr_p || !r.code_addr_p)
346
    /* An invalid code addr is a wild card, always succeed.  */
347
    eq = 1;
348
  else if (l.code_addr != r.code_addr)
349
    /* If .code addresses are different, the frames are different.  */
350
    eq = 0;
351
  else if (!l.special_addr_p || !r.special_addr_p)
352
    /* An invalid special addr is a wild card (or unused), always succeed.  */
353
    eq = 1;
354
  else if (l.special_addr == r.special_addr)
355
    /* Frames are equal.  */
356
    eq = 1;
357
  else
358
    /* No luck.  */
359
    eq = 0;
360
  if (frame_debug)
361
    {
362
      fprintf_unfiltered (gdb_stdlog, "{ frame_id_eq (l=");
363
      fprint_frame_id (gdb_stdlog, l);
364
      fprintf_unfiltered (gdb_stdlog, ",r=");
365
      fprint_frame_id (gdb_stdlog, r);
366
      fprintf_unfiltered (gdb_stdlog, ") -> %d }\n", eq);
367
    }
368
  return eq;
369
}
370
 
371
int
372
frame_id_inner (struct gdbarch *gdbarch, struct frame_id l, struct frame_id r)
373
{
374
  int inner;
375
  if (!l.stack_addr_p || !r.stack_addr_p)
376
    /* Like NaN, any operation involving an invalid ID always fails.  */
377
    inner = 0;
378
  else
379
    /* Only return non-zero when strictly inner than.  Note that, per
380
       comment in "frame.h", there is some fuzz here.  Frameless
381
       functions are not strictly inner than (same .stack but
382
       different .code and/or .special address).  */
383
    inner = gdbarch_inner_than (gdbarch, l.stack_addr, r.stack_addr);
384
  if (frame_debug)
385
    {
386
      fprintf_unfiltered (gdb_stdlog, "{ frame_id_inner (l=");
387
      fprint_frame_id (gdb_stdlog, l);
388
      fprintf_unfiltered (gdb_stdlog, ",r=");
389
      fprint_frame_id (gdb_stdlog, r);
390
      fprintf_unfiltered (gdb_stdlog, ") -> %d }\n", inner);
391
    }
392
  return inner;
393
}
394
 
395
struct frame_info *
396
frame_find_by_id (struct frame_id id)
397
{
398
  struct frame_info *frame;
399
 
400
  /* ZERO denotes the null frame, let the caller decide what to do
401
     about it.  Should it instead return get_current_frame()?  */
402
  if (!frame_id_p (id))
403
    return NULL;
404
 
405
  for (frame = get_current_frame ();
406
       frame != NULL;
407
       frame = get_prev_frame (frame))
408
    {
409
      struct frame_id this = get_frame_id (frame);
410
      if (frame_id_eq (id, this))
411
        /* An exact match.  */
412
        return frame;
413
      if (frame_id_inner (get_frame_arch (frame), id, this))
414
        /* Gone to far.  */
415
        return NULL;
416
      /* Either we're not yet gone far enough out along the frame
417
         chain (inner(this,id)), or we're comparing frameless functions
418
         (same .base, different .func, no test available).  Struggle
419
         on until we've definitly gone to far.  */
420
    }
421
  return NULL;
422
}
423
 
424
CORE_ADDR
425
frame_pc_unwind (struct frame_info *this_frame)
426
{
427
  if (!this_frame->prev_pc.p)
428
    {
429
      CORE_ADDR pc;
430
      if (this_frame->unwind == NULL)
431
        this_frame->unwind
432
          = frame_unwind_find_by_frame (this_frame->next,
433
                                        &this_frame->prologue_cache);
434
      if (this_frame->unwind->prev_pc != NULL)
435
        /* A per-frame unwinder, prefer it.  */
436
        pc = this_frame->unwind->prev_pc (this_frame->next,
437
                                          &this_frame->prologue_cache);
438
      else if (gdbarch_unwind_pc_p (get_frame_arch (this_frame)))
439
        {
440
          /* The right way.  The `pure' way.  The one true way.  This
441
             method depends solely on the register-unwind code to
442
             determine the value of registers in THIS frame, and hence
443
             the value of this frame's PC (resume address).  A typical
444
             implementation is no more than:
445
 
446
             frame_unwind_register (this_frame, ISA_PC_REGNUM, buf);
447
             return extract_unsigned_integer (buf, size of ISA_PC_REGNUM);
448
 
449
             Note: this method is very heavily dependent on a correct
450
             register-unwind implementation, it pays to fix that
451
             method first; this method is frame type agnostic, since
452
             it only deals with register values, it works with any
453
             frame.  This is all in stark contrast to the old
454
             FRAME_SAVED_PC which would try to directly handle all the
455
             different ways that a PC could be unwound.  */
456
          pc = gdbarch_unwind_pc (get_frame_arch (this_frame), this_frame);
457
        }
458
      else
459
        internal_error (__FILE__, __LINE__, _("No unwind_pc method"));
460
      this_frame->prev_pc.value = pc;
461
      this_frame->prev_pc.p = 1;
462
      if (frame_debug)
463
        fprintf_unfiltered (gdb_stdlog,
464
                            "{ frame_pc_unwind (this_frame=%d) -> 0x%s }\n",
465
                            this_frame->level,
466
                            paddr_nz (this_frame->prev_pc.value));
467
    }
468
  return this_frame->prev_pc.value;
469
}
470
 
471
CORE_ADDR
472
frame_func_unwind (struct frame_info *fi, enum frame_type this_type)
473
{
474
  if (!fi->prev_func.p)
475
    {
476
      /* Make certain that this, and not the adjacent, function is
477
         found.  */
478
      CORE_ADDR addr_in_block = frame_unwind_address_in_block (fi, this_type);
479
      fi->prev_func.p = 1;
480
      fi->prev_func.addr = get_pc_function_start (addr_in_block);
481
      if (frame_debug)
482
        fprintf_unfiltered (gdb_stdlog,
483
                            "{ frame_func_unwind (fi=%d) -> 0x%s }\n",
484
                            fi->level, paddr_nz (fi->prev_func.addr));
485
    }
486
  return fi->prev_func.addr;
487
}
488
 
489
CORE_ADDR
490
get_frame_func (struct frame_info *fi)
491
{
492
  return frame_func_unwind (fi->next, get_frame_type (fi));
493
}
494
 
495
static int
496
do_frame_register_read (void *src, int regnum, gdb_byte *buf)
497
{
498
  frame_register_read (src, regnum, buf);
499
  return 1;
500
}
501
 
502
struct regcache *
503
frame_save_as_regcache (struct frame_info *this_frame)
504
{
505
  struct regcache *regcache = regcache_xmalloc (get_frame_arch (this_frame));
506
  struct cleanup *cleanups = make_cleanup_regcache_xfree (regcache);
507
  regcache_save (regcache, do_frame_register_read, this_frame);
508
  discard_cleanups (cleanups);
509
  return regcache;
510
}
511
 
512
void
513
frame_pop (struct frame_info *this_frame)
514
{
515
  struct frame_info *prev_frame;
516
  struct regcache *scratch;
517
  struct cleanup *cleanups;
518
 
519
  /* Ensure that we have a frame to pop to.  */
520
  prev_frame = get_prev_frame_1 (this_frame);
521
 
522
  if (!prev_frame)
523
    error (_("Cannot pop the initial frame."));
524
 
525
  /* Make a copy of all the register values unwound from this frame.
526
     Save them in a scratch buffer so that there isn't a race between
527
     trying to extract the old values from the current regcache while
528
     at the same time writing new values into that same cache.  */
529
  scratch = frame_save_as_regcache (prev_frame);
530
  cleanups = make_cleanup_regcache_xfree (scratch);
531
 
532
  /* FIXME: cagney/2003-03-16: It should be possible to tell the
533
     target's register cache that it is about to be hit with a burst
534
     register transfer and that the sequence of register writes should
535
     be batched.  The pair target_prepare_to_store() and
536
     target_store_registers() kind of suggest this functionality.
537
     Unfortunately, they don't implement it.  Their lack of a formal
538
     definition can lead to targets writing back bogus values
539
     (arguably a bug in the target code mind).  */
540
  /* Now copy those saved registers into the current regcache.
541
     Here, regcache_cpy() calls regcache_restore().  */
542
  regcache_cpy (get_current_regcache (), scratch);
543
  do_cleanups (cleanups);
544
 
545
  /* We've made right mess of GDB's local state, just discard
546
     everything.  */
547
  reinit_frame_cache ();
548
}
549
 
550
void
551
frame_register_unwind (struct frame_info *frame, int regnum,
552
                       int *optimizedp, enum lval_type *lvalp,
553
                       CORE_ADDR *addrp, int *realnump, gdb_byte *bufferp)
554
{
555
  struct frame_unwind_cache *cache;
556
 
557
  if (frame_debug)
558
    {
559
      fprintf_unfiltered (gdb_stdlog, "\
560
{ frame_register_unwind (frame=%d,regnum=%d(%s),...) ",
561
                          frame->level, regnum,
562
                          frame_map_regnum_to_name (frame, regnum));
563
    }
564
 
565
  /* Require all but BUFFERP to be valid.  A NULL BUFFERP indicates
566
     that the value proper does not need to be fetched.  */
567
  gdb_assert (optimizedp != NULL);
568
  gdb_assert (lvalp != NULL);
569
  gdb_assert (addrp != NULL);
570
  gdb_assert (realnump != NULL);
571
  /* gdb_assert (bufferp != NULL); */
572
 
573
  /* NOTE: cagney/2002-11-27: A program trying to unwind a NULL frame
574
     is broken.  There is always a frame.  If there, for some reason,
575
     isn't a frame, there is some pretty busted code as it should have
576
     detected the problem before calling here.  */
577
  gdb_assert (frame != NULL);
578
 
579
  /* Find the unwinder.  */
580
  if (frame->unwind == NULL)
581
    frame->unwind = frame_unwind_find_by_frame (frame->next,
582
                                                &frame->prologue_cache);
583
 
584
  /* Ask this frame to unwind its register.  See comment in
585
     "frame-unwind.h" for why NEXT frame and this unwind cache are
586
     passed in.  */
587
  frame->unwind->prev_register (frame->next, &frame->prologue_cache, regnum,
588
                                optimizedp, lvalp, addrp, realnump, bufferp);
589
 
590
  if (frame_debug)
591
    {
592
      fprintf_unfiltered (gdb_stdlog, "->");
593
      fprintf_unfiltered (gdb_stdlog, " *optimizedp=%d", (*optimizedp));
594
      fprintf_unfiltered (gdb_stdlog, " *lvalp=%d", (int) (*lvalp));
595
      fprintf_unfiltered (gdb_stdlog, " *addrp=0x%s", paddr_nz ((*addrp)));
596
      fprintf_unfiltered (gdb_stdlog, " *bufferp=");
597
      if (bufferp == NULL)
598
        fprintf_unfiltered (gdb_stdlog, "<NULL>");
599
      else
600
        {
601
          int i;
602
          const unsigned char *buf = bufferp;
603
          fprintf_unfiltered (gdb_stdlog, "[");
604
          for (i = 0; i < register_size (get_frame_arch (frame), regnum); i++)
605
            fprintf_unfiltered (gdb_stdlog, "%02x", buf[i]);
606
          fprintf_unfiltered (gdb_stdlog, "]");
607
        }
608
      fprintf_unfiltered (gdb_stdlog, " }\n");
609
    }
610
}
611
 
612
void
613
frame_register (struct frame_info *frame, int regnum,
614
                int *optimizedp, enum lval_type *lvalp,
615
                CORE_ADDR *addrp, int *realnump, gdb_byte *bufferp)
616
{
617
  /* Require all but BUFFERP to be valid.  A NULL BUFFERP indicates
618
     that the value proper does not need to be fetched.  */
619
  gdb_assert (optimizedp != NULL);
620
  gdb_assert (lvalp != NULL);
621
  gdb_assert (addrp != NULL);
622
  gdb_assert (realnump != NULL);
623
  /* gdb_assert (bufferp != NULL); */
624
 
625
  /* Obtain the register value by unwinding the register from the next
626
     (more inner frame).  */
627
  gdb_assert (frame != NULL && frame->next != NULL);
628
  frame_register_unwind (frame->next, regnum, optimizedp, lvalp, addrp,
629
                         realnump, bufferp);
630
}
631
 
632
void
633
frame_unwind_register (struct frame_info *frame, int regnum, gdb_byte *buf)
634
{
635
  int optimized;
636
  CORE_ADDR addr;
637
  int realnum;
638
  enum lval_type lval;
639
  frame_register_unwind (frame, regnum, &optimized, &lval, &addr,
640
                         &realnum, buf);
641
}
642
 
643
void
644
get_frame_register (struct frame_info *frame,
645
                    int regnum, gdb_byte *buf)
646
{
647
  frame_unwind_register (frame->next, regnum, buf);
648
}
649
 
650
LONGEST
651
frame_unwind_register_signed (struct frame_info *frame, int regnum)
652
{
653
  gdb_byte buf[MAX_REGISTER_SIZE];
654
  frame_unwind_register (frame, regnum, buf);
655
  return extract_signed_integer (buf, register_size (get_frame_arch (frame),
656
                                                     regnum));
657
}
658
 
659
LONGEST
660
get_frame_register_signed (struct frame_info *frame, int regnum)
661
{
662
  return frame_unwind_register_signed (frame->next, regnum);
663
}
664
 
665
ULONGEST
666
frame_unwind_register_unsigned (struct frame_info *frame, int regnum)
667
{
668
  gdb_byte buf[MAX_REGISTER_SIZE];
669
  frame_unwind_register (frame, regnum, buf);
670
  return extract_unsigned_integer (buf, register_size (get_frame_arch (frame),
671
                                                       regnum));
672
}
673
 
674
ULONGEST
675
get_frame_register_unsigned (struct frame_info *frame, int regnum)
676
{
677
  return frame_unwind_register_unsigned (frame->next, regnum);
678
}
679
 
680
void
681
put_frame_register (struct frame_info *frame, int regnum,
682
                    const gdb_byte *buf)
683
{
684
  struct gdbarch *gdbarch = get_frame_arch (frame);
685
  int realnum;
686
  int optim;
687
  enum lval_type lval;
688
  CORE_ADDR addr;
689
  frame_register (frame, regnum, &optim, &lval, &addr, &realnum, NULL);
690
  if (optim)
691
    error (_("Attempt to assign to a value that was optimized out."));
692
  switch (lval)
693
    {
694
    case lval_memory:
695
      {
696
        /* FIXME: write_memory doesn't yet take constant buffers.
697
           Arrrg!  */
698
        gdb_byte tmp[MAX_REGISTER_SIZE];
699
        memcpy (tmp, buf, register_size (gdbarch, regnum));
700
        write_memory (addr, tmp, register_size (gdbarch, regnum));
701
        break;
702
      }
703
    case lval_register:
704
      regcache_cooked_write (get_current_regcache (), realnum, buf);
705
      break;
706
    default:
707
      error (_("Attempt to assign to an unmodifiable value."));
708
    }
709
}
710
 
711
/* frame_register_read ()
712
 
713
   Find and return the value of REGNUM for the specified stack frame.
714
   The number of bytes copied is REGISTER_SIZE (REGNUM).
715
 
716
   Returns 0 if the register value could not be found.  */
717
 
718
int
719
frame_register_read (struct frame_info *frame, int regnum,
720
                     gdb_byte *myaddr)
721
{
722
  int optimized;
723
  enum lval_type lval;
724
  CORE_ADDR addr;
725
  int realnum;
726
  frame_register (frame, regnum, &optimized, &lval, &addr, &realnum, myaddr);
727
 
728
  return !optimized;
729
}
730
 
731
int
732
get_frame_register_bytes (struct frame_info *frame, int regnum,
733
                          CORE_ADDR offset, int len, gdb_byte *myaddr)
734
{
735
  struct gdbarch *gdbarch = get_frame_arch (frame);
736
 
737
  /* Skip registers wholly inside of OFFSET.  */
738
  while (offset >= register_size (gdbarch, regnum))
739
    {
740
      offset -= register_size (gdbarch, regnum);
741
      regnum++;
742
    }
743
 
744
  /* Copy the data.  */
745
  while (len > 0)
746
    {
747
      int curr_len = register_size (gdbarch, regnum) - offset;
748
      if (curr_len > len)
749
        curr_len = len;
750
 
751
      if (curr_len == register_size (gdbarch, regnum))
752
        {
753
          if (!frame_register_read (frame, regnum, myaddr))
754
            return 0;
755
        }
756
      else
757
        {
758
          gdb_byte buf[MAX_REGISTER_SIZE];
759
          if (!frame_register_read (frame, regnum, buf))
760
            return 0;
761
          memcpy (myaddr, buf + offset, curr_len);
762
        }
763
 
764
      myaddr += curr_len;
765
      len -= curr_len;
766
      offset = 0;
767
      regnum++;
768
    }
769
 
770
  return 1;
771
}
772
 
773
void
774
put_frame_register_bytes (struct frame_info *frame, int regnum,
775
                          CORE_ADDR offset, int len, const gdb_byte *myaddr)
776
{
777
  struct gdbarch *gdbarch = get_frame_arch (frame);
778
 
779
  /* Skip registers wholly inside of OFFSET.  */
780
  while (offset >= register_size (gdbarch, regnum))
781
    {
782
      offset -= register_size (gdbarch, regnum);
783
      regnum++;
784
    }
785
 
786
  /* Copy the data.  */
787
  while (len > 0)
788
    {
789
      int curr_len = register_size (gdbarch, regnum) - offset;
790
      if (curr_len > len)
791
        curr_len = len;
792
 
793
      if (curr_len == register_size (gdbarch, regnum))
794
        {
795
          put_frame_register (frame, regnum, myaddr);
796
        }
797
      else
798
        {
799
          gdb_byte buf[MAX_REGISTER_SIZE];
800
          frame_register_read (frame, regnum, buf);
801
          memcpy (buf + offset, myaddr, curr_len);
802
          put_frame_register (frame, regnum, buf);
803
        }
804
 
805
      myaddr += curr_len;
806
      len -= curr_len;
807
      offset = 0;
808
      regnum++;
809
    }
810
}
811
 
812
/* Map between a frame register number and its name.  A frame register
813
   space is a superset of the cooked register space --- it also
814
   includes builtin registers.  */
815
 
816
int
817
frame_map_name_to_regnum (struct frame_info *frame, const char *name, int len)
818
{
819
  return user_reg_map_name_to_regnum (get_frame_arch (frame), name, len);
820
}
821
 
822
const char *
823
frame_map_regnum_to_name (struct frame_info *frame, int regnum)
824
{
825
  return user_reg_map_regnum_to_name (get_frame_arch (frame), regnum);
826
}
827
 
828
/* Create a sentinel frame.  */
829
 
830
static struct frame_info *
831
create_sentinel_frame (struct regcache *regcache)
832
{
833
  struct frame_info *frame = FRAME_OBSTACK_ZALLOC (struct frame_info);
834
  frame->level = -1;
835
  /* Explicitly initialize the sentinel frame's cache.  Provide it
836
     with the underlying regcache.  In the future additional
837
     information, such as the frame's thread will be added.  */
838
  frame->prologue_cache = sentinel_frame_cache (regcache);
839
  /* For the moment there is only one sentinel frame implementation.  */
840
  frame->unwind = sentinel_frame_unwind;
841
  /* Link this frame back to itself.  The frame is self referential
842
     (the unwound PC is the same as the pc), so make it so.  */
843
  frame->next = frame;
844
  /* Make the sentinel frame's ID valid, but invalid.  That way all
845
     comparisons with it should fail.  */
846
  frame->this_id.p = 1;
847
  frame->this_id.value = null_frame_id;
848
  if (frame_debug)
849
    {
850
      fprintf_unfiltered (gdb_stdlog, "{ create_sentinel_frame (...) -> ");
851
      fprint_frame (gdb_stdlog, frame);
852
      fprintf_unfiltered (gdb_stdlog, " }\n");
853
    }
854
  return frame;
855
}
856
 
857
/* Info about the innermost stack frame (contents of FP register) */
858
 
859
static struct frame_info *current_frame;
860
 
861
/* Cache for frame addresses already read by gdb.  Valid only while
862
   inferior is stopped.  Control variables for the frame cache should
863
   be local to this module.  */
864
 
865
static struct obstack frame_cache_obstack;
866
 
867
void *
868
frame_obstack_zalloc (unsigned long size)
869
{
870
  void *data = obstack_alloc (&frame_cache_obstack, size);
871
  memset (data, 0, size);
872
  return data;
873
}
874
 
875
/* Return the innermost (currently executing) stack frame.  This is
876
   split into two functions.  The function unwind_to_current_frame()
877
   is wrapped in catch exceptions so that, even when the unwind of the
878
   sentinel frame fails, the function still returns a stack frame.  */
879
 
880
static int
881
unwind_to_current_frame (struct ui_out *ui_out, void *args)
882
{
883
  struct frame_info *frame = get_prev_frame (args);
884
  /* A sentinel frame can fail to unwind, e.g., because its PC value
885
     lands in somewhere like start.  */
886
  if (frame == NULL)
887
    return 1;
888
  current_frame = frame;
889
  return 0;
890
}
891
 
892
struct frame_info *
893
get_current_frame (void)
894
{
895
  /* First check, and report, the lack of registers.  Having GDB
896
     report "No stack!" or "No memory" when the target doesn't even
897
     have registers is very confusing.  Besides, "printcmd.exp"
898
     explicitly checks that ``print $pc'' with no registers prints "No
899
     registers".  */
900
  if (!target_has_registers)
901
    error (_("No registers."));
902
  if (!target_has_stack)
903
    error (_("No stack."));
904
  if (!target_has_memory)
905
    error (_("No memory."));
906
  if (current_frame == NULL)
907
    {
908
      struct frame_info *sentinel_frame =
909
        create_sentinel_frame (get_current_regcache ());
910
      if (catch_exceptions (uiout, unwind_to_current_frame, sentinel_frame,
911
                            RETURN_MASK_ERROR) != 0)
912
        {
913
          /* Oops! Fake a current frame?  Is this useful?  It has a PC
914
             of zero, for instance.  */
915
          current_frame = sentinel_frame;
916
        }
917
    }
918
  return current_frame;
919
}
920
 
921
/* The "selected" stack frame is used by default for local and arg
922
   access.  May be zero, for no selected frame.  */
923
 
924
static struct frame_info *selected_frame;
925
 
926
/* Return the selected frame.  Always non-NULL (unless there isn't an
927
   inferior sufficient for creating a frame) in which case an error is
928
   thrown.  */
929
 
930
struct frame_info *
931
get_selected_frame (const char *message)
932
{
933
  if (selected_frame == NULL)
934
    {
935
      if (message != NULL && (!target_has_registers
936
                              || !target_has_stack
937
                              || !target_has_memory))
938
        error (("%s"), message);
939
      /* Hey!  Don't trust this.  It should really be re-finding the
940
         last selected frame of the currently selected thread.  This,
941
         though, is better than nothing.  */
942
      select_frame (get_current_frame ());
943
    }
944
  /* There is always a frame.  */
945
  gdb_assert (selected_frame != NULL);
946
  return selected_frame;
947
}
948
 
949
/* This is a variant of get_selected_frame() which can be called when
950
   the inferior does not have a frame; in that case it will return
951
   NULL instead of calling error().  */
952
 
953
struct frame_info *
954
deprecated_safe_get_selected_frame (void)
955
{
956
  if (!target_has_registers || !target_has_stack || !target_has_memory)
957
    return NULL;
958
  return get_selected_frame (NULL);
959
}
960
 
961
/* Select frame FI (or NULL - to invalidate the current frame).  */
962
 
963
void
964
select_frame (struct frame_info *fi)
965
{
966
  struct symtab *s;
967
 
968
  selected_frame = fi;
969
  /* NOTE: cagney/2002-05-04: FI can be NULL.  This occurs when the
970
     frame is being invalidated.  */
971
  if (deprecated_selected_frame_level_changed_hook)
972
    deprecated_selected_frame_level_changed_hook (frame_relative_level (fi));
973
 
974
  /* FIXME: kseitz/2002-08-28: It would be nice to call
975
     selected_frame_level_changed_event() right here, but due to limitations
976
     in the current interfaces, we would end up flooding UIs with events
977
     because select_frame() is used extensively internally.
978
 
979
     Once we have frame-parameterized frame (and frame-related) commands,
980
     the event notification can be moved here, since this function will only
981
     be called when the user's selected frame is being changed. */
982
 
983
  /* Ensure that symbols for this frame are read in.  Also, determine the
984
     source language of this frame, and switch to it if desired.  */
985
  if (fi)
986
    {
987
      /* We retrieve the frame's symtab by using the frame PC.  However
988
         we cannot use the frame PC as-is, because it usually points to
989
         the instruction following the "call", which is sometimes the
990
         first instruction of another function.  So we rely on
991
         get_frame_address_in_block() which provides us with a PC which
992
         is guaranteed to be inside the frame's code block.  */
993
      s = find_pc_symtab (get_frame_address_in_block (fi));
994
      if (s
995
          && s->language != current_language->la_language
996
          && s->language != language_unknown
997
          && language_mode == language_mode_auto)
998
        {
999
          set_language (s->language);
1000
        }
1001
    }
1002
}
1003
 
1004
/* Create an arbitrary (i.e. address specified by user) or innermost frame.
1005
   Always returns a non-NULL value.  */
1006
 
1007
struct frame_info *
1008
create_new_frame (CORE_ADDR addr, CORE_ADDR pc)
1009
{
1010
  struct frame_info *fi;
1011
 
1012
  if (frame_debug)
1013
    {
1014
      fprintf_unfiltered (gdb_stdlog,
1015
                          "{ create_new_frame (addr=0x%s, pc=0x%s) ",
1016
                          paddr_nz (addr), paddr_nz (pc));
1017
    }
1018
 
1019
  fi = FRAME_OBSTACK_ZALLOC (struct frame_info);
1020
 
1021
  fi->next = create_sentinel_frame (get_current_regcache ());
1022
 
1023
  /* Select/initialize both the unwind function and the frame's type
1024
     based on the PC.  */
1025
  fi->unwind = frame_unwind_find_by_frame (fi->next, &fi->prologue_cache);
1026
 
1027
  fi->this_id.p = 1;
1028
  deprecated_update_frame_base_hack (fi, addr);
1029
  deprecated_update_frame_pc_hack (fi, pc);
1030
 
1031
  if (frame_debug)
1032
    {
1033
      fprintf_unfiltered (gdb_stdlog, "-> ");
1034
      fprint_frame (gdb_stdlog, fi);
1035
      fprintf_unfiltered (gdb_stdlog, " }\n");
1036
    }
1037
 
1038
  return fi;
1039
}
1040
 
1041
/* Return the frame that THIS_FRAME calls (NULL if THIS_FRAME is the
1042
   innermost frame).  Be careful to not fall off the bottom of the
1043
   frame chain and onto the sentinel frame.  */
1044
 
1045
struct frame_info *
1046
get_next_frame (struct frame_info *this_frame)
1047
{
1048
  if (this_frame->level > 0)
1049
    return this_frame->next;
1050
  else
1051
    return NULL;
1052
}
1053
 
1054
/* Observer for the target_changed event.  */
1055
 
1056
void
1057
frame_observer_target_changed (struct target_ops *target)
1058
{
1059
  reinit_frame_cache ();
1060
}
1061
 
1062
/* Flush the entire frame cache.  */
1063
 
1064
void
1065
reinit_frame_cache (void)
1066
{
1067
  struct frame_info *fi;
1068
 
1069
  /* Tear down all frame caches.  */
1070
  for (fi = current_frame; fi != NULL; fi = fi->prev)
1071
    {
1072
      if (fi->prologue_cache && fi->unwind->dealloc_cache)
1073
        fi->unwind->dealloc_cache (fi, fi->prologue_cache);
1074
      if (fi->base_cache && fi->base->unwind->dealloc_cache)
1075
        fi->base->unwind->dealloc_cache (fi, fi->base_cache);
1076
    }
1077
 
1078
  /* Since we can't really be sure what the first object allocated was */
1079
  obstack_free (&frame_cache_obstack, 0);
1080
  obstack_init (&frame_cache_obstack);
1081
 
1082
  if (current_frame != NULL)
1083
    annotate_frames_invalid ();
1084
 
1085
  current_frame = NULL;         /* Invalidate cache */
1086
  select_frame (NULL);
1087
  if (frame_debug)
1088
    fprintf_unfiltered (gdb_stdlog, "{ reinit_frame_cache () }\n");
1089
}
1090
 
1091
/* Find where a register is saved (in memory or another register).
1092
   The result of frame_register_unwind is just where it is saved
1093
   relative to this particular frame.  */
1094
 
1095
static void
1096
frame_register_unwind_location (struct frame_info *this_frame, int regnum,
1097
                                int *optimizedp, enum lval_type *lvalp,
1098
                                CORE_ADDR *addrp, int *realnump)
1099
{
1100
  gdb_assert (this_frame == NULL || this_frame->level >= 0);
1101
 
1102
  while (this_frame != NULL)
1103
    {
1104
      frame_register_unwind (this_frame, regnum, optimizedp, lvalp,
1105
                             addrp, realnump, NULL);
1106
 
1107
      if (*optimizedp)
1108
        break;
1109
 
1110
      if (*lvalp != lval_register)
1111
        break;
1112
 
1113
      regnum = *realnump;
1114
      this_frame = get_next_frame (this_frame);
1115
    }
1116
}
1117
 
1118
/* Return a "struct frame_info" corresponding to the frame that called
1119
   THIS_FRAME.  Returns NULL if there is no such frame.
1120
 
1121
   Unlike get_prev_frame, this function always tries to unwind the
1122
   frame.  */
1123
 
1124
static struct frame_info *
1125
get_prev_frame_1 (struct frame_info *this_frame)
1126
{
1127
  struct frame_info *prev_frame;
1128
  struct frame_id this_id;
1129
  struct gdbarch *gdbarch;
1130
 
1131
  gdb_assert (this_frame != NULL);
1132
  gdbarch = get_frame_arch (this_frame);
1133
 
1134
  if (frame_debug)
1135
    {
1136
      fprintf_unfiltered (gdb_stdlog, "{ get_prev_frame_1 (this_frame=");
1137
      if (this_frame != NULL)
1138
        fprintf_unfiltered (gdb_stdlog, "%d", this_frame->level);
1139
      else
1140
        fprintf_unfiltered (gdb_stdlog, "<NULL>");
1141
      fprintf_unfiltered (gdb_stdlog, ") ");
1142
    }
1143
 
1144
  /* Only try to do the unwind once.  */
1145
  if (this_frame->prev_p)
1146
    {
1147
      if (frame_debug)
1148
        {
1149
          fprintf_unfiltered (gdb_stdlog, "-> ");
1150
          fprint_frame (gdb_stdlog, this_frame->prev);
1151
          fprintf_unfiltered (gdb_stdlog, " // cached \n");
1152
        }
1153
      return this_frame->prev;
1154
    }
1155
  this_frame->prev_p = 1;
1156
  this_frame->stop_reason = UNWIND_NO_REASON;
1157
 
1158
  /* Check that this frame's ID was valid.  If it wasn't, don't try to
1159
     unwind to the prev frame.  Be careful to not apply this test to
1160
     the sentinel frame.  */
1161
  this_id = get_frame_id (this_frame);
1162
  if (this_frame->level >= 0 && !frame_id_p (this_id))
1163
    {
1164
      if (frame_debug)
1165
        {
1166
          fprintf_unfiltered (gdb_stdlog, "-> ");
1167
          fprint_frame (gdb_stdlog, NULL);
1168
          fprintf_unfiltered (gdb_stdlog, " // this ID is NULL }\n");
1169
        }
1170
      this_frame->stop_reason = UNWIND_NULL_ID;
1171
      return NULL;
1172
    }
1173
 
1174
  /* Check that this frame's ID isn't inner to (younger, below, next)
1175
     the next frame.  This happens when a frame unwind goes backwards.
1176
     Exclude signal trampolines (due to sigaltstack the frame ID can
1177
     go backwards) and sentinel frames (the test is meaningless).  */
1178
  if (this_frame->next->level >= 0
1179
      && this_frame->next->unwind->type != SIGTRAMP_FRAME
1180
      && frame_id_inner (get_frame_arch (this_frame), this_id,
1181
                         get_frame_id (this_frame->next)))
1182
    {
1183
      if (frame_debug)
1184
        {
1185
          fprintf_unfiltered (gdb_stdlog, "-> ");
1186
          fprint_frame (gdb_stdlog, NULL);
1187
          fprintf_unfiltered (gdb_stdlog, " // this frame ID is inner }\n");
1188
        }
1189
      this_frame->stop_reason = UNWIND_INNER_ID;
1190
      return NULL;
1191
    }
1192
 
1193
  /* Check that this and the next frame are not identical.  If they
1194
     are, there is most likely a stack cycle.  As with the inner-than
1195
     test above, avoid comparing the inner-most and sentinel frames.  */
1196
  if (this_frame->level > 0
1197
      && frame_id_eq (this_id, get_frame_id (this_frame->next)))
1198
    {
1199
      if (frame_debug)
1200
        {
1201
          fprintf_unfiltered (gdb_stdlog, "-> ");
1202
          fprint_frame (gdb_stdlog, NULL);
1203
          fprintf_unfiltered (gdb_stdlog, " // this frame has same ID }\n");
1204
        }
1205
      this_frame->stop_reason = UNWIND_SAME_ID;
1206
      return NULL;
1207
    }
1208
 
1209
  /* Check that this and the next frame do not unwind the PC register
1210
     to the same memory location.  If they do, then even though they
1211
     have different frame IDs, the new frame will be bogus; two
1212
     functions can't share a register save slot for the PC.  This can
1213
     happen when the prologue analyzer finds a stack adjustment, but
1214
     no PC save.
1215
 
1216
     This check does assume that the "PC register" is roughly a
1217
     traditional PC, even if the gdbarch_unwind_pc method adjusts
1218
     it (we do not rely on the value, only on the unwound PC being
1219
     dependent on this value).  A potential improvement would be
1220
     to have the frame prev_pc method and the gdbarch unwind_pc
1221
     method set the same lval and location information as
1222
     frame_register_unwind.  */
1223
  if (this_frame->level > 0
1224
      && gdbarch_pc_regnum (gdbarch) >= 0
1225
      && get_frame_type (this_frame) == NORMAL_FRAME
1226
      && get_frame_type (this_frame->next) == NORMAL_FRAME)
1227
    {
1228
      int optimized, realnum, nrealnum;
1229
      enum lval_type lval, nlval;
1230
      CORE_ADDR addr, naddr;
1231
 
1232
      frame_register_unwind_location (this_frame,
1233
                                      gdbarch_pc_regnum (gdbarch),
1234
                                      &optimized, &lval, &addr, &realnum);
1235
      frame_register_unwind_location (get_next_frame (this_frame),
1236
                                      gdbarch_pc_regnum (gdbarch),
1237
                                      &optimized, &nlval, &naddr, &nrealnum);
1238
 
1239
      if ((lval == lval_memory && lval == nlval && addr == naddr)
1240
          || (lval == lval_register && lval == nlval && realnum == nrealnum))
1241
        {
1242
          if (frame_debug)
1243
            {
1244
              fprintf_unfiltered (gdb_stdlog, "-> ");
1245
              fprint_frame (gdb_stdlog, NULL);
1246
              fprintf_unfiltered (gdb_stdlog, " // no saved PC }\n");
1247
            }
1248
 
1249
          this_frame->stop_reason = UNWIND_NO_SAVED_PC;
1250
          this_frame->prev = NULL;
1251
          return NULL;
1252
        }
1253
    }
1254
 
1255
  /* Allocate the new frame but do not wire it in to the frame chain.
1256
     Some (bad) code in INIT_FRAME_EXTRA_INFO tries to look along
1257
     frame->next to pull some fancy tricks (of course such code is, by
1258
     definition, recursive).  Try to prevent it.
1259
 
1260
     There is no reason to worry about memory leaks, should the
1261
     remainder of the function fail.  The allocated memory will be
1262
     quickly reclaimed when the frame cache is flushed, and the `we've
1263
     been here before' check above will stop repeated memory
1264
     allocation calls.  */
1265
  prev_frame = FRAME_OBSTACK_ZALLOC (struct frame_info);
1266
  prev_frame->level = this_frame->level + 1;
1267
 
1268
  /* Don't yet compute ->unwind (and hence ->type).  It is computed
1269
     on-demand in get_frame_type, frame_register_unwind, and
1270
     get_frame_id.  */
1271
 
1272
  /* Don't yet compute the frame's ID.  It is computed on-demand by
1273
     get_frame_id().  */
1274
 
1275
  /* The unwound frame ID is validate at the start of this function,
1276
     as part of the logic to decide if that frame should be further
1277
     unwound, and not here while the prev frame is being created.
1278
     Doing this makes it possible for the user to examine a frame that
1279
     has an invalid frame ID.
1280
 
1281
     Some very old VAX code noted: [...]  For the sake of argument,
1282
     suppose that the stack is somewhat trashed (which is one reason
1283
     that "info frame" exists).  So, return 0 (indicating we don't
1284
     know the address of the arglist) if we don't know what frame this
1285
     frame calls.  */
1286
 
1287
  /* Link it in.  */
1288
  this_frame->prev = prev_frame;
1289
  prev_frame->next = this_frame;
1290
 
1291
  if (frame_debug)
1292
    {
1293
      fprintf_unfiltered (gdb_stdlog, "-> ");
1294
      fprint_frame (gdb_stdlog, prev_frame);
1295
      fprintf_unfiltered (gdb_stdlog, " }\n");
1296
    }
1297
 
1298
  return prev_frame;
1299
}
1300
 
1301
/* Debug routine to print a NULL frame being returned.  */
1302
 
1303
static void
1304
frame_debug_got_null_frame (struct ui_file *file,
1305
                            struct frame_info *this_frame,
1306
                            const char *reason)
1307
{
1308
  if (frame_debug)
1309
    {
1310
      fprintf_unfiltered (gdb_stdlog, "{ get_prev_frame (this_frame=");
1311
      if (this_frame != NULL)
1312
        fprintf_unfiltered (gdb_stdlog, "%d", this_frame->level);
1313
      else
1314
        fprintf_unfiltered (gdb_stdlog, "<NULL>");
1315
      fprintf_unfiltered (gdb_stdlog, ") -> // %s}\n", reason);
1316
    }
1317
}
1318
 
1319
/* Is this (non-sentinel) frame in the "main"() function?  */
1320
 
1321
static int
1322
inside_main_func (struct frame_info *this_frame)
1323
{
1324
  struct minimal_symbol *msymbol;
1325
  CORE_ADDR maddr;
1326
 
1327
  if (symfile_objfile == 0)
1328
    return 0;
1329
  msymbol = lookup_minimal_symbol (main_name (), NULL, symfile_objfile);
1330
  if (msymbol == NULL)
1331
    return 0;
1332
  /* Make certain that the code, and not descriptor, address is
1333
     returned.  */
1334
  maddr = gdbarch_convert_from_func_ptr_addr (get_frame_arch (this_frame),
1335
                                              SYMBOL_VALUE_ADDRESS (msymbol),
1336
                                              &current_target);
1337
  return maddr == get_frame_func (this_frame);
1338
}
1339
 
1340
/* Test whether THIS_FRAME is inside the process entry point function.  */
1341
 
1342
static int
1343
inside_entry_func (struct frame_info *this_frame)
1344
{
1345
  return (get_frame_func (this_frame) == entry_point_address ());
1346
}
1347
 
1348
/* Return a structure containing various interesting information about
1349
   the frame that called THIS_FRAME.  Returns NULL if there is entier
1350
   no such frame or the frame fails any of a set of target-independent
1351
   condition that should terminate the frame chain (e.g., as unwinding
1352
   past main()).
1353
 
1354
   This function should not contain target-dependent tests, such as
1355
   checking whether the program-counter is zero.  */
1356
 
1357
struct frame_info *
1358
get_prev_frame (struct frame_info *this_frame)
1359
{
1360
  struct frame_info *prev_frame;
1361
 
1362
  /* Return the inner-most frame, when the caller passes in NULL.  */
1363
  /* NOTE: cagney/2002-11-09: Not sure how this would happen.  The
1364
     caller should have previously obtained a valid frame using
1365
     get_selected_frame() and then called this code - only possibility
1366
     I can think of is code behaving badly.
1367
 
1368
     NOTE: cagney/2003-01-10: Talk about code behaving badly.  Check
1369
     block_innermost_frame().  It does the sequence: frame = NULL;
1370
     while (1) { frame = get_prev_frame (frame); .... }.  Ulgh!  Why
1371
     it couldn't be written better, I don't know.
1372
 
1373
     NOTE: cagney/2003-01-11: I suspect what is happening in
1374
     block_innermost_frame() is, when the target has no state
1375
     (registers, memory, ...), it is still calling this function.  The
1376
     assumption being that this function will return NULL indicating
1377
     that a frame isn't possible, rather than checking that the target
1378
     has state and then calling get_current_frame() and
1379
     get_prev_frame().  This is a guess mind.  */
1380
  if (this_frame == NULL)
1381
    {
1382
      /* NOTE: cagney/2002-11-09: There was a code segment here that
1383
         would error out when CURRENT_FRAME was NULL.  The comment
1384
         that went with it made the claim ...
1385
 
1386
         ``This screws value_of_variable, which just wants a nice
1387
         clean NULL return from block_innermost_frame if there are no
1388
         frames.  I don't think I've ever seen this message happen
1389
         otherwise.  And returning NULL here is a perfectly legitimate
1390
         thing to do.''
1391
 
1392
         Per the above, this code shouldn't even be called with a NULL
1393
         THIS_FRAME.  */
1394
      frame_debug_got_null_frame (gdb_stdlog, this_frame, "this_frame NULL");
1395
      return current_frame;
1396
    }
1397
 
1398
  /* There is always a frame.  If this assertion fails, suspect that
1399
     something should be calling get_selected_frame() or
1400
     get_current_frame().  */
1401
  gdb_assert (this_frame != NULL);
1402
 
1403
  /* tausq/2004-12-07: Dummy frames are skipped because it doesn't make much
1404
     sense to stop unwinding at a dummy frame.  One place where a dummy
1405
     frame may have an address "inside_main_func" is on HPUX.  On HPUX, the
1406
     pcsqh register (space register for the instruction at the head of the
1407
     instruction queue) cannot be written directly; the only way to set it
1408
     is to branch to code that is in the target space.  In order to implement
1409
     frame dummies on HPUX, the called function is made to jump back to where
1410
     the inferior was when the user function was called.  If gdb was inside
1411
     the main function when we created the dummy frame, the dummy frame will
1412
     point inside the main function.  */
1413
  if (this_frame->level >= 0
1414
      && get_frame_type (this_frame) != DUMMY_FRAME
1415
      && !backtrace_past_main
1416
      && inside_main_func (this_frame))
1417
    /* Don't unwind past main().  Note, this is done _before_ the
1418
       frame has been marked as previously unwound.  That way if the
1419
       user later decides to enable unwinds past main(), that will
1420
       automatically happen.  */
1421
    {
1422
      frame_debug_got_null_frame (gdb_stdlog, this_frame, "inside main func");
1423
      return NULL;
1424
    }
1425
 
1426
  /* If the user's backtrace limit has been exceeded, stop.  We must
1427
     add two to the current level; one of those accounts for backtrace_limit
1428
     being 1-based and the level being 0-based, and the other accounts for
1429
     the level of the new frame instead of the level of the current
1430
     frame.  */
1431
  if (this_frame->level + 2 > backtrace_limit)
1432
    {
1433
      frame_debug_got_null_frame (gdb_stdlog, this_frame,
1434
                                  "backtrace limit exceeded");
1435
      return NULL;
1436
    }
1437
 
1438
  /* If we're already inside the entry function for the main objfile,
1439
     then it isn't valid.  Don't apply this test to a dummy frame -
1440
     dummy frame PCs typically land in the entry func.  Don't apply
1441
     this test to the sentinel frame.  Sentinel frames should always
1442
     be allowed to unwind.  */
1443
  /* NOTE: cagney/2003-07-07: Fixed a bug in inside_main_func() -
1444
     wasn't checking for "main" in the minimal symbols.  With that
1445
     fixed asm-source tests now stop in "main" instead of halting the
1446
     backtrace in weird and wonderful ways somewhere inside the entry
1447
     file.  Suspect that tests for inside the entry file/func were
1448
     added to work around that (now fixed) case.  */
1449
  /* NOTE: cagney/2003-07-15: danielj (if I'm reading it right)
1450
     suggested having the inside_entry_func test use the
1451
     inside_main_func() msymbol trick (along with entry_point_address()
1452
     I guess) to determine the address range of the start function.
1453
     That should provide a far better stopper than the current
1454
     heuristics.  */
1455
  /* NOTE: tausq/2004-10-09: this is needed if, for example, the compiler
1456
     applied tail-call optimizations to main so that a function called
1457
     from main returns directly to the caller of main.  Since we don't
1458
     stop at main, we should at least stop at the entry point of the
1459
     application.  */
1460
  if (!backtrace_past_entry
1461
      && get_frame_type (this_frame) != DUMMY_FRAME && this_frame->level >= 0
1462
      && inside_entry_func (this_frame))
1463
    {
1464
      frame_debug_got_null_frame (gdb_stdlog, this_frame, "inside entry func");
1465
      return NULL;
1466
    }
1467
 
1468
  /* Assume that the only way to get a zero PC is through something
1469
     like a SIGSEGV or a dummy frame, and hence that NORMAL frames
1470
     will never unwind a zero PC.  */
1471
  if (this_frame->level > 0
1472
      && get_frame_type (this_frame) == NORMAL_FRAME
1473
      && get_frame_type (get_next_frame (this_frame)) == NORMAL_FRAME
1474
      && get_frame_pc (this_frame) == 0)
1475
    {
1476
      frame_debug_got_null_frame (gdb_stdlog, this_frame, "zero PC");
1477
      return NULL;
1478
    }
1479
 
1480
  return get_prev_frame_1 (this_frame);
1481
}
1482
 
1483
CORE_ADDR
1484
get_frame_pc (struct frame_info *frame)
1485
{
1486
  gdb_assert (frame->next != NULL);
1487
  return frame_pc_unwind (frame->next);
1488
}
1489
 
1490
/* Return an address that falls within NEXT_FRAME's caller's code
1491
   block, assuming that the caller is a THIS_TYPE frame.  */
1492
 
1493
CORE_ADDR
1494
frame_unwind_address_in_block (struct frame_info *next_frame,
1495
                               enum frame_type this_type)
1496
{
1497
  /* A draft address.  */
1498
  CORE_ADDR pc = frame_pc_unwind (next_frame);
1499
 
1500
  /* If NEXT_FRAME was called by a signal frame or dummy frame, then
1501
     we shold not adjust the unwound PC.  These frames may not call
1502
     their next frame in the normal way; the operating system or GDB
1503
     may have pushed their resume address manually onto the stack, so
1504
     it may be the very first instruction.  Even if the resume address
1505
     was not manually pushed, they expect to be returned to.  */
1506
  if (this_type != NORMAL_FRAME)
1507
    return pc;
1508
 
1509
  /* If THIS frame is not inner most (i.e., NEXT isn't the sentinel),
1510
     and NEXT is `normal' (i.e., not a sigtramp, dummy, ....) THIS
1511
     frame's PC ends up pointing at the instruction fallowing the
1512
     "call".  Adjust that PC value so that it falls on the call
1513
     instruction (which, hopefully, falls within THIS frame's code
1514
     block).  So far it's proved to be a very good approximation.  See
1515
     get_frame_type() for why ->type can't be used.  */
1516
  if (next_frame->level >= 0
1517
      && get_frame_type (next_frame) == NORMAL_FRAME)
1518
    --pc;
1519
  return pc;
1520
}
1521
 
1522
CORE_ADDR
1523
get_frame_address_in_block (struct frame_info *this_frame)
1524
{
1525
  return frame_unwind_address_in_block (this_frame->next,
1526
                                        get_frame_type (this_frame));
1527
}
1528
 
1529
static int
1530
pc_notcurrent (struct frame_info *frame)
1531
{
1532
  /* If FRAME is not the innermost frame, that normally means that
1533
     FRAME->pc points at the return instruction (which is *after* the
1534
     call instruction), and we want to get the line containing the
1535
     call (because the call is where the user thinks the program is).
1536
     However, if the next frame is either a SIGTRAMP_FRAME or a
1537
     DUMMY_FRAME, then the next frame will contain a saved interrupt
1538
     PC and such a PC indicates the current (rather than next)
1539
     instruction/line, consequently, for such cases, want to get the
1540
     line containing fi->pc.  */
1541
  struct frame_info *next = get_next_frame (frame);
1542
  int notcurrent = (next != NULL && get_frame_type (next) == NORMAL_FRAME);
1543
  return notcurrent;
1544
}
1545
 
1546
void
1547
find_frame_sal (struct frame_info *frame, struct symtab_and_line *sal)
1548
{
1549
  (*sal) = find_pc_line (get_frame_pc (frame), pc_notcurrent (frame));
1550
}
1551
 
1552
/* Per "frame.h", return the ``address'' of the frame.  Code should
1553
   really be using get_frame_id().  */
1554
CORE_ADDR
1555
get_frame_base (struct frame_info *fi)
1556
{
1557
  return get_frame_id (fi).stack_addr;
1558
}
1559
 
1560
/* High-level offsets into the frame.  Used by the debug info.  */
1561
 
1562
CORE_ADDR
1563
get_frame_base_address (struct frame_info *fi)
1564
{
1565
  if (get_frame_type (fi) != NORMAL_FRAME)
1566
    return 0;
1567
  if (fi->base == NULL)
1568
    fi->base = frame_base_find_by_frame (fi->next);
1569
  /* Sneaky: If the low-level unwind and high-level base code share a
1570
     common unwinder, let them share the prologue cache.  */
1571
  if (fi->base->unwind == fi->unwind)
1572
    return fi->base->this_base (fi->next, &fi->prologue_cache);
1573
  return fi->base->this_base (fi->next, &fi->base_cache);
1574
}
1575
 
1576
CORE_ADDR
1577
get_frame_locals_address (struct frame_info *fi)
1578
{
1579
  void **cache;
1580
  if (get_frame_type (fi) != NORMAL_FRAME)
1581
    return 0;
1582
  /* If there isn't a frame address method, find it.  */
1583
  if (fi->base == NULL)
1584
    fi->base = frame_base_find_by_frame (fi->next);
1585
  /* Sneaky: If the low-level unwind and high-level base code share a
1586
     common unwinder, let them share the prologue cache.  */
1587
  if (fi->base->unwind == fi->unwind)
1588
    cache = &fi->prologue_cache;
1589
  else
1590
    cache = &fi->base_cache;
1591
  return fi->base->this_locals (fi->next, cache);
1592
}
1593
 
1594
CORE_ADDR
1595
get_frame_args_address (struct frame_info *fi)
1596
{
1597
  void **cache;
1598
  if (get_frame_type (fi) != NORMAL_FRAME)
1599
    return 0;
1600
  /* If there isn't a frame address method, find it.  */
1601
  if (fi->base == NULL)
1602
    fi->base = frame_base_find_by_frame (fi->next);
1603
  /* Sneaky: If the low-level unwind and high-level base code share a
1604
     common unwinder, let them share the prologue cache.  */
1605
  if (fi->base->unwind == fi->unwind)
1606
    cache = &fi->prologue_cache;
1607
  else
1608
    cache = &fi->base_cache;
1609
  return fi->base->this_args (fi->next, cache);
1610
}
1611
 
1612
/* Level of the selected frame: 0 for innermost, 1 for its caller, ...
1613
   or -1 for a NULL frame.  */
1614
 
1615
int
1616
frame_relative_level (struct frame_info *fi)
1617
{
1618
  if (fi == NULL)
1619
    return -1;
1620
  else
1621
    return fi->level;
1622
}
1623
 
1624
enum frame_type
1625
get_frame_type (struct frame_info *frame)
1626
{
1627
  if (frame->unwind == NULL)
1628
    /* Initialize the frame's unwinder because that's what
1629
       provides the frame's type.  */
1630
    frame->unwind = frame_unwind_find_by_frame (frame->next,
1631
                                                &frame->prologue_cache);
1632
  return frame->unwind->type;
1633
}
1634
 
1635
void
1636
deprecated_update_frame_pc_hack (struct frame_info *frame, CORE_ADDR pc)
1637
{
1638
  if (frame_debug)
1639
    fprintf_unfiltered (gdb_stdlog,
1640
                        "{ deprecated_update_frame_pc_hack (frame=%d,pc=0x%s) }\n",
1641
                        frame->level, paddr_nz (pc));
1642
  /* NOTE: cagney/2003-03-11: Some architectures (e.g., Arm) are
1643
     maintaining a locally allocated frame object.  Since such frames
1644
     are not in the frame chain, it isn't possible to assume that the
1645
     frame has a next.  Sigh.  */
1646
  if (frame->next != NULL)
1647
    {
1648
      /* While we're at it, update this frame's cached PC value, found
1649
         in the next frame.  Oh for the day when "struct frame_info"
1650
         is opaque and this hack on hack can just go away.  */
1651
      frame->next->prev_pc.value = pc;
1652
      frame->next->prev_pc.p = 1;
1653
    }
1654
}
1655
 
1656
void
1657
deprecated_update_frame_base_hack (struct frame_info *frame, CORE_ADDR base)
1658
{
1659
  if (frame_debug)
1660
    fprintf_unfiltered (gdb_stdlog,
1661
                        "{ deprecated_update_frame_base_hack (frame=%d,base=0x%s) }\n",
1662
                        frame->level, paddr_nz (base));
1663
  /* See comment in "frame.h".  */
1664
  frame->this_id.value.stack_addr = base;
1665
}
1666
 
1667
/* Memory access methods.  */
1668
 
1669
void
1670
get_frame_memory (struct frame_info *this_frame, CORE_ADDR addr,
1671
                  gdb_byte *buf, int len)
1672
{
1673
  read_memory (addr, buf, len);
1674
}
1675
 
1676
LONGEST
1677
get_frame_memory_signed (struct frame_info *this_frame, CORE_ADDR addr,
1678
                         int len)
1679
{
1680
  return read_memory_integer (addr, len);
1681
}
1682
 
1683
ULONGEST
1684
get_frame_memory_unsigned (struct frame_info *this_frame, CORE_ADDR addr,
1685
                           int len)
1686
{
1687
  return read_memory_unsigned_integer (addr, len);
1688
}
1689
 
1690
int
1691
safe_frame_unwind_memory (struct frame_info *this_frame,
1692
                          CORE_ADDR addr, gdb_byte *buf, int len)
1693
{
1694
  /* NOTE: read_memory_nobpt returns zero on success!  */
1695
  return !read_memory_nobpt (addr, buf, len);
1696
}
1697
 
1698
/* Architecture method.  */
1699
 
1700
struct gdbarch *
1701
get_frame_arch (struct frame_info *this_frame)
1702
{
1703
  return current_gdbarch;
1704
}
1705
 
1706
/* Stack pointer methods.  */
1707
 
1708
CORE_ADDR
1709
get_frame_sp (struct frame_info *this_frame)
1710
{
1711
  return frame_sp_unwind (this_frame->next);
1712
}
1713
 
1714
CORE_ADDR
1715
frame_sp_unwind (struct frame_info *next_frame)
1716
{
1717
  struct gdbarch *gdbarch = get_frame_arch (next_frame);
1718
  /* Normality - an architecture that provides a way of obtaining any
1719
     frame inner-most address.  */
1720
  if (gdbarch_unwind_sp_p (gdbarch))
1721
    return gdbarch_unwind_sp (gdbarch, next_frame);
1722
  /* Now things are really are grim.  Hope that the value returned by
1723
     the gdbarch_sp_regnum register is meaningful.  */
1724
  if (gdbarch_sp_regnum (gdbarch) >= 0)
1725
    return frame_unwind_register_unsigned (next_frame,
1726
                                           gdbarch_sp_regnum (gdbarch));
1727
  internal_error (__FILE__, __LINE__, _("Missing unwind SP method"));
1728
}
1729
 
1730
/* Return the reason why we can't unwind past FRAME.  */
1731
 
1732
enum unwind_stop_reason
1733
get_frame_unwind_stop_reason (struct frame_info *frame)
1734
{
1735
  /* If we haven't tried to unwind past this point yet, then assume
1736
     that unwinding would succeed.  */
1737
  if (frame->prev_p == 0)
1738
    return UNWIND_NO_REASON;
1739
 
1740
  /* Otherwise, we set a reason when we succeeded (or failed) to
1741
     unwind.  */
1742
  return frame->stop_reason;
1743
}
1744
 
1745
/* Return a string explaining REASON.  */
1746
 
1747
const char *
1748
frame_stop_reason_string (enum unwind_stop_reason reason)
1749
{
1750
  switch (reason)
1751
    {
1752
    case UNWIND_NULL_ID:
1753
      return _("unwinder did not report frame ID");
1754
 
1755
    case UNWIND_INNER_ID:
1756
      return _("previous frame inner to this frame (corrupt stack?)");
1757
 
1758
    case UNWIND_SAME_ID:
1759
      return _("previous frame identical to this frame (corrupt stack?)");
1760
 
1761
    case UNWIND_NO_SAVED_PC:
1762
      return _("frame did not save the PC");
1763
 
1764
    case UNWIND_NO_REASON:
1765
    case UNWIND_FIRST_ERROR:
1766
    default:
1767
      internal_error (__FILE__, __LINE__,
1768
                      "Invalid frame stop reason");
1769
    }
1770
}
1771
 
1772
extern initialize_file_ftype _initialize_frame; /* -Wmissing-prototypes */
1773
 
1774
static struct cmd_list_element *set_backtrace_cmdlist;
1775
static struct cmd_list_element *show_backtrace_cmdlist;
1776
 
1777
static void
1778
set_backtrace_cmd (char *args, int from_tty)
1779
{
1780
  help_list (set_backtrace_cmdlist, "set backtrace ", -1, gdb_stdout);
1781
}
1782
 
1783
static void
1784
show_backtrace_cmd (char *args, int from_tty)
1785
{
1786
  cmd_show_list (show_backtrace_cmdlist, from_tty, "");
1787
}
1788
 
1789
void
1790
_initialize_frame (void)
1791
{
1792
  obstack_init (&frame_cache_obstack);
1793
 
1794
  observer_attach_target_changed (frame_observer_target_changed);
1795
 
1796
  add_prefix_cmd ("backtrace", class_maintenance, set_backtrace_cmd, _("\
1797
Set backtrace specific variables.\n\
1798
Configure backtrace variables such as the backtrace limit"),
1799
                  &set_backtrace_cmdlist, "set backtrace ",
1800
                  0/*allow-unknown*/, &setlist);
1801
  add_prefix_cmd ("backtrace", class_maintenance, show_backtrace_cmd, _("\
1802
Show backtrace specific variables\n\
1803
Show backtrace variables such as the backtrace limit"),
1804
                  &show_backtrace_cmdlist, "show backtrace ",
1805
                  0/*allow-unknown*/, &showlist);
1806
 
1807
  add_setshow_boolean_cmd ("past-main", class_obscure,
1808
                           &backtrace_past_main, _("\
1809
Set whether backtraces should continue past \"main\"."), _("\
1810
Show whether backtraces should continue past \"main\"."), _("\
1811
Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
1812
the backtrace at \"main\".  Set this variable if you need to see the rest\n\
1813
of the stack trace."),
1814
                           NULL,
1815
                           show_backtrace_past_main,
1816
                           &set_backtrace_cmdlist,
1817
                           &show_backtrace_cmdlist);
1818
 
1819
  add_setshow_boolean_cmd ("past-entry", class_obscure,
1820
                           &backtrace_past_entry, _("\
1821
Set whether backtraces should continue past the entry point of a program."),
1822
                           _("\
1823
Show whether backtraces should continue past the entry point of a program."),
1824
                           _("\
1825
Normally there are no callers beyond the entry point of a program, so GDB\n\
1826
will terminate the backtrace there.  Set this variable if you need to see \n\
1827
the rest of the stack trace."),
1828
                           NULL,
1829
                           show_backtrace_past_entry,
1830
                           &set_backtrace_cmdlist,
1831
                           &show_backtrace_cmdlist);
1832
 
1833
  add_setshow_integer_cmd ("limit", class_obscure,
1834
                           &backtrace_limit, _("\
1835
Set an upper bound on the number of backtrace levels."), _("\
1836
Show the upper bound on the number of backtrace levels."), _("\
1837
No more than the specified number of frames can be displayed or examined.\n\
1838
Zero is unlimited."),
1839
                           NULL,
1840
                           show_backtrace_limit,
1841
                           &set_backtrace_cmdlist,
1842
                           &show_backtrace_cmdlist);
1843
 
1844
  /* Debug this files internals. */
1845
  add_setshow_zinteger_cmd ("frame", class_maintenance, &frame_debug,  _("\
1846
Set frame debugging."), _("\
1847
Show frame debugging."), _("\
1848
When non-zero, frame specific internal debugging is enabled."),
1849
                            NULL,
1850
                            show_frame_debug,
1851
                            &setdebuglist, &showdebuglist);
1852
}

powered by: WebSVN 2.1.0

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