* ser-pipe.c (pipe_open): Ignore SIGINTs in child.
[deliverable/binutils-gdb.git] / gdb / remote.c
index 591c9f6d4fb99dd5865073d5c4bf4bc3460e94a2..9dc4d2d9cd9a60edbfaf1533d294ca10e155250f 100644 (file)
@@ -427,6 +427,7 @@ remote_get_noisy_reply (char **buf_p,
   do                           /* Loop on reply from remote stub.  */
     {
       char *buf;
+
       QUIT;                    /* allow user to bail out with ^C */
       getpkt (buf_p, sizeof_buf, 0);
       buf = *buf_p;
@@ -587,6 +588,7 @@ packet_reg_from_regnum (struct remote_arch_state *rsa, long regnum)
   else
     {
       struct packet_reg *r = &rsa->regs[regnum];
+
       gdb_assert (r->regnum == regnum);
       return r;
     }
@@ -596,9 +598,11 @@ static struct packet_reg *
 packet_reg_from_pnum (struct remote_arch_state *rsa, LONGEST pnum)
 {
   int i;
+
   for (i = 0; i < gdbarch_num_regs (target_gdbarch); i++)
     {
       struct packet_reg *r = &rsa->regs[i];
+
       if (r->pnum == pnum)
        return r;
     }
@@ -812,6 +816,7 @@ set_memory_packet_size (char *args, struct memory_packet_config *config)
 {
   int fixed_p = config->fixed_p;
   long size = config->size;
+
   if (args == NULL)
     error (_("Argument required (integer, `fixed' or `limited')."));
   else if (strcmp (args, "hard") == 0
@@ -823,6 +828,7 @@ set_memory_packet_size (char *args, struct memory_packet_config *config)
   else
     {
       char *end;
+
       size = strtoul (args, &end, 0);
       if (args == end)
        error (_("Invalid %s (bad syntax)."), config->name);
@@ -904,6 +910,7 @@ static long
 get_memory_read_packet_size (void)
 {
   long size = get_memory_packet_size (&memory_read_packet_config);
+
   /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
      extra buffer size argument before the memory read size can be
      increased beyond this.  */
@@ -963,6 +970,7 @@ static void
 show_packet_config_cmd (struct packet_config *config)
 {
   char *support = "internal-error";
+
   switch (config->support)
     {
     case PACKET_ENABLE:
@@ -1019,6 +1027,7 @@ add_packet_config_cmd (struct packet_config *config, const char *name,
   if (legacy)
     {
       char *legacy_name;
+
       legacy_name = xstrprintf ("%s-packet", name);
       add_alias_cmd (legacy_name, cmd_name, class_obscure, 0,
                     &remote_set_cmdlist);
@@ -1136,6 +1145,7 @@ enum {
   PACKET_qXfer_spu_write,
   PACKET_qXfer_osdata,
   PACKET_qXfer_threads,
+  PACKET_qGetTIBAddr,
   PACKET_qGetTLSAddr,
   PACKET_qSupported,
   PACKET_QPassSignals,
@@ -1220,6 +1230,7 @@ set_remote_protocol_Z_packet_cmd (char *args, int from_tty,
                                  struct cmd_list_element *c)
 {
   int i;
+
   for (i = 0; i < NR_Z_PACKET_TYPES; i++)
     {
       remote_protocol_packets[PACKET_Z0 + i].detect = remote_Z_packet_detect;
@@ -1233,6 +1244,7 @@ show_remote_protocol_Z_packet_cmd (struct ui_file *file, int from_tty,
                                   const char *value)
 {
   int i;
+
   for (i = 0; i < NR_Z_PACKET_TYPES; i++)
     {
       show_packet_config_cmd (&remote_protocol_packets[PACKET_Z0 + i]);
@@ -1534,6 +1546,14 @@ remote_pass_signals (void)
     }
 }
 
+static void
+remote_notice_signals (ptid_t ptid)
+{
+  /* Update the remote on signals to silently pass, if they've
+     changed.  */
+  remote_pass_signals ();
+}
+
 /* If PTID is MAGIC_NULL_PTID, don't set any thread.  If PTID is
    MINUS_ONE_PTID, set the thread to -1, so the stub returns the
    thread.  If GEN is set, set the general thread, if not, then set
@@ -2473,6 +2493,21 @@ const struct gdb_xml_element threads_elements[] = {
   { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
 };
 
+/* Discard the contents of the constructed thread info context.  */
+
+static void
+clear_threads_parsing_context (void *p)
+{
+  struct threads_parsing_context *context = p;
+  int i;
+  struct thread_item *item;
+
+  for (i = 0; VEC_iterate (thread_item_t, context->items, i, item); ++i)
+    xfree (item->extra);
+
+  VEC_free (thread_item_t, context->items);
+}
+
 #endif
 
 /*
@@ -2503,15 +2538,20 @@ remote_threads_info (struct target_ops *ops)
        {
          struct gdb_xml_parser *parser;
          struct threads_parsing_context context;
-         struct cleanup *back_to = make_cleanup (null_cleanup, NULL);
+         struct cleanup *clear_parsing_context;
 
          context.items = 0;
+         /* Note: this parser cleanup is already guarded by BACK_TO
+            above.  */
          parser = gdb_xml_create_parser_and_cleanup (_("threads"),
                                                      threads_elements,
                                                      &context);
 
          gdb_xml_use_dtd (parser, "threads.dtd");
 
+         clear_parsing_context
+           = make_cleanup (clear_threads_parsing_context, &context);
+
          if (gdb_xml_parse (parser, xml) == 0)
            {
              int i;
@@ -2533,13 +2573,12 @@ remote_threads_info (struct target_ops *ops)
                      info = demand_private_info (item->ptid);
                      info->core = item->core;
                      info->extra = item->extra;
-                     item->extra = 0;
+                     item->extra = NULL;
                    }
-                 xfree (item->extra);
                }
            }
 
-         VEC_free (thread_item_t, context.items);
+         do_cleanups (clear_parsing_context);
        }
 
       do_cleanups (back_to);
@@ -2622,6 +2661,7 @@ remote_threads_extra_info (struct thread_info *tp)
   if (remote_protocol_packets[PACKET_qXfer_threads].support == PACKET_ENABLE)
     {
       struct thread_info *info = find_thread_ptid (tp->ptid);
+
       if (info && info->private)
        return info->private->extra;
       else
@@ -3154,6 +3194,11 @@ remote_start_remote (struct ui_out *uiout, void *opaque)
       /* In non-stop mode, any cached wait status will be stored in
         the stop reply queue.  */
       gdb_assert (wait_status == NULL);
+
+      /* Update the remote on signals to silently pass, or more
+        importantly, which to not ignore, in case a previous session
+        had set some different set of signals to be ignored.  */
+      remote_pass_signals ();
     }
 
   /* If we connected to a live target, do some additional setup.  */
@@ -3215,6 +3260,7 @@ static void
 init_all_packet_configs (void)
 {
   int i;
+
   for (i = 0; i < PACKET_MAX; i++)
     update_packet_config (&remote_protocol_packets[i]);
 }
@@ -3383,6 +3429,7 @@ remote_multi_process_feature (const struct protocol_feature *feature,
                              enum packet_support support, const char *value)
 {
   struct remote_state *rs = get_remote_state ();
+
   rs->multi_process_aware = (support == PACKET_ENABLE);
 }
 
@@ -3391,6 +3438,7 @@ remote_non_stop_feature (const struct protocol_feature *feature,
                              enum packet_support support, const char *value)
 {
   struct remote_state *rs = get_remote_state ();
+
   rs->non_stop_aware = (support == PACKET_ENABLE);
 }
 
@@ -3400,6 +3448,7 @@ remote_cond_tracepoint_feature (const struct protocol_feature *feature,
                                       const char *value)
 {
   struct remote_state *rs = get_remote_state ();
+
   rs->cond_tracepoints = (support == PACKET_ENABLE);
 }
 
@@ -3409,6 +3458,7 @@ remote_fast_tracepoint_feature (const struct protocol_feature *feature,
                                const char *value)
 {
   struct remote_state *rs = get_remote_state ();
+
   rs->fast_tracepoints = (support == PACKET_ENABLE);
 }
 
@@ -3418,6 +3468,7 @@ remote_disconnected_tracing_feature (const struct protocol_feature *feature,
                                     const char *value)
 {
   struct remote_state *rs = get_remote_state ();
+
   rs->disconnected_tracing = (support == PACKET_ENABLE);
 }
 
@@ -3468,11 +3519,11 @@ static char *remote_support_xml;
 /* Register string appended to "xmlRegisters=" in qSupported query.  */
 
 void
-register_remote_support_xml (const char *xml ATTRIBUTE_UNUSED)
+register_remote_support_xml (const char *xml)
 {
 #if defined(HAVE_LIBEXPAT)
   if (remote_support_xml == NULL)
-    remote_support_xml = concat ("xmlRegisters=", xml, NULL);
+    remote_support_xml = concat ("xmlRegisters=", xml, (char *) NULL);
   else
     {
       char *copy = xstrdup (remote_support_xml + 13);
@@ -3490,9 +3541,9 @@ register_remote_support_xml (const char *xml ATTRIBUTE_UNUSED)
       while ((p = strtok (NULL, ",")) != NULL);
       xfree (copy);
 
-      p = concat (remote_support_xml, ",", xml, NULL);
-      xfree (remote_support_xml);
-      remote_support_xml = p;
+      remote_support_xml = reconcat (remote_support_xml,
+                                    remote_support_xml, ",", xml,
+                                    (char *) NULL);
     }
 #endif
 }
@@ -3501,11 +3552,7 @@ static char *
 remote_query_supported_append (char *msg, const char *append)
 {
   if (msg)
-    {
-      char *p = concat (msg, ";", append, NULL);
-      xfree (msg);
-      return p;
-    }
+    return reconcat (msg, msg, ";", append, (char *) NULL);
   else
     return xstrdup (append);
 }
@@ -3529,27 +3576,24 @@ remote_query_supported (void)
   if (remote_protocol_packets[PACKET_qSupported].support != PACKET_DISABLE)
     {
       char *q = NULL;
-      const char *qsupported = gdbarch_qsupported (target_gdbarch);
+      struct cleanup *old_chain = make_cleanup (free_current_contents, &q);
 
       if (rs->extended)
        q = remote_query_supported_append (q, "multiprocess+");
-      
-      if (qsupported)
-       q = remote_query_supported_append (q, qsupported);
 
       if (remote_support_xml)
        q = remote_query_supported_append (q, remote_support_xml);
 
       if (q)
        {
-         char *p = concat ("qSupported:", q, NULL);
-         xfree (q);
-         putpkt (p);
-         xfree (p);
+         q = reconcat (q, "qSupported:", q, (char *) NULL);
+         putpkt (q);
        }
       else
        putpkt ("qSupported");
 
+      do_cleanups (old_chain);
+
       getpkt (&rs->buf, &rs->buf_size, 0);
 
       /* If an error occured, warn, but do not return - just reset the
@@ -4067,6 +4111,7 @@ int
 bin2hex (const gdb_byte *bin, char *hex, int count)
 {
   int i;
+
   /* May use a length, or a nul-terminated string as input.  */
   if (count == 0)
     count = strlen ((char *) bin);
@@ -4584,6 +4629,7 @@ remote_console_output (char *msg)
     {
       char tb[2];
       char c = fromhex (p[0]) * 16 + fromhex (p[1]);
+
       tb[0] = c;
       tb[1] = 0;
       fputs_unfiltered (tb, gdb_stdtarg);
@@ -4625,6 +4671,7 @@ static struct stop_reply *
 stop_reply_xmalloc (void)
 {
   struct stop_reply *r = XMALLOC (struct stop_reply);
+
   r->next = NULL;
   return r;
 }
@@ -4682,6 +4729,7 @@ static void
 do_stop_reply_xfree (void *arg)
 {
   struct stop_reply *r = arg;
+
   stop_reply_xfree (r);
 }
 
@@ -4853,6 +4901,7 @@ Packet: '%s'\n"),
              else if (strncmp (p, "core", p1 - p) == 0)
                {
                  ULONGEST c;
+
                  p = unpack_varlen_hex (++p1, &c);
                  event->core = c;
                }
@@ -4952,6 +5001,7 @@ Packet: '%s'\n"),
                              "process:", sizeof ("process:") - 1) == 0)
              {
                ULONGEST upid;
+
                p += sizeof ("process:") - 1;
                unpack_varlen_hex (p, &upid);
                pid = upid;
@@ -5065,7 +5115,6 @@ process_stop_reply (struct stop_reply *stop_reply,
                    struct target_waitstatus *status)
 {
   ptid_t ptid;
-  struct thread_info *info;
 
   *status = stop_reply->ws;
   ptid = stop_reply->ptid;
@@ -5490,30 +5539,28 @@ process_g_packet (struct regcache *regcache)
       p += 2;
     }
 
-  {
-    int i;
-    for (i = 0; i < gdbarch_num_regs (gdbarch); i++)
-      {
-       struct packet_reg *r = &rsa->regs[i];
-       if (r->in_g_packet)
-         {
-           if (r->offset * 2 >= strlen (rs->buf))
-             /* This shouldn't happen - we adjusted in_g_packet above.  */
-             internal_error (__FILE__, __LINE__,
-                             "unexpected end of 'g' packet reply");
-           else if (rs->buf[r->offset * 2] == 'x')
-             {
-               gdb_assert (r->offset * 2 < strlen (rs->buf));
-               /* The register isn't available, mark it as such (at
-                   the same time setting the value to zero).  */
-               regcache_raw_supply (regcache, r->regnum, NULL);
-             }
-           else
-             regcache_raw_supply (regcache, r->regnum,
-                                  regs + r->offset);
-         }
-      }
-  }
+  for (i = 0; i < gdbarch_num_regs (gdbarch); i++)
+    {
+      struct packet_reg *r = &rsa->regs[i];
+
+      if (r->in_g_packet)
+       {
+         if (r->offset * 2 >= strlen (rs->buf))
+           /* This shouldn't happen - we adjusted in_g_packet above.  */
+           internal_error (__FILE__, __LINE__,
+                           "unexpected end of 'g' packet reply");
+         else if (rs->buf[r->offset * 2] == 'x')
+           {
+             gdb_assert (r->offset * 2 < strlen (rs->buf));
+             /* The register isn't available, mark it as such (at
+                the same time setting the value to zero).  */
+             regcache_raw_supply (regcache, r->regnum, NULL);
+           }
+         else
+           regcache_raw_supply (regcache, r->regnum,
+                                regs + r->offset);
+       }
+    }
 }
 
 static void
@@ -5535,6 +5582,7 @@ remote_fetch_registers (struct target_ops *ops,
   if (regnum >= 0)
     {
       struct packet_reg *reg = packet_reg_from_regnum (rsa, regnum);
+
       gdb_assert (reg != NULL);
 
       /* If this register might be in the 'g' packet, try that first -
@@ -5650,11 +5698,13 @@ store_registers_using_G (const struct regcache *regcache)
      local buffer.  */
   {
     int i;
+
     regs = alloca (rsa->sizeof_g_packet);
     memset (regs, 0, rsa->sizeof_g_packet);
     for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++)
       {
        struct packet_reg *r = &rsa->regs[i];
+
        if (r->in_g_packet)
          regcache_raw_collect (regcache, r->regnum, regs + r->offset);
       }
@@ -5689,6 +5739,7 @@ remote_store_registers (struct target_ops *ops,
   if (regnum >= 0)
     {
       struct packet_reg *reg = packet_reg_from_regnum (rsa, regnum);
+
       gdb_assert (reg != NULL);
 
       /* Always prefer to store registers using the 'P' packet if
@@ -5738,6 +5789,7 @@ static int
 hexnumstr (char *buf, ULONGEST num)
 {
   int len = hexnumlen (num);
+
   return hexnumnstr (buf, num, len);
 }
 
@@ -5766,6 +5818,7 @@ static CORE_ADDR
 remote_address_masked (CORE_ADDR addr)
 {
   int address_size = remote_address_size;
+
   /* If "remoteaddresssize" was not set, default to target address size.  */
   if (!address_size)
     address_size = gdbarch_addr_bit (target_gdbarch);
@@ -5776,6 +5829,7 @@ remote_address_masked (CORE_ADDR addr)
       /* Only create a mask when that mask can safely be constructed
          in a ULONGEST variable.  */
       ULONGEST mask = 1;
+
       mask = (mask << address_size) - 1;
       addr &= mask;
     }
@@ -6233,6 +6287,7 @@ handle_notification (char *buf, size_t length)
        {
          struct cleanup *old_chain;
          struct stop_reply *reply = stop_reply_xmalloc ();
+
          old_chain = make_cleanup (do_stop_reply_xfree, reply);
 
          remote_parse_stop_reply (buf + 5, reply);
@@ -6289,8 +6344,8 @@ remote_send_printf (const char *format, ...)
 {
   struct remote_state *rs = get_remote_state ();
   int max_size = get_remote_packet_size ();
-
   va_list ap;
+
   va_start (ap, format);
 
   rs->buf[0] = '\0';
@@ -6310,6 +6365,7 @@ static void
 restore_remote_timeout (void *p)
 {
   int value = *(int *)p;
+
   remote_timeout = value;
 }
 
@@ -6325,9 +6381,9 @@ remote_flash_erase (struct target_ops *ops,
   int addr_size = gdbarch_addr_bit (target_gdbarch) / 8;
   int saved_remote_timeout = remote_timeout;
   enum packet_result ret;
-
   struct cleanup *back_to = make_cleanup (restore_remote_timeout,
                                           &saved_remote_timeout);
+
   remote_timeout = remote_flash_timeout;
 
   ret = remote_send_printf ("vFlashErase:%s,%s",
@@ -6803,8 +6859,8 @@ Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s\n",
        case '*':               /* Run length encoding.  */
           {
            int repeat;
-           csum += c;
 
+           csum += c;
            c = readchar (remote_timeout);
            csum += c;
            repeat = c - ' ' + 3;       /* Compute repeat count.  */
@@ -7495,6 +7551,7 @@ static int
 remote_stopped_data_address (struct target_ops *target, CORE_ADDR *addr_p)
 {
   int rc = 0;
+
   if (remote_stopped_by_watchpoint ())
     {
       *addr_p = remote_watch_data_address;
@@ -7853,6 +7910,7 @@ remote_xfer_partial (struct target_ops *ops, enum target_object object,
   if (object == TARGET_OBJECT_MEMORY)
     {
       int xfered;
+
       errno = 0;
 
       /* If the remote target is connected but not running, we should
@@ -8154,6 +8212,7 @@ remote_rcmd (char *command,
       for (p = buf; p[0] != '\0' && p[1] != '\0'; p += 2)
        {
          char c = (fromhex (p[0]) << 4) + fromhex (p[1]);
+
          fputc_unfiltered (c, outbuf);
        }
       break;
@@ -8170,6 +8229,7 @@ remote_memory_map (struct target_ops *ops)
   if (text)
     {
       struct cleanup *back_to = make_cleanup (xfree, text);
+
       result = parse_memory_map (text);
       do_cleanups (back_to);
     }
@@ -8437,6 +8497,48 @@ remote_get_thread_local_address (struct target_ops *ops,
   return 0;
 }
 
+/* Provide thread local base, i.e. Thread Information Block address.
+   Returns 1 if ptid is found and thread_local_base is non zero.  */
+
+int
+remote_get_tib_address (ptid_t ptid, CORE_ADDR *addr)
+{
+  if (remote_protocol_packets[PACKET_qGetTIBAddr].support != PACKET_DISABLE)
+    {
+      struct remote_state *rs = get_remote_state ();
+      char *p = rs->buf;
+      char *endp = rs->buf + get_remote_packet_size ();
+      enum packet_result result;
+
+      strcpy (p, "qGetTIBAddr:");
+      p += strlen (p);
+      p = write_ptid (p, endp, ptid);
+      *p++ = '\0';
+
+      putpkt (rs->buf);
+      getpkt (&rs->buf, &rs->buf_size, 0);
+      result = packet_ok (rs->buf,
+                         &remote_protocol_packets[PACKET_qGetTIBAddr]);
+      if (result == PACKET_OK)
+       {
+         ULONGEST result;
+
+         unpack_varlen_hex (rs->buf, &result);
+         if (addr)
+           *addr = (CORE_ADDR) result;
+         return 1;
+       }
+      else if (result == PACKET_UNKNOWN)
+       error (_("Remote target doesn't support qGetTIBAddr packet"));
+      else
+       error (_("Remote target failed to process qGetTIBAddr request"));
+    }
+  else
+    error (_("qGetTIBAddr not supported or disabled on this target"));
+  /* Not reached.  */
+  return 0;
+}
+
 /* Support for inferring a target description based on the current
    architecture and the size of a 'g' packet.  While the 'g' packet
    can have any size (since optional registers can be left off the
@@ -9268,6 +9370,7 @@ static int
 remote_supports_multi_process (void)
 {
   struct remote_state *rs = get_remote_state ();
+
   return remote_multi_process_p (rs);
 }
 
@@ -9275,6 +9378,7 @@ int
 remote_supports_cond_tracepoints (void)
 {
   struct remote_state *rs = get_remote_state ();
+
   return rs->cond_tracepoints;
 }
 
@@ -9282,6 +9386,7 @@ int
 remote_supports_fast_tracepoints (void)
 {
   struct remote_state *rs = get_remote_state ();
+
   return rs->fast_tracepoints;
 }
 
@@ -9581,10 +9686,10 @@ remote_trace_start (void)
 static int
 remote_get_trace_status (struct trace_status *ts)
 {
-  char *p, *p1, *p_temp;
-  ULONGEST val;
+  char *p;
   /* FIXME we need to get register block size some other way */
   extern int trace_regblock_size;
+
   trace_regblock_size = get_remote_arch_state ()->sizeof_g_packet;
 
   putpkt ("qTStatus");
@@ -9803,6 +9908,7 @@ static int
 remote_core_of_thread (struct target_ops *ops, ptid_t ptid)
 {
   struct thread_info *info = find_thread_ptid (ptid);
+
   if (info && info->private)
     return info->private->core;
   return -1;
@@ -9855,6 +9961,7 @@ Specify the serial device it is connected to\n\
   remote_ops.to_kill = remote_kill;
   remote_ops.to_load = generic_load;
   remote_ops.to_mourn_inferior = remote_mourn;
+  remote_ops.to_notice_signals = remote_notice_signals;
   remote_ops.to_thread_alive = remote_thread_alive;
   remote_ops.to_find_new_threads = remote_threads_info;
   remote_ops.to_pid_to_str = remote_pid_to_str;
@@ -9904,6 +10011,7 @@ Specify the serial device it is connected to\n\
   remote_ops.to_set_circular_trace_buffer = remote_set_circular_trace_buffer;
   remote_ops.to_core_of_thread = remote_core_of_thread;
   remote_ops.to_verify_memory = remote_verify_memory;
+  remote_ops.to_get_tib_address = remote_get_tib_address;
 }
 
 /* Set up the extended remote vector by making a copy of the standard
@@ -10001,6 +10109,7 @@ static int
 remote_async_mask (int new_mask)
 {
   int curr_mask = remote_async_mask_value;
+
   remote_async_mask_value = new_mask;
   return curr_mask;
 }
@@ -10031,6 +10140,7 @@ show_remote_cmd (char *args, int from_tty)
       {
        struct cleanup *option_chain
          = make_cleanup_ui_out_tuple_begin_end (uiout, "option");
+
        ui_out_field_string (uiout, "name", list->name);
        ui_out_text (uiout, ":  ");
        if (list->type == show_cmd)
@@ -10323,6 +10433,10 @@ Show the maximum size of the address (in bits) in a memory packet."), NULL,
                         "qGetTLSAddr", "get-thread-local-storage-address",
                         0);
 
+  add_packet_config_cmd (&remote_protocol_packets[PACKET_qGetTIBAddr],
+                        "qGetTIBAddr", "get-thread-information-block-address",
+                        0);
+
   add_packet_config_cmd (&remote_protocol_packets[PACKET_bc],
                         "bc", "reverse-continue", 0);
 
This page took 0.03638 seconds and 4 git commands to generate.