Merge GDB 7.5.1

gdb/frame.c

 /* Cache and manage frames for GDB, the GNU debugger.
 
    Copyright (C) 1986-1987, 1989, 1991, 1994-1996, 1998, 2000-2004,
    2007-2012 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
@@ skipping 291 matching lines @@
     fprintf_unfiltered (file, "<unknown>");
   fprintf_unfiltered (file, "}");
 }
 
 /* Given FRAME, return the enclosing normal frame for inlined
    function frames.  Otherwise return the original frame.  */
 
 static struct frame_info *
 skip_inlined_frames (struct frame_info *frame)
 {
-  while (get_frame_type (frame) == INLINE_FRAME)
+  while (get_frame_type (frame) == INLINE_FRAME
+         || get_frame_type (frame) == TAILCALL_FRAME)
     frame = get_prev_frame (frame);
 
   return frame;
 }
 
 /* Return a frame uniq ID that can be used to, later, re-find the
    frame.  */
 
 struct frame_id
 get_frame_id (struct frame_info *fi)
@@ skipping 484 matching lines @@
       dummy_frame_pop (get_frame_id (this_frame));
       return;
     }
 
   /* Ensure that we have a frame to pop to.  */
   prev_frame = get_prev_frame_1 (this_frame);
 
   if (!prev_frame)
     error (_("Cannot pop the initial frame."));
 
+  /* Ignore TAILCALL_FRAME type frames, they were executed already before
+     entering THISFRAME.  */
+  while (get_frame_type (prev_frame) == TAILCALL_FRAME)
+    prev_frame = get_prev_frame (prev_frame);
+
   /* Make a copy of all the register values unwound from this frame.
      Save them in a scratch buffer so that there isn't a race between
      trying to extract the old values from the current regcache while
      at the same time writing new values into that same cache.  */
   scratch = frame_save_as_regcache (prev_frame);
   cleanups = make_cleanup_regcache_xfree (scratch);
 
   /* FIXME: cagney/2003-03-16: It should be possible to tell the
      target's register cache that it is about to be hit with a burst
      register transfer and that the sequence of register writes should
@@ skipping 197 matching lines @@
   frame_unwind_register (frame, regnum, buf);
   return extract_unsigned_integer (buf, size, byte_order);
 }
 
 ULONGEST
 get_frame_register_unsigned (struct frame_info *frame, int regnum)
 {
   return frame_unwind_register_unsigned (frame->next, regnum);
 }
 
+int
+read_frame_register_unsigned (struct frame_info *frame, int regnum,
+                              ULONGEST *val)
+{
+  struct value *regval = get_frame_register_value (frame, regnum);
+
+  if (!value_optimized_out (regval)
+      && value_entirely_available (regval))
+    {
+      struct gdbarch *gdbarch = get_frame_arch (frame);
+      enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+      int size = register_size (gdbarch, VALUE_REGNUM (regval));
+
+      *val = extract_unsigned_integer (value_contents (regval), size, byte_order);
+      return 1;
+    }
+
+  return 0;
+}
+
 void
 put_frame_register (struct frame_info *frame, int regnum,
                     const gdb_byte *buf)
 {
   struct gdbarch *gdbarch = get_frame_arch (frame);
   int realnum;
   int optim;
   int unavail;
   enum lval_type lval;
   CORE_ADDR addr;
@@ skipping 1045 matching lines @@
         {
           sal->symtab = SYMBOL_SYMTAB (sym);
           sal->line = SYMBOL_LINE (sym);
         }
       else
         /* If the symbol does not have a location, we don't know where
            the call site is.  Do not pretend to.  This is jarring, but
            we can't do much better.  */
         sal->pc = get_frame_pc (frame);
 
+      sal->pspace = get_frame_program_space (frame);
+
       return;
     }
 
   /* If FRAME is not the innermost frame, that normally means that
      FRAME->pc points at the return instruction (which is *after* the
      call instruction), and we want to get the line containing the
      call (because the call is where the user thinks the program is).
      However, if the next frame is either a SIGTRAMP_FRAME or a
      DUMMY_FRAME, then the next frame will contain a saved interrupt
      PC and such a PC indicates the current (rather than next)
@@ skipping 370 matching lines @@
 
   /* Debug this files internals.  */
   add_setshow_zinteger_cmd ("frame", class_maintenance, &frame_debug,  _("\
 Set frame debugging."), _("\
 Show frame debugging."), _("\
 When non-zero, frame specific internal debugging is enabled."),
                             NULL,
                             show_frame_debug,
                             &setdebuglist, &showdebuglist);
 }