//==========================================================================
|
//==========================================================================
|
//
|
//
|
// bplist-dynamic.c
|
// bplist-dynamic.c
|
//
|
//
|
// Dynamic breakpoint list.
|
// Dynamic breakpoint list.
|
// Currently only statically allocated. (ie NO_MALLOC is assumed)
|
// Currently only statically allocated. (ie NO_MALLOC is assumed)
|
//
|
//
|
//==========================================================================
|
//==========================================================================
|
//####ECOSGPLCOPYRIGHTBEGIN####
|
//####ECOSGPLCOPYRIGHTBEGIN####
|
// -------------------------------------------
|
// -------------------------------------------
|
// This file is part of eCos, the Embedded Configurable Operating System.
|
// This file is part of eCos, the Embedded Configurable Operating System.
|
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.
|
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.
|
//
|
//
|
// eCos is free software; you can redistribute it and/or modify it under
|
// eCos 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
|
// the terms of the GNU General Public License as published by the Free
|
// Software Foundation; either version 2 or (at your option) any later version.
|
// Software Foundation; either version 2 or (at your option) any later version.
|
//
|
//
|
// eCos is distributed in the hope that it will be useful, but WITHOUT ANY
|
// eCos is distributed in the hope that it will be useful, but WITHOUT ANY
|
// WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
// WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
// for more details.
|
// for more details.
|
//
|
//
|
// You should have received a copy of the GNU General Public License along
|
// You should have received a copy of the GNU General Public License along
|
// with eCos; if not, write to the Free Software Foundation, Inc.,
|
// with eCos; if not, write to the Free Software Foundation, Inc.,
|
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
|
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
|
//
|
//
|
// As a special exception, if other files instantiate templates or use macros
|
// As a special exception, if other files instantiate templates or use macros
|
// or inline functions from this file, or you compile this file and link it
|
// or inline functions from this file, or you compile this file and link it
|
// with other works to produce a work based on this file, this file does not
|
// with other works to produce a work based on this file, this file does not
|
// by itself cause the resulting work to be covered by the GNU General Public
|
// by itself cause the resulting work to be covered by the GNU General Public
|
// License. However the source code for this file must still be made available
|
// License. However the source code for this file must still be made available
|
// in accordance with section (3) of the GNU General Public License.
|
// in accordance with section (3) of the GNU General Public License.
|
//
|
//
|
// This exception does not invalidate any other reasons why a work based on
|
// This exception does not invalidate any other reasons why a work based on
|
// this file might be covered by the GNU General Public License.
|
// this file might be covered by the GNU General Public License.
|
//
|
//
|
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.
|
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.
|
// at http://sources.redhat.com/ecos/ecos-license/
|
// at http://sources.redhat.com/ecos/ecos-license/
|
// -------------------------------------------
|
// -------------------------------------------
|
//####ECOSGPLCOPYRIGHTEND####
|
//####ECOSGPLCOPYRIGHTEND####
|
//==========================================================================
|
//==========================================================================
|
//#####DESCRIPTIONBEGIN####
|
//#####DESCRIPTIONBEGIN####
|
//
|
//
|
// Author(s):
|
// Author(s):
|
// Contributors: dmoseley
|
// Contributors: dmoseley
|
// Date: 2000-07-11
|
// Date: 2000-07-11
|
// Purpose: Dynamic breakpoint list.
|
// Purpose: Dynamic breakpoint list.
|
// Description:
|
// Description:
|
//
|
//
|
//
|
//
|
//####DESCRIPTIONEND####
|
//####DESCRIPTIONEND####
|
//
|
//
|
//=========================================================================
|
//=========================================================================
|
|
|
#include <pkgconf/system.h>
|
#include <pkgconf/system.h>
|
#include <pkgconf/hal.h>
|
#include <pkgconf/hal.h>
|
|
|
#if defined(CYGNUM_HAL_BREAKPOINT_LIST_SIZE) && (CYGNUM_HAL_BREAKPOINT_LIST_SIZE > 0) && defined(CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS)
|
#if defined(CYGNUM_HAL_BREAKPOINT_LIST_SIZE) && (CYGNUM_HAL_BREAKPOINT_LIST_SIZE > 0) && defined(CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS)
|
|
|
#define CYGARC_HAL_COMMON_EXPORT_CPU_MACROS
|
#define CYGARC_HAL_COMMON_EXPORT_CPU_MACROS
|
#include <cyg/hal/hal_stub.h>
|
#include <cyg/hal/hal_stub.h>
|
#include <cyg/hal/hal_arch.h>
|
#include <cyg/hal/hal_arch.h>
|
#include <cyg/hal/hal_cache.h>
|
#include <cyg/hal/hal_cache.h>
|
|
|
#ifdef TARGET_HAS_HARVARD_MEMORY
|
#ifdef TARGET_HAS_HARVARD_MEMORY
|
#define __read_mem_safe __read_progmem_safe
|
#define __read_mem_safe __read_progmem_safe
|
#define __write_mem_safe __write_progmem_safe
|
#define __write_mem_safe __write_progmem_safe
|
#endif
|
#endif
|
|
|
/*
|
/*
|
* A simple target breakpoint list without using malloc.
|
* A simple target breakpoint list without using malloc.
|
* To use this package, you must define HAL_BREAKINST_SIZE to be the size
|
* To use this package, you must define HAL_BREAKINST_SIZE to be the size
|
* in bytes of a trap instruction (max if there's more than one),
|
* in bytes of a trap instruction (max if there's more than one),
|
* HAL_BREAKINST to the opcode value of the instruction, and
|
* HAL_BREAKINST to the opcode value of the instruction, and
|
* HAL_BREAKINST_TYPE to be the type necessary to hold the opcode value.
|
* HAL_BREAKINST_TYPE to be the type necessary to hold the opcode value.
|
*/
|
*/
|
|
|
struct breakpoint_list {
|
struct breakpoint_list {
|
target_register_t addr;
|
target_register_t addr;
|
char old_contents [HAL_BREAKINST_SIZE];
|
char old_contents [HAL_BREAKINST_SIZE];
|
struct breakpoint_list *next;
|
struct breakpoint_list *next;
|
char in_memory;
|
char in_memory;
|
char length;
|
char length;
|
} *breakpoint_list = NULL;
|
} *breakpoint_list = NULL;
|
|
|
#ifndef HAL_BREAKINST_ADDR
|
#ifndef HAL_BREAKINST_ADDR
|
static HAL_BREAKINST_TYPE break_inst = HAL_BREAKINST;
|
static HAL_BREAKINST_TYPE break_inst = HAL_BREAKINST;
|
#define HAL_BREAKINST_ADDR(x) ((void*)&break_inst)
|
#define HAL_BREAKINST_ADDR(x) ((void*)&break_inst)
|
#endif
|
#endif
|
|
|
static struct breakpoint_list bp_list [CYGNUM_HAL_BREAKPOINT_LIST_SIZE];
|
static struct breakpoint_list bp_list [CYGNUM_HAL_BREAKPOINT_LIST_SIZE];
|
static struct breakpoint_list *free_bp_list = NULL;
|
static struct breakpoint_list *free_bp_list = NULL;
|
static int curr_bp_num = 0;
|
static int curr_bp_num = 0;
|
|
|
int
|
int
|
__set_breakpoint (target_register_t addr, target_register_t len)
|
__set_breakpoint (target_register_t addr, target_register_t len)
|
{
|
{
|
struct breakpoint_list **addent = &breakpoint_list;
|
struct breakpoint_list **addent = &breakpoint_list;
|
struct breakpoint_list *l = breakpoint_list;
|
struct breakpoint_list *l = breakpoint_list;
|
struct breakpoint_list *newent;
|
struct breakpoint_list *newent;
|
|
|
while (l != NULL && l->addr < addr)
|
while (l != NULL && l->addr < addr)
|
{
|
{
|
addent = &l->next;
|
addent = &l->next;
|
l = l->next;
|
l = l->next;
|
}
|
}
|
|
|
if (l != NULL && l->addr == addr)
|
if (l != NULL && l->addr == addr)
|
return 2;
|
return 2;
|
|
|
if (free_bp_list != NULL)
|
if (free_bp_list != NULL)
|
{
|
{
|
newent = free_bp_list;
|
newent = free_bp_list;
|
free_bp_list = free_bp_list->next;
|
free_bp_list = free_bp_list->next;
|
}
|
}
|
else
|
else
|
{
|
{
|
if (curr_bp_num < CYGNUM_HAL_BREAKPOINT_LIST_SIZE)
|
if (curr_bp_num < CYGNUM_HAL_BREAKPOINT_LIST_SIZE)
|
{
|
{
|
newent = &bp_list[curr_bp_num++];
|
newent = &bp_list[curr_bp_num++];
|
}
|
}
|
else
|
else
|
{
|
{
|
return 1;
|
return 1;
|
}
|
}
|
}
|
}
|
|
|
newent->addr = addr;
|
newent->addr = addr;
|
newent->in_memory = 0;
|
newent->in_memory = 0;
|
newent->next = l;
|
newent->next = l;
|
newent->length = len;
|
newent->length = len;
|
*addent = newent;
|
*addent = newent;
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
int
|
int
|
__remove_breakpoint (target_register_t addr, target_register_t len)
|
__remove_breakpoint (target_register_t addr, target_register_t len)
|
{
|
{
|
struct breakpoint_list *l = breakpoint_list;
|
struct breakpoint_list *l = breakpoint_list;
|
struct breakpoint_list *prev = NULL;
|
struct breakpoint_list *prev = NULL;
|
|
|
while (l != NULL && l->addr < addr)
|
while (l != NULL && l->addr < addr)
|
{
|
{
|
prev = l;
|
prev = l;
|
l = l->next;
|
l = l->next;
|
}
|
}
|
|
|
if ((l == NULL) || (l->addr != addr))
|
if ((l == NULL) || (l->addr != addr))
|
return 1;
|
return 1;
|
|
|
if (l->in_memory)
|
if (l->in_memory)
|
{
|
{
|
__write_mem_safe (&l->old_contents[0],
|
__write_mem_safe (&l->old_contents[0],
|
(void*)l->addr,
|
(void*)l->addr,
|
sizeof (l->old_contents));
|
sizeof (l->old_contents));
|
}
|
}
|
|
|
if (prev == NULL)
|
if (prev == NULL)
|
breakpoint_list = l->next;
|
breakpoint_list = l->next;
|
else
|
else
|
prev->next = l->next;
|
prev->next = l->next;
|
|
|
l->next = free_bp_list;
|
l->next = free_bp_list;
|
free_bp_list = l;
|
free_bp_list = l;
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
#if defined(HAL_STUB_HW_BREAKPOINT_LIST_SIZE) && (HAL_STUB_HW_BREAKPOINT_LIST_SIZE > 0)
|
#if defined(HAL_STUB_HW_BREAKPOINT_LIST_SIZE) && (HAL_STUB_HW_BREAKPOINT_LIST_SIZE > 0)
|
#ifndef HAL_STUB_HW_BREAKPOINT
|
#ifndef HAL_STUB_HW_BREAKPOINT
|
#error "Must define HAL_STUB_HW_BREAKPOINT"
|
#error "Must define HAL_STUB_HW_BREAKPOINT"
|
#endif
|
#endif
|
struct hw_breakpoint_list {
|
struct hw_breakpoint_list {
|
target_register_t addr;
|
target_register_t addr;
|
target_register_t len;
|
target_register_t len;
|
char used;
|
char used;
|
char installed;
|
char installed;
|
};
|
};
|
static struct hw_breakpoint_list hw_bp_list [HAL_STUB_HW_BREAKPOINT_LIST_SIZE];
|
static struct hw_breakpoint_list hw_bp_list [HAL_STUB_HW_BREAKPOINT_LIST_SIZE];
|
|
|
int
|
int
|
__set_hw_breakpoint (target_register_t addr, target_register_t len)
|
__set_hw_breakpoint (target_register_t addr, target_register_t len)
|
{
|
{
|
int i;
|
int i;
|
|
|
for (i = 0; i < HAL_STUB_HW_BREAKPOINT_LIST_SIZE; i++)
|
for (i = 0; i < HAL_STUB_HW_BREAKPOINT_LIST_SIZE; i++)
|
{
|
{
|
if (hw_bp_list[i].used == 0)
|
if (hw_bp_list[i].used == 0)
|
{
|
{
|
hw_bp_list[i].addr = addr;
|
hw_bp_list[i].addr = addr;
|
hw_bp_list[i].len = len;
|
hw_bp_list[i].len = len;
|
hw_bp_list[i].used = 1;
|
hw_bp_list[i].used = 1;
|
hw_bp_list[i].installed = 0;
|
hw_bp_list[i].installed = 0;
|
return 0;
|
return 0;
|
}
|
}
|
}
|
}
|
return -1;
|
return -1;
|
}
|
}
|
|
|
int
|
int
|
__remove_hw_breakpoint (target_register_t addr, target_register_t len)
|
__remove_hw_breakpoint (target_register_t addr, target_register_t len)
|
{
|
{
|
int i;
|
int i;
|
|
|
for (i = 0; i < HAL_STUB_HW_BREAKPOINT_LIST_SIZE; i++)
|
for (i = 0; i < HAL_STUB_HW_BREAKPOINT_LIST_SIZE; i++)
|
{
|
{
|
if (hw_bp_list[i].used && hw_bp_list[i].addr == addr
|
if (hw_bp_list[i].used && hw_bp_list[i].addr == addr
|
&& hw_bp_list[i].len == len)
|
&& hw_bp_list[i].len == len)
|
{
|
{
|
if (hw_bp_list[i].installed)
|
if (hw_bp_list[i].installed)
|
HAL_STUB_HW_BREAKPOINT(0, (void *)addr, (int)len);
|
HAL_STUB_HW_BREAKPOINT(0, (void *)addr, (int)len);
|
hw_bp_list[i].used = 0;
|
hw_bp_list[i].used = 0;
|
return 0;
|
return 0;
|
}
|
}
|
}
|
}
|
return -1;
|
return -1;
|
}
|
}
|
|
|
static void
|
static void
|
__install_hw_breakpoint_list (void)
|
__install_hw_breakpoint_list (void)
|
{
|
{
|
int i;
|
int i;
|
|
|
for (i = 0; i < HAL_STUB_HW_BREAKPOINT_LIST_SIZE; i++)
|
for (i = 0; i < HAL_STUB_HW_BREAKPOINT_LIST_SIZE; i++)
|
{
|
{
|
if (hw_bp_list[i].used && hw_bp_list[i].installed == 0)
|
if (hw_bp_list[i].used && hw_bp_list[i].installed == 0)
|
{
|
{
|
HAL_STUB_HW_BREAKPOINT(1, (void *)hw_bp_list[i].addr,
|
HAL_STUB_HW_BREAKPOINT(1, (void *)hw_bp_list[i].addr,
|
(int)hw_bp_list[i].len);
|
(int)hw_bp_list[i].len);
|
hw_bp_list[i].installed = 1;
|
hw_bp_list[i].installed = 1;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
static void
|
static void
|
__clear_hw_breakpoint_list (void)
|
__clear_hw_breakpoint_list (void)
|
{
|
{
|
int i;
|
int i;
|
|
|
for (i = 0; i < HAL_STUB_HW_BREAKPOINT_LIST_SIZE; i++)
|
for (i = 0; i < HAL_STUB_HW_BREAKPOINT_LIST_SIZE; i++)
|
{
|
{
|
if (hw_bp_list[i].used && hw_bp_list[i].installed)
|
if (hw_bp_list[i].used && hw_bp_list[i].installed)
|
{
|
{
|
HAL_STUB_HW_BREAKPOINT(0, (void *)hw_bp_list[i].addr,
|
HAL_STUB_HW_BREAKPOINT(0, (void *)hw_bp_list[i].addr,
|
(int)hw_bp_list[i].len);
|
(int)hw_bp_list[i].len);
|
hw_bp_list[i].installed = 0;
|
hw_bp_list[i].installed = 0;
|
}
|
}
|
}
|
}
|
}
|
}
|
#endif // HAL_STUB_HW_BREAKPOINT_LIST_SIZE
|
#endif // HAL_STUB_HW_BREAKPOINT_LIST_SIZE
|
|
|
#if defined(HAL_STUB_HW_WATCHPOINT_LIST_SIZE) && (HAL_STUB_HW_WATCHPOINT_LIST_SIZE > 0)
|
#if defined(HAL_STUB_HW_WATCHPOINT_LIST_SIZE) && (HAL_STUB_HW_WATCHPOINT_LIST_SIZE > 0)
|
#ifndef HAL_STUB_HW_WATCHPOINT
|
#ifndef HAL_STUB_HW_WATCHPOINT
|
#error "Must define HAL_STUB_HW_WATCHPOINT"
|
#error "Must define HAL_STUB_HW_WATCHPOINT"
|
#endif
|
#endif
|
struct hw_watchpoint_list {
|
struct hw_watchpoint_list {
|
target_register_t addr;
|
target_register_t addr;
|
target_register_t len;
|
target_register_t len;
|
int ztype;
|
int ztype;
|
char used;
|
char used;
|
char installed;
|
char installed;
|
};
|
};
|
static struct hw_watchpoint_list hw_wp_list [HAL_STUB_HW_WATCHPOINT_LIST_SIZE];
|
static struct hw_watchpoint_list hw_wp_list [HAL_STUB_HW_WATCHPOINT_LIST_SIZE];
|
|
|
int
|
int
|
__set_hw_watchpoint (target_register_t addr, target_register_t len, int ztype)
|
__set_hw_watchpoint (target_register_t addr, target_register_t len, int ztype)
|
{
|
{
|
int i;
|
int i;
|
|
|
for (i = 0; i < HAL_STUB_HW_WATCHPOINT_LIST_SIZE; i++)
|
for (i = 0; i < HAL_STUB_HW_WATCHPOINT_LIST_SIZE; i++)
|
{
|
{
|
if (hw_wp_list[i].used == 0)
|
if (hw_wp_list[i].used == 0)
|
{
|
{
|
hw_wp_list[i].addr = addr;
|
hw_wp_list[i].addr = addr;
|
hw_wp_list[i].len = len;
|
hw_wp_list[i].len = len;
|
hw_wp_list[i].ztype = ztype;
|
hw_wp_list[i].ztype = ztype;
|
hw_wp_list[i].used = 1;
|
hw_wp_list[i].used = 1;
|
hw_wp_list[i].installed = 0;
|
hw_wp_list[i].installed = 0;
|
return 0;
|
return 0;
|
}
|
}
|
}
|
}
|
return -1;
|
return -1;
|
}
|
}
|
|
|
int
|
int
|
__remove_hw_watchpoint (target_register_t addr, target_register_t len, int ztype)
|
__remove_hw_watchpoint (target_register_t addr, target_register_t len, int ztype)
|
{
|
{
|
int i;
|
int i;
|
|
|
for (i = 0; i < HAL_STUB_HW_WATCHPOINT_LIST_SIZE; i++)
|
for (i = 0; i < HAL_STUB_HW_WATCHPOINT_LIST_SIZE; i++)
|
{
|
{
|
if (hw_wp_list[i].used && hw_wp_list[i].addr == addr
|
if (hw_wp_list[i].used && hw_wp_list[i].addr == addr
|
&& hw_wp_list[i].len == len && hw_wp_list[i].ztype == ztype )
|
&& hw_wp_list[i].len == len && hw_wp_list[i].ztype == ztype )
|
{
|
{
|
if (hw_wp_list[i].installed)
|
if (hw_wp_list[i].installed)
|
HAL_STUB_HW_WATCHPOINT(0, (void *)addr, (int)len, ztype);
|
HAL_STUB_HW_WATCHPOINT(0, (void *)addr, (int)len, ztype);
|
hw_wp_list[i].used = 0;
|
hw_wp_list[i].used = 0;
|
return 0;
|
return 0;
|
}
|
}
|
}
|
}
|
return -1;
|
return -1;
|
}
|
}
|
|
|
static void
|
static void
|
__install_hw_watchpoint_list (void)
|
__install_hw_watchpoint_list (void)
|
{
|
{
|
int i;
|
int i;
|
|
|
for (i = 0; i < HAL_STUB_HW_WATCHPOINT_LIST_SIZE; i++)
|
for (i = 0; i < HAL_STUB_HW_WATCHPOINT_LIST_SIZE; i++)
|
{
|
{
|
if (hw_wp_list[i].used && hw_wp_list[i].installed == 0)
|
if (hw_wp_list[i].used && hw_wp_list[i].installed == 0)
|
{
|
{
|
HAL_STUB_HW_WATCHPOINT(1, (void *)hw_wp_list[i].addr,
|
HAL_STUB_HW_WATCHPOINT(1, (void *)hw_wp_list[i].addr,
|
(int)hw_wp_list[i].len, hw_wp_list[i].ztype);
|
(int)hw_wp_list[i].len, hw_wp_list[i].ztype);
|
hw_wp_list[i].installed = 1;
|
hw_wp_list[i].installed = 1;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
static void
|
static void
|
__clear_hw_watchpoint_list (void)
|
__clear_hw_watchpoint_list (void)
|
{
|
{
|
int i;
|
int i;
|
|
|
for (i = 0; i < HAL_STUB_HW_WATCHPOINT_LIST_SIZE; i++)
|
for (i = 0; i < HAL_STUB_HW_WATCHPOINT_LIST_SIZE; i++)
|
{
|
{
|
if (hw_wp_list[i].used && hw_wp_list[i].installed)
|
if (hw_wp_list[i].used && hw_wp_list[i].installed)
|
{
|
{
|
HAL_STUB_HW_WATCHPOINT(0, (void *)hw_wp_list[i].addr,
|
HAL_STUB_HW_WATCHPOINT(0, (void *)hw_wp_list[i].addr,
|
(int)hw_wp_list[i].len, hw_wp_list[i].ztype);
|
(int)hw_wp_list[i].len, hw_wp_list[i].ztype);
|
hw_wp_list[i].installed = 0;
|
hw_wp_list[i].installed = 0;
|
}
|
}
|
}
|
}
|
}
|
}
|
#endif // HAL_STUB_HW_WATCHPOINT_LIST_SIZE
|
#endif // HAL_STUB_HW_WATCHPOINT_LIST_SIZE
|
|
|
|
|
|
|
void
|
void
|
__install_breakpoint_list (void)
|
__install_breakpoint_list (void)
|
{
|
{
|
struct breakpoint_list *l = breakpoint_list;
|
struct breakpoint_list *l = breakpoint_list;
|
|
|
while (l != NULL)
|
while (l != NULL)
|
{
|
{
|
if (! l->in_memory)
|
if (! l->in_memory)
|
{
|
{
|
int len = sizeof (l->old_contents);
|
int len = sizeof (l->old_contents);
|
if (__read_mem_safe (&l->old_contents[0], (void*)l->addr, len) == len)
|
if (__read_mem_safe (&l->old_contents[0], (void*)l->addr, len) == len)
|
{
|
{
|
if (__write_mem_safe (HAL_BREAKINST_ADDR(l->length),
|
if (__write_mem_safe (HAL_BREAKINST_ADDR(l->length),
|
(void*)l->addr, l->length) == l->length)
|
(void*)l->addr, l->length) == l->length)
|
{
|
{
|
l->in_memory = 1;
|
l->in_memory = 1;
|
}
|
}
|
}
|
}
|
}
|
}
|
l = l->next;
|
l = l->next;
|
}
|
}
|
#if defined(HAL_STUB_HW_BREAKPOINT_LIST_SIZE) && (HAL_STUB_HW_BREAKPOINT_LIST_SIZE > 0)
|
#if defined(HAL_STUB_HW_BREAKPOINT_LIST_SIZE) && (HAL_STUB_HW_BREAKPOINT_LIST_SIZE > 0)
|
__install_hw_breakpoint_list();
|
__install_hw_breakpoint_list();
|
#endif
|
#endif
|
#if defined(HAL_STUB_HW_WATCHPOINT_LIST_SIZE) && (HAL_STUB_HW_WATCHPOINT_LIST_SIZE > 0)
|
#if defined(HAL_STUB_HW_WATCHPOINT_LIST_SIZE) && (HAL_STUB_HW_WATCHPOINT_LIST_SIZE > 0)
|
__install_hw_watchpoint_list();
|
__install_hw_watchpoint_list();
|
#endif
|
#endif
|
HAL_ICACHE_SYNC();
|
HAL_ICACHE_SYNC();
|
}
|
}
|
|
|
void
|
void
|
__clear_breakpoint_list (void)
|
__clear_breakpoint_list (void)
|
{
|
{
|
struct breakpoint_list *l = breakpoint_list;
|
struct breakpoint_list *l = breakpoint_list;
|
|
|
while (l != NULL)
|
while (l != NULL)
|
{
|
{
|
if (l->in_memory)
|
if (l->in_memory)
|
{
|
{
|
int len = sizeof (l->old_contents);
|
int len = sizeof (l->old_contents);
|
if (__write_mem_safe (&l->old_contents[0], (void*)l->addr, len) == len)
|
if (__write_mem_safe (&l->old_contents[0], (void*)l->addr, len) == len)
|
{
|
{
|
l->in_memory = 0;
|
l->in_memory = 0;
|
}
|
}
|
}
|
}
|
l = l->next;
|
l = l->next;
|
}
|
}
|
#if defined(HAL_STUB_HW_BREAKPOINT_LIST_SIZE) && (HAL_STUB_HW_BREAKPOINT_LIST_SIZE > 0)
|
#if defined(HAL_STUB_HW_BREAKPOINT_LIST_SIZE) && (HAL_STUB_HW_BREAKPOINT_LIST_SIZE > 0)
|
__clear_hw_breakpoint_list();
|
__clear_hw_breakpoint_list();
|
#endif
|
#endif
|
#if defined(HAL_STUB_HW_WATCHPOINT_LIST_SIZE) && (HAL_STUB_HW_WATCHPOINT_LIST_SIZE > 0)
|
#if defined(HAL_STUB_HW_WATCHPOINT_LIST_SIZE) && (HAL_STUB_HW_WATCHPOINT_LIST_SIZE > 0)
|
__clear_hw_watchpoint_list();
|
__clear_hw_watchpoint_list();
|
#endif
|
#endif
|
HAL_ICACHE_INVALIDATE_ALL();
|
HAL_ICACHE_INVALIDATE_ALL();
|
}
|
}
|
|
|
int
|
int
|
__display_breakpoint_list (void (*print_func)(target_register_t))
|
__display_breakpoint_list (void (*print_func)(target_register_t))
|
{
|
{
|
struct breakpoint_list *l = breakpoint_list;
|
struct breakpoint_list *l = breakpoint_list;
|
|
|
while (l != NULL)
|
while (l != NULL)
|
{
|
{
|
print_func(l->addr);
|
print_func(l->addr);
|
l = l->next;
|
l = l->next;
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
#else // (CYGNUM_HAL_BREAKPOINT_LIST_SIZE == 0) or UNDEFINED
|
#else // (CYGNUM_HAL_BREAKPOINT_LIST_SIZE == 0) or UNDEFINED
|
|
|
#include <cyg/hal/hal_stub.h> // Our header
|
#include <cyg/hal/hal_stub.h> // Our header
|
|
|
#ifndef CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS
|
#ifndef CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS
|
// We don't know that type target_register_t is yet.
|
// We don't know that type target_register_t is yet.
|
// Let's just pick a type so we can compile. Since
|
// Let's just pick a type so we can compile. Since
|
// these versions of the functions don't actually do
|
// these versions of the functions don't actually do
|
// anything with the parameters, the actualy types
|
// anything with the parameters, the actualy types
|
// don't matter.
|
// don't matter.
|
typedef unsigned long target_register_t;
|
typedef unsigned long target_register_t;
|
#endif
|
#endif
|
|
|
int
|
int
|
__set_breakpoint (target_register_t addr, target_register_t len)
|
__set_breakpoint (target_register_t addr, target_register_t len)
|
{
|
{
|
return 1;
|
return 1;
|
}
|
}
|
|
|
int
|
int
|
__remove_breakpoint (target_register_t addr, target_register_t len)
|
__remove_breakpoint (target_register_t addr, target_register_t len)
|
{
|
{
|
return 1;
|
return 1;
|
}
|
}
|
|
|
void
|
void
|
__install_breakpoint_list (void)
|
__install_breakpoint_list (void)
|
{
|
{
|
}
|
}
|
|
|
void
|
void
|
__clear_breakpoint_list (void)
|
__clear_breakpoint_list (void)
|
{
|
{
|
}
|
}
|
|
|
int
|
int
|
__display_breakpoint_list (void (*print_func)(target_register_t))
|
__display_breakpoint_list (void (*print_func)(target_register_t))
|
{
|
{
|
return 0;
|
return 0;
|
}
|
}
|
#endif // (CYGNUM_HAL_BREAKPOINT_LIST_SIZE > 0)
|
#endif // (CYGNUM_HAL_BREAKPOINT_LIST_SIZE > 0)
|
|
|
|
|
