[GDBserver] Multi-process + multi-arch

[deliverable/binutils-gdb.git] / gdb / gdbserver / tracepoint.c

diff --git a/gdb/gdbserver/tracepoint.c b/gdb/gdbserver/tracepoint.c
index 1ff61143465dc4bb5f1740c3bb663651ddfbde7f..d237e7f18b5ec8a7f66a036370c427eab4415043 100644 (file)
--- a/gdb/gdbserver/tracepoint.c
+++ b/gdb/gdbserver/tracepoint.c
@@ -29,6 +29,7 @@
 #include <stdint.h>
 
 #include "ax.h"
+#include "tdesc.h"
 
 #define DEFAULT_TRACE_BUFFER_SIZE 5242880 /* 5*1024*1024 */
 
@@ -4675,6 +4676,14 @@ collect_data_at_step (struct tracepoint_hit_ctx *ctx,
 
 #endif
 
+#ifdef IN_PROCESS_AGENT
+/* The target description used by the IPA.  Given that the IPA library
+   is built for a specific architecture that is loaded into the
+   inferior, there only needs to be one such description per
+   build.  */
+const struct target_desc *ipa_tdesc;
+#endif
+
 static struct regcache *
 get_context_regcache (struct tracepoint_hit_ctx *ctx)
 {
@@ -4687,7 +4696,7 @@ get_context_regcache (struct tracepoint_hit_ctx *ctx)
       if (!fctx->regcache_initted)
        {
          fctx->regcache_initted = 1;
-         init_register_cache (&fctx->regcache, fctx->regspace);
+         init_register_cache (&fctx->regcache, ipa_tdesc, fctx->regspace);
          supply_regblock (&fctx->regcache, NULL);
          supply_fast_tracepoint_registers (&fctx->regcache, fctx->regs);
        }
@@ -4702,7 +4711,7 @@ get_context_regcache (struct tracepoint_hit_ctx *ctx)
       if (!sctx->regcache_initted)
        {
          sctx->regcache_initted = 1;
-         init_register_cache (&sctx->regcache, sctx->regspace);
+         init_register_cache (&sctx->regcache, ipa_tdesc, sctx->regspace);
          supply_regblock (&sctx->regcache, NULL);
          /* Pass down the tracepoint address, because REGS doesn't
             include the PC, but we know what it must have been.  */
@@ -4761,13 +4770,15 @@ do_action_at_tracepoint (struct tracepoint_hit_ctx *ctx,
        unsigned char *regspace;
        struct regcache tregcache;
        struct regcache *context_regcache;
-
+       int regcache_size;
 
        trace_debug ("Want to collect registers");
 
+       context_regcache = get_context_regcache (ctx);
+       regcache_size = register_cache_size (context_regcache->tdesc);
+
        /* Collect all registers for now.  */
-       regspace = add_traceframe_block (tframe, tpoint,
-                                        1 + register_cache_size ());
+       regspace = add_traceframe_block (tframe, tpoint, 1 + regcache_size);
        if (regspace == NULL)
          {
            trace_debug ("Trace buffer block allocation failed, skipping");
@@ -4776,11 +4787,10 @@ do_action_at_tracepoint (struct tracepoint_hit_ctx *ctx,
        /* Identify a register block.  */
        *regspace = 'R';
 
-       context_regcache = get_context_regcache (ctx);
-
        /* Wrap the regblock in a register cache (in the stack, we
           don't want to malloc here).  */
-       init_register_cache (&tregcache, regspace + 1);
+       init_register_cache (&tregcache, context_regcache->tdesc,
+                            regspace + 1);
 
        /* Copy the register data to the regblock.  */
        regcache_cpy (&tregcache, context_regcache);
@@ -5083,7 +5093,7 @@ traceframe_walk_blocks (unsigned char *database, unsigned int datasize,
        {
        case 'R':
          /* Skip over the registers block.  */
-         dataptr += register_cache_size ();
+         dataptr += current_target_desc ()->registers_size;
          break;
        case 'M':
          /* Skip over the memory block.  */
@@ -5178,12 +5188,13 @@ traceframe_get_pc (struct traceframe *tframe)
 {
   struct regcache regcache;
   unsigned char *dataptr;
+  const struct target_desc *tdesc = current_target_desc ();
 
   dataptr = traceframe_find_regblock (tframe, -1);
   if (dataptr == NULL)
     return 0;
 
-  init_register_cache (&regcache, dataptr);
+  init_register_cache (&regcache, tdesc, dataptr);
   return regcache_read_pc (&regcache);
 }
 
@@ -5737,7 +5748,7 @@ gdb_collect (struct tracepoint *tpoint, unsigned char *regs)
   ctx.regcache_initted = 0;
   /* Wrap the regblock in a register cache (in the stack, we don't
      want to malloc here).  */
-  ctx.regspace = alloca (register_cache_size ());
+  ctx.regspace = alloca (ipa_tdesc->registers_size);
   if (ctx.regspace == NULL)
     {
       trace_debug ("Trace buffer block allocation failed, skipping");
@@ -6597,7 +6608,7 @@ gdb_probe (const struct marker *mdata, void *probe_private,
 
   /* Wrap the regblock in a register cache (in the stack, we don't
      want to malloc here).  */
-  ctx.regspace = alloca (register_cache_size ());
+  ctx.regspace = alloca (ipa_tdesc->registers_size);
   if (ctx.regspace == NULL)
     {
       trace_debug ("Trace buffer block allocation failed, skipping");