1 /* Target-dependent code for the S+core architecture, for GDB,
4 Copyright (C) 2006, 2007 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 2 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, write to the Free Software
23 Foundation, Inc., 51 Franklin Street, Fifth Floor,
24 Boston, MA 02110-1301, USA. */
27 #include "gdb_assert.h"
33 #include "arch-utils.h"
36 #include "frame-unwind.h"
37 #include "frame-base.h"
38 #include "trad-frame.h"
39 #include "dwarf2-frame.h"
40 #include "score-tdep.h"
42 #define G_FLD(_i,_ms,_ls) (((_i) << (31 - (_ms))) >> (31 - (_ms) + (_ls)))
43 #define RM_PBITS(_raw) ((G_FLD(_raw, 31, 16) << 15) | G_FLD(_raw, 14, 0))
51 struct score_frame_cache
55 struct trad_frame_saved_reg
*saved_regs
;
59 /* If S+core GCC will generate these instructions in the prologue:
65 then .pdr section is used. */
76 typedef struct frame_extra_info
79 unsigned int pdr
[P_SIZE
];
91 score_compare_pdr_entries (const void *a
, const void *b
)
93 CORE_ADDR lhs
= bfd_get_32 (the_bfd
, (bfd_byte
*) a
);
94 CORE_ADDR rhs
= bfd_get_32 (the_bfd
, (bfd_byte
*) b
);
104 score_analyze_pdr_section (CORE_ADDR startaddr
, CORE_ADDR pc
,
105 struct frame_info
*next_frame
,
106 struct score_frame_cache
*this_cache
)
109 struct obj_section
*sec
;
110 extra_info_t
*fci_ext
;
111 CORE_ADDR leaf_ra_stack_addr
= -1;
113 gdb_assert (startaddr
<= pc
);
114 gdb_assert (this_cache
!= NULL
);
116 fci_ext
= frame_obstack_zalloc (sizeof (extra_info_t
));
117 if ((sec
= find_pc_section (pc
)) == NULL
)
119 error ("Error: Can't find section in file:%s, line:%d!",
124 /* Anylyze .pdr section and get coresponding fields. */
126 static struct obj_priv
*priv
= NULL
;
131 priv
= obstack_alloc (&sec
->objfile
->objfile_obstack
,
132 sizeof (struct obj_priv
));
133 if ((bfdsec
= bfd_get_section_by_name (sec
->objfile
->obfd
, ".pdr")))
135 priv
->size
= bfd_section_size (sec
->objfile
->obfd
, bfdsec
);
136 priv
->contents
= obstack_alloc (&sec
->objfile
->objfile_obstack
,
138 bfd_get_section_contents (sec
->objfile
->obfd
, bfdsec
,
139 priv
->contents
, 0, priv
->size
);
140 the_bfd
= sec
->objfile
->obfd
;
141 qsort (priv
->contents
, priv
->size
/ 32, 32,
142 score_compare_pdr_entries
);
150 int low
= 0, mid
, high
= priv
->size
/ 32;
155 mid
= (low
+ high
) / 2;
156 ptr
= priv
->contents
+ mid
* 32;
157 pdr_pc
= bfd_get_signed_32 (sec
->objfile
->obfd
, ptr
);
158 pdr_pc
+= ANOFFSET (sec
->objfile
->section_offsets
,
159 SECT_OFF_TEXT (sec
->objfile
));
160 if (pdr_pc
== startaddr
)
162 if (pdr_pc
> startaddr
)
171 gdb_assert (bfd_get_32 (sec
->objfile
->obfd
, ptr
) == startaddr
);
172 #define EXT_PDR(_pi) bfd_get_32(sec->objfile->obfd, ptr+((_pi)<<2))
173 fci_ext
->pdr
[PI_SYM
] = EXT_PDR (PI_SYM
);
174 fci_ext
->pdr
[PI_R_MSK
] = EXT_PDR (PI_R_MSK
);
175 fci_ext
->pdr
[PI_R_OFF
] = EXT_PDR (PI_R_OFF
);
176 fci_ext
->pdr
[PI_R_LEF
] = EXT_PDR (PI_R_LEF
);
177 fci_ext
->pdr
[PI_F_OFF
] = EXT_PDR (PI_F_OFF
);
178 fci_ext
->pdr
[PI_F_REG
] = EXT_PDR (PI_F_REG
);
179 fci_ext
->pdr
[PI_RAREG
] = EXT_PDR (PI_RAREG
);
188 /* Open these functions if build with simulator. */
191 score_target_can_use_watch (int type
, int cnt
, int othertype
)
193 if (strcmp (current_target
.to_shortname
, "sim") == 0)
195 return soc_gh_can_use_watch (type
, cnt
);
199 return (*current_target
.to_can_use_hw_breakpoint
) (type
, cnt
, othertype
);
204 score_stopped_by_watch (void)
206 if (strcmp (current_target
.to_shortname
, "sim") == 0)
208 return soc_gh_stopped_by_watch ();
212 return (*current_target
.to_stopped_by_watchpoint
) ();
217 score_target_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
219 if (strcmp (current_target
.to_shortname
, "sim") == 0)
221 return soc_gh_add_watch (addr
, len
, type
);
225 return (*current_target
.to_insert_watchpoint
) (addr
, len
, type
);
230 score_target_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
232 if (strcmp (current_target
.to_shortname
, "sim") == 0)
234 return soc_gh_del_watch (addr
, len
, type
);
238 return (*current_target
.to_remove_watchpoint
) (addr
, len
, type
);
243 score_target_insert_hw_breakpoint (struct bp_target_info
* bp_tgt
)
245 if (strcmp (current_target
.to_shortname
, "sim") == 0)
247 return soc_gh_add_hardbp (bp_tgt
->placed_address
);
251 return (*current_target
.to_insert_hw_breakpoint
) (bp_tgt
);
256 score_target_remove_hw_breakpoint (struct bp_target_info
* bp_tgt
)
258 if (strcmp (current_target
.to_shortname
, "sim") == 0)
260 return soc_gh_del_hardbp (bp_tgt
->placed_address
);
264 return (*current_target
.to_remove_hw_breakpoint
) (bp_tgt
);
270 score_register_type (struct gdbarch
*gdbarch
, int regnum
)
272 gdb_assert (regnum
>= 0 && regnum
< SCORE_NUM_REGS
);
273 return builtin_type_uint32
;
277 score_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
279 return frame_unwind_register_unsigned (next_frame
, SCORE_PC_REGNUM
);
283 score_unwind_sp (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
285 return frame_unwind_register_unsigned (next_frame
, SCORE_SP_REGNUM
);
289 score_register_name (int regnum
)
291 const char *score_register_names
[] = {
292 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
293 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
294 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
295 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
297 "PSR", "COND", "ECR", "EXCPVEC",
298 "CCR", "EPC", "EMA", "TLBLOCK",
299 "TLBPT", "PEADDR", "TLBRPT", "PEVN",
300 "PECTX", "LIMPFN", "LDMPFN", "PREV",
301 "DREG", "PC", "DSAVE", "COUNTER",
302 "LDCR", "STCR", "CEH", "CEL",
305 gdb_assert (regnum
>= 0 && regnum
< SCORE_NUM_REGS
);
306 return score_register_names
[regnum
];
310 score_register_sim_regno (int regnum
)
312 gdb_assert (regnum
>= 0 && regnum
< SCORE_NUM_REGS
);
317 score_print_insn (bfd_vma memaddr
, struct disassemble_info
*info
)
319 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
320 return print_insn_big_score (memaddr
, info
);
322 return print_insn_little_score (memaddr
, info
);
325 static const gdb_byte
*
326 score_breakpoint_from_pc (CORE_ADDR
*pcptr
, int *lenptr
)
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
);
339 if (TARGET_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
*type
,
419 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
, TARGET_BYTE_ORDER
,
438 readbuf
, writebuf
, offset
);
440 return RETURN_VALUE_REGISTER_CONVENTION
;
444 static struct frame_id
445 score_unwind_dummy_id (struct gdbarch
*gdbarch
,
446 struct frame_info
*next_frame
)
448 return frame_id_build (
449 frame_unwind_register_unsigned (next_frame
, SCORE_SP_REGNUM
),
450 frame_pc_unwind (next_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
)
483 CORE_ADDR stack_offset
= 0;
486 /* Step 1, Save RA. */
487 regcache_cooked_write_unsigned (regcache
, SCORE_RA_REGNUM
, bp_addr
);
489 /* Step 2, Make space on the stack for the args. */
490 struct_addr
= align_down (struct_addr
, 16);
491 sp
= align_down (sp
, 16);
492 for (argnum
= 0; argnum
< nargs
; argnum
++)
493 arglen
+= align_up (TYPE_LENGTH (value_type (args
[argnum
])),
495 sp
-= align_up (arglen
, 16);
497 argreg
= SCORE_BEGIN_ARG_REGNUM
;
499 /* Step 3, Check if struct return then save the struct address to
500 r4 and increase the stack_offset by 4. */
503 regcache_cooked_write_unsigned (regcache
, argreg
++, struct_addr
);
504 stack_offset
+= SCORE_REGSIZE
;
507 /* Step 4, Load arguments:
508 If arg length is too long (> 4 bytes), then split the arg and
510 for (argnum
= 0; argnum
< nargs
; argnum
++)
512 struct value
*arg
= args
[argnum
];
513 struct type
*arg_type
= check_typedef (value_type (arg
));
514 enum type_code typecode
= TYPE_CODE (arg_type
);
515 const gdb_byte
*val
= value_contents (arg
);
516 int downward_offset
= 0;
517 int odd_sized_struct_p
;
518 int arg_last_part_p
= 0;
520 arglen
= TYPE_LENGTH (arg_type
);
521 odd_sized_struct_p
= (arglen
> SCORE_REGSIZE
522 && arglen
% SCORE_REGSIZE
!= 0);
524 /* If a arg should be aligned to 8 bytes (long long or double),
525 the value should be put to even register numbers. */
526 if (score_type_needs_double_align (arg_type
))
532 /* If sizeof a block < SCORE_REGSIZE, then Score GCC will chose
533 the default "downward"/"upward" method:
539 char a; char b; char c;
540 } s = {'a', 'b', 'c'};
542 Big endian: s = {X, 'a', 'b', 'c'}
543 Little endian: s = {'a', 'b', 'c', X}
545 Where X is a hole. */
547 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
548 && (typecode
== TYPE_CODE_STRUCT
549 || typecode
== TYPE_CODE_UNION
)
550 && argreg
> SCORE_LAST_ARG_REGNUM
551 && arglen
< SCORE_REGSIZE
)
552 downward_offset
+= (SCORE_REGSIZE
- arglen
);
556 int partial_len
= arglen
< SCORE_REGSIZE
? arglen
: SCORE_REGSIZE
;
557 ULONGEST regval
= extract_unsigned_integer (val
, partial_len
);
559 /* The last part of a arg should shift left when
560 TARGET_BYTE_ORDER is BFD_ENDIAN_BIG. */
561 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
562 && arg_last_part_p
== 1
563 && (typecode
== TYPE_CODE_STRUCT
564 || typecode
== TYPE_CODE_UNION
))
565 regval
<<= ((SCORE_REGSIZE
- partial_len
) * TARGET_CHAR_BIT
);
567 /* Always increase the stack_offset and save args to stack. */
568 addr
= sp
+ stack_offset
+ downward_offset
;
569 write_memory (addr
, val
, partial_len
);
571 if (argreg
<= SCORE_LAST_ARG_REGNUM
)
573 regcache_cooked_write_unsigned (regcache
, argreg
++, regval
);
574 if (arglen
> SCORE_REGSIZE
&& arglen
< SCORE_REGSIZE
* 2)
579 arglen
-= partial_len
;
580 stack_offset
+= align_up (partial_len
, SCORE_REGSIZE
);
584 /* Step 5, Save SP. */
585 regcache_cooked_write_unsigned (regcache
, SCORE_SP_REGNUM
, sp
);
591 score_malloc_and_get_memblock (CORE_ADDR addr
, CORE_ADDR size
)
594 char *memblock
= NULL
;
598 error ("Error: malloc size < 0 in file:%s, line:%d!",
605 memblock
= (char *) xmalloc (size
);
606 memset (memblock
, 0, size
);
607 ret
= target_read_memory (addr
& ~0x3, memblock
, size
);
610 error ("Error: target_read_memory in file:%s, line:%d!",
618 score_free_memblock (char *memblock
)
624 score_adjust_memblock_ptr (char **memblock
, CORE_ADDR prev_pc
,
629 /* First time call this function, do nothing. */
631 else if (cur_pc
- prev_pc
== 2 && (cur_pc
& 0x3) == 0)
633 /* First 16-bit instruction, then 32-bit instruction. */
634 *memblock
+= SCORE_INSTLEN
;
636 else if (cur_pc
- prev_pc
== 4)
638 /* Is 32-bit instruction, increase MEMBLOCK by 4. */
639 *memblock
+= SCORE_INSTLEN
;
644 score_fetch_inst (CORE_ADDR addr
, char *memblock
)
646 static inst_t inst
= { 0, 0 };
647 char buf
[SCORE_INSTLEN
] = { 0 };
651 if (target_has_execution
&& memblock
!= NULL
)
653 /* Fetch instruction from local MEMBLOCK. */
654 memcpy (buf
, memblock
, SCORE_INSTLEN
);
658 /* Fetch instruction from target. */
659 ret
= target_read_memory (addr
& ~0x3, buf
, SCORE_INSTLEN
);
662 error ("Error: target_read_memory in file:%s, line:%d!",
668 inst
.raw
= extract_unsigned_integer (buf
, SCORE_INSTLEN
);
669 inst
.is15
= !(inst
.raw
& 0x80008000);
670 inst
.v
= RM_PBITS (inst
.raw
);
671 big
= (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
);
674 if (big
^ ((addr
& 0x2) == 2))
675 inst
.v
= G_FLD (inst
.v
, 29, 15);
677 inst
.v
= G_FLD (inst
.v
, 14, 0);
683 score_skip_prologue (CORE_ADDR pc
)
686 int iscan
= 32, stack_sub
= 0;
689 inst_t
*inst
= score_fetch_inst (cpc
, NULL
);
692 if (!inst
->is15
&& !stack_sub
693 && (G_FLD (inst
->v
, 29, 25) == 0x1
694 && G_FLD (inst
->v
, 24, 20) == 0x0))
696 /* addi r0, offset */
697 pc
= stack_sub
= cpc
+ SCORE_INSTLEN
;
700 && inst
->v
== RM_PBITS (0x8040bc56))
703 pc
= cpc
+ SCORE_INSTLEN
;
707 && inst
->v
== RM_PBITS (0x0203))
710 pc
= cpc
+ SCORE16_INSTLEN
;
714 && ((G_FLD (inst
->v
, 14, 12) == 3) /* j15 form */
715 || (G_FLD (inst
->v
, 14, 12) == 4) /* b15 form */
716 || (G_FLD (inst
->v
, 14, 12) == 0x0
717 && G_FLD (inst
->v
, 3, 0) == 0x4))) /* br! */
720 && ((G_FLD (inst
->v
, 29, 25) == 2) /* j32 form */
721 || (G_FLD (inst
->v
, 29, 25) == 4) /* b32 form */
722 || (G_FLD (inst
->v
, 29, 25) == 0x0
723 && G_FLD (inst
->v
, 6, 1) == 0x4))) /* br */
726 cpc
+= inst
->is15
? SCORE16_INSTLEN
: SCORE_INSTLEN
;
732 score_in_function_epilogue_p (struct gdbarch
*gdbarch
, CORE_ADDR cur_pc
)
734 inst_t
*inst
= score_fetch_inst (cur_pc
, NULL
);
737 return 1; /* mv! r0, r2 */
738 else if (G_FLD (inst
->v
, 14, 12) == 0x2
739 && G_FLD (inst
->v
, 3, 0) == 0xa)
741 else if (G_FLD (inst
->v
, 14, 12) == 0x0
742 && G_FLD (inst
->v
, 7, 0) == 0x34)
743 return 1; /* br! r3 */
744 else if (G_FLD (inst
->v
, 29, 15) == 0x2
745 && G_FLD (inst
->v
, 6, 1) == 0x2b)
746 return 1; /* mv r0, r2 */
747 else if (G_FLD (inst
->v
, 29, 25) == 0x0
748 && G_FLD (inst
->v
, 6, 1) == 0x4
749 && G_FLD (inst
->v
, 19, 15) == 0x3)
750 return 1; /* br r3 */
756 score_analyze_prologue (CORE_ADDR startaddr
, CORE_ADDR pc
,
757 struct frame_info
*next_frame
,
758 struct score_frame_cache
*this_cache
)
762 CORE_ADDR cur_pc
= startaddr
;
771 char *memblock
= NULL
;
772 char *memblock_ptr
= NULL
;
773 CORE_ADDR prev_pc
= -1;
775 /* Allocate MEMBLOCK if PC - STARTADDR > 0. */
776 memblock_ptr
= memblock
=
777 score_malloc_and_get_memblock (startaddr
, pc
- startaddr
);
779 sp
= frame_unwind_register_unsigned (next_frame
, SCORE_SP_REGNUM
);
780 fp
= frame_unwind_register_unsigned (next_frame
, SCORE_FP_REGNUM
);
782 for (; cur_pc
< pc
; prev_pc
= cur_pc
, cur_pc
+= inst_len
)
785 if (memblock
!= NULL
)
787 /* Reading memory block from target succefully and got all
788 the instructions(from STARTADDR to PC) needed. */
789 score_adjust_memblock_ptr (&memblock
, prev_pc
, cur_pc
);
790 inst
= score_fetch_inst (cur_pc
, memblock
);
794 /* Otherwise, we fetch 4 bytes from target, and GDB also
796 inst
= score_fetch_inst (cur_pc
, NULL
);
801 inst_len
= SCORE16_INSTLEN
;
803 if (G_FLD (inst
->v
, 14, 12) == 0x2
804 && G_FLD (inst
->v
, 3, 0) == 0xe)
809 if (G_FLD (inst
->v
, 11, 7) == 0x6
813 ra_offset
= sp_offset
;
816 else if (G_FLD (inst
->v
, 11, 7) == 0x4
820 fp_offset
= sp_offset
;
824 else if (G_FLD (inst
->v
, 14, 12) == 0x2
825 && G_FLD (inst
->v
, 3, 0) == 0xa)
830 else if (G_FLD (inst
->v
, 14, 7) == 0xc1
831 && G_FLD (inst
->v
, 2, 0) == 0x0)
834 sp_offset
+= (int) pow (2, G_FLD (inst
->v
, 6, 3));
836 else if (G_FLD (inst
->v
, 14, 7) == 0xc0
837 && G_FLD (inst
->v
, 2, 0) == 0x0)
840 sp_offset
-= (int) pow (2, G_FLD (inst
->v
, 6, 3));
845 inst_len
= SCORE_INSTLEN
;
847 if (G_FLD (inst
->v
, 29, 15) == 0xc60
848 && G_FLD (inst
->v
, 2, 0) == 0x4)
850 /* sw r3, [r0, offset]+ */
851 sp_offset
+= SCORE_INSTLEN
;
852 if (ra_offset_p
== 0)
854 ra_offset
= sp_offset
;
858 if (G_FLD (inst
->v
, 29, 15) == 0xc40
859 && G_FLD (inst
->v
, 2, 0) == 0x4)
861 /* sw r2, [r0, offset]+ */
862 sp_offset
+= SCORE_INSTLEN
;
863 if (fp_offset_p
== 0)
865 fp_offset
= sp_offset
;
869 else if (G_FLD (inst
->v
, 29, 15) == 0x1c60
870 && G_FLD (inst
->v
, 2, 0) == 0x0)
872 /* lw r3, [r0]+, 4 */
873 sp_offset
-= SCORE_INSTLEN
;
876 else if (G_FLD (inst
->v
, 29, 15) == 0x1c40
877 && G_FLD (inst
->v
, 2, 0) == 0x0)
879 /* lw r2, [r0]+, 4 */
880 sp_offset
-= SCORE_INSTLEN
;
884 else if (G_FLD (inst
->v
, 29, 17) == 0x100
885 && G_FLD (inst
->v
, 0, 0) == 0x0)
887 /* addi r0, -offset */
888 sp_offset
+= 65536 - G_FLD (inst
->v
, 16, 1);
890 else if (G_FLD (inst
->v
, 29, 17) == 0x110
891 && G_FLD (inst
->v
, 0, 0) == 0x0)
893 /* addi r2, offset */
896 unsigned int save_v
= inst
->v
;
898 score_fetch_inst (cur_pc
+ SCORE_INSTLEN
, NULL
);
899 if (inst2
->v
== 0x23)
902 sp_offset
-= G_FLD (save_v
, 16, 1);
910 if (ra_offset_p
== 1)
912 if (this_cache
->saved_regs
[SCORE_PC_REGNUM
].addr
== -1)
913 this_cache
->saved_regs
[SCORE_PC_REGNUM
].addr
=
914 sp
+ sp_offset
- ra_offset
;
918 this_cache
->saved_regs
[SCORE_PC_REGNUM
] =
919 this_cache
->saved_regs
[SCORE_RA_REGNUM
];
923 if (fp_offset_p
== 1)
925 if (this_cache
->saved_regs
[SCORE_FP_REGNUM
].addr
== -1)
926 this_cache
->saved_regs
[SCORE_FP_REGNUM
].addr
=
927 sp
+ sp_offset
- fp_offset
;
930 /* Save SP and FP. */
931 this_cache
->base
= sp
+ sp_offset
;
934 /* Don't forget to free MEMBLOCK if we allocated it. */
935 if (memblock_ptr
!= NULL
)
936 score_free_memblock (memblock_ptr
);
939 static struct score_frame_cache
*
940 score_make_prologue_cache (struct frame_info
*next_frame
, void **this_cache
)
942 struct score_frame_cache
*cache
;
944 if ((*this_cache
) != NULL
)
945 return (*this_cache
);
947 cache
= FRAME_OBSTACK_ZALLOC (struct score_frame_cache
);
948 (*this_cache
) = cache
;
949 cache
->saved_regs
= trad_frame_alloc_saved_regs (next_frame
);
951 /* Analyze the prologue. */
953 const CORE_ADDR pc
= frame_pc_unwind (next_frame
);
954 CORE_ADDR start_addr
;
956 find_pc_partial_function (pc
, NULL
, &start_addr
, NULL
);
959 score_analyze_prologue (start_addr
, pc
, next_frame
, *this_cache
);
963 trad_frame_set_value (cache
->saved_regs
, SCORE_SP_REGNUM
, cache
->base
);
965 return (*this_cache
);
969 score_prologue_this_id (struct frame_info
*next_frame
, void **this_cache
,
970 struct frame_id
*this_id
)
972 struct score_frame_cache
*info
= score_make_prologue_cache (next_frame
,
974 (*this_id
) = frame_id_build (info
->base
,
975 frame_func_unwind (next_frame
, NORMAL_FRAME
));
979 score_prologue_prev_register (struct frame_info
*next_frame
,
981 int regnum
, int *optimizedp
,
982 enum lval_type
*lvalp
, CORE_ADDR
* addrp
,
983 int *realnump
, gdb_byte
* valuep
)
985 struct score_frame_cache
*info
= score_make_prologue_cache (next_frame
,
987 trad_frame_get_prev_register (next_frame
, info
->saved_regs
, regnum
,
988 optimizedp
, lvalp
, addrp
, realnump
, valuep
);
991 static const struct frame_unwind score_prologue_unwind
=
994 score_prologue_this_id
,
995 score_prologue_prev_register
998 static const struct frame_unwind
*
999 score_prologue_sniffer (struct frame_info
*next_frame
)
1001 return &score_prologue_unwind
;
1005 score_prologue_frame_base_address (struct frame_info
*next_frame
,
1008 struct score_frame_cache
*info
=
1009 score_make_prologue_cache (next_frame
, this_cache
);
1013 static const struct frame_base score_prologue_frame_base
=
1015 &score_prologue_unwind
,
1016 score_prologue_frame_base_address
,
1017 score_prologue_frame_base_address
,
1018 score_prologue_frame_base_address
,
1021 static const struct frame_base
*
1022 score_prologue_frame_base_sniffer (struct frame_info
*next_frame
)
1024 return &score_prologue_frame_base
;
1027 static struct gdbarch
*
1028 score_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1030 struct gdbarch
*gdbarch
;
1032 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1035 return (arches
->gdbarch
);
1037 gdbarch
= gdbarch_alloc (&info
, 0);
1039 set_gdbarch_short_bit (gdbarch
, 16);
1040 set_gdbarch_int_bit (gdbarch
, 32);
1041 set_gdbarch_float_bit (gdbarch
, 32);
1042 set_gdbarch_double_bit (gdbarch
, 64);
1043 set_gdbarch_long_double_bit (gdbarch
, 64);
1044 set_gdbarch_register_sim_regno (gdbarch
, score_register_sim_regno
);
1045 set_gdbarch_pc_regnum (gdbarch
, SCORE_PC_REGNUM
);
1046 set_gdbarch_sp_regnum (gdbarch
, SCORE_SP_REGNUM
);
1047 set_gdbarch_num_regs (gdbarch
, SCORE_NUM_REGS
);
1048 set_gdbarch_register_name (gdbarch
, score_register_name
);
1049 set_gdbarch_breakpoint_from_pc (gdbarch
, score_breakpoint_from_pc
);
1050 set_gdbarch_register_type (gdbarch
, score_register_type
);
1051 set_gdbarch_frame_align (gdbarch
, score_frame_align
);
1052 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1053 set_gdbarch_unwind_pc (gdbarch
, score_unwind_pc
);
1054 set_gdbarch_unwind_sp (gdbarch
, score_unwind_sp
);
1055 set_gdbarch_print_insn (gdbarch
, score_print_insn
);
1056 set_gdbarch_skip_prologue (gdbarch
, score_skip_prologue
);
1057 set_gdbarch_in_function_epilogue_p (gdbarch
, score_in_function_epilogue_p
);
1059 /* Watchpoint hooks. */
1060 set_gdbarch_have_nonsteppable_watchpoint (gdbarch
, 1);
1062 /* Dummy frame hooks. */
1063 set_gdbarch_return_value (gdbarch
, score_return_value
);
1064 set_gdbarch_call_dummy_location (gdbarch
, AT_ENTRY_POINT
);
1065 set_gdbarch_unwind_dummy_id (gdbarch
, score_unwind_dummy_id
);
1066 set_gdbarch_push_dummy_call (gdbarch
, score_push_dummy_call
);
1068 /* Normal frame hooks. */
1069 frame_unwind_append_sniffer (gdbarch
, dwarf2_frame_sniffer
);
1070 frame_base_append_sniffer (gdbarch
, dwarf2_frame_base_sniffer
);
1071 frame_unwind_append_sniffer (gdbarch
, score_prologue_sniffer
);
1072 frame_base_append_sniffer (gdbarch
, score_prologue_frame_base_sniffer
);
1077 extern initialize_file_ftype _initialize_score_tdep
;
1080 _initialize_score_tdep (void)
1082 gdbarch_register (bfd_arch_score
, score_gdbarch_init
, NULL
);