* Re: [patch] add target Score to GDB
2006-12-07 20:18 ` Jim Blandy
@ 2006-12-09 6:23 ` 秦巍
2007-01-03 0:08 ` Jim Blandy
0 siblings, 1 reply; 9+ messages in thread
From: 秦巍 @ 2006-12-09 6:23 UTC (permalink / raw)
To: Jim Blandy; +Cc: bjgnu, gdb-patches
[-- Attachment #1: Type: text/plain, Size: 2481 bytes --]
Sorry Jim i didn't reply you yesterday for the reason that i can't
checkout the
current cvs caused by our network.
> Jim Blandy <jimb@codesourcery.com> wrote on 2006-12-08 04:19:03:
> >> Does score_integer_to_address do exactly the same thing that GCC does
> >> when the user casts an integer to an address? If they don't, then
the
> >> user could become quite confused when GDB and GCC evaluate their
> >> expressions differently.
> >
> > I didn't see clearly about this hook when i was porting score gdb.
> > I have seen your NOTES in 'value_as_address'.
> > The pointer and the address are the same on score target,
> > and a pointer to a function always points to the entry point address
of
> > that function.
> > So we don't need to implement this hook. Can i say that?
>
> If you don't need to set it to get clean test suite results, then I
> would definitely recommend leaving it out.
I will leave it out.
> Please keep all lines under 80 characters in length; for example,
> score_unwind_dummy_id needs to be reformatted.
>
> I'm surprised by score_type_needs_double_align --- is it really true
> that struct types only need double alignment if their *first* member
> does? Why is that? I'd expect the code for structs and unions to be
> the same.
I have modified that.
> There should be patches to Makefile.in; could you post those? We need
> to see the complete patch in order to approve it.
>
> All changes need a ChangeLog entry. You don't need to say much for
> score-tdep.c and score-tdep.h; here's the entry for the xtensa port:
>
> 2006-11-14 Maxim Grigoriev <maxim@tensilica.com>
>
> * NEWS: New port to Xtensa.
> * Makefile.in: Add dependencies for Xtensa files.
> * configure.tgt (xtensa*, xtensa*-*-elf*): New.
> * configure.host (xtensa*-*-elf*): New.
> * config/xtensa/xtensa.mt: New file.
> * xtensa-config.c: New file.
> * xtensa-tdep.h: New file.
> * xtensa-tdep.c: New file.
>
> (I would prefer that the Makefile.in entry actually listed the
> variables and rules added.)
>
> Other than that, this looks good. Please post a complete patch,
> generated against the current CVS sources, and with a ChangeLog entry,
> for a final review, and then we'll get it committed.
I have added S+core target to ChangeLog and dependencies to Makefile.in.
The following is a complete patch. Thanks for checking it!
Best regards,
Qinwei
Mail qinwei@sunnorth.com.cn
Phone +86-010-62981668-2708
Fax +86-010-62985972
[-- Attachment #2: score_gdb.patch --]
[-- Type: application/octet-stream, Size: 32824 bytes --]
diff -ruN gdb-6.6/gdb/ChangeLog gdb-6.6-score/gdb/ChangeLog
--- gdb-6.6/gdb/ChangeLog 2006-12-09 06:05:36.000000000 +0800
+++ gdb-6.6-score/gdb/ChangeLog 2006-12-09 14:03:50.000000000 +0800
@@ -1,3 +1,12 @@
+2006-12-09 Qinwei <qinwei@sunnorth.com.cn>
+
+ * NEWS: New port to S+core.
+ * Makefile.in: Add dependencies for S+core files.
+ * configure.tgt (score*, score-*-*): New.
+ * config/score/embed.mt: New file.
+ * score-tdep.h: New file.
+ * score-tdep.c: New file.
+
2006-12-09 Nick Roberts <nickrob@snap.net.nz>
* varobj.c (varobj_update): Ensure frame is restored when
diff -ruN gdb-6.6/gdb/config/score/embed.mt gdb-6.6-score/gdb/config/score/embed.mt
--- gdb-6.6/gdb/config/score/embed.mt 1970-01-01 08:00:00.000000000 +0800
+++ gdb-6.6-score/gdb/config/score/embed.mt 2006-12-09 14:03:50.000000000 +0800
@@ -0,0 +1,2 @@
+# Target: S+core embedded system
+TDEPFILES= score-tdep.o
diff -ruN gdb-6.6/gdb/configure.tgt gdb-6.6-score/gdb/configure.tgt
--- gdb-6.6/gdb/configure.tgt 2006-11-23 01:34:15.000000000 +0800
+++ gdb-6.6-score/gdb/configure.tgt 2006-12-09 14:03:50.000000000 +0800
@@ -24,6 +24,7 @@
sparc*) gdb_target_cpu=sparc ;;
thumb*) gdb_target_cpu=arm ;;
s390*) gdb_target_cpu=s390 ;;
+score*) gdb_target_cpu=score ;;
sh*) gdb_target_cpu=sh ;;
spu*) gdb_target_cpu=spu ;;
strongarm*) gdb_target_cpu=arm ;;
@@ -179,6 +180,7 @@
build_gdbserver=yes
;;
+score-*-*) gdb_target=embed ;;
sh*-*-pe) gdb_target=wince ;;
sh-*-coff*) gdb_target=embed ;;
sh-*-elf*) gdb_target=embed ;;
diff -ruN gdb-6.6/gdb/Makefile.in gdb-6.6-score/gdb/Makefile.in
--- gdb-6.6/gdb/Makefile.in 2006-11-29 06:14:31.000000000 +0800
+++ gdb-6.6-score/gdb/Makefile.in 2006-12-09 14:03:50.000000000 +0800
@@ -782,6 +782,7 @@
s390_tdep_h = s390-tdep.h
scm_lang_h = scm-lang.h $(scm_tags_h)
scm_tags_h = scm-tags.h
+score_tdep_h = score-tdep.h
sentinel_frame_h = sentinel-frame.h
serial_h = serial.h
ser_base_h = ser-base.h
@@ -1490,6 +1491,7 @@
remote-st.c remote-utils.c dcache.c \
rs6000-nat.c rs6000-tdep.c \
s390-tdep.c s390-nat.c \
+ score-tdep.c \
ser-go32.c ser-pipe.c ser-tcp.c ser-mingw.c \
sh-tdep.c sh64-tdep.c shnbsd-tdep.c shnbsd-nat.c \
sol2-tdep.c \
@@ -2580,6 +2582,10 @@
scm-valprint.o: scm-valprint.c $(defs_h) $(symtab_h) $(gdbtypes_h) \
$(expression_h) $(parser_defs_h) $(language_h) $(value_h) \
$(scm_lang_h) $(valprint_h) $(gdbcore_h) $(c_lang_h)
+score-tdep.o: score-tdep.c $(defs_h) $(gdb_assert_h) $(inferior_h) \
+ $(symtab_h) $(objfiles_h) $(gdbcore_h) $(target_h) \
+ $(arch_utils_h) $(regcache_h) $(dis_asm_h) $(frame_unwind_h) \
+ $(frame_base_h) $(trad_frame_h) $(dwarf2_frame_h) $(score_tdep_h)
sentinel-frame.o: sentinel-frame.c $(defs_h) $(regcache_h) \
$(sentinel_frame_h) $(inferior_h) $(frame_unwind_h)
ser-e7kpc.o: ser-e7kpc.c $(defs_h) $(serial_h) $(gdb_string_h)
diff -ruN gdb-6.6/gdb/score-tdep.c gdb-6.6-score/gdb/score-tdep.c
--- gdb-6.6/gdb/score-tdep.c 1970-01-01 08:00:00.000000000 +0800
+++ gdb-6.6-score/gdb/score-tdep.c 2006-12-09 14:03:50.000000000 +0800
@@ -0,0 +1,905 @@
+/* Target-dependent code for the S+core architecture, for GDB, the GNU Debugger.
+
+ Copyright (C) 2006
+ Free Software Foundation, Inc.
+
+ Contributed by Qinwei (qinwei@sunnorth.com.cn)
+ Contributed by Ching-Peng Lin (cplin@sunplus.com)
+
+ This file is part of GDB.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA. */
+
+#include "defs.h"
+#include "gdb_assert.h"
+#include "inferior.h"
+#include "symtab.h"
+#include "objfiles.h"
+#include "gdbcore.h"
+#include "target.h"
+#include "arch-utils.h"
+#include "regcache.h"
+#include "dis-asm.h"
+#include "frame-unwind.h"
+#include "frame-base.h"
+#include "trad-frame.h"
+#include "dwarf2-frame.h"
+#include "score-tdep.h"
+
+#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))
+
+typedef struct{
+ unsigned int v;
+ unsigned int raw;
+ char is15;
+}inst_t;
+
+struct score_frame_cache
+{
+ CORE_ADDR base;
+ struct trad_frame_saved_reg *saved_regs;
+};
+
+#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 *next_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 ("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
+
+static struct type *
+score_register_type (struct gdbarch *gdbarch, int regnum)
+{
+ gdb_assert (regnum >= 0 && regnum < SCORE_NUM_REGS);
+ return builtin_type_uint32;
+}
+
+static LONGEST
+score_read_unsigned_register (int regnum)
+{
+ LONGEST val;
+ regcache_cooked_read_unsigned (current_regcache, regnum, &val);
+ return val;
+}
+
+static CORE_ADDR
+score_read_sp (void)
+{
+ return score_read_unsigned_register (SCORE_SP_REGNUM);
+}
+
+static CORE_ADDR
+score_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
+{
+ return frame_unwind_register_unsigned (next_frame, SCORE_PC_REGNUM);
+}
+
+static const char *
+score_register_name (int 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 < SCORE_NUM_REGS);
+ return score_register_names[regnum];
+}
+
+static int
+score_register_sim_regno (int regnum)
+{
+ gdb_assert (regnum >= 0 && regnum < SCORE_NUM_REGS);
+ return regnum;
+}
+
+static int
+score_print_insn (bfd_vma memaddr, struct disassemble_info *info)
+{
+ if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
+ return print_insn_big_score (memaddr, info);
+ else
+ return print_insn_little_score (memaddr, info);
+}
+
+static const gdb_byte *
+score_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
+{
+ gdb_byte buf[SCORE_INSTLEN] = { 0 };
+ int ret;
+ unsigned int raw;
+
+ if ((ret = target_read_memory (*pcptr & ~0x3, buf, SCORE_INSTLEN)) != 0)
+ {
+ memory_error (ret, *pcptr);
+ }
+ raw = extract_unsigned_integer (buf, SCORE_INSTLEN);
+
+ if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
+ {
+ if (!(raw & 0x80008000))
+ {
+ /* 16bits instruction. */
+ static gdb_byte big_breakpoint16[] = { 0x60, 0x02 };
+ *pcptr &= ~0x1;
+ *lenptr = sizeof (big_breakpoint16);
+ return big_breakpoint16;
+ }
+ else
+ {
+ /* 32bits instruction. */
+ static gdb_byte big_breakpoint32[] = { 0x80, 0x00, 0x80, 0x06 };
+ *pcptr &= ~0x3;
+ *lenptr = sizeof (big_breakpoint32);
+ return big_breakpoint32;
+ }
+ }
+ else
+ {
+ if (!(raw & 0x80008000))
+ {
+ /* 16bits instruction. */
+ static gdb_byte little_breakpoint16[] = { 0x02, 0x60 };
+ *pcptr &= ~0x1;
+ *lenptr = sizeof (little_breakpoint16);
+ return little_breakpoint16;
+ }
+ else
+ {
+ /* 32bits instruction. */
+ static gdb_byte little_breakpoint32[] = { 0x06, 0x80, 0x00, 0x80 };
+ *pcptr &= ~0x3;
+ *lenptr = sizeof (little_breakpoint32);
+ return little_breakpoint32;
+ }
+ }
+}
+
+static CORE_ADDR
+score_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
+{
+ return align_down (addr, 16);
+}
+
+static void
+score_xfer_register (struct regcache *regcache, int regnum, int length,
+ enum bfd_endian endian, gdb_byte *readbuf,
+ const gdb_byte *writebuf, int buf_offset)
+{
+ int reg_offset = 0;
+ gdb_assert (regnum >= 0 && regnum < SCORE_NUM_REGS);
+
+ switch (endian)
+ {
+ case BFD_ENDIAN_BIG:
+ reg_offset = SCORE_REGSIZE - length;
+ break;
+ case BFD_ENDIAN_LITTLE:
+ reg_offset = 0;
+ break;
+ case BFD_ENDIAN_UNKNOWN:
+ reg_offset = 0;
+ break;
+ default:
+ internal_error (__FILE__, __LINE__, _("score_xfer_register error!"));
+ }
+
+ if (readbuf != NULL)
+ regcache_cooked_read_part (regcache, regnum, reg_offset, length,
+ readbuf + buf_offset);
+ if (writebuf != NULL)
+ regcache_cooked_write_part (regcache, regnum, reg_offset, length,
+ writebuf + buf_offset);
+}
+
+static enum return_value_convention
+score_return_value (struct gdbarch *gdbarch, struct type *type,
+ struct regcache *regcache,
+ gdb_byte * readbuf, const gdb_byte * writebuf)
+{
+ if (TYPE_CODE (type) == TYPE_CODE_STRUCT
+ || TYPE_CODE (type) == TYPE_CODE_UNION
+ || TYPE_CODE (type) == TYPE_CODE_ARRAY)
+ return RETURN_VALUE_STRUCT_CONVENTION;
+ else
+ {
+ int offset;
+ int regnum;
+ for (offset = 0, regnum = SCORE_A0_REGNUM;
+ offset < TYPE_LENGTH (type);
+ offset += SCORE_REGSIZE, regnum++)
+ {
+ int xfer = SCORE_REGSIZE;
+ if (offset + xfer > TYPE_LENGTH (type))
+ xfer = TYPE_LENGTH (type) - offset;
+ score_xfer_register (regcache, regnum, xfer, TARGET_BYTE_ORDER,
+ readbuf, writebuf, offset);
+ }
+ return RETURN_VALUE_REGISTER_CONVENTION;
+ }
+}
+
+static struct frame_id
+score_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
+{
+ return frame_id_build (
+ frame_unwind_register_unsigned (next_frame, SCORE_SP_REGNUM),
+ frame_pc_unwind (next_frame));
+}
+
+static int
+score_type_needs_double_align (struct type *type)
+{
+ enum type_code typecode = TYPE_CODE (type);
+
+ if (typecode == TYPE_CODE_INT && TYPE_LENGTH (type) == 8)
+ return 1;
+ if (typecode == TYPE_CODE_FLT && TYPE_LENGTH (type) == 8)
+ return 1;
+ else if (typecode == TYPE_CODE_STRUCT || typecode == TYPE_CODE_UNION)
+ {
+ int i, n;
+
+ n = TYPE_NFIELDS (type);
+ for (i = 0; i < n; i++)
+ if (score_type_needs_double_align (TYPE_FIELD_TYPE (type, i)))
+ return 1;
+ return 0;
+ }
+ return 0;
+}
+
+static CORE_ADDR
+score_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
+ struct regcache *regcache, CORE_ADDR bp_addr,
+ int nargs, struct value **args, CORE_ADDR sp,
+ int struct_return, CORE_ADDR struct_addr)
+{
+ int argnum;
+ int argreg;
+ int arglen = 0;
+ CORE_ADDR stack_offset = 0;
+ CORE_ADDR addr = 0;
+
+ /* Step 1, Save RA. */
+ regcache_cooked_write_unsigned (regcache, SCORE_RA_REGNUM, bp_addr);
+
+ /* Step 2, Make space on the stack for the args. */
+ struct_addr = align_down (struct_addr, 16);
+ sp = align_down (sp, 16);
+ for (argnum = 0; argnum < nargs; argnum++)
+ arglen += align_up (TYPE_LENGTH (value_type (args[argnum])),
+ SCORE_REGSIZE);
+ sp -= align_up (arglen, 16);
+
+ argreg = SCORE_BEGIN_ARG_REGNUM;
+
+ /* Step 3, Check if struct return then save the struct address to r4 and
+ increase the stack_offset by 4. */
+ if (struct_return)
+ {
+ regcache_cooked_write_unsigned (regcache, argreg++, struct_addr);
+ stack_offset += SCORE_REGSIZE;
+ }
+
+ /* Step 4, Load arguments:
+ If arg length is too long (> 4 bytes),
+ then split the arg and save every parts. */
+ for (argnum = 0; argnum < nargs; argnum++)
+ {
+ struct value *arg = args[argnum];
+ struct type *arg_type = check_typedef (value_type (arg));
+ arglen = TYPE_LENGTH (arg_type);
+ enum type_code typecode = TYPE_CODE (arg_type);
+ const gdb_byte *val = value_contents (arg);
+ int downward_offset = 0;
+
+ int odd_sized_struct_p = (arglen > SCORE_REGSIZE
+ && arglen % SCORE_REGSIZE != 0);
+ int arg_last_part_p = 0;
+
+ /* If a arg should be aligned to 8 bytes (long long or double),
+ the value should be put to even register numbers. */
+ if (score_type_needs_double_align (arg_type))
+ {
+ if (argreg & 1)
+ argreg++;
+ }
+
+ /* If sizeof a block < SCORE_REGSIZE, then Score GCC will chose
+ the default "downward"/"upward" method:
+
+ Example:
+
+ struct struc
+ {
+ char a; char b; char c;
+ } s = {'a', 'b', 'c'};
+
+ Big endian: s = {X, 'a', 'b', 'c'}
+ Little endian: s = {'a', 'b', 'c', X}
+
+ Where X is a hole. */
+
+ if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
+ && (typecode == TYPE_CODE_STRUCT
+ || typecode == TYPE_CODE_UNION)
+ && argreg > SCORE_LAST_ARG_REGNUM
+ && arglen < SCORE_REGSIZE)
+ downward_offset += (SCORE_REGSIZE - arglen);
+
+ while (arglen > 0)
+ {
+ int partial_len = arglen < SCORE_REGSIZE ? arglen : SCORE_REGSIZE;
+ ULONGEST regval = extract_unsigned_integer (val, partial_len);
+
+ /* The last part of a arg should shift left when
+ TARGET_BYTE_ORDER is BFD_ENDIAN_BIG. */
+ if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
+ && arg_last_part_p == 1
+ && (typecode == TYPE_CODE_STRUCT
+ || typecode == TYPE_CODE_UNION))
+ regval <<= ((SCORE_REGSIZE - partial_len) * TARGET_CHAR_BIT);
+
+ /* Always increase the stack_offset and save args to stack. */
+ addr = sp + stack_offset + downward_offset;
+ write_memory (addr, val, partial_len);
+
+ if (argreg <= SCORE_LAST_ARG_REGNUM)
+ {
+ regcache_cooked_write_unsigned (regcache, argreg++, regval);
+ if (arglen > SCORE_REGSIZE && arglen < SCORE_REGSIZE * 2)
+ arg_last_part_p = 1;
+ }
+
+ val += partial_len;
+ arglen -= partial_len;
+ stack_offset += align_up (partial_len, SCORE_REGSIZE);
+ }
+ }
+
+ /* Step 5, Save SP. */
+ regcache_cooked_write_unsigned (regcache, SCORE_SP_REGNUM, sp);
+
+ return sp;
+}
+
+static inst_t *
+score_fetch_instruction (CORE_ADDR addr)
+{
+ static inst_t inst = { 0, 0 };
+ char buf[SCORE_INSTLEN];
+ int big;
+ int ret = target_read_memory (addr & ~0x3, buf, SCORE_INSTLEN);
+ unsigned int raw;
+
+ if (ret)
+ {
+ memory_error (ret, addr);
+ return 0;
+ }
+ inst.raw = extract_unsigned_integer (buf, SCORE_INSTLEN);
+ inst.is15 = !(inst.raw & 0x80008000);
+ inst.v = RM_PBITS (inst.raw);
+ big = (TARGET_BYTE_ORDER == 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;
+}
+
+static CORE_ADDR
+score_skip_prologue (CORE_ADDR pc)
+{
+ CORE_ADDR cpc = pc;
+ int iscan = 32, stack_sub = 0;
+ while (iscan-- > 0)
+ {
+ inst_t *inst = score_fetch_instruction (cpc);
+ if (!inst)
+ break;
+ if (!inst->is15 && !stack_sub
+ && (G_FLD (inst->v, 29, 25) == 0x1
+ && G_FLD (inst->v, 24, 20) == 0x0))
+ {
+ /* addi r0, offset */
+ pc = stack_sub = cpc + SCORE_INSTLEN;
+ }
+ else if (!inst->is15
+ && inst->v == RM_PBITS (0x8040bc56))
+ {
+ /* mv r2, r0 */
+ pc = cpc + SCORE_INSTLEN;
+ break;
+ }
+ else if (inst->is15
+ && inst->v == RM_PBITS (0x0203))
+ {
+ /* mv! r2, r0 */
+ pc = cpc + SCORE16_INSTLEN;
+ break;
+ }
+ else if (inst->is15
+ && ((G_FLD (inst->v, 14, 12) == 3) /* j15 form */
+ || (G_FLD (inst->v, 14, 12) == 4) /* b15 form */
+ || (G_FLD (inst->v, 14, 12) == 0x0
+ && G_FLD (inst->v, 3, 0) == 0x4))) /* br! */
+ break;
+ else if (!inst->is15
+ && ((G_FLD (inst->v, 29, 25) == 2) /* j32 form */
+ || (G_FLD (inst->v, 29, 25) == 4) /* b32 form */
+ || (G_FLD (inst->v, 29, 25) == 0x0
+ && G_FLD (inst->v, 6, 1) == 0x4))) /* br */
+ break;
+
+ cpc += inst->is15 ? SCORE16_INSTLEN : SCORE_INSTLEN;
+ }
+ return pc;
+}
+
+static int
+score_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR cur_pc)
+{
+ inst_t *inst = score_fetch_instruction (cur_pc);
+
+ if (inst->v == 0x23)
+ return 1; /* mv! r0, r2 */
+ else if (G_FLD (inst->v, 14, 12) == 0x2
+ && G_FLD (inst->v, 3, 0) == 0xa)
+ return 1; /* pop! */
+ else if (G_FLD (inst->v, 14, 12) == 0x0
+ && G_FLD (inst->v, 7, 0) == 0x34)
+ return 1; /* br! r3 */
+ else if (G_FLD (inst->v, 29, 15) == 0x2
+ && G_FLD (inst->v, 6, 1) == 0x2b)
+ return 1; /* mv r0, r2 */
+ else if (G_FLD (inst->v, 29, 25) == 0x0
+ && G_FLD (inst->v, 6, 1) == 0x4
+ && G_FLD (inst->v, 19, 15) == 0x3)
+ return 1; /* br r3 */
+ else
+ return 0;
+}
+
+static void
+score_analyze_prologue (CORE_ADDR startaddr, CORE_ADDR pc,
+ struct frame_info *next_frame,
+ struct score_frame_cache *this_cache)
+{
+ CORE_ADDR sp;
+ 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;
+
+ sp = frame_unwind_register_unsigned (next_frame, SCORE_SP_REGNUM);
+
+ for (; cur_pc < pc; cur_pc += inst_len)
+ {
+ inst_t *inst = score_fetch_instruction (cur_pc);
+ if (inst->is15 == 1)
+ {
+ inst_len = SCORE16_INSTLEN;
+
+ if (G_FLD (inst->v, 14, 12) == 0x2
+ && G_FLD (inst->v, 3, 0) == 0xe)
+ {
+ /* push! */
+ sp_offset += 4;
+
+ if (G_FLD (inst->v, 11, 7) == 0x6
+ && ra_offset_p == 0)
+ {
+ /* push! r3, [r0] */
+ ra_offset = sp_offset;
+ ra_offset_p = 1;
+ }
+ else if (G_FLD (inst->v, 11, 7) == 0x4
+ && fp_offset_p == 0)
+ {
+ /* push! r2, [r0] */
+ fp_offset = sp_offset;
+ fp_offset_p = 1;
+ }
+ }
+ else if (G_FLD (inst->v, 14, 12) == 0x2
+ && G_FLD (inst->v, 3, 0) == 0xa)
+ {
+ /* pop! */
+ sp_offset -= 4;
+ }
+ else if (G_FLD (inst->v, 14, 7) == 0xc1
+ && G_FLD (inst->v, 2, 0) == 0x0)
+ {
+ /* subei! r0, n */
+ sp_offset += (int) pow (2, G_FLD (inst->v, 6, 3));
+ }
+ else if (G_FLD (inst->v, 14, 7) == 0xc0
+ && G_FLD (inst->v, 2, 0) == 0x0)
+ {
+ /* addei! r0, n */
+ sp_offset -= (int) pow (2, G_FLD (inst->v, 6, 3));
+ }
+ }
+ else
+ {
+ inst_len = SCORE_INSTLEN;
+
+ if (G_FLD (inst->v, 29, 15) == 0xc60
+ && G_FLD (inst->v, 2, 0) == 0x4)
+ {
+ /* sw r3, [r0, offset]+ */
+ sp_offset += SCORE_INSTLEN;
+ if (ra_offset_p == 0)
+ {
+ ra_offset = sp_offset;
+ ra_offset_p = 1;
+ }
+ }
+ if (G_FLD (inst->v, 29, 15) == 0xc40
+ && G_FLD (inst->v, 2, 0) == 0x4)
+ {
+ /* sw r2, [r0, offset]+ */
+ sp_offset += SCORE_INSTLEN;
+ if (fp_offset_p == 0)
+ {
+ fp_offset = sp_offset;
+ fp_offset_p = 1;
+ }
+ }
+ else if (G_FLD (inst->v, 29, 15) == 0x1c60
+ && G_FLD (inst->v, 2, 0) == 0x0)
+ {
+ /* lw r3, [r0]+, 4 */
+ sp_offset -= SCORE_INSTLEN;
+ ra_offset_p = 1;
+ }
+ else if (G_FLD (inst->v, 29, 15) == 0x1c40
+ && G_FLD (inst->v, 2, 0) == 0x0)
+ {
+ /* lw r2, [r0]+, 4 */
+ sp_offset -= SCORE_INSTLEN;
+ fp_offset_p = 1;
+ }
+
+ else if (G_FLD (inst->v, 29, 17) == 0x100
+ && G_FLD (inst->v, 0, 0) == 0x0)
+ {
+ /* addi r0, -offset */
+ sp_offset += 65536 - G_FLD (inst->v, 16, 1);
+ }
+ else if (G_FLD (inst->v, 29, 17) == 0x110
+ && G_FLD (inst->v, 0, 0) == 0x0)
+ {
+ /* addi r2, offset */
+ if (pc - cur_pc > 4)
+ {
+ unsigned int save_v = inst->v;
+ inst_t *inst2 =
+ score_fetch_instruction (cur_pc + SCORE_INSTLEN);
+ if (inst2->v == 0x23)
+ /* mv! r0, r2 */
+ sp_offset -= G_FLD (save_v, 16, 1);
+ }
+ }
+ }
+ }
+
+ /* 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. */
+ this_cache->base =
+ frame_unwind_register_unsigned (next_frame, SCORE_SP_REGNUM) + sp_offset;
+}
+
+static struct score_frame_cache *
+score_make_prologue_cache (struct frame_info *next_frame, void **this_cache)
+{
+ struct score_frame_cache *cache;
+
+ if ((*this_cache) != NULL)
+ return (*this_cache);
+
+ cache = FRAME_OBSTACK_ZALLOC (struct score_frame_cache);
+ (*this_cache) = cache;
+ cache->saved_regs = trad_frame_alloc_saved_regs (next_frame);
+
+ /* Analyze the prologue. */
+ {
+ const CORE_ADDR pc = frame_pc_unwind (next_frame);
+ CORE_ADDR start_addr;
+
+ find_pc_partial_function (pc, NULL, &start_addr, NULL);
+ if (start_addr == 0)
+ return cache;
+ score_analyze_prologue (start_addr, pc, next_frame, *this_cache);
+ }
+
+ /* Save SP. */
+ trad_frame_set_value (cache->saved_regs, SCORE_SP_REGNUM, cache->base);
+
+ return (*this_cache);
+}
+
+static void
+score_prologue_this_id (struct frame_info *next_frame, void **this_cache,
+ struct frame_id *this_id)
+{
+ struct score_frame_cache *info = score_make_prologue_cache (next_frame,
+ this_cache);
+ (*this_id) = frame_id_build (info->base, frame_func_unwind (next_frame));
+}
+
+static void
+score_prologue_prev_register (struct frame_info *next_frame,
+ void **this_cache,
+ int regnum, int *optimizedp,
+ enum lval_type *lvalp, CORE_ADDR * addrp,
+ int *realnump, gdb_byte * valuep)
+{
+ struct score_frame_cache *info = score_make_prologue_cache (next_frame,
+ this_cache);
+ trad_frame_get_prev_register (next_frame, info->saved_regs, regnum,
+ optimizedp, lvalp, addrp, realnump, valuep);
+}
+
+static const struct frame_unwind score_prologue_unwind =
+{
+ NORMAL_FRAME,
+ score_prologue_this_id,
+ score_prologue_prev_register
+};
+
+static const struct frame_unwind *
+score_prologue_sniffer (struct frame_info *next_frame)
+{
+ return &score_prologue_unwind;
+}
+
+static CORE_ADDR
+score_prologue_frame_base_address (struct frame_info *next_frame,
+ void **this_cache)
+{
+ struct score_frame_cache *info =
+ score_make_prologue_cache (next_frame, this_cache);
+ return info->base;
+}
+
+static const struct frame_base score_prologue_frame_base =
+{
+ &score_prologue_unwind,
+ score_prologue_frame_base_address,
+ score_prologue_frame_base_address,
+ score_prologue_frame_base_address,
+};
+
+static const struct frame_base *
+score_prologue_frame_base_sniffer (struct frame_info *next_frame)
+{
+ return &score_prologue_frame_base;
+}
+
+static struct gdbarch *
+score_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
+{
+ struct gdbarch *gdbarch;
+
+ arches = gdbarch_list_lookup_by_info (arches, &info);
+ if (arches != NULL)
+ {
+ return (arches->gdbarch);
+ }
+ gdbarch = gdbarch_alloc (&info, 0);
+
+ set_gdbarch_short_bit (gdbarch, 16);
+ set_gdbarch_int_bit (gdbarch, 32);
+ set_gdbarch_float_bit (gdbarch, 32);
+ set_gdbarch_double_bit (gdbarch, 64);
+ set_gdbarch_long_double_bit (gdbarch, 64);
+ set_gdbarch_register_sim_regno (gdbarch, score_register_sim_regno);
+ set_gdbarch_pc_regnum (gdbarch, SCORE_PC_REGNUM);
+ set_gdbarch_sp_regnum (gdbarch, SCORE_SP_REGNUM);
+ 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_register_type (gdbarch, score_register_type);
+ set_gdbarch_frame_align (gdbarch, score_frame_align);
+ set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
+ set_gdbarch_read_sp (gdbarch, score_read_sp);
+ set_gdbarch_unwind_pc (gdbarch, score_unwind_pc);
+ set_gdbarch_print_insn (gdbarch, score_print_insn);
+ set_gdbarch_skip_prologue (gdbarch, score_skip_prologue);
+ set_gdbarch_in_function_epilogue_p (gdbarch, score_in_function_epilogue_p);
+ set_gdbarch_call_dummy_location (gdbarch, AT_ENTRY_POINT);
+ set_gdbarch_return_value (gdbarch, score_return_value);
+ set_gdbarch_unwind_dummy_id (gdbarch, score_unwind_dummy_id);
+ set_gdbarch_push_dummy_call (gdbarch, score_push_dummy_call);
+
+ frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer);
+ frame_base_append_sniffer (gdbarch, dwarf2_frame_base_sniffer);
+ frame_unwind_append_sniffer (gdbarch, score_prologue_sniffer);
+ frame_base_append_sniffer (gdbarch, score_prologue_frame_base_sniffer);
+
+ return gdbarch;
+}
+
+extern initialize_file_ftype _initialize_score_tdep;
+
+void
+_initialize_score_tdep (void)
+{
+ gdbarch_register (bfd_arch_score, score_gdbarch_init, NULL);
+}
diff -ruN gdb-6.6/gdb/score-tdep.h gdb-6.6-score/gdb/score-tdep.h
--- gdb-6.6/gdb/score-tdep.h 1970-01-01 08:00:00.000000000 +0800
+++ gdb-6.6-score/gdb/score-tdep.h 2006-12-09 14:03:50.000000000 +0800
@@ -0,0 +1,50 @@
+/* Target-dependent code for the S+core architecture, for GDB, the GNU Debugger.
+
+ Copyright (C) 2006
+ Free Software Foundation, Inc.
+
+ Contributed by Qinwei (qinwei@sunnorth.com.cn)
+ Contributed by Ching-Peng Lin (cplin@sunplus.com)
+
+ This file is part of GDB.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA. */
+
+#ifndef SCORE_TDEP_H
+#define SCORE_TDEP_H
+#include "math.h"
+
+enum gdb_regnum
+{
+ SCORE_SP_REGNUM = 0,
+ SCORE_FP_REGNUM = 2,
+ SCORE_RA_REGNUM = 3,
+ SCORE_A0_REGNUM = 4,
+ SCORE_AL_REGNUM = 7,
+ SCORE_PC_REGNUM = 49,
+};
+
+#define SCORE_A0_REGNUM 4
+#define SCORE_A1_REGNUM 5
+#define SCORE_REGSIZE 4
+#define SCORE_NUM_REGS 56
+#define SCORE_BEGIN_ARG_REGNUM 4
+#define SCORE_LAST_ARG_REGNUM 7
+
+#define SCORE_INSTLEN 4
+#define SCORE16_INSTLEN 2
+
+#endif /* SCORE_TDEP_H */
^ permalink raw reply [flat|nested] 9+ messages in thread