forked from Imagelibrary/rtems
238 lines
6.9 KiB
C
238 lines
6.9 KiB
C
/*
|
|
* Copyright (c) 2016 Chris Johns <chrisj@rtems.org>. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*/
|
|
|
|
/*
|
|
* Debugger for RTEMS.
|
|
*/
|
|
|
|
#ifndef _RTEMS_DEBUGGER_TARGET_h
|
|
#define _RTEMS_DEBUGGER_TARGET_h
|
|
|
|
#include <setjmp.h>
|
|
|
|
#include <rtems/rtems-debugger.h>
|
|
|
|
#include "rtems-debugger-threads.h"
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif /* __cplusplus */
|
|
|
|
/*
|
|
* Software breakpoint block size.
|
|
*/
|
|
#define RTEMS_DEBUGGER_TARGET_SWBREAK_NUM 64
|
|
|
|
/**
|
|
* Target capabilities mask.
|
|
*/
|
|
#define RTEMS_DEBUGGER_TARGET_CAP_SWBREAK (1 << 0)
|
|
#define RTEMS_DEBUGGER_TARGET_CAP_HWBREAK (1 << 1)
|
|
#define RTEMS_DEBUGGER_TARGET_CAP_HWWATCH (1 << 2)
|
|
|
|
/**
|
|
* Types of hardware breakpoints.
|
|
*/
|
|
typedef enum rtems_debugger_target_watchpoint
|
|
{
|
|
rtems_debugger_target_hw_read,
|
|
rtems_debugger_target_hw_write,
|
|
rtems_debugger_target_hw_read_write,
|
|
rtems_debugger_target_hw_execute
|
|
} rtems_debugger_target_watchpoint;
|
|
|
|
/**
|
|
* Target exception actions.
|
|
*/
|
|
typedef enum rtems_debugger_target_exc_action
|
|
{
|
|
rtems_debugger_target_exc_consumed, /*<< The exception has been consumed. */
|
|
rtems_debugger_target_exc_cascade, /*<< Cascade to a previous handler. */
|
|
rtems_debugger_target_exc_step, /*<< Step an instruction. */
|
|
} rtems_debugger_target_exc_action;
|
|
|
|
/**
|
|
* Memory breakpoint. We use thumb mode BKPT which is 2 bytes.
|
|
*/
|
|
#define RTEMS_DEBUGGER_TARGET_SWBREAK_MAX_SIZE (4)
|
|
typedef struct rtems_debugger_target_swbreak {
|
|
void* address;
|
|
uint8_t contents[RTEMS_DEBUGGER_TARGET_SWBREAK_MAX_SIZE];
|
|
} rtems_debugger_target_swbreak;
|
|
|
|
/**
|
|
* The target data.
|
|
*/
|
|
typedef struct rtems_debugger_target {
|
|
int capabilities; /*<< The capabilities to report. */
|
|
size_t reg_num; /*<< The number of registers. */
|
|
size_t reg_size; /*<< The size of a register. */
|
|
const uint8_t* breakpoint; /*<< The breakpoint instruction(s). */
|
|
size_t breakpoint_size; /*<< The breakpoint size. */
|
|
rtems_debugger_block swbreaks; /*<< The software breakpoint block. */
|
|
bool memory_access; /*<< Accessing target memory. */
|
|
jmp_buf access_return; /*<< Return from an access fault. */
|
|
} rtems_debugger_target;
|
|
|
|
/**
|
|
* Create the target.
|
|
*/
|
|
extern int rtems_debugger_target_create(void);
|
|
|
|
/**
|
|
* Destroy the target.
|
|
*/
|
|
extern int rtems_debugger_target_destroy(void);
|
|
|
|
/**
|
|
* Configure the target. This is architecture specific.
|
|
*/
|
|
extern int rtems_debugger_target_configure(rtems_debugger_target* target);
|
|
|
|
/**
|
|
* Enable the target.
|
|
*/
|
|
extern int rtems_debugger_target_enable(void);
|
|
|
|
/**
|
|
* Disable the target.
|
|
*/
|
|
extern int rtems_debugger_target_disable(void);
|
|
|
|
/**
|
|
* Return the capabilities mask for the target.
|
|
*/
|
|
extern uint32_t rtems_debugger_target_capabilities(void);
|
|
|
|
/**
|
|
* Return the number of regisers.
|
|
*/
|
|
extern size_t rtems_debugger_target_reg_num(void);
|
|
|
|
/**
|
|
* Return the size of the regisers in bytes.
|
|
*/
|
|
extern size_t rtems_debugger_target_reg_size(void);
|
|
|
|
/**
|
|
* Read the regosters.
|
|
*/
|
|
extern int rtems_debugger_target_read_regs(rtems_debugger_thread* thread);
|
|
|
|
/**
|
|
* Write the regosters.
|
|
*/
|
|
extern int rtems_debugger_target_write_regs(rtems_debugger_thread* thread);
|
|
|
|
/**
|
|
* Return the thread's program counter (PC).
|
|
*/
|
|
extern DB_UINT rtems_debugger_target_reg_pc(rtems_debugger_thread* thread);
|
|
|
|
/**
|
|
* Return the frame's program counter (PC).
|
|
*/
|
|
extern DB_UINT rtems_debugger_target_frame_pc(CPU_Exception_frame* frame);
|
|
|
|
/**
|
|
* Return the thread's stack pointer (SP).
|
|
*/
|
|
extern DB_UINT rtems_debugger_target_reg_sp(rtems_debugger_thread* thread);
|
|
|
|
/**
|
|
* Return the thread's TCB stack pointer (SP).
|
|
*/
|
|
extern DB_UINT rtems_debugger_target_tcb_sp(rtems_debugger_thread* thread);
|
|
|
|
/**
|
|
* The thread is stepping. Setup the thread to step an instruction.
|
|
*/
|
|
extern int rtems_debugger_target_thread_stepping(rtems_debugger_thread* thread);
|
|
|
|
/**
|
|
* Return the signal for the exception.
|
|
*/
|
|
extern int rtems_debugger_target_exception_to_signal(CPU_Exception_frame* frame);
|
|
|
|
/**
|
|
* Software breakpoints. These are also referred to as memory breakpoints.
|
|
*/
|
|
extern int rtems_debugger_target_swbreak_control(bool insert,
|
|
DB_UINT addr,
|
|
DB_UINT kind);
|
|
|
|
/**
|
|
* Insert software breakpoints into the memory.
|
|
*/
|
|
extern int rtems_debugger_target_swbreak_insert(void);
|
|
|
|
/**
|
|
* Remove software breakpoints from the memory.
|
|
*/
|
|
extern int rtems_debugger_target_swbreak_remove(void);
|
|
|
|
/**
|
|
* Hardware breakpoints.
|
|
*/
|
|
extern int rtems_debugger_target_hwbreak_control(rtems_debugger_target_watchpoint type,
|
|
bool insert,
|
|
DB_UINT addr,
|
|
DB_UINT kind);
|
|
|
|
/**
|
|
* Target exception processor.
|
|
*/
|
|
extern rtems_debugger_target_exc_action
|
|
rtems_debugger_target_exception(CPU_Exception_frame* frame);
|
|
|
|
/**
|
|
* Set the thread's exception stack frame pointer.
|
|
*/
|
|
extern int rtems_debugger_target_set_exception_frame(rtems_debugger_thread* thread);
|
|
|
|
/**
|
|
* Target instruction cache sync. This depends on the target but it normally
|
|
* means a data cache flush and an instruction cache invalidate.
|
|
*/
|
|
extern int rtems_debugger_target_cache_sync(rtems_debugger_target_swbreak* swbreak);
|
|
|
|
/**
|
|
* Start a target memory access. If 0 is return the access can proceed and if
|
|
* -1 is return the access has failed.
|
|
*/
|
|
extern int rtems_debugger_target_start_memory_access(void);
|
|
|
|
/**
|
|
* End a target memory access.
|
|
*/
|
|
extern void rtems_debugger_target_end_memory_access(void);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif /* __cplusplus */
|
|
|
|
|
|
#endif
|