OpenOCD
target.h
Go to the documentation of this file.
1 /* SPDX-License-Identifier: GPL-2.0-or-later */
2 
3 /***************************************************************************
4  * Copyright (C) 2005 by Dominic Rath *
5  * Dominic.Rath@gmx.de *
6  * *
7  * Copyright (C) 2007-2010 Øyvind Harboe *
8  * oyvind.harboe@zylin.com *
9  * *
10  * Copyright (C) 2008 by Spencer Oliver *
11  * spen@spen-soft.co.uk *
12  * *
13  * Copyright (C) 2011 by Broadcom Corporation *
14  * Evan Hunter - ehunter@broadcom.com *
15  * *
16  * Copyright (C) ST-Ericsson SA 2011 *
17  * michel.jaouen@stericsson.com : smp minimum support *
18  ***************************************************************************/
19 
20 #ifndef OPENOCD_TARGET_TARGET_H
21 #define OPENOCD_TARGET_TARGET_H
22 
23 #include <helper/list.h>
24 #include "helper/replacements.h"
25 #include "helper/system.h"
26 #include <jim.h>
27 
28 struct reg;
29 struct trace;
30 struct command_context;
31 struct command_invocation;
32 struct breakpoint;
33 struct watchpoint;
34 struct mem_param;
35 struct reg_param;
36 struct target_list;
37 struct gdb_fileio_info;
38 
39 /*
40  * TARGET_UNKNOWN = 0: we don't know anything about the target yet
41  * TARGET_RUNNING = 1: the target is executing or ready to execute user code
42  * TARGET_HALTED = 2: the target is not executing code, and ready to talk to the
43  * debugger. on an xscale it means that the debug handler is executing
44  * TARGET_RESET = 3: the target is being held in reset (only a temporary state,
45  * not sure how this is used with all the recent changes)
46  * TARGET_DEBUG_RUNNING = 4: the target is running, but it is executing code on
47  * behalf of the debugger (e.g. algorithm for flashing)
48  *
49  * also see: target_state_name();
50  */
51 
58 };
59 
60 enum nvp_assert {
63 };
64 
67  RESET_RUN = 1, /* reset and let target run */
68  RESET_HALT = 2, /* reset and halt target out of reset */
69  RESET_INIT = 3, /* reset and halt target out of reset, then run init script */
70 };
71 
82 };
83 
87 };
88 
89 struct working_area {
91  uint32_t size;
92  bool free;
93  uint8_t *backup;
94  struct working_area **user;
95  struct working_area *next;
96 };
97 
98 struct gdb_service {
99  struct target *target;
100  /* field for smp display */
101  /* element 0 coreid currently displayed ( 1 till n) */
102  /* element 1 coreid to be displayed at next resume 1 till n 0 means resume
103  * all cores core displayed */
104  int32_t core[2];
105 };
106 
107 /* target back off timer */
109  int times;
110  int count;
111 };
112 
113 /* split target registers into multiple class */
117 };
118 
119 /* target_type.h contains the full definition of struct target_type */
120 struct target {
121  struct target_type *type; /* target type definition (name, access functions) */
122  char *cmd_name; /* tcl Name of target */
123  int target_number; /* DO NOT USE! field to be removed in 2010 */
124  struct jtag_tap *tap; /* where on the jtag chain is this */
125  int32_t coreid; /* which device on the TAP? */
126 
129 
136  bool examined;
137 
146 
148 
149  bool reset_halt; /* attempt resetting the CPU into the halted mode? */
150  target_addr_t working_area; /* working area (initialised RAM). Evaluated
151  * upon first allocation from virtual/physical address. */
152  bool working_area_virt_spec; /* virtual address specified? */
153  target_addr_t working_area_virt; /* virtual address */
154  bool working_area_phys_spec; /* physical address specified? */
155  target_addr_t working_area_phys; /* physical address */
156  uint32_t working_area_size; /* size in bytes */
157  uint32_t backup_working_area; /* whether the content of the working area has to be preserved */
158  struct working_area *working_areas;/* list of allocated working areas */
159  enum target_debug_reason debug_reason;/* reason why the target entered debug state */
160  enum target_endianness endianness; /* target endianness */
161  /* also see: target_state_name() */
162  enum target_state state; /* the current backend-state (running, halted, ...) */
163  struct reg_cache *reg_cache; /* the first register cache of the target (core regs) */
164  struct breakpoint *breakpoints; /* list of breakpoints */
165  struct watchpoint *watchpoints; /* list of watchpoints */
166  struct trace *trace_info; /* generic trace information */
167  struct debug_msg_receiver *dbgmsg; /* list of debug message receivers */
168  uint32_t dbg_msg_enabled; /* debug message status */
169  void *arch_info; /* architecture specific information */
170  void *private_config; /* pointer to target specific config data (for jim_configure hook) */
171  struct target *next; /* next target in list */
172 
173  bool verbose_halt_msg; /* display async info in telnet session. Do not display
174  * lots of halted/resumed info when stepping in debugger. */
175  bool halt_issued; /* did we transition to halted state? */
176  int64_t halt_issued_time; /* Note time when halt was issued */
177 
178  /* ARM v7/v8 targets with ADIv5 interface */
179  bool dbgbase_set; /* By default the debug base is not set */
180  uint32_t dbgbase; /* Really a Cortex-A specific option, but there is no
181  * system in place to support target specific options
182  * currently. */
183  bool has_dap; /* set to true if target has ADIv5 support */
184  bool dap_configured; /* set to true if ADIv5 DAP is configured */
185  bool tap_configured; /* set to true if JTAG tap has been configured
186  * through -chain-position */
187 
188  struct rtos *rtos; /* Instance of Real Time Operating System support */
189  bool rtos_auto_detect; /* A flag that indicates that the RTOS has been specified as "auto"
190  * and must be detected when symbols are offered */
191  struct backoff_timer backoff;
192  int smp; /* Unique non-zero number for each SMP group */
193  struct list_head *smp_targets; /* list all targets in this smp group/cluster
194  * The head of the list is shared between the
195  * cluster, thus here there is a pointer */
196  /* the gdb service is there in case of smp, we have only one gdb server
197  * for all smp target
198  * the target attached to the gdb is changing dynamically by changing
199  * gdb_service->target pointer */
201 
202  /* file-I/O information for host to do syscall */
204 
205  char *gdb_port_override; /* target-specific override for gdb_port */
206 
207  int gdb_max_connections; /* max number of simultaneous gdb connections */
208 
209  /* The semihosting information, extracted from the target. */
211 };
212 
213 struct target_list {
214  struct list_head lh;
215  struct target *target;
216 };
217 
219  char *identifier;
220  uint64_t param_1;
221  uint64_t param_2;
222  uint64_t param_3;
223  uint64_t param_4;
224 };
225 
227 static inline const char *target_endianness(struct target *target)
228 {
229  return (target->endianness == TARGET_ENDIAN_UNKNOWN) ? "unknown" :
230  (target->endianness == TARGET_BIG_ENDIAN) ? "big endian" : "little endian";
231 }
232 
234 static inline const char *target_name(struct target *target)
235 {
236  return target->cmd_name;
237 }
238 
239 const char *debug_reason_name(struct target *t);
240 
242 
243  /* allow GDB to do stuff before others handle the halted event,
244  * this is in lieu of defining ordering of invocation of events,
245  * which would be more complicated
246  *
247  * Telling GDB to halt does not mean that the target stopped running,
248  * simply that we're dropping out of GDB's waiting for step or continue.
249  *
250  * This can be useful when e.g. detecting power dropout.
251  */
253  TARGET_EVENT_HALTED, /* target entered debug state from normal execution or reset */
254  TARGET_EVENT_RESUMED, /* target resumed to normal execution */
259 
260  TARGET_EVENT_GDB_START, /* debugger started execution (step/run) */
261  TARGET_EVENT_GDB_END, /* debugger stopped execution (step/run) */
262 
265  TARGET_EVENT_RESET_ASSERT, /* C code uses this instead of SRST */
271 
272  TARGET_EVENT_DEBUG_HALTED, /* target entered debug state, but was executing on behalf of the debugger */
273  TARGET_EVENT_DEBUG_RESUMED, /* target resumed to execute on behalf of the debugger */
274 
278 
281 
286 
288 
289  TARGET_EVENT_SEMIHOSTING_USER_CMD_0X100 = 0x100, /* semihosting allows user cmds from 0x100 to 0x1ff */
297 };
298 
300  enum target_event event;
301  Jim_Interp *interp;
302  Jim_Obj *body;
304 };
305 
307 
309  int (*callback)(struct target *target, enum target_event event, void *priv);
310  void *priv;
312 };
313 
315  struct list_head list;
316  void *priv;
317  int (*callback)(struct target *target, enum target_reset_mode reset_mode, void *priv);
318 };
319 
321  struct list_head list;
322  void *priv;
323  int (*callback)(struct target *target, size_t len, uint8_t *data, void *priv);
324 };
325 
329 };
330 
332  int (*callback)(void *priv);
333  unsigned int time_ms;
334  enum target_timer_type type;
335  bool removed;
336  int64_t when; /* output of timeval_ms() */
337  void *priv;
339 };
340 
343  uint32_t size;
344  uint32_t result;
345 };
346 
347 int target_register_commands(struct command_context *cmd_ctx);
348 int target_examine(void);
349 
351  int (*callback)(struct target *target,
352  enum target_event event, void *priv),
353  void *priv);
355  int (*callback)(struct target *target,
356  enum target_event event, void *priv),
357  void *priv);
358 
360  int (*callback)(struct target *target,
361  enum target_reset_mode reset_mode, void *priv),
362  void *priv);
364  int (*callback)(struct target *target,
365  enum target_reset_mode reset_mode, void *priv),
366  void *priv);
367 
369  int (*callback)(struct target *target,
370  size_t len, uint8_t *data, void *priv),
371  void *priv);
373  int (*callback)(struct target *target,
374  size_t len, uint8_t *data, void *priv),
375  void *priv);
376 
377 /* Poll the status of the target, detect any error conditions and report them.
378  *
379  * Also note that this fn will clear such error conditions, so a subsequent
380  * invocation will then succeed.
381  *
382  * These error conditions can be "sticky" error conditions. E.g. writing
383  * to memory could be implemented as an open loop and if memory writes
384  * fails, then a note is made of it, the error is sticky, but the memory
385  * write loop still runs to completion. This improves performance in the
386  * normal case as there is no need to verify that every single write succeed,
387  * yet it is possible to detect error conditions.
388  */
389 int target_poll(struct target *target);
390 int target_resume(struct target *target, int current, target_addr_t address,
391  int handle_breakpoints, int debug_execution);
392 int target_halt(struct target *target);
393 int target_call_event_callbacks(struct target *target, enum target_event event);
394 int target_call_reset_callbacks(struct target *target, enum target_reset_mode reset_mode);
395 int target_call_trace_callbacks(struct target *target, size_t len, uint8_t *data);
396 
401 int target_register_timer_callback(int (*callback)(void *priv),
402  unsigned int time_ms, enum target_timer_type type, void *priv);
403 int target_unregister_timer_callback(int (*callback)(void *priv), void *priv);
414 int64_t target_timer_next_event(void);
415 
416 struct target *get_target_by_num(int num);
417 struct target *get_current_target(struct command_context *cmd_ctx);
418 struct target *get_current_target_or_null(struct command_context *cmd_ctx);
419 struct target *get_target(const char *id);
420 
427 const char *target_type_name(struct target *target);
428 
435 int target_examine_one(struct target *target);
436 
438 static inline bool target_was_examined(struct target *target)
439 {
440  return target->examined;
441 }
442 
445 static inline void target_set_examined(struct target *target)
446 {
447  target->examined = true;
448 }
449 
456  struct breakpoint *breakpoint);
463  struct breakpoint *breakpoint);
470  struct breakpoint *breakpoint);
478  struct breakpoint *breakpoint);
485  struct watchpoint *watchpoint);
492  struct watchpoint *watchpoint);
493 
500  struct watchpoint **watchpoint);
501 
507 const char *target_get_gdb_arch(struct target *target);
508 
515  struct reg **reg_list[], int *reg_list_size,
516  enum target_register_class reg_class);
517 
525  struct reg **reg_list[], int *reg_list_size,
526  enum target_register_class reg_class);
527 
534 
540 int target_step(struct target *target,
541  int current, target_addr_t address, int handle_breakpoints);
548  int num_mem_params, struct mem_param *mem_params,
549  int num_reg_params, struct reg_param *reg_param,
550  target_addr_t entry_point, target_addr_t exit_point,
551  int timeout_ms, void *arch_info);
552 
559  int num_mem_params, struct mem_param *mem_params,
560  int num_reg_params, struct reg_param *reg_params,
561  target_addr_t entry_point, target_addr_t exit_point,
562  void *arch_info);
563 
570  int num_mem_params, struct mem_param *mem_params,
571  int num_reg_params, struct reg_param *reg_params,
572  target_addr_t exit_point, int timeout_ms,
573  void *arch_info);
574 
580  const uint8_t *buffer, uint32_t count, int block_size,
581  int num_mem_params, struct mem_param *mem_params,
582  int num_reg_params, struct reg_param *reg_params,
583  uint32_t buffer_start, uint32_t buffer_size,
584  uint32_t entry_point, uint32_t exit_point,
585  void *arch_info);
586 
592  uint8_t *buffer, uint32_t count, int block_size,
593  int num_mem_params, struct mem_param *mem_params,
594  int num_reg_params, struct reg_param *reg_params,
595  uint32_t buffer_start, uint32_t buffer_size,
596  uint32_t entry_point, uint32_t exit_point,
597  void *arch_info);
598 
605 int target_read_memory(struct target *target,
606  target_addr_t address, uint32_t size, uint32_t count, uint8_t *buffer);
608  target_addr_t address, uint32_t size, uint32_t count, uint8_t *buffer);
626 int target_write_memory(struct target *target,
627  target_addr_t address, uint32_t size, uint32_t count, const uint8_t *buffer);
629  target_addr_t address, uint32_t size, uint32_t count, const uint8_t *buffer);
630 
631 /*
632  * Write to target memory using the virtual address.
633  *
634  * Note that this fn is used to implement software breakpoints. Targets
635  * can implement support for software breakpoints to memory marked as read
636  * only by making this fn write to ram even if it is read only(MMU or
637  * MPUs).
638  *
639  * It is sufficient to implement for writing a single word(16 or 32 in
640  * ARM32/16 bit case) to write the breakpoint to ram.
641  *
642  * The target should also take care of "other things" to make sure that
643  * software breakpoints can be written using this function. E.g.
644  * when there is a separate instruction and data cache, this fn must
645  * make sure that the instruction cache is synced up to the potential
646  * code change that can happen as a result of the memory write(typically
647  * by invalidating the cache).
648  *
649  * The high level wrapper fn in target.c will break down this memory write
650  * request to multiple write requests to the target driver to e.g. guarantee
651  * that writing 4 bytes to an aligned address happens with a single 32 bit
652  * write operation, thus making this fn suitable to e.g. write to special
653  * peripheral registers which do not support byte operations.
654  */
655 int target_write_buffer(struct target *target,
656  target_addr_t address, uint32_t size, const uint8_t *buffer);
657 int target_read_buffer(struct target *target,
658  target_addr_t address, uint32_t size, uint8_t *buffer);
660  target_addr_t address, uint32_t size, uint32_t *crc);
662  struct target_memory_check_block *blocks, int num_blocks,
663  uint8_t erased_value);
664 int target_wait_state(struct target *target, enum target_state state, int ms);
665 
672 
678 int target_gdb_fileio_end(struct target *target, int retcode, int fileio_errno, bool ctrl_c);
679 
684 
690 unsigned target_address_bits(struct target *target);
691 
697 unsigned int target_data_bits(struct target *target);
698 
700 const char *target_state_name(struct target *target);
701 
703 const char *target_event_name(enum target_event event);
704 
706 const char *target_reset_mode_name(enum target_reset_mode reset_mode);
707 
708 /* DANGER!!!!!
709  *
710  * if "area" passed in to target_alloc_working_area() points to a memory
711  * location that goes out of scope (e.g. a pointer on the stack), then
712  * the caller of target_alloc_working_area() is responsible for invoking
713  * target_free_working_area() before "area" goes out of scope.
714  *
715  * target_free_all_working_areas() will NULL out the "area" pointer
716  * upon resuming or resetting the CPU.
717  *
718  */
720  uint32_t size, struct working_area **area);
721 /* Same as target_alloc_working_area, except that no error is logged
722  * when ERROR_TARGET_RESOURCE_NOT_AVAILABLE is returned.
723  *
724  * This allows the calling code to *try* to allocate target memory
725  * and have a fallback to another behaviour(slower?).
726  */
728  uint32_t size, struct working_area **area);
736 int target_free_working_area(struct target *target, struct working_area *area);
739 
743 void target_quit(void);
744 
745 extern struct target *all_targets;
746 
747 uint64_t target_buffer_get_u64(struct target *target, const uint8_t *buffer);
748 uint32_t target_buffer_get_u32(struct target *target, const uint8_t *buffer);
749 uint32_t target_buffer_get_u24(struct target *target, const uint8_t *buffer);
750 uint16_t target_buffer_get_u16(struct target *target, const uint8_t *buffer);
751 void target_buffer_set_u64(struct target *target, uint8_t *buffer, uint64_t value);
752 void target_buffer_set_u32(struct target *target, uint8_t *buffer, uint32_t value);
753 void target_buffer_set_u24(struct target *target, uint8_t *buffer, uint32_t value);
754 void target_buffer_set_u16(struct target *target, uint8_t *buffer, uint16_t value);
755 
756 void target_buffer_get_u64_array(struct target *target, const uint8_t *buffer, uint32_t count, uint64_t *dstbuf);
757 void target_buffer_get_u32_array(struct target *target, const uint8_t *buffer, uint32_t count, uint32_t *dstbuf);
758 void target_buffer_get_u16_array(struct target *target, const uint8_t *buffer, uint32_t count, uint16_t *dstbuf);
759 void target_buffer_set_u64_array(struct target *target, uint8_t *buffer, uint32_t count, const uint64_t *srcbuf);
760 void target_buffer_set_u32_array(struct target *target, uint8_t *buffer, uint32_t count, const uint32_t *srcbuf);
761 void target_buffer_set_u16_array(struct target *target, uint8_t *buffer, uint32_t count, const uint16_t *srcbuf);
762 
763 int target_read_u64(struct target *target, target_addr_t address, uint64_t *value);
764 int target_read_u32(struct target *target, target_addr_t address, uint32_t *value);
765 int target_read_u16(struct target *target, target_addr_t address, uint16_t *value);
766 int target_read_u8(struct target *target, target_addr_t address, uint8_t *value);
767 int target_write_u64(struct target *target, target_addr_t address, uint64_t value);
768 int target_write_u32(struct target *target, target_addr_t address, uint32_t value);
769 int target_write_u16(struct target *target, target_addr_t address, uint16_t value);
770 int target_write_u8(struct target *target, target_addr_t address, uint8_t value);
771 
772 int target_write_phys_u64(struct target *target, target_addr_t address, uint64_t value);
773 int target_write_phys_u32(struct target *target, target_addr_t address, uint32_t value);
774 int target_write_phys_u16(struct target *target, target_addr_t address, uint16_t value);
775 int target_write_phys_u8(struct target *target, target_addr_t address, uint8_t value);
776 
777 /* Issues USER() statements with target state information */
778 int target_arch_state(struct target *target);
779 
780 void target_handle_event(struct target *t, enum target_event e);
781 
783  struct target *target, target_addr_t address, unsigned size,
784  unsigned count, const uint8_t *buffer);
785 
786 int target_profiling_default(struct target *target, uint32_t *samples, uint32_t
787  max_num_samples, uint32_t *num_samples, uint32_t seconds);
788 
789 #define ERROR_TARGET_INVALID (-300)
790 #define ERROR_TARGET_INIT_FAILED (-301)
791 #define ERROR_TARGET_TIMEOUT (-302)
792 #define ERROR_TARGET_NOT_HALTED (-304)
793 #define ERROR_TARGET_FAILURE (-305)
794 #define ERROR_TARGET_UNALIGNED_ACCESS (-306)
795 #define ERROR_TARGET_DATA_ABORT (-307)
796 #define ERROR_TARGET_RESOURCE_NOT_AVAILABLE (-308)
797 #define ERROR_TARGET_TRANSLATION_FAULT (-309)
798 #define ERROR_TARGET_NOT_RUNNING (-310)
799 #define ERROR_TARGET_NOT_EXAMINED (-311)
800 #define ERROR_TARGET_DUPLICATE_BREAKPOINT (-312)
801 #define ERROR_TARGET_ALGO_EXIT (-313)
802 
803 extern bool get_target_reset_nag(void);
804 
805 #define TARGET_DEFAULT_POLLING_INTERVAL 100
806 
807 #endif /* OPENOCD_TARGET_TARGET_H */
uint8_t type
Definition: esp_usb_jtag.c:0
static struct esp_usb_jtag * priv
Definition: esp_usb_jtag.c:219
struct target * target
Definition: rtt/rtt.c:26
size_t size
Size of the control block search area.
Definition: rtt/rtt.c:30
When run_command is called, a new instance will be created on the stack, filled with the proper value...
Definition: command.h:76
uint64_t param_1
Definition: target.h:220
uint64_t param_4
Definition: target.h:223
uint64_t param_3
Definition: target.h:222
char * identifier
Definition: target.h:219
uint64_t param_2
Definition: target.h:221
int32_t core[2]
Definition: target.h:104
struct target * target
Definition: target.h:99
Definition: jtag.h:100
Definition: list.h:26
Definition: register.h:111
Definition: rtos.h:36
Jim_Interp * interp
Definition: target.h:301
Jim_Obj * body
Definition: target.h:302
struct target_event_action * next
Definition: target.h:303
enum target_event event
Definition: target.h:300
int(* callback)(struct target *target, enum target_event event, void *priv)
Definition: target.h:309
struct target_event_callback * next
Definition: target.h:311
struct list_head lh
Definition: target.h:214
struct target * target
Definition: target.h:215
target_addr_t address
Definition: target.h:342
int(* callback)(struct target *target, enum target_reset_mode reset_mode, void *priv)
Definition: target.h:317
struct list_head list
Definition: target.h:315
int(* callback)(void *priv)
Definition: target.h:332
struct target_timer_callback * next
Definition: target.h:338
unsigned int time_ms
Definition: target.h:333
enum target_timer_type type
Definition: target.h:334
int(* callback)(struct target *target, size_t len, uint8_t *data, void *priv)
Definition: target.h:323
struct list_head list
Definition: target.h:321
This holds methods shared between all instances of a given target type.
Definition: target_type.h:26
Definition: target.h:120
int32_t coreid
Definition: target.h:125
struct semihosting * semihosting
Definition: target.h:210
int smp
Definition: target.h:192
target_addr_t working_area
Definition: target.h:150
target_addr_t working_area_virt
Definition: target.h:153
struct gdb_service * gdb_service
Definition: target.h:200
uint32_t working_area_size
Definition: target.h:156
struct jtag_tap * tap
Definition: target.h:124
bool dbgbase_set
Definition: target.h:179
struct trace * trace_info
Definition: target.h:166
enum target_debug_reason debug_reason
Definition: target.h:159
enum target_state state
Definition: target.h:162
uint32_t dbgbase
Definition: target.h:180
void * private_config
Definition: target.h:170
char * gdb_port_override
Definition: target.h:205
enum target_endianness endianness
Definition: target.h:160
struct reg_cache * reg_cache
Definition: target.h:163
bool halt_issued
Definition: target.h:175
struct list_head * smp_targets
Definition: target.h:193
struct target_event_action * event_action
Definition: target.h:147
struct breakpoint * breakpoints
Definition: target.h:164
struct working_area * working_areas
Definition: target.h:158
bool verbose_halt_msg
Definition: target.h:173
bool dap_configured
Definition: target.h:184
struct rtos * rtos
Definition: target.h:188
struct gdb_fileio_info * fileio_info
Definition: target.h:203
struct debug_msg_receiver * dbgmsg
Definition: target.h:167
bool rtos_auto_detect
Definition: target.h:189
int64_t halt_issued_time
Definition: target.h:176
struct target_type * type
Definition: target.h:121
struct backoff_timer backoff
Definition: target.h:191
target_addr_t working_area_phys
Definition: target.h:155
bool has_dap
Definition: target.h:183
bool tap_configured
Definition: target.h:185
struct watchpoint * watchpoints
Definition: target.h:165
int target_number
Definition: target.h:123
bool working_area_phys_spec
Definition: target.h:154
bool running_alg
true if the target is currently running a downloaded "algorithm" instead of arbitrary user code.
Definition: target.h:145
void * arch_info
Definition: target.h:169
uint32_t dbg_msg_enabled
Definition: target.h:168
int gdb_max_connections
Definition: target.h:207
bool working_area_virt_spec
Definition: target.h:152
bool reset_halt
Definition: target.h:149
bool examined
Indicates whether this target has been examined.
Definition: target.h:136
char * cmd_name
Definition: target.h:122
uint32_t backup_working_area
Definition: target.h:157
bool defer_examine
Should we defer examine to later.
Definition: target.h:128
struct target * next
Definition: target.h:171
Definition: trace.h:21
uint32_t size
Definition: target.h:91
bool free
Definition: target.h:92
struct working_area * next
Definition: target.h:95
target_addr_t address
Definition: target.h:90
struct working_area ** user
Definition: target.h:94
uint8_t * backup
Definition: target.h:93
void target_buffer_get_u16_array(struct target *target, const uint8_t *buffer, uint32_t count, uint16_t *dstbuf)
Definition: target.c:460
void target_buffer_set_u24(struct target *target, uint8_t *buffer, uint32_t value)
Definition: target.c:420
int target_get_gdb_fileio_info(struct target *target, struct gdb_fileio_info *fileio_info)
Obtain file-I/O information from target for GDB to do syscall.
Definition: target.c:1495
int target_add_watchpoint(struct target *target, struct watchpoint *watchpoint)
Add the watchpoint for target.
Definition: target.c:1398
target_debug_reason
Definition: target.h:72
@ DBG_REASON_WPTANDBKPT
Definition: target.h:76
@ DBG_REASON_UNDEFINED
Definition: target.h:81
@ DBG_REASON_EXIT
Definition: target.h:79
@ DBG_REASON_NOTHALTED
Definition: target.h:78
@ DBG_REASON_DBGRQ
Definition: target.h:73
@ DBG_REASON_SINGLESTEP
Definition: target.h:77
@ DBG_REASON_WATCHPOINT
Definition: target.h:75
@ DBG_REASON_EXC_CATCH
Definition: target.h:80
@ DBG_REASON_BREAKPOINT
Definition: target.h:74
struct target * all_targets
Definition: target.c:154
int target_run_read_async_algorithm(struct target *target, uint8_t *buffer, uint32_t count, int block_size, int num_mem_params, struct mem_param *mem_params, int num_reg_params, struct reg_param *reg_params, uint32_t buffer_start, uint32_t buffer_size, uint32_t entry_point, uint32_t exit_point, void *arch_info)
This routine is a wrapper for asynchronous algorithms.
Definition: target.c:1156
int target_write_phys_u32(struct target *target, target_addr_t address, uint32_t value)
Definition: target.c:2788
uint64_t target_buffer_get_u64(struct target *target, const uint8_t *buffer)
Definition: target.c:366
int target_call_event_callbacks(struct target *target, enum target_event event)
Definition: target.c:1833
struct target * get_target(const char *id)
Definition: target.c:492
void target_free_all_working_areas(struct target *target)
Definition: target.c:2219
int target_unregister_reset_callback(int(*callback)(struct target *target, enum target_reset_mode reset_mode, void *priv), void *priv)
Definition: target.c:1779
target_reset_mode
Definition: target.h:65
@ RESET_RUN
Definition: target.h:67
@ RESET_HALT
Definition: target.h:68
@ RESET_UNKNOWN
Definition: target.h:66
@ RESET_INIT
Definition: target.h:69
target_register_class
Definition: target.h:114
@ REG_CLASS_GENERAL
Definition: target.h:116
@ REG_CLASS_ALL
Definition: target.h:115
int target_write_phys_u64(struct target *target, target_addr_t address, uint64_t value)
Definition: target.c:2767
int target_unregister_event_callback(int(*callback)(struct target *target, enum target_event event, void *priv), void *priv)
Definition: target.c:1756
int target_hit_watchpoint(struct target *target, struct watchpoint **watchpoint)
Find out the just hit watchpoint for target.
Definition: target.c:1412
int target_read_phys_memory(struct target *target, target_addr_t address, uint32_t size, uint32_t count, uint8_t *buffer)
Definition: target.c:1320
int target_register_event_callback(int(*callback)(struct target *target, enum target_event event, void *priv), void *priv)
Definition: target.c:1661
int target_write_phys_memory(struct target *target, target_addr_t address, uint32_t size, uint32_t count, const uint8_t *buffer)
Definition: target.c:1348
int target_halt(struct target *target)
Definition: target.c:585
int target_get_gdb_reg_list_noread(struct target *target, struct reg **reg_list[], int *reg_list_size, enum target_register_class reg_class)
Obtain the registers for GDB, but don't read register values from the target.
Definition: target.c:1459
const char * target_get_gdb_arch(struct target *target)
Obtain the architecture for GDB.
Definition: target.c:1430
int target_arch_state(struct target *target)
Definition: target.c:2325
void target_buffer_set_u16(struct target *target, uint8_t *buffer, uint16_t value)
Definition: target.c:429
int target_call_timer_callbacks_now(void)
Invoke this to ensure that e.g.
Definition: target.c:1953
int target_remove_breakpoint(struct target *target, struct breakpoint *breakpoint)
Remove the breakpoint for target.
Definition: target.c:1392
void target_buffer_set_u32(struct target *target, uint8_t *buffer, uint32_t value)
Definition: target.c:411
bool target_has_event_action(struct target *target, enum target_event event)
Returns true only if the target has a handler for the specified event.
Definition: target.c:5287
int target_register_commands(struct command_context *cmd_ctx)
Definition: target.c:6757
int target_checksum_memory(struct target *target, target_addr_t address, uint32_t size, uint32_t *crc)
Definition: target.c:2533
const char * target_state_name(struct target *target)
Return the name of this targets current state.
Definition: target.c:302
int target_write_buffer(struct target *target, target_addr_t address, uint32_t size, const uint8_t *buffer)
Definition: target.c:2408
int target_add_hybrid_breakpoint(struct target *target, struct breakpoint *breakpoint)
Add the ContextID & IVA breakpoint for target.
Definition: target.c:1382
int target_write_u8(struct target *target, target_addr_t address, uint8_t value)
Definition: target.c:2749
int target_add_breakpoint(struct target *target, struct breakpoint *breakpoint)
Add the breakpoint for target.
Definition: target.c:1362
target_addr_t target_address_max(struct target *target)
Return the highest accessible address for this target.
Definition: target.c:1513
int target_write_u16(struct target *target, target_addr_t address, uint16_t value)
Definition: target.c:2728
int target_unregister_timer_callback(int(*callback)(void *priv), void *priv)
Definition: target.c:1817
int target_gdb_fileio_end(struct target *target, int retcode, int fileio_errno, bool ctrl_c)
Pass GDB file-I/O response to target after finishing host syscall.
Definition: target.c:1504
int target_wait_algorithm(struct target *target, int num_mem_params, struct mem_param *mem_params, int num_reg_params, struct reg_param *reg_params, target_addr_t exit_point, int timeout_ms, void *arch_info)
Wait for an algorithm on the target given.
Definition: target.c:931
int target_read_buffer(struct target *target, target_addr_t address, uint32_t size, uint8_t *buffer)
Definition: target.c:2473
int target_unregister_trace_callback(int(*callback)(struct target *target, size_t len, uint8_t *data, void *priv), void *priv)
Definition: target.c:1798
int target_read_u8(struct target *target, target_addr_t address, uint8_t *value)
Definition: target.c:2664
int target_blank_check_memory(struct target *target, struct target_memory_check_block *blocks, int num_blocks, uint8_t erased_value)
Definition: target.c:2577
bool target_supports_gdb_connection(struct target *target)
Check if target allows GDB connections.
Definition: target.c:1470
target_timer_type
Definition: target.h:326
@ TARGET_TIMER_TYPE_PERIODIC
Definition: target.h:328
@ TARGET_TIMER_TYPE_ONESHOT
Definition: target.h:327
target_event
Definition: target.h:241
@ TARGET_EVENT_DEBUG_RESUMED
Definition: target.h:273
@ TARGET_EVENT_EXAMINE_START
Definition: target.h:275
@ TARGET_EVENT_RESET_START
Definition: target.h:263
@ TARGET_EVENT_SEMIHOSTING_USER_CMD_0X106
Definition: target.h:295
@ TARGET_EVENT_GDB_FLASH_WRITE_END
Definition: target.h:285
@ TARGET_EVENT_RESET_END
Definition: target.h:270
@ TARGET_EVENT_RESET_ASSERT_POST
Definition: target.h:266
@ TARGET_EVENT_RESET_DEASSERT_POST
Definition: target.h:268
@ TARGET_EVENT_HALTED
Definition: target.h:253
@ TARGET_EVENT_RESUMED
Definition: target.h:254
@ TARGET_EVENT_SEMIHOSTING_USER_CMD_0X102
Definition: target.h:291
@ TARGET_EVENT_SEMIHOSTING_USER_CMD_0X107
Definition: target.h:296
@ TARGET_EVENT_SEMIHOSTING_USER_CMD_0X105
Definition: target.h:294
@ TARGET_EVENT_EXAMINE_FAIL
Definition: target.h:276
@ TARGET_EVENT_GDB_START
Definition: target.h:260
@ TARGET_EVENT_EXAMINE_END
Definition: target.h:277
@ TARGET_EVENT_SEMIHOSTING_USER_CMD_0X104
Definition: target.h:293
@ TARGET_EVENT_RESET_INIT
Definition: target.h:269
@ TARGET_EVENT_GDB_END
Definition: target.h:261
@ TARGET_EVENT_RESET_DEASSERT_PRE
Definition: target.h:267
@ TARGET_EVENT_GDB_FLASH_ERASE_START
Definition: target.h:282
@ TARGET_EVENT_SEMIHOSTING_USER_CMD_0X103
Definition: target.h:292
@ TARGET_EVENT_DEBUG_HALTED
Definition: target.h:272
@ TARGET_EVENT_RESET_ASSERT_PRE
Definition: target.h:264
@ TARGET_EVENT_RESET_ASSERT
Definition: target.h:265
@ TARGET_EVENT_GDB_FLASH_WRITE_START
Definition: target.h:284
@ TARGET_EVENT_RESUME_START
Definition: target.h:255
@ TARGET_EVENT_STEP_END
Definition: target.h:258
@ TARGET_EVENT_STEP_START
Definition: target.h:257
@ TARGET_EVENT_GDB_ATTACH
Definition: target.h:279
@ TARGET_EVENT_SEMIHOSTING_USER_CMD_0X100
Definition: target.h:289
@ TARGET_EVENT_SEMIHOSTING_USER_CMD_0X101
Definition: target.h:290
@ TARGET_EVENT_RESUME_END
Definition: target.h:256
@ TARGET_EVENT_GDB_FLASH_ERASE_END
Definition: target.h:283
@ TARGET_EVENT_GDB_DETACH
Definition: target.h:280
@ TARGET_EVENT_TRACE_CONFIG
Definition: target.h:287
@ TARGET_EVENT_GDB_HALT
Definition: target.h:252
struct target * get_target_by_num(int num)
Definition: target.c:523
int target_profiling_default(struct target *target, uint32_t *samples, uint32_t max_num_samples, uint32_t *num_samples, uint32_t seconds)
Definition: target.c:2356
int target_write_memory(struct target *target, target_addr_t address, uint32_t size, uint32_t count, const uint8_t *buffer)
Write count items of size bytes to the memory of target at the address given.
Definition: target.c:1334
unsigned target_address_bits(struct target *target)
Return the number of address bits this target supports.
Definition: target.c:1522
void target_handle_md_output(struct command_invocation *cmd, struct target *target, target_addr_t address, unsigned size, unsigned count, const uint8_t *buffer)
Definition: target.c:3399
int target_get_gdb_reg_list(struct target *target, struct reg **reg_list[], int *reg_list_size, enum target_register_class reg_class)
Obtain the registers for GDB.
Definition: target.c:1437
int target_call_timer_callbacks(void)
Definition: target.c:1947
int target_write_u64(struct target *target, target_addr_t address, uint64_t value)
Definition: target.c:2686
target_state
Definition: target.h:52
@ TARGET_RESET
Definition: target.h:56
@ TARGET_DEBUG_RUNNING
Definition: target.h:57
@ TARGET_UNKNOWN
Definition: target.h:53
@ TARGET_HALTED
Definition: target.h:55
@ TARGET_RUNNING
Definition: target.h:54
struct target * get_current_target_or_null(struct command_context *cmd_ctx)
Definition: target.c:548
target_endianness
Definition: target.h:84
@ TARGET_BIG_ENDIAN
Definition: target.h:86
@ TARGET_ENDIAN_UNKNOWN
Definition: target.h:85
@ TARGET_LITTLE_ENDIAN
Definition: target.h:86
int target_call_reset_callbacks(struct target *target, enum target_reset_mode reset_mode)
Definition: target.c:1858
uint32_t target_get_working_area_avail(struct target *target)
Definition: target.c:2233
int target_alloc_working_area(struct target *target, uint32_t size, struct working_area **area)
Definition: target.c:2129
static const char * target_name(struct target *target)
Returns the instance-specific name of the specified target.
Definition: target.h:234
bool get_target_reset_nag(void)
Definition: target.c:6764
int target_step(struct target *target, int current, target_addr_t address, int handle_breakpoints)
Step the target.
Definition: target.c:1479
unsigned int target_data_bits(struct target *target)
Return the number of data bits this target supports.
Definition: target.c:1529
int target_remove_watchpoint(struct target *target, struct watchpoint *watchpoint)
Remove the watchpoint for target.
Definition: target.c:1407
const char * target_event_name(enum target_event event)
Return the name of a target event enumeration value.
Definition: target.c:317
int target_write_u32(struct target *target, target_addr_t address, uint32_t value)
Definition: target.c:2707
int target_examine_one(struct target *target)
Examine the specified target, letting it perform any Initialisation that requires JTAG access.
Definition: target.c:750
int target_poll(struct target *target)
Definition: target.c:555
int target_free_working_area(struct target *target, struct working_area *area)
Free a working area.
Definition: target.c:2187
int target_run_algorithm(struct target *target, int num_mem_params, struct mem_param *mem_params, int num_reg_params, struct reg_param *reg_param, target_addr_t entry_point, target_addr_t exit_point, int timeout_ms, void *arch_info)
Run an algorithm on the target given.
Definition: target.c:846
int target_alloc_working_area_try(struct target *target, uint32_t size, struct working_area **area)
Definition: target.c:2035
int target_register_timer_callback(int(*callback)(void *priv), unsigned int time_ms, enum target_timer_type type, void *priv)
The period is very approximate, the callback can happen much more often or much more rarely than spec...
Definition: target.c:1727
static void target_set_examined(struct target *target)
Sets the examined flag for the given target.
Definition: target.h:445
int target_read_u16(struct target *target, target_addr_t address, uint16_t *value)
Definition: target.c:2640
int target_run_flash_async_algorithm(struct target *target, const uint8_t *buffer, uint32_t count, int block_size, int num_mem_params, struct mem_param *mem_params, int num_reg_params, struct reg_param *reg_params, uint32_t buffer_start, uint32_t buffer_size, uint32_t entry_point, uint32_t exit_point, void *arch_info)
This routine is a wrapper for asynchronous algorithms.
Definition: target.c:1003
void target_buffer_set_u64(struct target *target, uint8_t *buffer, uint64_t value)
Definition: target.c:402
void target_buffer_set_u64_array(struct target *target, uint8_t *buffer, uint32_t count, const uint64_t *srcbuf)
Definition: target.c:468
int target_add_context_breakpoint(struct target *target, struct breakpoint *breakpoint)
Add the ContextID breakpoint for target.
Definition: target.c:1372
int target_read_u32(struct target *target, target_addr_t address, uint32_t *value)
Definition: target.c:2616
uint16_t target_buffer_get_u16(struct target *target, const uint8_t *buffer)
Definition: target.c:393
int target_read_memory(struct target *target, target_addr_t address, uint32_t size, uint32_t count, uint8_t *buffer)
Read count items of size bytes from the memory of target at the address given.
Definition: target.c:1306
void target_buffer_get_u64_array(struct target *target, const uint8_t *buffer, uint32_t count, uint64_t *dstbuf)
Definition: target.c:444
void target_buffer_set_u16_array(struct target *target, uint8_t *buffer, uint32_t count, const uint16_t *srcbuf)
Definition: target.c:484
static bool target_was_examined(struct target *target)
Definition: target.h:438
int target_register_reset_callback(int(*callback)(struct target *target, enum target_reset_mode reset_mode, void *priv), void *priv)
Definition: target.c:1683
uint32_t target_buffer_get_u24(struct target *target, const uint8_t *buffer)
Definition: target.c:384
void target_buffer_get_u32_array(struct target *target, const uint8_t *buffer, uint32_t count, uint32_t *dstbuf)
Definition: target.c:452
int64_t target_timer_next_event(void)
Returns when the next registered event will take place.
Definition: target.c:1958
int target_write_phys_u16(struct target *target, target_addr_t address, uint16_t value)
Definition: target.c:2809
void target_handle_event(struct target *t, enum target_event e)
Definition: target.c:5092
nvp_assert
Definition: target.h:60
@ NVP_ASSERT
Definition: target.h:62
@ NVP_DEASSERT
Definition: target.h:61
int target_examine(void)
Definition: target.c:784
int target_register_trace_callback(int(*callback)(struct target *target, size_t len, uint8_t *data, void *priv), void *priv)
Definition: target.c:1705
struct target * get_current_target(struct command_context *cmd_ctx)
Definition: target.c:536
void target_buffer_set_u32_array(struct target *target, uint8_t *buffer, uint32_t count, const uint32_t *srcbuf)
Definition: target.c:476
uint32_t target_buffer_get_u32(struct target *target, const uint8_t *buffer)
Definition: target.c:375
const char * debug_reason_name(struct target *t)
Definition: target.c:289
int target_call_trace_callbacks(struct target *target, size_t len, uint8_t *data)
Definition: target.c:1871
int target_start_algorithm(struct target *target, int num_mem_params, struct mem_param *mem_params, int num_reg_params, struct reg_param *reg_params, target_addr_t entry_point, target_addr_t exit_point, void *arch_info)
Starts an algorithm in the background on the target given.
Definition: target.c:887
const char * target_type_name(struct target *target)
Get the target type name.
Definition: target.c:809
void target_quit(void)
Free all the resources allocated by targets and the target layer.
Definition: target.c:2296
int target_write_phys_u8(struct target *target, target_addr_t address, uint8_t value)
Definition: target.c:2830
int target_read_u64(struct target *target, target_addr_t address, uint64_t *value)
Definition: target.c:2592
const char * target_reset_mode_name(enum target_reset_mode reset_mode)
Return the name of a target reset reason enumeration value.
Definition: target.c:328
int target_resume(struct target *target, int current, target_addr_t address, int handle_breakpoints, int debug_execution)
Make the target (re)start executing using its saved execution context (possibly with some modificatio...
Definition: target.c:634
int target_wait_state(struct target *target, enum target_state state, int ms)
Definition: target.c:3270
uint64_t target_addr_t
Definition: types.h:335
uint8_t cmd
Definition: vdebug.c:1
uint8_t state[4]
Definition: vdebug.c:21
uint8_t count[4]
Definition: vdebug.c:22