GDB 7.6.50

gdb/infcall.c

 /* Perform an inferior function call, for GDB, the GNU debugger.
 
-   Copyright (C) 1986-2012 Free Software Foundation, Inc.
+   Copyright (C) 1986-2013 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
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "defs.h"
 #include "breakpoint.h"
 #include "tracepoint.h"
 #include "target.h"
 #include "regcache.h"
 #include "inferior.h"
 #include "gdb_assert.h"
 #include "block.h"
 #include "gdbcore.h"
 #include "language.h"
 #include "objfiles.h"
 #include "gdbcmd.h"
 #include "command.h"
-#include "gdb_string.h"
+#include <string.h>
 #include "infcall.h"
 #include "dummy-frame.h"
 #include "ada-lang.h"
 #include "gdbthread.h"
 #include "exceptions.h"
 
 /* If we can't find a function's name from its address,
    we print this instead.  */
 #define RAW_FUNCTION_ADDRESS_FORMAT "at 0x%s"
 #define RAW_FUNCTION_ADDRESS_SIZE (sizeof (RAW_FUNCTION_ADDRESS_FORMAT) \
@@ skipping 162 matching lines @@
           type = lookup_pointer_type (TYPE_TARGET_TYPE (type));
       break;
     case TYPE_CODE_UNDEF:
     case TYPE_CODE_PTR:
     case TYPE_CODE_STRUCT:
     case TYPE_CODE_UNION:
     case TYPE_CODE_VOID:
     case TYPE_CODE_SET:
     case TYPE_CODE_RANGE:
     case TYPE_CODE_STRING:
-    case TYPE_CODE_BITSTRING:
     case TYPE_CODE_ERROR:
     case TYPE_CODE_MEMBERPTR:
     case TYPE_CODE_METHODPTR:
     case TYPE_CODE_METHOD:
     case TYPE_CODE_COMPLEX:
     default:
       break;
     }
 
   return value_cast (type, arg);
@@ skipping 122 matching lines @@
 {
   {
     struct symbol *symbol = find_pc_function (funaddr);
 
     if (symbol)
       return SYMBOL_PRINT_NAME (symbol);
   }
 
   {
     /* Try the minimal symbols.  */
-    struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (funaddr);
+    struct bound_minimal_symbol msymbol = lookup_minimal_symbol_by_pc (funaddr);
 
-    if (msymbol)
-      return SYMBOL_PRINT_NAME (msymbol);
+    if (msymbol.minsym)
+      return SYMBOL_PRINT_NAME (msymbol.minsym);
   }
 
   {
     char *tmp = xstrprintf (_(RAW_FUNCTION_ADDRESS_FORMAT),
                             hex_string (funaddr));
 
     gdb_assert (strlen (tmp) + 1 <= buf_size);
     strcpy (buf, tmp);
     xfree (tmp);
     return buf;
@@ skipping 329 matching lines @@
           args[i] = value_addr (args[i]);
       }
   }
 
   /* Reserve space for the return structure to be written on the
      stack, if necessary.  Make certain that the value is correctly
      aligned.  */
 
   if (struct_return || hidden_first_param_p)
     {
-      int len = TYPE_LENGTH (values_type);
-
       if (gdbarch_inner_than (gdbarch, 1, 2))
         {
           /* Stack grows downward.  Align STRUCT_ADDR and SP after
              making space for the return value.  */
-          sp -= len;
+          sp -= TYPE_LENGTH (values_type);
           if (gdbarch_frame_align_p (gdbarch))
             sp = gdbarch_frame_align (gdbarch, sp);
           struct_addr = sp;
         }
       else
         {
           /* Stack grows upward.  Align the frame, allocate space, and
              then again, re-align the frame???  */
           if (gdbarch_frame_align_p (gdbarch))
             sp = gdbarch_frame_align (gdbarch, sp);
           struct_addr = sp;
-          sp += len;
+          sp += TYPE_LENGTH (values_type);
           if (gdbarch_frame_align_p (gdbarch))
             sp = gdbarch_frame_align (gdbarch, sp);
         }
     }
 
   if (hidden_first_param_p)
     {
       struct value **new_args;
 
       /* Add the new argument to the front of the argument list.  */
@@ skipping 385 matching lines @@
 what gdb should do if a std::terminate() call is made from the\n\
 default exception handler.  If set, gdb unwinds the stack and restores\n\
 the context to what it was before the call.  If unset, gdb allows the\n\
 std::terminate call to proceed.\n\
 The default is to unwind the frame."),
                            NULL,
                            show_unwind_on_terminating_exception_p,
                            &setlist, &showlist);
 
 }