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