projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
testsuite/ChangeLog
[deliverable/binutils-gdb.git] / gdb / score-tdep.c
1 /* Target-dependent code for the S+core architecture, for GDB,
2 the GNU Debugger.
3
4 Copyright (C) 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
5
6 Contributed by Qinwei (qinwei@sunnorth.com.cn)
7 Contributed by Ching-Peng Lin (cplin@sunplus.com)
8
9 This file is part of GDB.
10
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.
15
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.
20
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/>. */
23
24 #include "defs.h"
25 #include "gdb_assert.h"
26 #include "inferior.h"
27 #include "symtab.h"
28 #include "objfiles.h"
29 #include "gdbcore.h"
30 #include "target.h"
31 #include "arch-utils.h"
32 #include "regcache.h"
33 #include "regset.h"
34 #include "dis-asm.h"
35 #include "frame-unwind.h"
36 #include "frame-base.h"
37 #include "trad-frame.h"
38 #include "dwarf2-frame.h"
39 #include "score-tdep.h"
40
41 #define G_FLD(_i,_ms,_ls) \
42 ((unsigned)((_i) << (31 - (_ms))) >> (31 - (_ms) + (_ls)))
43
44 typedef struct{
45 unsigned long long v;
46 unsigned long long raw;
47 unsigned int len;
48 }inst_t;
49
50 struct score_frame_cache
51 {
52 CORE_ADDR base;
53 CORE_ADDR fp;
54 struct trad_frame_saved_reg *saved_regs;
55 };
56
57 static int target_mach = bfd_mach_score7;
58
59 #if WITH_SIM
60 int
61 score_target_can_use_watch (int type, int cnt, int othertype)
62 {
63 if (strcmp (current_target.to_shortname, "sim") == 0)
64 return soc_gh_can_use_watch (type, cnt);
65 return (*current_target.to_can_use_hw_breakpoint) (type, cnt, othertype);
66 }
67
68 int
69 score_stopped_by_watch (void)
70 {
71 if (strcmp (current_target.to_shortname, "sim") == 0)
72 return soc_gh_stopped_by_watch ();
73 return (*current_target.to_stopped_by_watchpoint) ();
74 }
75
76 int
77 score_target_insert_watchpoint (CORE_ADDR addr, int len, int type)
78 {
79 if (strcmp (current_target.to_shortname, "sim") == 0)
80 return soc_gh_add_watch (addr, len, type);
81 return (*current_target.to_insert_watchpoint) (addr, len, type);
82 }
83
84 int
85 score_target_remove_watchpoint (CORE_ADDR addr, int len, int type)
86 {
87 if (strcmp (current_target.to_shortname, "sim") == 0)
88 return soc_gh_del_watch (addr, len, type);
89 return (*current_target.to_remove_watchpoint) (addr, len, type);
90 }
91
92 int
93 score_target_insert_hw_breakpoint (struct gdbarch *gdbarch,
94 struct bp_target_info * bp_tgt)
95 {
96 if (strcmp (current_target.to_shortname, "sim") == 0)
97 return soc_gh_add_hardbp (bp_tgt->placed_address);
98 return (*current_target.to_insert_hw_breakpoint) (gdbarch, bp_tgt);
99 }
100
101 int
102 score_target_remove_hw_breakpoint (struct gdbarch *gdbarch,
103 struct bp_target_info * bp_tgt)
104 {
105 if (strcmp (current_target.to_shortname, "sim") == 0)
106 return soc_gh_del_hardbp (bp_tgt->placed_address);
107 return (*current_target.to_remove_hw_breakpoint) (gdbarch, bp_tgt);
108 }
109 #endif
110
111 static struct type *
112 score_register_type (struct gdbarch *gdbarch, int regnum)
113 {
114 gdb_assert (regnum >= 0
115 && regnum < ((target_mach == bfd_mach_score7) ? SCORE7_NUM_REGS : SCORE3_NUM_REGS));
116 return builtin_type (gdbarch)->builtin_uint32;
117 }
118
119 static CORE_ADDR
120 score_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
121 {
122 return frame_unwind_register_unsigned (next_frame, SCORE_SP_REGNUM);
123 }
124
125 static CORE_ADDR
126 score_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
127 {
128 return frame_unwind_register_unsigned (next_frame, SCORE_PC_REGNUM);
129 }
130
131 static const char *
132 score7_register_name (struct gdbarch *gdbarch, int regnum)
133 {
134 const char *score_register_names[] = {
135 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
136 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
137 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
138 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
139
140 "PSR", "COND", "ECR", "EXCPVEC", "CCR",
141 "EPC", "EMA", "TLBLOCK", "TLBPT", "PEADDR",
142 "TLBRPT", "PEVN", "PECTX", "LIMPFN", "LDMPFN",
143 "PREV", "DREG", "PC", "DSAVE", "COUNTER",
144 "LDCR", "STCR", "CEH", "CEL",
145 };
146
147 gdb_assert (regnum >= 0 && regnum < SCORE7_NUM_REGS);
148 return score_register_names[regnum];
149 }
150
151 static const char *
152 score3_register_name (struct gdbarch *gdbarch, int regnum)
153 {
154 const char *score_register_names[] = {
155 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
156 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
157 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
158 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
159
160 "PSR", "COND", "ECR", "EXCPVEC", "CCR",
161 "EPC", "EMA", "PREV", "DREG", "DSAVE",
162 "COUNTER", "LDCR", "STCR", "CEH", "CEL",
163 "", "", "PC",
164 };
165
166 gdb_assert (regnum >= 0 && regnum < SCORE3_NUM_REGS);
167 return score_register_names[regnum];
168 }
169
170 #if WITH_SIM
171 static int
172 score_register_sim_regno (struct gdbarch *gdbarch, int regnum)
173 {
174 gdb_assert (regnum >= 0
175 && regnum < ((target_mach == bfd_mach_score7) ? SCORE7_NUM_REGS : SCORE3_NUM_REGS));
176 return regnum;
177 }
178 #endif
179
180 static int
181 score_print_insn (bfd_vma memaddr, struct disassemble_info *info)
182 {
183 if (info->endian == BFD_ENDIAN_BIG)
184 return print_insn_big_score (memaddr, info);
185 else
186 return print_insn_little_score (memaddr, info);
187 }
188
189 static inst_t *
190 score7_fetch_inst (struct gdbarch *gdbarch, CORE_ADDR addr, char *memblock)
191 {
192 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
193 static inst_t inst = { 0, 0, 0 };
194 char buf[SCORE_INSTLEN] = { 0 };
195 int big;
196 int ret;
197
198 if (target_has_execution && memblock != NULL)
199 {
200 /* Fetch instruction from local MEMBLOCK. */
201 memcpy (buf, memblock, SCORE_INSTLEN);
202 }
203 else
204 {
205 /* Fetch instruction from target. */
206 ret = target_read_memory (addr & ~0x3, buf, SCORE_INSTLEN);
207 if (ret)
208 {
209 error ("Error: target_read_memory in file:%s, line:%d!",
210 __FILE__, __LINE__);
211 return 0;
212 }
213 }
214
215 inst.raw = extract_unsigned_integer (buf, SCORE_INSTLEN, byte_order);
216 inst.len = (inst.raw & 0x80008000) ? 4 : 2;
217 inst.v = ((inst.raw >> 16 & 0x7FFF) << 15) | (inst.raw & 0x7FFF);
218 big = (byte_order == BFD_ENDIAN_BIG);
219 if (inst.len == 2)
220 {
221 if (big ^ ((addr & 0x2) == 2))
222 inst.v = G_FLD (inst.v, 29, 15);
223 else
224 inst.v = G_FLD (inst.v, 14, 0);
225 }
226 return &inst;
227 }
228
229 static inst_t *
230 score3_adjust_pc_and_fetch_inst (CORE_ADDR *pcptr, int *lenptr,
231 enum bfd_endian byte_order)
232 {
233 static inst_t inst = { 0, 0, 0 };
234
235 struct breakplace
236 {
237 int break_offset;
238 int inst_len;
239 };
240 /* raw table 1 (column 2, 3, 4)
241 * 0 1 0 * # 2
242 * 0 1 1 0 # 3
243 0 1 1 0 * # 6
244 table 2 (column 1, 2, 3)
245 * 0 0 * * # 0, 4
246 0 1 0 * * # 2
247 1 1 0 * * # 6
248 */
249
250 static const struct breakplace bk_table[16] =
251 {
252 /* table 1 */
253 {0, 0},
254 {0, 0},
255 {0, 4},
256 {0, 6},
257 {0, 0},
258 {0, 0},
259 {-2, 6},
260 {0, 0},
261 /* table 2 */
262 {0, 2},
263 {0, 0},
264 {-2, 4},
265 {0, 0},
266 {0, 2},
267 {0, 0},
268 {-4, 6},
269 {0, 0}
270 };
271
272 #define EXTRACT_LEN 2
273 CORE_ADDR adjust_pc = *pcptr & ~0x1;
274 int inst_len;
275 gdb_byte buf[5][EXTRACT_LEN] =
276 {
277 {'\0', '\0'},
278 {'\0', '\0'},
279 {'\0', '\0'},
280 {'\0', '\0'},
281 {'\0', '\0'}
282 };
283 int ret;
284 unsigned int raw;
285 unsigned int cbits = 0;
286 int bk_index;
287 int i, count;
288
289 inst.v = 0;
290 inst.raw = 0;
291 inst.len = 0;
292
293 adjust_pc -= 4;
294 for (i = 0; i < 5; i++)
295 {
296 ret = target_read_memory (adjust_pc + 2 * i, buf[i], EXTRACT_LEN);
297 if (ret != 0)
298 {
299 buf[i][0] = '\0';
300 buf[i][1] = '\0';
301 if (i == 2)
302 error ("Error: target_read_memory in file:%s, line:%d!",
303 __FILE__, __LINE__);
304 }
305
306 raw = extract_unsigned_integer (buf[i], EXTRACT_LEN, byte_order);
307 cbits = (cbits << 1) | (raw >> 15);
308 }
309 adjust_pc += 4;
310
311 if (cbits & 0x4)
312 {
313 /* table 1 */
314 cbits = (cbits >> 1) & 0x7;
315 bk_index = cbits;
316 }
317 else
318 {
319 /* table 2 */
320 cbits = (cbits >> 2) & 0x7;
321 bk_index = cbits + 8;
322 }
323
324 gdb_assert (!((bk_table[bk_index].break_offset == 0)
325 && (bk_table[bk_index].inst_len == 0)));
326
327 inst.len = bk_table[bk_index].inst_len;
328
329 i = (bk_table[bk_index].break_offset + 4) / 2;
330 count = inst.len / 2;
331 for (; count > 0; i++, count--)
332 {
333 inst.raw = (inst.raw << 16)
334 | extract_unsigned_integer (buf[i], EXTRACT_LEN, byte_order);
335 }
336
337 switch (inst.len)
338 {
339 case 2:
340 inst.v = inst.raw & 0x7FFF;
341 break;
342 case 4:
343 inst.v = ((inst.raw >> 16 & 0x7FFF) << 15) | (inst.raw & 0x7FFF);
344 break;
345 case 6:
346 inst.v = ((inst.raw >> 32 & 0x7FFF) << 30)
347 | ((inst.raw >> 16 & 0x7FFF) << 15) | (inst.raw & 0x7FFF);
348 break;
349 }
350
351 if (pcptr)
352 *pcptr = adjust_pc + bk_table[bk_index].break_offset;
353 if (lenptr)
354 *lenptr = bk_table[bk_index].inst_len;
355
356 #undef EXTRACT_LEN
357
358 return &inst;
359 }
360
361 static const gdb_byte *
362 score7_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr,
363 int *lenptr)
364 {
365 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
366 gdb_byte buf[SCORE_INSTLEN] = { 0 };
367 int ret;
368 unsigned int raw;
369
370 if ((ret = target_read_memory (*pcptr & ~0x3, buf, SCORE_INSTLEN)) != 0)
371 {
372 error ("Error: target_read_memory in file:%s, line:%d!",
373 __FILE__, __LINE__);
374 }
375 raw = extract_unsigned_integer (buf, SCORE_INSTLEN, byte_order);
376
377 if (byte_order == BFD_ENDIAN_BIG)
378 {
379 if (!(raw & 0x80008000))
380 {
381 /* 16bits instruction. */
382 static gdb_byte big_breakpoint16[] = { 0x60, 0x02 };
383 *pcptr &= ~0x1;
384 *lenptr = sizeof (big_breakpoint16);
385 return big_breakpoint16;
386 }
387 else
388 {
389 /* 32bits instruction. */
390 static gdb_byte big_breakpoint32[] = { 0x80, 0x00, 0x80, 0x06 };
391 *pcptr &= ~0x3;
392 *lenptr = sizeof (big_breakpoint32);
393 return big_breakpoint32;
394 }
395 }
396 else
397 {
398 if (!(raw & 0x80008000))
399 {
400 /* 16bits instruction. */
401 static gdb_byte little_breakpoint16[] = { 0x02, 0x60 };
402 *pcptr &= ~0x1;
403 *lenptr = sizeof (little_breakpoint16);
404 return little_breakpoint16;
405 }
406 else
407 {
408 /* 32bits instruction. */
409 static gdb_byte little_breakpoint32[] = { 0x06, 0x80, 0x00, 0x80 };
410 *pcptr &= ~0x3;
411 *lenptr = sizeof (little_breakpoint32);
412 return little_breakpoint32;
413 }
414 }
415 }
416
417 static const gdb_byte *
418 score3_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr,
419 int *lenptr)
420 {
421 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
422 CORE_ADDR adjust_pc = *pcptr;
423 int len;
424 static gdb_byte score_break_insns[6][6] = {
425 /* The following three instructions are big endian. */
426 { 0x00, 0x20 },
427 { 0x80, 0x00, 0x00, 0x06 },
428 { 0x80, 0x00, 0x80, 0x00, 0x00, 0x00 },
429 /* The following three instructions are little endian. */
430 { 0x20, 0x00 },
431 { 0x00, 0x80, 0x06, 0x00 },
432 { 0x00, 0x80, 0x00, 0x80, 0x00, 0x00 }};
433
434 gdb_byte *p = NULL;
435 int index = 0;
436
437 score3_adjust_pc_and_fetch_inst (&adjust_pc, &len, byte_order);
438
439 index = ((byte_order == BFD_ENDIAN_BIG) ? 0 : 3) + (len / 2 - 1);
440 p = score_break_insns[index];
441
442 *pcptr = adjust_pc;
443 *lenptr = len;
444
445 return p;
446 }
447
448 static CORE_ADDR
449 score_adjust_breakpoint_address (struct gdbarch *gdbarch, CORE_ADDR bpaddr)
450 {
451 CORE_ADDR adjust_pc = bpaddr;
452
453 if (target_mach == bfd_mach_score3)
454 score3_adjust_pc_and_fetch_inst (&adjust_pc, NULL,
455 gdbarch_byte_order (gdbarch));
456 else
457 adjust_pc = align_down (adjust_pc, 2);
458
459 return adjust_pc;
460 }
461
462 static CORE_ADDR
463 score_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
464 {
465 return align_down (addr, 16);
466 }
467
468 static void
469 score_xfer_register (struct regcache *regcache, int regnum, int length,
470 enum bfd_endian endian, gdb_byte *readbuf,
471 const gdb_byte *writebuf, int buf_offset)
472 {
473 int reg_offset = 0;
474 gdb_assert (regnum >= 0
475 && regnum < ((target_mach == bfd_mach_score7) ? SCORE7_NUM_REGS : SCORE3_NUM_REGS));
476
477 switch (endian)
478 {
479 case BFD_ENDIAN_BIG:
480 reg_offset = SCORE_REGSIZE - length;
481 break;
482 case BFD_ENDIAN_LITTLE:
483 reg_offset = 0;
484 break;
485 case BFD_ENDIAN_UNKNOWN:
486 reg_offset = 0;
487 break;
488 default:
489 error ("Error: score_xfer_register in file:%s, line:%d!",
490 __FILE__, __LINE__);
491 }
492
493 if (readbuf != NULL)
494 regcache_cooked_read_part (regcache, regnum, reg_offset, length,
495 readbuf + buf_offset);
496 if (writebuf != NULL)
497 regcache_cooked_write_part (regcache, regnum, reg_offset, length,
498 writebuf + buf_offset);
499 }
500
501 static enum return_value_convention
502 score_return_value (struct gdbarch *gdbarch, struct type *func_type,
503 struct type *type, struct regcache *regcache,
504 gdb_byte * readbuf, const gdb_byte * writebuf)
505 {
506 if (TYPE_CODE (type) == TYPE_CODE_STRUCT
507 || TYPE_CODE (type) == TYPE_CODE_UNION
508 || TYPE_CODE (type) == TYPE_CODE_ARRAY)
509 return RETURN_VALUE_STRUCT_CONVENTION;
510 else
511 {
512 int offset;
513 int regnum;
514 for (offset = 0, regnum = SCORE_A0_REGNUM;
515 offset < TYPE_LENGTH (type);
516 offset += SCORE_REGSIZE, regnum++)
517 {
518 int xfer = SCORE_REGSIZE;
519 if (offset + xfer > TYPE_LENGTH (type))
520 xfer = TYPE_LENGTH (type) - offset;
521 score_xfer_register (regcache, regnum, xfer,
522 gdbarch_byte_order(gdbarch),
523 readbuf, writebuf, offset);
524 }
525 return RETURN_VALUE_REGISTER_CONVENTION;
526 }
527 }
528
529 static struct frame_id
530 score_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
531 {
532 return frame_id_build (
533 get_frame_register_unsigned (this_frame, SCORE_SP_REGNUM),
534 get_frame_pc (this_frame));
535 }
536
537 static int
538 score_type_needs_double_align (struct type *type)
539 {
540 enum type_code typecode = TYPE_CODE (type);
541
542 if ((typecode == TYPE_CODE_INT && TYPE_LENGTH (type) == 8)
543 || (typecode == TYPE_CODE_FLT && TYPE_LENGTH (type) == 8))
544 return 1;
545 else if (typecode == TYPE_CODE_STRUCT || typecode == TYPE_CODE_UNION)
546 {
547 int i, n;
548
549 n = TYPE_NFIELDS (type);
550 for (i = 0; i < n; i++)
551 if (score_type_needs_double_align (TYPE_FIELD_TYPE (type, i)))
552 return 1;
553 return 0;
554 }
555 return 0;
556 }
557
558 static CORE_ADDR
559 score_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
560 struct regcache *regcache, CORE_ADDR bp_addr,
561 int nargs, struct value **args, CORE_ADDR sp,
562 int struct_return, CORE_ADDR struct_addr)
563 {
564 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
565 int argnum;
566 int argreg;
567 int arglen = 0;
568 CORE_ADDR stack_offset = 0;
569 CORE_ADDR addr = 0;
570
571 /* Step 1, Save RA. */
572 regcache_cooked_write_unsigned (regcache, SCORE_RA_REGNUM, bp_addr);
573
574 /* Step 2, Make space on the stack for the args. */
575 struct_addr = align_down (struct_addr, 16);
576 sp = align_down (sp, 16);
577 for (argnum = 0; argnum < nargs; argnum++)
578 arglen += align_up (TYPE_LENGTH (value_type (args[argnum])),
579 SCORE_REGSIZE);
580 sp -= align_up (arglen, 16);
581
582 argreg = SCORE_BEGIN_ARG_REGNUM;
583
584 /* Step 3, Check if struct return then save the struct address to
585 r4 and increase the stack_offset by 4. */
586 if (struct_return)
587 {
588 regcache_cooked_write_unsigned (regcache, argreg++, struct_addr);
589 stack_offset += SCORE_REGSIZE;
590 }
591
592 /* Step 4, Load arguments:
593 If arg length is too long (> 4 bytes), then split the arg and
594 save every parts. */
595 for (argnum = 0; argnum < nargs; argnum++)
596 {
597 struct value *arg = args[argnum];
598 struct type *arg_type = check_typedef (value_type (arg));
599 enum type_code typecode = TYPE_CODE (arg_type);
600 const gdb_byte *val = value_contents (arg);
601 int downward_offset = 0;
602 int odd_sized_struct_p;
603 int arg_last_part_p = 0;
604
605 arglen = TYPE_LENGTH (arg_type);
606 odd_sized_struct_p = (arglen > SCORE_REGSIZE
607 && arglen % SCORE_REGSIZE != 0);
608
609 /* If a arg should be aligned to 8 bytes (long long or double),
610 the value should be put to even register numbers. */
611 if (score_type_needs_double_align (arg_type))
612 {
613 if (argreg & 1)
614 argreg++;
615 }
616
617 /* If sizeof a block < SCORE_REGSIZE, then Score GCC will chose
618 the default "downward"/"upward" method:
619
620 Example:
621
622 struct struc
623 {
624 char a; char b; char c;
625 } s = {'a', 'b', 'c'};
626
627 Big endian: s = {X, 'a', 'b', 'c'}
628 Little endian: s = {'a', 'b', 'c', X}
629
630 Where X is a hole. */
631
632 if (gdbarch_byte_order(gdbarch) == BFD_ENDIAN_BIG
633 && (typecode == TYPE_CODE_STRUCT
634 || typecode == TYPE_CODE_UNION)
635 && argreg > SCORE_LAST_ARG_REGNUM
636 && arglen < SCORE_REGSIZE)
637 downward_offset += (SCORE_REGSIZE - arglen);
638
639 while (arglen > 0)
640 {
641 int partial_len = arglen < SCORE_REGSIZE ? arglen : SCORE_REGSIZE;
642 ULONGEST regval = extract_unsigned_integer (val, partial_len,
643 byte_order);
644
645 /* The last part of a arg should shift left when
646 gdbarch_byte_order is BFD_ENDIAN_BIG. */
647 if (byte_order == BFD_ENDIAN_BIG
648 && arg_last_part_p == 1
649 && (typecode == TYPE_CODE_STRUCT
650 || typecode == TYPE_CODE_UNION))
651 regval <<= ((SCORE_REGSIZE - partial_len) * TARGET_CHAR_BIT);
652
653 /* Always increase the stack_offset and save args to stack. */
654 addr = sp + stack_offset + downward_offset;
655 write_memory (addr, val, partial_len);
656
657 if (argreg <= SCORE_LAST_ARG_REGNUM)
658 {
659 regcache_cooked_write_unsigned (regcache, argreg++, regval);
660 if (arglen > SCORE_REGSIZE && arglen < SCORE_REGSIZE * 2)
661 arg_last_part_p = 1;
662 }
663
664 val += partial_len;
665 arglen -= partial_len;
666 stack_offset += align_up (partial_len, SCORE_REGSIZE);
667 }
668 }
669
670 /* Step 5, Save SP. */
671 regcache_cooked_write_unsigned (regcache, SCORE_SP_REGNUM, sp);
672
673 return sp;
674 }
675
676 static CORE_ADDR
677 score7_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
678 {
679 CORE_ADDR cpc = pc;
680 int iscan = 32, stack_sub = 0;
681 while (iscan-- > 0)
682 {
683 inst_t *inst = score7_fetch_inst (gdbarch, cpc, NULL);
684 if (!inst)
685 break;
686 if ((inst->len == 4) && !stack_sub
687 && (G_FLD (inst->v, 29, 25) == 0x1
688 && G_FLD (inst->v, 24, 20) == 0x0))
689 {
690 /* addi r0, offset */
691 stack_sub = cpc + SCORE_INSTLEN;
692 pc = cpc + SCORE_INSTLEN;
693 }
694 else if ((inst->len == 4)
695 && (G_FLD (inst->v, 29, 25) == 0x0)
696 && (G_FLD (inst->v, 24, 20) == 0x2)
697 && (G_FLD (inst->v, 19, 15) == 0x0)
698 && (G_FLD (inst->v, 14, 10) == 0xF)
699 && (G_FLD (inst->v, 9, 0) == 0x56))
700 {
701 /* mv r2, r0 */
702 pc = cpc + SCORE_INSTLEN;
703 break;
704 }
705 else if ((inst->len == 2)
706 && (G_FLD (inst->v, 14, 12) == 0x0)
707 && (G_FLD (inst->v, 11, 8) == 0x2)
708 && (G_FLD (inst->v, 7, 4) == 0x0)
709 && (G_FLD (inst->v, 3, 0) == 0x3))
710 {
711 /* mv! r2, r0 */
712 pc = cpc + SCORE16_INSTLEN;
713 break;
714 }
715 else if ((inst->len == 2)
716 && ((G_FLD (inst->v, 14, 12) == 3) /* j15 form */
717 || (G_FLD (inst->v, 14, 12) == 4) /* b15 form */
718 || (G_FLD (inst->v, 14, 12) == 0x0
719 && G_FLD (inst->v, 3, 0) == 0x4))) /* br! */
720 break;
721 else if ((inst->len == 4)
722 && ((G_FLD (inst->v, 29, 25) == 2) /* j32 form */
723 || (G_FLD (inst->v, 29, 25) == 4) /* b32 form */
724 || (G_FLD (inst->v, 29, 25) == 0x0
725 && G_FLD (inst->v, 6, 1) == 0x4))) /* br */
726 break;
727
728 cpc += (inst->len == 2) ? SCORE16_INSTLEN : SCORE_INSTLEN;
729 }
730 return pc;
731 }
732
733 static CORE_ADDR
734 score3_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
735 {
736 CORE_ADDR cpc = pc;
737 int iscan = 32, stack_sub = 0;
738 while (iscan-- > 0)
739 {
740 inst_t *inst
741 = score3_adjust_pc_and_fetch_inst (&cpc, NULL, gdbarch_byte_order (gdbarch));
742
743 if (!inst)
744 break;
745 if (inst->len == 4 && !stack_sub
746 && (G_FLD (inst->v, 29, 25) == 0x1)
747 && (G_FLD (inst->v, 19, 17) == 0x0)
748 && (G_FLD (inst->v, 24, 20) == 0x0))
749 {
750 /* addi r0, offset */
751 stack_sub = cpc + inst->len;
752 pc = cpc + inst->len;
753 }
754 else if (inst->len == 4
755 && (G_FLD (inst->v, 29, 25) == 0x0)
756 && (G_FLD (inst->v, 24, 20) == 0x2)
757 && (G_FLD (inst->v, 19, 15) == 0x0)
758 && (G_FLD (inst->v, 14, 10) == 0xF)
759 && (G_FLD (inst->v, 9, 0) == 0x56))
760 {
761 /* mv r2, r0 */
762 pc = cpc + inst->len;
763 break;
764 }
765 else if ((inst->len == 2)
766 && (G_FLD (inst->v, 14, 10) == 0x10)
767 && (G_FLD (inst->v, 9, 5) == 0x2)
768 && (G_FLD (inst->v, 4, 0) == 0x0))
769 {
770 /* mv! r2, r0 */
771 pc = cpc + inst->len;
772 break;
773 }
774 else if (inst->len == 2
775 && ((G_FLD (inst->v, 14, 12) == 3) /* b15 form */
776 || (G_FLD (inst->v, 14, 12) == 0x0
777 && G_FLD (inst->v, 11, 5) == 0x4))) /* br! */
778 break;
779 else if (inst->len == 4
780 && ((G_FLD (inst->v, 29, 25) == 2) /* j32 form */
781 || (G_FLD (inst->v, 29, 25) == 4))) /* b32 form */
782 break;
783
784 cpc += inst->len;
785 }
786 return pc;
787 }
788
789 static int
790 score7_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR cur_pc)
791 {
792 inst_t *inst = score7_fetch_inst (gdbarch, cur_pc, NULL);
793
794 if (inst->v == 0x23)
795 return 1; /* mv! r0, r2 */
796 else if (G_FLD (inst->v, 14, 12) == 0x2
797 && G_FLD (inst->v, 3, 0) == 0xa)
798 return 1; /* pop! */
799 else if (G_FLD (inst->v, 14, 12) == 0x0
800 && G_FLD (inst->v, 7, 0) == 0x34)
801 return 1; /* br! r3 */
802 else if (G_FLD (inst->v, 29, 15) == 0x2
803 && G_FLD (inst->v, 6, 1) == 0x2b)
804 return 1; /* mv r0, r2 */
805 else if (G_FLD (inst->v, 29, 25) == 0x0
806 && G_FLD (inst->v, 6, 1) == 0x4
807 && G_FLD (inst->v, 19, 15) == 0x3)
808 return 1; /* br r3 */
809 else
810 return 0;
811 }
812
813 static int
814 score3_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR cur_pc)
815 {
816 CORE_ADDR pc = cur_pc;
817 inst_t *inst
818 = score3_adjust_pc_and_fetch_inst (&pc, NULL, gdbarch_byte_order (gdbarch));
819
820 if (inst->len == 2
821 && (G_FLD (inst->v, 14, 10) == 0x10)
822 && (G_FLD (inst->v, 9, 5) == 0x0)
823 && (G_FLD (inst->v, 4, 0) == 0x2))
824 return 1; /* mv! r0, r2 */
825 else if (inst->len == 4
826 && (G_FLD (inst->v, 29, 25) == 0x0)
827 && (G_FLD (inst->v, 24, 20) == 0x2)
828 && (G_FLD (inst->v, 19, 15) == 0x0)
829 && (G_FLD (inst->v, 14, 10) == 0xF)
830 && (G_FLD (inst->v, 9, 0) == 0x56))
831 return 1; /* mv r0, r2 */
832 else if (inst->len == 2
833 && (G_FLD (inst->v, 14, 12) == 0x0)
834 && (G_FLD (inst->v, 11, 5) == 0x2))
835 return 1; /* pop! */
836 else if (inst->len == 2
837 && (G_FLD (inst->v, 14, 12) == 0x0)
838 && (G_FLD (inst->v, 11, 7) == 0x0)
839 && (G_FLD (inst->v, 6, 5) == 0x2))
840 return 1; /* rpop! */
841 else if (inst->len == 2
842 && (G_FLD (inst->v, 14, 12) == 0x0)
843 && (G_FLD (inst->v, 11, 5) == 0x4)
844 && (G_FLD (inst->v, 4, 0) == 0x3))
845 return 1; /* br! r3 */
846 else if (inst->len == 4
847 && (G_FLD (inst->v, 29, 25) == 0x0)
848 && (G_FLD (inst->v, 24, 20) == 0x0)
849 && (G_FLD (inst->v, 19, 15) == 0x3)
850 && (G_FLD (inst->v, 14, 10) == 0xF)
851 && (G_FLD (inst->v, 9, 0) == 0x8))
852 return 1; /* br r3 */
853 else
854 return 0;
855 }
856
857 static char *
858 score7_malloc_and_get_memblock (CORE_ADDR addr, CORE_ADDR size)
859 {
860 int ret;
861 char *memblock = NULL;
862
863 if (size < 0)
864 {
865 error ("Error: malloc size < 0 in file:%s, line:%d!",
866 __FILE__, __LINE__);
867 return NULL;
868 }
869 else if (size == 0)
870 return NULL;
871
872 memblock = (char *) xmalloc (size);
873 memset (memblock, 0, size);
874 ret = target_read_memory (addr & ~0x3, memblock, size);
875 if (ret)
876 {
877 error ("Error: target_read_memory in file:%s, line:%d!",
878 __FILE__, __LINE__);
879 return NULL;
880 }
881 return memblock;
882 }
883
884 static void
885 score7_free_memblock (char *memblock)
886 {
887 xfree (memblock);
888 }
889
890 static void
891 score7_adjust_memblock_ptr (char **memblock, CORE_ADDR prev_pc,
892 CORE_ADDR cur_pc)
893 {
894 if (prev_pc == -1)
895 {
896 /* First time call this function, do nothing. */
897 }
898 else if (cur_pc - prev_pc == 2 && (cur_pc & 0x3) == 0)
899 {
900 /* First 16-bit instruction, then 32-bit instruction. */
901 *memblock += SCORE_INSTLEN;
902 }
903 else if (cur_pc - prev_pc == 4)
904 {
905 /* Is 32-bit instruction, increase MEMBLOCK by 4. */
906 *memblock += SCORE_INSTLEN;
907 }
908 }
909
910 static void
911 score7_analyze_prologue (CORE_ADDR startaddr, CORE_ADDR pc,
912 struct frame_info *this_frame,
913 struct score_frame_cache *this_cache)
914 {
915 struct gdbarch *gdbarch = get_frame_arch (this_frame);
916 CORE_ADDR sp;
917 CORE_ADDR fp;
918 CORE_ADDR cur_pc = startaddr;
919
920 int sp_offset = 0;
921 int ra_offset = 0;
922 int fp_offset = 0;
923 int ra_offset_p = 0;
924 int fp_offset_p = 0;
925 int inst_len = 0;
926
927 char *memblock = NULL;
928 char *memblock_ptr = NULL;
929 CORE_ADDR prev_pc = -1;
930
931 /* Allocate MEMBLOCK if PC - STARTADDR > 0. */
932 memblock_ptr = memblock =
933 score7_malloc_and_get_memblock (startaddr, pc - startaddr);
934
935 sp = get_frame_register_unsigned (this_frame, SCORE_SP_REGNUM);
936 fp = get_frame_register_unsigned (this_frame, SCORE_FP_REGNUM);
937
938 for (; cur_pc < pc; prev_pc = cur_pc, cur_pc += inst_len)
939 {
940 inst_t *inst = NULL;
941 if (memblock != NULL)
942 {
943 /* Reading memory block from target succefully and got all
944 the instructions(from STARTADDR to PC) needed. */
945 score7_adjust_memblock_ptr (&memblock, prev_pc, cur_pc);
946 inst = score7_fetch_inst (gdbarch, cur_pc, memblock);
947 }
948 else
949 {
950 /* Otherwise, we fetch 4 bytes from target, and GDB also
951 work correctly. */
952 inst = score7_fetch_inst (gdbarch, cur_pc, NULL);
953 }
954
955 /* FIXME: make a full-power prologue analyzer */
956 if (inst->len == 2)
957 {
958 inst_len = SCORE16_INSTLEN;
959
960 if (G_FLD (inst->v, 14, 12) == 0x2
961 && G_FLD (inst->v, 3, 0) == 0xe)
962 {
963 /* push! */
964 sp_offset += 4;
965
966 if (G_FLD (inst->v, 11, 7) == 0x6
967 && ra_offset_p == 0)
968 {
969 /* push! r3, [r0] */
970 ra_offset = sp_offset;
971 ra_offset_p = 1;
972 }
973 else if (G_FLD (inst->v, 11, 7) == 0x4
974 && fp_offset_p == 0)
975 {
976 /* push! r2, [r0] */
977 fp_offset = sp_offset;
978 fp_offset_p = 1;
979 }
980 }
981 else if (G_FLD (inst->v, 14, 12) == 0x2
982 && G_FLD (inst->v, 3, 0) == 0xa)
983 {
984 /* pop! */
985 sp_offset -= 4;
986 }
987 else if (G_FLD (inst->v, 14, 7) == 0xc1
988 && G_FLD (inst->v, 2, 0) == 0x0)
989 {
990 /* subei! r0, n */
991 sp_offset += (int) pow (2, G_FLD (inst->v, 6, 3));
992 }
993 else if (G_FLD (inst->v, 14, 7) == 0xc0
994 && G_FLD (inst->v, 2, 0) == 0x0)
995 {
996 /* addei! r0, n */
997 sp_offset -= (int) pow (2, G_FLD (inst->v, 6, 3));
998 }
999 }
1000 else
1001 {
1002 inst_len = SCORE_INSTLEN;
1003
1004 if (G_FLD(inst->v, 29, 25) == 0x3
1005 && G_FLD(inst->v, 2, 0) == 0x4
1006 && G_FLD(inst->v, 19, 15) == 0)
1007 {
1008 /* sw rD, [r0, offset]+ */
1009 sp_offset += SCORE_INSTLEN;
1010
1011 if (G_FLD(inst->v, 24, 20) == 0x3)
1012 {
1013 /* rD = r3 */
1014 if (ra_offset_p == 0)
1015 {
1016 ra_offset = sp_offset;
1017 ra_offset_p = 1;
1018 }
1019 }
1020 else if (G_FLD(inst->v, 24, 20) == 0x2)
1021 {
1022 /* rD = r2 */
1023 if (fp_offset_p == 0)
1024 {
1025 fp_offset = sp_offset;
1026 fp_offset_p = 1;
1027 }
1028 }
1029 }
1030 else if (G_FLD(inst->v, 29, 25) == 0x14
1031 && G_FLD(inst->v, 19,15) == 0)
1032 {
1033 /* sw rD, [r0, offset] */
1034 if (G_FLD(inst->v, 24, 20) == 0x3)
1035 {
1036 /* rD = r3 */
1037 ra_offset = sp_offset - G_FLD(inst->v, 14, 0);
1038 ra_offset_p = 1;
1039 }
1040 else if (G_FLD(inst->v, 24, 20) == 0x2)
1041 {
1042 /* rD = r2 */
1043 fp_offset = sp_offset - G_FLD(inst->v, 14, 0);
1044 fp_offset_p = 1;
1045 }
1046 }
1047 else if (G_FLD (inst->v, 29, 15) == 0x1c60
1048 && G_FLD (inst->v, 2, 0) == 0x0)
1049 {
1050 /* lw r3, [r0]+, 4 */
1051 sp_offset -= SCORE_INSTLEN;
1052 ra_offset_p = 1;
1053 }
1054 else if (G_FLD (inst->v, 29, 15) == 0x1c40
1055 && G_FLD (inst->v, 2, 0) == 0x0)
1056 {
1057 /* lw r2, [r0]+, 4 */
1058 sp_offset -= SCORE_INSTLEN;
1059 fp_offset_p = 1;
1060 }
1061
1062 else if (G_FLD (inst->v, 29, 17) == 0x100
1063 && G_FLD (inst->v, 0, 0) == 0x0)
1064 {
1065 /* addi r0, -offset */
1066 sp_offset += 65536 - G_FLD (inst->v, 16, 1);
1067 }
1068 else if (G_FLD (inst->v, 29, 17) == 0x110
1069 && G_FLD (inst->v, 0, 0) == 0x0)
1070 {
1071 /* addi r2, offset */
1072 if (pc - cur_pc > 4)
1073 {
1074 unsigned int save_v = inst->v;
1075 inst_t *inst2 =
1076 score7_fetch_inst (gdbarch, cur_pc + SCORE_INSTLEN, NULL);
1077 if (inst2->v == 0x23)
1078 {
1079 /* mv! r0, r2 */
1080 sp_offset -= G_FLD (save_v, 16, 1);
1081 }
1082 }
1083 }
1084 }
1085 }
1086
1087 /* Save RA. */
1088 if (ra_offset_p == 1)
1089 {
1090 if (this_cache->saved_regs[SCORE_PC_REGNUM].addr == -1)
1091 this_cache->saved_regs[SCORE_PC_REGNUM].addr =
1092 sp + sp_offset - ra_offset;
1093 }
1094 else
1095 {
1096 this_cache->saved_regs[SCORE_PC_REGNUM] =
1097 this_cache->saved_regs[SCORE_RA_REGNUM];
1098 }
1099
1100 /* Save FP. */
1101 if (fp_offset_p == 1)
1102 {
1103 if (this_cache->saved_regs[SCORE_FP_REGNUM].addr == -1)
1104 this_cache->saved_regs[SCORE_FP_REGNUM].addr =
1105 sp + sp_offset - fp_offset;
1106 }
1107
1108 /* Save SP and FP. */
1109 this_cache->base = sp + sp_offset;
1110 this_cache->fp = fp;
1111
1112 /* Don't forget to free MEMBLOCK if we allocated it. */
1113 if (memblock_ptr != NULL)
1114 score7_free_memblock (memblock_ptr);
1115 }
1116
1117 static void
1118 score3_analyze_prologue (CORE_ADDR startaddr, CORE_ADDR pc,
1119 struct frame_info *this_frame,
1120 struct score_frame_cache *this_cache)
1121 {
1122 CORE_ADDR sp;
1123 CORE_ADDR fp;
1124 CORE_ADDR cur_pc = startaddr;
1125 enum bfd_endian byte_order = gdbarch_byte_order (get_frame_arch (this_frame));
1126
1127 int sp_offset = 0;
1128 int ra_offset = 0;
1129 int fp_offset = 0;
1130 int ra_offset_p = 0;
1131 int fp_offset_p = 0;
1132 int inst_len = 0;
1133
1134 CORE_ADDR prev_pc = -1;
1135
1136 sp = get_frame_register_unsigned (this_frame, SCORE_SP_REGNUM);
1137 fp = get_frame_register_unsigned (this_frame, SCORE_FP_REGNUM);
1138
1139 for (; cur_pc < pc; prev_pc = cur_pc, cur_pc += inst_len)
1140 {
1141 inst_t *inst = NULL;
1142
1143 inst = score3_adjust_pc_and_fetch_inst (&cur_pc, &inst_len, byte_order);
1144
1145 /* FIXME: make a full-power prologue analyzer */
1146 if (inst->len == 2)
1147 {
1148 if (G_FLD (inst->v, 14, 12) == 0x0
1149 && G_FLD (inst->v, 11, 7) == 0x0
1150 && G_FLD (inst->v, 6, 5) == 0x3)
1151 {
1152 /* push! */
1153 sp_offset += 4;
1154
1155 if (G_FLD (inst->v, 4, 0) == 0x3
1156 && ra_offset_p == 0)
1157 {
1158 /* push! r3, [r0] */
1159 ra_offset = sp_offset;
1160 ra_offset_p = 1;
1161 }
1162 else if (G_FLD (inst->v, 4, 0) == 0x2
1163 && fp_offset_p == 0)
1164 {
1165 /* push! r2, [r0] */
1166 fp_offset = sp_offset;
1167 fp_offset_p = 1;
1168 }
1169 }
1170 else if (G_FLD (inst->v, 14, 12) == 0x6
1171 && G_FLD (inst->v, 11, 10) == 0x3)
1172 {
1173 /* rpush! */
1174 int start_r = G_FLD (inst->v, 9, 5);
1175 int cnt = G_FLD (inst->v, 4, 0);
1176
1177 if ((ra_offset_p == 0)
1178 && (start_r <= SCORE_RA_REGNUM)
1179 && (SCORE_RA_REGNUM < start_r + cnt))
1180 {
1181 /* rpush! contains r3 */
1182 ra_offset_p = 1;
1183 ra_offset = sp_offset + 4 * (SCORE_RA_REGNUM - start_r) + 4;
1184 }
1185
1186 if ((fp_offset_p == 0)
1187 && (start_r <= SCORE_FP_REGNUM)
1188 && (SCORE_FP_REGNUM < start_r + cnt))
1189 {
1190 /* rpush! contains r2 */
1191 fp_offset_p = 1;
1192 fp_offset = sp_offset + 4 * (SCORE_FP_REGNUM - start_r) + 4;
1193 }
1194
1195 sp_offset += 4 * cnt;
1196 }
1197 else if (G_FLD (inst->v, 14, 12) == 0x0
1198 && G_FLD (inst->v, 11, 7) == 0x0
1199 && G_FLD (inst->v, 6, 5) == 0x2)
1200 {
1201 /* pop! */
1202 sp_offset -= 4;
1203 }
1204 else if (G_FLD (inst->v, 14, 12) == 0x6
1205 && G_FLD (inst->v, 11, 10) == 0x2)
1206 {
1207 /* rpop! */
1208 sp_offset -= 4 * G_FLD (inst->v, 4, 0);
1209 }
1210 else if (G_FLD (inst->v, 14, 12) == 0x5
1211 && G_FLD (inst->v, 11, 10) == 0x3
1212 && G_FLD (inst->v, 9, 6) == 0x0)
1213 {
1214 /* addi! r0, -offset */
1215 int imm = G_FLD (inst->v, 5, 0);
1216 if (imm >> 5)
1217 imm = -(0x3F - imm + 1);
1218 sp_offset -= imm;
1219 }
1220 else if (G_FLD (inst->v, 14, 12) == 0x5
1221 && G_FLD (inst->v, 11, 10) == 0x3
1222 && G_FLD (inst->v, 9, 6) == 0x2)
1223 {
1224 /* addi! r2, offset */
1225 if (pc - cur_pc >= 2)
1226 {
1227 unsigned int save_v = inst->v;
1228 inst_t *inst2;
1229
1230 cur_pc += inst->len;
1231 inst2 = score3_adjust_pc_and_fetch_inst (&cur_pc, NULL, byte_order);
1232
1233 if (inst2->len == 2
1234 && G_FLD (inst2->v, 14, 10) == 0x10
1235 && G_FLD (inst2->v, 9, 5) == 0x0
1236 && G_FLD (inst2->v, 4, 0) == 0x2)
1237 {
1238 /* mv! r0, r2 */
1239 int imm = G_FLD (inst->v, 5, 0);
1240 if (imm >> 5)
1241 imm = -(0x3F - imm + 1);
1242 sp_offset -= imm;
1243 }
1244 }
1245 }
1246 }
1247 else if (inst->len == 4)
1248 {
1249 if (G_FLD (inst->v, 29, 25) == 0x3
1250 && G_FLD (inst->v, 2, 0) == 0x4
1251 && G_FLD (inst->v, 24, 20) == 0x3
1252 && G_FLD (inst->v, 19, 15) == 0x0)
1253 {
1254 /* sw r3, [r0, offset]+ */
1255 sp_offset += inst->len;
1256 if (ra_offset_p == 0)
1257 {
1258 ra_offset = sp_offset;
1259 ra_offset_p = 1;
1260 }
1261 }
1262 else if (G_FLD (inst->v, 29, 25) == 0x3
1263 && G_FLD (inst->v, 2, 0) == 0x4
1264 && G_FLD (inst->v, 24, 20) == 0x2
1265 && G_FLD (inst->v, 19, 15) == 0x0)
1266 {
1267 /* sw r2, [r0, offset]+ */
1268 sp_offset += inst->len;
1269 if (fp_offset_p == 0)
1270 {
1271 fp_offset = sp_offset;
1272 fp_offset_p = 1;
1273 }
1274 }
1275 else if (G_FLD (inst->v, 29, 25) == 0x7
1276 && G_FLD (inst->v, 2, 0) == 0x0
1277 && G_FLD (inst->v, 24, 20) == 0x3
1278 && G_FLD (inst->v, 19, 15) == 0x0)
1279 {
1280 /* lw r3, [r0]+, 4 */
1281 sp_offset -= inst->len;
1282 ra_offset_p = 1;
1283 }
1284 else if (G_FLD (inst->v, 29, 25) == 0x7
1285 && G_FLD (inst->v, 2, 0) == 0x0
1286 && G_FLD (inst->v, 24, 20) == 0x2
1287 && G_FLD (inst->v, 19, 15) == 0x0)
1288 {
1289 /* lw r2, [r0]+, 4 */
1290 sp_offset -= inst->len;
1291 fp_offset_p = 1;
1292 }
1293 else if (G_FLD (inst->v, 29, 25) == 0x1
1294 && G_FLD (inst->v, 19, 17) == 0x0
1295 && G_FLD (inst->v, 24, 20) == 0x0
1296 && G_FLD (inst->v, 0, 0) == 0x0)
1297 {
1298 /* addi r0, -offset */
1299 int imm = G_FLD (inst->v, 16, 1);
1300 if (imm >> 15)
1301 imm = -(0xFFFF - imm + 1);
1302 sp_offset -= imm;
1303 }
1304 else if (G_FLD (inst->v, 29, 25) == 0x1
1305 && G_FLD (inst->v, 19, 17) == 0x0
1306 && G_FLD (inst->v, 24, 20) == 0x2
1307 && G_FLD (inst->v, 0, 0) == 0x0)
1308 {
1309 /* addi r2, offset */
1310 if (pc - cur_pc >= 2)
1311 {
1312 unsigned int save_v = inst->v;
1313 inst_t *inst2;
1314
1315 cur_pc += inst->len;
1316 inst2 = score3_adjust_pc_and_fetch_inst (&cur_pc, NULL, byte_order);
1317
1318 if (inst2->len == 2
1319 && G_FLD (inst2->v, 14, 10) == 0x10
1320 && G_FLD (inst2->v, 9, 5) == 0x0
1321 && G_FLD (inst2->v, 4, 0) == 0x2)
1322 {
1323 /* mv! r0, r2 */
1324 int imm = G_FLD (inst->v, 16, 1);
1325 if (imm >> 15)
1326 imm = -(0xFFFF - imm + 1);
1327 sp_offset -= imm;
1328 }
1329 }
1330 }
1331 }
1332 }
1333
1334 /* Save RA. */
1335 if (ra_offset_p == 1)
1336 {
1337 if (this_cache->saved_regs[SCORE_PC_REGNUM].addr == -1)
1338 this_cache->saved_regs[SCORE_PC_REGNUM].addr =
1339 sp + sp_offset - ra_offset;
1340 }
1341 else
1342 {
1343 this_cache->saved_regs[SCORE_PC_REGNUM] =
1344 this_cache->saved_regs[SCORE_RA_REGNUM];
1345 }
1346
1347 /* Save FP. */
1348 if (fp_offset_p == 1)
1349 {
1350 if (this_cache->saved_regs[SCORE_FP_REGNUM].addr == -1)
1351 this_cache->saved_regs[SCORE_FP_REGNUM].addr =
1352 sp + sp_offset - fp_offset;
1353 }
1354
1355 /* Save SP and FP. */
1356 this_cache->base = sp + sp_offset;
1357 this_cache->fp = fp;
1358 }
1359
1360 static struct score_frame_cache *
1361 score_make_prologue_cache (struct frame_info *this_frame, void **this_cache)
1362 {
1363 struct score_frame_cache *cache;
1364
1365 if ((*this_cache) != NULL)
1366 return (*this_cache);
1367
1368 cache = FRAME_OBSTACK_ZALLOC (struct score_frame_cache);
1369 (*this_cache) = cache;
1370 cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
1371
1372 /* Analyze the prologue. */
1373 {
1374 const CORE_ADDR pc = get_frame_pc (this_frame);
1375 CORE_ADDR start_addr;
1376
1377 find_pc_partial_function (pc, NULL, &start_addr, NULL);
1378 if (start_addr == 0)
1379 return cache;
1380
1381 if (target_mach == bfd_mach_score3)
1382 score3_analyze_prologue (start_addr, pc, this_frame, *this_cache);
1383 else
1384 score7_analyze_prologue (start_addr, pc, this_frame, *this_cache);
1385 }
1386
1387 /* Save SP. */
1388 trad_frame_set_value (cache->saved_regs, SCORE_SP_REGNUM, cache->base);
1389
1390 return (*this_cache);
1391 }
1392
1393 static void
1394 score_prologue_this_id (struct frame_info *this_frame, void **this_cache,
1395 struct frame_id *this_id)
1396 {
1397 struct score_frame_cache *info = score_make_prologue_cache (this_frame,
1398 this_cache);
1399 (*this_id) = frame_id_build (info->base, get_frame_func (this_frame));
1400 }
1401
1402 static struct value *
1403 score_prologue_prev_register (struct frame_info *this_frame,
1404 void **this_cache, int regnum)
1405 {
1406 struct score_frame_cache *info = score_make_prologue_cache (this_frame,
1407 this_cache);
1408 return trad_frame_get_prev_register (this_frame, info->saved_regs, regnum);
1409 }
1410
1411 static const struct frame_unwind score_prologue_unwind =
1412 {
1413 NORMAL_FRAME,
1414 score_prologue_this_id,
1415 score_prologue_prev_register,
1416 NULL,
1417 default_frame_sniffer,
1418 NULL
1419 };
1420
1421 static CORE_ADDR
1422 score_prologue_frame_base_address (struct frame_info *this_frame,
1423 void **this_cache)
1424 {
1425 struct score_frame_cache *info =
1426 score_make_prologue_cache (this_frame, this_cache);
1427 return info->fp;
1428 }
1429
1430 static const struct frame_base score_prologue_frame_base =
1431 {
1432 &score_prologue_unwind,
1433 score_prologue_frame_base_address,
1434 score_prologue_frame_base_address,
1435 score_prologue_frame_base_address,
1436 };
1437
1438 static const struct frame_base *
1439 score_prologue_frame_base_sniffer (struct frame_info *this_frame)
1440 {
1441 return &score_prologue_frame_base;
1442 }
1443
1444 /* Core file support (dirty hack)
1445
1446 The core file MUST be generated by GNU/Linux on S+core */
1447
1448 static void
1449 score7_linux_supply_gregset(const struct regset *regset,
1450 struct regcache *regcache,
1451 int regnum, const void *gregs_buf, size_t len)
1452 {
1453 int regno;
1454 elf_gregset_t *gregs;
1455
1456 gdb_assert (regset != NULL);
1457 gdb_assert ((regcache != NULL) && (gregs_buf != NULL));
1458
1459 gregs = (elf_gregset_t *) gregs_buf;
1460
1461 for (regno = 0; regno < 32; regno++)
1462 if (regnum == -1 || regnum == regno)
1463 regcache_raw_supply (regcache, regno, gregs->regs + regno);
1464
1465 {
1466 struct sreg {
1467 int regnum;
1468 void *buf;
1469 } sregs [] = {
1470 { 55, &(gregs->cel) }, /* CEL */
1471 { 54, &(gregs->ceh) }, /* CEH */
1472 { 53, &(gregs->sr0) }, /* sr0, i.e. cnt or COUNTER */
1473 { 52, &(gregs->sr1) }, /* sr1, i.e. lcr or LDCR */
1474 { 51, &(gregs->sr1) }, /* sr2, i.e. scr or STCR */
1475
1476 /* Exception occured at this address, exactly the PC we want */
1477 { 49, &(gregs->cp0_epc) }, /* PC */
1478
1479 { 38, &(gregs->cp0_ema) }, /* EMA */
1480 { 37, &(gregs->cp0_epc) }, /* EPC */
1481 { 34, &(gregs->cp0_ecr) }, /* ECR */
1482 { 33, &(gregs->cp0_condition) }, /* COND */
1483 { 32, &(gregs->cp0_psr) }, /* PSR */
1484 };
1485
1486 for (regno = 0; regno < sizeof(sregs)/sizeof(sregs[0]); regno++)
1487 if (regnum == -1 || regnum == sregs[regno].regnum)
1488 regcache_raw_supply (regcache, sregs[regno].regnum, sregs[regno].buf);
1489 }
1490 }
1491
1492 /* Return the appropriate register set from the core section identified
1493 by SECT_NAME and SECT_SIZE. */
1494
1495 static const struct regset *
1496 score7_linux_regset_from_core_section(struct gdbarch *gdbarch,
1497 const char *sect_name, size_t sect_size)
1498 {
1499 struct gdbarch_tdep *tdep;
1500
1501 gdb_assert (gdbarch != NULL);
1502 gdb_assert (sect_name != NULL);
1503
1504 tdep = gdbarch_tdep (gdbarch);
1505
1506 if (strcmp(sect_name, ".reg") == 0 && sect_size == sizeof(elf_gregset_t))
1507 {
1508 if (tdep->gregset == NULL)
1509 tdep->gregset = regset_alloc (gdbarch, score7_linux_supply_gregset, NULL);
1510 return tdep->gregset;
1511 }
1512
1513 return NULL;
1514 }
1515
1516 static struct gdbarch *
1517 score_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1518 {
1519 struct gdbarch *gdbarch;
1520 struct gdbarch_tdep *tdep;
1521 target_mach = info.bfd_arch_info->mach;
1522
1523 arches = gdbarch_list_lookup_by_info (arches, &info);
1524 if (arches != NULL)
1525 {
1526 return (arches->gdbarch);
1527 }
1528 tdep = xcalloc(1, sizeof(struct gdbarch_tdep));
1529 gdbarch = gdbarch_alloc (&info, tdep);
1530
1531 set_gdbarch_short_bit (gdbarch, 16);
1532 set_gdbarch_int_bit (gdbarch, 32);
1533 set_gdbarch_float_bit (gdbarch, 32);
1534 set_gdbarch_double_bit (gdbarch, 64);
1535 set_gdbarch_long_double_bit (gdbarch, 64);
1536 #if WITH_SIM
1537 set_gdbarch_register_sim_regno (gdbarch, score_register_sim_regno);
1538 #endif
1539 set_gdbarch_pc_regnum (gdbarch, SCORE_PC_REGNUM);
1540 set_gdbarch_sp_regnum (gdbarch, SCORE_SP_REGNUM);
1541 set_gdbarch_adjust_breakpoint_address (gdbarch, score_adjust_breakpoint_address);
1542 set_gdbarch_register_type (gdbarch, score_register_type);
1543 set_gdbarch_frame_align (gdbarch, score_frame_align);
1544 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1545 set_gdbarch_unwind_sp (gdbarch, score_unwind_sp);
1546 set_gdbarch_unwind_pc (gdbarch, score_unwind_pc);
1547 set_gdbarch_print_insn (gdbarch, score_print_insn);
1548
1549 switch (target_mach)
1550 {
1551 case bfd_mach_score7:
1552 set_gdbarch_breakpoint_from_pc (gdbarch, score7_breakpoint_from_pc);
1553 set_gdbarch_skip_prologue (gdbarch, score7_skip_prologue);
1554 set_gdbarch_in_function_epilogue_p (gdbarch, score7_in_function_epilogue_p);
1555 set_gdbarch_register_name (gdbarch, score7_register_name);
1556 set_gdbarch_num_regs (gdbarch, SCORE7_NUM_REGS);
1557 /* Core file support. */
1558 set_gdbarch_regset_from_core_section (gdbarch, score7_linux_regset_from_core_section);
1559 break;
1560
1561 case bfd_mach_score3:
1562 set_gdbarch_breakpoint_from_pc (gdbarch, score3_breakpoint_from_pc);
1563 set_gdbarch_skip_prologue (gdbarch, score3_skip_prologue);
1564 set_gdbarch_in_function_epilogue_p (gdbarch, score3_in_function_epilogue_p);
1565 set_gdbarch_register_name (gdbarch, score3_register_name);
1566 set_gdbarch_num_regs (gdbarch, SCORE3_NUM_REGS);
1567 break;
1568 }
1569
1570 /* Watchpoint hooks. */
1571 set_gdbarch_have_nonsteppable_watchpoint (gdbarch, 1);
1572
1573 /* Dummy frame hooks. */
1574 set_gdbarch_return_value (gdbarch, score_return_value);
1575 set_gdbarch_call_dummy_location (gdbarch, AT_ENTRY_POINT);
1576 set_gdbarch_dummy_id (gdbarch, score_dummy_id);
1577 set_gdbarch_push_dummy_call (gdbarch, score_push_dummy_call);
1578
1579 /* Normal frame hooks. */
1580 dwarf2_append_unwinders (gdbarch);
1581 frame_base_append_sniffer (gdbarch, dwarf2_frame_base_sniffer);
1582 frame_unwind_append_unwinder (gdbarch, &score_prologue_unwind);
1583 frame_base_append_sniffer (gdbarch, score_prologue_frame_base_sniffer);
1584
1585 return gdbarch;
1586 }
1587
1588 extern initialize_file_ftype _initialize_score_tdep;
1589
1590 void
1591 _initialize_score_tdep (void)
1592 {
1593 gdbarch_register (bfd_arch_score, score_gdbarch_init, NULL);
1594 }
GDB Binutils - Deliverables
This page took 0.068398 seconds and 4 git commands to generate.