diff options
| -rw-r--r-- | gdb/ChangeLog | 5 | ||||
| -rw-r--r-- | gdb/gdbserver/ChangeLog | 57 | ||||
| -rw-r--r-- | gdb/gdbserver/Makefile.in | 3 | ||||
| -rw-r--r-- | gdb/gdbserver/linux-low.c | 103 | ||||
| -rw-r--r-- | gdb/gdbserver/linux-low.h | 3 | ||||
| -rw-r--r-- | gdb/gdbserver/linux-x86-low.c | 9 | ||||
| -rw-r--r-- | gdb/gdbserver/mem-break.c | 2 | ||||
| -rw-r--r-- | gdb/gdbserver/mem-break.h | 4 | ||||
| -rw-r--r-- | gdb/gdbserver/regcache.c | 82 | ||||
| -rw-r--r-- | gdb/gdbserver/regcache.h | 14 | ||||
| -rw-r--r-- | gdb/gdbserver/server.c | 96 | ||||
| -rw-r--r-- | gdb/gdbserver/server.h | 53 | ||||
| -rw-r--r-- | gdb/gdbserver/target.h | 14 | ||||
| -rw-r--r-- | gdb/gdbserver/tracepoint.c | 3398 | ||||
| -rw-r--r-- | gdb/gdbserver/utils.c | 125 | ||||
| -rwxr-xr-x | gdb/regformats/regdat.sh | 2 |
16 files changed, 3940 insertions, 30 deletions
diff --git a/gdb/ChangeLog b/gdb/ChangeLog index 123d345f..9e7ce87 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,8 @@ +2010-04-09 Pedro Alves <pedro@codesourcery.com> + + * regformats/regdat.sh: Include server.h. Don't include + regcache.h. + 2010-04-08 Stan Shebs <stan@codesourcery.com> Pedro Alves <pedro@codesourcery.com> diff --git a/gdb/gdbserver/ChangeLog b/gdb/gdbserver/ChangeLog index e9324d1..447714b 100644 --- a/gdb/gdbserver/ChangeLog +++ b/gdb/gdbserver/ChangeLog @@ -1,3 +1,60 @@ +2010-04-09 Stan Shebs <stan@codesourcery.com> + Pedro Alves <pedro@codesourcery.com> + + * server.h (LONGEST): New. + (struct thread_info) <while_stepping>: New field. + (unpack_varlen_hex, xrealloc, pulongest, plongest, phex_nz): + Declare. + (initialize_tracepoint, handle_tracepoint_general_set) + (handle_tracepoint_query, tracepoint_finished_step) + (tracepoint_was_hit, release_while_stepping_state_list): + (current_traceframe): Declare. + * server.c (handle_general_set): Handle tracepoint packets. + (read_memory): New. + (write_memory): New. + (handle_search_memory_1): Use read_memory. + (handle_query): Report support for conditional tracepoints, trace + state variables, and tracepoint sources. Handle tracepoint + queries. + (main): Initialize the tracepoints module. + (process_serial_event): Handle traceframe reads/writes. + + * linux-low.c (handle_tracepoints): New. + (linux_wait_1): Call it. + (linux_resume_one_lwp): Handle while-stepping. + (linux_supports_tracepoints, linux_read_pc, linux_write_pc): New. + (linux_target_ops): Install them. + * linux-low.h (struct linux_target_ops) <supports_tracepoints>: + New field. + * linux-x86-low.c (x86_supports_tracepoints): New. + (the_low_target). Install it. + + * mem-break.h (delete_breakpoint): Declare. + * mem-break.c (delete_breakpoint): Make external. + + * target.h (struct target_ops): Add `supports_tracepoints', + `read_pc', and `write_pc' fields. + (target_supports_tracepoints): Define. + * utils.c (xrealloc, decimal2str, pulongest, plongest, thirty_two) + (phex_nz): New. + + * regcache.h (struct regcache) <registers_owned>: New field. + (init_register_cache, regcache_cpy): Declare. + (regcache_read_pc, regcache_write_pc): Declare. + (register_cache_size): Declare. + (supply_regblock): Declare. + * regcache.c (init_register_cache): New. + (new_register_cache): Use it. + (regcache_cpy): New. + (register_cache_size): New. + (supply_regblock): New. + (regcache_read_pc, regcache_write_pc): New. + + * tracepoint.c: New. + + * Makefile.in (OBS): Add tracepoint.o. + (tracepoint.o): New rule. + 2010-04-08 H.J. Lu <hongjiu.lu@intel.com> * Makefile.in (clean): Also remove i386-mmx.c i386-mmx-linux.c. diff --git a/gdb/gdbserver/Makefile.in b/gdb/gdbserver/Makefile.in index a95837a..6bd3d66 100644 --- a/gdb/gdbserver/Makefile.in +++ b/gdb/gdbserver/Makefile.in @@ -127,7 +127,7 @@ TAGFILES = $(SOURCES) ${HFILES} ${ALLPARAM} ${POSSLIBS} OBS = inferiors.o regcache.o remote-utils.o server.o signals.o target.o \ utils.o version.o \ - mem-break.o hostio.o event-loop.o \ + mem-break.o hostio.o event-loop.o tracepoint.o \ $(XML_BUILTIN) \ $(DEPFILES) $(LIBOBJS) GDBREPLAY_OBS = gdbreplay.o version.o @@ -285,6 +285,7 @@ remote-utils.o: remote-utils.c terminal.h $(server_h) server.o: server.c $(server_h) target.o: target.c $(server_h) thread-db.o: thread-db.c $(server_h) $(linux_low_h) $(gdb_proc_service_h) +tracepoint.o: tracepoint.c $(server_h) utils.o: utils.c $(server_h) gdbreplay.o: gdbreplay.c config.h diff --git a/gdb/gdbserver/linux-low.c b/gdb/gdbserver/linux-low.c index f159244..3e37722 100644 --- a/gdb/gdbserver/linux-low.c +++ b/gdb/gdbserver/linux-low.c @@ -1117,6 +1117,39 @@ retry: return child; } +/* This function should only be called if the LWP got a SIGTRAP. + + Handle any tracepoint steps or hits. Return true if a tracepoint + event was handled, 0 otherwise. */ + +static int +handle_tracepoints (struct lwp_info *lwp) +{ + struct thread_info *tinfo = get_lwp_thread (lwp); + int tpoint_related_event = 0; + + /* And we need to be sure that any all-threads-stopping doesn't try + to move threads out of the jump pads, as it could deadlock the + inferior (LWP could be in the jump pad, maybe even holding the + lock.) */ + + /* Do any necessary step collect actions. */ + tpoint_related_event |= tracepoint_finished_step (tinfo, lwp->stop_pc); + + /* See if we just hit a tracepoint and do its main collect + actions. */ + tpoint_related_event |= tracepoint_was_hit (tinfo, lwp->stop_pc); + + if (tpoint_related_event) + { + if (debug_threads) + fprintf (stderr, "got a tracepoint event\n"); + return 1; + } + + return 0; +} + /* Arrange for a breakpoint to be hit again later. We don't keep the SIGTRAP status and don't forward the SIGTRAP signal to the LWP. We will handle the current event, eventually we will resume this LWP, @@ -1589,6 +1622,7 @@ linux_wait_1 (ptid_t ptid, int bp_explains_trap; int maybe_internal_trap; int report_to_gdb; + int trace_event; /* Translate generic target options into linux options. */ options = __WALL; @@ -1727,6 +1761,11 @@ retry: /* Now invoke the callbacks of any internal breakpoints there. */ check_breakpoints (event_child->stop_pc); + /* Handle tracepoint data collecting. This may overflow the + trace buffer, and cause a tracing stop, removing + breakpoints. */ + trace_event = handle_tracepoints (event_child); + if (bp_explains_trap) { /* If we stepped or ran into an internal breakpoint, we've @@ -1744,6 +1783,8 @@ retry: /* We have some other signal, possibly a step-over dance was in progress, and it should be cancelled too. */ step_over_finished = finish_step_over (event_child); + + trace_event = 0; } /* We have all the data we need. Either report the event to GDB, or @@ -1761,7 +1802,7 @@ retry: report_to_gdb = (!maybe_internal_trap || event_child->last_resume_kind == resume_step || event_child->stopped_by_watchpoint - || (!step_over_finished && !bp_explains_trap) + || (!step_over_finished && !bp_explains_trap && !trace_event) || gdb_breakpoint_here (event_child->stop_pc)); /* We found no reason GDB would want us to stop. We either hit one @@ -1775,6 +1816,8 @@ retry: fprintf (stderr, "Hit a gdbserver breakpoint.\n"); if (step_over_finished) fprintf (stderr, "Step-over finished.\n"); + if (trace_event) + fprintf (stderr, "Tracepoint event.\n"); } /* We're not reporting this breakpoint to GDB, so apply the @@ -2135,6 +2178,15 @@ linux_resume_one_lwp (struct lwp_info *lwp, if (lwp->stopped == 0) return; + /* Cancel actions that rely on GDB not changing the PC (e.g., the + user used the "jump" command, or "set $pc = foo"). */ + if (lwp->stop_pc != get_pc (lwp)) + { + /* Collecting 'while-stepping' actions doesn't make sense + anymore. */ + release_while_stepping_state_list (get_lwp_thread (lwp)); + } + /* If we have pending signals or status, and a new signal, enqueue the signal. Also enqueue the signal if we are waiting to reinsert a breakpoint; it will be picked up again below. */ @@ -2199,6 +2251,24 @@ linux_resume_one_lwp (struct lwp_info *lwp, signal = 0; } + /* If we have while-stepping actions in this thread set it stepping. + If we have a signal to deliver, it may or may not be set to + SIG_IGN, we don't know. Assume so, and allow collecting + while-stepping into a signal handler. A possible smart thing to + do would be to set an internal breakpoint at the signal return + address, continue, and carry on catching this while-stepping + action only when that breakpoint is hit. A future + enhancement. */ + if (get_lwp_thread (lwp)->while_stepping != NULL + && can_hardware_single_step ()) + { + if (debug_threads) + fprintf (stderr, + "lwp %ld has a while-stepping action -> forcing step.\n", + lwpid_of (lwp)); + step = 1; + } + if (debug_threads && the_low_target.get_pc != NULL) { struct regcache *regcache = get_thread_regcache (current_inferior, 1); @@ -4165,6 +4235,32 @@ linux_process_qsupported (const char *query) the_low_target.process_qsupported (query); } +static int +linux_supports_tracepoints (void) +{ + if (*the_low_target.supports_tracepoints == NULL) + return 0; + + return (*the_low_target.supports_tracepoints) (); +} + +static CORE_ADDR +linux_read_pc (struct regcache *regcache) +{ + if (the_low_target.get_pc == NULL) + return 0; + + return (*the_low_target.get_pc) (regcache); +} + +static void +linux_write_pc (struct regcache *regcache, CORE_ADDR pc) +{ + gdb_assert (the_low_target.set_pc != NULL); + + (*the_low_target.set_pc) (regcache, pc); +} + static struct target_ops linux_target_ops = { linux_create_inferior, linux_attach, @@ -4209,7 +4305,10 @@ static struct target_ops linux_target_ops = { NULL, #endif linux_core_of_thread, - linux_process_qsupported + linux_process_qsupported, + linux_supports_tracepoints, + linux_read_pc, + linux_write_pc }; static void diff --git a/gdb/gdbserver/linux-low.h b/gdb/gdbserver/linux-low.h index 52623bf..4564f56 100644 --- a/gdb/gdbserver/linux-low.h +++ b/gdb/gdbserver/linux-low.h @@ -117,6 +117,9 @@ struct linux_target_ops /* Hook to support target specific qSupported. */ void (*process_qsupported) (const char *); + + /* Returns true if the low target supports tracepoints. */ + int (*supports_tracepoints) (void); }; extern struct linux_target_ops the_low_target; diff --git a/gdb/gdbserver/linux-x86-low.c b/gdb/gdbserver/linux-x86-low.c index 9754c1e..d79713f 100644 --- a/gdb/gdbserver/linux-x86-low.c +++ b/gdb/gdbserver/linux-x86-low.c @@ -1027,6 +1027,12 @@ x86_arch_setup (void) x86_linux_update_xmltarget (); } +static int +x86_supports_tracepoints (void) +{ + return 1; +} + /* This is initialized assuming an amd64 target. x86_arch_setup will correct it for i386 or amd64 targets. */ @@ -1058,5 +1064,6 @@ struct linux_target_ops the_low_target = x86_linux_new_process, x86_linux_new_thread, x86_linux_prepare_to_resume, - x86_linux_process_qsupported + x86_linux_process_qsupported, + x86_supports_tracepoints }; diff --git a/gdb/gdbserver/mem-break.c b/gdb/gdbserver/mem-break.c index aa2f32f..c796948 100644 --- a/gdb/gdbserver/mem-break.c +++ b/gdb/gdbserver/mem-break.c @@ -302,7 +302,7 @@ delete_breakpoint_1 (struct process_info *proc, struct breakpoint *todel) return ENOENT; } -static int +int delete_breakpoint (struct breakpoint *todel) { struct process_info *proc = current_process (); diff --git a/gdb/gdbserver/mem-break.h b/gdb/gdbserver/mem-break.h index a226cc7..b9fcf65 100644 --- a/gdb/gdbserver/mem-break.h +++ b/gdb/gdbserver/mem-break.h @@ -55,6 +55,10 @@ struct breakpoint *set_breakpoint_at (CORE_ADDR where, int delete_gdb_breakpoint_at (CORE_ADDR addr); +/* Delete a breakpoint. */ + +int delete_breakpoint (struct breakpoint *bkpt); + /* Set a reinsert breakpoint at STOP_AT. */ void set_reinsert_breakpoint (CORE_ADDR stop_at); diff --git a/gdb/gdbserver/regcache.c b/gdb/gdbserver/regcache.c index d6cdc46..366c4a1 100644 --- a/gdb/gdbserver/regcache.c +++ b/gdb/gdbserver/regcache.c @@ -80,6 +80,29 @@ regcache_invalidate (void) } struct regcache * +init_register_cache (struct regcache *regcache, unsigned char *regbuf) +{ + if (regbuf == NULL) + { + /* Make sure to zero-initialize the register cache when it is + created, in case there are registers the target never + fetches. This way they'll read as zero instead of + garbage. */ + regcache->registers = xcalloc (1, register_bytes); + regcache->registers_owned = 1; + } + else + { + regcache->registers = regbuf; + regcache->registers_owned = 0; + } + + regcache->registers_valid = 0; + + return regcache; +} + +struct regcache * new_register_cache (void) { struct regcache *regcache; @@ -88,16 +111,7 @@ new_register_cache (void) return NULL; /* The architecture hasn't been initialized yet. */ regcache = xmalloc (sizeof (*regcache)); - - /* Make sure to zero-initialize the register cache when it is - created, in case there are registers the target never - fetches. This way they'll read as zero instead of - garbage. */ - regcache->registers = xcalloc (1, register_bytes); - - regcache->registers_valid = 0; - - return regcache; + return init_register_cache (regcache, NULL); } void @@ -110,6 +124,13 @@ free_register_cache (struct regcache *regcache) } } +void +regcache_cpy (struct regcache *dst, struct regcache *src) +{ + memcpy (dst->registers, src->registers, register_bytes); + dst->registers_valid = src->registers_valid; +} + static void realloc_register_cache (struct inferior_list_entry *thread_p) { @@ -146,6 +167,12 @@ set_register_cache (struct reg *regs, int n) for_each_inferior (&all_threads, realloc_register_cache); } +int +register_cache_size (void) +{ + return register_bytes; +} + void registers_to_string (struct regcache *regcache, char *buf) { @@ -222,6 +249,15 @@ supply_register (struct regcache *regcache, int n, const void *buf) } void +supply_regblock (struct regcache *regcache, const void *buf) +{ + if (buf) + memcpy (regcache->registers, buf, register_bytes); + else + memset (regcache->registers, 0, register_bytes); +} + +void supply_register_by_name (struct regcache *regcache, const char *name, const void *buf) { @@ -247,3 +283,29 @@ collect_register_by_name (struct regcache *regcache, { collect_register (regcache, find_regno (name), buf); } + +/* Special handling for register PC. */ + +CORE_ADDR +regcache_read_pc (struct regcache *regcache) +{ + CORE_ADDR pc_val; + + if (the_target->read_pc) + pc_val = the_target->read_pc (regcache); + else + internal_error (__FILE__, __LINE__, + "regcache_read_pc: Unable to find PC"); + + return pc_val; +} + +void +regcache_write_pc (struct regcache *regcache, CORE_ADDR pc) +{ + if (the_target->write_pc) + the_target->write_pc (regcache, pc); + else + internal_error (__FILE__, __LINE__, + "regcache_write_pc: Unable to update PC"); +} diff --git a/gdb/gdbserver/regcache.h b/gdb/gdbserver/regcache.h index 6aa001f..f6ad62b 100644 --- a/gdb/gdbserver/regcache.h +++ b/gdb/gdbserver/regcache.h @@ -30,9 +30,15 @@ struct thread_info; struct regcache { int registers_valid; + int registers_owned; unsigned char *registers; }; +struct regcache *init_register_cache (struct regcache *regcache, + unsigned char *regbuf); + +void regcache_cpy (struct regcache *dst, struct regcache *src); + /* Create a new register cache for INFERIOR. */ struct regcache *new_register_cache (void); @@ -57,12 +63,18 @@ void registers_to_string (struct regcache *regcache, char *buf); void registers_from_string (struct regcache *regcache, char *buf); +CORE_ADDR regcache_read_pc (struct regcache *regcache); + +void regcache_write_pc (struct regcache *regcache, CORE_ADDR pc); + /* Return a pointer to the description of register ``n''. */ struct reg *find_register_by_number (int n); int register_size (int n); +int register_cache_size (void); + int find_regno (const char *name); /* The following two variables are set by auto-generated @@ -75,6 +87,8 @@ void supply_register (struct regcache *regcache, int n, const void *buf); void supply_register_by_name (struct regcache *regcache, const char *name, const void *buf); +void supply_regblock (struct regcache *regcache, const void *buf); + void collect_register (struct regcache *regcache, int n, void *buf); void collect_register_as_string (struct regcache *regcache, int n, char *buf); diff --git a/gdb/gdbserver/server.c b/gdb/gdbserver/server.c index 568640e..0fd82ee 100644 --- a/gdb/gdbserver/server.c +++ b/gdb/gdbserver/server.c @@ -449,6 +449,10 @@ handle_general_set (char *own_buf) return; } + if (target_supports_tracepoints () + && handle_tracepoint_general_set (own_buf)) + return; + /* Otherwise we didn't know what packet it was. Say we didn't understand it. */ own_buf[0] = 0; @@ -506,6 +510,43 @@ monitor_show_help (void) monitor_output (" Quit GDBserver\n"); } +/* Read trace frame or inferior memory. */ + +static int +read_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len) +{ + if (current_traceframe >= 0) + { + ULONGEST nbytes; + ULONGEST length = len; + + if (traceframe_read_mem (current_traceframe, + memaddr, myaddr, len, &nbytes)) + return EIO; + /* Data read from trace buffer, we're done. */ + if (nbytes == length) + return 0; + if (!in_readonly_region (memaddr, length)) + return EIO; + /* Otherwise we have a valid readonly case, fall through. */ + /* (assume no half-trace half-real blocks for now) */ + } + + return read_inferior_memory (memaddr, myaddr, len); +} + +/* Write trace frame or inferior memory. Actually, writing to trace + frames is forbidden. */ + +static int +write_memory (CORE_ADDR memaddr, const unsigned char *myaddr, int len) +{ + if (current_traceframe >= 0) + return EIO; + else + return write_inferior_memory (memaddr, myaddr, len); +} + /* Subroutine of handle_search_memory to simplify it. */ static int @@ -517,7 +558,7 @@ handle_search_memory_1 (CORE_ADDR start_addr, CORE_ADDR search_space_len, { /* Prime the search buffer. */ - if (read_inferior_memory (start_addr, search_buf, search_buf_size) != 0) + if (read_memory (start_addr, search_buf, search_buf_size) != 0) { warning ("Unable to access target memory at 0x%lx, halting search.", (long) start_addr); @@ -568,7 +609,7 @@ handle_search_memory_1 (CORE_ADDR start_addr, CORE_ADDR search_space_len, ? search_space_len - keep_len : chunk_size); - if (read_inferior_memory (read_addr, search_buf + keep_len, + if (read_memory (read_addr, search_buf + keep_len, nr_to_read) != 0) { warning ("Unable to access target memory at 0x%lx, halting search.", @@ -1346,6 +1387,13 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p) strcat (own_buf, ";qXfer:threads:read+"); + if (target_supports_tracepoints ()) + { + strcat (own_buf, ";ConditionalTracepoints+"); + strcat (own_buf, ";TraceStateVariables+"); + strcat (own_buf, ";TracepointSource+"); + } + return; } @@ -1506,6 +1554,9 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p) return; } + if (target_supports_tracepoints () && handle_tracepoint_query (own_buf)) + return; + /* Otherwise we didn't know what packet it was. Say we didn't understand it. */ own_buf[0] = 0; @@ -2275,6 +2326,8 @@ main (int argc, char *argv[]) initialize_inferiors (); initialize_async_io (); initialize_low (); + if (target_supports_tracepoints ()) + initialize_tracepoint (); own_buf = xmalloc (PBUFSIZ + 1); mem_buf = xmalloc (PBUFSIZ); @@ -2541,20 +2594,35 @@ process_serial_event (void) } break; case 'g': - { - struct regcache *regcache; + require_running (own_buf); + if (current_traceframe >= 0) + { + struct regcache *regcache = new_register_cache (); - require_running (own_buf); - set_desired_inferior (1); - regcache = get_thread_regcache (current_inferior, 1); - registers_to_string (regcache, own_buf); - } + if (fetch_traceframe_registers (current_traceframe, + regcache, -1) == 0) + registers_to_string (regcache, own_buf); + else + write_enn (own_buf); + free_register_cache (regcache); + } + else + { + struct regcache *regcache; + + set_desired_inferior (1); + regcache = get_thread_regcache (current_inferior, 1); + registers_to_string (regcache, own_buf); + } break; case 'G': - { + require_running (own_buf); + if (current_traceframe >= 0) + write_enn (own_buf); + else + { struct regcache *regcache; - require_running (own_buf); set_desired_inferior (1); regcache = get_thread_regcache (current_inferior, 1); registers_from_string (regcache, &own_buf[1]); @@ -2564,7 +2632,7 @@ process_serial_event (void) case 'm': require_running (own_buf); decode_m_packet (&own_buf[1], &mem_addr, &len); - if (read_inferior_memory (mem_addr, mem_buf, len) == 0) + if (read_memory (mem_addr, mem_buf, len) == 0) convert_int_to_ascii (mem_buf, own_buf, len); else write_enn (own_buf); @@ -2572,7 +2640,7 @@ process_serial_event (void) case 'M': require_running (own_buf); decode_M_packet (&own_buf[1], &mem_addr, &len, mem_buf); - if (write_inferior_memory (mem_addr, mem_buf, len) == 0) + if (write_memory (mem_addr, mem_buf, len) == 0) write_ok (own_buf); else write_enn (own_buf); @@ -2581,7 +2649,7 @@ process_serial_event (void) require_running (own_buf); if (decode_X_packet (&own_buf[1], packet_len - 1, &mem_addr, &len, mem_buf) < 0 - || write_inferior_memory (mem_addr, mem_buf, len) != 0) + || write_memory (mem_addr, mem_buf, len) != 0) write_enn (own_buf); else write_ok (own_buf); diff --git a/gdb/gdbserver/server.h b/gdb/gdbserver/server.h index 88c6c5e..dcff359 100644 --- a/gdb/gdbserver/server.h +++ b/gdb/gdbserver/server.h @@ -85,6 +85,7 @@ typedef unsigned char gdb_byte; least the size of a (void *). */ typedef long long CORE_ADDR; +typedef long long LONGEST; typedef unsigned long long ULONGEST; /* The ptid struct is a collection of the various "ids" necessary @@ -180,6 +181,31 @@ struct thread_info /* The last wait status reported for this thread. */ struct target_waitstatus last_status; + + /* Given `while-stepping', a thread may be collecting data for more + than one tracepoint simultaneously. E.g.: + + ff0001 INSN1 <-- TP1, while-stepping 10 collect $regs + ff0002 INSN2 + ff0003 INSN3 <-- TP2, collect $regs + ff0004 INSN4 <-- TP3, while-stepping 10 collect $regs + ff0005 INSN5 + + Notice that when instruction INSN5 is reached, the while-stepping + actions of both TP1 and TP3 are still being collected, and that TP2 + had been collected meanwhile. The whole range of ff0001-ff0005 + should be single-stepped, due to at least TP1's while-stepping + action covering the whole range. + + On the other hand, the same tracepoint with a while-stepping action + may be hit by more than one thread simultaneously, hence we can't + keep the current step count in the tracepoint itself. + + This is the head of the list of the states of `while-stepping' + tracepoint actions this thread is now collecting; NULL if empty. + Each item in the list holds the current step of the while-stepping + action. */ + struct wstep_state *while_stepping; }; struct dll_info @@ -371,6 +397,7 @@ int hexify (char *hex, const char *bin, int count); int remote_escape_output (const gdb_byte *buffer, int len, gdb_byte *out_buf, int *out_len, int out_maxlen); +char *unpack_varlen_hex (char *buff, ULONGEST *result); void clear_symbol_cache (struct sym_cache **symcache_p); int look_up_one_symbol (const char *name, CORE_ADDR *addrp); @@ -416,6 +443,7 @@ void buffer_xml_printf (struct buffer *buffer, const char *format, ...) /* Functions from utils.c */ void *xmalloc (size_t) ATTR_MALLOC; +void *xrealloc (void *, size_t); void *xcalloc (size_t, size_t) ATTR_MALLOC; char *xstrdup (const char *) ATTR_MALLOC; void freeargv (char **argv); @@ -426,6 +454,9 @@ void internal_error (const char *file, int line, const char *, ...) ATTR_NORETURN ATTR_FORMAT (printf, 3, 4); void warning (const char *string,...) ATTR_FORMAT (printf, 1, 2); char *paddress (CORE_ADDR addr); +char *pulongest (ULONGEST u); +char *plongest (LONGEST l); +char *phex_nz (ULONGEST l, int sizeof_l); #define gdb_assert(expr) \ ((void) ((expr) ? 0 : \ @@ -464,6 +495,28 @@ char *paddress (CORE_ADDR addr); as large as the largest register set supported by gdbserver. */ #define PBUFSIZ 16384 +/* Functions from tracepoint.c */ + +void initialize_tracepoint (void); + +int handle_tracepoint_general_set (char *own_buf); +int handle_tracepoint_query (char *own_buf); + +int tracepoint_finished_step (struct thread_info *tinfo, CORE_ADDR stop_pc); +int tracepoint_was_hit (struct thread_info *tinfo, CORE_ADDR stop_pc); + +void release_while_stepping_state_list (struct thread_info *tinfo); + +extern int current_traceframe; + +int in_readonly_region (CORE_ADDR addr, ULONGEST length); +int traceframe_read_mem (int tfnum, CORE_ADDR addr, + unsigned char *buf, ULONGEST length, + ULONGEST *nbytes); +int fetch_traceframe_registers (int tfnum, + struct regcache *regcache, + int regnum); + /* Version information, from version.c. */ extern const char version[]; extern const char host_name[]; diff --git a/gdb/gdbserver/target.h b/gdb/gdbserver/target.h index 6109b1c..6ee5009 100644 --- a/gdb/gdbserver/target.h +++ b/gdb/gdbserver/target.h @@ -289,6 +289,16 @@ struct target_ops /* Target specific qSupported support. */ void (*process_qsupported) (const char *); + + /* Return 1 if the target supports tracepoints, 0 (or leave the + callback NULL) otherwise. */ + int (*supports_tracepoints) (void); + + /* Read PC from REGCACHE. */ + CORE_ADDR (*read_pc) (struct regcache *regcache); + + /* Write PC to REGCACHE. */ + void (*write_pc) (struct regcache *regcache, CORE_ADDR pc); }; extern struct target_ops *the_target; @@ -333,6 +343,10 @@ void set_target_ops (struct target_ops *); if (the_target->process_qsupported) \ the_target->process_qsupported (query) +#define target_supports_tracepoints() \ + (the_target->supports_tracepoints \ + ? (*the_target->supports_tracepoints) () : 0) + /* Start non-stop mode, returns 0 on success, -1 on failure. */ int start_non_stop (int nonstop); diff --git a/gdb/gdbserver/tracepoint.c b/gdb/gdbserver/tracepoint.c new file mode 100644 index 0000000..411f2b6 --- /dev/null +++ b/gdb/gdbserver/tracepoint.c @@ -0,0 +1,3398 @@ +/* Tracepoint code for remote server for GDB. + Copyright (C) 2009, 2010 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/>. */ + +#include "server.h" +#include <ctype.h> +#include <fcntl.h> +#include <unistd.h> +#include <sys/time.h> + +static void trace_debug_1 (const char *, ...) ATTR_FORMAT (printf, 1, 2); + +static void +trace_debug_1 (const char *fmt, ...) +{ + char buf[1024]; + va_list ap; + + va_start (ap, fmt); + vsprintf (buf, fmt, ap); + fprintf (stderr, "gdbserver/tracepoint: %s\n", buf); + va_end (ap); +} + +#define trace_debug(FMT, args...) \ + do { \ + if (debug_threads) \ + trace_debug_1 ((FMT), ##args); \ + } while (0) + +static int +tracepoint_handler (CORE_ADDR address) +{ + trace_debug ("tracepoint_handler: tracepoint at 0x%s hit", + paddress (address)); + return 0; +} + +/* This enum must exactly match what is documented in + gdb/doc/agentexpr.texi, including all the numerical values. */ + +enum gdb_agent_op + { + gdb_agent_op_float = 0x01, + gdb_agent_op_add = 0x02, + gdb_agent_op_sub = 0x03, + gdb_agent_op_mul = 0x04, + gdb_agent_op_div_signed = 0x05, + gdb_agent_op_div_unsigned = 0x06, + gdb_agent_op_rem_signed = 0x07, + gdb_agent_op_rem_unsigned = 0x08, + gdb_agent_op_lsh = 0x09, + gdb_agent_op_rsh_signed = 0x0a, + gdb_agent_op_rsh_unsigned = 0x0b, + gdb_agent_op_trace = 0x0c, + gdb_agent_op_trace_quick = 0x0d, + gdb_agent_op_log_not = 0x0e, + gdb_agent_op_bit_and = 0x0f, + gdb_agent_op_bit_or = 0x10, + gdb_agent_op_bit_xor = 0x11, + gdb_agent_op_bit_not = 0x12, + gdb_agent_op_equal = 0x13, + gdb_agent_op_less_signed = 0x14, + gdb_agent_op_less_unsigned = 0x15, + gdb_agent_op_ext = 0x16, + gdb_agent_op_ref8 = 0x17, + gdb_agent_op_ref16 = 0x18, + gdb_agent_op_ref32 = 0x19, + gdb_agent_op_ref64 = 0x1a, + gdb_agent_op_ref_float = 0x1b, + gdb_agent_op_ref_double = 0x1c, + gdb_agent_op_ref_long_double = 0x1d, + gdb_agent_op_l_to_d = 0x1e, + gdb_agent_op_d_to_l = 0x1f, + gdb_agent_op_if_goto = 0x20, + gdb_agent_op_goto = 0x21, + gdb_agent_op_const8 = 0x22, + gdb_agent_op_const16 = 0x23, + gdb_agent_op_const32 = 0x24, + gdb_agent_op_const64 = 0x25, + gdb_agent_op_reg = 0x26, + gdb_agent_op_end = 0x27, + gdb_agent_op_dup = 0x28, + gdb_agent_op_pop = 0x29, + gdb_agent_op_zero_ext = 0x2a, + gdb_agent_op_swap = 0x2b, + gdb_agent_op_getv = 0x2c, + gdb_agent_op_setv = 0x2d, + gdb_agent_op_tracev = 0x2e, + gdb_agent_op_trace16 = 0x30, + gdb_agent_op_last + }; + +static const char *gdb_agent_op_names [gdb_agent_op_last] = + { + "?undef?", + "float", + "add", + "sub", + "mul", + "div_signed", + "div_unsigned", + "rem_signed", + "rem_unsigned", + "lsh", + "rsh_signed", + "rsh_unsigned", + "trace", + "trace_quick", + "log_not", + "bit_and", + "bit_or", + "bit_xor", + "bit_not", + "equal", + "less_signed", + "less_unsigned", + "ext", + "ref8", + "ref16", + "ref32", + "ref64", + "ref_float", + "ref_double", + "ref_long_double", + "l_to_d", + "d_to_l", + "if_goto", + "goto", + "const8", + "const16", + "const32", + "const64", + "reg", + "end", + "dup", + "pop", + "zero_ext", + "swap", + "getv", + "setv", + "tracev", + "?undef?", + "trace16", + }; + +struct agent_expr +{ + int length; + + unsigned char *bytes; +}; + +/* Base action. Concrete actions inherit this. */ + +struct tracepoint_action +{ + char type; +}; + +/* An 'M' (collect memory) action. */ +struct collect_memory_action +{ + struct tracepoint_action base; + + ULONGEST addr; + ULONGEST len; + int basereg; +}; + +/* An 'R' (collect registers) action. */ + +struct collect_registers_action +{ + struct tracepoint_action base; +}; + +/* An 'X' (evaluate expression) action. */ + +struct eval_expr_action +{ + struct tracepoint_action base; + + struct agent_expr *expr; +}; + +/* An 'L' (collect static trace data) action. */ +struct collect_static_trace_data_action +{ + struct tracepoint_action base; +}; + +/* This structure describes a piece of the source-level definition of + the tracepoint. The contents are not interpreted by the target, + but preserved verbatim for uploading upon reconnection. */ + +struct source_string +{ + /* The type of string, such as "cond" for a conditional. */ + char *type; + + /* The source-level string itself. For the sake of target + debugging, we store it in plaintext, even though it is always + transmitted in hex. */ + char *str; + + /* Link to the next one in the list. We link them in the order + received, in case some make up an ordered list of commands or + some such. */ + struct source_string *next; +}; + +struct tracepoint_hit_ctx; + +/* The definition of a tracepoint. */ + +/* Tracepoints may have multiple locations, each at a different + address. This can occur with optimizations, template + instantiation, etc. Since the locations may be in different + scopes, the conditions and actions may be different for each + location. Our target version of tracepoints is more like GDB's + notion of "breakpoint locations", but we have almost nothing that + is not per-location, so we bother having two kinds of objects. The + key consequence is that numbers are not unique, and that it takes + both number and address to identify a tracepoint uniquely. */ + +struct tracepoint +{ + /* The number of the tracepoint, as specified by GDB. Several + tracepoint objects here may share a number. */ + int number; + + /* Address at which the tracepoint is supposed to trigger. Several + tracepoints may share an address. */ + CORE_ADDR address; + + /* True if the tracepoint is currently enabled. */ + int enabled; + + /* The number of single steps that will be performed after each + tracepoint hit. */ + long step_count; + + /* The number of times the tracepoint may be hit before it will + terminate the entire tracing run. */ + long pass_count; + + /* Pointer to the agent expression that is the tracepoint's + conditional, or NULL if the tracepoint is unconditional. */ + struct agent_expr *cond; + + /* The list of actions to take when the tracepoint triggers. */ + int numactions; + struct tracepoint_action **actions; + /* Same, but in string/packet form. */ + char **actions_str; + + /* The list of actions to take while in a stepping loop. */ + int num_step_actions; + struct tracepoint_action **step_actions; + /* Same, but in string/packet form. */ + char **step_actions_str; + + /* Count of the times we've hit this tracepoint during the run. + Note that while-stepping steps are not counted as "hits". */ + long hit_count; + + /* The collection of strings that describe the tracepoint as it was + entered into GDB. These are not used by the target, but are + reported back to GDB upon reconnection. */ + struct source_string *source_strings; + + /* Handle returned by the breakpoint module when we inserted the + trap. NULL if we haven't inserted it yet. */ + void *handle; + + /* Link to the next tracepoint in the list. */ + struct tracepoint *next; +}; + +/* Given `while-stepping', a thread may be collecting data for more + than one tracepoint simultaneously. On the other hand, the same + tracepoint with a while-stepping action may be hit by more than one + thread simultaneously (but not quite, each thread could be handling + a different step). Each thread holds a list of these objects, + representing the current step of each while-stepping action being + collected. */ + +struct wstep_state +{ + struct wstep_state *next; + + /* The tracepoint number. */ + int tp_number; + /* The tracepoint's address. */ + CORE_ADDR tp_address; + + /* The number of the current step in this 'while-stepping' + action. */ + long current_step; +}; + +/* The linked list of all tracepoints. */ + +static struct tracepoint *tracepoints; + +/* Pointer to the last tracepoint in the list, new tracepoints are + linked in at the end. */ + +static struct tracepoint *last_tracepoint; + +/* The first tracepoint to exceed its pass count. */ + +static struct tracepoint *stopping_tracepoint; + +/* True if the trace buffer is full or otherwise no longer usable. */ + +static int trace_buffer_is_full; + +/* Enumeration of the different kinds of things that can happen during + agent expression evaluation. */ + +enum eval_result_type + { + expr_eval_no_error, + expr_eval_empty_expression, + expr_eval_empty_stack, + expr_eval_stack_overflow, + expr_eval_stack_underflow, + expr_eval_unhandled_opcode, + expr_eval_unrecognized_opcode, + expr_eval_divide_by_zero, + expr_eval_invalid_goto + }; + +static enum eval_result_type expr_eval_result = expr_eval_no_error; + +static const char *eval_result_names[] = + { + "terror:in the attic", /* this should never be reported */ + "terror:empty expression", + "terror:empty stack", + "terror:stack overflow", + "terror:stack underflow", + "terror:unhandled opcode", + "terror:unrecognized opcode", + "terror:divide by zero" + }; + +/* The tracepoint in which the error occurred. */ + +static struct tracepoint *error_tracepoint; + +struct trace_state_variable +{ + /* This is the name of the variable as used in GDB. The target + doesn't use the name, but needs to have it for saving and + reconnection purposes. */ + char *name; + + /* This number identifies the variable uniquely. Numbers may be + assigned either by the target (in the case of builtin variables), + or by GDB, and are presumed unique during the course of a trace + experiment. */ + int number; + + /* The variable's initial value, a 64-bit signed integer always. */ + LONGEST initial_value; + + /* The variable's value, a 64-bit signed integer always. */ + LONGEST value; + + /* Pointer to a getter function, used to supply computed values. */ + LONGEST (*getter) (void); + + /* Link to the next variable. */ + struct trace_state_variable *next; +}; + +/* Linked list of all trace state variables. */ + +static struct trace_state_variable *trace_state_variables; + +/* The results of tracing go into a fixed-size space known as the + "trace buffer". Because usage follows a limited number of + patterns, we manage it ourselves rather than with malloc. Basic + rules are that we create only one trace frame at a time, each is + variable in size, they are never moved once created, and we only + discard if we are doing a circular buffer, and then only the oldest + ones. Each trace frame includes its own size, so we don't need to + link them together, and the trace frame number is relative to the + first one, so we don't need to record numbers. A trace frame also + records the number of the tracepoint that created it. The data + itself is a series of blocks, each introduced by a single character + and with a defined format. Each type of block has enough + type/length info to allow scanners to jump quickly from one block + to the next without reading each byte in the block. */ + +/* Trace buffer management would be simple - advance a free pointer + from beginning to end, then stop - were it not for the circular + buffer option, which is a useful way to prevent a trace run from + stopping prematurely because the buffer filled up. In the circular + case, the location of the first trace frame (trace_buffer_start) + moves as old trace frames are discarded. Also, since we grow trace + frames incrementally as actions are performed, we wrap around to + the beginning of the trace buffer. This is per-block, so each + block within a trace frame remains contiguous. Things get messy + when the wrapped-around trace frame is the one being discarded; the + free space ends up in two parts at opposite ends of the buffer. */ + +#ifndef ATTR_PACKED +# if defined(__GNUC__) +# define ATTR_PACKED __attribute__ ((packed)) +# else +# define ATTR_PACKED /* nothing */ +# endif +#endif + +/* The data collected at a tracepoint hit. This object should be as + small as possible, since there may be a great many of them. We do + not need to keep a frame number, because they are all sequential + and there are no deletions; so the Nth frame in the buffer is + always frame number N. */ + +struct traceframe +{ + /* Number of the tracepoint that collected this traceframe. A value + of 0 indicates the current end of the trace buffer. We make this + a 16-bit field because it's never going to happen that GDB's + numbering of tracepoints reaches 32,000. */ + int tpnum : 16; + + /* The size of the data in this trace frame. We limit this to 32 + bits, even on a 64-bit target, because it's just implausible that + one is validly going to collect 4 gigabytes of data at a single + tracepoint hit. */ + unsigned int data_size : 32; + + /* The base of the trace data, which is contiguous from this point. */ + unsigned char data[0]; + +} ATTR_PACKED traceframe_t; + +/* The traceframe to be used as the source of data to send back to + GDB. A value of -1 means to get data from the live program. */ + +int current_traceframe = -1; + +/* This flag is true if the trace buffer is circular, meaning that + when it fills, the oldest trace frames are discarded in order to + make room. */ + +static int circular_trace_buffer; + +/* Pointer to the block of memory that traceframes all go into. */ + +static unsigned char *trace_buffer_lo; + +/* Pointer to the end of the trace buffer, more precisely to the byte + after the end of the buffer. */ + +static unsigned char *trace_buffer_hi; + +/* Pointer to the first trace frame in the buffer. In the + non-circular case, this is equal to trace_buffer_lo, otherwise it + moves around in the buffer. */ + +static unsigned char *trace_buffer_start; + +/* Pointer to the free part of the trace buffer. Note that we clear + several bytes at and after this pointer, so that traceframe + scans/searches terminate properly. */ + +static unsigned char *trace_buffer_free; + +/* Pointer to the byte after the end of the free part. Note that this + may be smaller than trace_buffer_free in the circular case, and + means that the free part is in two pieces. Initially it is equal + to trace_buffer_hi, then is generally equivalent to + trace_buffer_start. */ + +static unsigned char *trace_buffer_end_free; + +/* Pointer to the wraparound. If not equal to trace_buffer_hi, then + this is the point at which the trace data breaks, and resumes at + trace_buffer_lo. */ + +static unsigned char *trace_buffer_wrap; + +/* Macro that returns a pointer to the first traceframe in the buffer. */ + +#define FIRST_TRACEFRAME() ((struct traceframe *) trace_buffer_start) + +/* Macro that returns a pointer to the next traceframe in the buffer. + If the computed location is beyond the wraparound point, subtract + the offset of the wraparound. */ + +#define NEXT_TRACEFRAME_1(TF) \ + (((unsigned char *) (TF)) + sizeof (struct traceframe) + (TF)->data_size) + +#define NEXT_TRACEFRAME(TF) \ + ((struct traceframe *) (NEXT_TRACEFRAME_1 (TF) \ + - ((NEXT_TRACEFRAME_1 (TF) >= trace_buffer_wrap) \ + ? (trace_buffer_wrap - trace_buffer_lo) \ + : 0))) + +/* The difference between these counters represents the total number + of complete traceframes present in the trace buffer. */ + +static unsigned int traceframe_write_count; +static unsigned int traceframe_read_count; + +/* Convenience macro. */ + +#define traceframe_count \ + ((unsigned int) (traceframe_write_count - traceframe_read_count)) + +/* The count of all traceframes created in the current run, including + ones that were discarded to make room. */ + +static int traceframes_created; + +/* Read-only regions are address ranges whose contents don't change, + and so can be read from target memory even while looking at a trace + frame. Without these, disassembly for instance will likely fail, + because the program code is not usually collected into a trace + frame. This data structure does not need to be very complicated or + particularly efficient, it's only going to be used occasionally, + and only by some commands. */ + +struct readonly_region +{ + /* The bounds of the region. */ + CORE_ADDR start, end; + + /* Link to the next one. */ + struct readonly_region *next; +}; + +/* Linked list of readonly regions. This list stays in effect from + one tstart to the next. */ + +static struct readonly_region *readonly_regions; + +/* The global that controls tracing overall. */ + +static int tracing; + +/* The reason for the last tracing run to have stopped. We initialize + to a distinct string so that GDB can distinguish between "stopped + after running" and "stopped because never run" cases. */ + +static const char *tracing_stop_reason = "tnotrun"; + +static int tracing_stop_tpnum; + +/* Functions local to this file. */ + +/* Base "class" for tracepoint type specific data to be passed down to + collect_data_at_tracepoint. */ +struct tracepoint_hit_ctx +{ + /* empty */ +}; + +/* Trap tracepoint specific data to be passed down to + collect_data_at_tracepoint. */ + +struct trap_tracepoint_ctx +{ + struct tracepoint_hit_ctx base; + + struct regcache *regcache; +}; + +static struct agent_expr *parse_agent_expr (char **actparm); +static char *unparse_agent_expr (struct agent_expr *aexpr); +static enum eval_result_type eval_agent_expr (struct tracepoint_hit_ctx *ctx, + struct traceframe *tframe, + struct agent_expr *aexpr, + ULONGEST *rslt); + +static int agent_mem_read (struct traceframe *tframe, + unsigned char *to, CORE_ADDR from, ULONGEST len); +static int agent_tsv_read (struct traceframe *tframe, int n); + +static CORE_ADDR traceframe_get_pc (struct traceframe *tframe); +static int traceframe_read_tsv (int num, LONGEST *val); + +static int condition_true_at_tracepoint (struct tracepoint_hit_ctx *ctx, + struct tracepoint *tpoint); + +static void clear_readonly_regions (void); +static void clear_installed_tracepoints (void); + +static void collect_data_at_tracepoint (struct tracepoint_hit_ctx *ctx, + CORE_ADDR stop_pc, + struct tracepoint *tpoint); + +static void collect_data_at_step (struct tracepoint_hit_ctx *ctx, + CORE_ADDR stop_pc, + struct tracepoint *tpoint, int current_step); + +static void do_action_at_tracepoint (struct tracepoint_hit_ctx *ctx, + CORE_ADDR stop_pc, + struct tracepoint *tpoint, + struct traceframe *tframe, + struct tracepoint_action *taction); + +/* Record that an error occurred during expression evaluation. */ + +static void +record_tracepoint_error (struct tracepoint *tpoint, const char *which, + enum eval_result_type rtype) +{ + trace_debug ("Tracepoint %d at %s %s eval reports error %d", + tpoint->number, paddress (tpoint->address), which, rtype); + + expr_eval_result = rtype; + error_tracepoint = tpoint; +} + +/* Trace buffer management. */ + +static void +clear_trace_buffer (void) +{ + trace_buffer_start = trace_buffer_lo; + trace_buffer_free = trace_buffer_lo; + trace_buffer_end_free = trace_buffer_hi; + trace_buffer_wrap = trace_buffer_hi; + /* A traceframe with zeroed fields marks the end of trace data. */ + ((struct traceframe *) trace_buffer_free)->tpnum = 0; + ((struct traceframe *) trace_buffer_free)->data_size = 0; + traceframe_read_count = traceframe_write_count = 0; + traceframes_created = 0; +} + +static void +init_trace_buffer (unsigned char *buf, int bufsize) +{ + trace_buffer_lo = buf; + trace_buffer_hi = trace_buffer_lo + bufsize; + + clear_trace_buffer (); +} + +/* Carve out a piece of the trace buffer, returning NULL in case of + failure. */ + +static void * +trace_buffer_alloc (size_t amt) +{ + unsigned char *rslt; + struct traceframe *oldest; + unsigned char *new_start; + + trace_debug ("Want to allocate %ld+%ld bytes in trace buffer", + (long) amt, (long) sizeof (struct traceframe)); + + /* Account for the EOB marker. */ + amt += sizeof (struct traceframe); + + /* Offsets are easier to grok for debugging than raw addresses, + especially for the small trace buffer sizes that are useful for + testing. */ + trace_debug ("Trace buffer start=%d free=%d endfree=%d wrap=%d hi=%d", + (int) (trace_buffer_start - trace_buffer_lo), + (int) (trace_buffer_free - trace_buffer_lo), + (int) (trace_buffer_end_free - trace_buffer_lo), + (int) (trace_buffer_wrap - trace_buffer_lo), + (int) (trace_buffer_hi - trace_buffer_lo)); + + /* The algorithm here is to keep trying to get a contiguous block of + the requested size, possibly discarding older traceframes to free + up space. Since free space might come in one or two pieces, + depending on whether discarded traceframes wrapped around at the + high end of the buffer, we test both pieces after each + discard. */ + while (1) + { + /* First, if we have two free parts, try the upper one first. */ + if (trace_buffer_end_free < trace_buffer_free) + { + if (trace_buffer_free + amt <= trace_buffer_hi) + /* We have enough in the upper part. */ + break; + else + { + /* Our high part of free space wasn't enough. Give up + on it for now, set wraparound. We will recover the + space later, if/when the wrapped-around traceframe is + discarded. */ + trace_debug ("Upper part too small, setting wraparound"); + trace_buffer_wrap = trace_buffer_free; + trace_buffer_free = trace_buffer_lo; + } + } + + /* The normal case. */ + if (trace_buffer_free + amt <= trace_buffer_end_free) + break; + + /* If we're here, then neither part is big enough, and + non-circular trace buffers are now full. */ + if (!circular_trace_buffer) + { + trace_debug ("Not enough space in the trace buffer"); + return NULL; + } + + trace_debug ("Need more space in the trace buffer"); + + /* If we have a circular buffer, we can try discarding the + oldest traceframe and see if that helps. */ + oldest = FIRST_TRACEFRAME (); + if (oldest->tpnum == 0) + { + /* Not good; we have no traceframes to free. Perhaps we're + asking for a block that is larger than the buffer? In + any case, give up. */ + trace_debug ("No traceframes to discard"); + return NULL; + } + + --traceframe_write_count; + + new_start = (unsigned char *) NEXT_TRACEFRAME (oldest); + /* If we freed the traceframe that wrapped around, go back + to the non-wrap case. */ + if (new_start < trace_buffer_start) + { + trace_debug ("Discarding past the wraparound"); + trace_buffer_wrap = trace_buffer_hi; + } + trace_buffer_start = new_start; + trace_buffer_end_free = trace_buffer_start; + + trace_debug ("Discarded a traceframe\n" + "Trace buffer, start=%d free=%d endfree=%d wrap=%d hi=%d", + (int) (trace_buffer_start - trace_buffer_lo), + (int) (trace_buffer_free - trace_buffer_lo), + (int) (trace_buffer_end_free - trace_buffer_lo), + (int) (trace_buffer_wrap - trace_buffer_lo), + (int) (trace_buffer_hi - trace_buffer_lo)); + + /* Now go back around the loop. The discard might have resulted + in either one or two pieces of free space, so we want to try + both before freeing any more traceframes. */ + } + + /* If we get here, we know we can provide the asked-for space. */ + + rslt = trace_buffer_free; + + /* Adjust the request back down, now that we know we have space for + the marker. */ + trace_buffer_free += (amt - sizeof (struct traceframe)); + + /* We have a new piece of the trace buffer. Hurray! */ + + /* Add an EOB marker just past this allocation. */ + ((struct traceframe *) trace_buffer_free)->tpnum = 0; + ((struct traceframe *) trace_buffer_free)->data_size = 0; + + /* Adjust the request back down, now that we know we have space for + the marker. */ + amt -= sizeof (struct traceframe); + + if (debug_threads) + { + trace_debug ("Allocated %d bytes", (int) amt); + trace_debug ("Trace buffer start=%d free=%d endfree=%d wrap=%d hi=%d", + (int) (trace_buffer_start - trace_buffer_lo), + (int) (trace_buffer_free - trace_buffer_lo), + (int) (trace_buffer_end_free - trace_buffer_lo), + (int) (trace_buffer_wrap - trace_buffer_lo), + (int) (trace_buffer_hi - trace_buffer_lo)); + } + + return rslt; +} + +/* Return the total free space. This is not necessarily the largest + block we can allocate, because of the two-part case. */ + +static int +free_space (void) +{ + if (trace_buffer_free <= trace_buffer_end_free) + return trace_buffer_end_free - trace_buffer_free; + else + return ((trace_buffer_end_free - trace_buffer_lo) + + (trace_buffer_hi - trace_buffer_free)); +} + +/* An 'S' in continuation packets indicates remainder are for + while-stepping. */ + +static int seen_step_action_flag; + +/* Create a tracepoint (location) with given number and address. */ + +static struct tracepoint * +add_tracepoint (int num, CORE_ADDR addr) +{ + struct tracepoint *tpoint; + + tpoint = xmalloc (sizeof (struct tracepoint)); + tpoint->number = num; + tpoint->address = addr; + tpoint->numactions = 0; + tpoint->actions = NULL; + tpoint->actions_str = NULL; + tpoint->cond = NULL; + tpoint->num_step_actions = 0; + tpoint->step_actions = NULL; + tpoint->step_actions_str = NULL; + tpoint->source_strings = NULL; + tpoint->handle = NULL; + tpoint->next = NULL; + + if (!last_tracepoint) + tracepoints = tpoint; + else + last_tracepoint->next = tpoint; + last_tracepoint = tpoint; + + seen_step_action_flag = 0; + + return tpoint; +} + +/* Return the tracepoint with the given number and address, or NULL. */ + +static struct tracepoint * +find_tracepoint (int id, CORE_ADDR addr) +{ + struct tracepoint *tpoint; + + for (tpoint = tracepoints; tpoint; tpoint = tpoint->next) + if (tpoint->number == id && tpoint->address == addr) + return tpoint; + + return NULL; +} + +/* There may be several tracepoints with the same number (because they + are "locations", in GDB parlance); return the next one after the + given tracepoint, or search from the beginning of the list if the + first argument is NULL. */ + +static struct tracepoint * +find_next_tracepoint_by_number (struct tracepoint *prev_tp, int num) +{ + struct tracepoint *tpoint; + + if (prev_tp) + tpoint = prev_tp->next; + else + tpoint = tracepoints; + for (; tpoint; tpoint = tpoint->next) + if (tpoint->number == num) + return tpoint; + + return NULL; +} + +static char * +save_string (const char *str, size_t len) +{ + char *s; + + s = xmalloc (len + 1); + memcpy (s, str, len); + s[len] = '\0'; + + return s; +} + +/* Append another action to perform when the tracepoint triggers. */ + +static void +add_tracepoint_action (struct tracepoint *tpoint, char *packet) +{ + char *act; + + if (*packet == 'S') + { + seen_step_action_flag = 1; + ++packet; + } + + act = packet; + + while (*act) + { + char *act_start = act; + struct tracepoint_action *action = NULL; + + switch (*act) + { + case 'M': + { + struct collect_memory_action *maction; + ULONGEST basereg; + int is_neg; + + maction = xmalloc (sizeof *maction); + maction->base.type = *act; + action = &maction->base; + + ++act; + is_neg = (*act == '-'); + if (*act == '-') + ++act; + act = unpack_varlen_hex (act, &basereg); + ++act; + act = unpack_varlen_hex (act, &maction->addr); + ++act; + act = unpack_varlen_hex (act, &maction->len); + maction->basereg = (is_neg + ? - (int) basereg + : (int) basereg); + trace_debug ("Want to collect %s bytes at 0x%s (basereg %d)", + pulongest (maction->len), + paddress (maction->addr), maction->basereg); + break; + } + case 'R': + { + struct collect_registers_action *raction; + + raction = xmalloc (sizeof *raction); + raction->base.type = *act; + action = &raction->base; + + trace_debug ("Want to collect registers"); + ++act; + /* skip past hex digits of mask for now */ + while (isxdigit(*act)) + ++act; + break; + } + case 'S': + trace_debug ("Unexpected step action, ignoring"); + ++act; + break; + case 'X': + { + struct eval_expr_action *xaction; + + xaction = xmalloc (sizeof (*xaction)); + xaction->base.type = *act; + action = &xaction->base; + + trace_debug ("Want to evaluate expression"); + xaction->expr = parse_agent_expr (&act); + break; + } + default: + trace_debug ("unknown trace action '%c', ignoring...", *act); + break; + case '-': + break; + } + + if (action == NULL) + break; + + if (seen_step_action_flag) + { + tpoint->num_step_actions++; + + tpoint->step_actions + = xrealloc (tpoint->step_actions, + (sizeof (*tpoint->step_actions) + * tpoint->num_step_actions)); + tpoint->step_actions_str + = xrealloc (tpoint->step_actions_str, + (sizeof (*tpoint->step_actions_str) + * tpoint->num_step_actions)); + tpoint->step_actions[tpoint->num_step_actions - 1] = action; + tpoint->step_actions_str[tpoint->num_step_actions - 1] + = save_string (act_start, act - act_start); + } + else + { + tpoint->numactions++; + tpoint->actions + = xrealloc (tpoint->actions, + sizeof (*tpoint->actions) * tpoint->numactions); + tpoint->actions_str + = xrealloc (tpoint->actions_str, + sizeof (*tpoint->actions_str) * tpoint->numactions); + tpoint->actions[tpoint->numactions - 1] = action; + tpoint->actions_str[tpoint->numactions - 1] + = save_string (act_start, act - act_start); + } + } +} + +/* Find or create a trace state variable with the given number. */ + +static struct trace_state_variable * +get_trace_state_variable (int num) +{ + struct trace_state_variable *tsv; + + /* Search for an existing variable. */ + for (tsv = trace_state_variables; tsv; tsv = tsv->next) + if (tsv->number == num) + return tsv; + + return NULL; +} + +/* Find or create a trace state variable with the given number. */ + +static struct trace_state_variable * +create_trace_state_variable (int num) +{ + struct trace_state_variable *tsv; + + tsv = get_trace_state_variable (num); + if (tsv != NULL) + return tsv; + + /* Create a new variable. */ + tsv = xmalloc (sizeof (struct trace_state_variable)); + tsv->number = num; + tsv->initial_value = 0; + tsv->value = 0; + tsv->getter = NULL; + tsv->name = NULL; + tsv->next = trace_state_variables; + trace_state_variables = tsv; + + return tsv; +} + +static LONGEST +get_trace_state_variable_value (int num) +{ + struct trace_state_variable *tsv; + + tsv = get_trace_state_variable (num); + + if (!tsv) + { + trace_debug ("No trace state variable %d, skipping value get", num); + return 0; + } + + /* Call a getter function if we have one. While it's tempting to + set up something to only call the getter once per tracepoint hit, + it could run afoul of thread races. Better to let the getter + handle it directly, if necessary to worry about it. */ + if (tsv->getter) + tsv->value = (tsv->getter) (); + + trace_debug ("get_trace_state_variable_value(%d) ==> %s", + num, plongest (tsv->value)); + + return tsv->value; +} + +static void +set_trace_state_variable_value (int num, LONGEST val) +{ + struct trace_state_variable *tsv; + + tsv = get_trace_state_variable (num); + + if (!tsv) + { + trace_debug ("No trace state variable %d, skipping value set", num); + return; + } + + tsv->value = val; +} + +static void +set_trace_state_variable_name (int num, const char *name) +{ + struct trace_state_variable *tsv; + + tsv = get_trace_state_variable (num); + + if (!tsv) + { + trace_debug ("No trace state variable %d, skipping name set", num); + return; + } + + tsv->name = (char *) name; +} + +static void +set_trace_state_variable_getter (int num, LONGEST (*getter) (void)) +{ + struct trace_state_variable *tsv; + + tsv = get_trace_state_variable (num); + + if (!tsv) + { + trace_debug ("No trace state variable %d, skipping getter set", num); + return; + } + + tsv->getter = getter; +} + +/* Add a raw traceframe for the given tracepoint. */ + +static struct traceframe * +add_traceframe (struct tracepoint *tpoint) +{ + struct traceframe *tframe; + + tframe = trace_buffer_alloc (sizeof (struct traceframe)); + + if (tframe == NULL) + return NULL; + + tframe->tpnum = tpoint->number; + tframe->data_size = 0; + + return tframe; +} + +/* Add a block to the traceframe currently being worked on. */ + +static unsigned char * +add_traceframe_block (struct traceframe *tframe, int amt) +{ + unsigned char *block; + + if (!tframe) + return NULL; + + block = trace_buffer_alloc (amt); + + if (!block) + return NULL; + + tframe->data_size += amt; + + return block; +} + +/* Flag that the current traceframe is finished. */ + +static void +finish_traceframe (struct traceframe *tframe) +{ + ++traceframe_write_count; + ++traceframes_created; +} + +/* Given a traceframe number NUM, find the NUMth traceframe in the + buffer. */ + +static struct traceframe * +find_traceframe (int num) +{ + struct traceframe *tframe; + int tfnum = 0; + + for (tframe = FIRST_TRACEFRAME (); + tframe->tpnum != 0; + tframe = NEXT_TRACEFRAME (tframe)) + { + if (tfnum == num) + return tframe; + ++tfnum; + } + + return NULL; +} + +static CORE_ADDR +get_traceframe_address (struct traceframe *tframe) +{ + CORE_ADDR addr; + struct tracepoint *tpoint; + + addr = traceframe_get_pc (tframe); + + if (addr) + return addr; + + /* Fallback strategy, will be incorrect for while-stepping frames + and multi-location tracepoints. */ + tpoint = find_next_tracepoint_by_number (NULL, tframe->tpnum); + return tpoint->address; +} + +/* Search for the next traceframe whose address is inside or outside + the given range. */ + +static struct traceframe * +find_next_traceframe_in_range (CORE_ADDR lo, CORE_ADDR hi, int inside_p, + int *tfnump) +{ + struct traceframe *tframe; + CORE_ADDR tfaddr; + + *tfnump = current_traceframe + 1; + tframe = find_traceframe (*tfnump); + /* The search is not supposed to wrap around. */ + if (!tframe) + { + *tfnump = -1; + return NULL; + } + + for (; tframe->tpnum != 0; tframe = NEXT_TRACEFRAME (tframe)) + { + tfaddr = get_traceframe_address (tframe); + if (inside_p + ? (lo <= tfaddr && tfaddr <= hi) + : (lo > tfaddr || tfaddr > hi)) + return tframe; + ++*tfnump; + } + + *tfnump = -1; + return NULL; +} + +/* Search for the next traceframe recorded by the given tracepoint. + Note that for multi-location tracepoints, this will find whatever + location appears first. */ + +static struct traceframe * +find_next_traceframe_by_tracepoint (int num, int *tfnump) +{ + struct traceframe *tframe; + + *tfnump = current_traceframe + 1; + tframe = find_traceframe (*tfnump); + /* The search is not supposed to wrap around. */ + if (!tframe) + { + *tfnump = -1; + return NULL; + } + + for (; tframe->tpnum != 0; tframe = NEXT_TRACEFRAME (tframe)) + { + if (tframe->tpnum == num) + return tframe; + ++*tfnump; + } + + *tfnump = -1; + return NULL; +} + +/* Clear all past trace state. */ + +static void +cmd_qtinit (char *packet) +{ + struct trace_state_variable *tsv, *prev, *next; + + /* Make sure we don't try to read from a trace frame. */ + current_traceframe = -1; + + trace_debug ("Initializing the trace"); + + clear_installed_tracepoints (); + clear_readonly_regions (); + + tracepoints = NULL; + last_tracepoint = NULL; + + /* Clear out any leftover trace state variables. Ones with target + defined getters should be kept however. */ + prev = NULL; + tsv = trace_state_variables; + while (tsv) + { + trace_debug ("Looking at var %d", tsv->number); + if (tsv->getter == NULL) + { + next = tsv->next; + if (prev) + prev->next = next; + else + trace_state_variables = next; + trace_debug ("Deleting var %d", tsv->number); + free (tsv); + tsv = next; + } + else + { + prev = tsv; + tsv = tsv->next; + } + } + + clear_trace_buffer (); + + write_ok (packet); +} + +/* Restore the program to its pre-tracing state. This routine may be called + in error situations, so it needs to be careful about only restoring + from known-valid bits. */ + +static void +clear_installed_tracepoints (void) +{ + struct tracepoint *tpoint; + struct tracepoint *prev_stpoint; + + prev_stpoint = NULL; + + /* Restore any bytes overwritten by tracepoints. */ + for (tpoint = tracepoints; tpoint; tpoint = tpoint->next) + { + if (!tpoint->enabled) + continue; + + /* Catch the case where we might try to remove a tracepoint that + was never actually installed. */ + if (tpoint->handle == NULL) + { + trace_debug ("Tracepoint %d at 0x%s was " + "never installed, nothing to clear", + tpoint->number, paddress (tpoint->address)); + continue; + } + + delete_breakpoint (tpoint->handle); + tpoint->handle = NULL; + } +} + +/* Parse a packet that defines a tracepoint. */ + +static void +cmd_qtdp (char *own_buf) +{ + int tppacket; + ULONGEST num; + ULONGEST addr; + ULONGEST count; + struct tracepoint *tpoint; + char *actparm; + char *packet = own_buf; + + packet += strlen ("QTDP:"); + + /* A hyphen at the beginning marks a packet specifying actions for a + tracepoint already supplied. */ + tppacket = 1; + if (*packet == '-') + { + tppacket = 0; + ++packet; + } + packet = unpack_varlen_hex (packet, &num); + ++packet; /* skip a colon */ + packet = unpack_varlen_hex (packet, &addr); + ++packet; /* skip a colon */ + + /* See if we already have this tracepoint. */ + tpoint = find_tracepoint (num, addr); + + if (tppacket) + { + /* Duplicate tracepoints are never allowed. */ + if (tpoint) + { + trace_debug ("Tracepoint error: tracepoint %d" + " at 0x%s already exists", + (int) num, paddress (addr)); + write_enn (own_buf); + return; + } + + tpoint = add_tracepoint (num, addr); + + tpoint->enabled = (*packet == 'E'); + ++packet; /* skip 'E' */ + ++packet; /* skip a colon */ + packet = unpack_varlen_hex (packet, &count); + tpoint->step_count = count; + ++packet; /* skip a colon */ + packet = unpack_varlen_hex (packet, &count); + tpoint->pass_count = count; + /* See if we have any of the additional optional fields. */ + while (*packet == ':') + { + ++packet; + if (*packet == 'X') + { + actparm = (char *) packet; + tpoint->cond = parse_agent_expr (&actparm); + packet = actparm; + } + else if (*packet == '-') + break; + else if (*packet == '\0') + break; + else + trace_debug ("Unknown optional tracepoint field"); + } + if (*packet == '-') + trace_debug ("Also has actions\n"); + + trace_debug ("Defined tracepoint %d at 0x%s, " + "enabled %d step %ld pass %ld", + tpoint->number, paddress (tpoint->address), + tpoint->enabled, + tpoint->step_count, tpoint->pass_count); + } + else if (tpoint) + add_tracepoint_action (tpoint, packet); + else + { + trace_debug ("Tracepoint error: tracepoint %d at 0x%s not found", + (int) num, paddress (addr)); + write_enn (own_buf); + return; + } + + write_ok (own_buf); +} + +static void +cmd_qtdpsrc (char *own_buf) +{ + ULONGEST num, addr, start, slen; + struct tracepoint *tpoint; + char *packet = own_buf; + char *saved, *srctype, *src; + size_t nbytes; + struct source_string *last, *newlast; + + packet += strlen ("QTDPsrc:"); + + packet = unpack_varlen_hex (packet, &num); + ++packet; /* skip a colon */ + packet = unpack_varlen_hex (packet, &addr); + ++packet; /* skip a colon */ + + /* See if we already have this tracepoint. */ + tpoint = find_tracepoint (num, addr); + + if (!tpoint) + { + trace_debug ("Tracepoint error: tracepoint %d at 0x%s not found", + (int) num, paddress (addr)); + write_enn (own_buf); + return; + } + + saved = packet; + packet = strchr (packet, ':'); + srctype = xmalloc (packet - saved + 1); + memcpy (srctype, saved, packet - saved); + srctype[packet - saved] = '\0'; + ++packet; + packet = unpack_varlen_hex (packet, &start); + ++packet; /* skip a colon */ + packet = unpack_varlen_hex (packet, &slen); + ++packet; /* skip a colon */ + src = xmalloc (slen + 1); + nbytes = unhexify (src, packet, strlen (packet) / 2); + src[nbytes] = '\0'; + + newlast = xmalloc (sizeof (struct source_string)); + newlast->type = srctype; + newlast->str = src; + newlast->next = NULL; + /* Always add a source string to the end of the list; + this keeps sequences of actions/commands in the right + order. */ + if (tpoint->source_strings) + { + for (last = tpoint->source_strings; last->next; last = last->next) + ; + last->next = newlast; + } + else + tpoint->source_strings = newlast; + + write_ok (own_buf); +} + +static void +cmd_qtdv (char *own_buf) +{ + ULONGEST num, val, builtin; + char *varname; + size_t nbytes; + struct trace_state_variable *tsv; + char *packet = own_buf; + + packet += strlen ("QTDV:"); + + packet = unpack_varlen_hex (packet, &num); + ++packet; /* skip a colon */ + packet = unpack_varlen_hex (packet, &val); + ++packet; /* skip a colon */ + packet = unpack_varlen_hex (packet, &builtin); + ++packet; /* skip a colon */ + + nbytes = strlen (packet) / 2; + varname = xmalloc (nbytes + 1); + nbytes = unhexify (varname, packet, nbytes); + varname[nbytes] = '\0'; + + tsv = create_trace_state_variable (num); + tsv->initial_value = (LONGEST) val; + tsv->name = varname; + + set_trace_state_variable_value (num, (LONGEST) val); + + write_ok (own_buf); +} + +static void +cmd_qtv (char *own_buf) +{ + ULONGEST num; + LONGEST val; + int err; + char *packet = own_buf; + + packet += strlen ("qTV:"); + packet = unpack_varlen_hex (packet, &num); + + if (current_traceframe >= 0) + { + err = traceframe_read_tsv ((int) num, &val); + if (err) + { + strcpy (own_buf, "U"); + return; + } + } + /* Only make tsv's be undefined before the first trace run. After a + trace run is over, the user might want to see the last value of + the tsv, and it might not be available in a traceframe. */ + else if (!tracing && strcmp (tracing_stop_reason, "tnotrun") == 0) + { + strcpy (own_buf, "U"); + return; + } + else + val = get_trace_state_variable_value (num); + + sprintf (own_buf, "V%s", phex_nz (val, 0)); +} + +/* Clear out the list of readonly regions. */ + +static void +clear_readonly_regions (void) +{ + struct readonly_region *roreg; + + while (readonly_regions) + { + roreg = readonly_regions; + readonly_regions = readonly_regions->next; + free (roreg); + } +} + +/* Parse the collection of address ranges whose contents GDB believes + to be unchanging and so can be read directly from target memory + even while looking at a traceframe. */ + +static void +cmd_qtro (char *own_buf) +{ + ULONGEST start, end; + struct readonly_region *roreg; + char *packet = own_buf; + + trace_debug ("Want to mark readonly regions"); + + clear_readonly_regions (); + + packet += strlen ("QTro"); + + while (*packet == ':') + { + ++packet; /* skip a colon */ + packet = unpack_varlen_hex (packet, &start); + ++packet; /* skip a comma */ + packet = unpack_varlen_hex (packet, &end); + roreg = xmalloc (sizeof (struct readonly_region)); + roreg->start = start; + roreg->end = end; + roreg->next = readonly_regions; + readonly_regions = roreg; + trace_debug ("Added readonly region from 0x%s to 0x%s", + paddress (roreg->start), paddress (roreg->end)); + } + + write_ok (own_buf); +} + +/* Test to see if the given range is in our list of readonly ranges. + We only test for being entirely within a range, GDB is not going to + send a single memory packet that spans multiple regions. */ + +int +in_readonly_region (CORE_ADDR addr, ULONGEST length) +{ + struct readonly_region *roreg; + + for (roreg = readonly_regions; roreg; roreg = roreg->next) + if (roreg->start <= addr && (addr + length - 1) <= roreg->end) + return 1; + + return 0; +} + +static void +cmd_qtstart (char *packet) +{ + struct tracepoint *tpoint; + int slow_tracepoint_count; + + trace_debug ("Starting the trace"); + + slow_tracepoint_count = 0; + + *packet = '\0'; + + /* Install tracepoints. */ + for (tpoint = tracepoints; tpoint; tpoint = tpoint->next) + { + /* Ensure all the hit counts start at zero. */ + tpoint->hit_count = 0; + + if (!tpoint->enabled) + continue; + + ++slow_tracepoint_count; + + /* Tracepoints are installed as memory breakpoints. Just go + ahead and install the trap. The breakpoints module handles + duplicated breakpoints, and the memory read routine handles + un-patching traps from memory reads. */ + tpoint->handle = set_breakpoint_at (tpoint->address, tracepoint_handler); + + /* Any failure is sufficient cause to give up. */ + if (tpoint->handle == NULL) + break; + } + + /* Any error in tracepoint insertion is unacceptable; better to + address the problem now, than end up with a useless or misleading + trace run. */ + if (tpoint != NULL) + { + clear_installed_tracepoints (); + if (*packet == '\0') + write_enn (packet); + return; + } + + stopping_tracepoint = NULL; + trace_buffer_is_full = 0; + expr_eval_result = expr_eval_no_error; + error_tracepoint = NULL; + + /* Tracing is now active, hits will now start being logged. */ + tracing = 1; + + write_ok (packet); +} + +/* End a tracing run, filling in a stop reason to report back to GDB, + and removing the tracepoints from the code. */ + +static void +stop_tracing (void) +{ + if (!tracing) + { + trace_debug ("Tracing is already off, ignoring"); + return; + } + + trace_debug ("Stopping the trace"); + + /* Stop logging. Tracepoints can still be hit, but they will not be + recorded. */ + tracing = 0; + + tracing_stop_reason = "t???"; + tracing_stop_tpnum = 0; + if (stopping_tracepoint) + { + trace_debug ("Stopping the trace because " + "tracepoint %d was hit %ld times", + stopping_tracepoint->number, + stopping_tracepoint->pass_count); + tracing_stop_reason = "tpasscount"; + tracing_stop_tpnum = stopping_tracepoint->number; + } + else if (trace_buffer_is_full) + { + trace_debug ("Stopping the trace because the trace buffer is full"); + tracing_stop_reason = "tfull"; + } + else if (expr_eval_result != expr_eval_no_error) + { + trace_debug ("Stopping the trace because of an expression eval error"); + tracing_stop_reason = eval_result_names[expr_eval_result]; + tracing_stop_tpnum = error_tracepoint->number; + } + else + { + trace_debug ("Stopping the trace because of a tstop command"); + tracing_stop_reason = "tstop"; + } + + stopping_tracepoint = NULL; + error_tracepoint = NULL; + + /* Clear out the tracepoints. */ + clear_installed_tracepoints (); +} + +static void +cmd_qtstop (char *packet) +{ + stop_tracing (); + write_ok (packet); +} + +static void +cmd_qtframe (char *own_buf) +{ + ULONGEST frame, pc, lo, hi, num; + int tfnum, tpnum; + struct traceframe *tframe; + char *packet = own_buf; + + packet += strlen ("QTFrame:"); + + if (strncmp (packet, "pc:", strlen ("pc:")) == 0) + { + packet += strlen ("pc:"); + packet = unpack_varlen_hex (packet, &pc); + trace_debug ("Want to find next traceframe at pc=0x%s", paddress (pc)); + tframe = find_next_traceframe_in_range (pc, pc, 1, &tfnum); + } + else if (strncmp (packet, "range:", strlen ("range:")) == 0) + { + packet += strlen ("range:"); + packet = unpack_varlen_hex (packet, &lo); + ++packet; + packet = unpack_varlen_hex (packet, &hi); + trace_debug ("Want to find next traceframe in the range 0x%s to 0x%s", + paddress (lo), paddress (hi)); + tframe = find_next_traceframe_in_range (lo, hi, 1, &tfnum); + } + else if (strncmp (packet, "outside:", strlen ("outside:")) == 0) + { + packet += strlen ("outside:"); + packet = unpack_varlen_hex (packet, &lo); + ++packet; + packet = unpack_varlen_hex (packet, &hi); + trace_debug ("Want to find next traceframe " + "outside the range 0x%s to 0x%s", + paddress (lo), paddress (hi)); + tframe = find_next_traceframe_in_range (lo, hi, 0, &tfnum); + } + else if (strncmp (packet, "tdp:", strlen ("tdp:")) == 0) + { + packet += strlen ("tdp:"); + packet = unpack_varlen_hex (packet, &num); + tpnum = (int) num; + trace_debug ("Want to find next traceframe for tracepoint %d", tpnum); + tframe = find_next_traceframe_by_tracepoint (tpnum, &tfnum); + } + else + { + unpack_varlen_hex (packet, &frame); + tfnum = (int) frame; + if (tfnum == -1) + { + trace_debug ("Want to stop looking at traceframes"); + current_traceframe = -1; + write_ok (own_buf); + return; + } + trace_debug ("Want to look at traceframe %d", tfnum); + tframe = find_traceframe (tfnum); + } + + if (tframe) + { + current_traceframe = tfnum; + sprintf (own_buf, "F%xT%x", tfnum, tframe->tpnum); + } + else + sprintf (own_buf, "F-1"); +} + +static void +cmd_qtstatus (char *packet) +{ + char *stop_reason_rsp = NULL; + + trace_debug ("Returning trace status as %d, stop reason %s", + tracing, tracing_stop_reason); + + stop_reason_rsp = (char *) tracing_stop_reason; + + /* The user visible error string in terror needs to be hex encoded. + We leave it as plain string in `tracepoint_stop_reason' to ease + debugging. */ + if (strncmp (stop_reason_rsp, "terror:", strlen ("terror:")) == 0) + { + const char *result_name; + int hexstr_len; + char *p; + + result_name = stop_reason_rsp + strlen ("terror:"); + hexstr_len = strlen (result_name) * 2; + p = stop_reason_rsp = alloca (strlen ("terror:") + hexstr_len + 1); + strcpy (p, "terror:"); + p += strlen (p); + convert_int_to_ascii ((gdb_byte *) result_name, p, strlen (result_name)); + } + + sprintf (packet, "T%c;%s:%x;tframes:%x;tcreated:%x;tfree:%x;tsize:%s", + (tracing ? '1' : '0'), + stop_reason_rsp, tracing_stop_tpnum, + traceframe_count, traceframes_created, + free_space (), + phex_nz (trace_buffer_hi - trace_buffer_lo, 0)); +} + +/* State variables to help return all the tracepoint bits. */ +static struct tracepoint *cur_tpoint; +static int cur_action; +static int cur_step_action; +static struct source_string *cur_source_string; +static struct trace_state_variable *cur_tsv; + +/* Compose a response that is an imitation of the syntax by which the + tracepoint was originally downloaded. */ + +static void +response_tracepoint (char *packet, struct tracepoint *tpoint) +{ + char *buf; + + sprintf (packet, "T%x:%s:%c:%lx:%lx", tpoint->number, + paddress (tpoint->address), + (tpoint->enabled ? 'E' : 'D'), tpoint->step_count, + tpoint->pass_count); + + if (tpoint->cond) + { + buf = unparse_agent_expr (tpoint->cond); + sprintf (packet + strlen (packet), ":X%x,%s", + tpoint->cond->length, buf); + free (buf); + } +} + +/* Compose a response that is an imitation of the syntax by which the + tracepoint action was originally downloaded (with the difference + that due to the way we store the actions, this will output a packet + per action, while GDB could have combined more than one action + per-packet. */ + +static void +response_action (char *packet, struct tracepoint *tpoint, + char *taction, int step) +{ + sprintf (packet, "%c%x:%s:%s", + (step ? 'S' : 'A'), tpoint->number, paddress (tpoint->address), + taction); +} + +/* Compose a response that is an imitation of the syntax by which the + tracepoint source piece was originally downloaded. */ + +static void +response_source (char *packet, + struct tracepoint *tpoint, struct source_string *src) +{ + char *buf; + int len; + + len = strlen (src->str); + buf = alloca (len * 2 + 1); + convert_int_to_ascii ((gdb_byte *) src->str, buf, len); + + sprintf (packet, "Z%x:%s:%s:%x:%x:%s", + tpoint->number, paddress (tpoint->address), + src->type, 0, len, buf); +} + +/* Return the first piece of tracepoint definition, and initialize the + state machine that will iterate through all the tracepoint + bits. */ + +static void +cmd_qtfp (char *packet) +{ + trace_debug ("Returning first tracepoint definition piece"); + + cur_tpoint = tracepoints; + cur_action = cur_step_action = -1; + cur_source_string = NULL; + + if (cur_tpoint) + response_tracepoint (packet, cur_tpoint); + else + strcpy (packet, "l"); +} + +/* Return additional pieces of tracepoint definition. Each action and + stepping action must go into its own packet, because of packet size + limits, and so we use state variables to deliver one piece at a + time. */ + +static void +cmd_qtsp (char *packet) +{ + trace_debug ("Returning subsequent tracepoint definition piece"); + + if (!cur_tpoint) + { + /* This case would normally never occur, but be prepared for + GDB misbehavior. */ + strcpy (packet, "l"); + } + else if (cur_action < cur_tpoint->numactions - 1) + { + ++cur_action; + response_action (packet, cur_tpoint, + cur_tpoint->actions_str[cur_action], 0); + } + else if (cur_step_action < cur_tpoint->num_step_actions - 1) + { + ++cur_step_action; + response_action (packet, cur_tpoint, + cur_tpoint->step_actions_str[cur_step_action], 1); + } + else if ((cur_source_string + ? cur_source_string->next + : cur_tpoint->source_strings)) + { + if (cur_source_string) + cur_source_string = cur_source_string->next; + else + cur_source_string = cur_tpoint->source_strings; + response_source (packet, cur_tpoint, cur_source_string); + } + else + { + cur_tpoint = cur_tpoint->next; + cur_action = cur_step_action = -1; + cur_source_string = NULL; + if (cur_tpoint) + response_tracepoint (packet, cur_tpoint); + else + strcpy (packet, "l"); + } +} + +/* Compose a response that is an imitation of the syntax by which the + trace state variable was originally downloaded. */ + +static void +response_tsv (char *packet, struct trace_state_variable *tsv) +{ + char *buf = (char *) ""; + int namelen; + + if (tsv->name) + { + namelen = strlen (tsv->name); + buf = alloca (namelen * 2 + 1); + convert_int_to_ascii ((gdb_byte *) tsv->name, buf, namelen); + } + + sprintf (packet, "%x:%s:%x:%s", tsv->number, phex_nz (tsv->initial_value, 0), + tsv->getter ? 1 : 0, buf); +} + +/* Return the first trace state variable definition, and initialize + the state machine that will iterate through all the tsv bits. */ + +static void +cmd_qtfv (char *packet) +{ + trace_debug ("Returning first trace state variable definition"); + + cur_tsv = trace_state_variables; + + if (cur_tsv) + response_tsv (packet, cur_tsv); + else + strcpy (packet, "l"); +} + +/* Return additional trace state variable definitions. */ + +static void +cmd_qtsv (char *packet) +{ + trace_debug ("Returning first trace state variable definition"); + + if (!cur_tpoint) + { + /* This case would normally never occur, but be prepared for + GDB misbehavior. */ + strcpy (packet, "l"); + } + else if (cur_tsv) + { + cur_tsv = cur_tsv->next; + if (cur_tsv) + response_tsv (packet, cur_tsv); + else + strcpy (packet, "l"); + } + else + strcpy (packet, "l"); +} + +/* Respond to qTBuffer packet with a block of raw data from the trace + buffer. GDB may ask for a lot, but we are allowed to reply with + only as much as will fit within packet limits or whatever. */ + +static void +cmd_qtbuffer (char *own_buf) +{ + ULONGEST offset, num, tot; + unsigned char *tbp; + char *packet = own_buf; + + packet += strlen ("qTBuffer:"); + + packet = unpack_varlen_hex (packet, &offset); + ++packet; /* skip a comma */ + packet = unpack_varlen_hex (packet, &num); + + trace_debug ("Want to get trace buffer, %d bytes at offset 0x%s", + (int) num, pulongest (offset)); + + tot = (trace_buffer_hi - trace_buffer_lo) - free_space (); + + /* If we're right at the end, reply specially that we're done. */ + if (offset == tot) + { + strcpy (own_buf, "l"); + return; + } + + /* Object to any other out-of-bounds request. */ + if (offset > tot) + { + write_enn (own_buf); + return; + } + + /* Compute the pointer corresponding to the given offset, accounting + for wraparound. */ + tbp = trace_buffer_start + offset; + if (tbp >= trace_buffer_wrap) + tbp -= (trace_buffer_wrap - trace_buffer_lo); + + /* Trim to the remaining bytes if we're close to the end. */ + if (num > tot - offset) + num = tot - offset; + + /* Trim to available packet size. */ + if (num >= (PBUFSIZ - 16) / 2 ) + num = (PBUFSIZ - 16) / 2; + + convert_int_to_ascii (tbp, own_buf, num); + own_buf[num] = '\0'; +} + +static void +cmd_bigqtbuffer (char *own_buf) +{ + ULONGEST val; + char *packet = own_buf; + + packet += strlen ("QTBuffer:"); + + if (strncmp ("circular:", packet, strlen ("circular:")) == 0) + { + packet += strlen ("circular:"); + packet = unpack_varlen_hex (packet, &val); + circular_trace_buffer = val; + trace_debug ("Trace buffer is now %s", + circular_trace_buffer ? "circular" : "linear"); + write_ok (own_buf); + } + else + write_enn (own_buf); +} + +int +handle_tracepoint_general_set (char *packet) +{ + if (strcmp ("QTinit", packet) == 0) + { + cmd_qtinit (packet); + return 1; + } + else if (strncmp ("QTDP:", packet, strlen ("QTDP:")) == 0) + { + cmd_qtdp (packet); + return 1; + } + else if (strncmp ("QTDPsrc:", packet, strlen ("QTDPsrc:")) == 0) + { + cmd_qtdpsrc (packet); + return 1; + } + else if (strncmp ("QTDV:", packet, strlen ("QTDV:")) == 0) + { + cmd_qtdv (packet); + return 1; + } + else if (strncmp ("QTro:", packet, strlen ("QTro:")) == 0) + { + cmd_qtro (packet); + return 1; + } + else if (strcmp ("QTStart", packet) == 0) + { + cmd_qtstart (packet); + return 1; + } + else if (strcmp ("QTStop", packet) == 0) + { + cmd_qtstop (packet); + return 1; + } + else if (strncmp ("QTFrame:", packet, strlen ("QTFrame:")) == 0) + { + cmd_qtframe (packet); + return 1; + } + else if (strncmp ("QTBuffer:", packet, strlen ("QTBuffer:")) == 0) + { + cmd_bigqtbuffer (packet); + return 1; + } + + return 0; +} + +int +handle_tracepoint_query (char *packet) +{ + if (strcmp ("qTStatus", packet) == 0) + { + cmd_qtstatus (packet); + return 1; + } + else if (strcmp ("qTfP", packet) == 0) + { + cmd_qtfp (packet); + return 1; + } + else if (strcmp ("qTsP", packet) == 0) + { + cmd_qtsp (packet); + return 1; + } + else if (strcmp ("qTfV", packet) == 0) + { + cmd_qtfv (packet); + return 1; + } + else if (strcmp ("qTsV", packet) == 0) + { + cmd_qtsv (packet); + return 1; + } + else if (strncmp ("qTV:", packet, strlen ("qTV:")) == 0) + { + cmd_qtv (packet); + return 1; + } + else if (strncmp ("qTBuffer:", packet, strlen ("qTBuffer:")) == 0) + { + cmd_qtbuffer (packet); + return 1; + } + + return 0; +} + +/* Call this when thread TINFO has hit the tracepoint defined by + TP_NUMBER and TP_ADDRESS, and that tracepoint has a while-stepping + action. This adds a while-stepping collecting state item to the + threads' collecting state list, so that we can keep track of + multiple simultaneous while-stepping actions being collected by the + same thread. This can happen in cases like: + + ff0001 INSN1 <-- TP1, while-stepping 10 collect $regs + ff0002 INSN2 + ff0003 INSN3 <-- TP2, collect $regs + ff0004 INSN4 <-- TP3, while-stepping 10 collect $regs + ff0005 INSN5 + + Notice that when instruction INSN5 is reached, the while-stepping + actions of both TP1 and TP3 are still being collected, and that TP2 + had been collected meanwhile. The whole range of ff0001-ff0005 + should be single-stepped, due to at least TP1's while-stepping + action covering the whole range. */ + +static void +add_while_stepping_state (struct thread_info *tinfo, + int tp_number, CORE_ADDR tp_address) +{ + struct wstep_state *wstep; + + wstep = xmalloc (sizeof (*wstep)); + wstep->next = tinfo->while_stepping; + + wstep->tp_number = tp_number; + wstep->tp_address = tp_address; + wstep->current_step = 0; + + tinfo->while_stepping = wstep; +} + +/* Release the while-stepping collecting state WSTEP. */ + +static void +release_while_stepping_state (struct wstep_state *wstep) +{ + free (wstep); +} + +/* Release all while-stepping collecting states currently associated + with thread TINFO. */ + +void +release_while_stepping_state_list (struct thread_info *tinfo) +{ + struct wstep_state *head; + + while (tinfo->while_stepping) + { + head = tinfo->while_stepping; + tinfo->while_stepping = head->next; + release_while_stepping_state (head); + } +} + +/* If TINFO was handling a 'while-stepping' action, the step has + finished, so collect any step data needed, and check if any more + steps are required. Return true if the thread was indeed + collecting tracepoint data, false otherwise. */ + +int +tracepoint_finished_step (struct thread_info *tinfo, CORE_ADDR stop_pc) +{ + struct tracepoint *tpoint; + struct wstep_state *wstep; + struct wstep_state **wstep_link; + struct trap_tracepoint_ctx ctx; + + /* Check if we were indeed collecting data for one of more + tracepoints with a 'while-stepping' count. */ + if (tinfo->while_stepping == NULL) + return 0; + + if (!tracing) + { + /* We're not even tracing anymore. Stop this thread from + collecting. */ + release_while_stepping_state_list (tinfo); + + /* The thread had stopped due to a single-step request indeed + explained by a tracepoint. */ + return 1; + } + + wstep = tinfo->while_stepping; + wstep_link = &tinfo->while_stepping; + + trace_debug ("Thread %s finished a single-step for tracepoint %d at 0x%s", + target_pid_to_str (tinfo->entry.id), + wstep->tp_number, paddress (wstep->tp_address)); + + ctx.regcache = get_thread_regcache (tinfo, 1); + + while (wstep != NULL) + { + tpoint = find_tracepoint (wstep->tp_number, wstep->tp_address); + if (tpoint == NULL) + { + trace_debug ("NO TRACEPOINT %d at 0x%s FOR THREAD %s!", + wstep->tp_number, paddress (wstep->tp_address), + target_pid_to_str (tinfo->entry.id)); + + /* Unlink. */ + *wstep_link = wstep->next; + release_while_stepping_state (wstep); + continue; + } + + /* We've just finished one step. */ + ++wstep->current_step; + + /* Collect data. */ + collect_data_at_step ((struct tracepoint_hit_ctx *) &ctx, + stop_pc, tpoint, wstep->current_step); + + if (wstep->current_step >= tpoint->step_count) + { + /* The requested numbers of steps have occurred. */ + trace_debug ("Thread %s done stepping for tracepoint %d at 0x%s", + target_pid_to_str (tinfo->entry.id), + wstep->tp_number, paddress (wstep->tp_address)); + + /* Unlink the wstep. */ + *wstep_link = wstep->next; + release_while_stepping_state (wstep); + wstep = *wstep_link; + + /* Only check the hit count now, which ensure that we do all + our stepping before stopping the run. */ + if (tpoint->pass_count > 0 + && tpoint->hit_count >= tpoint->pass_count + && stopping_tracepoint == NULL) + stopping_tracepoint = tpoint; + } + else + { + /* Keep single-stepping until the requested numbers of steps + have occurred. */ + wstep_link = &wstep->next; + wstep = *wstep_link; + } + + if (stopping_tracepoint + || trace_buffer_is_full + || expr_eval_result != expr_eval_no_error) + { + stop_tracing (); + break; + } + } + + return 1; +} + +/* Return true if TINFO just hit a tracepoint. Collect data if + so. */ + +int +tracepoint_was_hit (struct thread_info *tinfo, CORE_ADDR stop_pc) +{ + struct tracepoint *tpoint; + int ret = 0; + struct trap_tracepoint_ctx ctx; + + /* Not tracing, don't handle. */ + if (!tracing) + return 0; + + ctx.regcache = get_thread_regcache (tinfo, 1); + + for (tpoint = tracepoints; tpoint; tpoint = tpoint->next) + { + if (tpoint->enabled && stop_pc == tpoint->address) + { + trace_debug ("Thread %s at address of tracepoint %d at 0x%s", + target_pid_to_str (tinfo->entry.id), + tpoint->number, paddress (tpoint->address)); + + /* Test the condition if present, and collect if true. */ + if (!tpoint->cond + || (condition_true_at_tracepoint + ((struct tracepoint_hit_ctx *) &ctx, tpoint))) + collect_data_at_tracepoint ((struct tracepoint_hit_ctx *) &ctx, + stop_pc, tpoint); + + if (stopping_tracepoint + || trace_buffer_is_full + || expr_eval_result != expr_eval_no_error) + { + stop_tracing (); + } + /* If the tracepoint had a 'while-stepping' action, then set + the thread to collect this tracepoint on the following + single-steps. */ + else if (tpoint->step_count > 0) + { + add_while_stepping_state (tinfo, + tpoint->number, tpoint->address); + } + + ret = 1; + } + } + + return ret; +} + +/* Create a trace frame for the hit of the given tracepoint in the + given thread. */ + +static void +collect_data_at_tracepoint (struct tracepoint_hit_ctx *ctx, CORE_ADDR stop_pc, + struct tracepoint *tpoint) +{ + struct traceframe *tframe; + int acti; + + /* Only count it as a hit when we actually collect data. */ + tpoint->hit_count++; + + /* If we've exceeded a defined pass count, record the event for + later, and finish the collection for this hit. This test is only + for nonstepping tracepoints, stepping tracepoints test at the end + of their while-stepping loop. */ + if (tpoint->pass_count > 0 + && tpoint->hit_count >= tpoint->pass_count + && tpoint->step_count == 0 + && stopping_tracepoint == NULL) + stopping_tracepoint = tpoint; + + trace_debug ("Making new traceframe for tracepoint %d at 0x%s, hit %ld", + tpoint->number, paddress (tpoint->address), tpoint->hit_count); + + tframe = add_traceframe (tpoint); + + if (tframe) + { + for (acti = 0; acti < tpoint->numactions; ++acti) + { + trace_debug ("Tracepoint %d at 0x%s about to do action '%s'", + tpoint->number, paddress (tpoint->address), + tpoint->actions_str[acti]); + + do_action_at_tracepoint (ctx, stop_pc, tpoint, tframe, + tpoint->actions[acti]); + } + + finish_traceframe (tframe); + } + + if (tframe == NULL && tracing) + trace_buffer_is_full = 1; +} + +static void +collect_data_at_step (struct tracepoint_hit_ctx *ctx, + CORE_ADDR stop_pc, + struct tracepoint *tpoint, int current_step) +{ + struct traceframe *tframe; + int acti; + + trace_debug ("Making new step traceframe for " + "tracepoint %d at 0x%s, step %d of %ld, hit %ld", + tpoint->number, paddress (tpoint->address), + current_step, tpoint->step_count, + tpoint->hit_count); + + tframe = add_traceframe (tpoint); + + if (tframe) + { + for (acti = 0; acti < tpoint->num_step_actions; ++acti) + { + trace_debug ("Tracepoint %d at 0x%s about to do step action '%s'", + tpoint->number, paddress (tpoint->address), + tpoint->step_actions_str[acti]); + + do_action_at_tracepoint (ctx, stop_pc, tpoint, tframe, + tpoint->step_actions[acti]); + } + + finish_traceframe (tframe); + } + + if (tframe == NULL && tracing) + trace_buffer_is_full = 1; +} + +static struct regcache * +get_context_regcache (struct tracepoint_hit_ctx *ctx) +{ + struct trap_tracepoint_ctx *tctx = (struct trap_tracepoint_ctx *) ctx; + struct regcache *regcache = tctx->regcache; + + gdb_assert (regcache != NULL); + + return regcache; +} + +static void +do_action_at_tracepoint (struct tracepoint_hit_ctx *ctx, + CORE_ADDR stop_pc, + struct tracepoint *tpoint, + struct traceframe *tframe, + struct tracepoint_action *taction) +{ + enum eval_result_type err; + + switch (taction->type) + { + case 'M': + { + struct collect_memory_action *maction; + + maction = (struct collect_memory_action *) taction; + + trace_debug ("Want to collect %s bytes at 0x%s (basereg %d)", + pulongest (maction->len), + paddress (maction->addr), maction->basereg); + /* (should use basereg) */ + agent_mem_read (tframe, NULL, + (CORE_ADDR) maction->addr, maction->len); + break; + } + case 'R': + { + struct collect_registers_action *raction; + + unsigned char *regspace; + struct regcache tregcache; + struct regcache *context_regcache; + + raction = (struct collect_registers_action *) taction; + + trace_debug ("Want to collect registers"); + + /* Collect all registers for now. */ + regspace = add_traceframe_block (tframe, + 1 + register_cache_size ()); + if (regspace == NULL) + { + trace_debug ("Trace buffer block allocation failed, skipping"); + break; + } + /* 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); + + /* Copy the register data to the regblock. */ + regcache_cpy (&tregcache, context_regcache); + + /* On some platforms, trap-based tracepoints will have the PC + pointing to the next instruction after the trap, but we + don't want the user or GDB trying to guess whether the + saved PC needs adjusting; so always record the adjusted + stop_pc. Note that we can't use tpoint->address instead, + since it will be wrong for while-stepping actions. */ + trace_debug ("Storing stop pc (0x%s) in regblock", + paddress (tpoint->address)); + + /* This changes the regblock, not the thread's + regcache. */ + regcache_write_pc (&tregcache, stop_pc); + } + break; + case 'X': + { + struct eval_expr_action *eaction; + + eaction = (struct eval_expr_action *) taction; + + trace_debug ("Want to evaluate expression"); + + err = eval_agent_expr (ctx, tframe, eaction->expr, NULL); + + if (err != expr_eval_no_error) + { + record_tracepoint_error (tpoint, "action expression", err); + return; + } + } + break; + default: + trace_debug ("unknown trace action '%c', ignoring", taction->type); + break; + } +} + +static int +condition_true_at_tracepoint (struct tracepoint_hit_ctx *ctx, + struct tracepoint *tpoint) +{ + ULONGEST value = 0; + enum eval_result_type err; + + err = eval_agent_expr (ctx, NULL, tpoint->cond, &value); + + if (err != expr_eval_no_error) + { + record_tracepoint_error (tpoint, "condition", err); + /* The error case must return false. */ + return 0; + } + + trace_debug ("Tracepoint %d at 0x%s condition evals to %s", + tpoint->number, paddress (tpoint->address), + pulongest (value)); + return (value ? 1 : 0); +} + +/* The packet form of an agent expression consists of an 'X', number + of bytes in expression, a comma, and then the bytes. */ + +static struct agent_expr * +parse_agent_expr (char **actparm) +{ + char *act = *actparm; + ULONGEST xlen; + struct agent_expr *aexpr; + + ++act; /* skip the X */ + act = unpack_varlen_hex (act, &xlen); + ++act; /* skip a comma */ + aexpr = xmalloc (sizeof (struct agent_expr)); + aexpr->length = xlen; + aexpr->bytes = xmalloc (xlen); + convert_ascii_to_int (act, aexpr->bytes, xlen); + *actparm = act + (xlen * 2); + return aexpr; +} + +/* Convert the bytes of an agent expression back into hex digits, so + they can be printed or uploaded. This allocates the buffer, + callers should free when they are done with it. */ + +static char * +unparse_agent_expr (struct agent_expr *aexpr) +{ + char *rslt; + + rslt = xmalloc (2 * aexpr->length + 1); + convert_int_to_ascii (aexpr->bytes, rslt, aexpr->length); + return rslt; +} + +/* The agent expression evaluator, as specified by the GDB docs. It + returns 0 if everything went OK, and a nonzero error code + otherwise. */ + +static enum eval_result_type +eval_agent_expr (struct tracepoint_hit_ctx *ctx, + struct traceframe *tframe, + struct agent_expr *aexpr, + ULONGEST *rslt) +{ + int pc = 0; +#define STACK_MAX 100 + ULONGEST stack[STACK_MAX], top; + int sp = 0; + unsigned char op; + int arg; + + /* This union is a convenient way to convert representations. For + now, assume a standard architecture where the hardware integer + types have 8, 16, 32, 64 bit types. A more robust solution would + be to import stdint.h from gnulib. */ + union + { + union + { + unsigned char bytes[1]; + unsigned char val; + } u8; + union + { + unsigned char bytes[2]; + unsigned short val; + } u16; + union + { + unsigned char bytes[4]; + unsigned int val; + } u32; + union + { + unsigned char bytes[8]; + ULONGEST val; + } u64; + } cnv; + + if (aexpr->length == 0) + { + trace_debug ("empty agent expression"); + return expr_eval_empty_expression; + } + + /* Cache the stack top in its own variable. Much of the time we can + operate on this variable, rather than dinking with the stack. It + needs to be copied to the stack when sp changes. */ + top = 0; + + while (1) + { + op = aexpr->bytes[pc++]; + + trace_debug ("About to interpret byte 0x%x", op); + + switch (op) + { + case gdb_agent_op_add: + top += stack[--sp]; + break; + + case gdb_agent_op_sub: + top = stack[--sp] - top; + break; + + case gdb_agent_op_mul: + top *= stack[--sp]; + break; + + case gdb_agent_op_div_signed: + if (top == 0) + { + trace_debug ("Attempted to divide by zero"); + return expr_eval_divide_by_zero; + } + top = ((LONGEST) stack[--sp]) / ((LONGEST) top); + break; + + case gdb_agent_op_div_unsigned: + if (top == 0) + { + trace_debug ("Attempted to divide by zero"); + return expr_eval_divide_by_zero; + } + top = stack[--sp] / top; + break; + + case gdb_agent_op_rem_signed: + if (top == 0) + { + trace_debug ("Attempted to divide by zero"); + return expr_eval_divide_by_zero; + } + top = ((LONGEST) stack[--sp]) % ((LONGEST) top); + break; + + case gdb_agent_op_rem_unsigned: + if (top == 0) + { + trace_debug ("Attempted to divide by zero"); + return expr_eval_divide_by_zero; + } + top = stack[--sp] % top; + break; + + case gdb_agent_op_lsh: + top = stack[--sp] << top; + break; + + case gdb_agent_op_rsh_signed: + top = ((LONGEST) stack[--sp]) >> top; + break; + + case gdb_agent_op_rsh_unsigned: + top = stack[--sp] >> top; + break; + + case gdb_agent_op_trace: + agent_mem_read (tframe, + NULL, (CORE_ADDR) stack[--sp], (ULONGEST) top); + if (--sp >= 0) + top = stack[sp]; + break; + + case gdb_agent_op_trace_quick: + arg = aexpr->bytes[pc++]; + agent_mem_read (tframe, NULL, (CORE_ADDR) top, (ULONGEST) arg); + break; + + case gdb_agent_op_log_not: + top = !top; + break; + + case gdb_agent_op_bit_and: + top &= stack[--sp]; + break; + + case gdb_agent_op_bit_or: + top |= stack[--sp]; + break; + + case gdb_agent_op_bit_xor: + top ^= stack[--sp]; + break; + + case gdb_agent_op_bit_not: + top = ~top; + break; + + case gdb_agent_op_equal: + top = (stack[--sp] == top); + break; + + case gdb_agent_op_less_signed: + top = (((LONGEST) stack[--sp]) < ((LONGEST) top)); + break; + + case gdb_agent_op_less_unsigned: + top = (stack[--sp] < top); + break; + + case gdb_agent_op_ext: + arg = aexpr->bytes[pc++]; + if (arg < (sizeof (LONGEST) * 8)) + { + LONGEST mask = 1 << (arg - 1); + top &= ((LONGEST) 1 << arg) - 1; + top = (top ^ mask) - mask; + } + break; + + case gdb_agent_op_ref8: + agent_mem_read (tframe, cnv.u8.bytes, (CORE_ADDR) top, 1); + top = cnv.u8.val; + break; + + case gdb_agent_op_ref16: + agent_mem_read (tframe, cnv.u16.bytes, (CORE_ADDR) top, 2); + top = cnv.u16.val; + break; + + case gdb_agent_op_ref32: + agent_mem_read (tframe, cnv.u32.bytes, (CORE_ADDR) top, 4); + top = cnv.u32.val; + break; + + case gdb_agent_op_ref64: + agent_mem_read (tframe, cnv.u64.bytes, (CORE_ADDR) top, 8); + top = cnv.u64.val; + break; + + case gdb_agent_op_if_goto: + if (top) + pc = (aexpr->bytes[pc] << 8) + (aexpr->bytes[pc + 1]); + else + pc += 2; + if (--sp >= 0) + top = stack[sp]; + break; + + case gdb_agent_op_goto: + pc = (aexpr->bytes[pc] << 8) + (aexpr->bytes[pc + 1]); + break; + + case gdb_agent_op_const8: + /* Flush the cached stack top. */ + stack[sp++] = top; + top = aexpr->bytes[pc++]; + break; + + case gdb_agent_op_const16: + /* Flush the cached stack top. */ + stack[sp++] = top; + top = aexpr->bytes[pc++]; + top = (top << 8) + aexpr->bytes[pc++]; + break; + + case gdb_agent_op_const32: + /* Flush the cached stack top. */ + stack[sp++] = top; + top = aexpr->bytes[pc++]; + top = (top << 8) + aexpr->bytes[pc++]; + top = (top << 8) + aexpr->bytes[pc++]; + top = (top << 8) + aexpr->bytes[pc++]; + break; + + case gdb_agent_op_const64: + /* Flush the cached stack top. */ + stack[sp++] = top; + top = aexpr->bytes[pc++]; + top = (top << 8) + aexpr->bytes[pc++]; + top = (top << 8) + aexpr->bytes[pc++]; + top = (top << 8) + aexpr->bytes[pc++]; + top = (top << 8) + aexpr->bytes[pc++]; + top = (top << 8) + aexpr->bytes[pc++]; + top = (top << 8) + aexpr->bytes[pc++]; + top = (top << 8) + aexpr->bytes[pc++]; + break; + + case gdb_agent_op_reg: + /* Flush the cached stack top. */ + stack[sp++] = top; + arg = aexpr->bytes[pc++]; + arg = (arg << 8) + aexpr->bytes[pc++]; + { + int regnum = arg; + struct regcache *regcache; + + regcache = get_context_regcache (ctx); + + switch (register_size (regnum)) + { + case 8: + collect_register (regcache, regnum, cnv.u64.bytes); + top = cnv.u64.val; + break; + case 4: + collect_register (regcache, regnum, cnv.u32.bytes); + top = cnv.u32.val; + break; + case 2: + collect_register (regcache, regnum, cnv.u16.bytes); + top = cnv.u16.val; + break; + case 1: + collect_register (regcache, regnum, cnv.u8.bytes); + top = cnv.u8.val; + break; + default: + internal_error (__FILE__, __LINE__, + "unhandled register size"); + } + } + break; + + case gdb_agent_op_end: + trace_debug ("At end of expression, sp=%d, stack top cache=0x%s", + sp, pulongest (top)); + if (rslt) + { + if (sp <= 0) + { + /* This should be an error */ + trace_debug ("Stack is empty, nothing to return"); + return expr_eval_empty_stack; + } + *rslt = top; + } + return expr_eval_no_error; + + case gdb_agent_op_dup: + stack[sp++] = top; + break; + + case gdb_agent_op_pop: + if (--sp >= 0) + top = stack[sp]; + break; + + case gdb_agent_op_zero_ext: + arg = aexpr->bytes[pc++]; + if (arg < (sizeof (LONGEST) * 8)) + top &= ((LONGEST) 1 << arg) - 1; + break; + + case gdb_agent_op_swap: + /* Interchange top two stack elements, making sure top gets + copied back onto stack. */ + stack[sp] = top; + top = stack[sp - 1]; + stack[sp - 1] = stack[sp]; + break; + + case gdb_agent_op_getv: + /* Flush the cached stack top. */ + stack[sp++] = top; + arg = aexpr->bytes[pc++]; + arg = (arg << 8) + aexpr->bytes[pc++]; + top = get_trace_state_variable_value (arg); + break; + + case gdb_agent_op_setv: + arg = aexpr->bytes[pc++]; + arg = (arg << 8) + aexpr->bytes[pc++]; + set_trace_state_variable_value (arg, top); + /* Note that we leave the value on the stack, for the + benefit of later/enclosing expressions. */ + break; + + case gdb_agent_op_tracev: + arg = aexpr->bytes[pc++]; + arg = (arg << 8) + aexpr->bytes[pc++]; + agent_tsv_read (tframe, arg); + break; + + /* GDB never (currently) generates any of these ops. */ + case gdb_agent_op_float: + case gdb_agent_op_ref_float: + case gdb_agent_op_ref_double: + case gdb_agent_op_ref_long_double: + case gdb_agent_op_l_to_d: + case gdb_agent_op_d_to_l: + case gdb_agent_op_trace16: + trace_debug ("Agent expression op 0x%x valid, but not handled", + op); + /* If ever GDB generates any of these, we don't have the + option of ignoring. */ + return 1; + + default: + trace_debug ("Agent expression op 0x%x not recognized", op); + /* Don't struggle on, things will just get worse. */ + return expr_eval_unrecognized_opcode; + } + + /* Check for stack badness. */ + if (sp >= (STACK_MAX - 1)) + { + trace_debug ("Expression stack overflow"); + return expr_eval_stack_overflow; + } + + if (sp < 0) + { + trace_debug ("Expression stack underflow"); + return expr_eval_stack_underflow; + } + + trace_debug ("Op %s -> sp=%d, top=0x%s", + gdb_agent_op_names[op], sp, pulongest (top)); + } +} + +/* Do memory copies for bytecodes. */ +/* Do the recording of memory blocks for actions and bytecodes. */ + +static int +agent_mem_read (struct traceframe *tframe, + unsigned char *to, CORE_ADDR from, ULONGEST len) +{ + unsigned char *mspace; + ULONGEST remaining = len; + unsigned short blocklen; + + /* If a 'to' buffer is specified, use it. */ + if (to != NULL) + { + read_inferior_memory (from, to, len); + return 0; + } + + /* Otherwise, create a new memory block in the trace buffer. */ + while (remaining > 0) + { + size_t sp; + + blocklen = (remaining > 65535 ? 65535 : remaining); + sp = 1 + sizeof (from) + sizeof (blocklen) + blocklen; + mspace = add_traceframe_block (tframe, sp); + if (mspace == NULL) + return 1; + /* Identify block as a memory block. */ + *mspace = 'M'; + ++mspace; + /* Record address and size. */ + memcpy (mspace, &from, sizeof (from)); + mspace += sizeof (from); + memcpy (mspace, &blocklen, sizeof (blocklen)); + mspace += sizeof (blocklen); + /* Record the memory block proper. */ + read_inferior_memory (from, mspace, blocklen); + trace_debug ("%d bytes recorded", blocklen); + remaining -= blocklen; + from += blocklen; + } + return 0; +} + +/* Record the value of a trace state variable. */ + +static int +agent_tsv_read (struct traceframe *tframe, int n) +{ + unsigned char *vspace; + LONGEST val; + + vspace = add_traceframe_block (tframe, + 1 + sizeof (n) + sizeof (LONGEST)); + if (vspace == NULL) + return 1; + /* Identify block as a variable. */ + *vspace = 'V'; + /* Record variable's number and value. */ + memcpy (vspace + 1, &n, sizeof (n)); + val = get_trace_state_variable_value (n); + memcpy (vspace + 1 + sizeof (n), &val, sizeof (val)); + trace_debug ("Variable %d recorded", n); + return 0; +} + +static unsigned char * +traceframe_find_block_type (unsigned char *database, unsigned int datasize, + int tfnum, char type_wanted) +{ + unsigned char *dataptr; + + if (datasize == 0) + { + trace_debug ("traceframe %d has no data", tfnum); + return NULL; + } + + /* Iterate through a traceframe's blocks, looking for a block of the + requested type. */ + for (dataptr = database; + dataptr < database + datasize; + /* nothing */) + { + char blocktype; + unsigned short mlen; + + if (dataptr == trace_buffer_wrap) + { + /* Adjust to reflect wrapping part of the frame around to + the beginning. */ + datasize = dataptr - database; + dataptr = database = trace_buffer_lo; + } + blocktype = *dataptr++; + + if (type_wanted == blocktype) + return dataptr; + + switch (blocktype) + { + case 'R': + /* Skip over the registers block. */ + dataptr += register_cache_size (); + break; + case 'M': + /* Skip over the memory block. */ + dataptr += sizeof (CORE_ADDR); + memcpy (&mlen, dataptr, sizeof (mlen)); + dataptr += (sizeof (mlen) + mlen); + break; + case 'S': + /* Skip over the static trace data block. */ + memcpy (&mlen, dataptr, sizeof (mlen)); + dataptr += (sizeof (mlen) + mlen); + break; + case 'V': + /* Skip over the TSV block. */ + dataptr += (sizeof (int) + sizeof (LONGEST)); + break; + default: + trace_debug ("traceframe %d has unknown block type 0x%x", + tfnum, blocktype); + return NULL; + } + } + + return NULL; +} + +static unsigned char * +traceframe_find_regblock (struct traceframe *tframe, int tfnum) +{ + unsigned char *regblock; + + regblock = traceframe_find_block_type (tframe->data, + tframe->data_size, + tfnum, 'R'); + + if (regblock == NULL) + trace_debug ("traceframe %d has no register data", tfnum); + + return regblock; +} + +/* Get registers from a traceframe. */ + +int +fetch_traceframe_registers (int tfnum, struct regcache *regcache, int regnum) +{ + unsigned char *dataptr; + struct tracepoint *tpoint; + struct traceframe *tframe; + + tframe = find_traceframe (tfnum); + + if (tframe == NULL) + { + trace_debug ("traceframe %d not found", tfnum); + return 1; + } + + dataptr = traceframe_find_regblock (tframe, tfnum); + if (dataptr == NULL) + { + /* We don't like making up numbers, but GDB has all manner of + troubles when the target says there are no registers. */ + supply_regblock (regcache, NULL); + + /* We can generally guess at a PC, although this will be + misleading for while-stepping frames and multi-location + tracepoints. */ + tpoint = find_next_tracepoint_by_number (NULL, tframe->tpnum); + if (tpoint != NULL) + regcache_write_pc (regcache, tpoint->address); + } + else + supply_regblock (regcache, dataptr); + + return 0; +} + +static CORE_ADDR +traceframe_get_pc (struct traceframe *tframe) +{ + struct regcache regcache; + unsigned char *dataptr; + + dataptr = traceframe_find_regblock (tframe, -1); + if (dataptr == NULL) + return 0; + + init_register_cache (®cache, dataptr); + return regcache_read_pc (®cache); +} + +/* Read a requested block of memory from a trace frame. */ + +int +traceframe_read_mem (int tfnum, CORE_ADDR addr, + unsigned char *buf, ULONGEST length, + ULONGEST *nbytes) +{ + struct traceframe *tframe; + unsigned char *database, *dataptr; + unsigned int datasize; + CORE_ADDR maddr; + unsigned short mlen; + + trace_debug ("traceframe_read_mem"); + + tframe = find_traceframe (tfnum); + + if (!tframe) + { + trace_debug ("traceframe %d not found", tfnum); + return 1; + } + + datasize = tframe->data_size; + database = dataptr = &tframe->data[0]; + + /* Iterate through a traceframe's blocks, looking for memory. */ + while ((dataptr = traceframe_find_block_type (dataptr, + datasize - (dataptr - database), + tfnum, 'M')) != NULL) + { + memcpy (&maddr, dataptr, sizeof (maddr)); + dataptr += sizeof (maddr); + memcpy (&mlen, dataptr, sizeof (mlen)); + dataptr += sizeof (mlen); + trace_debug ("traceframe %d has %d bytes at %s", + tfnum, mlen, paddress (maddr)); + + /* Check that requested data is in bounds. */ + if (maddr <= addr && (addr + length) <= (maddr + mlen)) + { + /* Block includes the requested range, copy it out. */ + memcpy (buf, dataptr + (addr - maddr), length); + *nbytes = length; + return 0; + } + + /* Skip over this block. */ + dataptr += mlen; + } + + trace_debug ("traceframe %d has no memory data for the desired region", + tfnum); + + *nbytes = 0; + return 0; +} + +static int +traceframe_read_tsv (int tsvnum, LONGEST *val) +{ + int tfnum; + struct traceframe *tframe; + unsigned char *database, *dataptr; + unsigned int datasize; + int vnum; + + trace_debug ("traceframe_read_tsv"); + + tfnum = current_traceframe; + + if (tfnum < 0) + { + trace_debug ("no current traceframe"); + return 1; + } + + tframe = find_traceframe (tfnum); + + if (tframe == NULL) + { + trace_debug ("traceframe %d not found", tfnum); + return 1; + } + + datasize = tframe->data_size; + database = dataptr = &tframe->data[0]; + + /* Iterate through a traceframe's blocks, looking for the tsv. */ + while ((dataptr = traceframe_find_block_type (dataptr, + datasize - (dataptr - database), + tfnum, 'V')) != NULL) + { + memcpy (&vnum, dataptr, sizeof (vnum)); + dataptr += sizeof (vnum); + + trace_debug ("traceframe %d has variable %d", tfnum, vnum); + + /* Check that this is the variable we want. */ + if (tsvnum == vnum) + { + memcpy (val, dataptr, sizeof (*val)); + return 0; + } + + /* Skip over this block. */ + dataptr += sizeof (LONGEST); + } + + trace_debug ("traceframe %d has no data for variable %d", + tfnum, tsvnum); + return 1; +} + +static LONGEST +tsv_get_timestamp (void) +{ + struct timeval tv; + + if (gettimeofday (&tv, 0) != 0) + return -1; + else + return (LONGEST) tv.tv_sec * 1000000 + tv.tv_usec; +} + +void +initialize_tracepoint (void) +{ + /* There currently no way to change the buffer size. */ + const int sizeOfBuffer = 5 * 1024 * 1024; + unsigned char *buf = xmalloc (sizeOfBuffer); + init_trace_buffer (buf, sizeOfBuffer); + + /* Wire trace state variable 1 to be the timestamp. This will be + uploaded to GDB upon connection and become one of its trace state + variables. (In case you're wondering, if GDB already has a trace + variable numbered 1, it will be renumbered.) */ + create_trace_state_variable (1); + set_trace_state_variable_name (1, "trace_timestamp"); + set_trace_state_variable_getter (1, tsv_get_timestamp); +} diff --git a/gdb/gdbserver/utils.c b/gdb/gdbserver/utils.c index 78c6f66..33671e5 100644 --- a/gdb/gdbserver/utils.c +++ b/gdb/gdbserver/utils.c @@ -57,6 +57,26 @@ xmalloc (size_t size) return newmem; } +/* Reallocate memory without fail. This works like xmalloc. */ + +void * +xrealloc (void *ptr, size_t size) +{ + void *val; + + if (size == 0) + size = 1; + + if (ptr != NULL) + val = realloc (ptr, size); /* OK: realloc */ + else + val = malloc (size); /* OK: malloc */ + if (val == NULL) + malloc_failure (size); + + return val; +} + /* Allocate memory without fail and set it to zero. If malloc fails, this will print a message to stderr and exit. */ @@ -229,3 +249,108 @@ paddress (CORE_ADDR addr) xsnprintf (str, CELLSIZE, "%lx", (long) addr); return str; } + +static char * +decimal2str (char *sign, ULONGEST addr, int width) +{ + /* Steal code from valprint.c:print_decimal(). Should this worry + about the real size of addr as the above does? */ + unsigned long temp[3]; + char *str = get_cell (); + + int i = 0; + do + { + temp[i] = addr % (1000 * 1000 * 1000); + addr /= (1000 * 1000 * 1000); + i++; + width -= 9; + } + while (addr != 0 && i < (sizeof (temp) / sizeof (temp[0]))); + + width = 9; + if (width < 0) + width = 0; + + switch (i) + { + case 1: + xsnprintf (str, CELLSIZE, "%s%0*lu", sign, width, temp[0]); + break; + case 2: + xsnprintf (str, CELLSIZE, "%s%0*lu%09lu", sign, width, + temp[1], temp[0]); + break; + case 3: + xsnprintf (str, CELLSIZE, "%s%0*lu%09lu%09lu", sign, width, + temp[2], temp[1], temp[0]); + break; + default: + internal_error (__FILE__, __LINE__, + "failed internal consistency check"); + } + + return str; +} + +/* %u for ULONGEST. The result is stored in a circular static buffer, + NUMCELLS deep. */ + +char * +pulongest (ULONGEST u) +{ + return decimal2str ("", u, 0); +} + +/* %d for LONGEST. The result is stored in a circular static buffer, + NUMCELLS deep. */ + +char * +plongest (LONGEST l) +{ + if (l < 0) + return decimal2str ("-", -l, 0); + else + return decimal2str ("", l, 0); +} + +/* Eliminate warning from compiler on 32-bit systems. */ +static int thirty_two = 32; + +/* Convert a ULONGEST into a HEX string, like %lx. The result is + stored in a circular static buffer, NUMCELLS deep. */ + +char * +phex_nz (ULONGEST l, int sizeof_l) +{ + char *str; + + switch (sizeof_l) + { + case 8: + { + unsigned long high = (unsigned long) (l >> thirty_two); + str = get_cell (); + if (high == 0) + xsnprintf (str, CELLSIZE, "%lx", + (unsigned long) (l & 0xffffffff)); + else + xsnprintf (str, CELLSIZE, "%lx%08lx", high, + (unsigned long) (l & 0xffffffff)); + break; + } + case 4: + str = get_cell (); + xsnprintf (str, CELLSIZE, "%lx", (unsigned long) l); + break; + case 2: + str = get_cell (); + xsnprintf (str, CELLSIZE, "%x", (unsigned short) (l & 0xffff)); + break; + default: + str = phex_nz (l, sizeof (l)); + break; + } + + return str; +} diff --git a/gdb/regformats/regdat.sh b/gdb/regformats/regdat.sh index 18c8189..ee15f8d 100755 --- a/gdb/regformats/regdat.sh +++ b/gdb/regformats/regdat.sh @@ -119,8 +119,8 @@ EOF exec > new-$2 copyright $1 +echo '#include "server.h"' echo '#include "regdef.h"' -echo '#include "regcache.h"' echo offset=0 i=0 |