X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Ftarget.h;h=272571b75020ae085e665f0023f33f595c40720c;hb=3c0ee1a46468d89b8865cd70616af4558c499b16;hp=b1cb8523b56cf3a11b8802218bab8bbd9854484e;hpb=a96d9b2e9a79e6cc7a9da9b4e5bab6fcc35f1eb4;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/target.h b/gdb/target.h index b1cb8523b5..272571b750 100644 --- a/gdb/target.h +++ b/gdb/target.h @@ -1,7 +1,7 @@ /* Interface between GDB and target environments, including files and processes Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, - 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 + 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc. Contributed by Cygnus Support. Written by John Gilmore. @@ -31,6 +31,10 @@ struct target_ops; struct bp_target_info; struct regcache; struct target_section_table; +struct trace_state_variable; +struct trace_status; +struct uploaded_tsv; +struct uploaded_tp; /* This include file defines the interface between the main part of the debugger, and the part which is target-specific, or @@ -110,6 +114,15 @@ enum target_waitkind TARGET_WAITKIND_EXECD, + /* The program had previously vforked, and now the child is done + with the shared memory region, because it exec'ed or exited. + Note that the event is reported to the vfork parent. This is + only used if GDB did not stay attached to the vfork child, + otherwise, a TARGET_WAITKIND_EXECD or + TARGET_WAITKIND_EXIT|SIGNALLED event associated with the child + has the same effect. */ + TARGET_WAITKIND_VFORK_DONE, + /* The program has entered or returned from a system call. On HP-UX, this is used in the hardware watchpoint implementation. The syscall's unique integer ID number is in value.syscall_id */ @@ -246,9 +259,23 @@ enum target_object /* Extra signal info. Usually the contents of `siginfo_t' on unix platforms. */ TARGET_OBJECT_SIGNAL_INFO, + /* The list of threads that are being debugged. */ + TARGET_OBJECT_THREADS, /* Possible future objects: TARGET_OBJECT_FILE, ... */ }; +/* Enumeration of the kinds of traceframe searches that a target may + be able to perform. */ + +enum trace_find_type + { + tfind_number, + tfind_pc, + tfind_tp, + tfind_range, + tfind_outside, + }; + /* Request that OPS transfer up to LEN 8-bit bytes of the target's OBJECT. The OFFSET, for a seekable object, specifies the starting point. The ANNEX can be used to provide additional @@ -450,13 +477,18 @@ struct target_ops void (*to_async) (void (*) (enum inferior_event_type, void *), void *); int (*to_async_mask) (int); int (*to_supports_non_stop) (void); + /* find_memory_regions support method for gcore */ int (*to_find_memory_regions) (int (*) (CORE_ADDR, unsigned long, int, int, int, void *), void *); + /* make_corefile_notes support method for gcore */ char * (*to_make_corefile_notes) (bfd *, int *); - + /* get_bookmark support method for bookmarks */ + gdb_byte * (*to_get_bookmark) (char *, int); + /* goto_bookmark support method for bookmarks */ + void (*to_goto_bookmark) (gdb_byte *, int); /* Return the thread-local address at OFFSET in the thread-local storage for the thread PTID and the shared library or executable file given by OBJFILE. If that block of @@ -576,6 +608,84 @@ struct target_ops The default implementation always returns target_gdbarch. */ struct gdbarch *(*to_thread_architecture) (struct target_ops *, ptid_t); + /* Determine current address space of thread PTID. + + The default implementation always returns the inferior's + address space. */ + struct address_space *(*to_thread_address_space) (struct target_ops *, + ptid_t); + + /* Tracepoint-related operations. */ + + /* Prepare the target for a tracing run. */ + void (*to_trace_init) (void); + + /* Send full details of a tracepoint to the target. */ + void (*to_download_tracepoint) (struct breakpoint *t); + + /* Send full details of a trace state variable to the target. */ + void (*to_download_trace_state_variable) (struct trace_state_variable *tsv); + + /* Inform the target info of memory regions that are readonly + (such as text sections), and so it should return data from + those rather than look in the trace buffer. */ + void (*to_trace_set_readonly_regions) (void); + + /* Start a trace run. */ + void (*to_trace_start) (void); + + /* Get the current status of a tracing run. */ + int (*to_get_trace_status) (struct trace_status *ts); + + /* Stop a trace run. */ + void (*to_trace_stop) (void); + + /* Ask the target to find a trace frame of the given type TYPE, + using NUM, ADDR1, and ADDR2 as search parameters. Returns the + number of the trace frame, and also the tracepoint number at + TPP. If no trace frame matches, return -1. May throw if the + operation fails. */ + int (*to_trace_find) (enum trace_find_type type, int num, + ULONGEST addr1, ULONGEST addr2, int *tpp); + + /* Get the value of the trace state variable number TSV, returning + 1 if the value is known and writing the value itself into the + location pointed to by VAL, else returning 0. */ + int (*to_get_trace_state_variable_value) (int tsv, LONGEST *val); + + int (*to_save_trace_data) (const char *filename); + + int (*to_upload_tracepoints) (struct uploaded_tp **utpp); + + int (*to_upload_trace_state_variables) (struct uploaded_tsv **utsvp); + + LONGEST (*to_get_raw_trace_data) (gdb_byte *buf, + ULONGEST offset, LONGEST len); + + /* Set the target's tracing behavior in response to unexpected + disconnection - set VAL to 1 to keep tracing, 0 to stop. */ + void (*to_set_disconnected_tracing) (int val); + void (*to_set_circular_trace_buffer) (int val); + + /* Return the processor core that thread PTID was last seen on. + This information is updated only when: + - update_thread_list is called + - thread stops + If the core cannot be determined -- either for the specified thread, or + right now, or in this debug session, or for this target -- return -1. */ + int (*to_core_of_thread) (struct target_ops *, ptid_t ptid); + + /* Verify that the memory in the [MEMADDR, MEMADDR+SIZE) range + matches the contents of [DATA,DATA+SIZE). Returns 1 if there's + a match, 0 if there's a mismatch, and -1 if an error is + encountered while reading memory. */ + int (*to_verify_memory) (struct target_ops *, const gdb_byte *data, + CORE_ADDR memaddr, ULONGEST size); + + /* Return the address of the start of the Thread Information Block + a Windows OS specific feature. */ + int (*to_get_tib_address) (ptid_t ptid, CORE_ADDR *addr); + int to_magic; /* Need sub-structure for target machine related rather than comm related? */ @@ -685,6 +795,10 @@ extern void target_store_registers (struct regcache *regcache, int regs); #define target_prepare_to_store(regcache) \ (*current_target.to_prepare_to_store) (regcache) +/* Determine current address space of thread PTID. */ + +struct address_space *target_thread_address_space (ptid_t); + /* Returns true if this target can debug multiple processes simultaneously. */ @@ -1121,10 +1235,17 @@ extern char *normal_pid_to_str (ptid_t ptid); #define target_make_corefile_notes(BFD, SIZE_P) \ (current_target.to_make_corefile_notes) (BFD, SIZE_P) +/* Bookmark interfaces. */ +#define target_get_bookmark(ARGS, FROM_TTY) \ + (current_target.to_get_bookmark) (ARGS, FROM_TTY) + +#define target_goto_bookmark(ARG, FROM_TTY) \ + (current_target.to_goto_bookmark) (ARG, FROM_TTY) + /* Hardware watchpoint interfaces. */ /* Returns non-zero if we were stopped by a hardware watchpoint (memory read or - write). */ + write). Only the INFERIOR_PTID task is being queried. */ #define target_stopped_by_watchpoint \ (*current_target.to_stopped_by_watchpoint) @@ -1156,9 +1277,10 @@ extern char *normal_pid_to_str (ptid_t ptid); (*current_target.to_region_ok_for_hw_watchpoint) (addr, len) -/* Set/clear a hardware watchpoint starting at ADDR, for LEN bytes. TYPE is 0 - for write, 1 for read, and 2 for read/write accesses. Returns 0 for - success, non-zero for failure. */ +/* Set/clear a hardware watchpoint starting at ADDR, for LEN bytes. + TYPE is 0 for write, 1 for read, and 2 for read/write accesses. + Returns 0 for success, 1 if the watchpoint type is not supported, + -1 for failure. */ #define target_insert_watchpoint(addr, len, type) \ (*current_target.to_insert_watchpoint) (addr, len, type) @@ -1172,8 +1294,11 @@ extern char *normal_pid_to_str (ptid_t ptid); #define target_remove_hw_breakpoint(gdbarch, bp_tgt) \ (*current_target.to_remove_hw_breakpoint) (gdbarch, bp_tgt) -#define target_stopped_data_address(target, x) \ - (*target.to_stopped_data_address) (target, x) +/* Return non-zero if target knows the data address which triggered this + target_stopped_by_watchpoint, in such case place it to *ADDR_P. Only the + INFERIOR_PTID task is being queried. */ +#define target_stopped_data_address(target, addr_p) \ + (*target.to_stopped_data_address) (target, addr_p) #define target_watchpoint_addr_within_range(target, addr, start, length) \ (*target.to_watchpoint_addr_within_range) (target, addr, start, length) @@ -1203,6 +1328,56 @@ extern int target_search_memory (CORE_ADDR start_addr, ULONGEST pattern_len, CORE_ADDR *found_addrp); +/* Tracepoint-related operations. */ + +#define target_trace_init() \ + (*current_target.to_trace_init) () + +#define target_download_tracepoint(t) \ + (*current_target.to_download_tracepoint) (t) + +#define target_download_trace_state_variable(tsv) \ + (*current_target.to_download_trace_state_variable) (tsv) + +#define target_trace_start() \ + (*current_target.to_trace_start) () + +#define target_trace_set_readonly_regions() \ + (*current_target.to_trace_set_readonly_regions) () + +#define target_get_trace_status(ts) \ + (*current_target.to_get_trace_status) (ts) + +#define target_trace_stop() \ + (*current_target.to_trace_stop) () + +#define target_trace_find(type,num,addr1,addr2,tpp) \ + (*current_target.to_trace_find) ((type), (num), (addr1), (addr2), (tpp)) + +#define target_get_trace_state_variable_value(tsv,val) \ + (*current_target.to_get_trace_state_variable_value) ((tsv), (val)) + +#define target_save_trace_data(filename) \ + (*current_target.to_save_trace_data) (filename) + +#define target_upload_tracepoints(utpp) \ + (*current_target.to_upload_tracepoints) (utpp) + +#define target_upload_trace_state_variables(utsvp) \ + (*current_target.to_upload_trace_state_variables) (utsvp) + +#define target_get_raw_trace_data(buf,offset,len) \ + (*current_target.to_get_raw_trace_data) ((buf), (offset), (len)) + +#define target_set_disconnected_tracing(val) \ + (*current_target.to_set_disconnected_tracing) (val) + +#define target_set_circular_trace_buffer(val) \ + (*current_target.to_set_circular_trace_buffer) (val) + +#define target_get_tib_address(ptid, addr) \ + (*current_target.to_get_tib_address) ((ptid), (addr)) + /* Command logging facility. */ #define target_log_command(p) \ @@ -1211,6 +1386,17 @@ extern int target_search_memory (CORE_ADDR start_addr, (*current_target.to_log_command) (p); \ while (0) + +extern int target_core_of_thread (ptid_t ptid); + +/* Verify that the memory in the [MEMADDR, MEMADDR+SIZE) range matches + the contents of [DATA,DATA+SIZE). Returns 1 if there's a match, 0 + if there's a mismatch, and -1 if an error is encountered while + reading memory. Throws an error if the functionality is found not + to be supported by the current target. */ +int target_verify_memory (const gdb_byte *data, + CORE_ADDR memaddr, ULONGEST size); + /* Routines for maintenance of the target structures... add_target: Add a target to the list of all possible targets.