?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Updated translations for various languages and sub-directories
[binutils-gdb.git] / gdb / csky-tdep.c
blobf293d204da20a9e6597db3122a3a34daf9f94206
1 /* Target-dependent code for the CSKY architecture, for GDB.
2
3 Copyright (C) 2010-2022 Free Software Foundation, Inc.
4
5 Contributed by C-SKY Microsystems and Mentor Graphics.
6
7 This file is part of GDB.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21
22 #include "defs.h"
23 #include "gdbsupport/gdb_assert.h"
24 #include "frame.h"
25 #include "inferior.h"
26 #include "symtab.h"
27 #include "value.h"
28 #include "gdbcmd.h"
29 #include "language.h"
30 #include "gdbcore.h"
31 #include "symfile.h"
32 #include "objfiles.h"
33 #include "gdbtypes.h"
34 #include "target.h"
35 #include "arch-utils.h"
36 #include "regcache.h"
37 #include "osabi.h"
38 #include "block.h"
39 #include "reggroups.h"
40 #include "elf/csky.h"
41 #include "elf-bfd.h"
42 #include "symcat.h"
43 #include "sim-regno.h"
44 #include "dis-asm.h"
45 #include "frame-unwind.h"
46 #include "frame-base.h"
47 #include "trad-frame.h"
48 #include "infcall.h"
49 #include "floatformat.h"
50 #include "remote.h"
51 #include "target-descriptions.h"
52 #include "dwarf2/frame.h"
53 #include "user-regs.h"
54 #include "valprint.h"
55 #include "csky-tdep.h"
56 #include "regset.h"
57 #include "opcode/csky.h"
58 #include <algorithm>
59 #include <vector>
60
61 /* Control debugging information emitted in this file. */
62
63 static bool csky_debug = false;
64
65 static const reggroup *cr_reggroup;
66 static const reggroup *fr_reggroup;
67 static const reggroup *vr_reggroup;
68 static const reggroup *mmu_reggroup;
69 static const reggroup *prof_reggroup;
70
71 static const char *csky_supported_tdesc_feature_names[] = {
72 (const char *)"org.gnu.csky.abiv2.gpr",
73 (const char *)"org.gnu.csky.abiv2.fpu",
74 (const char *)"org.gnu.csky.abiv2.cr",
75 (const char *)"org.gnu.csky.abiv2.fvcr",
76 (const char *)"org.gnu.csky.abiv2.mmu",
77 (const char *)"org.gnu.csky.abiv2.tee",
78 (const char *)"org.gnu.csky.abiv2.fpu2",
79 (const char *)"org.gnu.csky.abiv2.bank0",
80 (const char *)"org.gnu.csky.abiv2.bank1",
81 (const char *)"org.gnu.csky.abiv2.bank2",
82 (const char *)"org.gnu.csky.abiv2.bank3",
83 (const char *)"org.gnu.csky.abiv2.bank4",
84 (const char *)"org.gnu.csky.abiv2.bank5",
85 (const char *)"org.gnu.csky.abiv2.bank6",
86 (const char *)"org.gnu.csky.abiv2.bank7",
87 (const char *)"org.gnu.csky.abiv2.bank8",
88 (const char *)"org.gnu.csky.abiv2.bank9",
89 (const char *)"org.gnu.csky.abiv2.bank10",
90 (const char *)"org.gnu.csky.abiv2.bank11",
91 (const char *)"org.gnu.csky.abiv2.bank12",
92 (const char *)"org.gnu.csky.abiv2.bank13",
93 (const char *)"org.gnu.csky.abiv2.bank14",
94 (const char *)"org.gnu.csky.abiv2.bank15",
95 (const char *)"org.gnu.csky.abiv2.bank16",
96 (const char *)"org.gnu.csky.abiv2.bank17",
97 (const char *)"org.gnu.csky.abiv2.bank18",
98 (const char *)"org.gnu.csky.abiv2.bank19",
99 (const char *)"org.gnu.csky.abiv2.bank20",
100 (const char *)"org.gnu.csky.abiv2.bank21",
101 (const char *)"org.gnu.csky.abiv2.bank22",
102 (const char *)"org.gnu.csky.abiv2.bank23",
103 (const char *)"org.gnu.csky.abiv2.bank24",
104 (const char *)"org.gnu.csky.abiv2.bank25",
105 (const char *)"org.gnu.csky.abiv2.bank26",
106 (const char *)"org.gnu.csky.abiv2.bank27",
107 (const char *)"org.gnu.csky.abiv2.bank28",
108 (const char *)"org.gnu.csky.abiv2.bank29",
109 (const char *)"org.gnu.csky.abiv2.bank30",
110 (const char *)"org.gnu.csky.abiv2.bank31"
111 };
112
113 struct csky_supported_tdesc_register
114 {
115 char name[16];
116 int num;
117 };
118
119 static const struct csky_supported_tdesc_register csky_supported_gpr_regs[] = {
120 {"r0", 0},
121 {"r1", 1},
122 {"r2", 2},
123 {"r3", 3},
124 {"r4", 4},
125 {"r5", 5},
126 {"r6", 6},
127 {"r7", 7},
128 {"r8", 8},
129 {"r9", 9},
130 {"r10", 10},
131 {"r11", 11},
132 {"r12", 12},
133 {"r13", 13},
134 {"r14", 14},
135 {"r15", 15},
136 {"r16", 16},
137 {"r17", 17},
138 {"r18", 18},
139 {"r19", 19},
140 {"r20", 20},
141 {"r21", 21},
142 {"r22", 22},
143 {"r23", 23},
144 {"r24", 24},
145 {"r25", 25},
146 {"r26", 26},
147 {"r27", 27},
148 {"r28", 28},
149 {"r28", 28},
150 {"r29", 29},
151 {"r30", 30},
152 {"r31", 31},
153 {"hi", CSKY_HI_REGNUM},
154 {"lo", CSKY_LO_REGNUM},
155 {"pc", CSKY_PC_REGNUM}
156 };
157
158 static const struct csky_supported_tdesc_register csky_supported_fpu_regs[] = {
159 /* fr0~fr15. */
160 {"fr0", CSKY_FR0_REGNUM + 0},
161 {"fr1", CSKY_FR0_REGNUM + 1},
162 {"fr2", CSKY_FR0_REGNUM + 2},
163 {"fr3", CSKY_FR0_REGNUM + 3},
164 {"fr4", CSKY_FR0_REGNUM + 4},
165 {"fr5", CSKY_FR0_REGNUM + 5},
166 {"fr6", CSKY_FR0_REGNUM + 6},
167 {"fr7", CSKY_FR0_REGNUM + 7},
168 {"fr8", CSKY_FR0_REGNUM + 8},
169 {"fr9", CSKY_FR0_REGNUM + 9},
170 {"fr10", CSKY_FR0_REGNUM + 10},
171 {"fr11", CSKY_FR0_REGNUM + 11},
172 {"fr12", CSKY_FR0_REGNUM + 12},
173 {"fr13", CSKY_FR0_REGNUM + 13},
174 {"fr14", CSKY_FR0_REGNUM + 14},
175 {"fr15", CSKY_FR0_REGNUM + 15},
176 /* fr16~fr31. */
177 {"fr16", CSKY_FR16_REGNUM + 0},
178 {"fr17", CSKY_FR16_REGNUM + 1},
179 {"fr18", CSKY_FR16_REGNUM + 2},
180 {"fr19", CSKY_FR16_REGNUM + 3},
181 {"fr20", CSKY_FR16_REGNUM + 4},
182 {"fr21", CSKY_FR16_REGNUM + 5},
183 {"fr22", CSKY_FR16_REGNUM + 6},
184 {"fr23", CSKY_FR16_REGNUM + 7},
185 {"fr24", CSKY_FR16_REGNUM + 8},
186 {"fr25", CSKY_FR16_REGNUM + 9},
187 {"fr26", CSKY_FR16_REGNUM + 10},
188 {"fr27", CSKY_FR16_REGNUM + 11},
189 {"fr28", CSKY_FR16_REGNUM + 12},
190 {"fr29", CSKY_FR16_REGNUM + 13},
191 {"fr30", CSKY_FR16_REGNUM + 14},
192 {"fr31", CSKY_FR16_REGNUM + 15},
193 /* vr0~vr15. */
194 {"vr0", CSKY_VR0_REGNUM + 0},
195 {"vr1", CSKY_VR0_REGNUM + 1},
196 {"vr2", CSKY_VR0_REGNUM + 2},
197 {"vr3", CSKY_VR0_REGNUM + 3},
198 {"vr4", CSKY_VR0_REGNUM + 4},
199 {"vr5", CSKY_VR0_REGNUM + 5},
200 {"vr6", CSKY_VR0_REGNUM + 6},
201 {"vr7", CSKY_VR0_REGNUM + 7},
202 {"vr8", CSKY_VR0_REGNUM + 8},
203 {"vr9", CSKY_VR0_REGNUM + 9},
204 {"vr10", CSKY_VR0_REGNUM + 10},
205 {"vr11", CSKY_VR0_REGNUM + 11},
206 {"vr12", CSKY_VR0_REGNUM + 12},
207 {"vr13", CSKY_VR0_REGNUM + 13},
208 {"vr14", CSKY_VR0_REGNUM + 14},
209 {"vr15", CSKY_VR0_REGNUM + 15},
210 /* fpu control registers. */
211 {"fcr", CSKY_FCR_REGNUM + 0},
212 {"fid", CSKY_FCR_REGNUM + 1},
213 {"fesr", CSKY_FCR_REGNUM + 2},
214 };
215
216 static const struct csky_supported_tdesc_register csky_supported_ar_regs[] = {
217 {"ar0", CSKY_AR0_REGNUM + 0},
218 {"ar1", CSKY_AR0_REGNUM + 1},
219 {"ar2", CSKY_AR0_REGNUM + 2},
220 {"ar3", CSKY_AR0_REGNUM + 3},
221 {"ar4", CSKY_AR0_REGNUM + 4},
222 {"ar5", CSKY_AR0_REGNUM + 5},
223 {"ar6", CSKY_AR0_REGNUM + 6},
224 {"ar7", CSKY_AR0_REGNUM + 7},
225 {"ar8", CSKY_AR0_REGNUM + 8},
226 {"ar9", CSKY_AR0_REGNUM + 9},
227 {"ar10", CSKY_AR0_REGNUM + 10},
228 {"ar11", CSKY_AR0_REGNUM + 11},
229 {"ar12", CSKY_AR0_REGNUM + 12},
230 {"ar13", CSKY_AR0_REGNUM + 13},
231 {"ar14", CSKY_AR0_REGNUM + 14},
232 {"ar15", CSKY_AR0_REGNUM + 15},
233 };
234
235 static const struct csky_supported_tdesc_register csky_supported_bank0_regs[] = {
236 {"cr0", CSKY_CR0_REGNUM + 0},
237 {"cr1", CSKY_CR0_REGNUM + 1},
238 {"cr2", CSKY_CR0_REGNUM + 2},
239 {"cr3", CSKY_CR0_REGNUM + 3},
240 {"cr4", CSKY_CR0_REGNUM + 4},
241 {"cr5", CSKY_CR0_REGNUM + 5},
242 {"cr6", CSKY_CR0_REGNUM + 6},
243 {"cr7", CSKY_CR0_REGNUM + 7},
244 {"cr8", CSKY_CR0_REGNUM + 8},
245 {"cr9", CSKY_CR0_REGNUM + 9},
246 {"cr10", CSKY_CR0_REGNUM + 10},
247 {"cr11", CSKY_CR0_REGNUM + 11},
248 {"cr12", CSKY_CR0_REGNUM + 12},
249 {"cr13", CSKY_CR0_REGNUM + 13},
250 {"cr14", CSKY_CR0_REGNUM + 14},
251 {"cr15", CSKY_CR0_REGNUM + 15},
252 {"cr16", CSKY_CR0_REGNUM + 16},
253 {"cr17", CSKY_CR0_REGNUM + 17},
254 {"cr18", CSKY_CR0_REGNUM + 18},
255 {"cr19", CSKY_CR0_REGNUM + 19},
256 {"cr20", CSKY_CR0_REGNUM + 20},
257 {"cr21", CSKY_CR0_REGNUM + 21},
258 {"cr22", CSKY_CR0_REGNUM + 22},
259 {"cr23", CSKY_CR0_REGNUM + 23},
260 {"cr24", CSKY_CR0_REGNUM + 24},
261 {"cr25", CSKY_CR0_REGNUM + 25},
262 {"cr26", CSKY_CR0_REGNUM + 26},
263 {"cr27", CSKY_CR0_REGNUM + 27},
264 {"cr28", CSKY_CR0_REGNUM + 28},
265 {"cr29", CSKY_CR0_REGNUM + 29},
266 {"cr30", CSKY_CR0_REGNUM + 30},
267 {"cr31", CSKY_CR0_REGNUM + 31}
268 };
269
270 static const struct csky_supported_tdesc_register csky_supported_mmu_regs[] = {
271 {"mcr0", 128},
272 {"mcr2", 129},
273 {"mcr3", 130},
274 {"mcr4", 131},
275 {"mcr6", 132},
276 {"mcr8", 133},
277 {"mcr29", 134},
278 {"mcr30", 135},
279 {"mcr31", 136}
280 };
281
282 static const struct csky_supported_tdesc_register csky_supported_bank15_regs[] = {
283 {"cp15cp1", 253},
284 {"cp15cp5", 254},
285 {"cp15cp7", 255},
286 {"cp15cp9", 256},
287 {"cp15cp10", 257},
288 {"cp15cp11", 258},
289 {"cp15cp12", 259},
290 {"cp15cp13", 260},
291 {"cp15cp14", 261},
292 {"cp15cp15", 262},
293 {"cp15cp16", 263},
294 {"cp15cp17", 264},
295 {"cp15cp18", 265},
296 {"cp15cp19", 266},
297 {"cp15cp20", 267},
298 {"cp15cp21", 268},
299 {"cp15cp22", 269},
300 {"cp15cp23", 270},
301 {"cp15cp24", 271},
302 {"cp15cp25", 272},
303 {"cp15cp26", 273},
304 {"cp15cp27", 274},
305 {"cp15cp28", 275},
306 };
307
308 static const struct csky_supported_tdesc_register csky_supported_alias_regs[] = {
309 /* Alias register names for Bank0. */
310 {"psr", CSKY_CR0_REGNUM + 0},
311 {"vbr", CSKY_CR0_REGNUM + 1},
312 {"epsr", CSKY_CR0_REGNUM + 2},
313 {"fpsr", CSKY_CR0_REGNUM + 3},
314 {"epc", CSKY_CR0_REGNUM + 4},
315 {"fpc", CSKY_CR0_REGNUM + 5},
316 {"ss0", CSKY_CR0_REGNUM + 6},
317 {"ss1", CSKY_CR0_REGNUM + 7},
318 {"ss2", CSKY_CR0_REGNUM + 8},
319 {"ss3", CSKY_CR0_REGNUM + 9},
320 {"ss4", CSKY_CR0_REGNUM + 10},
321 {"gcr", CSKY_CR0_REGNUM + 11},
322 {"gsr", CSKY_CR0_REGNUM + 12},
323 {"cpuid", CSKY_CR0_REGNUM + 13},
324 {"ccr", CSKY_CR0_REGNUM + 18},
325 {"capr", CSKY_CR0_REGNUM + 19},
326 {"pacr", CSKY_CR0_REGNUM + 20},
327 {"prsr", CSKY_CR0_REGNUM + 21},
328 {"chr", CSKY_CR0_REGNUM + 31},
329 /* Alias register names for MMU. */
330 {"mir", 128},
331 {"mel0", 129},
332 {"mel1", 130},
333 {"meh", 131},
334 {"mpr", 132},
335 {"mcir", 133},
336 {"mpgd", 134},
337 {"msa0", 135},
338 {"msa1", 136},
339 /* Alias register names for Bank1. */
340 {"ebr", 190},
341 {"errlc", 195},
342 {"erraddr", 196},
343 {"errsts", 197},
344 {"errinj", 198},
345 {"usp", 203},
346 {"int_sp", 204},
347 {"itcmcr", 211},
348 {"dtcmcr", 212},
349 {"cindex", 215},
350 {"cdata0", 216},
351 {"cdata1", 217},
352 {"cdata2", 218},
353 {"cins", 220},
354 /* Alias register names for Bank3. */
355 {"sepsr", 221},
356 {"t_wssr", 221},
357 {"sevbr", 222},
358 {"t_wrcr", 222},
359 {"seepsr", 223},
360 {"seepc", 225},
361 {"nsssp", 227},
362 {"t_usp", 228},
363 {"dcr", 229},
364 {"t_pcr", 230},
365 };
366
367 /* Functions declaration. */
368
369 static const char *
370 csky_pseudo_register_name (struct gdbarch *gdbarch, int regno);
371
372 /* Get csky supported registers's count for tdesc xml. */
373
374 static int
375 csky_get_supported_tdesc_registers_count()
376 {
377 int count = 0;
378 count += ARRAY_SIZE (csky_supported_gpr_regs);
379 count += ARRAY_SIZE (csky_supported_fpu_regs);
380 count += ARRAY_SIZE (csky_supported_ar_regs);
381 count += ARRAY_SIZE (csky_supported_bank0_regs);
382 count += ARRAY_SIZE (csky_supported_mmu_regs);
383 count += ARRAY_SIZE (csky_supported_bank15_regs);
384 count += ARRAY_SIZE (csky_supported_alias_regs);
385 /* Bank1~Bank14, Bank16~Bank31. */
386 count += 32 * (14 + 16);
387 return count;
388 }
389
390 /* Return a supported register according to index. */
391
392 static const struct csky_supported_tdesc_register *
393 csky_get_supported_register_by_index (int index)
394 {
395 static struct csky_supported_tdesc_register tdesc_reg;
396 int count = 0;
397 int multi, remain;
398 int count_gpr = ARRAY_SIZE (csky_supported_gpr_regs);
399 int count_fpu = ARRAY_SIZE (csky_supported_fpu_regs);
400 int count_ar = ARRAY_SIZE (csky_supported_ar_regs);
401 int count_bank0 = ARRAY_SIZE (csky_supported_bank0_regs);
402 int count_mmu = ARRAY_SIZE (csky_supported_mmu_regs);
403 int count_bank15 = ARRAY_SIZE (csky_supported_bank15_regs);
404 int count_alias = ARRAY_SIZE (csky_supported_alias_regs);
405
406 count = count_gpr;
407 if (index < count)
408 return &csky_supported_gpr_regs[index];
409 if (index < (count + count_fpu))
410 return &csky_supported_fpu_regs[index - count];
411 count += count_fpu;
412 if (index < (count + count_ar))
413 return &csky_supported_ar_regs[index - count];
414 count += count_ar;
415 if (index < (count + count_bank0))
416 return &csky_supported_bank0_regs[index - count];
417 count += count_bank0;
418 if (index < (count + count_mmu))
419 return &csky_supported_mmu_regs[index - count];
420 count += count_mmu;
421 if (index < (count + count_bank15))
422 return &csky_supported_bank15_regs[index - count];
423 count += count_bank15;
424 if (index < (count + count_alias))
425 return &csky_supported_alias_regs[index - count];
426 count += count_alias;
427 index -= count;
428 multi = index / 32;
429 remain = index % 32;
430 switch (multi)
431 {
432 case 0: /* Bank1. */
433 {
434 sprintf (tdesc_reg.name, "cp1cr%d", remain);
435 tdesc_reg.num = 189 + remain;
436 }
437 break;
438 case 1: /* Bank2. */
439 {
440 sprintf (tdesc_reg.name, "cp2cr%d", remain);
441 tdesc_reg.num = 276 + remain;
442 }
443 break;
444 case 2: /* Bank3. */
445 {
446 sprintf (tdesc_reg.name, "cp3cr%d", remain);
447 tdesc_reg.num = 221 + remain;
448 }
449 break;
450 case 3: /* Bank4. */
451 case 4: /* Bank5. */
452 case 5: /* Bank6. */
453 case 6: /* Bank7. */
454 case 7: /* Bank8. */
455 case 8: /* Bank9. */
456 case 9: /* Bank10. */
457 case 10: /* Bank11. */
458 case 11: /* Bank12. */
459 case 12: /* Bank13. */
460 case 13: /* Bank14. */
461 {
462 /* Regitsers in Bank4~14 have continuous regno with start 308. */
463 sprintf (tdesc_reg.name, "cp%dcr%d", (multi + 1), remain);
464 tdesc_reg.num = 308 + ((multi - 3) * 32) + remain;
465 }
466 break;
467 case 14: /* Bank16. */
468 case 15: /* Bank17. */
469 case 16: /* Bank18. */
470 case 17: /* Bank19. */
471 case 18: /* Bank20. */
472 case 19: /* Bank21. */
473 case 20: /* Bank22. */
474 case 21: /* Bank23. */
475 case 22: /* Bank24. */
476 case 23: /* Bank25. */
477 case 24: /* Bank26. */
478 case 25: /* Bank27. */
479 case 26: /* Bank28. */
480 case 27: /* Bank29. */
481 case 28: /* Bank30. */
482 case 29: /* Bank31. */
483 {
484 /* Regitsers in Bank16~31 have continuous regno with start 660. */
485 sprintf (tdesc_reg.name, "cp%dcr%d", (multi + 2), remain);
486 tdesc_reg.num = 660 + ((multi - 14) * 32) + remain;
487 }
488 break;
489 default:
490 return NULL;
491 }
492 return &tdesc_reg;
493 }
494
495 /* Convenience function to print debug messages in prologue analysis. */
496
497 static void
498 print_savedreg_msg (int regno, int offsets[], bool print_continuing)
499 {
500 gdb_printf (gdb_stdlog, "csky: r%d saved at offset 0x%x\n",
501 regno, offsets[regno]);
502 if (print_continuing)
503 gdb_printf (gdb_stdlog, "csky: continuing\n");
504 }
505
506 /* Check whether the instruction at ADDR is 16-bit or not. */
507
508 static int
509 csky_pc_is_csky16 (struct gdbarch *gdbarch, CORE_ADDR addr)
510 {
511 gdb_byte target_mem[2];
512 int status;
513 unsigned int insn;
514 int ret = 1;
515 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
516
517 status = target_read_memory (addr, target_mem, 2);
518 /* Assume a 16-bit instruction if we can't read memory. */
519 if (status)
520 return 1;
521
522 /* Get instruction from memory. */
523 insn = extract_unsigned_integer (target_mem, 2, byte_order);
524 if ((insn & CSKY_32_INSN_MASK) == CSKY_32_INSN_MASK)
525 ret = 0;
526 else if (insn == CSKY_BKPT_INSN)
527 {
528 /* Check for 32-bit bkpt instruction which is all 0. */
529 status = target_read_memory (addr + 2, target_mem, 2);
530 if (status)
531 return 1;
532
533 insn = extract_unsigned_integer (target_mem, 2, byte_order);
534 if (insn == CSKY_BKPT_INSN)
535 ret = 0;
536 }
537 return ret;
538 }
539
540 /* Get one instruction at ADDR and store it in INSN. Return 2 for
541 a 16-bit instruction or 4 for a 32-bit instruction. */
542
543 static int
544 csky_get_insn (struct gdbarch *gdbarch, CORE_ADDR addr, unsigned int *insn)
545 {
546 gdb_byte target_mem[2];
547 unsigned int insn_type;
548 int status;
549 int insn_len = 2;
550 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
551
552 status = target_read_memory (addr, target_mem, 2);
553 if (status)
554 memory_error (TARGET_XFER_E_IO, addr);
555
556 insn_type = extract_unsigned_integer (target_mem, 2, byte_order);
557 if (CSKY_32_INSN_MASK == (insn_type & CSKY_32_INSN_MASK))
558 {
559 status = target_read_memory (addr + 2, target_mem, 2);
560 if (status)
561 memory_error (TARGET_XFER_E_IO, addr);
562 insn_type = ((insn_type << 16)
563 | extract_unsigned_integer (target_mem, 2, byte_order));
564 insn_len = 4;
565 }
566 *insn = insn_type;
567 return insn_len;
568 }
569
570 /* Implement the read_pc gdbarch method. */
571
572 static CORE_ADDR
573 csky_read_pc (readable_regcache *regcache)
574 {
575 ULONGEST pc;
576 regcache->cooked_read (CSKY_PC_REGNUM, &pc);
577 return pc;
578 }
579
580 /* Implement the write_pc gdbarch method. */
581
582 static void
583 csky_write_pc (regcache *regcache, CORE_ADDR val)
584 {
585 regcache_cooked_write_unsigned (regcache, CSKY_PC_REGNUM, val);
586 }
587
588 /* C-Sky ABI register names. */
589
590 static const char * const csky_register_names[] =
591 {
592 /* General registers 0 - 31. */
593 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
594 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
595 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
596 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
597
598 /* DSP hilo registers 36 and 37. */
599 "", "", "", "", "hi", "lo", "", "",
600
601 /* FPU/VPU general registers 40 - 71. */
602 "fr0", "fr1", "fr2", "fr3", "fr4", "fr5", "fr6", "fr7",
603 "fr8", "fr9", "fr10", "fr11", "fr12", "fr13", "fr14", "fr15",
604 "vr0", "vr1", "vr2", "vr3", "vr4", "vr5", "vr6", "vr7",
605 "vr8", "vr9", "vr10", "vr11", "vr12", "vr13", "vr14", "vr15",
606
607 /* Program counter 72. */
608 "pc",
609
610 /* Optional registers (ar) 73 - 88. */
611 "ar0", "ar1", "ar2", "ar3", "ar4", "ar5", "ar6", "ar7",
612 "ar8", "ar9", "ar10", "ar11", "ar12", "ar13", "ar14", "ar15",
613
614 /* Control registers (cr) 89 - 119. */
615 "psr", "vbr", "epsr", "fpsr", "epc", "fpc", "ss0", "ss1",
616 "ss2", "ss3", "ss4", "gcr", "gsr", "cr13", "cr14", "cr15",
617 "cr16", "cr17", "cr18", "cr19", "cr20", "cr21", "cr22", "cr23",
618 "cr24", "cr25", "cr26", "cr27", "cr28", "cr29", "cr30", "cr31",
619
620 /* FPU/VPU control registers 121 ~ 123. */
621 /* User sp 127. */
622 "fid", "fcr", "fesr", "", "", "", "usp",
623
624 /* MMU control registers: 128 - 136. */
625 "mcr0", "mcr2", "mcr3", "mcr4", "mcr6", "mcr8", "mcr29", "mcr30",
626 "mcr31", "", "", "",
627
628 /* Profiling control registers 140 - 143. */
629 /* Profiling software general registers 144 - 157. */
630 "profcr0", "profcr1", "profcr2", "profcr3", "profsgr0", "profsgr1",
631 "profsgr2", "profsgr3", "profsgr4", "profsgr5", "profsgr6", "profsgr7",
632 "profsgr8", "profsgr9", "profsgr10","profsgr11","profsgr12", "profsgr13",
633 "", "",
634
635 /* Profiling architecture general registers 160 - 174. */
636 "profagr0", "profagr1", "profagr2", "profagr3", "profagr4", "profagr5",
637 "profagr6", "profagr7", "profagr8", "profagr9", "profagr10","profagr11",
638 "profagr12","profagr13","profagr14", "",
639
640 /* Profiling extension general registers 176 - 188. */
641 "profxgr0", "profxgr1", "profxgr2", "profxgr3", "profxgr4", "profxgr5",
642 "profxgr6", "profxgr7", "profxgr8", "profxgr9", "profxgr10","profxgr11",
643 "profxgr12",
644
645 /* Control registers in bank1. */
646 "", "", "", "", "", "", "", "",
647 "", "", "", "", "", "", "", "",
648 "cp1cr16", "cp1cr17", "cp1cr18", "cp1cr19", "cp1cr20", "", "", "",
649 "", "", "", "", "", "", "", "",
650
651 /* Control registers in bank3 (ICE). */
652 "sepsr", "sevbr", "seepsr", "", "seepc", "", "nsssp", "seusp",
653 "sedcr", "", "", "", "", "", "", "",
654 "", "", "", "", "", "", "", "",
655 "", "", "", "", "", "", "", ""
656 };
657
658 /* Implement the register_name gdbarch method. */
659
660 static const char *
661 csky_register_name (struct gdbarch *gdbarch, int reg_nr)
662 {
663 if (reg_nr >= gdbarch_num_regs (gdbarch))
664 return csky_pseudo_register_name (gdbarch, reg_nr);
665
666 if (tdesc_has_registers (gdbarch_target_desc (gdbarch)))
667 return tdesc_register_name (gdbarch, reg_nr);
668
669 return csky_register_names[reg_nr];
670 }
671
672 /* Construct vector type for vrx registers. */
673
674 static struct type *
675 csky_vector_type (struct gdbarch *gdbarch)
676 {
677 const struct builtin_type *bt = builtin_type (gdbarch);
678
679 struct type *t;
680
681 t = arch_composite_type (gdbarch, "__gdb_builtin_type_vec128i",
682 TYPE_CODE_UNION);
683
684 append_composite_type_field (t, "u32",
685 init_vector_type (bt->builtin_int32, 4));
686 append_composite_type_field (t, "u16",
687 init_vector_type (bt->builtin_int16, 8));
688 append_composite_type_field (t, "u8",
689 init_vector_type (bt->builtin_int8, 16));
690
691 t->set_is_vector (true);
692 t->set_name ("builtin_type_vec128i");
693
694 return t;
695 }
696
697 /* Return the GDB type object for the "standard" data type
698 of data in register N. */
699
700 static struct type *
701 csky_register_type (struct gdbarch *gdbarch, int reg_nr)
702 {
703 int num_regs = gdbarch_num_regs (gdbarch);
704 csky_gdbarch_tdep *tdep
705 = gdbarch_tdep<csky_gdbarch_tdep> (gdbarch);
706
707 if (tdep->fv_pseudo_registers_count)
708 {
709 if ((reg_nr >= num_regs)
710 && (reg_nr < (num_regs + tdep->fv_pseudo_registers_count)))
711 return builtin_type (gdbarch)->builtin_int32;
712 }
713
714 /* Vector register has 128 bits, and only in ck810. Just return
715 csky_vector_type(), not check tdesc_has_registers(), is in case
716 of some GDB stub does not describe type for Vector resgisters
717 in the target-description-xml. */
718 if ((reg_nr >= CSKY_VR0_REGNUM) && (reg_nr <= CSKY_VR0_REGNUM + 15))
719 return csky_vector_type (gdbarch);
720
721 /* If type has been described in tdesc-xml, use it. */
722 if (tdesc_has_registers (gdbarch_target_desc (gdbarch)))
723 {
724 struct type *tdesc_t = tdesc_register_type (gdbarch, reg_nr);
725 if (tdesc_t)
726 return tdesc_t;
727 }
728
729 /* PC, EPC, FPC is a text pointer. */
730 if ((reg_nr == CSKY_PC_REGNUM) || (reg_nr == CSKY_EPC_REGNUM)
731 || (reg_nr == CSKY_FPC_REGNUM))
732 return builtin_type (gdbarch)->builtin_func_ptr;
733
734 /* VBR is a data pointer. */
735 if (reg_nr == CSKY_VBR_REGNUM)
736 return builtin_type (gdbarch)->builtin_data_ptr;
737
738 /* Float register has 64 bits, and only in ck810. */
739 if ((reg_nr >=CSKY_FR0_REGNUM) && (reg_nr <= CSKY_FR0_REGNUM + 15))
740 return arch_float_type (gdbarch, 64, "builtin_type_csky_ext",
741 floatformats_ieee_double);
742
743 /* Profiling general register has 48 bits, we use 64bit. */
744 if ((reg_nr >= CSKY_PROFGR_REGNUM) && (reg_nr <= CSKY_PROFGR_REGNUM + 44))
745 return builtin_type (gdbarch)->builtin_uint64;
746
747 if (reg_nr == CSKY_SP_REGNUM)
748 return builtin_type (gdbarch)->builtin_data_ptr;
749
750 /* Others are 32 bits. */
751 return builtin_type (gdbarch)->builtin_int32;
752 }
753
754 /* Data structure to marshall items in a dummy stack frame when
755 calling a function in the inferior. */
756
757 struct csky_stack_item
758 {
759 csky_stack_item (int len_, const gdb_byte *data_)
760 : len (len_), data (data_)
761 {}
762
763 int len;
764 const gdb_byte *data;
765 };
766
767 /* Implement the push_dummy_call gdbarch method. */
768
769 static CORE_ADDR
770 csky_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
771 struct regcache *regcache, CORE_ADDR bp_addr,
772 int nargs, struct value **args, CORE_ADDR sp,
773 function_call_return_method return_method,
774 CORE_ADDR struct_addr)
775 {
776 int argnum;
777 int argreg = CSKY_ABI_A0_REGNUM;
778 int last_arg_regnum = CSKY_ABI_LAST_ARG_REGNUM;
779 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
780 std::vector<csky_stack_item> stack_items;
781
782 /* Set the return address. For CSKY, the return breakpoint is
783 always at BP_ADDR. */
784 regcache_cooked_write_unsigned (regcache, CSKY_LR_REGNUM, bp_addr);
785
786 /* The struct_return pointer occupies the first parameter
787 passing register. */
788 if (return_method == return_method_struct)
789 {
790 if (csky_debug)
791 {
792 gdb_printf (gdb_stdlog,
793 "csky: struct return in %s = %s\n",
794 gdbarch_register_name (gdbarch, argreg),
795 paddress (gdbarch, struct_addr));
796 }
797 regcache_cooked_write_unsigned (regcache, argreg, struct_addr);
798 argreg++;
799 }
800
801 /* Put parameters into argument registers in REGCACHE.
802 In ABI argument registers are r0 through r3. */
803 for (argnum = 0; argnum < nargs; argnum++)
804 {
805 int len;
806 struct type *arg_type;
807 const gdb_byte *val;
808
809 arg_type = check_typedef (value_type (args[argnum]));
810 len = arg_type->length ();
811 val = value_contents (args[argnum]).data ();
812
813 /* Copy the argument to argument registers or the dummy stack.
814 Large arguments are split between registers and stack.
815
816 If len < 4, there is no need to worry about endianness since
817 the arguments will always be stored in the low address. */
818 if (len < 4)
819 {
820 CORE_ADDR regval
821 = extract_unsigned_integer (val, len, byte_order);
822 regcache_cooked_write_unsigned (regcache, argreg, regval);
823 argreg++;
824 }
825 else
826 {
827 while (len > 0)
828 {
829 int partial_len = len < 4 ? len : 4;
830 if (argreg <= last_arg_regnum)
831 {
832 /* The argument is passed in an argument register. */
833 CORE_ADDR regval
834 = extract_unsigned_integer (val, partial_len,
835 byte_order);
836 if (byte_order == BFD_ENDIAN_BIG)
837 regval <<= (4 - partial_len) * 8;
838
839 /* Put regval into register in REGCACHE. */
840 regcache_cooked_write_unsigned (regcache, argreg,
841 regval);
842 argreg++;
843 }
844 else
845 {
846 /* The argument should be pushed onto the dummy stack. */
847 stack_items.emplace_back (4, val);
848 }
849 len -= partial_len;
850 val += partial_len;
851 }
852 }
853 }
854
855 /* Transfer the dummy stack frame to the target. */
856 std::vector<csky_stack_item>::reverse_iterator iter;
857 for (iter = stack_items.rbegin (); iter != stack_items.rend (); ++iter)
858 {
859 sp -= iter->len;
860 write_memory (sp, iter->data, iter->len);
861 }
862
863 /* Finally, update the SP register. */
864 regcache_cooked_write_unsigned (regcache, CSKY_SP_REGNUM, sp);
865 return sp;
866 }
867
868 /* Implement the return_value gdbarch method. */
869
870 static enum return_value_convention
871 csky_return_value (struct gdbarch *gdbarch, struct value *function,
872 struct type *valtype, struct regcache *regcache,
873 gdb_byte *readbuf, const gdb_byte *writebuf)
874 {
875 CORE_ADDR regval;
876 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
877 int len = valtype->length ();
878 unsigned int ret_regnum = CSKY_RET_REGNUM;
879
880 /* Csky abi specifies that return values larger than 8 bytes
881 are put on the stack. */
882 if (len > 8)
883 return RETURN_VALUE_STRUCT_CONVENTION;
884 else
885 {
886 if (readbuf != NULL)
887 {
888 ULONGEST tmp;
889 /* By using store_unsigned_integer we avoid having to do
890 anything special for small big-endian values. */
891 regcache->cooked_read (ret_regnum, &tmp);
892 store_unsigned_integer (readbuf, (len > 4 ? 4 : len),
893 byte_order, tmp);
894 if (len > 4)
895 {
896 regcache->cooked_read (ret_regnum + 1, &tmp);
897 store_unsigned_integer (readbuf + 4, 4, byte_order, tmp);
898 }
899 }
900 if (writebuf != NULL)
901 {
902 regval = extract_unsigned_integer (writebuf, len > 4 ? 4 : len,
903 byte_order);
904 regcache_cooked_write_unsigned (regcache, ret_regnum, regval);
905 if (len > 4)
906 {
907 regval = extract_unsigned_integer ((gdb_byte *) writebuf + 4,
908 4, byte_order);
909 regcache_cooked_write_unsigned (regcache, ret_regnum + 1,
910 regval);
911 }
912
913 }
914 return RETURN_VALUE_REGISTER_CONVENTION;
915 }
916 }
917
918 /* Implement the frame_align gdbarch method.
919
920 Adjust the address downward (direction of stack growth) so that it
921 is correctly aligned for a new stack frame. */
922
923 static CORE_ADDR
924 csky_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
925 {
926 return align_down (addr, 4);
927 }
928
929 /* Unwind cache used for gdbarch fallback unwinder. */
930
931 struct csky_unwind_cache
932 {
933 /* The stack pointer at the time this frame was created; i.e. the
934 caller's stack pointer when this function was called. It is used
935 to identify this frame. */
936 CORE_ADDR prev_sp;
937
938 /* The frame base for this frame is just prev_sp - frame size.
939 FRAMESIZE is the distance from the frame pointer to the
940 initial stack pointer. */
941 int framesize;
942
943 /* The register used to hold the frame pointer for this frame. */
944 int framereg;
945
946 /* Saved register offsets. */
947 trad_frame_saved_reg *saved_regs;
948 };
949
950 /* Do prologue analysis, returning the PC of the first instruction
951 after the function prologue. */
952
953 static CORE_ADDR
954 csky_analyze_prologue (struct gdbarch *gdbarch,
955 CORE_ADDR start_pc,
956 CORE_ADDR limit_pc,
957 CORE_ADDR end_pc,
958 frame_info_ptr this_frame,
959 struct csky_unwind_cache *this_cache,
960 lr_type_t lr_type)
961 {
962 CORE_ADDR addr;
963 unsigned int insn, rn;
964 int framesize = 0;
965 int stacksize = 0;
966 int register_offsets[CSKY_NUM_GREGS_SAVED_GREGS];
967 int insn_len;
968 /* For adjusting fp. */
969 int is_fp_saved = 0;
970 int adjust_fp = 0;
971
972 /* REGISTER_OFFSETS will contain offsets from the top of the frame
973 (NOT the frame pointer) for the various saved registers, or -1
974 if the register is not saved. */
975 for (rn = 0; rn < CSKY_NUM_GREGS_SAVED_GREGS; rn++)
976 register_offsets[rn] = -1;
977
978 /* Analyze the prologue. Things we determine from analyzing the
979 prologue include the size of the frame and which registers are
980 saved (and where). */
981 if (csky_debug)
982 {
983 gdb_printf (gdb_stdlog,
984 "csky: Scanning prologue: start_pc = 0x%x,"
985 "limit_pc = 0x%x\n", (unsigned int) start_pc,
986 (unsigned int) limit_pc);
987 }
988
989 /* Default to 16 bit instruction. */
990 insn_len = 2;
991 stacksize = 0;
992 for (addr = start_pc; addr < limit_pc; addr += insn_len)
993 {
994 /* Get next insn. */
995 insn_len = csky_get_insn (gdbarch, addr, &insn);
996
997 /* Check if 32 bit. */
998 if (insn_len == 4)
999 {
1000 /* subi32 sp,sp oimm12. */
1001 if (CSKY_32_IS_SUBI0 (insn))
1002 {
1003 /* Got oimm12. */
1004 int offset = CSKY_32_SUBI_IMM (insn);
1005 if (csky_debug)
1006 {
1007 gdb_printf (gdb_stdlog,
1008 "csky: got subi sp,%d; continuing\n",
1009 offset);
1010 }
1011 stacksize += offset;
1012 continue;
1013 }
1014 /* stm32 ry-rz,(sp). */
1015 else if (CSKY_32_IS_STMx0 (insn))
1016 {
1017 /* Spill register(s). */
1018 int start_register;
1019 int reg_count;
1020 int offset;
1021
1022 /* BIG WARNING! The CKCore ABI does not restrict functions
1023 to taking only one stack allocation. Therefore, when
1024 we save a register, we record the offset of where it was
1025 saved relative to the current stacksize. This will
1026 then give an offset from the SP upon entry to our
1027 function. Remember, stacksize is NOT constant until
1028 we're done scanning the prologue. */
1029 start_register = CSKY_32_STM_VAL_REGNUM (insn);
1030 reg_count = CSKY_32_STM_SIZE (insn);
1031 if (csky_debug)
1032 {
1033 gdb_printf (gdb_stdlog,
1034 "csky: got stm r%d-r%d,(sp)\n",
1035 start_register,
1036 start_register + reg_count);
1037 }
1038
1039 for (rn = start_register, offset = 0;
1040 rn <= start_register + reg_count;
1041 rn++, offset += 4)
1042 {
1043 register_offsets[rn] = stacksize - offset;
1044 if (csky_debug)
1045 {
1046 gdb_printf (gdb_stdlog,
1047 "csky: r%d saved at 0x%x"
1048 " (offset %d)\n",
1049 rn, register_offsets[rn],
1050 offset);
1051 }
1052 }
1053 if (csky_debug)
1054 gdb_printf (gdb_stdlog, "csky: continuing\n");
1055 continue;
1056 }
1057 /* stw ry,(sp,disp). */
1058 else if (CSKY_32_IS_STWx0 (insn))
1059 {
1060 /* Spill register: see note for IS_STM above. */
1061 int disp;
1062
1063 rn = CSKY_32_ST_VAL_REGNUM (insn);
1064 disp = CSKY_32_ST_OFFSET (insn);
1065 register_offsets[rn] = stacksize - disp;
1066 if (csky_debug)
1067 print_savedreg_msg (rn, register_offsets, true);
1068 continue;
1069 }
1070 else if (CSKY_32_IS_MOV_FP_SP (insn))
1071 {
1072 /* SP is saved to FP reg, means code afer prologue may
1073 modify SP. */
1074 is_fp_saved = 1;
1075 adjust_fp = stacksize;
1076 continue;
1077 }
1078 else if (CSKY_32_IS_MFCR_EPSR (insn))
1079 {
1080 unsigned int insn2;
1081 addr += 4;
1082 int mfcr_regnum = insn & 0x1f;
1083 insn_len = csky_get_insn (gdbarch, addr, &insn2);
1084 if (insn_len == 2)
1085 {
1086 int stw_regnum = (insn2 >> 5) & 0x7;
1087 if (CSKY_16_IS_STWx0 (insn2) && (mfcr_regnum == stw_regnum))
1088 {
1089 int offset;
1090
1091 /* CSKY_EPSR_REGNUM. */
1092 rn = CSKY_NUM_GREGS;
1093 offset = CSKY_16_STWx0_OFFSET (insn2);
1094 register_offsets[rn] = stacksize - offset;
1095 if (csky_debug)
1096 print_savedreg_msg (rn, register_offsets, true);
1097 continue;
1098 }
1099 break;
1100 }
1101 else
1102 {
1103 /* INSN_LEN == 4. */
1104 int stw_regnum = (insn2 >> 21) & 0x1f;
1105 if (CSKY_32_IS_STWx0 (insn2) && (mfcr_regnum == stw_regnum))
1106 {
1107 int offset;
1108
1109 /* CSKY_EPSR_REGNUM. */
1110 rn = CSKY_NUM_GREGS;
1111 offset = CSKY_32_ST_OFFSET (insn2);
1112 register_offsets[rn] = framesize - offset;
1113 if (csky_debug)
1114 print_savedreg_msg (rn, register_offsets, true);
1115 continue;
1116 }
1117 break;
1118 }
1119 }
1120 else if (CSKY_32_IS_MFCR_FPSR (insn))
1121 {
1122 unsigned int insn2;
1123 addr += 4;
1124 int mfcr_regnum = insn & 0x1f;
1125 insn_len = csky_get_insn (gdbarch, addr, &insn2);
1126 if (insn_len == 2)
1127 {
1128 int stw_regnum = (insn2 >> 5) & 0x7;
1129 if (CSKY_16_IS_STWx0 (insn2) && (mfcr_regnum
1130 == stw_regnum))
1131 {
1132 int offset;
1133
1134 /* CSKY_FPSR_REGNUM. */
1135 rn = CSKY_NUM_GREGS + 1;
1136 offset = CSKY_16_STWx0_OFFSET (insn2);
1137 register_offsets[rn] = stacksize - offset;
1138 if (csky_debug)
1139 print_savedreg_msg (rn, register_offsets, true);
1140 continue;
1141 }
1142 break;
1143 }
1144 else
1145 {
1146 /* INSN_LEN == 4. */
1147 int stw_regnum = (insn2 >> 21) & 0x1f;
1148 if (CSKY_32_IS_STWx0 (insn2) && (mfcr_regnum == stw_regnum))
1149 {
1150 int offset;
1151
1152 /* CSKY_FPSR_REGNUM. */
1153 rn = CSKY_NUM_GREGS + 1;
1154 offset = CSKY_32_ST_OFFSET (insn2);
1155 register_offsets[rn] = framesize - offset;
1156 if (csky_debug)
1157 print_savedreg_msg (rn, register_offsets, true);
1158 continue;
1159 }
1160 break;
1161 }
1162 }
1163 else if (CSKY_32_IS_MFCR_EPC (insn))
1164 {
1165 unsigned int insn2;
1166 addr += 4;
1167 int mfcr_regnum = insn & 0x1f;
1168 insn_len = csky_get_insn (gdbarch, addr, &insn2);
1169 if (insn_len == 2)
1170 {
1171 int stw_regnum = (insn2 >> 5) & 0x7;
1172 if (CSKY_16_IS_STWx0 (insn2) && (mfcr_regnum == stw_regnum))
1173 {
1174 int offset;
1175
1176 /* CSKY_EPC_REGNUM. */
1177 rn = CSKY_NUM_GREGS + 2;
1178 offset = CSKY_16_STWx0_OFFSET (insn2);
1179 register_offsets[rn] = stacksize - offset;
1180 if (csky_debug)
1181 print_savedreg_msg (rn, register_offsets, true);
1182 continue;
1183 }
1184 break;
1185 }
1186 else
1187 {
1188 /* INSN_LEN == 4. */
1189 int stw_regnum = (insn2 >> 21) & 0x1f;
1190 if (CSKY_32_IS_STWx0 (insn2) && (mfcr_regnum == stw_regnum))
1191 {
1192 int offset;
1193
1194 /* CSKY_EPC_REGNUM. */
1195 rn = CSKY_NUM_GREGS + 2;
1196 offset = CSKY_32_ST_OFFSET (insn2);
1197 register_offsets[rn] = framesize - offset;
1198 if (csky_debug)
1199 print_savedreg_msg (rn, register_offsets, true);
1200 continue;
1201 }
1202 break;
1203 }
1204 }
1205 else if (CSKY_32_IS_MFCR_FPC (insn))
1206 {
1207 unsigned int insn2;
1208 addr += 4;
1209 int mfcr_regnum = insn & 0x1f;
1210 insn_len = csky_get_insn (gdbarch, addr, &insn2);
1211 if (insn_len == 2)
1212 {
1213 int stw_regnum = (insn2 >> 5) & 0x7;
1214 if (CSKY_16_IS_STWx0 (insn2) && (mfcr_regnum == stw_regnum))
1215 {
1216 int offset;
1217
1218 /* CSKY_FPC_REGNUM. */
1219 rn = CSKY_NUM_GREGS + 3;
1220 offset = CSKY_16_STWx0_OFFSET (insn2);
1221 register_offsets[rn] = stacksize - offset;
1222 if (csky_debug)
1223 print_savedreg_msg (rn, register_offsets, true);
1224 continue;
1225 }
1226 break;
1227 }
1228 else
1229 {
1230 /* INSN_LEN == 4. */
1231 int stw_regnum = (insn2 >> 21) & 0x1f;
1232 if (CSKY_32_IS_STWx0 (insn2) && (mfcr_regnum == stw_regnum))
1233 {
1234 int offset;
1235
1236 /* CSKY_FPC_REGNUM. */
1237 rn = CSKY_NUM_GREGS + 3;
1238 offset = CSKY_32_ST_OFFSET (insn2);
1239 register_offsets[rn] = framesize - offset;
1240 if (csky_debug)
1241 print_savedreg_msg (rn, register_offsets, true);
1242 continue;
1243 }
1244 break;
1245 }
1246 }
1247 else if (CSKY_32_IS_PUSH (insn))
1248 {
1249 /* Push for 32_bit. */
1250 if (CSKY_32_IS_PUSH_R29 (insn))
1251 {
1252 stacksize += 4;
1253 register_offsets[29] = stacksize;
1254 if (csky_debug)
1255 print_savedreg_msg (29, register_offsets, false);
1256 }
1257 if (CSKY_32_PUSH_LIST2 (insn))
1258 {
1259 int num = CSKY_32_PUSH_LIST2 (insn);
1260 int tmp = 0;
1261 stacksize += num * 4;
1262 if (csky_debug)
1263 {
1264 gdb_printf (gdb_stdlog,
1265 "csky: push regs_array: r16-r%d\n",
1266 16 + num - 1);
1267 }
1268 for (rn = 16; rn <= 16 + num - 1; rn++)
1269 {
1270 register_offsets[rn] = stacksize - tmp;
1271 if (csky_debug)
1272 {
1273 gdb_printf (gdb_stdlog,
1274 "csky: r%d saved at 0x%x"
1275 " (offset %d)\n", rn,
1276 register_offsets[rn], tmp);
1277 }
1278 tmp += 4;
1279 }
1280 }
1281 if (CSKY_32_IS_PUSH_R15 (insn))
1282 {
1283 stacksize += 4;
1284 register_offsets[15] = stacksize;
1285 if (csky_debug)
1286 print_savedreg_msg (15, register_offsets, false);
1287 }
1288 if (CSKY_32_PUSH_LIST1 (insn))
1289 {
1290 int num = CSKY_32_PUSH_LIST1 (insn);
1291 int tmp = 0;
1292 stacksize += num * 4;
1293 if (csky_debug)
1294 {
1295 gdb_printf (gdb_stdlog,
1296 "csky: push regs_array: r4-r%d\n",
1297 4 + num - 1);
1298 }
1299 for (rn = 4; rn <= 4 + num - 1; rn++)
1300 {
1301 register_offsets[rn] = stacksize - tmp;
1302 if (csky_debug)
1303 {
1304 gdb_printf (gdb_stdlog,
1305 "csky: r%d saved at 0x%x"
1306 " (offset %d)\n", rn,
1307 register_offsets[rn], tmp);
1308 }
1309 tmp += 4;
1310 }
1311 }
1312
1313 framesize = stacksize;
1314 if (csky_debug)
1315 gdb_printf (gdb_stdlog, "csky: continuing\n");
1316 continue;
1317 }
1318 else if (CSKY_32_IS_LRW4 (insn) || CSKY_32_IS_MOVI4 (insn)
1319 || CSKY_32_IS_MOVIH4 (insn) || CSKY_32_IS_BMASKI4 (insn))
1320 {
1321 int adjust = 0;
1322 int offset = 0;
1323 unsigned int insn2;
1324
1325 if (csky_debug)
1326 {
1327 gdb_printf (gdb_stdlog,
1328 "csky: looking at large frame\n");
1329 }
1330 if (CSKY_32_IS_LRW4 (insn))
1331 {
1332 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1333 int literal_addr = (addr + ((insn & 0xffff) << 2))
1334 & 0xfffffffc;
1335 adjust = read_memory_unsigned_integer (literal_addr, 4,
1336 byte_order);
1337 }
1338 else if (CSKY_32_IS_MOVI4 (insn))
1339 adjust = (insn & 0xffff);
1340 else if (CSKY_32_IS_MOVIH4 (insn))
1341 adjust = (insn & 0xffff) << 16;
1342 else
1343 {
1344 /* CSKY_32_IS_BMASKI4 (insn). */
1345 adjust = (1 << (((insn & 0x3e00000) >> 21) + 1)) - 1;
1346 }
1347
1348 if (csky_debug)
1349 {
1350 gdb_printf (gdb_stdlog,
1351 "csky: base stacksize=0x%x\n", adjust);
1352
1353 /* May have zero or more insns which modify r4. */
1354 gdb_printf (gdb_stdlog,
1355 "csky: looking for r4 adjusters...\n");
1356 }
1357
1358 offset = 4;
1359 insn_len = csky_get_insn (gdbarch, addr + offset, &insn2);
1360 while (CSKY_IS_R4_ADJUSTER (insn2))
1361 {
1362 if (CSKY_32_IS_ADDI4 (insn2))
1363 {
1364 int imm = (insn2 & 0xfff) + 1;
1365 adjust += imm;
1366 if (csky_debug)
1367 {
1368 gdb_printf (gdb_stdlog,
1369 "csky: addi r4,%d\n", imm);
1370 }
1371 }
1372 else if (CSKY_32_IS_SUBI4 (insn2))
1373 {
1374 int imm = (insn2 & 0xfff) + 1;
1375 adjust -= imm;
1376 if (csky_debug)
1377 {
1378 gdb_printf (gdb_stdlog,
1379 "csky: subi r4,%d\n", imm);
1380 }
1381 }
1382 else if (CSKY_32_IS_NOR4 (insn2))
1383 {
1384 adjust = ~adjust;
1385 if (csky_debug)
1386 {
1387 gdb_printf (gdb_stdlog,
1388 "csky: nor r4,r4,r4\n");
1389 }
1390 }
1391 else if (CSKY_32_IS_ROTLI4 (insn2))
1392 {
1393 int imm = ((insn2 >> 21) & 0x1f);
1394 int temp = adjust >> (32 - imm);
1395 adjust <<= imm;
1396 adjust |= temp;
1397 if (csky_debug)
1398 {
1399 gdb_printf (gdb_stdlog,
1400 "csky: rotli r4,r4,%d\n", imm);
1401 }
1402 }
1403 else if (CSKY_32_IS_LISI4 (insn2))
1404 {
1405 int imm = ((insn2 >> 21) & 0x1f);
1406 adjust <<= imm;
1407 if (csky_debug)
1408 {
1409 gdb_printf (gdb_stdlog,
1410 "csky: lsli r4,r4,%d\n", imm);
1411 }
1412 }
1413 else if (CSKY_32_IS_BSETI4 (insn2))
1414 {
1415 int imm = ((insn2 >> 21) & 0x1f);
1416 adjust |= (1 << imm);
1417 if (csky_debug)
1418 {
1419 gdb_printf (gdb_stdlog,
1420 "csky: bseti r4,r4 %d\n", imm);
1421 }
1422 }
1423 else if (CSKY_32_IS_BCLRI4 (insn2))
1424 {
1425 int imm = ((insn2 >> 21) & 0x1f);
1426 adjust &= ~(1 << imm);
1427 if (csky_debug)
1428 {
1429 gdb_printf (gdb_stdlog,
1430 "csky: bclri r4,r4 %d\n", imm);
1431 }
1432 }
1433 else if (CSKY_32_IS_IXH4 (insn2))
1434 {
1435 adjust *= 3;
1436 if (csky_debug)
1437 {
1438 gdb_printf (gdb_stdlog,
1439 "csky: ixh r4,r4,r4\n");
1440 }
1441 }
1442 else if (CSKY_32_IS_IXW4 (insn2))
1443 {
1444 adjust *= 5;
1445 if (csky_debug)
1446 {
1447 gdb_printf (gdb_stdlog,
1448 "csky: ixw r4,r4,r4\n");
1449 }
1450 }
1451 else if (CSKY_16_IS_ADDI4 (insn2))
1452 {
1453 int imm = (insn2 & 0xff) + 1;
1454 adjust += imm;
1455 if (csky_debug)
1456 {
1457 gdb_printf (gdb_stdlog,
1458 "csky: addi r4,%d\n", imm);
1459 }
1460 }
1461 else if (CSKY_16_IS_SUBI4 (insn2))
1462 {
1463 int imm = (insn2 & 0xff) + 1;
1464 adjust -= imm;
1465 if (csky_debug)
1466 {
1467 gdb_printf (gdb_stdlog,
1468 "csky: subi r4,%d\n", imm);
1469 }
1470 }
1471 else if (CSKY_16_IS_NOR4 (insn2))
1472 {
1473 adjust = ~adjust;
1474 if (csky_debug)
1475 {
1476 gdb_printf (gdb_stdlog,
1477 "csky: nor r4,r4\n");
1478 }
1479 }
1480 else if (CSKY_16_IS_BSETI4 (insn2))
1481 {
1482 int imm = (insn2 & 0x1f);
1483 adjust |= (1 << imm);
1484 if (csky_debug)
1485 {
1486 gdb_printf (gdb_stdlog,
1487 "csky: bseti r4, %d\n", imm);
1488 }
1489 }
1490 else if (CSKY_16_IS_BCLRI4 (insn2))
1491 {
1492 int imm = (insn2 & 0x1f);
1493 adjust &= ~(1 << imm);
1494 if (csky_debug)
1495 {
1496 gdb_printf (gdb_stdlog,
1497 "csky: bclri r4, %d\n", imm);
1498 }
1499 }
1500 else if (CSKY_16_IS_LSLI4 (insn2))
1501 {
1502 int imm = (insn2 & 0x1f);
1503 adjust <<= imm;
1504 if (csky_debug)
1505 {
1506 gdb_printf (gdb_stdlog,
1507 "csky: lsli r4,r4, %d\n", imm);
1508 }
1509 }
1510
1511 offset += insn_len;
1512 insn_len = csky_get_insn (gdbarch, addr + offset, &insn2);
1513 };
1514
1515 if (csky_debug)
1516 {
1517 gdb_printf (gdb_stdlog, "csky: done looking for"
1518 " r4 adjusters\n");
1519 }
1520
1521 /* If the next insn adjusts the stack pointer, we keep
1522 everything; if not, we scrap it and we've found the
1523 end of the prologue. */
1524 if (CSKY_IS_SUBU4 (insn2))
1525 {
1526 addr += offset;
1527 stacksize += adjust;
1528 if (csky_debug)
1529 {
1530 gdb_printf (gdb_stdlog,
1531 "csky: found stack adjustment of"
1532 " 0x%x bytes.\n", adjust);
1533 gdb_printf (gdb_stdlog,
1534 "csky: skipping to new address %s\n",
1535 core_addr_to_string_nz (addr));
1536 gdb_printf (gdb_stdlog,
1537 "csky: continuing\n");
1538 }
1539 continue;
1540 }
1541
1542 /* None of these instructions are prologue, so don't touch
1543 anything. */
1544 if (csky_debug)
1545 {
1546 gdb_printf (gdb_stdlog,
1547 "csky: no subu sp,sp,r4; NOT altering"
1548 " stacksize.\n");
1549 }
1550 break;
1551 }
1552 }
1553 else
1554 {
1555 /* insn_len != 4. */
1556
1557 /* subi.sp sp,disp. */
1558 if (CSKY_16_IS_SUBI0 (insn))
1559 {
1560 int offset = CSKY_16_SUBI_IMM (insn);
1561 if (csky_debug)
1562 {
1563 gdb_printf (gdb_stdlog,
1564 "csky: got subi r0,%d; continuing\n",
1565 offset);
1566 }
1567 stacksize += offset;
1568 continue;
1569 }
1570 /* stw.16 rz,(sp,disp). */
1571 else if (CSKY_16_IS_STWx0 (insn))
1572 {
1573 /* Spill register: see note for IS_STM above. */
1574 int disp;
1575
1576 rn = CSKY_16_ST_VAL_REGNUM (insn);
1577 disp = CSKY_16_ST_OFFSET (insn);
1578 register_offsets[rn] = stacksize - disp;
1579 if (csky_debug)
1580 print_savedreg_msg (rn, register_offsets, true);
1581 continue;
1582 }
1583 else if (CSKY_16_IS_MOV_FP_SP (insn))
1584 {
1585 /* SP is saved to FP reg, means prologue may modify SP. */
1586 is_fp_saved = 1;
1587 adjust_fp = stacksize;
1588 continue;
1589 }
1590 else if (CSKY_16_IS_PUSH (insn))
1591 {
1592 /* Push for 16_bit. */
1593 int offset = 0;
1594 if (CSKY_16_IS_PUSH_R15 (insn))
1595 {
1596 stacksize += 4;
1597 register_offsets[15] = stacksize;
1598 if (csky_debug)
1599 print_savedreg_msg (15, register_offsets, false);
1600 offset += 4;
1601 }
1602 if (CSKY_16_PUSH_LIST1 (insn))
1603 {
1604 int num = CSKY_16_PUSH_LIST1 (insn);
1605 int tmp = 0;
1606 stacksize += num * 4;
1607 offset += num * 4;
1608 if (csky_debug)
1609 {
1610 gdb_printf (gdb_stdlog,
1611 "csky: push regs_array: r4-r%d\n",
1612 4 + num - 1);
1613 }
1614 for (rn = 4; rn <= 4 + num - 1; rn++)
1615 {
1616 register_offsets[rn] = stacksize - tmp;
1617 if (csky_debug)
1618 {
1619 gdb_printf (gdb_stdlog,
1620 "csky: r%d saved at 0x%x"
1621 " (offset %d)\n", rn,
1622 register_offsets[rn], offset);
1623 }
1624 tmp += 4;
1625 }
1626 }
1627
1628 framesize = stacksize;
1629 if (csky_debug)
1630 gdb_printf (gdb_stdlog, "csky: continuing\n");
1631 continue;
1632 }
1633 else if (CSKY_16_IS_LRW4 (insn) || CSKY_16_IS_MOVI4 (insn))
1634 {
1635 int adjust = 0;
1636 unsigned int insn2;
1637
1638 if (csky_debug)
1639 {
1640 gdb_printf (gdb_stdlog,
1641 "csky: looking at large frame\n");
1642 }
1643 if (CSKY_16_IS_LRW4 (insn))
1644 {
1645 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1646 int offset = ((insn & 0x300) >> 3) | (insn & 0x1f);
1647 int literal_addr = (addr + ( offset << 2)) & 0xfffffffc;
1648 adjust = read_memory_unsigned_integer (literal_addr, 4,
1649 byte_order);
1650 }
1651 else
1652 {
1653 /* CSKY_16_IS_MOVI4 (insn). */
1654 adjust = (insn & 0xff);
1655 }
1656
1657 if (csky_debug)
1658 {
1659 gdb_printf (gdb_stdlog,
1660 "csky: base stacksize=0x%x\n", adjust);
1661 }
1662
1663 /* May have zero or more instructions which modify r4. */
1664 if (csky_debug)
1665 {
1666 gdb_printf (gdb_stdlog,
1667 "csky: looking for r4 adjusters...\n");
1668 }
1669 int offset = 2;
1670 insn_len = csky_get_insn (gdbarch, addr + offset, &insn2);
1671 while (CSKY_IS_R4_ADJUSTER (insn2))
1672 {
1673 if (CSKY_32_IS_ADDI4 (insn2))
1674 {
1675 int imm = (insn2 & 0xfff) + 1;
1676 adjust += imm;
1677 if (csky_debug)
1678 {
1679 gdb_printf (gdb_stdlog,
1680 "csky: addi r4,%d\n", imm);
1681 }
1682 }
1683 else if (CSKY_32_IS_SUBI4 (insn2))
1684 {
1685 int imm = (insn2 & 0xfff) + 1;
1686 adjust -= imm;
1687 if (csky_debug)
1688 {
1689 gdb_printf (gdb_stdlog,
1690 "csky: subi r4,%d\n", imm);
1691 }
1692 }
1693 else if (CSKY_32_IS_NOR4 (insn2))
1694 {
1695 adjust = ~adjust;
1696 if (csky_debug)
1697 {
1698 gdb_printf (gdb_stdlog,
1699 "csky: nor r4,r4,r4\n");
1700 }
1701 }
1702 else if (CSKY_32_IS_ROTLI4 (insn2))
1703 {
1704 int imm = ((insn2 >> 21) & 0x1f);
1705 int temp = adjust >> (32 - imm);
1706 adjust <<= imm;
1707 adjust |= temp;
1708 if (csky_debug)
1709 {
1710 gdb_printf (gdb_stdlog,
1711 "csky: rotli r4,r4,%d\n", imm);
1712 }
1713 }
1714 else if (CSKY_32_IS_LISI4 (insn2))
1715 {
1716 int imm = ((insn2 >> 21) & 0x1f);
1717 adjust <<= imm;
1718 if (csky_debug)
1719 {
1720 gdb_printf (gdb_stdlog,
1721 "csky: lsli r4,r4,%d\n", imm);
1722 }
1723 }
1724 else if (CSKY_32_IS_BSETI4 (insn2))
1725 {
1726 int imm = ((insn2 >> 21) & 0x1f);
1727 adjust |= (1 << imm);
1728 if (csky_debug)
1729 {
1730 gdb_printf (gdb_stdlog,
1731 "csky: bseti r4,r4 %d\n", imm);
1732 }
1733 }
1734 else if (CSKY_32_IS_BCLRI4 (insn2))
1735 {
1736 int imm = ((insn2 >> 21) & 0x1f);
1737 adjust &= ~(1 << imm);
1738 if (csky_debug)
1739 {
1740 gdb_printf (gdb_stdlog,
1741 "csky: bclri r4,r4 %d\n", imm);
1742 }
1743 }
1744 else if (CSKY_32_IS_IXH4 (insn2))
1745 {
1746 adjust *= 3;
1747 if (csky_debug)
1748 {
1749 gdb_printf (gdb_stdlog,
1750 "csky: ixh r4,r4,r4\n");
1751 }
1752 }
1753 else if (CSKY_32_IS_IXW4 (insn2))
1754 {
1755 adjust *= 5;
1756 if (csky_debug)
1757 {
1758 gdb_printf (gdb_stdlog,
1759 "csky: ixw r4,r4,r4\n");
1760 }
1761 }
1762 else if (CSKY_16_IS_ADDI4 (insn2))
1763 {
1764 int imm = (insn2 & 0xff) + 1;
1765 adjust += imm;
1766 if (csky_debug)
1767 {
1768 gdb_printf (gdb_stdlog,
1769 "csky: addi r4,%d\n", imm);
1770 }
1771 }
1772 else if (CSKY_16_IS_SUBI4 (insn2))
1773 {
1774 int imm = (insn2 & 0xff) + 1;
1775 adjust -= imm;
1776 if (csky_debug)
1777 {
1778 gdb_printf (gdb_stdlog,
1779 "csky: subi r4,%d\n", imm);
1780 }
1781 }
1782 else if (CSKY_16_IS_NOR4 (insn2))
1783 {
1784 adjust = ~adjust;
1785 if (csky_debug)
1786 {
1787 gdb_printf (gdb_stdlog,
1788 "csky: nor r4,r4\n");
1789 }
1790 }
1791 else if (CSKY_16_IS_BSETI4 (insn2))
1792 {
1793 int imm = (insn2 & 0x1f);
1794 adjust |= (1 << imm);
1795 if (csky_debug)
1796 {
1797 gdb_printf (gdb_stdlog,
1798 "csky: bseti r4, %d\n", imm);
1799 }
1800 }
1801 else if (CSKY_16_IS_BCLRI4 (insn2))
1802 {
1803 int imm = (insn2 & 0x1f);
1804 adjust &= ~(1 << imm);
1805 if (csky_debug)
1806 {
1807 gdb_printf (gdb_stdlog,
1808 "csky: bclri r4, %d\n", imm);
1809 }
1810 }
1811 else if (CSKY_16_IS_LSLI4 (insn2))
1812 {
1813 int imm = (insn2 & 0x1f);
1814 adjust <<= imm;
1815 if (csky_debug)
1816 {
1817 gdb_printf (gdb_stdlog,
1818 "csky: lsli r4,r4, %d\n", imm);
1819 }
1820 }
1821
1822 offset += insn_len;
1823 insn_len = csky_get_insn (gdbarch, addr + offset, &insn2);
1824 };
1825
1826 if (csky_debug)
1827 {
1828 gdb_printf (gdb_stdlog, "csky: "
1829 "done looking for r4 adjusters\n");
1830 }
1831
1832 /* If the next instruction adjusts the stack pointer, we keep
1833 everything; if not, we scrap it and we've found the end
1834 of the prologue. */
1835 if (CSKY_IS_SUBU4 (insn2))
1836 {
1837 addr += offset;
1838 stacksize += adjust;
1839 if (csky_debug)
1840 {
1841 gdb_printf (gdb_stdlog, "csky: "
1842 "found stack adjustment of 0x%x"
1843 " bytes.\n", adjust);
1844 gdb_printf (gdb_stdlog, "csky: "
1845 "skipping to new address %s\n",
1846 core_addr_to_string_nz (addr));
1847 gdb_printf (gdb_stdlog, "csky: continuing\n");
1848 }
1849 continue;
1850 }
1851
1852 /* None of these instructions are prologue, so don't touch
1853 anything. */
1854 if (csky_debug)
1855 {
1856 gdb_printf (gdb_stdlog, "csky: no subu sp,r4; "
1857 "NOT altering stacksize.\n");
1858 }
1859 break;
1860 }
1861 }
1862
1863 /* This is not a prologue instruction, so stop here. */
1864 if (csky_debug)
1865 {
1866 gdb_printf (gdb_stdlog, "csky: insn is not a prologue"
1867 " insn -- ending scan\n");
1868 }
1869 break;
1870 }
1871
1872 if (this_cache)
1873 {
1874 CORE_ADDR unwound_fp;
1875 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1876 this_cache->framesize = framesize;
1877
1878 if (is_fp_saved)
1879 {
1880 this_cache->framereg = CSKY_FP_REGNUM;
1881 unwound_fp = get_frame_register_unsigned (this_frame,
1882 this_cache->framereg);
1883 this_cache->prev_sp = unwound_fp + adjust_fp;
1884 }
1885 else
1886 {
1887 this_cache->framereg = CSKY_SP_REGNUM;
1888 unwound_fp = get_frame_register_unsigned (this_frame,
1889 this_cache->framereg);
1890 this_cache->prev_sp = unwound_fp + stacksize;
1891 }
1892
1893 /* Note where saved registers are stored. The offsets in
1894 REGISTER_OFFSETS are computed relative to the top of the frame. */
1895 for (rn = 0; rn < CSKY_NUM_GREGS; rn++)
1896 {
1897 if (register_offsets[rn] >= 0)
1898 {
1899 this_cache->saved_regs[rn].set_addr (this_cache->prev_sp
1900 - register_offsets[rn]);
1901 if (csky_debug)
1902 {
1903 CORE_ADDR rn_value = read_memory_unsigned_integer (
1904 this_cache->saved_regs[rn].addr (), 4, byte_order);
1905 gdb_printf (gdb_stdlog, "Saved register %s "
1906 "stored at 0x%08lx, value=0x%08lx\n",
1907 csky_register_names[rn],
1908 (unsigned long)
1909 this_cache->saved_regs[rn].addr (),
1910 (unsigned long) rn_value);
1911 }
1912 }
1913 }
1914 if (lr_type == LR_TYPE_EPC)
1915 {
1916 /* rte || epc . */
1917 this_cache->saved_regs[CSKY_PC_REGNUM]
1918 = this_cache->saved_regs[CSKY_EPC_REGNUM];
1919 }
1920 else if (lr_type == LR_TYPE_FPC)
1921 {
1922 /* rfi || fpc . */
1923 this_cache->saved_regs[CSKY_PC_REGNUM]
1924 = this_cache->saved_regs[CSKY_FPC_REGNUM];
1925 }
1926 else
1927 {
1928 this_cache->saved_regs[CSKY_PC_REGNUM]
1929 = this_cache->saved_regs[CSKY_LR_REGNUM];
1930 }
1931 }
1932
1933 return addr;
1934 }
1935
1936 /* Detect whether PC is at a point where the stack frame has been
1937 destroyed. */
1938
1939 static int
1940 csky_stack_frame_destroyed_p (struct gdbarch *gdbarch, CORE_ADDR pc)
1941 {
1942 unsigned int insn;
1943 CORE_ADDR addr;
1944 CORE_ADDR func_start, func_end;
1945
1946 if (!find_pc_partial_function (pc, NULL, &func_start, &func_end))
1947 return 0;
1948
1949 bool fp_saved = false;
1950 int insn_len;
1951 for (addr = func_start; addr < func_end; addr += insn_len)
1952 {
1953 /* Get next insn. */
1954 insn_len = csky_get_insn (gdbarch, addr, &insn);
1955
1956 if (insn_len == 2)
1957 {
1958 /* Is sp is saved to fp. */
1959 if (CSKY_16_IS_MOV_FP_SP (insn))
1960 fp_saved = true;
1961 /* If sp was saved to fp and now being restored from
1962 fp then it indicates the start of epilog. */
1963 else if (fp_saved && CSKY_16_IS_MOV_SP_FP (insn))
1964 return pc >= addr;
1965 }
1966 }
1967 return 0;
1968 }
1969
1970 /* Implement the skip_prologue gdbarch hook. */
1971
1972 static CORE_ADDR
1973 csky_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
1974 {
1975 CORE_ADDR func_addr, func_end;
1976 const int default_search_limit = 128;
1977
1978 /* See if we can find the end of the prologue using the symbol table. */
1979 if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
1980 {
1981 CORE_ADDR post_prologue_pc
1982 = skip_prologue_using_sal (gdbarch, func_addr);
1983
1984 if (post_prologue_pc != 0)
1985 return std::max (pc, post_prologue_pc);
1986 }
1987 else
1988 func_end = pc + default_search_limit;
1989
1990 /* Find the end of prologue. Default lr_type. */
1991 return csky_analyze_prologue (gdbarch, pc, func_end, func_end,
1992 NULL, NULL, LR_TYPE_R15);
1993 }
1994
1995 /* Implement the breakpoint_kind_from_pc gdbarch method. */
1996
1997 static int
1998 csky_breakpoint_kind_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr)
1999 {
2000 if (csky_pc_is_csky16 (gdbarch, *pcptr))
2001 return CSKY_INSN_SIZE16;
2002 else
2003 return CSKY_INSN_SIZE32;
2004 }
2005
2006 /* Implement the sw_breakpoint_from_kind gdbarch method. */
2007
2008 static const gdb_byte *
2009 csky_sw_breakpoint_from_kind (struct gdbarch *gdbarch, int kind, int *size)
2010 {
2011 *size = kind;
2012 if (kind == CSKY_INSN_SIZE16)
2013 {
2014 static gdb_byte csky_16_breakpoint[] = { 0, 0 };
2015 return csky_16_breakpoint;
2016 }
2017 else
2018 {
2019 static gdb_byte csky_32_breakpoint[] = { 0, 0, 0, 0 };
2020 return csky_32_breakpoint;
2021 }
2022 }
2023
2024 /* Determine link register type. */
2025
2026 static lr_type_t
2027 csky_analyze_lr_type (struct gdbarch *gdbarch,
2028 CORE_ADDR start_pc, CORE_ADDR end_pc)
2029 {
2030 CORE_ADDR addr;
2031 unsigned int insn, insn_len;
2032 insn_len = 2;
2033
2034 for (addr = start_pc; addr < end_pc; addr += insn_len)
2035 {
2036 insn_len = csky_get_insn (gdbarch, addr, &insn);
2037 if (insn_len == 4)
2038 {
2039 if (CSKY_32_IS_MFCR_EPSR (insn) || CSKY_32_IS_MFCR_EPC (insn)
2040 || CSKY_32_IS_RTE (insn))
2041 return LR_TYPE_EPC;
2042 }
2043 else if (CSKY_32_IS_MFCR_FPSR (insn) || CSKY_32_IS_MFCR_FPC (insn)
2044 || CSKY_32_IS_RFI (insn))
2045 return LR_TYPE_FPC;
2046 else if (CSKY_32_IS_JMP (insn) || CSKY_32_IS_BR (insn)
2047 || CSKY_32_IS_JMPIX (insn) || CSKY_32_IS_JMPI (insn))
2048 return LR_TYPE_R15;
2049 else
2050 {
2051 /* 16 bit instruction. */
2052 if (CSKY_16_IS_JMP (insn) || CSKY_16_IS_BR (insn)
2053 || CSKY_16_IS_JMPIX (insn))
2054 return LR_TYPE_R15;
2055 }
2056 }
2057 return LR_TYPE_R15;
2058 }
2059
2060 /* Heuristic unwinder. */
2061
2062 static struct csky_unwind_cache *
2063 csky_frame_unwind_cache (frame_info_ptr this_frame)
2064 {
2065 CORE_ADDR prologue_start, prologue_end, func_end, prev_pc, block_addr;
2066 struct csky_unwind_cache *cache;
2067 const struct block *bl;
2068 unsigned long func_size = 0;
2069 struct gdbarch *gdbarch = get_frame_arch (this_frame);
2070 unsigned int sp_regnum = CSKY_SP_REGNUM;
2071
2072 /* Default lr type is r15. */
2073 lr_type_t lr_type = LR_TYPE_R15;
2074
2075 cache = FRAME_OBSTACK_ZALLOC (struct csky_unwind_cache);
2076 cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
2077
2078 /* Assume there is no frame until proven otherwise. */
2079 cache->framereg = sp_regnum;
2080
2081 cache->framesize = 0;
2082
2083 prev_pc = get_frame_pc (this_frame);
2084 block_addr = get_frame_address_in_block (this_frame);
2085 if (find_pc_partial_function (block_addr, NULL, &prologue_start,
2086 &func_end) == 0)
2087 /* We couldn't find a function containing block_addr, so bail out
2088 and hope for the best. */
2089 return cache;
2090
2091 /* Get the (function) symbol matching prologue_start. */
2092 bl = block_for_pc (prologue_start);
2093 if (bl != NULL)
2094 func_size = bl->end () - bl->start ();
2095 else
2096 {
2097 struct bound_minimal_symbol msymbol
2098 = lookup_minimal_symbol_by_pc (prologue_start);
2099 if (msymbol.minsym != NULL)
2100 func_size = msymbol.minsym->size ();
2101 }
2102
2103 /* If FUNC_SIZE is 0 we may have a special-case use of lr
2104 e.g. exception or interrupt. */
2105 if (func_size == 0)
2106 lr_type = csky_analyze_lr_type (gdbarch, prologue_start, func_end);
2107
2108 prologue_end = std::min (func_end, prev_pc);
2109
2110 /* Analyze the function prologue. */
2111 csky_analyze_prologue (gdbarch, prologue_start, prologue_end,
2112 func_end, this_frame, cache, lr_type);
2113
2114 /* gdbarch_sp_regnum contains the value and not the address. */
2115 cache->saved_regs[sp_regnum].set_value (cache->prev_sp);
2116 return cache;
2117 }
2118
2119 /* Implement the this_id function for the normal unwinder. */
2120
2121 static void
2122 csky_frame_this_id (frame_info_ptr this_frame,
2123 void **this_prologue_cache, struct frame_id *this_id)
2124 {
2125 struct csky_unwind_cache *cache;
2126 struct frame_id id;
2127
2128 if (*this_prologue_cache == NULL)
2129 *this_prologue_cache = csky_frame_unwind_cache (this_frame);
2130 cache = (struct csky_unwind_cache *) *this_prologue_cache;
2131
2132 /* This marks the outermost frame. */
2133 if (cache->prev_sp == 0)
2134 return;
2135
2136 id = frame_id_build (cache->prev_sp, get_frame_func (this_frame));
2137 *this_id = id;
2138 }
2139
2140 /* Implement the prev_register function for the normal unwinder. */
2141
2142 static struct value *
2143 csky_frame_prev_register (frame_info_ptr this_frame,
2144 void **this_prologue_cache, int regnum)
2145 {
2146 struct csky_unwind_cache *cache;
2147
2148 if (*this_prologue_cache == NULL)
2149 *this_prologue_cache = csky_frame_unwind_cache (this_frame);
2150 cache = (struct csky_unwind_cache *) *this_prologue_cache;
2151
2152 return trad_frame_get_prev_register (this_frame, cache->saved_regs,
2153 regnum);
2154 }
2155
2156 /* Data structures for the normal prologue-analysis-based
2157 unwinder. */
2158
2159 static const struct frame_unwind csky_unwind_cache = {
2160 "cski prologue",
2161 NORMAL_FRAME,
2162 default_frame_unwind_stop_reason,
2163 csky_frame_this_id,
2164 csky_frame_prev_register,
2165 NULL,
2166 default_frame_sniffer,
2167 NULL,
2168 NULL
2169 };
2170
2171 static CORE_ADDR
2172 csky_check_long_branch (frame_info_ptr frame, CORE_ADDR pc)
2173 {
2174 gdb_byte buf[8];
2175 struct gdbarch *gdbarch = get_frame_arch (frame);
2176 enum bfd_endian byte_order_for_code
2177 = gdbarch_byte_order_for_code (gdbarch);
2178
2179 if (target_read_memory (pc, buf, 8) == 0)
2180 {
2181 unsigned int data0
2182 = extract_unsigned_integer (buf, 4, byte_order_for_code);
2183 unsigned int data1
2184 = extract_unsigned_integer (buf + 4, 4, byte_order_for_code);
2185
2186 /* Case: jmpi [pc+4] : 0xeac00001
2187 .long addr */
2188 if (data0 == CSKY_JMPI_PC_4)
2189 return data1;
2190
2191 /* Case: lrw t1, [pc+8] : 0xea8d0002
2192 jmp t1 : 0x7834
2193 nop : 0x6c03
2194 .long addr */
2195 if ((data0 == CSKY_LRW_T1_PC_8) && (data1 == CSKY_JMP_T1_VS_NOP))
2196 {
2197 if (target_read_memory (pc + 8, buf, 4) == 0)
2198 return extract_unsigned_integer (buf, 4, byte_order_for_code);
2199 }
2200
2201 return 0;
2202 }
2203
2204 return 0;
2205 }
2206
2207 static int
2208 csky_stub_unwind_sniffer (const struct frame_unwind *self,
2209 frame_info_ptr this_frame,
2210 void **this_prologue_cache)
2211 {
2212 CORE_ADDR addr_in_block, pc;
2213 gdb_byte dummy[4];
2214 const char *name;
2215 CORE_ADDR start_addr;
2216
2217 /* Get pc */
2218 addr_in_block = get_frame_address_in_block (this_frame);
2219 pc = get_frame_pc (this_frame);
2220
2221 if (in_plt_section (addr_in_block)
2222 || target_read_memory (pc, dummy, 4) != 0)
2223 return 1;
2224
2225 /* Find the starting address and name of the function containing the PC. */
2226 if (find_pc_partial_function (pc, &name, &start_addr, NULL) == 0)
2227 {
2228 start_addr = csky_check_long_branch (this_frame, pc);
2229 /* if not long branch, return 0. */
2230 if (start_addr != 0)
2231 return 1;
2232
2233 return 0;
2234 }
2235
2236 return 0;
2237 }
2238
2239 static struct csky_unwind_cache *
2240 csky_make_stub_cache (frame_info_ptr this_frame)
2241 {
2242 struct csky_unwind_cache *cache;
2243
2244 cache = FRAME_OBSTACK_ZALLOC (struct csky_unwind_cache);
2245 cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
2246 cache->prev_sp = get_frame_register_unsigned (this_frame, CSKY_SP_REGNUM);
2247
2248 return cache;
2249 }
2250
2251 static void
2252 csky_stub_this_id (frame_info_ptr this_frame,
2253 void **this_cache,
2254 struct frame_id *this_id)
2255 {
2256 struct csky_unwind_cache *cache;
2257
2258 if (*this_cache == NULL)
2259 *this_cache = csky_make_stub_cache (this_frame);
2260 cache = (struct csky_unwind_cache *) *this_cache;
2261
2262 /* Our frame ID for a stub frame is the current SP and LR. */
2263 *this_id = frame_id_build (cache->prev_sp, get_frame_pc (this_frame));
2264 }
2265
2266 static struct value *
2267 csky_stub_prev_register (frame_info_ptr this_frame,
2268 void **this_cache,
2269 int prev_regnum)
2270 {
2271 struct csky_unwind_cache *cache;
2272
2273 if (*this_cache == NULL)
2274 *this_cache = csky_make_stub_cache (this_frame);
2275 cache = (struct csky_unwind_cache *) *this_cache;
2276
2277 /* If we are asked to unwind the PC, then return the LR. */
2278 if (prev_regnum == CSKY_PC_REGNUM)
2279 {
2280 CORE_ADDR lr;
2281
2282 lr = frame_unwind_register_unsigned (this_frame, CSKY_LR_REGNUM);
2283 return frame_unwind_got_constant (this_frame, prev_regnum, lr);
2284 }
2285
2286 if (prev_regnum == CSKY_SP_REGNUM)
2287 return frame_unwind_got_constant (this_frame, prev_regnum, cache->prev_sp);
2288
2289 return trad_frame_get_prev_register (this_frame, cache->saved_regs,
2290 prev_regnum);
2291 }
2292
2293 static frame_unwind csky_stub_unwind = {
2294 "csky stub",
2295 NORMAL_FRAME,
2296 default_frame_unwind_stop_reason,
2297 csky_stub_this_id,
2298 csky_stub_prev_register,
2299 NULL,
2300 csky_stub_unwind_sniffer
2301 };
2302
2303 /* Implement the this_base, this_locals, and this_args hooks
2304 for the normal unwinder. */
2305
2306 static CORE_ADDR
2307 csky_frame_base_address (frame_info_ptr this_frame, void **this_cache)
2308 {
2309 struct csky_unwind_cache *cache;
2310
2311 if (*this_cache == NULL)
2312 *this_cache = csky_frame_unwind_cache (this_frame);
2313 cache = (struct csky_unwind_cache *) *this_cache;
2314
2315 return cache->prev_sp - cache->framesize;
2316 }
2317
2318 static const struct frame_base csky_frame_base = {
2319 &csky_unwind_cache,
2320 csky_frame_base_address,
2321 csky_frame_base_address,
2322 csky_frame_base_address
2323 };
2324
2325 /* Initialize register access method. */
2326
2327 static void
2328 csky_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
2329 struct dwarf2_frame_state_reg *reg,
2330 frame_info_ptr this_frame)
2331 {
2332 if (regnum == gdbarch_pc_regnum (gdbarch))
2333 reg->how = DWARF2_FRAME_REG_RA;
2334 else if (regnum == gdbarch_sp_regnum (gdbarch))
2335 reg->how = DWARF2_FRAME_REG_CFA;
2336 }
2337
2338 /* Create csky register groups. */
2339
2340 static void
2341 csky_init_reggroup ()
2342 {
2343 cr_reggroup = reggroup_new ("cr", USER_REGGROUP);
2344 fr_reggroup = reggroup_new ("fr", USER_REGGROUP);
2345 vr_reggroup = reggroup_new ("vr", USER_REGGROUP);
2346 mmu_reggroup = reggroup_new ("mmu", USER_REGGROUP);
2347 prof_reggroup = reggroup_new ("profiling", USER_REGGROUP);
2348 }
2349
2350 /* Add register groups into reggroup list. */
2351
2352 static void
2353 csky_add_reggroups (struct gdbarch *gdbarch)
2354 {
2355 reggroup_add (gdbarch, cr_reggroup);
2356 reggroup_add (gdbarch, fr_reggroup);
2357 reggroup_add (gdbarch, vr_reggroup);
2358 reggroup_add (gdbarch, mmu_reggroup);
2359 reggroup_add (gdbarch, prof_reggroup);
2360 }
2361
2362 /* Return the groups that a CSKY register can be categorised into. */
2363
2364 static int
2365 csky_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
2366 const struct reggroup *reggroup)
2367 {
2368 int raw_p;
2369
2370 if (gdbarch_register_name (gdbarch, regnum)[0] == '\0')
2371 return 0;
2372
2373 if (reggroup == all_reggroup)
2374 return 1;
2375
2376 raw_p = regnum < gdbarch_num_regs (gdbarch);
2377 if (reggroup == save_reggroup || reggroup == restore_reggroup)
2378 return raw_p;
2379
2380 if ((((regnum >= CSKY_R0_REGNUM) && (regnum <= CSKY_R0_REGNUM + 31))
2381 || (regnum == CSKY_PC_REGNUM)
2382 || (regnum == CSKY_EPC_REGNUM)
2383 || (regnum == CSKY_CR0_REGNUM)
2384 || (regnum == CSKY_EPSR_REGNUM))
2385 && (reggroup == general_reggroup))
2386 return 1;
2387
2388 if (((regnum == CSKY_PC_REGNUM)
2389 || ((regnum >= CSKY_CR0_REGNUM)
2390 && (regnum <= CSKY_CR0_REGNUM + 30)))
2391 && (reggroup == cr_reggroup))
2392 return 2;
2393
2394 if ((((regnum >= CSKY_VR0_REGNUM) && (regnum <= CSKY_VR0_REGNUM + 15))
2395 || ((regnum >= CSKY_FCR_REGNUM)
2396 && (regnum <= CSKY_FCR_REGNUM + 2)))
2397 && (reggroup == vr_reggroup))
2398 return 3;
2399
2400 if (((regnum >= CSKY_MMU_REGNUM) && (regnum <= CSKY_MMU_REGNUM + 8))
2401 && (reggroup == mmu_reggroup))
2402 return 4;
2403
2404 if (((regnum >= CSKY_PROFCR_REGNUM)
2405 && (regnum <= CSKY_PROFCR_REGNUM + 48))
2406 && (reggroup == prof_reggroup))
2407 return 5;
2408
2409 if ((((regnum >= CSKY_FR0_REGNUM) && (regnum <= CSKY_FR0_REGNUM + 15))
2410 || ((regnum >= CSKY_FCR_REGNUM) && (regnum <= CSKY_FCR_REGNUM + 2)))
2411 && (reggroup == fr_reggroup))
2412 return 6;
2413
2414 if (tdesc_has_registers (gdbarch_target_desc (gdbarch)))
2415 {
2416 if (tdesc_register_in_reggroup_p (gdbarch, regnum, reggroup) > 0)
2417 return 7;
2418 }
2419
2420 return 0;
2421 }
2422
2423 /* Implement the dwarf2_reg_to_regnum gdbarch method. */
2424
2425 static int
2426 csky_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int dw_reg)
2427 {
2428 /* For GPRs. */
2429 if (dw_reg >= CSKY_R0_REGNUM && dw_reg <= CSKY_R0_REGNUM + 31)
2430 return dw_reg;
2431
2432 /* For Hi, Lo, PC. */
2433 if (dw_reg == CSKY_HI_REGNUM || dw_reg == CSKY_LO_REGNUM
2434 || dw_reg == CSKY_PC_REGNUM)
2435 return dw_reg;
2436
2437 /* For Float and Vector pseudo registers. */
2438 if (dw_reg >= FV_PSEUDO_REGNO_FIRST && dw_reg <= FV_PSEUDO_REGNO_LAST)
2439 {
2440 char name_buf[4];
2441
2442 xsnprintf (name_buf, sizeof (name_buf), "s%d",
2443 dw_reg - FV_PSEUDO_REGNO_FIRST);
2444 return user_reg_map_name_to_regnum (gdbarch, name_buf,
2445 strlen (name_buf));
2446 }
2447
2448 /* Others, unknown. */
2449 return -1;
2450 }
2451
2452 /* Check whether xml has discribled the essential regs. */
2453
2454 static int
2455 csky_essential_reg_check (const struct csky_supported_tdesc_register *reg)
2456 {
2457 if ((strcmp (reg->name , "pc") == 0)
2458 && (reg->num == CSKY_PC_REGNUM))
2459 return CSKY_TDESC_REGS_PC_NUMBERED;
2460 else if ((strcmp (reg->name , "r14") == 0)
2461 && (reg->num == CSKY_SP_REGNUM))
2462 return CSKY_TDESC_REGS_SP_NUMBERED;
2463 else if ((strcmp (reg->name , "r15") == 0)
2464 && (reg->num == CSKY_LR_REGNUM))
2465 return CSKY_TDESC_REGS_LR_NUMBERED;
2466 else
2467 return 0;
2468 }
2469
2470 /* Check whether xml has discribled the fr0~fr15 regs. */
2471
2472 static int
2473 csky_fr0_fr15_reg_check (const struct csky_supported_tdesc_register *reg) {
2474 int i = 0;
2475 for (i = 0; i < 16; i++)
2476 {
2477 if ((strcmp (reg->name, csky_supported_fpu_regs[i].name) == 0)
2478 && (csky_supported_fpu_regs[i].num == reg->num))
2479 return (1 << i);
2480 }
2481
2482 return 0;
2483 };
2484
2485 /* Check whether xml has discribled the fr16~fr31 regs. */
2486
2487 static int
2488 csky_fr16_fr31_reg_check (const struct csky_supported_tdesc_register *reg) {
2489 int i = 0;
2490 for (i = 0; i < 16; i++)
2491 {
2492 if ((strcmp (reg->name, csky_supported_fpu_regs[i + 16].name) == 0)
2493 && (csky_supported_fpu_regs[i + 16].num == reg->num))
2494 return (1 << i);
2495 }
2496
2497 return 0;
2498 };
2499
2500 /* Check whether xml has discribled the vr0~vr15 regs. */
2501
2502 static int
2503 csky_vr0_vr15_reg_check (const struct csky_supported_tdesc_register *reg) {
2504 int i = 0;
2505 for (i = 0; i < 16; i++)
2506 {
2507 if ((strcmp (reg->name, csky_supported_fpu_regs[i + 32].name) == 0)
2508 && (csky_supported_fpu_regs[i + 32].num == reg->num))
2509 return (1 << i);
2510 }
2511
2512 return 0;
2513 };
2514
2515 /* Return pseudo reg's name. */
2516
2517 static const char *
2518 csky_pseudo_register_name (struct gdbarch *gdbarch, int regno)
2519 {
2520 int num_regs = gdbarch_num_regs (gdbarch);
2521 csky_gdbarch_tdep *tdep
2522 = gdbarch_tdep<csky_gdbarch_tdep> (gdbarch);
2523
2524 regno -= num_regs;
2525
2526 if (tdep->fv_pseudo_registers_count)
2527 {
2528 static const char *const fv_pseudo_names[] = {
2529 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
2530 "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
2531 "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
2532 "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
2533 "s32", "s33", "s34", "s35", "s36", "s37", "s38", "s39",
2534 "s40", "s41", "s42", "s43", "s44", "s45", "s46", "s47",
2535 "s48", "s49", "s50", "s51", "s52", "s53", "s54", "s55",
2536 "s56", "s57", "s58", "s59", "s60", "s61", "s62", "s63",
2537 "s64", "s65", "s66", "s67", "s68", "s69", "s70", "s71",
2538 "s72", "s73", "s74", "s75", "s76", "s77", "s78", "s79",
2539 "s80", "s81", "s82", "s83", "s84", "s85", "s86", "s87",
2540 "s88", "s89", "s90", "s91", "s92", "s93", "s94", "s95",
2541 "s96", "s97", "s98", "s99", "s100", "s101", "s102", "s103",
2542 "s104", "s105", "s106", "s107", "s108", "s109", "s110", "s111",
2543 "s112", "s113", "s114", "s115", "s116", "s117", "s118", "s119",
2544 "s120", "s121", "s122", "s123", "s124", "s125", "s126", "s127",
2545 };
2546
2547 if (regno < tdep->fv_pseudo_registers_count)
2548 {
2549 if ((regno < 64) && ((regno % 4) >= 2) && !tdep->has_vr0)
2550 return "";
2551 else if ((regno >= 64) && ((regno % 4) >= 2))
2552 return "";
2553 else
2554 return fv_pseudo_names[regno];
2555 }
2556 }
2557
2558 return "";
2559 }
2560
2561 /* Read for csky pseudo regs. */
2562
2563 static enum register_status
2564 csky_pseudo_register_read (struct gdbarch *gdbarch,
2565 struct readable_regcache *regcache,
2566 int regnum, gdb_byte *buf)
2567 {
2568 int num_regs = gdbarch_num_regs (gdbarch);
2569 csky_gdbarch_tdep *tdep
2570 = gdbarch_tdep<csky_gdbarch_tdep> (gdbarch);
2571
2572 regnum -= num_regs;
2573
2574 if (regnum < tdep->fv_pseudo_registers_count)
2575 {
2576 enum register_status status;
2577 int gdb_regnum = 0;
2578 int offset = 0;
2579 gdb_byte reg_buf[16];
2580
2581 /* Ensure getting s0~s63 from vrx if tdep->has_vr0 is ture. */
2582 if (tdep->has_vr0)
2583 {
2584 if (regnum < 64)
2585 {
2586 gdb_regnum = CSKY_VR0_REGNUM + (regnum / 4);
2587 offset = (regnum % 4) * 4;
2588 }
2589 else
2590 {
2591 gdb_regnum = CSKY_FR16_REGNUM + ((regnum - 64) / 4);
2592 if ((regnum % 4) >= 2)
2593 return REG_UNAVAILABLE;
2594 offset = (regnum % 2) * 4;
2595 }
2596 }
2597 else
2598 {
2599 gdb_regnum = CSKY_FR0_REGNUM + (regnum / 4);
2600 if ((regnum % 4) >= 2)
2601 return REG_UNAVAILABLE;
2602 offset = (regnum % 2) * 4;
2603 }
2604
2605 status = regcache->raw_read (gdb_regnum, reg_buf);
2606 if (status == REG_VALID)
2607 memcpy (buf, reg_buf + offset, 4);
2608 return status;
2609 }
2610
2611 return REG_UNKNOWN;
2612 }
2613
2614 /* Write for csky pseudo regs. */
2615
2616 static void
2617 csky_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
2618 int regnum, const gdb_byte *buf)
2619 {
2620 int num_regs = gdbarch_num_regs (gdbarch);
2621 csky_gdbarch_tdep *tdep
2622 = gdbarch_tdep<csky_gdbarch_tdep> (gdbarch);
2623
2624 regnum -= num_regs;
2625
2626 if (regnum < tdep->fv_pseudo_registers_count)
2627 {
2628 gdb_byte reg_buf[16];
2629 int gdb_regnum = 0;
2630 int offset = 0;
2631
2632 if (tdep->has_vr0)
2633 {
2634 if (regnum < 64)
2635 {
2636 gdb_regnum = CSKY_VR0_REGNUM + (regnum / 4);
2637 offset = (regnum % 4) * 4;
2638 }
2639 else
2640 {
2641 gdb_regnum = CSKY_FR16_REGNUM + ((regnum - 64) / 4);
2642 if ((regnum % 4) >= 2)
2643 return;
2644 offset = (regnum % 2) * 4;
2645 }
2646 }
2647 else
2648 {
2649 gdb_regnum = CSKY_FR0_REGNUM + (regnum / 4);
2650 if ((regnum % 4) >= 2)
2651 return;
2652 offset = (regnum % 2) * 4;
2653 }
2654
2655 regcache->raw_read (gdb_regnum, reg_buf);
2656 memcpy (reg_buf + offset, buf, 4);
2657 regcache->raw_write (gdb_regnum, reg_buf);
2658 return;
2659 }
2660
2661 return;
2662 }
2663
2664 /* Initialize the current architecture based on INFO. If possible,
2665 re-use an architecture from ARCHES, which is a list of
2666 architectures already created during this debugging session.
2667
2668 Called at program startup, when reading a core file, and when
2669 reading a binary file. */
2670
2671 static struct gdbarch *
2672 csky_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
2673 {
2674 struct gdbarch *gdbarch;
2675 /* Analyze info.abfd. */
2676 unsigned int fpu_abi = 0;
2677 unsigned int vdsp_version = 0;
2678 unsigned int fpu_hardfp = 0;
2679 /* Analyze info.target_desc */
2680 int num_regs = 0;
2681 int has_fr0 = 0;
2682 int has_fr16 = 0;
2683 int has_vr0 = 0;
2684 tdesc_arch_data_up tdesc_data;
2685
2686 if (tdesc_has_registers (info.target_desc))
2687 {
2688 int valid_p = 0;
2689 int numbered = 0;
2690 int index = 0;
2691 int i = 0;
2692 int feature_names_count = ARRAY_SIZE (csky_supported_tdesc_feature_names);
2693 int support_tdesc_regs_count
2694 = csky_get_supported_tdesc_registers_count();
2695 const struct csky_supported_tdesc_register *tdesc_reg;
2696 const struct tdesc_feature *feature;
2697
2698 tdesc_data = tdesc_data_alloc ();
2699 for (index = 0; index < feature_names_count; index ++)
2700 {
2701 feature = tdesc_find_feature (info.target_desc,
2702 csky_supported_tdesc_feature_names[index]);
2703 if (feature != NULL)
2704 {
2705 for (i = 0; i < support_tdesc_regs_count; i++)
2706 {
2707 tdesc_reg = csky_get_supported_register_by_index (i);
2708 if (!tdesc_reg)
2709 break;
2710 numbered = tdesc_numbered_register (feature, tdesc_data.get(),
2711 tdesc_reg->num,
2712 tdesc_reg->name);
2713 if (numbered) {
2714 valid_p |= csky_essential_reg_check (tdesc_reg);
2715 has_fr0 |= csky_fr0_fr15_reg_check (tdesc_reg);
2716 has_fr16 |= csky_fr16_fr31_reg_check (tdesc_reg);
2717 has_vr0 |= csky_vr0_vr15_reg_check (tdesc_reg);
2718 if (num_regs < tdesc_reg->num)
2719 num_regs = tdesc_reg->num;
2720 }
2721 }
2722 }
2723 }
2724 if (valid_p != CSKY_TDESC_REGS_ESSENTIAL_VALUE)
2725 return NULL;
2726 }
2727
2728 /* When the type of bfd file is srec(or any files are not elf),
2729 the E_FLAGS will be not credible. */
2730 if (info.abfd != NULL && bfd_get_flavour (info.abfd) == bfd_target_elf_flavour)
2731 {
2732 /* Get FPU, VDSP build options. */
2733 fpu_abi = bfd_elf_get_obj_attr_int (info.abfd,
2734 OBJ_ATTR_PROC,
2735 Tag_CSKY_FPU_ABI);
2736 vdsp_version = bfd_elf_get_obj_attr_int (info.abfd,
2737 OBJ_ATTR_PROC,
2738 Tag_CSKY_VDSP_VERSION);
2739 fpu_hardfp = bfd_elf_get_obj_attr_int (info.abfd,
2740 OBJ_ATTR_PROC,
2741 Tag_CSKY_FPU_HARDFP);
2742 }
2743
2744 /* Find a candidate among the list of pre-declared architectures. */
2745 for (arches = gdbarch_list_lookup_by_info (arches, &info);
2746 arches != NULL;
2747 arches = gdbarch_list_lookup_by_info (arches->next, &info))
2748 {
2749 csky_gdbarch_tdep *tdep
2750 = gdbarch_tdep<csky_gdbarch_tdep> (arches->gdbarch);
2751 if (fpu_abi != tdep->fpu_abi)
2752 continue;
2753 if (vdsp_version != tdep->vdsp_version)
2754 continue;
2755 if (fpu_hardfp != tdep->fpu_hardfp)
2756 continue;
2757
2758 /* Found a match. */
2759 return arches->gdbarch;
2760 }
2761
2762 /* None found, create a new architecture from the information
2763 provided. */
2764 csky_gdbarch_tdep *tdep = new csky_gdbarch_tdep;
2765 gdbarch = gdbarch_alloc (&info, tdep);
2766 tdep->fpu_abi = fpu_abi;
2767 tdep->vdsp_version = vdsp_version;
2768 tdep->fpu_hardfp = fpu_hardfp;
2769
2770 if (tdesc_data != NULL)
2771 {
2772 if ((has_vr0 == CSKY_FULL16_ONEHOT_VALUE)
2773 && (has_fr16 == CSKY_FULL16_ONEHOT_VALUE))
2774 {
2775 tdep->has_vr0 = 1;
2776 tdep->fv_pseudo_registers_count = 128;
2777 }
2778 else if ((has_vr0 == CSKY_FULL16_ONEHOT_VALUE)
2779 && (has_fr16 != CSKY_FULL16_ONEHOT_VALUE))
2780 {
2781 tdep->has_vr0 = 1;
2782 tdep->fv_pseudo_registers_count = 64;
2783 }
2784 else if ((has_fr0 == CSKY_FULL16_ONEHOT_VALUE)
2785 && (has_vr0 != CSKY_FULL16_ONEHOT_VALUE))
2786 {
2787 tdep->has_vr0 = 0;
2788 tdep->fv_pseudo_registers_count = 64;
2789 }
2790 else
2791 {
2792 tdep->has_vr0 = 0;
2793 tdep->fv_pseudo_registers_count = 0;
2794 }
2795 }
2796 else
2797 {
2798 tdep->has_vr0 = 1;
2799 tdep->fv_pseudo_registers_count = 64;
2800 }
2801
2802 /* Target data types. */
2803 set_gdbarch_ptr_bit (gdbarch, 32);
2804 set_gdbarch_addr_bit (gdbarch, 32);
2805 set_gdbarch_short_bit (gdbarch, 16);
2806 set_gdbarch_int_bit (gdbarch, 32);
2807 set_gdbarch_long_bit (gdbarch, 32);
2808 set_gdbarch_long_long_bit (gdbarch, 64);
2809 set_gdbarch_float_bit (gdbarch, 32);
2810 set_gdbarch_double_bit (gdbarch, 64);
2811 set_gdbarch_float_format (gdbarch, floatformats_ieee_single);
2812 set_gdbarch_double_format (gdbarch, floatformats_ieee_double);
2813
2814 /* Information about the target architecture. */
2815 set_gdbarch_return_value (gdbarch, csky_return_value);
2816 set_gdbarch_breakpoint_kind_from_pc (gdbarch, csky_breakpoint_kind_from_pc);
2817 set_gdbarch_sw_breakpoint_from_kind (gdbarch, csky_sw_breakpoint_from_kind);
2818
2819 /* Register architecture. */
2820 set_gdbarch_num_regs (gdbarch, CSKY_NUM_REGS);
2821 set_gdbarch_pc_regnum (gdbarch, CSKY_PC_REGNUM);
2822 set_gdbarch_sp_regnum (gdbarch, CSKY_SP_REGNUM);
2823 set_gdbarch_register_name (gdbarch, csky_register_name);
2824 set_gdbarch_register_type (gdbarch, csky_register_type);
2825 set_gdbarch_read_pc (gdbarch, csky_read_pc);
2826 set_gdbarch_write_pc (gdbarch, csky_write_pc);
2827 csky_add_reggroups (gdbarch);
2828 set_gdbarch_register_reggroup_p (gdbarch, csky_register_reggroup_p);
2829 set_gdbarch_stab_reg_to_regnum (gdbarch, csky_dwarf_reg_to_regnum);
2830 set_gdbarch_dwarf2_reg_to_regnum (gdbarch, csky_dwarf_reg_to_regnum);
2831 dwarf2_frame_set_init_reg (gdbarch, csky_dwarf2_frame_init_reg);
2832
2833 /* Functions to analyze frames. */
2834 frame_base_set_default (gdbarch, &csky_frame_base);
2835 set_gdbarch_skip_prologue (gdbarch, csky_skip_prologue);
2836 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
2837 set_gdbarch_frame_align (gdbarch, csky_frame_align);
2838 set_gdbarch_stack_frame_destroyed_p (gdbarch, csky_stack_frame_destroyed_p);
2839
2840 /* Functions handling dummy frames. */
2841 set_gdbarch_push_dummy_call (gdbarch, csky_push_dummy_call);
2842
2843 /* Frame unwinders. Use DWARF debug info if available,
2844 otherwise use our own unwinder. */
2845 dwarf2_append_unwinders (gdbarch);
2846 frame_unwind_append_unwinder (gdbarch, &csky_stub_unwind);
2847 frame_unwind_append_unwinder (gdbarch, &csky_unwind_cache);
2848
2849 /* Hook in ABI-specific overrides, if they have been registered. */
2850 gdbarch_init_osabi (info, gdbarch);
2851
2852 /* Support simple overlay manager. */
2853 set_gdbarch_overlay_update (gdbarch, simple_overlay_update);
2854 set_gdbarch_char_signed (gdbarch, 0);
2855
2856 if (tdesc_data != nullptr)
2857 {
2858 set_gdbarch_num_regs (gdbarch, (num_regs + 1));
2859 tdesc_use_registers (gdbarch, info.target_desc, std::move (tdesc_data));
2860 set_gdbarch_register_type (gdbarch, csky_register_type);
2861 set_gdbarch_register_reggroup_p (gdbarch,
2862 csky_register_reggroup_p);
2863 }
2864
2865 if (tdep->fv_pseudo_registers_count)
2866 {
2867 set_gdbarch_num_pseudo_regs (gdbarch,
2868 tdep->fv_pseudo_registers_count);
2869 set_gdbarch_pseudo_register_read (gdbarch,
2870 csky_pseudo_register_read);
2871 set_gdbarch_pseudo_register_write (gdbarch,
2872 csky_pseudo_register_write);
2873 set_tdesc_pseudo_register_name (gdbarch, csky_pseudo_register_name);
2874 }
2875
2876 return gdbarch;
2877 }
2878
2879 void _initialize_csky_tdep ();
2880 void
2881 _initialize_csky_tdep ()
2882 {
2883
2884 gdbarch_register (bfd_arch_csky, csky_gdbarch_init);
2885
2886 csky_init_reggroup ();
2887
2888 /* Allow debugging this file's internals. */
2889 add_setshow_boolean_cmd ("csky", class_maintenance, &csky_debug,
2890 _("Set C-Sky debugging."),
2891 _("Show C-Sky debugging."),
2892 _("When on, C-Sky specific debugging is enabled."),
2893 NULL,
2894 NULL,
2895 &setdebuglist, &showdebuglist);
2896 }
The GNU Binutils are a collection of binary tools.