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