bplist-dynamic.c

eCos操作系统源码

//==========================================================================
//
//      bplist-dynamic.c
//
//      Dynamic breakpoint list.
//      Currently only statically allocated.  (ie NO_MALLOC is assumed)
//
//==========================================================================
//####ECOSGPLCOPYRIGHTBEGIN####
// -------------------------------------------
// This file is part of eCos, the Embedded Configurable Operating System.
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.
//
// 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
// 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
// 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 eCos; if not, write to the Free Software Foundation, Inc.,
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
//
// 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
// 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
// License. However the source code for this file must still be made available
// 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 file might be covered by the GNU General Public License.
//
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.
// at http://sources.redhat.com/ecos/ecos-license/
// -------------------------------------------
//####ECOSGPLCOPYRIGHTEND####
//==========================================================================
//#####DESCRIPTIONBEGIN####
//
// Author(s):    
// Contributors: dmoseley
// Date:         2000-07-11
// Purpose:      Dynamic breakpoint list.
// Description:  
//               
//
//####DESCRIPTIONEND####
//
//=========================================================================

#include <pkgconf/system.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)

#define CYGARC_HAL_COMMON_EXPORT_CPU_MACROS
#include <cyg/hal/hal_stub.h>
#include <cyg/hal/hal_arch.h>
#include <cyg/hal/hal_cache.h>

#ifdef TARGET_HAS_HARVARD_MEMORY
#define __read_mem_safe __read_progmem_safe
#define __write_mem_safe __write_progmem_safe
#endif

/*
 * A simple target breakpoint list without using malloc.
 * 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),
 * HAL_BREAKINST to the opcode value of the instruction, and
 * HAL_BREAKINST_TYPE to be the type necessary to hold the opcode value.
 */

struct breakpoint_list {
  target_register_t  addr;
  char old_contents [HAL_BREAKINST_SIZE];
  struct breakpoint_list *next;
  char in_memory;
  char length;
} *breakpoint_list = NULL;

#ifndef HAL_BREAKINST_ADDR
static HAL_BREAKINST_TYPE break_inst = HAL_BREAKINST;
#define HAL_BREAKINST_ADDR(x) ((void*)&break_inst)
#endif

static struct breakpoint_list bp_list [CYGNUM_HAL_BREAKPOINT_LIST_SIZE];
static struct breakpoint_list *free_bp_list = NULL;
static int curr_bp_num = 0;

int
__set_breakpoint (target_register_t addr, target_register_t len)
{
  struct breakpoint_list **addent = &breakpoint_list;
  struct breakpoint_list *l = breakpoint_list;
  struct breakpoint_list *newent;

  while (l != NULL && l->addr < addr)
    {
      addent = &l->next;
      l =  l->next;
    }

  if (l != NULL && l->addr == addr)
    return 2;

  if (free_bp_list != NULL)
    {
      newent = free_bp_list;
      free_bp_list = free_bp_list->next;
    }
  else
    {
      if (curr_bp_num < CYGNUM_HAL_BREAKPOINT_LIST_SIZE)
	{
	  newent = &bp_list[curr_bp_num++];
	}
      else
	{
	  return 1;
	}
    }

  newent->addr = addr;
  newent->in_memory = 0;
  newent->next = l;
  newent->length = len;
  *addent = newent;

  return 0;
}

int
__remove_breakpoint (target_register_t addr, target_register_t len)
{
  struct breakpoint_list *l = breakpoint_list;
  struct breakpoint_list *prev = NULL;

  while (l != NULL && l->addr < addr)
    {
      prev = l;
      l = l->next;
    }

  if ((l == NULL) || (l->addr != addr))
    return 1;

  if (l->in_memory)
    {
      __write_mem_safe (&l->old_contents[0],
			(void*)l->addr,
			sizeof (l->old_contents));
    }

  if (prev == NULL)
    breakpoint_list = l->next;
  else
    prev->next = l->next;

  l->next = free_bp_list;
  free_bp_list = l;

  return 0;
}

#if defined(HAL_STUB_HW_BREAKPOINT_LIST_SIZE) && (HAL_STUB_HW_BREAKPOINT_LIST_SIZE > 0)
#ifndef HAL_STUB_HW_BREAKPOINT
#error "Must define HAL_STUB_HW_BREAKPOINT"
#endif
struct hw_breakpoint_list {
  target_register_t  addr;
  target_register_t  len;
  char used;
  char installed;
};
static struct hw_breakpoint_list hw_bp_list [HAL_STUB_HW_BREAKPOINT_LIST_SIZE];

int
__set_hw_breakpoint (target_register_t addr, target_register_t len)
{
  int i;

  for (i = 0; i < HAL_STUB_HW_BREAKPOINT_LIST_SIZE; i++)
    {
      if (hw_bp_list[i].used == 0)
	{
	  hw_bp_list[i].addr = addr;
	  hw_bp_list[i].len = len;
	  hw_bp_list[i].used = 1;
	  hw_bp_list[i].installed = 0;
	  return 0;
	}
    }
  return -1;
}

int
__remove_hw_breakpoint (target_register_t addr, target_register_t len)
{
  int i;

  for (i = 0; i < HAL_STUB_HW_BREAKPOINT_LIST_SIZE; i++)
    {
      if (hw_bp_list[i].used && hw_bp_list[i].addr == addr
	  && hw_bp_list[i].len == len)
	{
	  if (hw_bp_list[i].installed)
	    HAL_STUB_HW_BREAKPOINT(0, (void *)addr, (int)len);
	  hw_bp_list[i].used = 0;
	  return 0;
	}
    }
  return -1;
}

static void
__install_hw_breakpoint_list (void)
{
  int i;

  for (i = 0; i < HAL_STUB_HW_BREAKPOINT_LIST_SIZE; i++)
    {
      if (hw_bp_list[i].used && hw_bp_list[i].installed == 0)
	{
	  HAL_STUB_HW_BREAKPOINT(1, (void *)hw_bp_list[i].addr,
				 (int)hw_bp_list[i].len);
	  hw_bp_list[i].installed = 1;
	}
    }
}

static void
__clear_hw_breakpoint_list (void)
{
  int i;

  for (i = 0; i < HAL_STUB_HW_BREAKPOINT_LIST_SIZE; i++)
    {
      if (hw_bp_list[i].used && hw_bp_list[i].installed)
	{
	  HAL_STUB_HW_BREAKPOINT(0, (void *)hw_bp_list[i].addr,
				 (int)hw_bp_list[i].len);
	  hw_bp_list[i].installed = 0;
	}
    }
}
#endif // HAL_STUB_HW_BREAKPOINT_LIST_SIZE

#if defined(HAL_STUB_HW_WATCHPOINT_LIST_SIZE) && (HAL_STUB_HW_WATCHPOINT_LIST_SIZE > 0)
#ifndef HAL_STUB_HW_WATCHPOINT
#error "Must define HAL_STUB_HW_WATCHPOINT"
#endif
struct hw_watchpoint_list {
  target_register_t  addr;
  target_register_t  len;
  int ztype;
  char used;
  char installed;
};
static struct hw_watchpoint_list hw_wp_list [HAL_STUB_HW_WATCHPOINT_LIST_SIZE];

int
__set_hw_watchpoint (target_register_t addr, target_register_t len, int ztype)
{
  int i;

  for (i = 0; i < HAL_STUB_HW_WATCHPOINT_LIST_SIZE; i++)
    {
      if (hw_wp_list[i].used == 0)
	{
	  hw_wp_list[i].addr = addr;
	  hw_wp_list[i].len = len;
	  hw_wp_list[i].ztype = ztype;
	  hw_wp_list[i].used = 1;
	  hw_wp_list[i].installed = 0;
	  return 0;
	}
    }
  return -1;
}

int
__remove_hw_watchpoint (target_register_t addr, target_register_t len, int ztype)
{
  int i;

  for (i = 0; i < HAL_STUB_HW_WATCHPOINT_LIST_SIZE; i++)
    {
      if (hw_wp_list[i].used && hw_wp_list[i].addr == addr
	  && hw_wp_list[i].len == len && hw_wp_list[i].ztype == ztype )
	{
	  if (hw_wp_list[i].installed)
	    HAL_STUB_HW_WATCHPOINT(0, (void *)addr, (int)len, ztype);
	  hw_wp_list[i].used = 0;
	  return 0;
	}
    }
  return -1;
}

static void
__install_hw_watchpoint_list (void)
{
  int i;

  for (i = 0; i < HAL_STUB_HW_WATCHPOINT_LIST_SIZE; i++)
    {
      if (hw_wp_list[i].used && hw_wp_list[i].installed == 0)
	{
	  HAL_STUB_HW_WATCHPOINT(1, (void *)hw_wp_list[i].addr,
				 (int)hw_wp_list[i].len, hw_wp_list[i].ztype);
	  hw_wp_list[i].installed = 1;
	}
    }
}

static void
__clear_hw_watchpoint_list (void)
{
  int i;

  for (i = 0; i < HAL_STUB_HW_WATCHPOINT_LIST_SIZE; i++)
    {
      if (hw_wp_list[i].used && hw_wp_list[i].installed)
	{
	  HAL_STUB_HW_WATCHPOINT(0, (void *)hw_wp_list[i].addr,
				 (int)hw_wp_list[i].len, hw_wp_list[i].ztype);
	  hw_wp_list[i].installed = 0;
	}
    }
}
#endif // HAL_STUB_HW_WATCHPOINT_LIST_SIZE



void
__install_breakpoint_list (void)
{
  struct breakpoint_list *l = breakpoint_list;

  while (l != NULL)
    {
      if (! l->in_memory)
	{
	  int len = sizeof (l->old_contents);
	  if (__read_mem_safe (&l->old_contents[0], (void*)l->addr, len) == len)
	    {
	      if (__write_mem_safe (HAL_BREAKINST_ADDR(l->length),
				    (void*)l->addr, l->length) == l->length)
		{
		  l->in_memory = 1;
		}
	    }
	}
      l = l->next;
    }
#if defined(HAL_STUB_HW_BREAKPOINT_LIST_SIZE) && (HAL_STUB_HW_BREAKPOINT_LIST_SIZE > 0)
  __install_hw_breakpoint_list();
#endif
#if defined(HAL_STUB_HW_WATCHPOINT_LIST_SIZE) && (HAL_STUB_HW_WATCHPOINT_LIST_SIZE > 0)
  __install_hw_watchpoint_list();
#endif
  HAL_ICACHE_SYNC();
}

void
__clear_breakpoint_list (void)
{
  struct breakpoint_list *l = breakpoint_list;

  while (l != NULL)
    {
      if (l->in_memory)
	{
	  int len = sizeof (l->old_contents);
	  if (__write_mem_safe (&l->old_contents[0], (void*)l->addr, len) == len)
	    {
	      l->in_memory = 0;
	    }
	}
      l = l->next;
    }
#if defined(HAL_STUB_HW_BREAKPOINT_LIST_SIZE) && (HAL_STUB_HW_BREAKPOINT_LIST_SIZE > 0)
  __clear_hw_breakpoint_list();
#endif
#if defined(HAL_STUB_HW_WATCHPOINT_LIST_SIZE) && (HAL_STUB_HW_WATCHPOINT_LIST_SIZE > 0)
  __clear_hw_watchpoint_list();
#endif
  HAL_ICACHE_INVALIDATE_ALL();
}

int
__display_breakpoint_list (void (*print_func)(target_register_t))
{
  struct breakpoint_list *l = breakpoint_list;

  while (l != NULL)
    {
      print_func(l->addr);
      l = l->next;
    }

  return 0;
}
#else  // (CYGNUM_HAL_BREAKPOINT_LIST_SIZE == 0) or UNDEFINED

#include <cyg/hal/hal_stub.h>           // Our header

#ifndef CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS
// We don't know that type target_register_t is yet.
// Let's just pick a type so we can compile.  Since
// these versions of the functions don't actually do
// anything with the parameters, the actualy types
// don't matter.
typedef unsigned long target_register_t;
#endif

int
__set_breakpoint (target_register_t addr, target_register_t len)
{
  return 1;
}

int
__remove_breakpoint (target_register_t addr, target_register_t len)
{
  return 1;
}

void
__install_breakpoint_list (void)
{
}

void
__clear_breakpoint_list (void)
{
}

int
__display_breakpoint_list (void (*print_func)(target_register_t))
{
    return 0;
}
#endif // (CYGNUM_HAL_BREAKPOINT_LIST_SIZE > 0)