Index: gdb/configure.tgt
===================================================================
RCS file: /cvs/src/src/gdb/configure.tgt,v
retrieving revision 1.213
diff -r1.213 configure.tgt
378c378,382
< 	gdb_target_obs="score-tdep.o"
---
> 	gdb_target_obs="score-tdep.o corelow.o"
> 	if test -f ../sim/score/Makefile; then
> 	  gdb_sim=../sim/score/libsim.a
> 	fi
> 	build_gdbserver=yes
Index: gdb/score-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/score-tdep.c,v
retrieving revision 1.18
diff -r1.18 score-tdep.c
32a33
> #include "regset.h"
40,41c41
< #define G_FLD(_i,_ms,_ls)   (((_i) << (31 - (_ms))) >> (31 - (_ms) + (_ls)))
< #define RM_PBITS(_raw)      ((G_FLD(_raw, 31, 16) << 15) | G_FLD(_raw, 14, 0))
---
> #define G_FLD(_i,_ms,_ls)   ((unsigned)((_i) << (31 - (_ms))) >> (31 - (_ms) + (_ls)))
44,46c44,46
<     unsigned int v;
<     unsigned int raw;
<     char         is15;
---
>     unsigned long long v;
>     unsigned long long raw;
>     unsigned int len;
56,186c56
< #if 0
< /* If S+core GCC will generate these instructions in the prologue:
< 
<    lw   rx, imm1
<    addi rx, -imm2
<    mv!  r2, rx
< 
<    then .pdr section is used.  */
< 
< #define P_SIZE          8
< #define PI_SYM          0
< #define PI_R_MSK        1
< #define PI_R_OFF        2
< #define PI_R_LEF        4
< #define PI_F_OFF        5
< #define PI_F_REG        6
< #define PI_RAREG        7
< 
< typedef struct frame_extra_info
< {
<   CORE_ADDR p_frame;
<   unsigned int pdr[P_SIZE];
< } extra_info_t;
< 
< struct obj_priv
< {
<   bfd_size_type size;
<   char *contents;
< };
< 
< static bfd *the_bfd;
< 
< static int
< score_compare_pdr_entries (const void *a, const void *b)
< {
<   CORE_ADDR lhs = bfd_get_32 (the_bfd, (bfd_byte *) a);
<   CORE_ADDR rhs = bfd_get_32 (the_bfd, (bfd_byte *) b);
<   if (lhs < rhs)
<     return -1;
<   else if (lhs == rhs)
<     return 0;
<   else
<     return 1;
< }
< 
< static void
< score_analyze_pdr_section (CORE_ADDR startaddr, CORE_ADDR pc,
<                            struct frame_info *this_frame,
<                            struct score_frame_cache *this_cache)
< {
<   struct symbol *sym;
<   struct obj_section *sec;
<   extra_info_t *fci_ext;
<   CORE_ADDR leaf_ra_stack_addr = -1;
< 
<   gdb_assert (startaddr <= pc);
<   gdb_assert (this_cache != NULL);
< 
<   fci_ext = frame_obstack_zalloc (sizeof (extra_info_t));
<   if ((sec = find_pc_section (pc)) == NULL)
<     {
<       error ("Error: Can't find section in file:%s, line:%d!",
<              __FILE__, __LINE__);
<       return;
<     }
< 
<   /* Anylyze .pdr section and get coresponding fields.  */
<   {
<     static struct obj_priv *priv = NULL;
< 
<     if (priv == NULL)
<       {
<         asection *bfdsec;
<         priv = obstack_alloc (&sec->objfile->objfile_obstack,
<                               sizeof (struct obj_priv));
<         if ((bfdsec = bfd_get_section_by_name (sec->objfile->obfd, ".pdr")))
<           {
<             priv->size = bfd_section_size (sec->objfile->obfd, bfdsec);
<             priv->contents = obstack_alloc (&sec->objfile->objfile_obstack,
<                                             priv->size);
<             bfd_get_section_contents (sec->objfile->obfd, bfdsec,
<                                       priv->contents, 0, priv->size);
<             the_bfd = sec->objfile->obfd;
<             qsort (priv->contents, priv->size / 32, 32,
<                    score_compare_pdr_entries);
<             the_bfd = NULL;
<           }
<         else
<           priv->size = 0;
<       }
<     if (priv->size != 0)
<       {
<         int low = 0, mid, high = priv->size / 32;
<         char *ptr;
<         do
<           {
<             CORE_ADDR pdr_pc;
<             mid = (low + high) / 2;
<             ptr = priv->contents + mid * 32;
<             pdr_pc = bfd_get_signed_32 (sec->objfile->obfd, ptr);
<             pdr_pc += ANOFFSET (sec->objfile->section_offsets,
<                                 SECT_OFF_TEXT (sec->objfile));
<             if (pdr_pc == startaddr)
<               break;
<             if (pdr_pc > startaddr)
<               high = mid;
<             else
<               low = mid + 1;
<           }
<         while (low != high);
< 
<         if (low != high)
<           {
<             gdb_assert (bfd_get_32 (sec->objfile->obfd, ptr) == startaddr);
< #define EXT_PDR(_pi)    bfd_get_32(sec->objfile->obfd, ptr+((_pi)<<2))
<             fci_ext->pdr[PI_SYM] = EXT_PDR (PI_SYM);
<             fci_ext->pdr[PI_R_MSK] = EXT_PDR (PI_R_MSK);
<             fci_ext->pdr[PI_R_OFF] = EXT_PDR (PI_R_OFF);
<             fci_ext->pdr[PI_R_LEF] = EXT_PDR (PI_R_LEF);
<             fci_ext->pdr[PI_F_OFF] = EXT_PDR (PI_F_OFF);
<             fci_ext->pdr[PI_F_REG] = EXT_PDR (PI_F_REG);
<             fci_ext->pdr[PI_RAREG] = EXT_PDR (PI_RAREG);
< #undef EXT_PDR
<           }
<       }
<   }
< }
< #endif
< 
< #if 0
< /* Open these functions if build with simulator.  */
---
> static int target_mach = bfd_mach_score7;
190a61
> #if WITH_SIM
195a67
> #endif
203a76
> #if WITH_SIM
208a82
> #endif
216a91
> #if WITH_SIM
221a97
> #endif
229a106
> #if WITH_SIM
234a112
> #endif
242a121
> #if WITH_SIM
247a127
> #endif
255a136
> #if WITH_SIM
260a142
> #endif
265d146
< #endif
270c151,152
<   gdb_assert (regnum >= 0 && regnum < SCORE_NUM_REGS);
---
>   gdb_assert (regnum >= 0 
>               && regnum < ((target_mach == bfd_mach_score7) ? SCORE7_NUM_REGS : SCORE3_NUM_REGS));
274a157,162
> score_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
> {
>   return frame_unwind_register_unsigned (next_frame, SCORE_SP_REGNUM);
> }
> 
> static CORE_ADDR
280,281c168,169
< static CORE_ADDR
< score_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
---
> static const char *
> score7_register_name (struct gdbarch *gdbarch, int regnum)
283c171,185
<   return frame_unwind_register_unsigned (next_frame, SCORE_SP_REGNUM);
---
>   const char *score_register_names[] = {
>     "r0",  "r1",  "r2",  "r3",  "r4",  "r5",  "r6",  "r7",
>     "r8",  "r9",  "r10", "r11", "r12", "r13", "r14", "r15",
>     "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
>     "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
> 
>     "PSR",     "COND",  "ECR",     "EXCPVEC", "CCR",
>     "EPC",     "EMA",   "TLBLOCK", "TLBPT",   "PEADDR",
>     "TLBRPT",  "PEVN",  "PECTX",   "LIMPFN",  "LDMPFN", 
>     "PREV",    "DREG",  "PC",      "DSAVE",   "COUNTER",
>     "LDCR",    "STCR",  "CEH",     "CEL",
>   };
> 
>   gdb_assert (regnum >= 0 && regnum < SCORE7_NUM_REGS);
>   return score_register_names[regnum];
287c189
< score_register_name (struct gdbarch *gdbarch, int regnum)
---
> score3_register_name (struct gdbarch *gdbarch, int regnum)
295,300c197,200
<     "PSR",   "COND",   "ECR",    "EXCPVEC",
<     "CCR",   "EPC",    "EMA",    "TLBLOCK",
<     "TLBPT", "PEADDR", "TLBRPT", "PEVN",
<     "PECTX", "LIMPFN", "LDMPFN", "PREV",
<     "DREG",  "PC",     "DSAVE",  "COUNTER",
<     "LDCR",  "STCR",   "CEH",    "CEL",
---
>     "PSR",      "COND",   "ECR",   "EXCPVEC",  "CCR",
>     "EPC",      "EMA",    "PREV",  "DREG",     "DSAVE",
>     "COUNTER",  "LDCR",   "STCR",  "CEH",      "CEL",
>     "",         "",       "PC",
303c203
<   gdb_assert (regnum >= 0 && regnum < SCORE_NUM_REGS);
---
>   gdb_assert (regnum >= 0 && regnum < SCORE3_NUM_REGS);
306a207
> #if WITH_SIM
310c211,212
<   gdb_assert (regnum >= 0 && regnum < SCORE_NUM_REGS);
---
>   gdb_assert (regnum >= 0 
>               && regnum < ((target_mach == bfd_mach_score7) ? SCORE7_NUM_REGS : SCORE3_NUM_REGS));
312a215
> #endif
322a226,384
> static inst_t *
> score7_fetch_inst (struct gdbarch *gdbarch, CORE_ADDR addr, char *memblock)
> {
>   static inst_t inst = { 0, 0, 0 };
>   char buf[SCORE_INSTLEN] = { 0 };
>   int big;
>   int ret;
> 
>   if (target_has_execution && memblock != NULL)
>     {
>       /* Fetch instruction from local MEMBLOCK.  */
>       memcpy (buf, memblock, SCORE_INSTLEN);
>     }
>   else
>     {
>       /* Fetch instruction from target.  */
>       ret = target_read_memory (addr & ~0x3, buf, SCORE_INSTLEN);
>       if (ret)
>         {
>           error ("Error: target_read_memory in file:%s, line:%d!",
>                   __FILE__, __LINE__);
>           return 0;
>         }
>     }
> 
>   inst.raw = extract_unsigned_integer (buf, SCORE_INSTLEN);
>   inst.len = (inst.raw & 0x80008000) ? 4 : 2;
>   inst.v = ((inst.raw >> 16 & 0x7FFF) << 15) | (inst.raw & 0x7FFF); 
>   big = (gdbarch_byte_order(gdbarch) == BFD_ENDIAN_BIG);
>   if (inst.len == 2)
>     {
>       if (big ^ ((addr & 0x2) == 2))
>         inst.v = G_FLD (inst.v, 29, 15);
>       else
>         inst.v = G_FLD (inst.v, 14, 0);
>     }
>   return &inst;
> }
> 
> static inst_t *
> score3_adjust_pc_and_fetch_inst (CORE_ADDR *pcptr, int *lenptr)
> {
>   static inst_t inst = { 0, 0, 0 };
> 
>   struct breakplace
>   {
>     int break_offset;
>     int inst_len;
>   };
>   /*     raw        table 1 (column 2, 3, 4)
>     *  0  1  0  *   # 2
>     *  0  1  1  0   # 3
>     0  1  1  0  *   # 6
>                     table 2 (column 1, 2, 3)
>     *  0  0  *  *   # 0, 4
>     0  1  0  *  *   # 2
>     1  1  0  *  *   # 6
>    */
> 
>   static const struct breakplace bk_table[16] =
>     {
>       /* table 1 */
>       {0, 0},
>       {0, 0},
>       {0, 4},
>       {0, 6},
>       {0, 0},
>       {0, 0},
>       {-2, 6},
>       {0, 0},
>       /* table 2 */
>       {0, 2},
>       {0, 0},
>       {-2, 4},
>       {0, 0},
>       {0, 2},
>       {0, 0},
>       {-4, 6},
>       {0, 0}
>     };
> 
> #define EXTRACT_LEN 2
>   CORE_ADDR adjust_pc = *pcptr & ~0x1;
>   int inst_len;
>   gdb_byte buf[5][EXTRACT_LEN] = {{'\0', '\0'}, {'\0', '\0'}, {'\0', '\0'}, {'\0', '\0'}, {'\0', '\0'}};
>   int ret;
>   unsigned int raw;
>   unsigned int cbits = 0;
>   int bk_index;
>   int i, count;
> 
>   inst.v = 0;
>   inst.raw = 0;
>   inst.len = 0;
> 
>   adjust_pc -= 4;
>   for (i = 0; i < 5; i++)
>     {
>       ret = target_read_memory (adjust_pc + 2 * i, buf[i], EXTRACT_LEN);
>       if (ret != 0)
>         {
>           buf[i][0] = '\0';
>           buf[i][1] = '\0';
> 	  if (i == 2)
>             error ("Error: target_read_memory in file:%s, line:%d!", __FILE__, __LINE__);
>         }
> 
>       raw = extract_unsigned_integer (buf[i], EXTRACT_LEN);
>       cbits = (cbits << 1) | (raw >> 15); 
>     }
>   adjust_pc += 4;
> 
>   if (cbits & 0x4)
>     {
>       /* table 1 */
>       cbits = (cbits >> 1) & 0x7;
>       bk_index = cbits;
>     }
>   else
>     {
>       /* table 2 */
>       cbits = (cbits >> 2) & 0x7;
>       bk_index = cbits + 8; 
>     }
> 
>   gdb_assert (!((bk_table[bk_index].break_offset == 0) && (bk_table[bk_index].inst_len == 0)));
> 
>   inst.len = bk_table[bk_index].inst_len;
> 
>   i = (bk_table[bk_index].break_offset + 4) / 2;
>   count = inst.len / 2;
>   for (; count > 0; i++, count--)
>     {
>       inst.raw = (inst.raw << 16) | extract_unsigned_integer (buf[i], EXTRACT_LEN);
>     }
> 
>   switch (inst.len)
>     {
>     case 2:
>       inst.v = inst.raw & 0x7FFF;
>       break;
>     case 4:
>       inst.v = ((inst.raw >> 16 & 0x7FFF) << 15) | (inst.raw & 0x7FFF);
>       break;
>     case 6:
>       inst.v = ((inst.raw >> 32 & 0x7FFF) << 30) | ((inst.raw >> 16 & 0x7FFF) << 15) | (inst.raw & 0x7FFF);
>       break;
>     }
> 
>   if (pcptr)
>     *pcptr = adjust_pc + bk_table[bk_index].break_offset;
>   if (lenptr)
>     *lenptr = bk_table[bk_index].inst_len;
> 
> #undef EXTRACT_LEN
> 
>   return &inst;
> }
> 
324,325c386
< score_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr,
< 			  int *lenptr)
---
> score7_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
377a439,480
> static const gdb_byte *
> score3_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
> {
>   CORE_ADDR adjust_pc = *pcptr; 
>   int len;
>   static gdb_byte score_break_insns[6][6] = {
>     /* The following three instructions are big endian.  */
>     { 0x00, 0x20 },
>     { 0x80, 0x00, 0x00, 0x06 },
>     { 0x80, 0x00, 0x80, 0x00, 0x00, 0x00 },
>     /* The following three instructions are little endian.  */
>     { 0x20, 0x00 },
>     { 0x00, 0x80, 0x06, 0x00 },
>     { 0x00, 0x80, 0x00, 0x80, 0x00, 0x00 }};
> 
>   gdb_byte *p = NULL;
>   int index = 0;
> 
>   score3_adjust_pc_and_fetch_inst (&adjust_pc, &len);
> 
>   index = ((gdbarch_byte_order(gdbarch) == BFD_ENDIAN_BIG) ? 0 : 3) + (len / 2 - 1);
>   p = score_break_insns[index];
> 
>   *pcptr = adjust_pc;
>   *lenptr = len;
> 
>   return p;
> }
> 
> static CORE_ADDR
> score_adjust_breakpoint_address (struct gdbarch *gdbarch, CORE_ADDR bpaddr)
> {
>   CORE_ADDR adjust_pc = bpaddr; 
> 
>   if (target_mach == bfd_mach_score3)
>     score3_adjust_pc_and_fetch_inst (&adjust_pc, NULL);
>   else
>     adjust_pc = align_down (adjust_pc, 2);
>   
>   return adjust_pc;
> }
> 
390c493,494
<   gdb_assert (regnum >= 0 && regnum < SCORE_NUM_REGS);
---
>   gdb_assert (regnum >= 0 
>               && regnum < ((target_mach == bfd_mach_score7) ? SCORE7_NUM_REGS : SCORE3_NUM_REGS));
418c522
< 		    struct type *type, struct regcache *regcache,
---
>                     struct type *type, struct regcache *regcache,
436,437c540
<           score_xfer_register (regcache, regnum, xfer,
< 			       gdbarch_byte_order (gdbarch),
---
>           score_xfer_register (regcache, regnum, xfer, gdbarch_byte_order(gdbarch),
546c649
<       if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG
---
>       if (gdbarch_byte_order(gdbarch) == BFD_ENDIAN_BIG
560c663
<           if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG
---
>           if (gdbarch_byte_order(gdbarch) == BFD_ENDIAN_BIG
589,680d691
< static char *
< score_malloc_and_get_memblock (CORE_ADDR addr, CORE_ADDR size)
< {
<   int ret;
<   char *memblock = NULL;
< 
<   if (size < 0)
<     {
<       error ("Error: malloc size < 0 in file:%s, line:%d!",
<              __FILE__, __LINE__);
<       return NULL;
<     }
<   else if (size == 0)
<     return NULL;
< 
<   memblock = (char *) xmalloc (size);
<   memset (memblock, 0, size);
<   ret = target_read_memory (addr & ~0x3, memblock, size);
<   if (ret)
<     {
<       error ("Error: target_read_memory in file:%s, line:%d!",
<              __FILE__, __LINE__);
<       return NULL;
<     }
<   return memblock;
< }
< 
< static void
< score_free_memblock (char *memblock)
< {
<   xfree (memblock);
< }
< 
< static void
< score_adjust_memblock_ptr (char **memblock, CORE_ADDR prev_pc,
<                            CORE_ADDR cur_pc)
< {
<   if (prev_pc == -1)
<     {
<       /* First time call this function, do nothing.  */
<     }
<   else if (cur_pc - prev_pc == 2 && (cur_pc & 0x3) == 0)
<     {
<       /* First 16-bit instruction, then 32-bit instruction.  */
<       *memblock += SCORE_INSTLEN;
<     }
<   else if (cur_pc - prev_pc == 4)
<     {
<       /* Is 32-bit instruction, increase MEMBLOCK by 4.  */
<       *memblock += SCORE_INSTLEN;
<     }
< }
< 
< static inst_t *
< score_fetch_inst (struct gdbarch *gdbarch, CORE_ADDR addr, char *memblock)
< {
<   static inst_t inst = { 0, 0 };
<   char buf[SCORE_INSTLEN] = { 0 };
<   int big;
<   int ret;
< 
<   if (target_has_execution && memblock != NULL)
<     {
<       /* Fetch instruction from local MEMBLOCK.  */
<       memcpy (buf, memblock, SCORE_INSTLEN);
<     }
<   else
<     {
<       /* Fetch instruction from target.  */
<       ret = target_read_memory (addr & ~0x3, buf, SCORE_INSTLEN);
<       if (ret)
<         {
<           error ("Error: target_read_memory in file:%s, line:%d!",
<                   __FILE__, __LINE__);
<           return 0;
<         }
<     }
< 
<   inst.raw = extract_unsigned_integer (buf, SCORE_INSTLEN);
<   inst.is15 = !(inst.raw & 0x80008000);
<   inst.v = RM_PBITS (inst.raw);
<   big = (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG);
<   if (inst.is15)
<     {
<       if (big ^ ((addr & 0x2) == 2))
<         inst.v = G_FLD (inst.v, 29, 15);
<       else
<         inst.v = G_FLD (inst.v, 14, 0);
<     }
<   return &inst;
< }
< 
682c693
< score_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
---
> score7_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
688c699
<       inst_t *inst = score_fetch_inst (gdbarch, cpc, NULL);
---
>       inst_t *inst = score7_fetch_inst (gdbarch, cpc, NULL);
691c702
<       if (!inst->is15 && !stack_sub
---
>       if ((inst->len == 4) && !stack_sub
696c707,708
<           pc = stack_sub = cpc + SCORE_INSTLEN;
---
>           stack_sub = cpc + SCORE_INSTLEN;
>           pc = cpc + SCORE_INSTLEN;
698,699c710,715
<       else if (!inst->is15
<                && inst->v == RM_PBITS (0x8040bc56))
---
>       else if ((inst->len == 4)
>                && (G_FLD (inst->v, 29, 25) == 0x0)
>                && (G_FLD (inst->v, 24, 20) == 0x2)
>                && (G_FLD (inst->v, 19, 15) == 0x0)
>                && (G_FLD (inst->v, 14, 10) == 0xF)
>                && (G_FLD (inst->v, 9, 0) == 0x56))
705,706c721,725
<       else if (inst->is15
<                && inst->v == RM_PBITS (0x0203))
---
>       else if ((inst->len == 2)
>                && (G_FLD (inst->v, 14, 12) == 0x0)
>                && (G_FLD (inst->v, 11, 8) == 0x2)
>                && (G_FLD (inst->v, 7, 4) == 0x0)
>                && (G_FLD (inst->v, 3, 0) == 0x3))
712c731
<       else if (inst->is15
---
>       else if ((inst->len == 2)
718c737
<       else if (!inst->is15
---
>       else if ((inst->len == 4)
725c744,798
<       cpc += inst->is15 ? SCORE16_INSTLEN : SCORE_INSTLEN;
---
>       cpc += (inst->len == 2) ? SCORE16_INSTLEN : SCORE_INSTLEN;
>     }
>   return pc;
> }
> 
> static CORE_ADDR
> score3_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
> {
>   CORE_ADDR cpc = pc;
>   int iscan = 32, stack_sub = 0;
>   while (iscan-- > 0)
>     {
>       inst_t *inst = score3_adjust_pc_and_fetch_inst (&cpc, NULL);
>       if (!inst)
>         break;
>       if (inst->len == 4 && !stack_sub
>           && (G_FLD (inst->v, 29, 25) == 0x1)
>           && (G_FLD (inst->v, 19, 17) == 0x0)
> 	  && (G_FLD (inst->v, 24, 20) == 0x0))
>         {
>           /* addi r0, offset */
>           stack_sub = cpc + inst->len;
>           pc = cpc + inst->len;
>         }
>       else if (inst->len == 4
>                && (G_FLD (inst->v, 29, 25) == 0x0)
> 	       && (G_FLD (inst->v, 24, 20) == 0x2)
> 	       && (G_FLD (inst->v, 19, 15) == 0x0)
> 	       && (G_FLD (inst->v, 14, 10) == 0xF)
> 	       && (G_FLD (inst->v, 9, 0) == 0x56))
>         {
>           /* mv r2, r0  */
>           pc = cpc + inst->len;
>           break;
>         }
>       else if ((inst->len == 2)
>                && (G_FLD (inst->v, 14, 10) == 0x10)
>                && (G_FLD (inst->v, 9, 5) == 0x2)
> 	       && (G_FLD (inst->v, 4, 0) == 0x0))
>         {
>           /* mv! r2, r0 */
>           pc = cpc + inst->len;
>           break;
>         }
>       else if (inst->len == 2
>                && ((G_FLD (inst->v, 14, 12) == 3) /* b15 form */
>                    || (G_FLD (inst->v, 14, 12) == 0x0
>                        && G_FLD (inst->v, 11, 5) == 0x4))) /* br! */
>         break;
>       else if (inst->len == 4
>                && ((G_FLD (inst->v, 29, 25) == 2)    /* j32 form */
>                    || (G_FLD (inst->v, 29, 25) == 4))) /* b32 form */
>         break;
> 
>       cpc += inst->len;
731c804
< score_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR cur_pc)
---
> score7_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR cur_pc)
733c806
<   inst_t *inst = score_fetch_inst (gdbarch, cur_pc, NULL);
---
>   inst_t *inst = score7_fetch_inst (gdbarch, cur_pc, NULL);
753a827,902
> static int
> score3_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR cur_pc)
> {
>   CORE_ADDR pc = cur_pc;
>   inst_t *inst = score3_adjust_pc_and_fetch_inst (&pc, NULL);
> 
>   if (inst->len == 2
>       && (G_FLD (inst->v, 14, 10) == 0x10)
>       && (G_FLD (inst->v, 9, 5) == 0x0)
>       && (G_FLD (inst->v, 4, 0) == 0x2))
>     return 1;   /* mv! r0, r2 */
>   else if (inst->len == 4
>            && (G_FLD (inst->v, 29, 25) == 0x0)
>            && (G_FLD (inst->v, 24, 20) == 0x2)
>            && (G_FLD (inst->v, 19, 15) == 0x0)
> 	   && (G_FLD (inst->v, 14, 10) == 0xF)
> 	   && (G_FLD (inst->v, 9, 0) == 0x56))
>     return 1;   /* mv r0, r2 */
>   else if (inst->len == 2
>            && (G_FLD (inst->v, 14, 12) == 0x0)
>            && (G_FLD (inst->v, 11, 5) == 0x2))
>     return 1;   /* pop! */
>   else if (inst->len == 2
>            && (G_FLD (inst->v, 14, 12) == 0x0)
>            && (G_FLD (inst->v, 11, 7) == 0x0)
>            && (G_FLD (inst->v, 6, 5) == 0x2))
>     return 1;   /* rpop! */
>   else if (inst->len == 2
>            && (G_FLD (inst->v, 14, 12) == 0x0)
>            && (G_FLD (inst->v, 11, 5) == 0x4)
>            && (G_FLD (inst->v, 4, 0) == 0x3))
>     return 1;   /* br! r3 */
>   else if (inst->len == 4
>            && (G_FLD (inst->v, 29, 25) == 0x0)
>            && (G_FLD (inst->v, 24, 20) == 0x0)
>            && (G_FLD (inst->v, 19, 15) == 0x3)
>            && (G_FLD (inst->v, 14, 10) == 0xF)
>            && (G_FLD (inst->v, 9, 0) == 0x8))
>     return 1;   /* br r3 */
>   else
>     return 0;
> }
> 
> static char *
> score7_malloc_and_get_memblock (CORE_ADDR addr, CORE_ADDR size)
> {
>   int ret;
>   char *memblock = NULL;
> 
>   if (size < 0)
>     {
>       error ("Error: malloc size < 0 in file:%s, line:%d!",
>              __FILE__, __LINE__);
>       return NULL;
>     }
>   else if (size == 0)
>     return NULL;
> 
>   memblock = (char *) xmalloc (size);
>   memset (memblock, 0, size);
>   ret = target_read_memory (addr & ~0x3, memblock, size);
>   if (ret)
>     {
>       error ("Error: target_read_memory in file:%s, line:%d!",
>              __FILE__, __LINE__);
>       return NULL;
>     }
>   return memblock;
> }
> 
> static void
> score7_free_memblock (char *memblock)
> {
>   xfree (memblock);
> }
> 
755c904,924
< score_analyze_prologue (CORE_ADDR startaddr, CORE_ADDR pc,
---
> score7_adjust_memblock_ptr (char **memblock, CORE_ADDR prev_pc,
>                            CORE_ADDR cur_pc)
> {
>   if (prev_pc == -1)
>     {
>       /* First time call this function, do nothing.  */
>     }
>   else if (cur_pc - prev_pc == 2 && (cur_pc & 0x3) == 0)
>     {
>       /* First 16-bit instruction, then 32-bit instruction.  */
>       *memblock += SCORE_INSTLEN;
>     }
>   else if (cur_pc - prev_pc == 4)
>     {
>       /* Is 32-bit instruction, increase MEMBLOCK by 4.  */
>       *memblock += SCORE_INSTLEN;
>     }
> }
> 
> static void
> score7_analyze_prologue (CORE_ADDR startaddr, CORE_ADDR pc,
777c946
<     score_malloc_and_get_memblock (startaddr, pc - startaddr);
---
>     score7_malloc_and_get_memblock (startaddr, pc - startaddr);
789,790c958,959
<           score_adjust_memblock_ptr (&memblock, prev_pc, cur_pc);
<           inst = score_fetch_inst (gdbarch, cur_pc, memblock);
---
>           score7_adjust_memblock_ptr (&memblock, prev_pc, cur_pc);
>           inst = score7_fetch_inst (gdbarch, cur_pc, memblock);
796c965
<           inst = score_fetch_inst (gdbarch, cur_pc, NULL);
---
>           inst = score7_fetch_inst (gdbarch, cur_pc, NULL);
799c968,969
<       if (inst->is15 == 1)
---
>       /* FIXME: make a full-power prologue analyzer */
>       if (inst->len == 2)
847,848c1017,1019
<           if (G_FLD (inst->v, 29, 15) == 0xc60
<               && G_FLD (inst->v, 2, 0) == 0x4)
---
>           if (G_FLD(inst->v, 29, 25) == 0x3
>               && G_FLD(inst->v, 2, 0) == 0x4
>               && G_FLD(inst->v, 19, 15) == 0)
850,856c1021,1041
<               /* sw r3, [r0, offset]+ */
<               sp_offset += SCORE_INSTLEN;
<               if (ra_offset_p == 0)
<                 {
<                   ra_offset = sp_offset;
<                   ra_offset_p = 1;
<                 }
---
>                 /* sw rD, [r0, offset]+ */
>                 sp_offset += SCORE_INSTLEN;
> 
>                 if (G_FLD(inst->v, 24, 20) == 0x3)
>                   {
>                       /* rD = r3 */
>                       if (ra_offset_p == 0)
>                         {
>                             ra_offset = sp_offset;
>                             ra_offset_p = 1;
>                         }
>                   }
>                 else if (G_FLD(inst->v, 24, 20) == 0x2)
>                   {
>                       /* rD = r2 */
>                       if (fp_offset_p == 0)
>                         {
>                             fp_offset = sp_offset;
>                             fp_offset_p = 1;
>                         }
>                   }
858,859c1043,1044
<           if (G_FLD (inst->v, 29, 15) == 0xc40
<               && G_FLD (inst->v, 2, 0) == 0x4)
---
>           else if (G_FLD(inst->v, 29, 25) == 0x14
>                    && G_FLD(inst->v, 19,15) == 0)
861,867c1046,1058
<               /* sw r2, [r0, offset]+ */
<               sp_offset += SCORE_INSTLEN;
<               if (fp_offset_p == 0)
<                 {
<                   fp_offset = sp_offset;
<                   fp_offset_p = 1;
<                 }
---
>                 /* sw rD, [r0, offset] */
>                 if (G_FLD(inst->v, 24, 20) == 0x3)
>                   {
>                       /* rD = r3 */
>                       ra_offset = sp_offset - G_FLD(inst->v, 14, 0);
>                       ra_offset_p = 1;
>                   }
>                 else if (G_FLD(inst->v, 24, 20) == 0x2)
>                   {
>                       /* rD = r2 */
>                       fp_offset = sp_offset - G_FLD(inst->v, 14, 0);
>                       fp_offset_p = 1;
>                   }
898c1089
<                     score_fetch_inst (gdbarch, cur_pc + SCORE_INSTLEN, NULL);
---
>                     score7_fetch_inst (gdbarch, cur_pc + SCORE_INSTLEN, NULL);
936c1127,1369
<     score_free_memblock (memblock_ptr);
---
>     score7_free_memblock (memblock_ptr);
> }
> 
> static void
> score3_analyze_prologue (CORE_ADDR startaddr, CORE_ADDR pc,
>                         struct frame_info *this_frame,
>                         struct score_frame_cache *this_cache)
> {
>   CORE_ADDR sp;
>   CORE_ADDR fp;
>   CORE_ADDR cur_pc = startaddr;
> 
>   int sp_offset = 0;
>   int ra_offset = 0;
>   int fp_offset = 0;
>   int ra_offset_p = 0;
>   int fp_offset_p = 0;
>   int inst_len = 0;
> 
>   CORE_ADDR prev_pc = -1;
> 
>   sp = get_frame_register_unsigned (this_frame, SCORE_SP_REGNUM);
>   fp = get_frame_register_unsigned (this_frame, SCORE_FP_REGNUM);
> 
>   for (; cur_pc < pc; prev_pc = cur_pc, cur_pc += inst_len)
>     {
>       inst_t *inst = NULL;
> 
>       inst = score3_adjust_pc_and_fetch_inst (&cur_pc, &inst_len);
> 
>       /* FIXME: make a full-power prologue analyzer */
>       if (inst->len == 2)
>         {
>           if (G_FLD (inst->v, 14, 12) == 0x0
>               && G_FLD (inst->v, 11, 7) == 0x0
>               && G_FLD (inst->v, 6, 5) == 0x3)
>             {
>               /* push! */
>               sp_offset += 4;
> 
>               if (G_FLD (inst->v, 4, 0) == 0x3
>                   && ra_offset_p == 0)
>                 {
>                   /* push! r3, [r0] */
>                   ra_offset = sp_offset;
>                   ra_offset_p = 1;
>                 }
>               else if (G_FLD (inst->v, 4, 0) == 0x2
>                        && fp_offset_p == 0)
>                 {
>                   /* push! r2, [r0] */
>                   fp_offset = sp_offset;
>                   fp_offset_p = 1;
>                 }
>             }
>           else if (G_FLD (inst->v, 14, 12) == 0x6
>                    && G_FLD (inst->v, 11, 10) == 0x3)
>             {
>               /* rpush! */
>               int start_r = G_FLD (inst->v, 9, 5);
>               int cnt = G_FLD (inst->v, 4, 0);
>      
>               if ((ra_offset_p == 0)
> 		  && (start_r <= SCORE_RA_REGNUM)
>                   && (SCORE_RA_REGNUM < start_r + cnt))
>                 {
>                   /* rpush! contains r3 */
>                   ra_offset_p = 1;
>                   ra_offset = sp_offset + 4 * (SCORE_RA_REGNUM - start_r) + 4;
>                 }
> 
>               if ((fp_offset_p == 0)
> 		  && (start_r <= SCORE_FP_REGNUM)
>                   && (SCORE_FP_REGNUM < start_r + cnt))
>                 {
>                   /* rpush! contains r2 */
>                   fp_offset_p = 1;
>                   fp_offset = sp_offset + 4 * (SCORE_FP_REGNUM - start_r) + 4;
>                 }
> 
>               sp_offset += 4 * cnt;
>             }
>           else if (G_FLD (inst->v, 14, 12) == 0x0
>                    && G_FLD (inst->v, 11, 7) == 0x0
>                    && G_FLD (inst->v, 6, 5) == 0x2)
>             {
>               /* pop! */
>               sp_offset -= 4;
>             }
>           else if (G_FLD (inst->v, 14, 12) == 0x6
>                    && G_FLD (inst->v, 11, 10) == 0x2)
>             {
>               /* rpop! */
>               sp_offset -= 4 * G_FLD (inst->v, 4, 0);
>             }
>           else if (G_FLD (inst->v, 14, 12) == 0x5
>                    && G_FLD (inst->v, 11, 10) == 0x3
>                    && G_FLD (inst->v, 9, 6) == 0x0)
>             {
>               /* addi! r0, -offset */
>               int imm = G_FLD (inst->v, 5, 0);
> 	      if (imm >> 5)
> 		imm = -(0x3F - imm + 1);
> 	      sp_offset -= imm;
>             }
>           else if (G_FLD (inst->v, 14, 12) == 0x5
>                    && G_FLD (inst->v, 11, 10) == 0x3
>                    && G_FLD (inst->v, 9, 6) == 0x2)
>             {
>               /* addi! r2, offset */
>               if (pc - cur_pc >= 2)
>                 {
>                   unsigned int save_v = inst->v;
>                   inst_t *inst2;
> 
> 		          cur_pc += inst->len;
>                   inst2 = score3_adjust_pc_and_fetch_inst (&cur_pc, NULL);
> 
>                   if (inst2->len == 2
>                       && G_FLD (inst2->v, 14, 10) == 0x10
>                       && G_FLD (inst2->v, 9, 5) == 0x0
>                       && G_FLD (inst2->v, 4, 0) == 0x2)
>                     {
>                       /* mv! r0, r2 */
>                       int imm = G_FLD (inst->v, 5, 0);
> 	              if (imm >> 5)
> 		        imm = -(0x3F - imm + 1);
>                       sp_offset -= imm;
>                     }
>                 }
> 	    }
>         }
>       else if (inst->len == 4)
>         {
>           if (G_FLD (inst->v, 29, 25) == 0x3
>               && G_FLD (inst->v, 2, 0) == 0x4
>               && G_FLD (inst->v, 24, 20) == 0x3
>               && G_FLD (inst->v, 19, 15) == 0x0)
>             {
>               /* sw r3, [r0, offset]+ */
>               sp_offset += inst->len;
>               if (ra_offset_p == 0)
>                 {
>                   ra_offset = sp_offset;
>                   ra_offset_p = 1;
>                 }
>             }
>           else if (G_FLD (inst->v, 29, 25) == 0x3
>                    && G_FLD (inst->v, 2, 0) == 0x4
>                    && G_FLD (inst->v, 24, 20) == 0x2
>                    && G_FLD (inst->v, 19, 15) == 0x0)
>             {
>               /* sw r2, [r0, offset]+ */
>               sp_offset += inst->len;
>               if (fp_offset_p == 0)
>                 {
>                   fp_offset = sp_offset;
>                   fp_offset_p = 1;
>                 }
>             }
>           else if (G_FLD (inst->v, 29, 25) == 0x7
>                    && G_FLD (inst->v, 2, 0) == 0x0
>                    && G_FLD (inst->v, 24, 20) == 0x3
>                    && G_FLD (inst->v, 19, 15) == 0x0)
>             {
>               /* lw r3, [r0]+, 4 */
>               sp_offset -= inst->len;
>               ra_offset_p = 1;
>             }
>           else if (G_FLD (inst->v, 29, 25) == 0x7
>                    && G_FLD (inst->v, 2, 0) == 0x0
>                    && G_FLD (inst->v, 24, 20) == 0x2
>                    && G_FLD (inst->v, 19, 15) == 0x0)
>             {
>               /* lw r2, [r0]+, 4 */
>               sp_offset -= inst->len;
>               fp_offset_p = 1;
>             }
>           else if (G_FLD (inst->v, 29, 25) == 0x1
>                    && G_FLD (inst->v, 19, 17) == 0x0
>                    && G_FLD (inst->v, 24, 20) == 0x0
>                    && G_FLD (inst->v, 0, 0) == 0x0)
>             {
>               /* addi r0, -offset */
>               int imm = G_FLD (inst->v, 16, 1);
> 	      if (imm >> 15)
> 		imm = -(0xFFFF - imm + 1);
>               sp_offset -= imm;
>             }
>           else if (G_FLD (inst->v, 29, 25) == 0x1
>                    && G_FLD (inst->v, 19, 17) == 0x0
>                    && G_FLD (inst->v, 24, 20) == 0x2
>                    && G_FLD (inst->v, 0, 0) == 0x0)
>             {
>               /* addi r2, offset */
>               if (pc - cur_pc >= 2)
>                 {
>                   unsigned int save_v = inst->v;
>                   inst_t *inst2;
> 
> 		          cur_pc += inst->len;
>                   inst2 = score3_adjust_pc_and_fetch_inst (&cur_pc, NULL);
> 
>                   if (inst2->len == 2
>                       && G_FLD (inst2->v, 14, 10) == 0x10
>                       && G_FLD (inst2->v, 9, 5) == 0x0
>                       && G_FLD (inst2->v, 4, 0) == 0x2)
>                     {
>                       /* mv! r0, r2 */
>                       int imm = G_FLD (inst->v, 16, 1);
> 	              if (imm >> 15)
> 		        imm = -(0xFFFF - imm + 1);
>                       sp_offset -= imm;
>                     }
>                 }
>             }
>         }
>     }
> 
>   /* Save RA.  */
>   if (ra_offset_p == 1)
>     {
>       if (this_cache->saved_regs[SCORE_PC_REGNUM].addr == -1)
>         this_cache->saved_regs[SCORE_PC_REGNUM].addr =
>           sp + sp_offset - ra_offset;
>     }
>   else
>     {
>       this_cache->saved_regs[SCORE_PC_REGNUM] =
>         this_cache->saved_regs[SCORE_RA_REGNUM];
>     }
> 
>   /* Save FP.  */
>   if (fp_offset_p == 1)
>     {
>       if (this_cache->saved_regs[SCORE_FP_REGNUM].addr == -1)
>         this_cache->saved_regs[SCORE_FP_REGNUM].addr =
>           sp + sp_offset - fp_offset;
>     }
> 
>   /* Save SP and FP.  */
>   this_cache->base = sp + sp_offset;
>   this_cache->fp = fp;
959c1392,1396
<     score_analyze_prologue (start_addr, pc, this_frame, *this_cache);
---
> 
>     if (target_mach == bfd_mach_score3)
>       score3_analyze_prologue (start_addr, pc, this_frame, *this_cache);
>     else
>       score7_analyze_prologue (start_addr, pc, this_frame, *this_cache);
992c1429,1430
<   default_frame_sniffer
---
>   default_frame_sniffer,
>   NULL
1017a1456,1527
> /* Core file support (dirty hack)
>   
>    The core file MUST be generated by GNU/Linux on S+core */
> 
> static void
> score7_linux_supply_gregset(const struct regset *regset,
>                 struct regcache *regcache,
>                 int regnum, const void *gregs_buf, size_t len)
> {
>     int regno;
>     elf_gregset_t *gregs;
> 
>     gdb_assert (regset != NULL);
>     gdb_assert ((regcache != NULL) && (gregs_buf != NULL));
> 
>     gregs = (elf_gregset_t *) gregs_buf;
> 
>     for (regno = 0; regno < 32; regno++)
>         if (regnum == -1 || regnum == regno)
>             regcache_raw_supply (regcache, regno, gregs->regs + regno);
> 
>     {
>         struct sreg {
>                 int regnum;
>                 void *buf;
>         } sregs [] = {
>                 { 55, &(gregs->cel) },  /* CEL */
>                 { 54, &(gregs->ceh) },  /* CEH */
>                 { 53, &(gregs->sr0) },  /* sr0, i.e. cnt or COUNTER */
>                 { 52, &(gregs->sr1) },  /* sr1, i.e. lcr or LDCR */
>                 { 51, &(gregs->sr1) },  /* sr2, i.e. scr or STCR */
> 
>                 /* Exception occured at this address, exactly the PC we want */
>                 { 49, &(gregs->cp0_epc) }, /* PC */
> 
>                 { 38, &(gregs->cp0_ema) }, /* EMA */
>                 { 37, &(gregs->cp0_epc) }, /* EPC */
>                 { 34, &(gregs->cp0_ecr) }, /* ECR */
>                 { 33, &(gregs->cp0_condition) }, /* COND */
>                 { 32, &(gregs->cp0_psr) }, /* PSR */
>         };
> 
>         for (regno = 0; regno < sizeof(sregs)/sizeof(sregs[0]); regno++)
>                 if (regnum == -1 || regnum == sregs[regno].regnum)
>                         regcache_raw_supply (regcache, sregs[regno].regnum, sregs[regno].buf);
>     }
> }
> 
> /* Return the appropriate register set from the core section identified
>    by SECT_NAME and SECT_SIZE. */
> 
> static const struct regset *
> score7_linux_regset_from_core_section(struct gdbarch *gdbarch,
>                     const char *sect_name, size_t sect_size)
> {
>     struct gdbarch_tdep *tdep;
> 
>     gdb_assert (gdbarch != NULL);
>     gdb_assert (sect_name != NULL);
> 
>     tdep = gdbarch_tdep (gdbarch);
> 
>     if (strcmp(sect_name, ".reg") == 0 && sect_size == sizeof(elf_gregset_t))
>     {
>         if (tdep->gregset == NULL)
>             tdep->gregset = regset_alloc (gdbarch, score7_linux_supply_gregset, NULL);
>         return tdep->gregset;
>     }
> 
>     return NULL;
> }
> 
1021a1532,1533
>   struct gdbarch_tdep *tdep;
>   target_mach = info.bfd_arch_info->mach;
1028c1540,1541
<   gdbarch = gdbarch_alloc (&info, 0);
---
>   tdep = xcalloc(1, sizeof(struct gdbarch_tdep));
>   gdbarch = gdbarch_alloc (&info, tdep);
1034a1548
> #if WITH_SIM
1035a1550
> #endif
1038,1040c1553
<   set_gdbarch_num_regs (gdbarch, SCORE_NUM_REGS);
<   set_gdbarch_register_name (gdbarch, score_register_name);
<   set_gdbarch_breakpoint_from_pc (gdbarch, score_breakpoint_from_pc);
---
>   set_gdbarch_adjust_breakpoint_address (gdbarch, score_adjust_breakpoint_address);
1044d1556
<   set_gdbarch_unwind_pc (gdbarch, score_unwind_pc);
1045a1558
>   set_gdbarch_unwind_pc (gdbarch, score_unwind_pc);
1047,1048c1560,1580
<   set_gdbarch_skip_prologue (gdbarch, score_skip_prologue);
<   set_gdbarch_in_function_epilogue_p (gdbarch, score_in_function_epilogue_p);
---
> 
>   switch (target_mach)
>     {
>     case bfd_mach_score7:
>       set_gdbarch_breakpoint_from_pc (gdbarch, score7_breakpoint_from_pc);
>       set_gdbarch_skip_prologue (gdbarch, score7_skip_prologue);
>       set_gdbarch_in_function_epilogue_p (gdbarch, score7_in_function_epilogue_p);
>       set_gdbarch_register_name (gdbarch, score7_register_name);
>       set_gdbarch_num_regs (gdbarch, SCORE7_NUM_REGS);
>       /* Core file support. */
>       set_gdbarch_regset_from_core_section (gdbarch, score7_linux_regset_from_core_section);
>       break;
> 
>     case bfd_mach_score3:
>       set_gdbarch_breakpoint_from_pc (gdbarch, score3_breakpoint_from_pc);
>       set_gdbarch_skip_prologue (gdbarch, score3_skip_prologue);
>       set_gdbarch_in_function_epilogue_p (gdbarch, score3_in_function_epilogue_p);
>       set_gdbarch_register_name (gdbarch, score3_register_name);
>       set_gdbarch_num_regs (gdbarch, SCORE3_NUM_REGS);
>       break;
>     }
Index: gdb/score-tdep.h
===================================================================
RCS file: /cvs/src/src/gdb/score-tdep.h,v
retrieving revision 1.5
diff -r1.5 score-tdep.h
41c41,42
< #define SCORE_NUM_REGS         56
---
> #define SCORE7_NUM_REGS         56
> #define SCORE3_NUM_REGS         50
47a49,151
> /* Forward declarations. */
> struct regset;
> 
> /* Target-dependent structure in gdbarch */
> struct gdbarch_tdep
> {
>     /* Cached core file helpers. */
>     struct regset *gregset;
> };
> 
> /* Linux Core file support (dirty hack)
>   
>    S+core Linux register set definition, copy from S+core Linux */
> struct pt_regs {
>     /* Pad bytes for argument save space on the stack. */
>     unsigned long pad0[6]; /* may be 4,MIPS accept 6var,SCore accepts 4 Var--yuchen */
> 
>     /* Saved main processor registers. */
>     unsigned long orig_r4;
>     unsigned long regs[32];
> 
>     /* Other saved registers. */
>     unsigned long cel;
>     unsigned long ceh;
> 
>     unsigned long sr0;  /*cnt*/
>     unsigned long sr1;  /*lcr*/
>     unsigned long sr2;  /*scr*/
> 
>     /* saved cp0 registers */
>     unsigned long cp0_epc;
>     unsigned long cp0_ema;
>     unsigned long cp0_psr;
>     unsigned long cp0_ecr;
>     unsigned long cp0_condition;
> };
> 
> typedef struct pt_regs elf_gregset_t;
> 
> #ifdef WITH_SIM
> 
> #include <breakpoint.h>
> 
> int soc_gh_can_use_watch(int type, int cnt);
> int soc_gh_add_watch(unsigned int addr, int len, int type);
> int soc_gh_del_watch(unsigned int addr, int len, int type);
> int soc_gh_stopped_by_watch(void);
> int soc_gh_add_hardbp(unsigned int addr); 
> int soc_gh_del_hardbp(unsigned int addr); 
> 
> int score_target_can_use_watch(int type, int cnt, int ot);
> int score_stopped_by_watch(void);
> int score_target_insert_watchpoint (CORE_ADDR addr, int len, int type);
> int score_target_remove_watchpoint (CORE_ADDR addr, int len, int type);
> int score_target_insert_hw_breakpoint (struct bp_target_info * bp_tgt);
> int score_target_remove_hw_breakpoint (struct bp_target_info * bp_tgt);
> 
> #define TARGET_HAS_HARDWARE_WATCHPOINTS
> 
> #ifdef TARGET_CAN_USE_HARDWARE_WATCHPOINT
> #undef TARGET_CAN_USE_HARDWARE_WATCHPOINT
> 
> #define TARGET_CAN_USE_HARDWARE_WATCHPOINT(type, cnt, ot) \
>     score_target_can_use_watch(type, cnt, ot)
> #endif
> 
> #ifdef STOPPED_BY_WATCHPOINT
> #undef STOPPED_BY_WATCHPOINT
> 
> #define STOPPED_BY_WATCHPOINT(w) \
>     score_stopped_by_watch()
> #endif
> 
> #ifdef target_insert_watchpoint
> #undef target_insert_watchpoint
> 
> #define target_insert_watchpoint(addr, len, type) \
>     score_target_insert_watchpoint (addr, len, type)
> #endif
> 
> #ifdef target_remove_watchpoint
> #undef target_remove_watchpoint
> 
> #define target_remove_watchpoint(addr, len, type) \
>     score_target_remove_watchpoint (addr, len, type)
> #endif
> 
> #ifdef target_insert_hw_breakpoint
> #undef target_insert_hw_breakpoint
> 
> #define target_insert_hw_breakpoint(bp_tgt) \
>     score_target_insert_hw_breakpoint (bp_tgt)
> #endif
> 
> #ifdef target_remove_hw_breakpoint
> #undef target_remove_hw_breakpoint
> 
> #define target_remove_hw_breakpoint(bp_tgt) \
>     score_target_remove_hw_breakpoint (bp_tgt)
> #endif
> 
> #endif /* WITH_SIM */
> 
