Subversion Repositories openrisc

//==========================================================================

//

//      monitor.c

//

//      Monitor shell and main routines for CygMON the Wonder Monitor

//

//==========================================================================

//####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: gthomas, dmoseley

// Date:         1999-10-20

// Purpose:      Monitor shell and main routines for CygMON the Wonder Monitor

// Description:  

//               

//

//####DESCRIPTIONEND####

//

//=========================================================================

/* Platform-independent code for cygmon */

#include <stdlib.h>

#include <unistd.h>

#ifdef HAVE_BSP

#include <bsp/bsp.h>

#include <bsp/cpu.h>

#include <bsp/hex-utils.h>

#endif

#include <monitor.h>

#ifdef HAVE_BSP

#include "cpu_info.h"

#endif

#include <ledit.h>

#include <signal.h>

#include <string.h>

#include <ctype.h>

#if USE_CYGMON_PROTOTYPES

/* Use common prototypes */

/* Some of the composed board.h files compose these

   prototypes redundently, but if they dont,

   these are the common definitions */

#include "fmt_util.h"   /* Interface to string formatting utilities */

#include "tservice.h"   /* Interface to target specific services */

#include "generic-stub.h" /* from libstub */

#endif /* USE_CYGMON_PROTOTYPES */

static int  cygmon_handle_exception (int sigval);

static void monitor_take_control (void);

#if CYGMON_SYSTEM_SERVICES

extern int process_syscall (int syscall_num);

#elif defined (USE_ECOS_HAL_EXCEPTIONS)

static int cygmon_process_syscall (int sigval);

#endif

int stub_is_active = 0;

mem_addr_t last_pc;

#ifdef HAVE_BSP

#if !defined(USE_ECOS_HAL_EXCEPTIONS)

static int mon_dbg_handler(int exc_nr, void *regs);

static int mon_kill_handler(int exc_nr, void *regs);

#endif // USE_ECOS_HAL_EXCEPTIONS

#ifndef USE_ECOS_HAL_BREAKPOINTS

#define __is_breakpoint_function() (get_pc() == (target_register_t)bsp_breakinsn)

#endif

#ifdef __ECOS__

/*

 * This global flag is used by generic-stub.c to communicate to us that we

 * are processing the breakpoint function within Cygmon itself.

 */

extern int processing_breakpoint_function;

#endif

/* Global pointer to current set of saved registers. */

void *mon_saved_regs;

/* Original BSP debug vector replaced by monitor. */

#if !defined(USE_ECOS_HAL_EXCEPTIONS)

static bsp_handler_t old_dbg_vec;

#endif // !defined(USE_ECOS_HAL_EXCEPTIONS)

#else

static int handle_signal (int signal_val);

__PFI user_signal_handler = NULL;

#endif

#if defined(__ECOS__)

#include <cyg/hal/hal_stub.h>

#endif

#if defined(__ECOS__) && !defined(PROCESS_EXCEPTION_VEC_PROTOTYPE_EXISTS)

#define PROCESS_EXCEPTION_VEC_PROTOTYPE_EXISTS

extern volatile __PFI (*__process_exception_vec)(int);

#endif

#ifdef MONITOR_CONTROL_INTERRUPTS

/* This is set if the user wants interrupts enabled in the monitor. */

static int monitor_interrupts_enabled;

#endif

#if NOMAIN

int monitor_main (int argc, char **argv) /* Suppress default main() junk */

#else

int main (int argc, char **argv)

#endif

{

#ifdef HAVE_BSP

  int  cur_port;

  struct bsp_comm_info comm_info;

#else

  /* Set up exception handling traps */

  initialize_stub ();

#endif

  initialize_mon ();

#ifdef HAVE_BSP

  /* get info on debug channel */

  cur_port = bsp_set_debug_comm(-1);

  bsp_sysinfo(BSP_INFO_COMM, cur_port, &comm_info);

  /*

   * If we're using a network interface, don't install

   * the cygmon vectors. Currently, we only support stub

   * mode over a network connection.

   */

  if (comm_info.kind != BSP_COMM_ENET)

    {

      xprintf("\n");

      version ();

      /* replace original BSP debug and kill handler with ours */

#if !defined(USE_ECOS_HAL_EXCEPTIONS)

      old_dbg_vec = bsp_install_dbg_handler(mon_dbg_handler);

      (void)bsp_install_kill_handler(mon_kill_handler);

#else

      /* replace original BSP debug and kill handler with ours using eCos stuff */

      __process_exception_vec = (__PFI)cygmon_handle_exception;

      __process_syscall_vec = cygmon_process_syscall;

      __process_exit_vec = monitor_take_control;

#endif // __ECOS__

    }

  else

    {

      /* This forces the console to use the gdb channel. */

      bsp_set_console_comm(cur_port);

    }

#else

  xprintf("\n");

  version ();

  __process_exception_vec = cygmon_handle_exception;

  __process_exit_vec = monitor_take_control;

#if CYGMON_SYSTEM_SERVICES

  __process_syscall_vec = process_syscall;

#endif  

  __process_signal_vec = handle_signal;

  __init_vec = install_breakpoints;

  __cleanup_vec = clear_breakpoints;

#endif

#if 0

#ifdef __ECOS__

  __process_exception_vec = cygmon_handle_exception;

#endif

#endif

  while (1)

    {

      breakpoint ();

      if (switch_to_stub_flag)

        {

          xprintf("Switching to stub\n");

          switch_to_stub_flag = 0;

        }

    }

  /* never reached */

  exit (0);

}

/* Transfer control to gdb stub */

int

transfer_to_stub ()

{

  /* Return back to the exception handler, but the exception handler

     should invoke the stub's exception handler instead of ours. */

#if defined(HAVE_BSP) && !defined(USE_ECOS_HAL_EXCEPTIONS)

  (void)bsp_install_dbg_handler(old_dbg_vec);

#else

  __switch_to_stub ();

#endif

  /* The stub is now active. */

  stub_is_active = 1;

  return -1;

}

void

clear_user_state (void)

{

#ifdef HAS_TIMER

  if (__timer_enabled ())

    __settimer (0, 0);

#endif

  clear_breakpoints ();

#ifndef HAVE_BSP

  user_signal_handler = NULL;

#endif

  __clear_single_step ();

}

static void

monitor_take_control (void)

{

  stub_is_active = 0;

  switch_to_stub_flag = 0;

  // Flush the unget state.  This is because the ecos stub and Cygmon track this

  // stuff separately.

  bsp_debug_ungetc('\0');

#ifdef INITIALIZE_MON_EACH_TIME

  // Call the per-stop initialization routine if it is defined.

  INITIALIZE_MON_EACH_TIME();

#endif

#if defined(HAVE_BSP) && !defined(USE_ECOS_HAL_EXCEPTIONS)

  /* replace original BSP debug trap handler with ours */

  (void)bsp_install_dbg_handler(mon_dbg_handler);

#else

  clear_user_state ();

  __process_exception_vec = cygmon_handle_exception;

#endif

}

#ifdef MONITOR_CONTROL_INTERRUPTS

void

monitor_enable_interrupts (void)

{

  monitor_interrupts_enabled = 1;

  enable_interrupts ();

}

void

monitor_disable_interrupts (void)

{

  monitor_interrupts_enabled = 0;

  disable_interrupts ();

}

int

monitor_interrupt_state (void)

{

  return monitor_interrupts_enabled;

}

#endif

#if defined(USE_ECOS_HAL_EXCEPTIONS)

externC HAL_SavedRegisters *_hal_registers;

extern int machine_syscall(HAL_SavedRegisters *regs);

static int

cygmon_process_syscall (int sigval)

{

    return machine_syscall(_hal_registers);

}

#endif

static int

cygmon_handle_exception (int sigval)

{

  target_register_t pc;

#ifdef MONITOR_CONTROL_INTERRUPTS

  if (monitor_interrupts_enabled)

    {

      if (! __in_interrupt)

        enable_interrupts ();

    }

#endif

#ifdef TARGET_EXCEPTION_CODE

  TARGET_EXCEPTION_CODE

#endif

#ifndef HAVE_BSP

  if (sigval != SIGKILL)

    if (handle_signal (sigval) == 0)

      return 0;

#endif

  clear_user_state ();

  /* We may want to tweak the PC to point at the faulting instruction,

     for example. (breakpoints on x86). */

#ifdef TARGET_ADJUST_PC

  TARGET_ADJUST_PC

#endif

  pc = get_pc();

  MAKE_STD_ADDR (pc, &last_pc);

#ifdef __ECOS__

  if ((sigval == SIGTRAP) && (__is_breakpoint_function() || processing_breakpoint_function))

#else

  if ((sigval == SIGTRAP) && __is_breakpoint_function())

#endif

    {

      /*

       * This is the initial breakpoint inserted by the BSP

       * Don't print anything for this as it is confusing

       */

    }

  else

    {

      if (sigval == SIGTRAP)

          xprintf ("Hit breakpoint");

      else

          xprintf ("Got signal %d", sigval);

      xprintf (" at 0x%s\n", int2str (pc, 16, sizeof (target_register_t) * 2));

#ifdef DISASSEMBLER

      if (!__is_breakpoint_function ())

        {

          do_dis (&last_pc);

          flush_dis ();

        }

#endif

    }

  monitor_take_control ();

  return monitor_loop ();

}

#ifndef HAVE_BSP

/* Returns 0 if the program should restart at the point at which the

   signal was received, -1 otherwise. */

static int

handle_signal (int signal)

{

  if (signal == SIGKILL)

    return -1;

  if (user_signal_handler != NULL)

    {

      int result = user_signal_handler (signal);

      switch (result)

        {

          /* Don't ignore potential hardware signals. */

        case 3:

          if (signal == SIGSEGV || signal == SIGBUS || signal == SIGFPE

              || signal == SIGTRAP || signal == SIGILL)

            return -1;

        case 0:

          return 0;

        default:

        case 1:

        case 2:

          return -1;

        }

    }

    return -1;

}

#endif

void

version (void)

{

#ifdef HAVE_BSP

  struct bsp_platform_info platform;

  struct bsp_mem_info      mem;

  int                      i;

  unsigned long            u, totmem, topmem;

#endif

  extern char *build_date;

  xprintf ("Cygmon, the Cygnus ROM monitor.\n");

  xprintf ("Copyright(c) 1997, 1998, 1999, 2000 Red Hat\n\n");

  xprintf ("Version: %s\nThis image was built on %s\n\n",

           VERSION, build_date);

#ifdef HAVE_BSP

  bsp_sysinfo(BSP_INFO_PLATFORM, &platform);

  totmem = topmem = 0;

  i = 0;

  while (bsp_sysinfo(BSP_INFO_MEMORY, i++, &mem) == 0)

    {

      if (mem.kind == BSP_MEM_RAM)

        {

          totmem += mem.nbytes;

          u = (unsigned long)mem.virt_start + mem.nbytes;

          if (u > topmem)

            topmem = u;

        }

    }

  xprintf("CPU: %s\n", platform.cpu);

  xprintf("Board: %s\n", platform.board);

  if (*(platform.extra))

      xprintf("%s\n", platform.extra);

  xprintf("Total RAM: %d bytes\n", totmem);

  xprintf("Top of RAM: 0x%x\n", topmem);

#endif

}

#ifdef HAVE_BSP

#if !defined(USE_ECOS_HAL_EXCEPTIONS)

static int

mon_kill_handler(int exc_nr, void *regs)

{

    monitor_take_control();

    return 1;

}

#endif // !defined(USE_ECOS_HAL_EXCEPTIONS)

#if !defined(USE_ECOS_HAL_EXCEPTIONS)

static int

mon_dbg_handler(int exc_nr, void *regs)

{

    int sig;

    unsigned long cur_pc;

    mon_saved_regs = regs;

    sig = bsp_get_signal(exc_nr, regs);

    cygmon_handle_exception(sig);

    cur_pc = bsp_get_pc(regs);

    if (cur_pc == (unsigned long)bsp_breakinsn)

        bsp_skip_instruction(regs);

    if (!stub_is_active)

        install_breakpoints();

    return 1;

}

#endif // !defined(USE_ECOS_HAL_EXCEPTIONS)

#endif