1 /* Target-dependent code for the S+core architecture, for GDB,
4 Copyright (C) 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
6 Contributed by Qinwei (qinwei@sunnorth.com.cn)
7 Contributed by Ching-Peng Lin (cplin@sunplus.com)
9 This file is part of GDB.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program. If not, see <http://www.gnu.org/licenses/>. */
25 #include "gdb_assert.h"
31 #include "arch-utils.h"
34 #include "frame-unwind.h"
35 #include "frame-base.h"
36 #include "trad-frame.h"
37 #include "dwarf2-frame.h"
38 #include "score-tdep.h"
40 #define G_FLD(_i,_ms,_ls) (((_i) << (31 - (_ms))) >> (31 - (_ms) + (_ls)))
41 #define RM_PBITS(_raw) ((G_FLD(_raw, 31, 16) << 15) | G_FLD(_raw, 14, 0))
49 struct score_frame_cache
53 struct trad_frame_saved_reg *saved_regs;
57 /* If S+core GCC will generate these instructions in the prologue:
63 then .pdr section is used. */
74 typedef struct frame_extra_info
77 unsigned int pdr[P_SIZE];
89 score_compare_pdr_entries (const void *a, const void *b)
91 CORE_ADDR lhs = bfd_get_32 (the_bfd, (bfd_byte *) a);
92 CORE_ADDR rhs = bfd_get_32 (the_bfd, (bfd_byte *) b);
102 score_analyze_pdr_section (CORE_ADDR startaddr, CORE_ADDR pc,
103 struct frame_info *this_frame,
104 struct score_frame_cache *this_cache)
107 struct obj_section *sec;
108 extra_info_t *fci_ext;
109 CORE_ADDR leaf_ra_stack_addr = -1;
111 gdb_assert (startaddr <= pc);
112 gdb_assert (this_cache != NULL);
114 fci_ext = frame_obstack_zalloc (sizeof (extra_info_t));
115 if ((sec = find_pc_section (pc)) == NULL)
117 error ("Error: Can't find section in file:%s, line:%d!",
122 /* Anylyze .pdr section and get coresponding fields. */
124 static struct obj_priv *priv = NULL;
129 priv = obstack_alloc (&sec->objfile->objfile_obstack,
130 sizeof (struct obj_priv));
131 if ((bfdsec = bfd_get_section_by_name (sec->objfile->obfd, ".pdr")))
133 priv->size = bfd_section_size (sec->objfile->obfd, bfdsec);
134 priv->contents = obstack_alloc (&sec->objfile->objfile_obstack,
136 bfd_get_section_contents (sec->objfile->obfd, bfdsec,
137 priv->contents, 0, priv->size);
138 the_bfd = sec->objfile->obfd;
139 qsort (priv->contents, priv->size / 32, 32,
140 score_compare_pdr_entries);
148 int low = 0, mid, high = priv->size / 32;
153 mid = (low + high) / 2;
154 ptr = priv->contents + mid * 32;
155 pdr_pc = bfd_get_signed_32 (sec->objfile->obfd, ptr);
156 pdr_pc += ANOFFSET (sec->objfile->section_offsets,
157 SECT_OFF_TEXT (sec->objfile));
158 if (pdr_pc == startaddr)
160 if (pdr_pc > startaddr)
169 gdb_assert (bfd_get_32 (sec->objfile->obfd, ptr) == startaddr);
170 #define EXT_PDR(_pi) bfd_get_32(sec->objfile->obfd, ptr+((_pi)<<2))
171 fci_ext->pdr[PI_SYM] = EXT_PDR (PI_SYM);
172 fci_ext->pdr[PI_R_MSK] = EXT_PDR (PI_R_MSK);
173 fci_ext->pdr[PI_R_OFF] = EXT_PDR (PI_R_OFF);
174 fci_ext->pdr[PI_R_LEF] = EXT_PDR (PI_R_LEF);
175 fci_ext->pdr[PI_F_OFF] = EXT_PDR (PI_F_OFF);
176 fci_ext->pdr[PI_F_REG] = EXT_PDR (PI_F_REG);
177 fci_ext->pdr[PI_RAREG] = EXT_PDR (PI_RAREG);
186 /* Open these functions if build with simulator. */
189 score_target_can_use_watch (int type, int cnt, int othertype)
191 if (strcmp (current_target.to_shortname, "sim") == 0)
193 return soc_gh_can_use_watch (type, cnt);
197 return (*current_target.to_can_use_hw_breakpoint) (type, cnt, othertype);
202 score_stopped_by_watch (void)
204 if (strcmp (current_target.to_shortname, "sim") == 0)
206 return soc_gh_stopped_by_watch ();
210 return (*current_target.to_stopped_by_watchpoint) ();
215 score_target_insert_watchpoint (CORE_ADDR addr, int len, int type)
217 if (strcmp (current_target.to_shortname, "sim") == 0)
219 return soc_gh_add_watch (addr, len, type);
223 return (*current_target.to_insert_watchpoint) (addr, len, type);
228 score_target_remove_watchpoint (CORE_ADDR addr, int len, int type)
230 if (strcmp (current_target.to_shortname, "sim") == 0)
232 return soc_gh_del_watch (addr, len, type);
236 return (*current_target.to_remove_watchpoint) (addr, len, type);
241 score_target_insert_hw_breakpoint (struct bp_target_info * bp_tgt)
243 if (strcmp (current_target.to_shortname, "sim") == 0)
245 return soc_gh_add_hardbp (bp_tgt->placed_address);
249 return (*current_target.to_insert_hw_breakpoint) (bp_tgt);
254 score_target_remove_hw_breakpoint (struct bp_target_info * bp_tgt)
256 if (strcmp (current_target.to_shortname, "sim") == 0)
258 return soc_gh_del_hardbp (bp_tgt->placed_address);
262 return (*current_target.to_remove_hw_breakpoint) (bp_tgt);
268 score_register_type (struct gdbarch *gdbarch, int regnum)
270 gdb_assert (regnum >= 0 && regnum < SCORE_NUM_REGS);
271 return builtin_type (gdbarch)->builtin_uint32;
275 score_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
277 return frame_unwind_register_unsigned (next_frame, SCORE_PC_REGNUM);
281 score_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
283 return frame_unwind_register_unsigned (next_frame, SCORE_SP_REGNUM);
287 score_register_name (struct gdbarch *gdbarch, int regnum)
289 const char *score_register_names[] = {
290 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
291 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
292 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
293 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
295 "PSR", "COND", "ECR", "EXCPVEC",
296 "CCR", "EPC", "EMA", "TLBLOCK",
297 "TLBPT", "PEADDR", "TLBRPT", "PEVN",
298 "PECTX", "LIMPFN", "LDMPFN", "PREV",
299 "DREG", "PC", "DSAVE", "COUNTER",
300 "LDCR", "STCR", "CEH", "CEL",
303 gdb_assert (regnum >= 0 && regnum < SCORE_NUM_REGS);
304 return score_register_names[regnum];
308 score_register_sim_regno (struct gdbarch *gdbarch, int regnum)
310 gdb_assert (regnum >= 0 && regnum < SCORE_NUM_REGS);
315 score_print_insn (bfd_vma memaddr, struct disassemble_info *info)
317 if (info->endian == BFD_ENDIAN_BIG)
318 return print_insn_big_score (memaddr, info);
320 return print_insn_little_score (memaddr, info);
323 static const gdb_byte *
324 score_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr,
327 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
328 gdb_byte buf[SCORE_INSTLEN] = { 0 };
332 if ((ret = target_read_memory (*pcptr & ~0x3, buf, SCORE_INSTLEN)) != 0)
334 error ("Error: target_read_memory in file:%s, line:%d!",
337 raw = extract_unsigned_integer (buf, SCORE_INSTLEN, byte_order);
339 if (byte_order == BFD_ENDIAN_BIG)
341 if (!(raw & 0x80008000))
343 /* 16bits instruction. */
344 static gdb_byte big_breakpoint16[] = { 0x60, 0x02 };
346 *lenptr = sizeof (big_breakpoint16);
347 return big_breakpoint16;
351 /* 32bits instruction. */
352 static gdb_byte big_breakpoint32[] = { 0x80, 0x00, 0x80, 0x06 };
354 *lenptr = sizeof (big_breakpoint32);
355 return big_breakpoint32;
360 if (!(raw & 0x80008000))
362 /* 16bits instruction. */
363 static gdb_byte little_breakpoint16[] = { 0x02, 0x60 };
365 *lenptr = sizeof (little_breakpoint16);
366 return little_breakpoint16;
370 /* 32bits instruction. */
371 static gdb_byte little_breakpoint32[] = { 0x06, 0x80, 0x00, 0x80 };
373 *lenptr = sizeof (little_breakpoint32);
374 return little_breakpoint32;
380 score_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
382 return align_down (addr, 16);
386 score_xfer_register (struct regcache *regcache, int regnum, int length,
387 enum bfd_endian endian, gdb_byte *readbuf,
388 const gdb_byte *writebuf, int buf_offset)
391 gdb_assert (regnum >= 0 && regnum < SCORE_NUM_REGS);
396 reg_offset = SCORE_REGSIZE - length;
398 case BFD_ENDIAN_LITTLE:
401 case BFD_ENDIAN_UNKNOWN:
405 error ("Error: score_xfer_register in file:%s, line:%d!",
410 regcache_cooked_read_part (regcache, regnum, reg_offset, length,
411 readbuf + buf_offset);
412 if (writebuf != NULL)
413 regcache_cooked_write_part (regcache, regnum, reg_offset, length,
414 writebuf + buf_offset);
417 static enum return_value_convention
418 score_return_value (struct gdbarch *gdbarch, struct type *func_type,
419 struct type *type, struct regcache *regcache,
420 gdb_byte * readbuf, const gdb_byte * writebuf)
422 if (TYPE_CODE (type) == TYPE_CODE_STRUCT
423 || TYPE_CODE (type) == TYPE_CODE_UNION
424 || TYPE_CODE (type) == TYPE_CODE_ARRAY)
425 return RETURN_VALUE_STRUCT_CONVENTION;
430 for (offset = 0, regnum = SCORE_A0_REGNUM;
431 offset < TYPE_LENGTH (type);
432 offset += SCORE_REGSIZE, regnum++)
434 int xfer = SCORE_REGSIZE;
435 if (offset + xfer > TYPE_LENGTH (type))
436 xfer = TYPE_LENGTH (type) - offset;
437 score_xfer_register (regcache, regnum, xfer,
438 gdbarch_byte_order (gdbarch),
439 readbuf, writebuf, offset);
441 return RETURN_VALUE_REGISTER_CONVENTION;
445 static struct frame_id
446 score_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
448 return frame_id_build (
449 get_frame_register_unsigned (this_frame, SCORE_SP_REGNUM),
450 get_frame_pc (this_frame));
454 score_type_needs_double_align (struct type *type)
456 enum type_code typecode = TYPE_CODE (type);
458 if ((typecode == TYPE_CODE_INT && TYPE_LENGTH (type) == 8)
459 || (typecode == TYPE_CODE_FLT && TYPE_LENGTH (type) == 8))
461 else if (typecode == TYPE_CODE_STRUCT || typecode == TYPE_CODE_UNION)
465 n = TYPE_NFIELDS (type);
466 for (i = 0; i < n; i++)
467 if (score_type_needs_double_align (TYPE_FIELD_TYPE (type, i)))
475 score_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
476 struct regcache *regcache, CORE_ADDR bp_addr,
477 int nargs, struct value **args, CORE_ADDR sp,
478 int struct_return, CORE_ADDR struct_addr)
480 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
484 CORE_ADDR stack_offset = 0;
487 /* Step 1, Save RA. */
488 regcache_cooked_write_unsigned (regcache, SCORE_RA_REGNUM, bp_addr);
490 /* Step 2, Make space on the stack for the args. */
491 struct_addr = align_down (struct_addr, 16);
492 sp = align_down (sp, 16);
493 for (argnum = 0; argnum < nargs; argnum++)
494 arglen += align_up (TYPE_LENGTH (value_type (args[argnum])),
496 sp -= align_up (arglen, 16);
498 argreg = SCORE_BEGIN_ARG_REGNUM;
500 /* Step 3, Check if struct return then save the struct address to
501 r4 and increase the stack_offset by 4. */
504 regcache_cooked_write_unsigned (regcache, argreg++, struct_addr);
505 stack_offset += SCORE_REGSIZE;
508 /* Step 4, Load arguments:
509 If arg length is too long (> 4 bytes), then split the arg and
511 for (argnum = 0; argnum < nargs; argnum++)
513 struct value *arg = args[argnum];
514 struct type *arg_type = check_typedef (value_type (arg));
515 enum type_code typecode = TYPE_CODE (arg_type);
516 const gdb_byte *val = value_contents (arg);
517 int downward_offset = 0;
518 int odd_sized_struct_p;
519 int arg_last_part_p = 0;
521 arglen = TYPE_LENGTH (arg_type);
522 odd_sized_struct_p = (arglen > SCORE_REGSIZE
523 && arglen % SCORE_REGSIZE != 0);
525 /* If a arg should be aligned to 8 bytes (long long or double),
526 the value should be put to even register numbers. */
527 if (score_type_needs_double_align (arg_type))
533 /* If sizeof a block < SCORE_REGSIZE, then Score GCC will chose
534 the default "downward"/"upward" method:
540 char a; char b; char c;
541 } s = {'a', 'b', 'c'};
543 Big endian: s = {X, 'a', 'b', 'c'}
544 Little endian: s = {'a', 'b', 'c', X}
546 Where X is a hole. */
548 if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG
549 && (typecode == TYPE_CODE_STRUCT
550 || typecode == TYPE_CODE_UNION)
551 && argreg > SCORE_LAST_ARG_REGNUM
552 && arglen < SCORE_REGSIZE)
553 downward_offset += (SCORE_REGSIZE - arglen);
557 int partial_len = arglen < SCORE_REGSIZE ? arglen : SCORE_REGSIZE;
558 ULONGEST regval = extract_unsigned_integer (val, partial_len,
561 /* The last part of a arg should shift left when
562 gdbarch_byte_order is BFD_ENDIAN_BIG. */
563 if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG
564 && arg_last_part_p == 1
565 && (typecode == TYPE_CODE_STRUCT
566 || typecode == TYPE_CODE_UNION))
567 regval <<= ((SCORE_REGSIZE - partial_len) * TARGET_CHAR_BIT);
569 /* Always increase the stack_offset and save args to stack. */
570 addr = sp + stack_offset + downward_offset;
571 write_memory (addr, val, partial_len);
573 if (argreg <= SCORE_LAST_ARG_REGNUM)
575 regcache_cooked_write_unsigned (regcache, argreg++, regval);
576 if (arglen > SCORE_REGSIZE && arglen < SCORE_REGSIZE * 2)
581 arglen -= partial_len;
582 stack_offset += align_up (partial_len, SCORE_REGSIZE);
586 /* Step 5, Save SP. */
587 regcache_cooked_write_unsigned (regcache, SCORE_SP_REGNUM, sp);
593 score_malloc_and_get_memblock (CORE_ADDR addr, CORE_ADDR size)
596 char *memblock = NULL;
600 error ("Error: malloc size < 0 in file:%s, line:%d!",
607 memblock = (char *) xmalloc (size);
608 memset (memblock, 0, size);
609 ret = target_read_memory (addr & ~0x3, memblock, size);
612 error ("Error: target_read_memory in file:%s, line:%d!",
620 score_free_memblock (char *memblock)
626 score_adjust_memblock_ptr (char **memblock, CORE_ADDR prev_pc,
631 /* First time call this function, do nothing. */
633 else if (cur_pc - prev_pc == 2 && (cur_pc & 0x3) == 0)
635 /* First 16-bit instruction, then 32-bit instruction. */
636 *memblock += SCORE_INSTLEN;
638 else if (cur_pc - prev_pc == 4)
640 /* Is 32-bit instruction, increase MEMBLOCK by 4. */
641 *memblock += SCORE_INSTLEN;
646 score_fetch_inst (struct gdbarch *gdbarch, CORE_ADDR addr, char *memblock)
648 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
649 static inst_t inst = { 0, 0 };
650 char buf[SCORE_INSTLEN] = { 0 };
654 if (target_has_execution && memblock != NULL)
656 /* Fetch instruction from local MEMBLOCK. */
657 memcpy (buf, memblock, SCORE_INSTLEN);
661 /* Fetch instruction from target. */
662 ret = target_read_memory (addr & ~0x3, buf, SCORE_INSTLEN);
665 error ("Error: target_read_memory in file:%s, line:%d!",
671 inst.raw = extract_unsigned_integer (buf, SCORE_INSTLEN, byte_order);
672 inst.is15 = !(inst.raw & 0x80008000);
673 inst.v = RM_PBITS (inst.raw);
674 big = (byte_order == BFD_ENDIAN_BIG);
677 if (big ^ ((addr & 0x2) == 2))
678 inst.v = G_FLD (inst.v, 29, 15);
680 inst.v = G_FLD (inst.v, 14, 0);
686 score_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
689 int iscan = 32, stack_sub = 0;
692 inst_t *inst = score_fetch_inst (gdbarch, cpc, NULL);
695 if (!inst->is15 && !stack_sub
696 && (G_FLD (inst->v, 29, 25) == 0x1
697 && G_FLD (inst->v, 24, 20) == 0x0))
699 /* addi r0, offset */
700 pc = stack_sub = cpc + SCORE_INSTLEN;
703 && inst->v == RM_PBITS (0x8040bc56))
706 pc = cpc + SCORE_INSTLEN;
710 && inst->v == RM_PBITS (0x0203))
713 pc = cpc + SCORE16_INSTLEN;
717 && ((G_FLD (inst->v, 14, 12) == 3) /* j15 form */
718 || (G_FLD (inst->v, 14, 12) == 4) /* b15 form */
719 || (G_FLD (inst->v, 14, 12) == 0x0
720 && G_FLD (inst->v, 3, 0) == 0x4))) /* br! */
723 && ((G_FLD (inst->v, 29, 25) == 2) /* j32 form */
724 || (G_FLD (inst->v, 29, 25) == 4) /* b32 form */
725 || (G_FLD (inst->v, 29, 25) == 0x0
726 && G_FLD (inst->v, 6, 1) == 0x4))) /* br */
729 cpc += inst->is15 ? SCORE16_INSTLEN : SCORE_INSTLEN;
735 score_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR cur_pc)
737 inst_t *inst = score_fetch_inst (gdbarch, cur_pc, NULL);
740 return 1; /* mv! r0, r2 */
741 else if (G_FLD (inst->v, 14, 12) == 0x2
742 && G_FLD (inst->v, 3, 0) == 0xa)
744 else if (G_FLD (inst->v, 14, 12) == 0x0
745 && G_FLD (inst->v, 7, 0) == 0x34)
746 return 1; /* br! r3 */
747 else if (G_FLD (inst->v, 29, 15) == 0x2
748 && G_FLD (inst->v, 6, 1) == 0x2b)
749 return 1; /* mv r0, r2 */
750 else if (G_FLD (inst->v, 29, 25) == 0x0
751 && G_FLD (inst->v, 6, 1) == 0x4
752 && G_FLD (inst->v, 19, 15) == 0x3)
753 return 1; /* br r3 */
759 score_analyze_prologue (CORE_ADDR startaddr, CORE_ADDR pc,
760 struct frame_info *this_frame,
761 struct score_frame_cache *this_cache)
763 struct gdbarch *gdbarch = get_frame_arch (this_frame);
766 CORE_ADDR cur_pc = startaddr;
775 char *memblock = NULL;
776 char *memblock_ptr = NULL;
777 CORE_ADDR prev_pc = -1;
779 /* Allocate MEMBLOCK if PC - STARTADDR > 0. */
780 memblock_ptr = memblock =
781 score_malloc_and_get_memblock (startaddr, pc - startaddr);
783 sp = get_frame_register_unsigned (this_frame, SCORE_SP_REGNUM);
784 fp = get_frame_register_unsigned (this_frame, SCORE_FP_REGNUM);
786 for (; cur_pc < pc; prev_pc = cur_pc, cur_pc += inst_len)
789 if (memblock != NULL)
791 /* Reading memory block from target succefully and got all
792 the instructions(from STARTADDR to PC) needed. */
793 score_adjust_memblock_ptr (&memblock, prev_pc, cur_pc);
794 inst = score_fetch_inst (gdbarch, cur_pc, memblock);
798 /* Otherwise, we fetch 4 bytes from target, and GDB also
800 inst = score_fetch_inst (gdbarch, cur_pc, NULL);
805 inst_len = SCORE16_INSTLEN;
807 if (G_FLD (inst->v, 14, 12) == 0x2
808 && G_FLD (inst->v, 3, 0) == 0xe)
813 if (G_FLD (inst->v, 11, 7) == 0x6
817 ra_offset = sp_offset;
820 else if (G_FLD (inst->v, 11, 7) == 0x4
824 fp_offset = sp_offset;
828 else if (G_FLD (inst->v, 14, 12) == 0x2
829 && G_FLD (inst->v, 3, 0) == 0xa)
834 else if (G_FLD (inst->v, 14, 7) == 0xc1
835 && G_FLD (inst->v, 2, 0) == 0x0)
838 sp_offset += (int) pow (2, G_FLD (inst->v, 6, 3));
840 else if (G_FLD (inst->v, 14, 7) == 0xc0
841 && G_FLD (inst->v, 2, 0) == 0x0)
844 sp_offset -= (int) pow (2, G_FLD (inst->v, 6, 3));
849 inst_len = SCORE_INSTLEN;
851 if (G_FLD (inst->v, 29, 15) == 0xc60
852 && G_FLD (inst->v, 2, 0) == 0x4)
854 /* sw r3, [r0, offset]+ */
855 sp_offset += SCORE_INSTLEN;
856 if (ra_offset_p == 0)
858 ra_offset = sp_offset;
862 if (G_FLD (inst->v, 29, 15) == 0xc40
863 && G_FLD (inst->v, 2, 0) == 0x4)
865 /* sw r2, [r0, offset]+ */
866 sp_offset += SCORE_INSTLEN;
867 if (fp_offset_p == 0)
869 fp_offset = sp_offset;
873 else if (G_FLD (inst->v, 29, 15) == 0x1c60
874 && G_FLD (inst->v, 2, 0) == 0x0)
876 /* lw r3, [r0]+, 4 */
877 sp_offset -= SCORE_INSTLEN;
880 else if (G_FLD (inst->v, 29, 15) == 0x1c40
881 && G_FLD (inst->v, 2, 0) == 0x0)
883 /* lw r2, [r0]+, 4 */
884 sp_offset -= SCORE_INSTLEN;
888 else if (G_FLD (inst->v, 29, 17) == 0x100
889 && G_FLD (inst->v, 0, 0) == 0x0)
891 /* addi r0, -offset */
892 sp_offset += 65536 - G_FLD (inst->v, 16, 1);
894 else if (G_FLD (inst->v, 29, 17) == 0x110
895 && G_FLD (inst->v, 0, 0) == 0x0)
897 /* addi r2, offset */
900 unsigned int save_v = inst->v;
902 score_fetch_inst (gdbarch, cur_pc + SCORE_INSTLEN, NULL);
903 if (inst2->v == 0x23)
906 sp_offset -= G_FLD (save_v, 16, 1);
914 if (ra_offset_p == 1)
916 if (this_cache->saved_regs[SCORE_PC_REGNUM].addr == -1)
917 this_cache->saved_regs[SCORE_PC_REGNUM].addr =
918 sp + sp_offset - ra_offset;
922 this_cache->saved_regs[SCORE_PC_REGNUM] =
923 this_cache->saved_regs[SCORE_RA_REGNUM];
927 if (fp_offset_p == 1)
929 if (this_cache->saved_regs[SCORE_FP_REGNUM].addr == -1)
930 this_cache->saved_regs[SCORE_FP_REGNUM].addr =
931 sp + sp_offset - fp_offset;
934 /* Save SP and FP. */
935 this_cache->base = sp + sp_offset;
938 /* Don't forget to free MEMBLOCK if we allocated it. */
939 if (memblock_ptr != NULL)
940 score_free_memblock (memblock_ptr);
943 static struct score_frame_cache *
944 score_make_prologue_cache (struct frame_info *this_frame, void **this_cache)
946 struct score_frame_cache *cache;
948 if ((*this_cache) != NULL)
949 return (*this_cache);
951 cache = FRAME_OBSTACK_ZALLOC (struct score_frame_cache);
952 (*this_cache) = cache;
953 cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
955 /* Analyze the prologue. */
957 const CORE_ADDR pc = get_frame_pc (this_frame);
958 CORE_ADDR start_addr;
960 find_pc_partial_function (pc, NULL, &start_addr, NULL);
963 score_analyze_prologue (start_addr, pc, this_frame, *this_cache);
967 trad_frame_set_value (cache->saved_regs, SCORE_SP_REGNUM, cache->base);
969 return (*this_cache);
973 score_prologue_this_id (struct frame_info *this_frame, void **this_cache,
974 struct frame_id *this_id)
976 struct score_frame_cache *info = score_make_prologue_cache (this_frame,
978 (*this_id) = frame_id_build (info->base, get_frame_func (this_frame));
981 static struct value *
982 score_prologue_prev_register (struct frame_info *this_frame,
983 void **this_cache, int regnum)
985 struct score_frame_cache *info = score_make_prologue_cache (this_frame,
987 return trad_frame_get_prev_register (this_frame, info->saved_regs, regnum);
990 static const struct frame_unwind score_prologue_unwind =
993 score_prologue_this_id,
994 score_prologue_prev_register,
996 default_frame_sniffer
1000 score_prologue_frame_base_address (struct frame_info *this_frame,
1003 struct score_frame_cache *info =
1004 score_make_prologue_cache (this_frame, this_cache);
1008 static const struct frame_base score_prologue_frame_base =
1010 &score_prologue_unwind,
1011 score_prologue_frame_base_address,
1012 score_prologue_frame_base_address,
1013 score_prologue_frame_base_address,
1016 static const struct frame_base *
1017 score_prologue_frame_base_sniffer (struct frame_info *this_frame)
1019 return &score_prologue_frame_base;
1022 static struct gdbarch *
1023 score_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1025 struct gdbarch *gdbarch;
1027 arches = gdbarch_list_lookup_by_info (arches, &info);
1030 return (arches->gdbarch);
1032 gdbarch = gdbarch_alloc (&info, 0);
1034 set_gdbarch_short_bit (gdbarch, 16);
1035 set_gdbarch_int_bit (gdbarch, 32);
1036 set_gdbarch_float_bit (gdbarch, 32);
1037 set_gdbarch_double_bit (gdbarch, 64);
1038 set_gdbarch_long_double_bit (gdbarch, 64);
1039 set_gdbarch_register_sim_regno (gdbarch, score_register_sim_regno);
1040 set_gdbarch_pc_regnum (gdbarch, SCORE_PC_REGNUM);
1041 set_gdbarch_sp_regnum (gdbarch, SCORE_SP_REGNUM);
1042 set_gdbarch_num_regs (gdbarch, SCORE_NUM_REGS);
1043 set_gdbarch_register_name (gdbarch, score_register_name);
1044 set_gdbarch_breakpoint_from_pc (gdbarch, score_breakpoint_from_pc);
1045 set_gdbarch_register_type (gdbarch, score_register_type);
1046 set_gdbarch_frame_align (gdbarch, score_frame_align);
1047 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1048 set_gdbarch_unwind_pc (gdbarch, score_unwind_pc);
1049 set_gdbarch_unwind_sp (gdbarch, score_unwind_sp);
1050 set_gdbarch_print_insn (gdbarch, score_print_insn);
1051 set_gdbarch_skip_prologue (gdbarch, score_skip_prologue);
1052 set_gdbarch_in_function_epilogue_p (gdbarch, score_in_function_epilogue_p);
1054 /* Watchpoint hooks. */
1055 set_gdbarch_have_nonsteppable_watchpoint (gdbarch, 1);
1057 /* Dummy frame hooks. */
1058 set_gdbarch_return_value (gdbarch, score_return_value);
1059 set_gdbarch_call_dummy_location (gdbarch, AT_ENTRY_POINT);
1060 set_gdbarch_dummy_id (gdbarch, score_dummy_id);
1061 set_gdbarch_push_dummy_call (gdbarch, score_push_dummy_call);
1063 /* Normal frame hooks. */
1064 dwarf2_append_unwinders (gdbarch);
1065 frame_base_append_sniffer (gdbarch, dwarf2_frame_base_sniffer);
1066 frame_unwind_append_unwinder (gdbarch, &score_prologue_unwind);
1067 frame_base_append_sniffer (gdbarch, score_prologue_frame_base_sniffer);
1072 extern initialize_file_ftype _initialize_score_tdep;
1075 _initialize_score_tdep (void)
1077 gdbarch_register (bfd_arch_score, score_gdbarch_init, NULL);