Merge GDB 7.5.1

gdb/infcall.c

 /* Perform an inferior function call, for GDB, the GNU debugger.
 
    Copyright (C) 1986-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
    (at your option) any later version.
@@ skipping 70 matching lines @@
                     value);
 }
 
 /* This boolean tells what gdb should do if a signal is received while
    in a function called from gdb (call dummy).  If set, gdb unwinds
    the stack and restore the context to what as it was before the
    call.
 
    The default is to stop in the frame where the signal was received.  */
 
-int unwind_on_signal_p = 0;
+static int unwind_on_signal_p = 0;
 static void
 show_unwind_on_signal_p (struct ui_file *file, int from_tty,
                          struct cmd_list_element *c, const char *value)
 {
   fprintf_filtered (file,
                     _("Unwinding of stack if a signal is "
                       "received while in a call dummy is %s.\n"),
                     value);
 }
 
@@ skipping 50 matching lines @@
      saved by the called function.  */
   arg = value_coerce_to_target (arg);
 
   switch (TYPE_CODE (type))
     {
     case TYPE_CODE_REF:
       {
         struct value *new_value;
 
         if (TYPE_CODE (arg_type) == TYPE_CODE_REF)
-          return value_cast_pointers (type, arg);
+          return value_cast_pointers (type, arg, 0);
 
         /* Cast the value to the reference's target type, and then
            convert it back to a reference.  This will issue an error
            if the value was not previously in memory - in some cases
            we should clearly be allowing this, but how?  */
         new_value = value_cast (TYPE_TARGET_TYPE (type), arg);
         new_value = value_ref (new_value);
         return new_value;
       }
     case TYPE_CODE_INT:
@@ skipping 219 matching lines @@
 
   clear_proceed_status ();
 
   disable_watchpoints_before_interactive_call_start ();
 
   /* We want stop_registers, please...  */
   call_thread->control.proceed_to_finish = 1;
 
   TRY_CATCH (e, RETURN_MASK_ALL)
     {
-      proceed (real_pc, TARGET_SIGNAL_0, 0);
+      proceed (real_pc, GDB_SIGNAL_0, 0);
 
       /* Inferior function calls are always synchronous, even if the
          target supports asynchronous execution.  Do here what
          `proceed' itself does in sync mode.  */
       if (target_can_async_p () && is_running (inferior_ptid))
         {
           wait_for_inferior ();
           normal_stop ();
         }
     }
@@ skipping 44 matching lines @@
    May fail to return, if a breakpoint or signal is hit
    during the execution of the function.
 
    ARGS is modified to contain coerced values.  */
 
 struct value *
 call_function_by_hand (struct value *function, int nargs, struct value **args)
 {
   CORE_ADDR sp;
   struct type *values_type, *target_values_type;
-  unsigned char struct_return = 0, lang_struct_return = 0;
+  unsigned char struct_return = 0, hidden_first_param_p = 0;
   CORE_ADDR struct_addr = 0;
   struct infcall_control_state *inf_status;
   struct cleanup *inf_status_cleanup;
   struct infcall_suspend_state *caller_state;
   CORE_ADDR funaddr;
   CORE_ADDR real_pc;
   struct type *ftype = check_typedef (value_type (function));
   CORE_ADDR bp_addr;
   struct frame_id dummy_id;
   struct cleanup *args_cleanup;
@@ skipping 113 matching lines @@
      hidden argument pointing to storage) or a normal value return?
      There are two cases: language-mandated structure return and
      target ABI structure return.  The variable STRUCT_RETURN only
      describes the latter.  The language version is handled by passing
      the return location as the first parameter to the function,
      even preceding "this".  This is different from the target
      ABI version, which is target-specific; for instance, on ia64
      the first argument is passed in out0 but the hidden structure
      return pointer would normally be passed in r8.  */
 
-  if (language_pass_by_reference (values_type))
+  if (gdbarch_return_in_first_hidden_param_p (gdbarch, values_type))
     {
-      lang_struct_return = 1;
+      hidden_first_param_p = 1;
 
       /* Tell the target specific argument pushing routine not to
          expect a value.  */
       target_values_type = builtin_type (gdbarch)->builtin_void;
     }
   else
     {
-      struct_return = using_struct_return (gdbarch,
-                                           value_type (function), values_type);
+      struct_return = using_struct_return (gdbarch, function, values_type);
       target_values_type = values_type;
     }
 
   /* Determine the location of the breakpoint (and possibly other
      stuff) that the called function will return to.  The SPARC, for a
      function returning a structure or union, needs to make space for
      not just the breakpoint but also an extra word containing the
      size (?) of the structure being passed.  */
 
-  /* The actual breakpoint (at BP_ADDR) is inserted separatly so there
-     is no need to write that out.  */
-
   switch (gdbarch_call_dummy_location (gdbarch))
     {
     case ON_STACK:
-      sp = push_dummy_code (gdbarch, sp, funaddr,
-                                args, nargs, target_values_type,
-                                &real_pc, &bp_addr, get_current_regcache ());
+      {
+        const gdb_byte *bp_bytes;
+        CORE_ADDR bp_addr_as_address;
+        int bp_size;
+
+        /* Be careful BP_ADDR is in inferior PC encoding while
+           BP_ADDR_AS_ADDRESS is a plain memory address.  */
+
+        sp = push_dummy_code (gdbarch, sp, funaddr, args, nargs,
+                              target_values_type, &real_pc, &bp_addr,
+                              get_current_regcache ());
+
+        /* Write a legitimate instruction at the point where the infcall
+           breakpoint is going to be inserted.  While this instruction
+           is never going to be executed, a user investigating the
+           memory from GDB would see this instruction instead of random
+           uninitialized bytes.  We chose the breakpoint instruction
+           as it may look as the most logical one to the user and also
+           valgrind 3.7.0 needs it for proper vgdb inferior calls.
+
+           If software breakpoints are unsupported for this target we
+           leave the user visible memory content uninitialized.  */
+
+        bp_addr_as_address = bp_addr;
+        bp_bytes = gdbarch_breakpoint_from_pc (gdbarch, &bp_addr_as_address,
+                                               &bp_size);
+        if (bp_bytes != NULL)
+          write_memory (bp_addr_as_address, bp_bytes, bp_size);
+      }
       break;
     case AT_ENTRY_POINT:
       {
         CORE_ADDR dummy_addr;
 
         real_pc = funaddr;
         dummy_addr = entry_point_address ();
+
         /* A call dummy always consists of just a single breakpoint, so
-           its address is the same as the address of the dummy.  */
+           its address is the same as the address of the dummy.
+
+           The actual breakpoint is inserted separatly so there is no need to
+           write that out.  */
         bp_addr = dummy_addr;
         break;
       }
-    case AT_SYMBOL:
-      /* Some executables define a symbol __CALL_DUMMY_ADDRESS whose
-         address is the location where the breakpoint should be
-         placed.  Once all targets are using the overhauled frame code
-         this can be deleted - ON_STACK is a better option.  */
-      {
-        struct minimal_symbol *sym;
-        CORE_ADDR dummy_addr;
-
-        sym = lookup_minimal_symbol ("__CALL_DUMMY_ADDRESS", NULL, NULL);
-        real_pc = funaddr;
-        if (sym)
-          {
-            dummy_addr = SYMBOL_VALUE_ADDRESS (sym);
-            /* Make certain that the address points at real code, and not
-               a function descriptor.  */
-            dummy_addr = gdbarch_convert_from_func_ptr_addr (gdbarch,
-                                                             dummy_addr,
-                                                             &current_target);
-          }
-        else
-          dummy_addr = entry_point_address ();
-        /* A call dummy always consists of just a single breakpoint,
-           so it's address is the same as the address of the dummy.  */
-        bp_addr = dummy_addr;
-        break;
-      }
     default:
       internal_error (__FILE__, __LINE__, _("bad switch"));
     }
 
   if (nargs < TYPE_NFIELDS (ftype))
     error (_("Too few arguments in function call."));
 
   {
     int i;
 
@@ skipping 21 matching lines @@
 
         if (param_type != NULL && language_pass_by_reference (param_type))
           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 || lang_struct_return)
+  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;
           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;
           if (gdbarch_frame_align_p (gdbarch))
             sp = gdbarch_frame_align (gdbarch, sp);
         }
     }
 
-  if (lang_struct_return)
+  if (hidden_first_param_p)
     {
       struct value **new_args;
 
       /* Add the new argument to the front of the argument list.  */
       new_args = xmalloc (sizeof (struct value *) * (nargs + 1));
       new_args[0] = value_from_pointer (lookup_pointer_type (values_type),
                                         struct_addr);
       memcpy (&new_args[1], &args[0], sizeof (struct value *) * nargs);
       args = new_args;
       nargs++;
@@ skipping 17 matching lines @@
      dummy breakpoint.  */
   /* Sanity.  The exact same SP value is returned by PUSH_DUMMY_CALL,
      saved as the dummy-frame TOS, and used by dummy_id to form
      the frame ID's stack address.  */
   dummy_id = frame_id_build (sp, bp_addr);
 
   /* Create a momentary breakpoint at the return address of the
      inferior.  That way it breaks when it returns.  */
 
   {
-    struct breakpoint *bpt;
+    struct breakpoint *bpt, *longjmp_b;
     struct symtab_and_line sal;
 
     init_sal (&sal);            /* initialize to zeroes */
     sal.pspace = current_program_space;
     sal.pc = bp_addr;
     sal.section = find_pc_overlay (sal.pc);
     /* Sanity.  The exact same SP value is returned by
        PUSH_DUMMY_CALL, saved as the dummy-frame TOS, and used by
        dummy_id to form the frame ID's stack address.  */
     bpt = set_momentary_breakpoint (gdbarch, sal, dummy_id, bp_call_dummy);
+
+    /* set_momentary_breakpoint invalidates FRAME.  */
+    frame = NULL;
+
     bpt->disposition = disp_del;
+    gdb_assert (bpt->related_breakpoint == bpt);
+
+    longjmp_b = set_longjmp_breakpoint_for_call_dummy ();
+    if (longjmp_b)
+      {
+        /* Link BPT into the chain of LONGJMP_B.  */
+        bpt->related_breakpoint = longjmp_b;
+        while (longjmp_b->related_breakpoint != bpt->related_breakpoint)
+          longjmp_b = longjmp_b->related_breakpoint;
+        longjmp_b->related_breakpoint = bpt;
+      }
   }
 
   /* Create a breakpoint in std::terminate.
      If a C++ exception is raised in the dummy-frame, and the
      exception handler is (normally, and expected to be) out-of-frame,
      the default C++ handler will (wrongly) be called in an inferior
      function call.  This is wrong, as an exception can be  normally
      and legally handled out-of-frame.  The confines of the dummy frame
      prevent the unwinder from finding the correct handler (or any
      handler, unless it is in-frame).  The default handler calls
@@ skipping 232 matching lines @@
 
     regcache_cpy_no_passthrough (retbuf, stop_registers);
 
     /* Inferior call is successful.  Restore the inferior status.
        At this stage, leave the RETBUF alone.  */
     restore_infcall_control_state (inf_status);
 
     /* Figure out the value returned by the function.  */
     retval = allocate_value (values_type);
 
-    if (lang_struct_return)
+    if (hidden_first_param_p)
       read_value_memory (retval, 0, 1, struct_addr,
                          value_contents_raw (retval),
                          TYPE_LENGTH (values_type));
     else if (TYPE_CODE (target_values_type) != TYPE_CODE_VOID)
       {
         /* If the function returns void, don't bother fetching the
            return value.  */
-        switch (gdbarch_return_value (gdbarch, value_type (function),
-                                      target_values_type, NULL, NULL, NULL))
+        switch (gdbarch_return_value (gdbarch, function, target_values_type,
+                                      NULL, NULL, NULL))
           {
           case RETURN_VALUE_REGISTER_CONVENTION:
           case RETURN_VALUE_ABI_RETURNS_ADDRESS:
           case RETURN_VALUE_ABI_PRESERVES_ADDRESS:
-            gdbarch_return_value (gdbarch, value_type (function), values_type,
+            gdbarch_return_value (gdbarch, function, values_type,
                                   retbuf, value_contents_raw (retval), NULL);
             break;
           case RETURN_VALUE_STRUCT_CONVENTION:
             read_value_memory (retval, 0, 1, struct_addr,
                                value_contents_raw (retval),
                                TYPE_LENGTH (values_type));
             break;
           }
       }
 
@@ skipping 48 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);
 
 }