Changeset cb1e8497 in rtems


Ignore:
Timestamp:
Jun 25, 2019, 11:07:40 AM (5 months ago)
Author:
Chris Johns <chrisj@…>
Branches:
master
Children:
7d4f74e
Parents:
98d6792
git-author:
Chris Johns <chrisj@…> (06/25/19 11:07:40)
git-committer:
Chris Johns <chrisj@…> (07/30/19 22:33:05)
Message:

libdebugger: ARM fixes for Cortex-A8 and ARM mode.

  • Fix destorying the target and thread parts.
  • Fix the ARM backend to support Cortex-A8 and ARM mode code.
  • Use the DBGDSCR interrupt mask when single stepping.
  • Use the DBGDSCR method of entry to debug mode to filter the execptions.
  • Add support for BSPs to control the ARM backend.
Location:
cpukit
Files:
2 added
4 edited

Legend:

Unmodified
Added
Removed
  • cpukit/Makefile.am

    r98d6792 rcb1e8497  
    18831883libdebugger_a_SOURCES =
    18841884libdebugger_a_SOURCES += libdebugger/rtems-debugger-block.c
     1885libdebugger_a_SOURCES += libdebugger/rtems-debugger-bsp.c
    18851886libdebugger_a_SOURCES += libdebugger/rtems-debugger-cmd.c
    18861887libdebugger_a_SOURCES += libdebugger/rtems-debugger-remote.c
  • cpukit/libdebugger/rtems-debugger-arm.c

    r98d6792 rcb1e8497  
    3838#include <rtems/score/threadimpl.h>
    3939
     40#include <rtems/debugger/rtems-debugger-bsp.h>
     41
    4042#include "rtems-debugger-target.h"
    4143#include "rtems-debugger-threads.h"
     
    7779 * If the variant only supports thumb insturctions disable the support.
    7880 */
    79 #define ARM_SWITCH_REG     uint32_t arm_switch_reg
    80 #define ARM_SWITCH_REG_ASM [arm_switch_reg] "=&r" (arm_switch_reg)
    8181#if !ARM_THUMB_ONLY && defined(__thumb__)
    82   #define ASM_ARM_MODE   ".align 2\nbx pc\n.arm\n"
    83   #define ASM_THUMB_MODE "add %[arm_switch_reg], pc, #1\nbx %[arm_switch_reg]\n.thumb\n"
     82  #define ARM_SWITCH_REG       uint32_t arm_switch_reg
     83  #define ARM_SWITCH_REG_ASM   [arm_switch_reg] "=&r" (arm_switch_reg)
     84  #define ARM_SWITCH_REG_ASM_L ARM_SWITCH_REG_ASM,
     85  #define ASM_ARM_MODE         ".align 2\nbx pc\n.arm\n"
     86  #define ASM_THUMB_MODE       "add %[arm_switch_reg], pc, #1\nbx %[arm_switch_reg]\n.thumb\n"
    8487#else
     88  #define ARM_SWITCH_REG
     89  #define ARM_SWITCH_REG_ASM
     90  #define ARM_SWITCH_REG_ASM_L
    8591  #define ASM_ARM_MODE
    8692  #define ASM_THUMB_MODE
     
    199205 */
    200206#if defined(ARM_MULTILIB_ARCH_V4)
    201  #define FRAME_SR frame->register_cpsr
     207 #define FRAME_SR(_frame) (_frame)->register_cpsr
    202208#elif defined(ARM_MULTILIB_ARCH_V7M)
    203  #define FRAME_SR frame->register_xpsr
     209 #define FRAME_SR(_frame) (_frame)->register_xpsr
    204210#else
    205211 #error ARM architecture is not supported.
    206212#endif
     213
     214/**
     215 * Print the exception frame.
     216 */
     217#define EXC_FRAME_PRINT(_out, _prefix, _frame) \
     218do { \
     219  _out(_prefix "  R0 = %08" PRIx32 "  R1 = %08" PRIx32       \
     220               "  R2 = %08" PRIx32 "  R3 = %08" PRIx32 "\n", \
     221       _frame->register_r0, _frame->register_r1, \
     222       _frame->register_r2, _frame->register_r3); \
     223  _out(_prefix "  R4 = %08" PRIx32 "  R5 = %08" PRIx32       \
     224               "  R6 = %08" PRIx32 "  R7 = %08" PRIx32 "\n", \
     225       _frame->register_r4, _frame->register_r5, \
     226       _frame->register_r6, _frame->register_r7); \
     227  _out(_prefix "  R8 = %08" PRIx32 "  R9 = %08" PRIx32       \
     228               " R10 = %08" PRIx32 " R11 = %08" PRIx32 "\n", \
     229       _frame->register_r8, _frame->register_r9, \
     230       _frame->register_r10, _frame->register_r11); \
     231  _out(_prefix " R12 = %08" PRIx32 "  SP = %08" PRIx32       \
     232               "  LR = %08" PRIxPTR "  PC = %08" PRIxPTR "\n", \
     233       _frame->register_r12, _frame->register_sp, \
     234       (intptr_t) _frame->register_lr, (intptr_t) _frame->register_pc); \
     235  _out(_prefix " CPSR = %08" PRIx32 " %c%c%c%c%c%c%c%c%c%c%c"       \
     236               " GE:%" PRIx32 " IT:%02" PRIx32 " M:%" PRIx32 " %s\n", \
     237       FRAME_SR(_frame), \
     238       (FRAME_SR(_frame) & (1 << 31)) != 0 ? 'N' : '-', \
     239       (FRAME_SR(_frame) & (1 << 30)) != 0 ? 'Z' : '-', \
     240       (FRAME_SR(_frame) & (1 << 29)) != 0 ? 'C' : '-', \
     241       (FRAME_SR(_frame) & (1 << 28)) != 0 ? 'V' : '-', \
     242       (FRAME_SR(_frame) & (1 << 27)) != 0 ? 'Q' : '-', \
     243       (FRAME_SR(_frame) & (1 << 24)) != 0 ? 'J' : '-', \
     244       (FRAME_SR(_frame) & (1 <<  9)) != 0 ? 'E' : '-', \
     245       (FRAME_SR(_frame) & (1 <<  8)) != 0 ? 'A' : '-', \
     246       (FRAME_SR(_frame) & (1 <<  7)) != 0 ? 'I' : '-', \
     247       (FRAME_SR(_frame) & (1 <<  6)) != 0 ? 'F' : '-', \
     248       (FRAME_SR(_frame) & (1 <<  5)) != 0 ? 'T' : '-', \
     249       (FRAME_SR(_frame) >> 16) & 0xf, \
     250       ((FRAME_SR(_frame) >> (25 - 5)) & (0x3 << 5)) | ((FRAME_SR(_frame) >> 10) & 0x1f), \
     251       FRAME_SR(_frame) & 0x1f, arm_mode_label(FRAME_SR(_frame) & 0x1f)); \
     252} while (0)
    207253
    208254/**
     
    221267
    222268/**
     269 * An exception offset is added to the return address of the PC on an
     270 * exception's stack frame. The PC needs to be adjusted.
     271 */
     272static const size_t exc_offsets[2][5] =
     273{
     274  /* ARM undef_ins sup call pref abt data abt */
     275  {  0,  4,        0,       4,       8 },
     276  /* TMB undef_ins sup call pref abt data abt */
     277  {  0,  2,        0,       4,       8 }
     278};
     279
     280/**
    223281 * Is a session active?
    224282 */
     
    228286 * ARM debug hardware.
    229287 */
    230 static int debug_version;
    231 static int debug_revision;;
    232 static int hw_breakpoints;
    233 static int hw_watchpoints;
     288static int   debug_version;
     289static void* debug_registers;
     290static int   debug_revision;
     291static bool  debug_disable_ints;
     292static int   hw_breakpoints;
     293static int   hw_watchpoints;
    234294
    235295/**
     
    267327//static arm_debug_hwbreak hw_watches[ARM_HW_WATCHPOINT_MAX];
    268328
     329/*
     330 * Method of entry (MOE) to debug mode. Bits [5:2] of DBGDSCR.
     331 */
     332#define ARM_HW_DSCR_MOE_HALT_REQUEST       (0x0)
     333#define ARM_HW_DSCR_MOE_BREAKPOINT_EVENT   (0x1)
     334#define ARM_HW_DSCR_MOE_ASYNC_WATCHPOINT   (0x2)
     335#define ARM_HW_DSCR_MOE_BREAKPOINT_INSTR   (0x3)
     336#define ARM_HW_DSCR_MOE_EXTERNAL           (0x4)
     337#define ARM_HW_DSCR_MOE_VECTOR_CATCH_EVENT (0x5)
     338#define ARM_HW_DSCR_MOE_OS_UNLOCK_EVENT    (0x8)
     339#define ARM_HW_DSCR_MOE_SYNC_WATCHPOINT    (0xa)
     340
     341/*
     342 * Use to locally probe and catch exceptions when accessinf suspect addresses.
     343 */
     344static void __attribute__((naked)) arm_debug_unlock_abort(void);
     345
     346/*
     347 * Target debugging support. Use this to debug the backend.
     348 */
    269349#if TARGET_DEBUG
    270350void rtems_debugger_printk_lock(rtems_interrupt_lock_context* lock_context);
     
    314394}
    315395
     396#if TARGET_DEBUG
     397static const char*
     398arm_moe_label(uint32_t moe)
     399{
     400  switch (moe) {
     401  case ARM_HW_DSCR_MOE_HALT_REQUEST:
     402    return "HLT";
     403  case ARM_HW_DSCR_MOE_BREAKPOINT_EVENT:
     404    return "BPE";
     405  case ARM_HW_DSCR_MOE_ASYNC_WATCHPOINT:
     406    return "AWP";
     407  case ARM_HW_DSCR_MOE_BREAKPOINT_INSTR:
     408    return "BPI";
     409  case ARM_HW_DSCR_MOE_EXTERNAL:
     410    return "EXT";
     411  case ARM_HW_DSCR_MOE_VECTOR_CATCH_EVENT:
     412    return "VCE";
     413  case ARM_HW_DSCR_MOE_OS_UNLOCK_EVENT:
     414    return "OUL";
     415  case ARM_HW_DSCR_MOE_SYNC_WATCHPOINT:
     416    return "SWP";
     417  default:
     418    break;
     419  }
     420  return "RSV";
     421}
     422#endif
     423
    316424/*
    317425 * CP register access.
     
    338446      ARM_CP_INSTR(mrc, _cp, _op1, val, _CRn, _CRm, _op2)  \
    339447      ASM_THUMB_MODE                                       \
    340       : ARM_SWITCH_REG_ASM,                                \
     448      : ARM_SWITCH_REG_ASM_L                               \
    341449        [val] "=&r" (_val));                               \
    342450  } while (0)
     451
     452/*
     453 * CP14 register access.
     454 *
     455 * The registers can be access via the core or they can be memory-mapped.
     456 */
    343457
    344458/*
     
    367481#define ARM_CP15_READ(_val, _op1, _CRn, _CRm, _op2)  \
    368482  ARM_CP_READ(15, _op1, _val, _CRn, _CRm, _op2)
     483
     484/*
     485 * Read and write a memory mapped debug register. The register number is a word
     486 * offset from the base address.
     487 */
     488#define ARM_MMAP_ADDR(reg)       (((volatile uint32_t*) debug_registers) + (reg))
     489#define ARM_MMAP_WRITE(reg, val) *ARM_MMAP_ADDR(reg) = (val); _ARM_Data_synchronization_barrier()
     490#define ARM_MMAP_READ(reg)       *ARM_MMAP_ADDR(reg)
     491
     492static bool
     493arm_debug_authentication(uint32_t dbgauthstatus)
     494{
     495  bool granted = (dbgauthstatus & (1 << 0)) != 0;
     496  rtems_debugger_printf("rtems-db: arm debug: authentication: %s " \
     497                        "(%s %s %s %s %s %s %s %s)\n",
     498                        granted ? "granted" : "denied",
     499                        (dbgauthstatus & (1 << 0)) == 0 ? "-" : "NSE",
     500                        (dbgauthstatus & (1 << 1)) == 0 ? "-" : "NSI",
     501                        (dbgauthstatus & (1 << 2)) == 0 ? "-" : "NSNE",
     502                        (dbgauthstatus & (1 << 3)) == 0 ? "-" : "NSNI",
     503                        (dbgauthstatus & (1 << 4)) == 0 ? "-" : "SE",
     504                        (dbgauthstatus & (1 << 5)) == 0 ? "-" : "SI",
     505                        (dbgauthstatus & (1 << 6)) == 0 ? "-" : "SNE",
     506                        (dbgauthstatus & (1 << 7)) == 0 ? "-" : "SNI");
     507  return granted;
     508}
     509
     510static int
     511arm_debug_cp14_enable(rtems_debugger_target* target)
     512{
     513  uint32_t val;
     514  ARM_CP14_READ(val, 7, 14, 6);
     515  if (!arm_debug_authentication(val))
     516    return -1;
     517  ARM_CP14_READ(val, 0, 1, 0);
     518  if ((val & (1 << 15)) == 0) {
     519    switch (debug_version) {
     520    case 1:
     521    case 2:
     522      ARM_CP14_WRITE(val | (1 << 15), 0, 1, 0);
     523      break;
     524    case 3:
     525    case 5:
     526    default:
     527      ARM_CP14_WRITE(val | (1 << 15), 0, 2, 2);
     528      break;
     529    case 4:
     530      rtems_debugger_printf("rtems-db: arm debug: no cp14 access with version 4\n");
     531      return -1;
     532    }
     533    ARM_CP14_READ(val, 0, 1, 0);
     534    if ((val & (1 << 15)) == 0) {
     535      rtems_debugger_printf("rtems-db: arm debug: cannot enter monitor mode\n");
     536      errno = EIO;
     537      return -1;
     538    }
     539  }
     540  rtems_debugger_printf("rtems-db: arm debug: using cp14 register access\n");
     541  return 0;
     542}
     543
     544/*
     545 * The write access to the software unlock register can cause an abort. Absorb
     546 * it.
     547 */
     548static jmp_buf unlock_abort_jmpbuf;
     549static size_t  arm_debug_retries;
     550
     551static int
     552arm_debug_mmap_enable(rtems_debugger_target* target, uint32_t dbgdidr)
     553{
     554  uint32_t rom;
     555  uint32_t val;
     556  void*    abort_handler;
     557  int      rc = -1;
     558
     559  /*
     560   * File scope as setjmp/longjmp effect the local stack variables.
     561   */
     562  arm_debug_retries = 5;
     563
     564  /*
     565   * The DBGDSAR is a signed offset from DBGDRAR. Both need to be
     566   * valid for the debug register address to be valid. Currently there
     567   * is no support to decode a ROM table.
     568   */
     569  ARM_CP14_READ(rom, 1, 0, 0);
     570  if ((rom & 3) == 3) {
     571    ARM_CP14_READ(val, 2, 0, 0);
     572    if ((val & 3) == 3 ) {
     573      debug_registers = (void*) ((rom & ~3) + ((int32_t) (val & ~3)));
     574    }
     575  }
     576
     577  if (debug_registers == NULL) {
     578    debug_registers = rtems_debugger_arm_debug_registers();
     579    if (debug_registers == NULL) {
     580      rtems_debugger_printf("rtems-db: arm debug: no valid register map\n");
     581      return -1;
     582    }
     583  }
     584
     585  /*
     586   * Make sure the memory mapped registers return the same ID.
     587   */
     588  if (ARM_MMAP_READ(0) != dbgdidr) {
     589    debug_registers = NULL;
     590    rtems_debugger_printf("rtems-db: arm debug: debug reg map not verified: " \
     591                          "0x%08x\n", ARM_MMAP_READ(0));
     592    return -1;
     593  }
     594
     595  if (!arm_debug_authentication(ARM_MMAP_READ(1006)))
     596    return -1;
     597
     598#if ARM_CP15
     599  abort_handler =
     600    arm_cp15_set_exception_handler(ARM_EXCEPTION_DATA_ABORT,
     601                                   arm_debug_unlock_abort);
     602#endif
     603
     604  while (arm_debug_retries-- > 0) {
     605    if (setjmp(unlock_abort_jmpbuf) == 0) {
     606      /*
     607       * If there is a software lock and it is locked unlock it.
     608       *
     609       * On the TI am335x this can cause a data abort which we catch and retry
     610       * which seems to make the debug hardware work.
     611       */
     612      if (ARM_MMAP_READ(1005) == 3) {
     613        ARM_MMAP_WRITE(1004, 0xC5ACCE55);
     614      }
     615      /*
     616       * Are we already in debug mode?
     617       */
     618      val = ARM_MMAP_READ(34);
     619      if ((val & (1 << 15)) == 0) {
     620        rtems_debugger_printf("rtems-db: arm debug: enable debug mode\n");
     621        val = ARM_MMAP_READ(34);
     622        ARM_MMAP_WRITE(34, ARM_MMAP_READ(34) | (1 << 15));
     623        arm_debug_retries = 0;
     624      }
     625    }
     626  }
     627
     628#if ARM_CP15
     629  arm_cp15_set_exception_handler(ARM_EXCEPTION_DATA_ABORT, abort_handler);
     630#endif
     631
     632  if (arm_debug_retries > 0) {
     633    rtems_debugger_printf("rtems-db: arm debug: using debug register access\n");
     634    rc = 0;
     635  }
     636  else {
     637    rtems_debugger_printf("rtems-db: arm debug: cannot enter debug mode\n");
     638  }
     639
     640  val = ARM_MMAP_READ(1006);
     641
     642  return rc;
     643}
    369644
    370645static int
     
    381656    "ARMv7 [v7.1]"
    382657  };
     658  int rc = -1;
     659
     660#if ARM_CP15
     661  ARM_CP15_READ(val, 0, 0, 0, 0);
     662  rtems_debugger_printf("rtems-db: arm core: Architecture: %d Variant: %d " \
     663                        "Implementor: %d Part Number: %d Revision: %d\n",
     664                        (val >> 16) & ((1 << (19 - 16 + 1)) - 1),
     665                        (val >> 20) & ((1 << (23 - 20 + 1)) - 1),
     666                        (val >> 24) & ((1 << (31 - 24 + 1)) - 1),
     667                        (val >>  4) & ((1 << (15 -  4 + 1)) - 1),
     668                        (val >>  0) & ((1 << ( 3 -  0 + 1)) - 1));
     669#endif
     670
    383671  ARM_CP14_READ(val, 0, 0, 0);
     672
    384673  debug_version = ID_VALUE(val, 19, 16);
    385674  if (debug_version < 1 || debug_version > 5) {
     
    389678    return -1;
    390679  }
     680
    391681  vl = labels[debug_version - 1];
    392682  debug_revision = ID_VALUE(val, 3, 0);
    393683  hw_breakpoints = ID_VALUE(val, 27, 24);
    394684  hw_watchpoints = ID_VALUE(val, 31, 28);
    395   rtems_debugger_printf("rtems-db: arm debug: (v%d.%d) %s breakpoints:%d watchpoints:%d\n",
     685
     686  rtems_debugger_printf("rtems-db: arm debug: (v%d.%d) %s " \
     687                        "breakpoints:%d watchpoints:%d\n",
    396688                        debug_version, debug_revision, vl,
    397689                        hw_breakpoints, hw_watchpoints);
    398   ARM_CP14_READ(val, 0, 1, 0);
    399   if ((val & (1 << 15)) == 0) {
    400     switch (debug_version) {
     690
     691  if (!rtems_debugger_arm_debug_configure())
     692    return -1;
     693
     694  switch (debug_version) {
    401695    case 1:
    402696    case 2:
    403       ARM_CP14_WRITE(val | (1 << 15), 0, 1, 0);
    404       break;
    405697    case 3:
    406     case 4:
    407698    case 5:
    408699    default:
    409       ARM_CP14_WRITE(val | (1 << 15), 0, 2, 2);
     700      rc = arm_debug_mmap_enable(target, val);
     701      if (rc != 0)
     702        rc =  arm_debug_cp14_enable(target);
    410703      break;
    411     }
    412     ARM_CP14_READ(val, 0, 1, 0);
    413     if ((val & (1 << 15)) == 0) {
    414       rtems_debugger_printf("rtems-db: arm debug: cannot enter monitor mode\n");
    415       errno = EIO;
    416       return -1;
    417     }
    418   }
    419   return 0;
     704    case 4:
     705      rc = arm_debug_mmap_enable(target, val);
     706      break;
     707  }
     708
     709  return rc;
    420710}
    421711
     
    436726arm_debug_break_write_control(int bp, uint32_t control)
    437727{
    438   switch (bp) {
    439   case 0:
    440     ARM_CP14_WRITE(control, 0, 0, 5);
    441     break;
    442   case 1:
    443     ARM_CP14_WRITE(control, 0, 1, 5);
    444     break;
    445   case 2:
    446     ARM_CP14_WRITE(control, 0, 2, 5);
    447     break;
    448   case 3:
    449     ARM_CP14_WRITE(control, 0, 3, 5);
    450     break;
    451   case 4:
    452     ARM_CP14_WRITE(control, 0, 4, 5);
    453     break;
    454   case 5:
    455     ARM_CP14_WRITE(control, 0, 5, 5);
    456     break;
    457   case 6:
    458     ARM_CP14_WRITE(control, 0, 6, 5);
    459     break;
    460   case 7:
    461     ARM_CP14_WRITE(control, 0, 7, 5);
    462     break;
    463   case 8:
    464     ARM_CP14_WRITE(control, 0, 8, 5);
    465     break;
    466   case 9:
    467     ARM_CP14_WRITE(control, 0, 9, 5);
    468     break;
    469   case 10:
    470     ARM_CP14_WRITE(control, 0, 10, 5);
    471     break;
    472   case 11:
    473     ARM_CP14_WRITE(control, 0, 11, 5);
    474     break;
    475   case 12:
    476     ARM_CP14_WRITE(control, 0, 12, 5);
    477     break;
    478   case 13:
    479     ARM_CP14_WRITE(control, 0, 13, 5);
    480     break;
    481   case 14:
    482     ARM_CP14_WRITE(control, 0, 14, 5);
    483     break;
    484   case 15:
    485     ARM_CP14_WRITE(control, 0, 15, 5);
    486     break;
     728  if (bp < 15) {
     729    if (debug_registers != NULL) {
     730      ARM_MMAP_WRITE(80 + bp, control);
     731    }
     732    else {
     733      switch (bp) {
     734      case 0:
     735        ARM_CP14_WRITE(control, 0, 0, 5);
     736        break;
     737      case 1:
     738        ARM_CP14_WRITE(control, 0, 1, 5);
     739        break;
     740      case 2:
     741        ARM_CP14_WRITE(control, 0, 2, 5);
     742        break;
     743      case 3:
     744        ARM_CP14_WRITE(control, 0, 3, 5);
     745        break;
     746      case 4:
     747        ARM_CP14_WRITE(control, 0, 4, 5);
     748        break;
     749      case 5:
     750        ARM_CP14_WRITE(control, 0, 5, 5);
     751        break;
     752      case 6:
     753        ARM_CP14_WRITE(control, 0, 6, 5);
     754        break;
     755      case 7:
     756        ARM_CP14_WRITE(control, 0, 7, 5);
     757        break;
     758      case 8:
     759        ARM_CP14_WRITE(control, 0, 8, 5);
     760        break;
     761      case 9:
     762        ARM_CP14_WRITE(control, 0, 9, 5);
     763        break;
     764      case 10:
     765        ARM_CP14_WRITE(control, 0, 10, 5);
     766        break;
     767      case 11:
     768        ARM_CP14_WRITE(control, 0, 11, 5);
     769        break;
     770      case 12:
     771        ARM_CP14_WRITE(control, 0, 12, 5);
     772        break;
     773      case 13:
     774        ARM_CP14_WRITE(control, 0, 13, 5);
     775        break;
     776      case 14:
     777        ARM_CP14_WRITE(control, 0, 14, 5);
     778        break;
     779      case 15:
     780        ARM_CP14_WRITE(control, 0, 15, 5);
     781        break;
     782      }
     783    }
    487784  }
    488785}
     
    491788arm_debug_break_write_value(int bp, uint32_t value)
    492789{
    493   switch (bp) {
    494   case 0:
    495     ARM_CP14_WRITE(value, 0, 0, 4);
    496     break;
    497   case 1:
    498     ARM_CP14_WRITE(value, 0, 1, 4);
    499     break;
    500   case 2:
    501     ARM_CP14_WRITE(value, 0, 2, 4);
    502     break;
    503   case 3:
    504     ARM_CP14_WRITE(value, 0, 3, 4);
    505     break;
    506   case 4:
    507     ARM_CP14_WRITE(value, 0, 4, 4);
    508     break;
    509   case 5:
    510     ARM_CP14_WRITE(value, 0, 5, 4);
    511     break;
    512   case 6:
    513     ARM_CP14_WRITE(value, 0, 6, 4);
    514     break;
    515   case 7:
    516     ARM_CP14_WRITE(value, 0, 7, 4);
    517     break;
    518   case 8:
    519     ARM_CP14_WRITE(value, 0, 8, 4);
    520     break;
    521   case 9:
    522     ARM_CP14_WRITE(value, 0, 9, 4);
    523     break;
    524   case 10:
    525     ARM_CP14_WRITE(value, 0, 10, 4);
    526     break;
    527   case 11:
    528     ARM_CP14_WRITE(value, 0, 11, 4);
    529     break;
    530   case 12:
    531     ARM_CP14_WRITE(value, 0, 12, 4);
    532     break;
    533   case 13:
    534     ARM_CP14_WRITE(value, 0, 13, 4);
    535     break;
    536   case 14:
    537     ARM_CP14_WRITE(value, 0, 14, 4);
    538     break;
    539   case 15:
    540     ARM_CP14_WRITE(value, 0, 15, 4);
    541     break;
    542   }
     790  if (bp < 15) {
     791    if (debug_registers != NULL) {
     792      ARM_MMAP_WRITE(64 + bp, value);
     793    }
     794    else {
     795      switch (bp) {
     796      case 0:
     797        ARM_CP14_WRITE(value, 0, 0, 4);
     798        break;
     799      case 1:
     800        ARM_CP14_WRITE(value, 0, 1, 4);
     801        break;
     802      case 2:
     803        ARM_CP14_WRITE(value, 0, 2, 4);
     804        break;
     805      case 3:
     806        ARM_CP14_WRITE(value, 0, 3, 4);
     807        break;
     808      case 4:
     809        ARM_CP14_WRITE(value, 0, 4, 4);
     810        break;
     811      case 5:
     812        ARM_CP14_WRITE(value, 0, 5, 4);
     813        break;
     814      case 6:
     815        ARM_CP14_WRITE(value, 0, 6, 4);
     816        break;
     817      case 7:
     818        ARM_CP14_WRITE(value, 0, 7, 4);
     819        break;
     820      case 8:
     821        ARM_CP14_WRITE(value, 0, 8, 4);
     822        break;
     823      case 9:
     824        ARM_CP14_WRITE(value, 0, 9, 4);
     825        break;
     826      case 10:
     827        ARM_CP14_WRITE(value, 0, 10, 4);
     828        break;
     829      case 11:
     830        ARM_CP14_WRITE(value, 0, 11, 4);
     831        break;
     832      case 12:
     833        ARM_CP14_WRITE(value, 0, 12, 4);
     834        break;
     835      case 13:
     836        ARM_CP14_WRITE(value, 0, 13, 4);
     837        break;
     838      case 14:
     839        ARM_CP14_WRITE(value, 0, 14, 4);
     840        break;
     841      case 15:
     842        ARM_CP14_WRITE(value, 0, 15, 4);
     843        break;
     844      }
     845    }
     846  }
     847}
     848
     849static uint32_t
     850arm_debug_dbgdscr_read(void)
     851{
     852  uint32_t val;
     853  if (debug_registers != NULL) {
     854    val = ARM_MMAP_READ(34);
     855  }
     856  else {
     857    ARM_CP14_READ(val, 0, 1, 0);
     858  }
     859  return val;
     860}
     861
     862static void
     863arm_debug_dbgdscr_write(uint32_t val)
     864{
     865  if (debug_registers != NULL) {
     866    ARM_MMAP_WRITE(34, val);
     867  }
     868  else {
     869    ARM_CP14_WRITE(val, 0, 1, 0);
     870  }
     871}
     872
     873static uint32_t
     874arm_debug_method_of_entry(void)
     875{
     876  return (arm_debug_dbgdscr_read() >> 2) & 0xf;
     877}
     878
     879static void
     880arm_debug_disable_interrupts(void)
     881{
     882  debug_disable_ints = true;
     883}
     884
     885static void
     886arm_debug_commit_interrupt_disable(void)
     887{
     888  if (debug_disable_ints) {
     889    arm_debug_dbgdscr_write(arm_debug_dbgdscr_read() | (1 << 11));
     890    debug_disable_ints = false;
     891  }
     892}
     893
     894static void
     895arm_debug_enable_interrupts(void)
     896{
     897  arm_debug_dbgdscr_write(arm_debug_dbgdscr_read() & ~(1 << 11));
    543898}
    544899
     
    560915arm_debug_set_context_id(const uint32_t id)
    561916{
     917#if ARM_CP15
    562918  ARM_CP15_WRITE(id, 0, 13, 0, 1);
     919#endif
    563920}
    564921
     
    571928{
    572929  rtems_interrupt_lock_context lock_context;
    573   arm_debug_hwbreak*            bp = &hw_breaks[0];
    574   int                           i;
     930  arm_debug_hwbreak*           bp = &hw_breaks[0];
     931  int                          i;
    575932  rtems_interrupt_lock_acquire(&target_lock, &lock_context);
    576933  if (bp->enabled && !bp->loaded) {
     
    595952  rtems_interrupt_lock_context lock_context;
    596953  arm_debug_hwbreak*           bp = &hw_breaks[0];
    597   int                i;
     954  int                          i;
    598955  rtems_interrupt_lock_acquire(&target_lock, &lock_context);
    599956  arm_debug_set_context_id(0);
     
    603960  }
    604961  rtems_interrupt_lock_release(&target_lock, &lock_context);
     962}
     963
     964static void
     965arm_debug_break_dump(void)
     966{
     967#if TARGET_DEBUG
     968  arm_debug_hwbreak* bp = &hw_breaks[0];
     969  int                i;
     970  for (i = 0; i < hw_breakpoints; ++i, ++bp) {
     971    if (bp->enabled) {
     972      target_printk("[} bp: %d: control: %08x addr: %08x\n",
     973                    i, bp->control, bp->value);
     974    }
     975  }
     976#endif
    605977}
    606978
     
    6331005
    6341006static void
     1007target_print_frame(CPU_Exception_frame* frame)
     1008{
     1009  EXC_FRAME_PRINT(target_printk, "[} ", frame);
     1010}
     1011
     1012static const size_t
     1013target_exc_offset(CPU_Exception_frame* frame)
     1014{
     1015  size_t thumb = (FRAME_SR(frame) & (1 << 5)) == 0 ? 0 : 1;
     1016  return exc_offsets[thumb][frame->vector];
     1017}
     1018
     1019static void
    6351020target_exception(CPU_Exception_frame* frame)
    6361021{
    6371022#if TARGET_DEBUG
    638   uint32_t ifsr = arm_cp15_get_instruction_fault_status();
    639 #endif
    640 
    641   target_printk("[} frame = %08" PRIx32 " sig=%d vector=%x ifsr=%08" PRIx32 " pra=%08x\n",
     1023#if ARM_CP15
     1024  const uint32_t ifsr = arm_cp15_get_instruction_fault_status();
     1025#else
     1026  const uint32_t ifsr = 0;
     1027#endif
     1028  const uint32_t mvector = frame->vector;
     1029  const uint32_t dbgdscr = arm_debug_dbgdscr_read();
     1030#endif
     1031
     1032  const uint32_t moe = arm_debug_method_of_entry();
     1033  const size_t exc_offset = target_exc_offset(frame);
     1034
     1035  switch (moe){
     1036  case ARM_HW_DSCR_MOE_BREAKPOINT_EVENT:
     1037  case ARM_HW_DSCR_MOE_BREAKPOINT_INSTR:
     1038  case ARM_HW_DSCR_MOE_ASYNC_WATCHPOINT:
     1039  case ARM_HW_DSCR_MOE_SYNC_WATCHPOINT:
     1040    frame->vector = 2;
     1041    break;
     1042  case ARM_HW_DSCR_MOE_HALT_REQUEST:
     1043  case ARM_HW_DSCR_MOE_EXTERNAL:
     1044  case ARM_HW_DSCR_MOE_VECTOR_CATCH_EVENT:
     1045  case ARM_HW_DSCR_MOE_OS_UNLOCK_EVENT:
     1046  default:
     1047    break;
     1048  }
     1049
     1050  target_printk("[} > frame = %08" PRIx32 \
     1051                " sig=%d vector=%u (%u) dbgdscr=%08" PRIx32 " moe=%s" \
     1052                " ifsr=%08" PRIx32 " pra=%08x\n",
    6421053                (uint32_t) frame,
    6431054                rtems_debugger_target_exception_to_signal(frame),
    644                 frame->vector, ifsr, (intptr_t) frame->register_pc);
    645 
    646   if ((FRAME_SR & (1 <<  5)) == 0)
    647     frame->register_pc = (void*) ((intptr_t) frame->register_pc - 8);
    648   else
    649     frame->register_pc = (void*) ((intptr_t) frame->register_pc - 4);
    650 
    651   target_printk("[}  R0 = %08" PRIx32 "  R1 = %08" PRIx32       \
    652                 "  R2 = %08" PRIx32 "  R3 = %08" PRIx32 "\n",
    653                 frame->register_r0, frame->register_r1,
    654                 frame->register_r2, frame->register_r3);
    655   target_printk("[}  R4 = %08" PRIx32 "  R5 = %08" PRIx32       \
    656                 "  R6 = %08" PRIx32 "  R7 = %08" PRIx32 "\n",
    657                 frame->register_r4, frame->register_r5,
    658                 frame->register_r6, frame->register_r7);
    659   target_printk("[}  R8 = %08" PRIx32 "  R9 = %08" PRIx32       \
    660                 " R10 = %08" PRIx32 " R11 = %08" PRIx32 "\n",
    661                 frame->register_r8, frame->register_r9,
    662                 frame->register_r10, frame->register_r11);
    663   target_printk("[} R12 = %08" PRIx32 "  SP = %08" PRIx32       \
    664                 "  LR = %08" PRIxPTR "  PC = %08" PRIxPTR "\n", \
    665                 frame->register_r12, frame->register_sp,
    666                 (intptr_t) frame->register_lr, (intptr_t) frame->register_pc);
    667   target_printk("[}  CPSR = %08" PRIx32 " %c%c%c%c%c%c%c%c%c%c%c" \
    668                 " GE:%" PRIx32 " IT:%02" PRIx32 " M:%" PRIx32 " %s\n",
    669                 FRAME_SR,
    670                 (FRAME_SR & (1 << 31)) != 0 ? 'N' : '-',
    671                 (FRAME_SR & (1 << 30)) != 0 ? 'Z' : '-',
    672                 (FRAME_SR & (1 << 29)) != 0 ? 'C' : '-',
    673                 (FRAME_SR & (1 << 28)) != 0 ? 'V' : '-',
    674                 (FRAME_SR & (1 << 27)) != 0 ? 'Q' : '-',
    675                 (FRAME_SR & (1 << 24)) != 0 ? 'J' : '-',
    676                 (FRAME_SR & (1 <<  9)) != 0 ? 'E' : '-',
    677                 (FRAME_SR & (1 <<  8)) != 0 ? 'A' : '-',
    678                 (FRAME_SR & (1 <<  7)) != 0 ? 'I' : '-',
    679                 (FRAME_SR & (1 <<  6)) != 0 ? 'F' : '-',
    680                 (FRAME_SR & (1 <<  5)) != 0 ? 'T' : '-',
    681                 ((FRAME_SR >> (25 - 5)) & (0x3 << 5)) | ((FRAME_SR >> 10) & 0x1f),
    682                 (FRAME_SR >> 16) & 0xf,
    683                 FRAME_SR & 0x1f, arm_mode_label(FRAME_SR & 0x1f));
    684 
     1055                frame->vector, mvector, dbgdscr, arm_moe_label(moe),
     1056                ifsr, (intptr_t) frame->register_pc);
     1057
     1058  frame->register_pc = (void*) ((intptr_t) frame->register_pc - exc_offset);
     1059
     1060  target_print_frame(frame);
     1061
     1062  arm_debug_enable_interrupts();
    6851063  arm_debug_break_clear();
    6861064
     
    6931071    break;
    6941072  case rtems_debugger_target_exc_step:
    695     FRAME_SR |= CPSR_INTS_MASK;
    6961073    break;
    6971074  case rtems_debugger_target_exc_cascade:
     
    7011078  }
    7021079
    703   target_printk("[} resuming frame = %08" PRIx32 " PC = %08" PRIxPTR " CPSR = %08" PRIx32 "\n",
    704                 (uint32_t) frame, (intptr_t) frame->register_pc, FRAME_SR);
     1080  target_printk("[} < resuming frame = %08" PRIx32 \
     1081                " PC = %08" PRIxPTR " CPSR = %08" PRIx32 "\n",
     1082                (uint32_t) frame, (intptr_t) frame->register_pc, FRAME_SR(frame));
     1083  target_print_frame(frame);
     1084  arm_debug_break_dump();
    7051085}
    7061086
     
    7781158#endif /* ARM_MULTILIB_VFP */
    7791159
     1160#define ARM_CLEAR_THUMB_MODE "bic  r1, r1, %[psr_t]\n" /* clear thumb */
     1161
    7801162#define EXCEPTION_ENTRY_THREAD_V4(_frame)                               \
    7811163  __asm__ volatile(                                                     \
     
    7861168    "mrs  r1, spsr\n"                            /* get the saved sr */ \
    7871169    "mov  r6, r1\n"                            /* stash it for later */ \
    788     "bic  r1, r1, %[psr_t]\n"         /* clear thumb mode, not sure? */ \
     1170    ARM_CLEAR_THUMB_MODE                         /* clear thumb mode */ \
    7891171    "orr  r1, r1, %[psr_i]\n"                           /* mask irqs */ \
    7901172    "mrs  r2, cpsr\n"                          /* get the current sr */ \
     
    8191201    "msr  cpsr, r1\n"       /* restore the state with irq mask clear */ \
    8201202    ASM_THUMB_MODE                                                      \
    821     : ARM_SWITCH_REG_ASM,                                               \
     1203    : ARM_SWITCH_REG_ASM_L                                              \
    8221204      [o_frame] "=r" (_frame)                                           \
    8231205    : [psr_t] "i" (ARM_PSR_T),                                          \
     
    8801262    "cmp  r3, r4\n"                                      /* the end? */ \
    8811263    "bne  1b\n"                                                         \
     1264    "mov  r0, %[i_frame]\n"                         /* get the frame */ \
    8821265    "add  r1, r0, %[r0_r12_size]\n"       /* get the sp in the frame */ \
    883     "ldm  r1, {r3-r6}\n"                   /* recover from the frame */ \
     1266    "ldm  r1, {r3-r6}\n"                 /* recover sp, lr, pc, cpsr */ \
    8841267    "orr  r1, r6, %[psr_i]\n"  /* get the thread's psr and mask irqs */ \
    8851268    "msr  cpsr, r1\n"                         /* switch to user mode */ \
     
    9311314#endif
    9321315
     1316/*
     1317 * This is used to catch faulting accesses.
     1318 */
     1319static void __attribute__((naked))
     1320arm_debug_unlock_abort(void)
     1321{
     1322  CPU_Exception_frame* frame;
     1323  ARM_SWITCH_REG;
     1324  EXCEPTION_ENTRY_EXC();
     1325  EXCEPTION_ENTRY_THREAD(frame);
     1326  longjmp(unlock_abort_jmpbuf, -1);
     1327}
     1328
    9331329static void __attribute__((naked))
    9341330target_exception_undefined_instruction(void)
     
    9381334  EXCEPTION_ENTRY_EXC();
    9391335  arm_debug_break_unload();
     1336  arm_debug_enable_interrupts();
    9401337  EXCEPTION_ENTRY_THREAD(frame);
    9411338  frame->vector = 1;
    9421339  target_exception(frame);
    9431340  EXCEPTION_EXIT_THREAD(frame);
     1341  arm_debug_commit_interrupt_disable();
    9441342  arm_debug_break_load();
    9451343  EXCEPTION_EXIT_EXC();
     
    9521350  ARM_SWITCH_REG;
    9531351  /*
    954    * The PC offset needs to be review so we move past a svc instruction. This
    955    * can then used as a user breakpoint. The issue is this exception is used by
    956    * the BKPT instruction in the prefetch abort handler to signal a TRAP.
     1352   * The PC offset needs to be reviewed so we move past a svc
     1353   * instruction. This can then be used as a user breakpoint. The issue is
     1354   * this exception is used by the BKPT instruction in the prefetch abort
     1355   * handler to signal a TRAP.
    9571356   */
    9581357  EXCEPTION_ENTRY_EXC();
    9591358  arm_debug_break_unload();
     1359  arm_debug_enable_interrupts();
    9601360  EXCEPTION_ENTRY_THREAD(frame);
    9611361  frame->vector = 2;
    9621362  target_exception(frame);
    9631363  EXCEPTION_EXIT_THREAD(frame);
     1364  arm_debug_commit_interrupt_disable();
    9641365  arm_debug_break_load();
    9651366  EXCEPTION_EXIT_EXC();
     
    9731374  EXCEPTION_ENTRY_EXC();
    9741375  arm_debug_break_unload();
     1376  arm_debug_enable_interrupts();
    9751377  EXCEPTION_ENTRY_THREAD(frame);
    976 #if ARM_CP15
    977   if ((arm_cp15_get_instruction_fault_status() & 0x1f) == 0x02)
    978     frame->vector = 2;
    979   else
    980     frame->vector = 3;
    981 #else
    9821378  frame->vector = 3;
    983 #endif
    9841379  target_exception(frame);
    9851380  EXCEPTION_EXIT_THREAD(frame);
     1381  arm_debug_commit_interrupt_disable();
    9861382  arm_debug_break_load();
    9871383  EXCEPTION_EXIT_EXC();
     
    9951391  EXCEPTION_ENTRY_EXC();
    9961392  arm_debug_break_unload();
     1393  arm_debug_enable_interrupts();
    9971394  EXCEPTION_ENTRY_THREAD(frame);
    9981395  frame->vector = 4;
    9991396  target_exception(frame);
    10001397  EXCEPTION_EXIT_THREAD(frame);
     1398  arm_debug_commit_interrupt_disable();
    10011399  arm_debug_break_load();
    10021400  EXCEPTION_EXIT_EXC();
     
    10141412
    10151413static void
    1016 rtems_debugger_target_set_vectors(void)
     1414rtems_debugger_target_set_mmu(void)
    10171415{
    10181416  void* text_begin;
     
    10201418  text_begin = &bsp_section_text_begin[0];
    10211419  text_end = &bsp_section_text_end[0];
     1420  target_printk("[} MMU edit: text_begin: %p text_end: %p\n",
     1421                text_begin, text_end);
    10221422  text_section_flags =
    10231423    arm_cp15_set_translation_table_entries(text_begin,
    10241424                                           text_end,
    10251425                                           ARMV7_MMU_DATA_READ_WRITE_CACHED);
     1426}
     1427
     1428static void
     1429rtems_debugger_target_set_vectors(void)
     1430{
    10261431  arm_cp15_set_exception_handler(ARM_EXCEPTION_UNDEF,
    10271432                                 target_exception_undefined_instruction);
     
    10491454  (void) da;
    10501455}
     1456
     1457static void
     1458rtems_debugger_target_set_mmu(void)
     1459{
     1460}
    10511461#endif
    10521462
     
    10871497  arm_debug_break_clear();
    10881498  rtems_interrupt_lock_acquire(&target_lock, &lock_context);
     1499  rtems_debugger_target_set_mmu();
    10891500  rtems_debugger_target_set_vectors();
    10901501  rtems_interrupt_lock_release(&target_lock, &lock_context);
     
    11371548       * value.
    11381549       */
    1139       FRAME_SR &= ~CPSR_INTS_MASK;
     1550      FRAME_SR(frame) &= ~CPSR_INTS_MASK;
    11401551
    11411552      if (rtems_debugger_thread_flag(thread,
    11421553                                     RTEMS_DEBUGGER_THREAD_FLAG_INTS_DISABLED)) {
    1143         FRAME_SR |=
     1554        FRAME_SR(frame) |=
    11441555          (thread->flags >> RTEMS_DEBUGGER_THREAD_FLAG_TARGET_BASE) & CPSR_INTS_MASK;
    1145         thread->flags = ~RTEMS_DEBUGGER_THREAD_FLAG_INTS_DISABLED;
     1556        thread->flags &= ~RTEMS_DEBUGGER_THREAD_FLAG_INTS_DISABLED;
    11461557      }
    11471558
     
    11621573      rtems_debugger_set_int_reg(thread, REG_LR,   (uint32_t) frame->register_lr);
    11631574      rtems_debugger_set_int_reg(thread, REG_PC,   (uint32_t) frame->register_pc);
    1164       rtems_debugger_set_int_reg(thread, REG_CPSR, FRAME_SR);
     1575      rtems_debugger_set_int_reg(thread, REG_CPSR, FRAME_SR(frame));
    11651576      /*
    11661577       * Get the signal from the frame.
     
    12351646      frame->register_lr  = (void*) rtems_debugger_get_int_reg(thread, REG_LR);
    12361647      frame->register_pc  = (void*) rtems_debugger_get_int_reg(thread, REG_PC);
    1237       FRAME_SR            = rtems_debugger_get_int_reg(thread, REG_CPSR);
     1648      FRAME_SR(frame)     = rtems_debugger_get_int_reg(thread, REG_CPSR);
    12381649    }
    12391650    thread->flags &= ~RTEMS_DEBUGGER_THREAD_FLAG_REG_DIRTY;
     
    12861697    CPU_Exception_frame* frame = thread->frame;
    12871698    arm_debug_hwbreak*   bp = &hw_breaks[0];
     1699
    12881700    target_printk("[} stepping: %s\n", bp->enabled ? "yes" : "no");
     1701
    12891702    if (!bp->enabled) {
    12901703      const uint32_t addr = (intptr_t) frame->register_pc;
    1291       const bool     thumb = (FRAME_SR & (1 << 5)) != 0 ? true : false;
     1704      const bool     thumb = (FRAME_SR(frame) & (1 << 5)) != 0 ? true : false;
    12921705      uint32_t       bas;
    12931706
     
    13341747                            ARM_HW_BP_PRIV_PL0_SUP_SYS);
    13351748
    1336       /*
    1337        * Save the interrupt state before stepping if set.
    1338        */
    1339 #if ARM_PSR_HAS_INT_MASK
    1340       if ((FRAME_SR & CPSR_INTS_MASK) != 0) {
    1341         uint32_t int_state;
    1342         int_state =
    1343           (frame->register_cpsr & CPSR_INTS_MASK) << RTEMS_DEBUGGER_THREAD_FLAG_TARGET_BASE;
    1344         thread->flags |= RTEMS_DEBUGGER_THREAD_FLAG_INTS_DISABLED | int_state;
    1345       }
    1346       /*
    1347        * Mask the interrupt when stepping.
    1348        */
    1349       FRAME_SR |= CPSR_INTS_MASK;
    1350 #endif
     1749      arm_debug_disable_interrupts();
    13511750    }
    13521751  }
     
    13881787rtems_debugger_target_exception_print(CPU_Exception_frame* frame)
    13891788{
    1390   rtems_debugger_printf("  R0 = %08" PRIx32 "  R1 = %08" PRIx32       \
    1391                         "  R2 = %08" PRIx32 "  R3 = %08" PRIx32 "\n",
    1392                         frame->register_r0, frame->register_r1,
    1393                         frame->register_r2, frame->register_r3);
    1394   rtems_debugger_printf("  R4 = %08" PRIx32 "  R5 = %08" PRIx32       \
    1395                         "  R6 = %08" PRIx32 "  R7 = %08" PRIx32 "\n",
    1396                         frame->register_r4, frame->register_r5,
    1397                         frame->register_r6, frame->register_r7);
    1398   rtems_debugger_printf("  R8 = %08" PRIx32 "  R9 = %08" PRIx32       \
    1399                         " R10 = %08" PRIx32 " R11 = %08" PRIx32 "\n",
    1400                         frame->register_r8, frame->register_r9,
    1401                         frame->register_r10, frame->register_r11);
    1402   rtems_debugger_printf(" R12 = %08" PRIx32 "  SP = %08" PRIx32       \
    1403                         "  LR = %08" PRIxPTR "  PC = %08" PRIxPTR "\n", \
    1404                         frame->register_r12, frame->register_sp,
    1405                         (intptr_t) frame->register_lr, (intptr_t) frame->register_pc);
    1406   rtems_debugger_printf(" CPSR = %08" PRIx32 " %c%c%c%c%c%c%c%c%c%c%c"       \
    1407                         " GE:%" PRIx32 " IT:%02" PRIx32 " M:%" PRIx32 " %s\n",
    1408                         FRAME_SR,
    1409                         (FRAME_SR & (1 << 31)) != 0 ? 'N' : '-',
    1410                         (FRAME_SR & (1 << 30)) != 0 ? 'Z' : '-',
    1411                         (FRAME_SR & (1 << 29)) != 0 ? 'C' : '-',
    1412                         (FRAME_SR & (1 << 28)) != 0 ? 'V' : '-',
    1413                         (FRAME_SR & (1 << 27)) != 0 ? 'Q' : '-',
    1414                         (FRAME_SR & (1 << 24)) != 0 ? 'J' : '-',
    1415                         (FRAME_SR & (1 <<  9)) != 0 ? 'E' : '-',
    1416                         (FRAME_SR & (1 <<  8)) != 0 ? 'A' : '-',
    1417                         (FRAME_SR & (1 <<  7)) != 0 ? 'I' : '-',
    1418                         (FRAME_SR & (1 <<  6)) != 0 ? 'F' : '-',
    1419                         (FRAME_SR & (1 <<  5)) != 0 ? 'T' : '-',
    1420                         ((FRAME_SR >> (25 - 5)) & (0x3 << 5)) | ((FRAME_SR >> 10) & 0x1f),
    1421                         (FRAME_SR >> 16) & 0xf,
    1422                         FRAME_SR & 0x1f, arm_mode_label(FRAME_SR & 0x1f));
     1789  EXC_FRAME_PRINT(rtems_debugger_printf, "", frame);
    14231790}
    14241791
  • cpukit/libdebugger/rtems-debugger-server.c

    r98d6792 rcb1e8497  
    17051705  r = rtems_debugger_target_create();
    17061706  if (r < 0) {
    1707     rtems_debugger_thread_destroy();
    17081707    rtems_debugger_unlock();
    17091708    return r;
     
    17121711  r = rtems_debugger_thread_create();
    17131712  if (r < 0) {
     1713    rtems_debugger_target_destroy();
    17141714    rtems_debugger_unlock();
    17151715    return r;
     
    17261726                                 &rtems_debugger->events_task);
    17271727  if (r < 0) {
     1728    rtems_debugger_thread_destroy();
    17281729    rtems_debugger_target_destroy();
    1729     rtems_debugger_thread_destroy();
    17301730    rtems_debugger_unlock();
    17311731    return r;
  • cpukit/libdebugger/rtems-debugger-threads.c

    r98d6792 rcb1e8497  
    363363        rtems_status_code      sc;
    364364        int                    rr;
     365        bool                   has_exception;
    365366        /*
    366367         * Check if resuming, which can be continuing, a step, or stepping a
     
    381382            }
    382383          }
     384          has_exception =
     385            rtems_debugger_thread_flag(thread,
     386                                       RTEMS_DEBUGGER_THREAD_FLAG_EXCEPTION);
    383387          if (rtems_debugger_verbose())
    384             rtems_debugger_printf("rtems-db: sys:    : resume: 0x%08" PRIx32 "\n",
    385                                   thread->id);
    386           if (rtems_debugger_thread_flag(thread,
    387                                          RTEMS_DEBUGGER_THREAD_FLAG_EXCEPTION)) {
     388            rtems_debugger_printf("rtems-db: sys:    : resume: 0x%08" PRIx32 " %c\n",
     389                                  thread->id, has_exception ? 'E' : ' ');
     390          if (has_exception) {
    388391              rtems_debugger_target_exception_thread_resume(thread);
    389392          } else {
Note: See TracChangeset for help on using the changeset viewer.