GDB 7.6.50

gdb/common/agent.c

 /* Shared utility routines for GDB to interact with agent.
 
-   Copyright (C) 2009-2012 Free Software Foundation, Inc.
+   Copyright (C) 2009-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/>.  */
 
 #ifdef GDBSERVER
 #include "server.h"
 #else
 #include "defs.h"
 #include "target.h"
 #include "inferior.h" /* for non_stop */
 #endif
 
 #include <string.h>
 #include <unistd.h>
 #include "agent.h"
+#include "filestuff.h"
 
 int debug_agent = 0;
 
 #ifdef GDBSERVER
 #define DEBUG_AGENT(fmt, args...)       \
   if (debug_agent)                      \
     fprintf (stderr, fmt, ##args);
 #else
 #define DEBUG_AGENT(fmt, args...)       \
   if (debug_agent)                      \
@@ skipping 77 matching lines @@
 static unsigned int
 agent_get_helper_thread_id (void)
 {
   if  (helper_thread_id == 0)
     {
 #ifdef GDBSERVER
       if (read_inferior_memory (ipa_sym_addrs.addr_helper_thread_id,
                                 (unsigned char *) &helper_thread_id,
                                 sizeof helper_thread_id))
 #else
-      enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+      enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
       gdb_byte buf[4];
 
       if (target_read_memory (ipa_sym_addrs.addr_helper_thread_id,
                               buf, sizeof buf) == 0)
         helper_thread_id = extract_unsigned_integer (buf, sizeof buf,
                                                      byte_order);
       else
 #endif
         {
           warning (_("Error reading helper thread's id in lib"));
@@ skipping 22 matching lines @@
 {
 #ifdef HAVE_SYS_UN_H
   struct sockaddr_un addr;
   int res, fd;
   char path[UNIX_PATH_MAX];
 
   res = xsnprintf (path, UNIX_PATH_MAX, "%s/gdb_ust%d", P_tmpdir, pid);
   if (res >= UNIX_PATH_MAX)
     return -1;
 
-  res = fd = socket (PF_UNIX, SOCK_STREAM, 0);
+  res = fd = gdb_socket_cloexec (PF_UNIX, SOCK_STREAM, 0);
   if (res == -1)
     {
       warning (_("error opening sync socket: %s"), strerror (errno));
       return -1;
     }
 
   addr.sun_family = AF_UNIX;
 
   res = xsnprintf (addr.sun_path, UNIX_PATH_MAX, "%s", path);
   if (res >= UNIX_PATH_MAX)
@@ skipping 29 matching lines @@
 agent_run_command (int pid, const char *cmd, int len)
 {
   int fd;
   int tid = agent_get_helper_thread_id ();
   ptid_t ptid = ptid_build (pid, tid, 0);
 
 #ifdef GDBSERVER
   int ret = write_inferior_memory (ipa_sym_addrs.addr_cmd_buf,
                                    (const unsigned char *) cmd, len);
 #else
-  int ret = target_write_memory (ipa_sym_addrs.addr_cmd_buf, cmd, len);
+  int ret = target_write_memory (ipa_sym_addrs.addr_cmd_buf,
+                                 (gdb_byte *) cmd, len);
 #endif
 
   if (ret != 0)
     {
       warning (_("unable to write"));
       return -1;
     }
 
   DEBUG_AGENT ("agent: resumed helper thread\n");
 
@@ skipping 93 matching lines @@
 int
 agent_capability_check (enum agent_capa agent_capa)
 {
   if (agent_capability == 0)
     {
 #ifdef GDBSERVER
       if (read_inferior_memory (ipa_sym_addrs.addr_capability,
                                 (unsigned char *) &agent_capability,
                                 sizeof agent_capability))
 #else
-      enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+      enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
       gdb_byte buf[4];
 
       if (target_read_memory (ipa_sym_addrs.addr_capability,
                               buf, sizeof buf) == 0)
         agent_capability = extract_unsigned_integer (buf, sizeof buf,
                                                      byte_order);
       else
 #endif
         warning (_("Error reading capability of agent"));
     }
   return agent_capability & agent_capa;
 }
 
 /* Invalidate the cache of agent capability, so we'll read it from inferior
    again.  Call it when launches a new program or reconnect to remote stub.  */
 
 void
 agent_capability_invalidate (void)
 {
   agent_capability = 0;
 }