ppc476 workaround sizing

[platform/upstream/binutils.git] / gdb / tracefile.c

diff --git a/gdb/tracefile.c b/gdb/tracefile.c
index 9945ae5..0b89cfa 100644 (file)
--- a/gdb/tracefile.c
+++ b/gdb/tracefile.c
@@ -20,6 +20,8 @@
 #include "defs.h"
 #include "tracefile.h"
 #include "ctf.h"
+#include "exec.h"
+#include "regcache.h"
 
 /* Helper macros.  */
 
@@ -376,6 +378,138 @@ trace_save_ctf (const char *dirname, int target_does_save)
   do_cleanups (back_to);
 }
 
+/* Fetch register data from tracefile, shared for both tfile and
+   ctf.  */
+
+void
+tracefile_fetch_registers (struct regcache *regcache, int regno)
+{
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
+  int regn, pc_regno;
+
+  /* We get here if no register data has been found.  Mark registers
+     as unavailable.  */
+  for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
+    regcache_raw_supply (regcache, regn, NULL);
+
+  /* We can often usefully guess that the PC is going to be the same
+     as the address of the tracepoint.  */
+  pc_regno = gdbarch_pc_regnum (gdbarch);
+
+  /* XXX This guessing code below only works if the PC register isn't
+     a pseudo-register.  The value of a pseudo-register isn't stored
+     in the (non-readonly) regcache -- instead it's recomputed
+     (probably from some other cached raw register) whenever the
+     register is read.  This guesswork should probably move to some
+     higher layer.  */
+  if (pc_regno < 0 || pc_regno >= gdbarch_num_regs (gdbarch))
+    return;
+
+  if (regno == -1 || regno == pc_regno)
+    {
+      struct tracepoint *tp = get_tracepoint (get_tracepoint_number ());
+      gdb_byte *regs;
+
+      if (tp && tp->base.loc)
+       {
+         /* But don't try to guess if tracepoint is multi-location...  */
+         if (tp->base.loc->next)
+           {
+             warning (_("Tracepoint %d has multiple "
+                        "locations, cannot infer $pc"),
+                      tp->base.number);
+             return;
+           }
+         /* ... or does while-stepping.  */
+         if (tp->step_count > 0)
+           {
+             warning (_("Tracepoint %d does while-stepping, "
+                        "cannot infer $pc"),
+                      tp->base.number);
+             return;
+           }
+
+         regs = alloca (register_size (gdbarch, pc_regno));
+         store_unsigned_integer (regs, register_size (gdbarch, pc_regno),
+                                 gdbarch_byte_order (gdbarch),
+                                 tp->base.loc->address);
+         regcache_raw_supply (regcache, pc_regno, regs);
+       }
+    }
+}
+
+/* This is the implementation of target_ops method to_has_all_memory.  */
+
+static int
+tracefile_has_all_memory (struct target_ops *ops)
+{
+  return 1;
+}
+
+/* This is the implementation of target_ops method to_has_memory.  */
+
+static int
+tracefile_has_memory (struct target_ops *ops)
+{
+  return 1;
+}
+
+/* This is the implementation of target_ops method to_has_stack.
+   The target has a stack when GDB has already selected one trace
+   frame.  */
+
+static int
+tracefile_has_stack (struct target_ops *ops)
+{
+  return get_traceframe_number () != -1;
+}
+
+/* This is the implementation of target_ops method to_has_registers.
+   The target has registers when GDB has already selected one trace
+   frame.  */
+
+static int
+tracefile_has_registers (struct target_ops *ops)
+{
+  return get_traceframe_number () != -1;
+}
+
+/* This is the implementation of target_ops method to_thread_alive.
+   tracefile has one thread faked by GDB.  */
+
+static int
+tracefile_thread_alive (struct target_ops *ops, ptid_t ptid)
+{
+  return 1;
+}
+
+/* This is the implementation of target_ops method to_get_trace_status.
+   The trace status for a file is that tracing can never be run.  */
+
+static int
+tracefile_get_trace_status (struct target_ops *self, struct trace_status *ts)
+{
+  /* Other bits of trace status were collected as part of opening the
+     trace files, so nothing to do here.  */
+
+  return -1;
+}
+
+/* Initialize OPS for tracefile related targets.  */
+
+void
+init_tracefile_ops (struct target_ops *ops)
+{
+  ops->to_stratum = process_stratum;
+  ops->to_get_trace_status = tracefile_get_trace_status;
+  ops->to_has_all_memory = tracefile_has_all_memory;
+  ops->to_has_memory = tracefile_has_memory;
+  ops->to_has_stack = tracefile_has_stack;
+  ops->to_has_registers = tracefile_has_registers;
+  ops->to_thread_alive = tracefile_thread_alive;
+  ops->to_magic = OPS_MAGIC;
+}
+
 extern initialize_file_ftype _initialize_tracefile;
 
 void