1 /* Target-dependent code for the S+core architecture, for GDB,
4 Copyright (C) 2006-2017 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/>. */
30 #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) \
41 ((unsigned)((_i) << (31 - (_ms))) >> (31 - (_ms) + (_ls)))
45 unsigned long long raw;
49 struct score_frame_cache
53 struct trad_frame_saved_reg *saved_regs;
56 static int target_mach = bfd_mach_score7;
59 score_register_type (struct gdbarch *gdbarch, int regnum)
61 gdb_assert (regnum >= 0
62 && regnum < ((target_mach == bfd_mach_score7)
63 ? SCORE7_NUM_REGS : SCORE3_NUM_REGS));
64 return builtin_type (gdbarch)->builtin_uint32;
68 score_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
70 return frame_unwind_register_unsigned (next_frame, SCORE_SP_REGNUM);
74 score_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
76 return frame_unwind_register_unsigned (next_frame, SCORE_PC_REGNUM);
80 score7_register_name (struct gdbarch *gdbarch, int regnum)
82 const char *score_register_names[] = {
83 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
84 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
85 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
86 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
88 "PSR", "COND", "ECR", "EXCPVEC", "CCR",
89 "EPC", "EMA", "TLBLOCK", "TLBPT", "PEADDR",
90 "TLBRPT", "PEVN", "PECTX", "LIMPFN", "LDMPFN",
91 "PREV", "DREG", "PC", "DSAVE", "COUNTER",
92 "LDCR", "STCR", "CEH", "CEL",
95 gdb_assert (regnum >= 0 && regnum < SCORE7_NUM_REGS);
96 return score_register_names[regnum];
100 score3_register_name (struct gdbarch *gdbarch, int regnum)
102 const char *score_register_names[] = {
103 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
104 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
105 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
106 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
108 "PSR", "COND", "ECR", "EXCPVEC", "CCR",
109 "EPC", "EMA", "PREV", "DREG", "DSAVE",
110 "COUNTER", "LDCR", "STCR", "CEH", "CEL",
114 gdb_assert (regnum >= 0 && regnum < SCORE3_NUM_REGS);
115 return score_register_names[regnum];
120 score_register_sim_regno (struct gdbarch *gdbarch, int regnum)
122 gdb_assert (regnum >= 0
123 && regnum < ((target_mach == bfd_mach_score7)
124 ? SCORE7_NUM_REGS : SCORE3_NUM_REGS));
130 score_print_insn (bfd_vma memaddr, struct disassemble_info *info)
132 if (info->endian == BFD_ENDIAN_BIG)
133 return print_insn_big_score (memaddr, info);
135 return print_insn_little_score (memaddr, info);
139 score7_fetch_inst (struct gdbarch *gdbarch, CORE_ADDR addr, gdb_byte *memblock)
141 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
142 static inst_t inst = { 0, 0, 0 };
143 gdb_byte buf[SCORE_INSTLEN] = { 0 };
147 if (target_has_execution && memblock != NULL)
149 /* Fetch instruction from local MEMBLOCK. */
150 memcpy (buf, memblock, SCORE_INSTLEN);
154 /* Fetch instruction from target. */
155 ret = target_read_memory (addr & ~0x3, buf, SCORE_INSTLEN);
158 error (_("Error: target_read_memory in file:%s, line:%d!"),
164 inst.raw = extract_unsigned_integer (buf, SCORE_INSTLEN, byte_order);
165 inst.len = (inst.raw & 0x80008000) ? 4 : 2;
166 inst.v = ((inst.raw >> 16 & 0x7FFF) << 15) | (inst.raw & 0x7FFF);
167 big = (byte_order == BFD_ENDIAN_BIG);
170 if (big ^ ((addr & 0x2) == 2))
171 inst.v = G_FLD (inst.v, 29, 15);
173 inst.v = G_FLD (inst.v, 14, 0);
179 score3_adjust_pc_and_fetch_inst (CORE_ADDR *pcptr, int *lenptr,
180 enum bfd_endian byte_order)
182 static inst_t inst = { 0, 0, 0 };
189 /* raw table 1 (column 2, 3, 4)
193 table 2 (column 1, 2, 3)
199 static const struct breakplace bk_table[16] =
221 #define EXTRACT_LEN 2
222 CORE_ADDR adjust_pc = *pcptr & ~0x1;
223 gdb_byte buf[5][EXTRACT_LEN] =
233 unsigned int cbits = 0;
242 for (i = 0; i < 5; i++)
244 ret = target_read_memory (adjust_pc + 2 * i, buf[i], EXTRACT_LEN);
250 error (_("Error: target_read_memory in file:%s, line:%d!"),
254 raw = extract_unsigned_integer (buf[i], EXTRACT_LEN, byte_order);
255 cbits = (cbits << 1) | (raw >> 15);
262 cbits = (cbits >> 1) & 0x7;
268 cbits = (cbits >> 2) & 0x7;
269 bk_index = cbits + 8;
272 gdb_assert (!((bk_table[bk_index].break_offset == 0)
273 && (bk_table[bk_index].inst_len == 0)));
275 inst.len = bk_table[bk_index].inst_len;
277 i = (bk_table[bk_index].break_offset + 4) / 2;
278 count = inst.len / 2;
279 for (; count > 0; i++, count--)
281 inst.raw = (inst.raw << 16)
282 | extract_unsigned_integer (buf[i], EXTRACT_LEN, byte_order);
288 inst.v = inst.raw & 0x7FFF;
291 inst.v = ((inst.raw >> 16 & 0x7FFF) << 15) | (inst.raw & 0x7FFF);
294 inst.v = ((inst.raw >> 32 & 0x7FFF) << 30)
295 | ((inst.raw >> 16 & 0x7FFF) << 15) | (inst.raw & 0x7FFF);
300 *pcptr = adjust_pc + bk_table[bk_index].break_offset;
302 *lenptr = bk_table[bk_index].inst_len;
309 /* Implement the breakpoint_kind_from_pc gdbarch method. */
312 score7_breakpoint_kind_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr)
316 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
317 gdb_byte buf[SCORE_INSTLEN] = { 0 };
319 if ((ret = target_read_memory (*pcptr & ~0x3, buf, SCORE_INSTLEN)) != 0)
321 error (_("Error: target_read_memory in file:%s, line:%d!"),
324 raw = extract_unsigned_integer (buf, SCORE_INSTLEN, byte_order);
326 if (!(raw & 0x80008000))
328 /* 16bits instruction. */
334 /* 32bits instruction. */
340 /* Implement the sw_breakpoint_from_kind gdbarch method. */
342 static const gdb_byte *
343 score7_sw_breakpoint_from_kind (struct gdbarch *gdbarch, int kind, int *size)
345 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
351 static gdb_byte big_breakpoint32[] = { 0x80, 0x00, 0x80, 0x06 };
352 static gdb_byte little_breakpoint32[] = { 0x06, 0x80, 0x00, 0x80 };
354 if (byte_order == BFD_ENDIAN_BIG)
355 return big_breakpoint32;
357 return little_breakpoint32;
361 static gdb_byte big_breakpoint16[] = { 0x60, 0x02 };
362 static gdb_byte little_breakpoint16[] = { 0x02, 0x60 };
364 if (byte_order == BFD_ENDIAN_BIG)
365 return big_breakpoint16;
367 return little_breakpoint16;
371 /* Implement the breakpoint_kind_from_pc gdbarch method. */
374 score3_breakpoint_kind_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr)
376 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
379 score3_adjust_pc_and_fetch_inst (pcptr, &len, byte_order);
384 /* Implement the sw_breakpoint_from_kind gdbarch method. */
386 static const gdb_byte *
387 score3_sw_breakpoint_from_kind (struct gdbarch *gdbarch, int kind, int *size)
390 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
391 static gdb_byte score_break_insns[6][6] = {
392 /* The following three instructions are big endian. */
394 { 0x80, 0x00, 0x00, 0x06 },
395 { 0x80, 0x00, 0x80, 0x00, 0x00, 0x00 },
396 /* The following three instructions are little endian. */
398 { 0x00, 0x80, 0x06, 0x00 },
399 { 0x00, 0x80, 0x00, 0x80, 0x00, 0x00 }};
403 index = ((byte_order == BFD_ENDIAN_BIG) ? 0 : 3) + (kind / 2 - 1);
404 return score_break_insns[index];
408 score_adjust_breakpoint_address (struct gdbarch *gdbarch, CORE_ADDR bpaddr)
410 CORE_ADDR adjust_pc = bpaddr;
412 if (target_mach == bfd_mach_score3)
413 score3_adjust_pc_and_fetch_inst (&adjust_pc, NULL,
414 gdbarch_byte_order (gdbarch));
416 adjust_pc = align_down (adjust_pc, 2);
422 score_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
424 return align_down (addr, 16);
428 score_xfer_register (struct regcache *regcache, int regnum, int length,
429 enum bfd_endian endian, gdb_byte *readbuf,
430 const gdb_byte *writebuf, int buf_offset)
433 gdb_assert (regnum >= 0
434 && regnum < ((target_mach == bfd_mach_score7)
435 ? SCORE7_NUM_REGS : SCORE3_NUM_REGS));
440 reg_offset = SCORE_REGSIZE - length;
442 case BFD_ENDIAN_LITTLE:
445 case BFD_ENDIAN_UNKNOWN:
449 error (_("Error: score_xfer_register in file:%s, line:%d!"),
454 regcache_cooked_read_part (regcache, regnum, reg_offset, length,
455 readbuf + buf_offset);
456 if (writebuf != NULL)
457 regcache_cooked_write_part (regcache, regnum, reg_offset, length,
458 writebuf + buf_offset);
461 static enum return_value_convention
462 score_return_value (struct gdbarch *gdbarch, struct value *function,
463 struct type *type, struct regcache *regcache,
464 gdb_byte * readbuf, const gdb_byte * writebuf)
466 if (TYPE_CODE (type) == TYPE_CODE_STRUCT
467 || TYPE_CODE (type) == TYPE_CODE_UNION
468 || TYPE_CODE (type) == TYPE_CODE_ARRAY)
469 return RETURN_VALUE_STRUCT_CONVENTION;
474 for (offset = 0, regnum = SCORE_A0_REGNUM;
475 offset < TYPE_LENGTH (type);
476 offset += SCORE_REGSIZE, regnum++)
478 int xfer = SCORE_REGSIZE;
480 if (offset + xfer > TYPE_LENGTH (type))
481 xfer = TYPE_LENGTH (type) - offset;
482 score_xfer_register (regcache, regnum, xfer,
483 gdbarch_byte_order(gdbarch),
484 readbuf, writebuf, offset);
486 return RETURN_VALUE_REGISTER_CONVENTION;
490 static struct frame_id
491 score_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
493 return frame_id_build (get_frame_register_unsigned (this_frame,
495 get_frame_pc (this_frame));
499 score_type_needs_double_align (struct type *type)
501 enum type_code typecode = TYPE_CODE (type);
503 if ((typecode == TYPE_CODE_INT && TYPE_LENGTH (type) == 8)
504 || (typecode == TYPE_CODE_FLT && TYPE_LENGTH (type) == 8))
506 else if (typecode == TYPE_CODE_STRUCT || typecode == TYPE_CODE_UNION)
510 n = TYPE_NFIELDS (type);
511 for (i = 0; i < n; i++)
512 if (score_type_needs_double_align (TYPE_FIELD_TYPE (type, i)))
520 score_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
521 struct regcache *regcache, CORE_ADDR bp_addr,
522 int nargs, struct value **args, CORE_ADDR sp,
523 int struct_return, CORE_ADDR struct_addr)
525 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
529 CORE_ADDR stack_offset = 0;
532 /* Step 1, Save RA. */
533 regcache_cooked_write_unsigned (regcache, SCORE_RA_REGNUM, bp_addr);
535 /* Step 2, Make space on the stack for the args. */
536 struct_addr = align_down (struct_addr, 16);
537 sp = align_down (sp, 16);
538 for (argnum = 0; argnum < nargs; argnum++)
539 arglen += align_up (TYPE_LENGTH (value_type (args[argnum])),
541 sp -= align_up (arglen, 16);
543 argreg = SCORE_BEGIN_ARG_REGNUM;
545 /* Step 3, Check if struct return then save the struct address to
546 r4 and increase the stack_offset by 4. */
549 regcache_cooked_write_unsigned (regcache, argreg++, struct_addr);
550 stack_offset += SCORE_REGSIZE;
553 /* Step 4, Load arguments:
554 If arg length is too long (> 4 bytes), then split the arg and
556 for (argnum = 0; argnum < nargs; argnum++)
558 struct value *arg = args[argnum];
559 struct type *arg_type = check_typedef (value_type (arg));
560 enum type_code typecode = TYPE_CODE (arg_type);
561 const gdb_byte *val = value_contents (arg);
562 int downward_offset = 0;
563 int arg_last_part_p = 0;
565 arglen = TYPE_LENGTH (arg_type);
567 /* If a arg should be aligned to 8 bytes (long long or double),
568 the value should be put to even register numbers. */
569 if (score_type_needs_double_align (arg_type))
575 /* If sizeof a block < SCORE_REGSIZE, then Score GCC will chose
576 the default "downward"/"upward" method:
582 char a; char b; char c;
583 } s = {'a', 'b', 'c'};
585 Big endian: s = {X, 'a', 'b', 'c'}
586 Little endian: s = {'a', 'b', 'c', X}
588 Where X is a hole. */
590 if (gdbarch_byte_order(gdbarch) == BFD_ENDIAN_BIG
591 && (typecode == TYPE_CODE_STRUCT
592 || typecode == TYPE_CODE_UNION)
593 && argreg > SCORE_LAST_ARG_REGNUM
594 && arglen < SCORE_REGSIZE)
595 downward_offset += (SCORE_REGSIZE - arglen);
599 int partial_len = arglen < SCORE_REGSIZE ? arglen : SCORE_REGSIZE;
600 ULONGEST regval = extract_unsigned_integer (val, partial_len,
603 /* The last part of a arg should shift left when
604 gdbarch_byte_order is BFD_ENDIAN_BIG. */
605 if (byte_order == BFD_ENDIAN_BIG
606 && arg_last_part_p == 1
607 && (typecode == TYPE_CODE_STRUCT
608 || typecode == TYPE_CODE_UNION))
609 regval <<= ((SCORE_REGSIZE - partial_len) * TARGET_CHAR_BIT);
611 /* Always increase the stack_offset and save args to stack. */
612 addr = sp + stack_offset + downward_offset;
613 write_memory (addr, val, partial_len);
615 if (argreg <= SCORE_LAST_ARG_REGNUM)
617 regcache_cooked_write_unsigned (regcache, argreg++, regval);
618 if (arglen > SCORE_REGSIZE && arglen < SCORE_REGSIZE * 2)
623 arglen -= partial_len;
624 stack_offset += align_up (partial_len, SCORE_REGSIZE);
628 /* Step 5, Save SP. */
629 regcache_cooked_write_unsigned (regcache, SCORE_SP_REGNUM, sp);
635 score7_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
638 int iscan = 32, stack_sub = 0;
641 inst_t *inst = score7_fetch_inst (gdbarch, cpc, NULL);
644 if ((inst->len == 4) && !stack_sub
645 && (G_FLD (inst->v, 29, 25) == 0x1
646 && G_FLD (inst->v, 24, 20) == 0x0))
648 /* addi r0, offset */
649 stack_sub = cpc + SCORE_INSTLEN;
650 pc = cpc + SCORE_INSTLEN;
652 else if ((inst->len == 4)
653 && (G_FLD (inst->v, 29, 25) == 0x0)
654 && (G_FLD (inst->v, 24, 20) == 0x2)
655 && (G_FLD (inst->v, 19, 15) == 0x0)
656 && (G_FLD (inst->v, 14, 10) == 0xF)
657 && (G_FLD (inst->v, 9, 0) == 0x56))
660 pc = cpc + SCORE_INSTLEN;
663 else if ((inst->len == 2)
664 && (G_FLD (inst->v, 14, 12) == 0x0)
665 && (G_FLD (inst->v, 11, 8) == 0x2)
666 && (G_FLD (inst->v, 7, 4) == 0x0)
667 && (G_FLD (inst->v, 3, 0) == 0x3))
670 pc = cpc + SCORE16_INSTLEN;
673 else if ((inst->len == 2)
674 && ((G_FLD (inst->v, 14, 12) == 3) /* j15 form */
675 || (G_FLD (inst->v, 14, 12) == 4) /* b15 form */
676 || (G_FLD (inst->v, 14, 12) == 0x0
677 && G_FLD (inst->v, 3, 0) == 0x4))) /* br! */
679 else if ((inst->len == 4)
680 && ((G_FLD (inst->v, 29, 25) == 2) /* j32 form */
681 || (G_FLD (inst->v, 29, 25) == 4) /* b32 form */
682 || (G_FLD (inst->v, 29, 25) == 0x0
683 && G_FLD (inst->v, 6, 1) == 0x4))) /* br */
686 cpc += (inst->len == 2) ? SCORE16_INSTLEN : SCORE_INSTLEN;
692 score3_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
695 int iscan = 32, stack_sub = 0;
699 = score3_adjust_pc_and_fetch_inst (&cpc, NULL,
700 gdbarch_byte_order (gdbarch));
704 if (inst->len == 4 && !stack_sub
705 && (G_FLD (inst->v, 29, 25) == 0x1)
706 && (G_FLD (inst->v, 19, 17) == 0x0)
707 && (G_FLD (inst->v, 24, 20) == 0x0))
709 /* addi r0, offset */
710 stack_sub = cpc + inst->len;
711 pc = cpc + inst->len;
713 else if (inst->len == 4
714 && (G_FLD (inst->v, 29, 25) == 0x0)
715 && (G_FLD (inst->v, 24, 20) == 0x2)
716 && (G_FLD (inst->v, 19, 15) == 0x0)
717 && (G_FLD (inst->v, 14, 10) == 0xF)
718 && (G_FLD (inst->v, 9, 0) == 0x56))
721 pc = cpc + inst->len;
724 else if ((inst->len == 2)
725 && (G_FLD (inst->v, 14, 10) == 0x10)
726 && (G_FLD (inst->v, 9, 5) == 0x2)
727 && (G_FLD (inst->v, 4, 0) == 0x0))
730 pc = cpc + inst->len;
733 else if (inst->len == 2
734 && ((G_FLD (inst->v, 14, 12) == 3) /* b15 form */
735 || (G_FLD (inst->v, 14, 12) == 0x0
736 && G_FLD (inst->v, 11, 5) == 0x4))) /* br! */
738 else if (inst->len == 4
739 && ((G_FLD (inst->v, 29, 25) == 2) /* j32 form */
740 || (G_FLD (inst->v, 29, 25) == 4))) /* b32 form */
748 /* Implement the stack_frame_destroyed_p gdbarch method. */
751 score7_stack_frame_destroyed_p (struct gdbarch *gdbarch, CORE_ADDR cur_pc)
753 inst_t *inst = score7_fetch_inst (gdbarch, cur_pc, NULL);
756 return 1; /* mv! r0, r2 */
757 else if (G_FLD (inst->v, 14, 12) == 0x2
758 && G_FLD (inst->v, 3, 0) == 0xa)
760 else if (G_FLD (inst->v, 14, 12) == 0x0
761 && G_FLD (inst->v, 7, 0) == 0x34)
762 return 1; /* br! r3 */
763 else if (G_FLD (inst->v, 29, 15) == 0x2
764 && G_FLD (inst->v, 6, 1) == 0x2b)
765 return 1; /* mv r0, r2 */
766 else if (G_FLD (inst->v, 29, 25) == 0x0
767 && G_FLD (inst->v, 6, 1) == 0x4
768 && G_FLD (inst->v, 19, 15) == 0x3)
769 return 1; /* br r3 */
774 /* Implement the stack_frame_destroyed_p gdbarch method. */
777 score3_stack_frame_destroyed_p (struct gdbarch *gdbarch, CORE_ADDR cur_pc)
779 CORE_ADDR pc = cur_pc;
781 = score3_adjust_pc_and_fetch_inst (&pc, NULL,
782 gdbarch_byte_order (gdbarch));
785 && (G_FLD (inst->v, 14, 10) == 0x10)
786 && (G_FLD (inst->v, 9, 5) == 0x0)
787 && (G_FLD (inst->v, 4, 0) == 0x2))
788 return 1; /* mv! r0, r2 */
789 else if (inst->len == 4
790 && (G_FLD (inst->v, 29, 25) == 0x0)
791 && (G_FLD (inst->v, 24, 20) == 0x2)
792 && (G_FLD (inst->v, 19, 15) == 0x0)
793 && (G_FLD (inst->v, 14, 10) == 0xF)
794 && (G_FLD (inst->v, 9, 0) == 0x56))
795 return 1; /* mv r0, r2 */
796 else if (inst->len == 2
797 && (G_FLD (inst->v, 14, 12) == 0x0)
798 && (G_FLD (inst->v, 11, 5) == 0x2))
800 else if (inst->len == 2
801 && (G_FLD (inst->v, 14, 12) == 0x0)
802 && (G_FLD (inst->v, 11, 7) == 0x0)
803 && (G_FLD (inst->v, 6, 5) == 0x2))
804 return 1; /* rpop! */
805 else if (inst->len == 2
806 && (G_FLD (inst->v, 14, 12) == 0x0)
807 && (G_FLD (inst->v, 11, 5) == 0x4)
808 && (G_FLD (inst->v, 4, 0) == 0x3))
809 return 1; /* br! r3 */
810 else if (inst->len == 4
811 && (G_FLD (inst->v, 29, 25) == 0x0)
812 && (G_FLD (inst->v, 24, 20) == 0x0)
813 && (G_FLD (inst->v, 19, 15) == 0x3)
814 && (G_FLD (inst->v, 14, 10) == 0xF)
815 && (G_FLD (inst->v, 9, 0) == 0x8))
816 return 1; /* br r3 */
822 score7_malloc_and_get_memblock (CORE_ADDR addr, CORE_ADDR size)
825 gdb_byte *memblock = NULL;
830 memblock = (gdb_byte *) xmalloc (size);
831 memset (memblock, 0, size);
832 ret = target_read_memory (addr & ~0x3, memblock, size);
835 error (_("Error: target_read_memory in file:%s, line:%d!"),
843 score7_free_memblock (gdb_byte *memblock)
849 score7_adjust_memblock_ptr (gdb_byte **memblock, CORE_ADDR prev_pc,
854 /* First time call this function, do nothing. */
856 else if (cur_pc - prev_pc == 2 && (cur_pc & 0x3) == 0)
858 /* First 16-bit instruction, then 32-bit instruction. */
859 *memblock += SCORE_INSTLEN;
861 else if (cur_pc - prev_pc == 4)
863 /* Is 32-bit instruction, increase MEMBLOCK by 4. */
864 *memblock += SCORE_INSTLEN;
869 score7_analyze_prologue (CORE_ADDR startaddr, CORE_ADDR pc,
870 struct frame_info *this_frame,
871 struct score_frame_cache *this_cache)
873 struct gdbarch *gdbarch = get_frame_arch (this_frame);
876 CORE_ADDR cur_pc = startaddr;
885 gdb_byte *memblock = NULL;
886 gdb_byte *memblock_ptr = NULL;
887 CORE_ADDR prev_pc = -1;
889 /* Allocate MEMBLOCK if PC - STARTADDR > 0. */
890 memblock_ptr = memblock =
891 score7_malloc_and_get_memblock (startaddr, pc - startaddr);
893 sp = get_frame_register_unsigned (this_frame, SCORE_SP_REGNUM);
894 fp = get_frame_register_unsigned (this_frame, SCORE_FP_REGNUM);
896 for (; cur_pc < pc; prev_pc = cur_pc, cur_pc += inst_len)
899 if (memblock != NULL)
901 /* Reading memory block from target succefully and got all
902 the instructions(from STARTADDR to PC) needed. */
903 score7_adjust_memblock_ptr (&memblock, prev_pc, cur_pc);
904 inst = score7_fetch_inst (gdbarch, cur_pc, memblock);
908 /* Otherwise, we fetch 4 bytes from target, and GDB also
910 inst = score7_fetch_inst (gdbarch, cur_pc, NULL);
913 /* FIXME: make a full-power prologue analyzer. */
916 inst_len = SCORE16_INSTLEN;
918 if (G_FLD (inst->v, 14, 12) == 0x2
919 && G_FLD (inst->v, 3, 0) == 0xe)
924 if (G_FLD (inst->v, 11, 7) == 0x6
928 ra_offset = sp_offset;
931 else if (G_FLD (inst->v, 11, 7) == 0x4
935 fp_offset = sp_offset;
939 else if (G_FLD (inst->v, 14, 12) == 0x2
940 && G_FLD (inst->v, 3, 0) == 0xa)
945 else if (G_FLD (inst->v, 14, 7) == 0xc1
946 && G_FLD (inst->v, 2, 0) == 0x0)
949 sp_offset += (int) pow (2, G_FLD (inst->v, 6, 3));
951 else if (G_FLD (inst->v, 14, 7) == 0xc0
952 && G_FLD (inst->v, 2, 0) == 0x0)
955 sp_offset -= (int) pow (2, G_FLD (inst->v, 6, 3));
960 inst_len = SCORE_INSTLEN;
962 if (G_FLD(inst->v, 29, 25) == 0x3
963 && G_FLD(inst->v, 2, 0) == 0x4
964 && G_FLD(inst->v, 19, 15) == 0)
966 /* sw rD, [r0, offset]+ */
967 sp_offset += SCORE_INSTLEN;
969 if (G_FLD(inst->v, 24, 20) == 0x3)
972 if (ra_offset_p == 0)
974 ra_offset = sp_offset;
978 else if (G_FLD(inst->v, 24, 20) == 0x2)
981 if (fp_offset_p == 0)
983 fp_offset = sp_offset;
988 else if (G_FLD(inst->v, 29, 25) == 0x14
989 && G_FLD(inst->v, 19,15) == 0)
991 /* sw rD, [r0, offset] */
992 if (G_FLD(inst->v, 24, 20) == 0x3)
995 ra_offset = sp_offset - G_FLD(inst->v, 14, 0);
998 else if (G_FLD(inst->v, 24, 20) == 0x2)
1001 fp_offset = sp_offset - G_FLD(inst->v, 14, 0);
1005 else if (G_FLD (inst->v, 29, 15) == 0x1c60
1006 && G_FLD (inst->v, 2, 0) == 0x0)
1008 /* lw r3, [r0]+, 4 */
1009 sp_offset -= SCORE_INSTLEN;
1012 else if (G_FLD (inst->v, 29, 15) == 0x1c40
1013 && G_FLD (inst->v, 2, 0) == 0x0)
1015 /* lw r2, [r0]+, 4 */
1016 sp_offset -= SCORE_INSTLEN;
1020 else if (G_FLD (inst->v, 29, 17) == 0x100
1021 && G_FLD (inst->v, 0, 0) == 0x0)
1023 /* addi r0, -offset */
1024 sp_offset += 65536 - G_FLD (inst->v, 16, 1);
1026 else if (G_FLD (inst->v, 29, 17) == 0x110
1027 && G_FLD (inst->v, 0, 0) == 0x0)
1029 /* addi r2, offset */
1030 if (pc - cur_pc > 4)
1032 unsigned int save_v = inst->v;
1034 score7_fetch_inst (gdbarch, cur_pc + SCORE_INSTLEN, NULL);
1035 if (inst2->v == 0x23)
1038 sp_offset -= G_FLD (save_v, 16, 1);
1046 if (ra_offset_p == 1)
1048 if (this_cache->saved_regs[SCORE_PC_REGNUM].addr == -1)
1049 this_cache->saved_regs[SCORE_PC_REGNUM].addr =
1050 sp + sp_offset - ra_offset;
1054 this_cache->saved_regs[SCORE_PC_REGNUM] =
1055 this_cache->saved_regs[SCORE_RA_REGNUM];
1059 if (fp_offset_p == 1)
1061 if (this_cache->saved_regs[SCORE_FP_REGNUM].addr == -1)
1062 this_cache->saved_regs[SCORE_FP_REGNUM].addr =
1063 sp + sp_offset - fp_offset;
1066 /* Save SP and FP. */
1067 this_cache->base = sp + sp_offset;
1068 this_cache->fp = fp;
1070 /* Don't forget to free MEMBLOCK if we allocated it. */
1071 if (memblock_ptr != NULL)
1072 score7_free_memblock (memblock_ptr);
1076 score3_analyze_prologue (CORE_ADDR startaddr, CORE_ADDR pc,
1077 struct frame_info *this_frame,
1078 struct score_frame_cache *this_cache)
1082 CORE_ADDR cur_pc = startaddr;
1083 enum bfd_endian byte_order
1084 = gdbarch_byte_order (get_frame_arch (this_frame));
1089 int ra_offset_p = 0;
1090 int fp_offset_p = 0;
1093 sp = get_frame_register_unsigned (this_frame, SCORE_SP_REGNUM);
1094 fp = get_frame_register_unsigned (this_frame, SCORE_FP_REGNUM);
1096 for (; cur_pc < pc; cur_pc += inst_len)
1098 inst_t *inst = NULL;
1100 inst = score3_adjust_pc_and_fetch_inst (&cur_pc, &inst_len, byte_order);
1102 /* FIXME: make a full-power prologue analyzer. */
1105 if (G_FLD (inst->v, 14, 12) == 0x0
1106 && G_FLD (inst->v, 11, 7) == 0x0
1107 && G_FLD (inst->v, 6, 5) == 0x3)
1112 if (G_FLD (inst->v, 4, 0) == 0x3
1113 && ra_offset_p == 0)
1115 /* push! r3, [r0] */
1116 ra_offset = sp_offset;
1119 else if (G_FLD (inst->v, 4, 0) == 0x2
1120 && fp_offset_p == 0)
1122 /* push! r2, [r0] */
1123 fp_offset = sp_offset;
1127 else if (G_FLD (inst->v, 14, 12) == 0x6
1128 && G_FLD (inst->v, 11, 10) == 0x3)
1131 int start_r = G_FLD (inst->v, 9, 5);
1132 int cnt = G_FLD (inst->v, 4, 0);
1134 if ((ra_offset_p == 0)
1135 && (start_r <= SCORE_RA_REGNUM)
1136 && (SCORE_RA_REGNUM < start_r + cnt))
1138 /* rpush! contains r3 */
1140 ra_offset = sp_offset + 4 * (SCORE_RA_REGNUM - start_r) + 4;
1143 if ((fp_offset_p == 0)
1144 && (start_r <= SCORE_FP_REGNUM)
1145 && (SCORE_FP_REGNUM < start_r + cnt))
1147 /* rpush! contains r2 */
1149 fp_offset = sp_offset + 4 * (SCORE_FP_REGNUM - start_r) + 4;
1152 sp_offset += 4 * cnt;
1154 else if (G_FLD (inst->v, 14, 12) == 0x0
1155 && G_FLD (inst->v, 11, 7) == 0x0
1156 && G_FLD (inst->v, 6, 5) == 0x2)
1161 else if (G_FLD (inst->v, 14, 12) == 0x6
1162 && G_FLD (inst->v, 11, 10) == 0x2)
1165 sp_offset -= 4 * G_FLD (inst->v, 4, 0);
1167 else if (G_FLD (inst->v, 14, 12) == 0x5
1168 && G_FLD (inst->v, 11, 10) == 0x3
1169 && G_FLD (inst->v, 9, 6) == 0x0)
1171 /* addi! r0, -offset */
1172 int imm = G_FLD (inst->v, 5, 0);
1174 imm = -(0x3F - imm + 1);
1177 else if (G_FLD (inst->v, 14, 12) == 0x5
1178 && G_FLD (inst->v, 11, 10) == 0x3
1179 && G_FLD (inst->v, 9, 6) == 0x2)
1181 /* addi! r2, offset */
1182 if (pc - cur_pc >= 2)
1186 cur_pc += inst->len;
1187 inst2 = score3_adjust_pc_and_fetch_inst (&cur_pc, NULL,
1191 && G_FLD (inst2->v, 14, 10) == 0x10
1192 && G_FLD (inst2->v, 9, 5) == 0x0
1193 && G_FLD (inst2->v, 4, 0) == 0x2)
1196 int imm = G_FLD (inst->v, 5, 0);
1198 imm = -(0x3F - imm + 1);
1204 else if (inst->len == 4)
1206 if (G_FLD (inst->v, 29, 25) == 0x3
1207 && G_FLD (inst->v, 2, 0) == 0x4
1208 && G_FLD (inst->v, 24, 20) == 0x3
1209 && G_FLD (inst->v, 19, 15) == 0x0)
1211 /* sw r3, [r0, offset]+ */
1212 sp_offset += inst->len;
1213 if (ra_offset_p == 0)
1215 ra_offset = sp_offset;
1219 else if (G_FLD (inst->v, 29, 25) == 0x3
1220 && G_FLD (inst->v, 2, 0) == 0x4
1221 && G_FLD (inst->v, 24, 20) == 0x2
1222 && G_FLD (inst->v, 19, 15) == 0x0)
1224 /* sw r2, [r0, offset]+ */
1225 sp_offset += inst->len;
1226 if (fp_offset_p == 0)
1228 fp_offset = sp_offset;
1232 else if (G_FLD (inst->v, 29, 25) == 0x7
1233 && G_FLD (inst->v, 2, 0) == 0x0
1234 && G_FLD (inst->v, 24, 20) == 0x3
1235 && G_FLD (inst->v, 19, 15) == 0x0)
1237 /* lw r3, [r0]+, 4 */
1238 sp_offset -= inst->len;
1241 else if (G_FLD (inst->v, 29, 25) == 0x7
1242 && G_FLD (inst->v, 2, 0) == 0x0
1243 && G_FLD (inst->v, 24, 20) == 0x2
1244 && G_FLD (inst->v, 19, 15) == 0x0)
1246 /* lw r2, [r0]+, 4 */
1247 sp_offset -= inst->len;
1250 else if (G_FLD (inst->v, 29, 25) == 0x1
1251 && G_FLD (inst->v, 19, 17) == 0x0
1252 && G_FLD (inst->v, 24, 20) == 0x0
1253 && G_FLD (inst->v, 0, 0) == 0x0)
1255 /* addi r0, -offset */
1256 int imm = G_FLD (inst->v, 16, 1);
1258 imm = -(0xFFFF - imm + 1);
1261 else if (G_FLD (inst->v, 29, 25) == 0x1
1262 && G_FLD (inst->v, 19, 17) == 0x0
1263 && G_FLD (inst->v, 24, 20) == 0x2
1264 && G_FLD (inst->v, 0, 0) == 0x0)
1266 /* addi r2, offset */
1267 if (pc - cur_pc >= 2)
1271 cur_pc += inst->len;
1272 inst2 = score3_adjust_pc_and_fetch_inst (&cur_pc, NULL,
1276 && G_FLD (inst2->v, 14, 10) == 0x10
1277 && G_FLD (inst2->v, 9, 5) == 0x0
1278 && G_FLD (inst2->v, 4, 0) == 0x2)
1281 int imm = G_FLD (inst->v, 16, 1);
1283 imm = -(0xFFFF - imm + 1);
1292 if (ra_offset_p == 1)
1294 if (this_cache->saved_regs[SCORE_PC_REGNUM].addr == -1)
1295 this_cache->saved_regs[SCORE_PC_REGNUM].addr =
1296 sp + sp_offset - ra_offset;
1300 this_cache->saved_regs[SCORE_PC_REGNUM] =
1301 this_cache->saved_regs[SCORE_RA_REGNUM];
1305 if (fp_offset_p == 1)
1307 if (this_cache->saved_regs[SCORE_FP_REGNUM].addr == -1)
1308 this_cache->saved_regs[SCORE_FP_REGNUM].addr =
1309 sp + sp_offset - fp_offset;
1312 /* Save SP and FP. */
1313 this_cache->base = sp + sp_offset;
1314 this_cache->fp = fp;
1317 static struct score_frame_cache *
1318 score_make_prologue_cache (struct frame_info *this_frame, void **this_cache)
1320 struct score_frame_cache *cache;
1322 if ((*this_cache) != NULL)
1323 return (struct score_frame_cache *) (*this_cache);
1325 cache = FRAME_OBSTACK_ZALLOC (struct score_frame_cache);
1326 (*this_cache) = cache;
1327 cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
1329 /* Analyze the prologue. */
1331 const CORE_ADDR pc = get_frame_pc (this_frame);
1332 CORE_ADDR start_addr;
1334 find_pc_partial_function (pc, NULL, &start_addr, NULL);
1335 if (start_addr == 0)
1338 if (target_mach == bfd_mach_score3)
1339 score3_analyze_prologue (start_addr, pc, this_frame,
1340 (struct score_frame_cache *) *this_cache);
1342 score7_analyze_prologue (start_addr, pc, this_frame,
1343 (struct score_frame_cache *) *this_cache);
1347 trad_frame_set_value (cache->saved_regs, SCORE_SP_REGNUM, cache->base);
1349 return (struct score_frame_cache *) (*this_cache);
1353 score_prologue_this_id (struct frame_info *this_frame, void **this_cache,
1354 struct frame_id *this_id)
1356 struct score_frame_cache *info = score_make_prologue_cache (this_frame,
1358 (*this_id) = frame_id_build (info->base, get_frame_func (this_frame));
1361 static struct value *
1362 score_prologue_prev_register (struct frame_info *this_frame,
1363 void **this_cache, int regnum)
1365 struct score_frame_cache *info = score_make_prologue_cache (this_frame,
1367 return trad_frame_get_prev_register (this_frame, info->saved_regs, regnum);
1370 static const struct frame_unwind score_prologue_unwind =
1373 default_frame_unwind_stop_reason,
1374 score_prologue_this_id,
1375 score_prologue_prev_register,
1377 default_frame_sniffer,
1382 score_prologue_frame_base_address (struct frame_info *this_frame,
1385 struct score_frame_cache *info =
1386 score_make_prologue_cache (this_frame, this_cache);
1390 static const struct frame_base score_prologue_frame_base =
1392 &score_prologue_unwind,
1393 score_prologue_frame_base_address,
1394 score_prologue_frame_base_address,
1395 score_prologue_frame_base_address,
1398 static const struct frame_base *
1399 score_prologue_frame_base_sniffer (struct frame_info *this_frame)
1401 return &score_prologue_frame_base;
1404 /* Core file support. */
1406 static const struct regcache_map_entry score7_linux_gregmap[] =
1408 /* FIXME: According to the current Linux kernel, r0 is preceded by
1409 9 rather than 7 words. */
1410 { 7, REGCACHE_MAP_SKIP, 4 },
1411 { 32, 0, 4 }, /* r0 ... r31 */
1412 { 1, 55, 4 }, /* CEL */
1413 { 1, 54, 4 }, /* CEH */
1414 { 1, 53, 4 }, /* sr0, i.e. cnt or COUNTER */
1415 { 1, 52, 4 }, /* sr1, i.e. lcr or LDCR */
1416 { 1, 51, 4 }, /* sr2, i.e. scr or STCR */
1417 { 1, 49, 4 }, /* PC (same slot as EPC) */
1418 { 1, 38, 4 }, /* EMA */
1419 { 1, 32, 4 }, /* PSR */
1420 { 1, 34, 4 }, /* ECR */
1421 { 1, 33, 4 }, /* COND */
1425 #define SCORE7_LINUX_EPC_OFFSET (44 * 4)
1426 #define SCORE7_LINUX_SIZEOF_GREGSET (49 * 4)
1429 score7_linux_supply_gregset(const struct regset *regset,
1430 struct regcache *regcache,
1431 int regnum, const void *buf,
1434 regcache_supply_regset (regset, regcache, regnum, buf, size);
1436 /* Supply the EPC from the same slot as the PC. Note that the
1437 collect function will store the PC in that slot. */
1438 if ((regnum == -1 || regnum == SCORE_EPC_REGNUM)
1439 && size >= SCORE7_LINUX_EPC_OFFSET + 4)
1440 regcache_raw_supply (regcache, SCORE_EPC_REGNUM,
1441 (const gdb_byte *) buf
1442 + SCORE7_LINUX_EPC_OFFSET);
1445 static const struct regset score7_linux_gregset =
1447 score7_linux_gregmap,
1448 score7_linux_supply_gregset,
1449 regcache_collect_regset
1452 /* Iterate over core file register note sections. */
1455 score7_linux_iterate_over_regset_sections (struct gdbarch *gdbarch,
1456 iterate_over_regset_sections_cb *cb,
1458 const struct regcache *regcache)
1460 cb (".reg", SCORE7_LINUX_SIZEOF_GREGSET, &score7_linux_gregset,
1464 static struct gdbarch *
1465 score_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1467 struct gdbarch *gdbarch;
1468 target_mach = info.bfd_arch_info->mach;
1470 arches = gdbarch_list_lookup_by_info (arches, &info);
1473 return (arches->gdbarch);
1475 gdbarch = gdbarch_alloc (&info, NULL);
1477 set_gdbarch_short_bit (gdbarch, 16);
1478 set_gdbarch_int_bit (gdbarch, 32);
1479 set_gdbarch_float_bit (gdbarch, 32);
1480 set_gdbarch_double_bit (gdbarch, 64);
1481 set_gdbarch_long_double_bit (gdbarch, 64);
1483 set_gdbarch_register_sim_regno (gdbarch, score_register_sim_regno);
1485 set_gdbarch_pc_regnum (gdbarch, SCORE_PC_REGNUM);
1486 set_gdbarch_sp_regnum (gdbarch, SCORE_SP_REGNUM);
1487 set_gdbarch_adjust_breakpoint_address (gdbarch,
1488 score_adjust_breakpoint_address);
1489 set_gdbarch_register_type (gdbarch, score_register_type);
1490 set_gdbarch_frame_align (gdbarch, score_frame_align);
1491 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1492 set_gdbarch_unwind_sp (gdbarch, score_unwind_sp);
1493 set_gdbarch_unwind_pc (gdbarch, score_unwind_pc);
1494 set_gdbarch_print_insn (gdbarch, score_print_insn);
1496 switch (target_mach)
1498 case bfd_mach_score7:
1499 set_gdbarch_breakpoint_kind_from_pc (gdbarch,
1500 score7_breakpoint_kind_from_pc);
1501 set_gdbarch_sw_breakpoint_from_kind (gdbarch,
1502 score7_sw_breakpoint_from_kind);
1503 set_gdbarch_skip_prologue (gdbarch, score7_skip_prologue);
1504 set_gdbarch_stack_frame_destroyed_p (gdbarch,
1505 score7_stack_frame_destroyed_p);
1506 set_gdbarch_register_name (gdbarch, score7_register_name);
1507 set_gdbarch_num_regs (gdbarch, SCORE7_NUM_REGS);
1508 /* Core file support. */
1509 set_gdbarch_iterate_over_regset_sections
1510 (gdbarch, score7_linux_iterate_over_regset_sections);
1513 case bfd_mach_score3:
1514 set_gdbarch_breakpoint_kind_from_pc (gdbarch,
1515 score3_breakpoint_kind_from_pc);
1516 set_gdbarch_sw_breakpoint_from_kind (gdbarch,
1517 score3_sw_breakpoint_from_kind);
1518 set_gdbarch_skip_prologue (gdbarch, score3_skip_prologue);
1519 set_gdbarch_stack_frame_destroyed_p (gdbarch,
1520 score3_stack_frame_destroyed_p);
1521 set_gdbarch_register_name (gdbarch, score3_register_name);
1522 set_gdbarch_num_regs (gdbarch, SCORE3_NUM_REGS);
1526 /* Watchpoint hooks. */
1527 set_gdbarch_have_nonsteppable_watchpoint (gdbarch, 1);
1529 /* Dummy frame hooks. */
1530 set_gdbarch_return_value (gdbarch, score_return_value);
1531 set_gdbarch_call_dummy_location (gdbarch, AT_ENTRY_POINT);
1532 set_gdbarch_dummy_id (gdbarch, score_dummy_id);
1533 set_gdbarch_push_dummy_call (gdbarch, score_push_dummy_call);
1535 /* Normal frame hooks. */
1536 dwarf2_append_unwinders (gdbarch);
1537 frame_base_append_sniffer (gdbarch, dwarf2_frame_base_sniffer);
1538 frame_unwind_append_unwinder (gdbarch, &score_prologue_unwind);
1539 frame_base_append_sniffer (gdbarch, score_prologue_frame_base_sniffer);
1544 extern initialize_file_ftype _initialize_score_tdep;
1547 _initialize_score_tdep (void)
1549 gdbarch_register (bfd_arch_score, score_gdbarch_init, NULL);