projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Comment tidy
[deliverable/binutils-gdb.git] / gdb / nds32-tdep.c
1 /* Target-dependent code for the NDS32 architecture, for GDB.
2
3 Copyright (C) 2013-2017 Free Software Foundation, Inc.
4 Contributed by Andes Technology Corporation.
5
6 This file is part of GDB.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20
21 #include "defs.h"
22 #include "frame.h"
23 #include "frame-unwind.h"
24 #include "frame-base.h"
25 #include "symtab.h"
26 #include "gdbtypes.h"
27 #include "gdbcore.h"
28 #include "value.h"
29 #include "reggroups.h"
30 #include "inferior.h"
31 #include "osabi.h"
32 #include "arch-utils.h"
33 #include "regcache.h"
34 #include "dis-asm.h"
35 #include "user-regs.h"
36 #include "elf-bfd.h"
37 #include "dwarf2-frame.h"
38 #include "remote.h"
39 #include "target-descriptions.h"
40
41 #include "nds32-tdep.h"
42 #include "elf/nds32.h"
43 #include "opcode/nds32.h"
44 #include <algorithm>
45
46 #include "features/nds32.c"
47
48 /* Simple macros for instruction analysis. */
49 #define CHOP_BITS(insn, n) (insn & ~__MASK (n))
50 #define N32_LSMW_ENABLE4(insn) (((insn) >> 6) & 0xf)
51 #define N32_SMW_ADM \
52 N32_TYPE4 (LSMW, 0, 0, 0, 1, (N32_LSMW_ADM << 2) | N32_LSMW_LSMW)
53 #define N32_LMW_BIM \
54 N32_TYPE4 (LSMW, 0, 0, 0, 0, (N32_LSMW_BIM << 2) | N32_LSMW_LSMW)
55 #define N32_FLDI_SP \
56 N32_TYPE2 (LDC, 0, REG_SP, 0)
57
58 /* Use an invalid address value as 'not available' marker. */
59 enum { REG_UNAVAIL = (CORE_ADDR) -1 };
60
61 /* Use an impossible value as invalid offset. */
62 enum { INVALID_OFFSET = (CORE_ADDR) -1 };
63
64 /* Instruction groups for NDS32 epilogue analysis. */
65 enum
66 {
67 /* Instructions used everywhere, not only in epilogue. */
68 INSN_NORMAL,
69 /* Instructions used to reset sp for local vars, arguments, etc. */
70 INSN_RESET_SP,
71 /* Instructions used to recover saved regs and to recover padding. */
72 INSN_RECOVER,
73 /* Instructions used to return to the caller. */
74 INSN_RETURN,
75 /* Instructions used to recover saved regs and to return to the caller. */
76 INSN_RECOVER_RETURN,
77 };
78
79 static const char *const nds32_register_names[] =
80 {
81 /* 32 GPRs. */
82 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
83 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
84 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
85 "r24", "r25", "r26", "r27", "fp", "gp", "lp", "sp",
86 /* PC. */
87 "pc",
88 };
89
90 static const char *const nds32_fdr_register_names[] =
91 {
92 "fd0", "fd1", "fd2", "fd3", "fd4", "fd5", "fd6", "fd7",
93 "fd8", "fd9", "fd10", "fd11", "fd12", "fd13", "fd14", "fd15",
94 "fd16", "fd17", "fd18", "fd19", "fd20", "fd21", "fd22", "fd23",
95 "fd24", "fd25", "fd26", "fd27", "fd28", "fd29", "fd30", "fd31"
96 };
97
98 static const char *const nds32_fsr_register_names[] =
99 {
100 "fs0", "fs1", "fs2", "fs3", "fs4", "fs5", "fs6", "fs7",
101 "fs8", "fs9", "fs10", "fs11", "fs12", "fs13", "fs14", "fs15",
102 "fs16", "fs17", "fs18", "fs19", "fs20", "fs21", "fs22", "fs23",
103 "fs24", "fs25", "fs26", "fs27", "fs28", "fs29", "fs30", "fs31"
104 };
105
106 /* The number of registers for four FPU configuration options. */
107 const int num_fdr_map[] = { 4, 8, 16, 32 };
108 const int num_fsr_map[] = { 8, 16, 32, 32 };
109
110 /* Aliases for registers. */
111 static const struct
112 {
113 const char *name;
114 const char *alias;
115 } nds32_register_aliases[] =
116 {
117 {"r15", "ta"},
118 {"r26", "p0"},
119 {"r27", "p1"},
120 {"fp", "r28"},
121 {"gp", "r29"},
122 {"lp", "r30"},
123 {"sp", "r31"},
124
125 {"cr0", "cpu_ver"},
126 {"cr1", "icm_cfg"},
127 {"cr2", "dcm_cfg"},
128 {"cr3", "mmu_cfg"},
129 {"cr4", "msc_cfg"},
130 {"cr5", "core_id"},
131 {"cr6", "fucop_exist"},
132 {"cr7", "msc_cfg2"},
133
134 {"ir0", "psw"},
135 {"ir1", "ipsw"},
136 {"ir2", "p_psw"},
137 {"ir3", "ivb"},
138 {"ir4", "eva"},
139 {"ir5", "p_eva"},
140 {"ir6", "itype"},
141 {"ir7", "p_itype"},
142 {"ir8", "merr"},
143 {"ir9", "ipc"},
144 {"ir10", "p_ipc"},
145 {"ir11", "oipc"},
146 {"ir12", "p_p0"},
147 {"ir13", "p_p1"},
148 {"ir14", "int_mask"},
149 {"ir15", "int_pend"},
150 {"ir16", "sp_usr"},
151 {"ir17", "sp_priv"},
152 {"ir18", "int_pri"},
153 {"ir19", "int_ctrl"},
154 {"ir20", "sp_usr1"},
155 {"ir21", "sp_priv1"},
156 {"ir22", "sp_usr2"},
157 {"ir23", "sp_priv2"},
158 {"ir24", "sp_usr3"},
159 {"ir25", "sp_priv3"},
160 {"ir26", "int_mask2"},
161 {"ir27", "int_pend2"},
162 {"ir28", "int_pri2"},
163 {"ir29", "int_trigger"},
164
165 {"mr0", "mmu_ctl"},
166 {"mr1", "l1_pptb"},
167 {"mr2", "tlb_vpn"},
168 {"mr3", "tlb_data"},
169 {"mr4", "tlb_misc"},
170 {"mr5", "vlpt_idx"},
171 {"mr6", "ilmb"},
172 {"mr7", "dlmb"},
173 {"mr8", "cache_ctl"},
174 {"mr9", "hsmp_saddr"},
175 {"mr10", "hsmp_eaddr"},
176 {"mr11", "bg_region"},
177
178 {"dr0", "bpc0"},
179 {"dr1", "bpc1"},
180 {"dr2", "bpc2"},
181 {"dr3", "bpc3"},
182 {"dr4", "bpc4"},
183 {"dr5", "bpc5"},
184 {"dr6", "bpc6"},
185 {"dr7", "bpc7"},
186 {"dr8", "bpa0"},
187 {"dr9", "bpa1"},
188 {"dr10", "bpa2"},
189 {"dr11", "bpa3"},
190 {"dr12", "bpa4"},
191 {"dr13", "bpa5"},
192 {"dr14", "bpa6"},
193 {"dr15", "bpa7"},
194 {"dr16", "bpam0"},
195 {"dr17", "bpam1"},
196 {"dr18", "bpam2"},
197 {"dr19", "bpam3"},
198 {"dr20", "bpam4"},
199 {"dr21", "bpam5"},
200 {"dr22", "bpam6"},
201 {"dr23", "bpam7"},
202 {"dr24", "bpv0"},
203 {"dr25", "bpv1"},
204 {"dr26", "bpv2"},
205 {"dr27", "bpv3"},
206 {"dr28", "bpv4"},
207 {"dr29", "bpv5"},
208 {"dr30", "bpv6"},
209 {"dr31", "bpv7"},
210 {"dr32", "bpcid0"},
211 {"dr33", "bpcid1"},
212 {"dr34", "bpcid2"},
213 {"dr35", "bpcid3"},
214 {"dr36", "bpcid4"},
215 {"dr37", "bpcid5"},
216 {"dr38", "bpcid6"},
217 {"dr39", "bpcid7"},
218 {"dr40", "edm_cfg"},
219 {"dr41", "edmsw"},
220 {"dr42", "edm_ctl"},
221 {"dr43", "edm_dtr"},
222 {"dr44", "bpmtc"},
223 {"dr45", "dimbr"},
224 {"dr46", "tecr0"},
225 {"dr47", "tecr1"},
226
227 {"hspr0", "hsp_ctl"},
228 {"hspr1", "sp_bound"},
229 {"hspr2", "sp_bound_priv"},
230
231 {"pfr0", "pfmc0"},
232 {"pfr1", "pfmc1"},
233 {"pfr2", "pfmc2"},
234 {"pfr3", "pfm_ctl"},
235 {"pfr4", "pft_ctl"},
236
237 {"dmar0", "dma_cfg"},
238 {"dmar1", "dma_gcsw"},
239 {"dmar2", "dma_chnsel"},
240 {"dmar3", "dma_act"},
241 {"dmar4", "dma_setup"},
242 {"dmar5", "dma_isaddr"},
243 {"dmar6", "dma_esaddr"},
244 {"dmar7", "dma_tcnt"},
245 {"dmar8", "dma_status"},
246 {"dmar9", "dma_2dset"},
247 {"dmar10", "dma_2dsctl"},
248 {"dmar11", "dma_rcnt"},
249 {"dmar12", "dma_hstatus"},
250
251 {"racr0", "prusr_acc_ctl"},
252 {"fucpr", "fucop_ctl"},
253
254 {"idr0", "sdz_ctl"},
255 {"idr1", "misc_ctl"},
256 {"idr2", "ecc_misc"},
257
258 {"secur0", "sfcr"},
259 {"secur1", "sign"},
260 {"secur2", "isign"},
261 {"secur3", "p_isign"},
262 };
263
264 /* Value of a register alias. BATON is the regnum of the corresponding
265 register. */
266
267 static struct value *
268 value_of_nds32_reg (struct frame_info *frame, const void *baton)
269 {
270 return value_of_register ((int) (intptr_t) baton, frame);
271 }
272 \f
273 /* Implement the "frame_align" gdbarch method. */
274
275 static CORE_ADDR
276 nds32_frame_align (struct gdbarch *gdbarch, CORE_ADDR sp)
277 {
278 /* 8-byte aligned. */
279 return align_down (sp, 8);
280 }
281
282 /* The same insn machine code is used for little-endian and big-endian. */
283 constexpr gdb_byte nds32_break_insn[] = { 0xEA, 0x00 };
284
285 typedef BP_MANIPULATION (nds32_break_insn) nds32_breakpoint;
286
287 /* Implement the "dwarf2_reg_to_regnum" gdbarch method. */
288
289 static int
290 nds32_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, int num)
291 {
292 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
293 const int FSR = 38;
294 const int FDR = FSR + 32;
295
296 if (num >= 0 && num < 32)
297 {
298 /* General-purpose registers (R0 - R31). */
299 return num;
300 }
301 else if (num >= FSR && num < FSR + 32)
302 {
303 /* Single precision floating-point registers (FS0 - FS31). */
304 return num - FSR + tdep->fs0_regnum;
305 }
306 else if (num >= FDR && num < FDR + 32)
307 {
308 /* Double precision floating-point registers (FD0 - FD31). */
309 return num - FDR + NDS32_FD0_REGNUM;
310 }
311
312 /* No match, return a inaccessible register number. */
313 return -1;
314 }
315 \f
316 /* NDS32 register groups. */
317 static struct reggroup *nds32_cr_reggroup;
318 static struct reggroup *nds32_ir_reggroup;
319 static struct reggroup *nds32_mr_reggroup;
320 static struct reggroup *nds32_dr_reggroup;
321 static struct reggroup *nds32_pfr_reggroup;
322 static struct reggroup *nds32_hspr_reggroup;
323 static struct reggroup *nds32_dmar_reggroup;
324 static struct reggroup *nds32_racr_reggroup;
325 static struct reggroup *nds32_idr_reggroup;
326 static struct reggroup *nds32_secur_reggroup;
327
328 static void
329 nds32_init_reggroups (void)
330 {
331 nds32_cr_reggroup = reggroup_new ("cr", USER_REGGROUP);
332 nds32_ir_reggroup = reggroup_new ("ir", USER_REGGROUP);
333 nds32_mr_reggroup = reggroup_new ("mr", USER_REGGROUP);
334 nds32_dr_reggroup = reggroup_new ("dr", USER_REGGROUP);
335 nds32_pfr_reggroup = reggroup_new ("pfr", USER_REGGROUP);
336 nds32_hspr_reggroup = reggroup_new ("hspr", USER_REGGROUP);
337 nds32_dmar_reggroup = reggroup_new ("dmar", USER_REGGROUP);
338 nds32_racr_reggroup = reggroup_new ("racr", USER_REGGROUP);
339 nds32_idr_reggroup = reggroup_new ("idr", USER_REGGROUP);
340 nds32_secur_reggroup = reggroup_new ("secur", USER_REGGROUP);
341 }
342
343 static void
344 nds32_add_reggroups (struct gdbarch *gdbarch)
345 {
346 /* Add pre-defined register groups. */
347 reggroup_add (gdbarch, general_reggroup);
348 reggroup_add (gdbarch, float_reggroup);
349 reggroup_add (gdbarch, system_reggroup);
350 reggroup_add (gdbarch, all_reggroup);
351 reggroup_add (gdbarch, save_reggroup);
352 reggroup_add (gdbarch, restore_reggroup);
353
354 /* Add NDS32 register groups. */
355 reggroup_add (gdbarch, nds32_cr_reggroup);
356 reggroup_add (gdbarch, nds32_ir_reggroup);
357 reggroup_add (gdbarch, nds32_mr_reggroup);
358 reggroup_add (gdbarch, nds32_dr_reggroup);
359 reggroup_add (gdbarch, nds32_pfr_reggroup);
360 reggroup_add (gdbarch, nds32_hspr_reggroup);
361 reggroup_add (gdbarch, nds32_dmar_reggroup);
362 reggroup_add (gdbarch, nds32_racr_reggroup);
363 reggroup_add (gdbarch, nds32_idr_reggroup);
364 reggroup_add (gdbarch, nds32_secur_reggroup);
365 }
366
367 /* Implement the "register_reggroup_p" gdbarch method. */
368
369 static int
370 nds32_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
371 struct reggroup *reggroup)
372 {
373 const char *reg_name;
374 const char *group_name;
375 int ret;
376
377 if (reggroup == all_reggroup)
378 return 1;
379
380 /* General reggroup contains only GPRs and PC. */
381 if (reggroup == general_reggroup)
382 return regnum <= NDS32_PC_REGNUM;
383
384 if (reggroup == float_reggroup || reggroup == save_reggroup
385 || reggroup == restore_reggroup)
386 {
387 ret = tdesc_register_in_reggroup_p (gdbarch, regnum, reggroup);
388 if (ret != -1)
389 return ret;
390
391 return default_register_reggroup_p (gdbarch, regnum, reggroup);
392 }
393
394 if (reggroup == system_reggroup)
395 return (regnum > NDS32_PC_REGNUM)
396 && !nds32_register_reggroup_p (gdbarch, regnum, float_reggroup);
397
398 /* The NDS32 reggroup contains registers whose name is prefixed
399 by reggroup name. */
400 reg_name = gdbarch_register_name (gdbarch, regnum);
401 group_name = reggroup_name (reggroup);
402 return !strncmp (reg_name, group_name, strlen (group_name));
403 }
404 \f
405 /* Implement the "pseudo_register_type" tdesc_arch_data method. */
406
407 static struct type *
408 nds32_pseudo_register_type (struct gdbarch *gdbarch, int regnum)
409 {
410 regnum -= gdbarch_num_regs (gdbarch);
411
412 /* Currently, only FSRs could be defined as pseudo registers. */
413 if (regnum < gdbarch_num_pseudo_regs (gdbarch))
414 return arch_float_type (gdbarch, -1, "builtin_type_ieee_single",
415 floatformats_ieee_single);
416
417 warning (_("Unknown nds32 pseudo register %d."), regnum);
418 return NULL;
419 }
420
421 /* Implement the "pseudo_register_name" tdesc_arch_data method. */
422
423 static const char *
424 nds32_pseudo_register_name (struct gdbarch *gdbarch, int regnum)
425 {
426 regnum -= gdbarch_num_regs (gdbarch);
427
428 /* Currently, only FSRs could be defined as pseudo registers. */
429 if (regnum < gdbarch_num_pseudo_regs (gdbarch))
430 return nds32_fsr_register_names[regnum];
431
432 warning (_("Unknown nds32 pseudo register %d."), regnum);
433 return NULL;
434 }
435
436 /* Implement the "pseudo_register_read" gdbarch method. */
437
438 static enum register_status
439 nds32_pseudo_register_read (struct gdbarch *gdbarch,
440 struct regcache *regcache, int regnum,
441 gdb_byte *buf)
442 {
443 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
444 gdb_byte reg_buf[8];
445 int offset, fdr_regnum;
446 enum register_status status;
447
448 /* This function is registered in nds32_gdbarch_init only after these are
449 set. */
450 gdb_assert (tdep->fpu_freg != -1);
451 gdb_assert (tdep->use_pseudo_fsrs != 0);
452
453 regnum -= gdbarch_num_regs (gdbarch);
454
455 /* Currently, only FSRs could be defined as pseudo registers. */
456 if (regnum < gdbarch_num_pseudo_regs (gdbarch))
457 {
458 /* fs0 is always the most significant half of fd0. */
459 if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
460 offset = (regnum & 1) ? 4 : 0;
461 else
462 offset = (regnum & 1) ? 0 : 4;
463
464 fdr_regnum = NDS32_FD0_REGNUM + (regnum >> 1);
465 status = regcache_raw_read (regcache, fdr_regnum, reg_buf);
466 if (status == REG_VALID)
467 memcpy (buf, reg_buf + offset, 4);
468
469 return status;
470 }
471
472 gdb_assert_not_reached ("invalid pseudo register number");
473 }
474
475 /* Implement the "pseudo_register_write" gdbarch method. */
476
477 static void
478 nds32_pseudo_register_write (struct gdbarch *gdbarch,
479 struct regcache *regcache, int regnum,
480 const gdb_byte *buf)
481 {
482 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
483 gdb_byte reg_buf[8];
484 int offset, fdr_regnum;
485
486 /* This function is registered in nds32_gdbarch_init only after these are
487 set. */
488 gdb_assert (tdep->fpu_freg != -1);
489 gdb_assert (tdep->use_pseudo_fsrs != 0);
490
491 regnum -= gdbarch_num_regs (gdbarch);
492
493 /* Currently, only FSRs could be defined as pseudo registers. */
494 if (regnum < gdbarch_num_pseudo_regs (gdbarch))
495 {
496 /* fs0 is always the most significant half of fd0. */
497 if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
498 offset = (regnum & 1) ? 4 : 0;
499 else
500 offset = (regnum & 1) ? 0 : 4;
501
502 fdr_regnum = NDS32_FD0_REGNUM + (regnum >> 1);
503 regcache_raw_read (regcache, fdr_regnum, reg_buf);
504 memcpy (reg_buf + offset, buf, 4);
505 regcache_raw_write (regcache, fdr_regnum, reg_buf);
506 return;
507 }
508
509 gdb_assert_not_reached ("invalid pseudo register number");
510 }
511 \f
512 /* Helper function for NDS32 ABI. Return true if FPRs can be used
513 to pass function arguments and return value. */
514
515 static int
516 nds32_abi_use_fpr (int elf_abi)
517 {
518 return elf_abi == E_NDS_ABI_V2FP_PLUS;
519 }
520
521 /* Helper function for NDS32 ABI. Return true if GPRs and stack
522 can be used together to pass an argument. */
523
524 static int
525 nds32_abi_split (int elf_abi)
526 {
527 return elf_abi == E_NDS_ABI_AABI;
528 }
529
530 #define NDS32_NUM_SAVED_REGS (NDS32_LP_REGNUM + 1)
531
532 struct nds32_frame_cache
533 {
534 /* The previous frame's inner most stack address. Used as this
535 frame ID's stack_addr. */
536 CORE_ADDR prev_sp;
537
538 /* The frame's base, optionally used by the high-level debug info. */
539 CORE_ADDR base;
540
541 /* During prologue analysis, keep how far the SP and FP have been offset
542 from the start of the stack frame (as defined by the previous frame's
543 stack pointer).
544 During epilogue analysis, keep how far the SP has been offset from the
545 current stack pointer. */
546 CORE_ADDR sp_offset;
547 CORE_ADDR fp_offset;
548
549 /* The address of the first instruction in this function. */
550 CORE_ADDR pc;
551
552 /* Saved registers. */
553 CORE_ADDR saved_regs[NDS32_NUM_SAVED_REGS];
554 };
555
556 /* Allocate and initialize a frame cache. */
557
558 static struct nds32_frame_cache *
559 nds32_alloc_frame_cache (void)
560 {
561 struct nds32_frame_cache *cache;
562 int i;
563
564 cache = FRAME_OBSTACK_ZALLOC (struct nds32_frame_cache);
565
566 /* Initialize fp_offset to check if FP is set in prologue. */
567 cache->fp_offset = INVALID_OFFSET;
568
569 /* Saved registers. We initialize these to -1 since zero is a valid
570 offset. */
571 for (i = 0; i < NDS32_NUM_SAVED_REGS; i++)
572 cache->saved_regs[i] = REG_UNAVAIL;
573
574 return cache;
575 }
576
577 /* Helper function for instructions used to push multiple words. */
578
579 static void
580 nds32_push_multiple_words (struct nds32_frame_cache *cache, int rb, int re,
581 int enable4)
582 {
583 CORE_ADDR sp_offset = cache->sp_offset;
584 int i;
585
586 /* Check LP, GP, FP in enable4. */
587 for (i = 1; i <= 3; i++)
588 {
589 if ((enable4 >> i) & 0x1)
590 {
591 sp_offset += 4;
592 cache->saved_regs[NDS32_SP_REGNUM - i] = sp_offset;
593 }
594 }
595
596 /* Skip case where re == rb == sp. */
597 if ((rb < REG_FP) && (re < REG_FP))
598 {
599 for (i = re; i >= rb; i--)
600 {
601 sp_offset += 4;
602 cache->saved_regs[i] = sp_offset;
603 }
604 }
605
606 /* For sp, update the offset. */
607 cache->sp_offset = sp_offset;
608 }
609
610 /* Analyze the instructions within the given address range. If CACHE
611 is non-NULL, fill it in. Return the first address beyond the given
612 address range. If CACHE is NULL, return the first address not
613 recognized as a prologue instruction. */
614
615 static CORE_ADDR
616 nds32_analyze_prologue (struct gdbarch *gdbarch, CORE_ADDR pc,
617 CORE_ADDR limit_pc, struct nds32_frame_cache *cache)
618 {
619 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
620 int abi_use_fpr = nds32_abi_use_fpr (tdep->elf_abi);
621 /* Current scanning status. */
622 int in_prologue_bb = 0;
623 int val_ta = 0;
624 uint32_t insn, insn_len;
625
626 for (; pc < limit_pc; pc += insn_len)
627 {
628 insn = read_memory_unsigned_integer (pc, 4, BFD_ENDIAN_BIG);
629
630 if ((insn & 0x80000000) == 0)
631 {
632 /* 32-bit instruction */
633 insn_len = 4;
634
635 if (CHOP_BITS (insn, 15) == N32_TYPE2 (ADDI, REG_SP, REG_SP, 0))
636 {
637 /* addi $sp, $sp, imm15s */
638 int imm15s = N32_IMM15S (insn);
639
640 if (imm15s < 0)
641 {
642 if (cache != NULL)
643 cache->sp_offset += -imm15s;
644
645 in_prologue_bb = 1;
646 continue;
647 }
648 }
649 else if (CHOP_BITS (insn, 15) == N32_TYPE2 (ADDI, REG_FP, REG_SP, 0))
650 {
651 /* addi $fp, $sp, imm15s */
652 int imm15s = N32_IMM15S (insn);
653
654 if (imm15s > 0)
655 {
656 if (cache != NULL)
657 cache->fp_offset = cache->sp_offset - imm15s;
658
659 in_prologue_bb = 1;
660 continue;
661 }
662 }
663 else if ((insn & ~(__MASK (19) << 6)) == N32_SMW_ADM
664 && N32_RA5 (insn) == REG_SP)
665 {
666 /* smw.adm Rb, [$sp], Re, enable4 */
667 if (cache != NULL)
668 nds32_push_multiple_words (cache, N32_RT5 (insn),
669 N32_RB5 (insn),
670 N32_LSMW_ENABLE4 (insn));
671 in_prologue_bb = 1;
672 continue;
673 }
674 else if (insn == N32_ALU1 (ADD, REG_SP, REG_SP, REG_TA)
675 || insn == N32_ALU1 (ADD, REG_SP, REG_TA, REG_SP))
676 {
677 /* add $sp, $sp, $ta */
678 /* add $sp, $ta, $sp */
679 if (val_ta < 0)
680 {
681 if (cache != NULL)
682 cache->sp_offset += -val_ta;
683
684 in_prologue_bb = 1;
685 continue;
686 }
687 }
688 else if (CHOP_BITS (insn, 20) == N32_TYPE1 (MOVI, REG_TA, 0))
689 {
690 /* movi $ta, imm20s */
691 if (cache != NULL)
692 val_ta = N32_IMM20S (insn);
693
694 continue;
695 }
696 else if (CHOP_BITS (insn, 20) == N32_TYPE1 (SETHI, REG_TA, 0))
697 {
698 /* sethi $ta, imm20u */
699 if (cache != NULL)
700 val_ta = N32_IMM20U (insn) << 12;
701
702 continue;
703 }
704 else if (CHOP_BITS (insn, 15) == N32_TYPE2 (ORI, REG_TA, REG_TA, 0))
705 {
706 /* ori $ta, $ta, imm15u */
707 if (cache != NULL)
708 val_ta |= N32_IMM15U (insn);
709
710 continue;
711 }
712 else if (CHOP_BITS (insn, 15) == N32_TYPE2 (ADDI, REG_TA, REG_TA, 0))
713 {
714 /* addi $ta, $ta, imm15s */
715 if (cache != NULL)
716 val_ta += N32_IMM15S (insn);
717
718 continue;
719 }
720 if (insn == N32_ALU1 (ADD, REG_GP, REG_TA, REG_GP)
721 || insn == N32_ALU1 (ADD, REG_GP, REG_GP, REG_TA))
722 {
723 /* add $gp, $ta, $gp */
724 /* add $gp, $gp, $ta */
725 in_prologue_bb = 1;
726 continue;
727 }
728 else if (CHOP_BITS (insn, 20) == N32_TYPE1 (MOVI, REG_GP, 0))
729 {
730 /* movi $gp, imm20s */
731 in_prologue_bb = 1;
732 continue;
733 }
734 else if (CHOP_BITS (insn, 20) == N32_TYPE1 (SETHI, REG_GP, 0))
735 {
736 /* sethi $gp, imm20u */
737 in_prologue_bb = 1;
738 continue;
739 }
740 else if (CHOP_BITS (insn, 15) == N32_TYPE2 (ORI, REG_GP, REG_GP, 0))
741 {
742 /* ori $gp, $gp, imm15u */
743 in_prologue_bb = 1;
744 continue;
745 }
746 else
747 {
748 /* Jump/Branch insns never appear in prologue basic block.
749 The loop can be escaped early when these insns are met. */
750 if (in_prologue_bb == 1)
751 {
752 int op = N32_OP6 (insn);
753
754 if (op == N32_OP6_JI
755 || op == N32_OP6_JREG
756 || op == N32_OP6_BR1
757 || op == N32_OP6_BR2
758 || op == N32_OP6_BR3)
759 break;
760 }
761 }
762
763 if (abi_use_fpr && N32_OP6 (insn) == N32_OP6_SDC
764 && __GF (insn, 12, 3) == 0)
765 {
766 /* For FPU insns, CP (bit [13:14]) should be CP0, and only
767 normal form (bit [12] == 0) is used. */
768
769 /* fsdi FDt, [$sp + (imm12s << 2)] */
770 if (N32_RA5 (insn) == REG_SP)
771 continue;
772 }
773
774 /* The optimizer might shove anything into the prologue, if
775 we build up cache (cache != NULL) from analyzing prologue,
776 we just skip what we don't recognize and analyze further to
777 make cache as complete as possible. However, if we skip
778 prologue, we'll stop immediately on unrecognized
779 instruction. */
780 if (cache == NULL)
781 break;
782 }
783 else
784 {
785 /* 16-bit instruction */
786 insn_len = 2;
787
788 insn >>= 16;
789
790 if (CHOP_BITS (insn, 10) == N16_TYPE10 (ADDI10S, 0))
791 {
792 /* addi10s.sp */
793 int imm10s = N16_IMM10S (insn);
794
795 if (imm10s < 0)
796 {
797 if (cache != NULL)
798 cache->sp_offset += -imm10s;
799
800 in_prologue_bb = 1;
801 continue;
802 }
803 }
804 else if (__GF (insn, 7, 8) == N16_T25_PUSH25)
805 {
806 /* push25 */
807 if (cache != NULL)
808 {
809 int imm8u = (insn & 0x1f) << 3;
810 int re = (insn >> 5) & 0x3;
811 const int reg_map[] = { 6, 8, 10, 14 };
812
813 /* Operation 1 -- smw.adm R6, [$sp], Re, #0xe */
814 nds32_push_multiple_words (cache, 6, reg_map[re], 0xe);
815
816 /* Operation 2 -- sp = sp - (imm5u << 3) */
817 cache->sp_offset += imm8u;
818 }
819
820 in_prologue_bb = 1;
821 continue;
822 }
823 else if (insn == N16_TYPE5 (ADD5PC, REG_GP))
824 {
825 /* add5.pc $gp */
826 in_prologue_bb = 1;
827 continue;
828 }
829 else if (CHOP_BITS (insn, 5) == N16_TYPE55 (MOVI55, REG_GP, 0))
830 {
831 /* movi55 $gp, imm5s */
832 in_prologue_bb = 1;
833 continue;
834 }
835 else
836 {
837 /* Jump/Branch insns never appear in prologue basic block.
838 The loop can be escaped early when these insns are met. */
839 if (in_prologue_bb == 1)
840 {
841 uint32_t insn5 = CHOP_BITS (insn, 5);
842 uint32_t insn8 = CHOP_BITS (insn, 8);
843 uint32_t insn38 = CHOP_BITS (insn, 11);
844
845 if (insn5 == N16_TYPE5 (JR5, 0)
846 || insn5 == N16_TYPE5 (JRAL5, 0)
847 || insn5 == N16_TYPE5 (RET5, 0)
848 || insn8 == N16_TYPE8 (J8, 0)
849 || insn8 == N16_TYPE8 (BEQZS8, 0)
850 || insn8 == N16_TYPE8 (BNEZS8, 0)
851 || insn38 == N16_TYPE38 (BEQZ38, 0, 0)
852 || insn38 == N16_TYPE38 (BNEZ38, 0, 0)
853 || insn38 == N16_TYPE38 (BEQS38, 0, 0)
854 || insn38 == N16_TYPE38 (BNES38, 0, 0))
855 break;
856 }
857 }
858
859 /* The optimizer might shove anything into the prologue, if
860 we build up cache (cache != NULL) from analyzing prologue,
861 we just skip what we don't recognize and analyze further to
862 make cache as complete as possible. However, if we skip
863 prologue, we'll stop immediately on unrecognized
864 instruction. */
865 if (cache == NULL)
866 break;
867 }
868 }
869
870 return pc;
871 }
872
873 /* Implement the "skip_prologue" gdbarch method.
874
875 Find the end of function prologue. */
876
877 static CORE_ADDR
878 nds32_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
879 {
880 CORE_ADDR func_addr, limit_pc;
881
882 /* See if we can determine the end of the prologue via the symbol table.
883 If so, then return either PC, or the PC after the prologue, whichever
884 is greater. */
885 if (find_pc_partial_function (pc, NULL, &func_addr, NULL))
886 {
887 CORE_ADDR post_prologue_pc
888 = skip_prologue_using_sal (gdbarch, func_addr);
889 if (post_prologue_pc != 0)
890 return std::max (pc, post_prologue_pc);
891 }
892
893 /* Can't determine prologue from the symbol table, need to examine
894 instructions. */
895
896 /* Find an upper limit on the function prologue using the debug
897 information. If the debug information could not be used to provide
898 that bound, then use an arbitrary large number as the upper bound. */
899 limit_pc = skip_prologue_using_sal (gdbarch, pc);
900 if (limit_pc == 0)
901 limit_pc = pc + 128; /* Magic. */
902
903 /* Find the end of prologue. */
904 return nds32_analyze_prologue (gdbarch, pc, limit_pc, NULL);
905 }
906
907 /* Allocate and fill in *THIS_CACHE with information about the prologue of
908 *THIS_FRAME. Do not do this if *THIS_CACHE was already allocated. Return
909 a pointer to the current nds32_frame_cache in *THIS_CACHE. */
910
911 static struct nds32_frame_cache *
912 nds32_frame_cache (struct frame_info *this_frame, void **this_cache)
913 {
914 struct gdbarch *gdbarch = get_frame_arch (this_frame);
915 struct nds32_frame_cache *cache;
916 CORE_ADDR current_pc;
917 ULONGEST prev_sp;
918 ULONGEST this_base;
919 int i;
920
921 if (*this_cache)
922 return (struct nds32_frame_cache *) *this_cache;
923
924 cache = nds32_alloc_frame_cache ();
925 *this_cache = cache;
926
927 cache->pc = get_frame_func (this_frame);
928 current_pc = get_frame_pc (this_frame);
929 nds32_analyze_prologue (gdbarch, cache->pc, current_pc, cache);
930
931 /* Compute the previous frame's stack pointer (which is also the
932 frame's ID's stack address), and this frame's base pointer. */
933 if (cache->fp_offset != INVALID_OFFSET)
934 {
935 /* FP is set in prologue, so it can be used to calculate other info. */
936 this_base = get_frame_register_unsigned (this_frame, NDS32_FP_REGNUM);
937 prev_sp = this_base + cache->fp_offset;
938 }
939 else
940 {
941 this_base = get_frame_register_unsigned (this_frame, NDS32_SP_REGNUM);
942 prev_sp = this_base + cache->sp_offset;
943 }
944
945 cache->prev_sp = prev_sp;
946 cache->base = this_base;
947
948 /* Adjust all the saved registers such that they contain addresses
949 instead of offsets. */
950 for (i = 0; i < NDS32_NUM_SAVED_REGS; i++)
951 if (cache->saved_regs[i] != REG_UNAVAIL)
952 cache->saved_regs[i] = cache->prev_sp - cache->saved_regs[i];
953
954 return cache;
955 }
956
957 /* Implement the "this_id" frame_unwind method.
958
959 Our frame ID for a normal frame is the current function's starting
960 PC and the caller's SP when we were called. */
961
962 static void
963 nds32_frame_this_id (struct frame_info *this_frame,
964 void **this_cache, struct frame_id *this_id)
965 {
966 struct nds32_frame_cache *cache = nds32_frame_cache (this_frame, this_cache);
967
968 /* This marks the outermost frame. */
969 if (cache->prev_sp == 0)
970 return;
971
972 *this_id = frame_id_build (cache->prev_sp, cache->pc);
973 }
974
975 /* Implement the "prev_register" frame_unwind method. */
976
977 static struct value *
978 nds32_frame_prev_register (struct frame_info *this_frame, void **this_cache,
979 int regnum)
980 {
981 struct nds32_frame_cache *cache = nds32_frame_cache (this_frame, this_cache);
982
983 if (regnum == NDS32_SP_REGNUM)
984 return frame_unwind_got_constant (this_frame, regnum, cache->prev_sp);
985
986 /* The PC of the previous frame is stored in the LP register of
987 the current frame. */
988 if (regnum == NDS32_PC_REGNUM)
989 regnum = NDS32_LP_REGNUM;
990
991 if (regnum < NDS32_NUM_SAVED_REGS && cache->saved_regs[regnum] != REG_UNAVAIL)
992 return frame_unwind_got_memory (this_frame, regnum,
993 cache->saved_regs[regnum]);
994
995 return frame_unwind_got_register (this_frame, regnum, regnum);
996 }
997
998 static const struct frame_unwind nds32_frame_unwind =
999 {
1000 NORMAL_FRAME,
1001 default_frame_unwind_stop_reason,
1002 nds32_frame_this_id,
1003 nds32_frame_prev_register,
1004 NULL,
1005 default_frame_sniffer,
1006 };
1007
1008 /* Return the frame base address of *THIS_FRAME. */
1009
1010 static CORE_ADDR
1011 nds32_frame_base_address (struct frame_info *this_frame, void **this_cache)
1012 {
1013 struct nds32_frame_cache *cache = nds32_frame_cache (this_frame, this_cache);
1014
1015 return cache->base;
1016 }
1017
1018 static const struct frame_base nds32_frame_base =
1019 {
1020 &nds32_frame_unwind,
1021 nds32_frame_base_address,
1022 nds32_frame_base_address,
1023 nds32_frame_base_address
1024 };
1025 \f
1026 /* Helper function for instructions used to pop multiple words. */
1027
1028 static void
1029 nds32_pop_multiple_words (struct nds32_frame_cache *cache, int rb, int re,
1030 int enable4)
1031 {
1032 CORE_ADDR sp_offset = cache->sp_offset;
1033 int i;
1034
1035 /* Skip case where re == rb == sp. */
1036 if ((rb < REG_FP) && (re < REG_FP))
1037 {
1038 for (i = rb; i <= re; i++)
1039 {
1040 cache->saved_regs[i] = sp_offset;
1041 sp_offset += 4;
1042 }
1043 }
1044
1045 /* Check FP, GP, LP in enable4. */
1046 for (i = 3; i >= 1; i--)
1047 {
1048 if ((enable4 >> i) & 0x1)
1049 {
1050 cache->saved_regs[NDS32_SP_REGNUM - i] = sp_offset;
1051 sp_offset += 4;
1052 }
1053 }
1054
1055 /* For sp, update the offset. */
1056 cache->sp_offset = sp_offset;
1057 }
1058
1059 /* The instruction sequences in NDS32 epilogue are
1060
1061 INSN_RESET_SP (optional)
1062 (If exists, this must be the first instruction in epilogue
1063 and the stack has not been destroyed.).
1064 INSN_RECOVER (optional).
1065 INSN_RETURN/INSN_RECOVER_RETURN (required). */
1066
1067 /* Helper function for analyzing the given 32-bit INSN. If CACHE is non-NULL,
1068 the necessary information will be recorded. */
1069
1070 static inline int
1071 nds32_analyze_epilogue_insn32 (int abi_use_fpr, uint32_t insn,
1072 struct nds32_frame_cache *cache)
1073 {
1074 if (CHOP_BITS (insn, 15) == N32_TYPE2 (ADDI, REG_SP, REG_SP, 0)
1075 && N32_IMM15S (insn) > 0)
1076 /* addi $sp, $sp, imm15s */
1077 return INSN_RESET_SP;
1078 else if (CHOP_BITS (insn, 15) == N32_TYPE2 (ADDI, REG_SP, REG_FP, 0)
1079 && N32_IMM15S (insn) < 0)
1080 /* addi $sp, $fp, imm15s */
1081 return INSN_RESET_SP;
1082 else if ((insn & ~(__MASK (19) << 6)) == N32_LMW_BIM
1083 && N32_RA5 (insn) == REG_SP)
1084 {
1085 /* lmw.bim Rb, [$sp], Re, enable4 */
1086 if (cache != NULL)
1087 nds32_pop_multiple_words (cache, N32_RT5 (insn),
1088 N32_RB5 (insn), N32_LSMW_ENABLE4 (insn));
1089
1090 return INSN_RECOVER;
1091 }
1092 else if (insn == N32_JREG (JR, 0, REG_LP, 0, 1))
1093 /* ret $lp */
1094 return INSN_RETURN;
1095 else if (insn == N32_ALU1 (ADD, REG_SP, REG_SP, REG_TA)
1096 || insn == N32_ALU1 (ADD, REG_SP, REG_TA, REG_SP))
1097 /* add $sp, $sp, $ta */
1098 /* add $sp, $ta, $sp */
1099 return INSN_RESET_SP;
1100 else if (abi_use_fpr
1101 && (insn & ~(__MASK (5) << 20 | __MASK (13))) == N32_FLDI_SP)
1102 {
1103 if (__GF (insn, 12, 1) == 0)
1104 /* fldi FDt, [$sp + (imm12s << 2)] */
1105 return INSN_RECOVER;
1106 else
1107 {
1108 /* fldi.bi FDt, [$sp], (imm12s << 2) */
1109 int offset = N32_IMM12S (insn) << 2;
1110
1111 if (offset == 8 || offset == 12)
1112 {
1113 if (cache != NULL)
1114 cache->sp_offset += offset;
1115
1116 return INSN_RECOVER;
1117 }
1118 }
1119 }
1120
1121 return INSN_NORMAL;
1122 }
1123
1124 /* Helper function for analyzing the given 16-bit INSN. If CACHE is non-NULL,
1125 the necessary information will be recorded. */
1126
1127 static inline int
1128 nds32_analyze_epilogue_insn16 (uint32_t insn, struct nds32_frame_cache *cache)
1129 {
1130 if (insn == N16_TYPE5 (RET5, REG_LP))
1131 /* ret5 $lp */
1132 return INSN_RETURN;
1133 else if (CHOP_BITS (insn, 10) == N16_TYPE10 (ADDI10S, 0))
1134 {
1135 /* addi10s.sp */
1136 int imm10s = N16_IMM10S (insn);
1137
1138 if (imm10s > 0)
1139 {
1140 if (cache != NULL)
1141 cache->sp_offset += imm10s;
1142
1143 return INSN_RECOVER;
1144 }
1145 }
1146 else if (__GF (insn, 7, 8) == N16_T25_POP25)
1147 {
1148 /* pop25 */
1149 if (cache != NULL)
1150 {
1151 int imm8u = (insn & 0x1f) << 3;
1152 int re = (insn >> 5) & 0x3;
1153 const int reg_map[] = { 6, 8, 10, 14 };
1154
1155 /* Operation 1 -- sp = sp + (imm5u << 3) */
1156 cache->sp_offset += imm8u;
1157
1158 /* Operation 2 -- lmw.bim R6, [$sp], Re, #0xe */
1159 nds32_pop_multiple_words (cache, 6, reg_map[re], 0xe);
1160 }
1161
1162 /* Operation 3 -- ret $lp */
1163 return INSN_RECOVER_RETURN;
1164 }
1165
1166 return INSN_NORMAL;
1167 }
1168
1169 /* Analyze a reasonable amount of instructions from the given PC to find
1170 the instruction used to return to the caller. Return 1 if the 'return'
1171 instruction could be found, 0 otherwise.
1172
1173 If CACHE is non-NULL, fill it in. */
1174
1175 static int
1176 nds32_analyze_epilogue (struct gdbarch *gdbarch, CORE_ADDR pc,
1177 struct nds32_frame_cache *cache)
1178 {
1179 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1180 int abi_use_fpr = nds32_abi_use_fpr (tdep->elf_abi);
1181 CORE_ADDR limit_pc;
1182 uint32_t insn, insn_len;
1183 int insn_type = INSN_NORMAL;
1184
1185 if (abi_use_fpr)
1186 limit_pc = pc + 48;
1187 else
1188 limit_pc = pc + 16;
1189
1190 for (; pc < limit_pc; pc += insn_len)
1191 {
1192 insn = read_memory_unsigned_integer (pc, 4, BFD_ENDIAN_BIG);
1193
1194 if ((insn & 0x80000000) == 0)
1195 {
1196 /* 32-bit instruction */
1197 insn_len = 4;
1198
1199 insn_type = nds32_analyze_epilogue_insn32 (abi_use_fpr, insn, cache);
1200 if (insn_type == INSN_RETURN)
1201 return 1;
1202 else if (insn_type == INSN_RECOVER)
1203 continue;
1204 }
1205 else
1206 {
1207 /* 16-bit instruction */
1208 insn_len = 2;
1209
1210 insn >>= 16;
1211 insn_type = nds32_analyze_epilogue_insn16 (insn, cache);
1212 if (insn_type == INSN_RETURN || insn_type == INSN_RECOVER_RETURN)
1213 return 1;
1214 else if (insn_type == INSN_RECOVER)
1215 continue;
1216 }
1217
1218 /* Stop the scan if this is an unexpected instruction. */
1219 break;
1220 }
1221
1222 return 0;
1223 }
1224
1225 /* Implement the "stack_frame_destroyed_p" gdbarch method. */
1226
1227 static int
1228 nds32_stack_frame_destroyed_p (struct gdbarch *gdbarch, CORE_ADDR addr)
1229 {
1230 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1231 int abi_use_fpr = nds32_abi_use_fpr (tdep->elf_abi);
1232 int insn_type = INSN_NORMAL;
1233 int ret_found = 0;
1234 uint32_t insn;
1235
1236 insn = read_memory_unsigned_integer (addr, 4, BFD_ENDIAN_BIG);
1237
1238 if ((insn & 0x80000000) == 0)
1239 {
1240 /* 32-bit instruction */
1241
1242 insn_type = nds32_analyze_epilogue_insn32 (abi_use_fpr, insn, NULL);
1243 }
1244 else
1245 {
1246 /* 16-bit instruction */
1247
1248 insn >>= 16;
1249 insn_type = nds32_analyze_epilogue_insn16 (insn, NULL);
1250 }
1251
1252 if (insn_type == INSN_NORMAL || insn_type == INSN_RESET_SP)
1253 return 0;
1254
1255 /* Search the required 'return' instruction within the following reasonable
1256 instructions. */
1257 ret_found = nds32_analyze_epilogue (gdbarch, addr, NULL);
1258 if (ret_found == 0)
1259 return 0;
1260
1261 /* Scan backwards to make sure that the last instruction has adjusted
1262 stack. Both a 16-bit and a 32-bit instruction will be tried. This is
1263 just a heuristic, so the false positives will be acceptable. */
1264 insn = read_memory_unsigned_integer (addr - 2, 4, BFD_ENDIAN_BIG);
1265
1266 /* Only 16-bit instructions are possible at addr - 2. */
1267 if ((insn & 0x80000000) != 0)
1268 {
1269 /* This may be a 16-bit instruction or part of a 32-bit instruction. */
1270
1271 insn_type = nds32_analyze_epilogue_insn16 (insn >> 16, NULL);
1272 if (insn_type == INSN_RECOVER)
1273 return 1;
1274 }
1275
1276 insn = read_memory_unsigned_integer (addr - 4, 4, BFD_ENDIAN_BIG);
1277
1278 /* If this is a 16-bit instruction at addr - 4, then there must be another
1279 16-bit instruction at addr - 2, so only 32-bit instructions need to
1280 be analyzed here. */
1281 if ((insn & 0x80000000) == 0)
1282 {
1283 /* This may be a 32-bit instruction or part of a 32-bit instruction. */
1284
1285 insn_type = nds32_analyze_epilogue_insn32 (abi_use_fpr, insn, NULL);
1286 if (insn_type == INSN_RECOVER || insn_type == INSN_RESET_SP)
1287 return 1;
1288 }
1289
1290 return 0;
1291 }
1292
1293 /* Implement the "sniffer" frame_unwind method. */
1294
1295 static int
1296 nds32_epilogue_frame_sniffer (const struct frame_unwind *self,
1297 struct frame_info *this_frame, void **this_cache)
1298 {
1299 if (frame_relative_level (this_frame) == 0)
1300 return nds32_stack_frame_destroyed_p (get_frame_arch (this_frame),
1301 get_frame_pc (this_frame));
1302 else
1303 return 0;
1304 }
1305
1306 /* Allocate and fill in *THIS_CACHE with information needed to unwind
1307 *THIS_FRAME within epilogue. Do not do this if *THIS_CACHE was already
1308 allocated. Return a pointer to the current nds32_frame_cache in
1309 *THIS_CACHE. */
1310
1311 static struct nds32_frame_cache *
1312 nds32_epilogue_frame_cache (struct frame_info *this_frame, void **this_cache)
1313 {
1314 struct gdbarch *gdbarch = get_frame_arch (this_frame);
1315 struct nds32_frame_cache *cache;
1316 CORE_ADDR current_pc, current_sp;
1317 int i;
1318
1319 if (*this_cache)
1320 return (struct nds32_frame_cache *) *this_cache;
1321
1322 cache = nds32_alloc_frame_cache ();
1323 *this_cache = cache;
1324
1325 cache->pc = get_frame_func (this_frame);
1326 current_pc = get_frame_pc (this_frame);
1327 nds32_analyze_epilogue (gdbarch, current_pc, cache);
1328
1329 current_sp = get_frame_register_unsigned (this_frame, NDS32_SP_REGNUM);
1330 cache->prev_sp = current_sp + cache->sp_offset;
1331
1332 /* Adjust all the saved registers such that they contain addresses
1333 instead of offsets. */
1334 for (i = 0; i < NDS32_NUM_SAVED_REGS; i++)
1335 if (cache->saved_regs[i] != REG_UNAVAIL)
1336 cache->saved_regs[i] = current_sp + cache->saved_regs[i];
1337
1338 return cache;
1339 }
1340
1341 /* Implement the "this_id" frame_unwind method. */
1342
1343 static void
1344 nds32_epilogue_frame_this_id (struct frame_info *this_frame,
1345 void **this_cache, struct frame_id *this_id)
1346 {
1347 struct nds32_frame_cache *cache
1348 = nds32_epilogue_frame_cache (this_frame, this_cache);
1349
1350 /* This marks the outermost frame. */
1351 if (cache->prev_sp == 0)
1352 return;
1353
1354 *this_id = frame_id_build (cache->prev_sp, cache->pc);
1355 }
1356
1357 /* Implement the "prev_register" frame_unwind method. */
1358
1359 static struct value *
1360 nds32_epilogue_frame_prev_register (struct frame_info *this_frame,
1361 void **this_cache, int regnum)
1362 {
1363 struct nds32_frame_cache *cache
1364 = nds32_epilogue_frame_cache (this_frame, this_cache);
1365
1366 if (regnum == NDS32_SP_REGNUM)
1367 return frame_unwind_got_constant (this_frame, regnum, cache->prev_sp);
1368
1369 /* The PC of the previous frame is stored in the LP register of
1370 the current frame. */
1371 if (regnum == NDS32_PC_REGNUM)
1372 regnum = NDS32_LP_REGNUM;
1373
1374 if (regnum < NDS32_NUM_SAVED_REGS && cache->saved_regs[regnum] != REG_UNAVAIL)
1375 return frame_unwind_got_memory (this_frame, regnum,
1376 cache->saved_regs[regnum]);
1377
1378 return frame_unwind_got_register (this_frame, regnum, regnum);
1379 }
1380
1381 static const struct frame_unwind nds32_epilogue_frame_unwind =
1382 {
1383 NORMAL_FRAME,
1384 default_frame_unwind_stop_reason,
1385 nds32_epilogue_frame_this_id,
1386 nds32_epilogue_frame_prev_register,
1387 NULL,
1388 nds32_epilogue_frame_sniffer
1389 };
1390 \f
1391 /* Implement the "dummy_id" gdbarch method. */
1392
1393 static struct frame_id
1394 nds32_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
1395 {
1396 CORE_ADDR sp = get_frame_register_unsigned (this_frame, NDS32_SP_REGNUM);
1397
1398 return frame_id_build (sp, get_frame_pc (this_frame));
1399 }
1400
1401 /* Implement the "unwind_pc" gdbarch method. */
1402
1403 static CORE_ADDR
1404 nds32_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
1405 {
1406 return frame_unwind_register_unsigned (next_frame, NDS32_PC_REGNUM);
1407 }
1408
1409 /* Implement the "unwind_sp" gdbarch method. */
1410
1411 static CORE_ADDR
1412 nds32_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
1413 {
1414 return frame_unwind_register_unsigned (next_frame, NDS32_SP_REGNUM);
1415 }
1416 \f
1417 /* Floating type and struct type that has only one floating type member
1418 can pass value using FPU registers (when FPU ABI is used). */
1419
1420 static int
1421 nds32_check_calling_use_fpr (struct type *type)
1422 {
1423 struct type *t;
1424 enum type_code typecode;
1425
1426 t = type;
1427 while (1)
1428 {
1429 t = check_typedef (t);
1430 typecode = TYPE_CODE (t);
1431 if (typecode != TYPE_CODE_STRUCT)
1432 break;
1433 else if (TYPE_NFIELDS (t) != 1)
1434 return 0;
1435 else
1436 t = TYPE_FIELD_TYPE (t, 0);
1437 }
1438
1439 return typecode == TYPE_CODE_FLT;
1440 }
1441
1442 /* Return the alignment (in bytes) of the given type. */
1443
1444 static int
1445 nds32_type_align (struct type *type)
1446 {
1447 int n;
1448 int align;
1449 int falign;
1450
1451 type = check_typedef (type);
1452 switch (TYPE_CODE (type))
1453 {
1454 default:
1455 /* Should never happen. */
1456 internal_error (__FILE__, __LINE__, _("unknown type alignment"));
1457 return 4;
1458
1459 case TYPE_CODE_PTR:
1460 case TYPE_CODE_ENUM:
1461 case TYPE_CODE_INT:
1462 case TYPE_CODE_FLT:
1463 case TYPE_CODE_SET:
1464 case TYPE_CODE_RANGE:
1465 case TYPE_CODE_REF:
1466 case TYPE_CODE_CHAR:
1467 case TYPE_CODE_BOOL:
1468 return TYPE_LENGTH (type);
1469
1470 case TYPE_CODE_ARRAY:
1471 case TYPE_CODE_COMPLEX:
1472 return nds32_type_align (TYPE_TARGET_TYPE (type));
1473
1474 case TYPE_CODE_STRUCT:
1475 case TYPE_CODE_UNION:
1476 align = 1;
1477 for (n = 0; n < TYPE_NFIELDS (type); n++)
1478 {
1479 falign = nds32_type_align (TYPE_FIELD_TYPE (type, n));
1480 if (falign > align)
1481 align = falign;
1482 }
1483 return align;
1484 }
1485 }
1486
1487 /* Implement the "push_dummy_call" gdbarch method. */
1488
1489 static CORE_ADDR
1490 nds32_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
1491 struct regcache *regcache, CORE_ADDR bp_addr,
1492 int nargs, struct value **args, CORE_ADDR sp,
1493 int struct_return, CORE_ADDR struct_addr)
1494 {
1495 const int REND = 6; /* End for register offset. */
1496 int goff = 0; /* Current gpr offset for argument. */
1497 int foff = 0; /* Current fpr offset for argument. */
1498 int soff = 0; /* Current stack offset for argument. */
1499 int i;
1500 ULONGEST regval;
1501 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1502 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1503 struct type *func_type = value_type (function);
1504 int abi_use_fpr = nds32_abi_use_fpr (tdep->elf_abi);
1505 int abi_split = nds32_abi_split (tdep->elf_abi);
1506
1507 /* Set the return address. For the NDS32, the return breakpoint is
1508 always at BP_ADDR. */
1509 regcache_cooked_write_unsigned (regcache, NDS32_LP_REGNUM, bp_addr);
1510
1511 /* If STRUCT_RETURN is true, then the struct return address (in
1512 STRUCT_ADDR) will consume the first argument-passing register.
1513 Both adjust the register count and store that value. */
1514 if (struct_return)
1515 {
1516 regcache_cooked_write_unsigned (regcache, NDS32_R0_REGNUM, struct_addr);
1517 goff++;
1518 }
1519
1520 /* Now make sure there's space on the stack */
1521 for (i = 0; i < nargs; i++)
1522 {
1523 struct type *type = value_type (args[i]);
1524 int align = nds32_type_align (type);
1525
1526 /* If align is zero, it may be an empty struct.
1527 Just ignore the argument of empty struct. */
1528 if (align == 0)
1529 continue;
1530
1531 sp -= TYPE_LENGTH (type);
1532 sp = align_down (sp, align);
1533 }
1534
1535 /* Stack must be 8-byte aligned. */
1536 sp = align_down (sp, 8);
1537
1538 soff = 0;
1539 for (i = 0; i < nargs; i++)
1540 {
1541 const gdb_byte *val;
1542 int align, len;
1543 struct type *type;
1544 int calling_use_fpr;
1545 int use_fpr = 0;
1546
1547 type = value_type (args[i]);
1548 calling_use_fpr = nds32_check_calling_use_fpr (type);
1549 len = TYPE_LENGTH (type);
1550 align = nds32_type_align (type);
1551 val = value_contents (args[i]);
1552
1553 /* The size of a composite type larger than 4 bytes will be rounded
1554 up to the nearest multiple of 4. */
1555 if (len > 4)
1556 len = align_up (len, 4);
1557
1558 /* Variadic functions are handled differently between AABI and ABI2FP+.
1559
1560 For AABI, the caller pushes arguments in registers, callee stores
1561 unnamed arguments in stack, and then va_arg fetch arguments in stack.
1562 Therefore, we don't have to handle variadic functions specially.
1563
1564 For ABI2FP+, the caller pushes only named arguments in registers
1565 and pushes all unnamed arguments in stack. */
1566
1567 if (abi_use_fpr && TYPE_VARARGS (func_type)
1568 && i >= TYPE_NFIELDS (func_type))
1569 goto use_stack;
1570
1571 /* Try to use FPRs to pass arguments only when
1572 1. The program is built using toolchain with FPU support.
1573 2. The type of this argument can use FPR to pass value. */
1574 use_fpr = abi_use_fpr && calling_use_fpr;
1575
1576 if (use_fpr)
1577 {
1578 if (tdep->fpu_freg == -1)
1579 goto error_no_fpr;
1580
1581 /* Adjust alignment. */
1582 if ((align >> 2) > 0)
1583 foff = align_up (foff, align >> 2);
1584
1585 if (foff < REND)
1586 {
1587 switch (len)
1588 {
1589 case 4:
1590 regcache_cooked_write (regcache,
1591 tdep->fs0_regnum + foff, val);
1592 foff++;
1593 break;
1594 case 8:
1595 regcache_cooked_write (regcache,
1596 NDS32_FD0_REGNUM + (foff >> 1), val);
1597 foff += 2;
1598 break;
1599 default:
1600 /* Long double? */
1601 internal_error (__FILE__, __LINE__,
1602 "Do not know how to handle %d-byte double.\n",
1603 len);
1604 break;
1605 }
1606 continue;
1607 }
1608 }
1609 else
1610 {
1611 /*
1612 When passing arguments using GPRs,
1613
1614 * A composite type not larger than 4 bytes is passed in $rN.
1615 The format is as if the value is loaded with load instruction
1616 of corresponding size (e.g., LB, LH, LW).
1617
1618 For example,
1619
1620 r0
1621 31 0
1622 LITTLE: [x x b a]
1623 BIG: [x x a b]
1624
1625 * Otherwise, a composite type is passed in consecutive registers.
1626 The size is rounded up to the nearest multiple of 4.
1627 The successive registers hold the parts of the argument as if
1628 were loaded using lmw instructions.
1629
1630 For example,
1631
1632 r0 r1
1633 31 0 31 0
1634 LITTLE: [d c b a] [x x x e]
1635 BIG: [a b c d] [e x x x]
1636 */
1637
1638 /* Adjust alignment. */
1639 if ((align >> 2) > 0)
1640 goff = align_up (goff, align >> 2);
1641
1642 if (len <= (REND - goff) * 4)
1643 {
1644 /* This argument can be passed wholly via GPRs. */
1645 while (len > 0)
1646 {
1647 regval = extract_unsigned_integer (val, (len > 4) ? 4 : len,
1648 byte_order);
1649 regcache_cooked_write_unsigned (regcache,
1650 NDS32_R0_REGNUM + goff,
1651 regval);
1652 len -= 4;
1653 val += 4;
1654 goff++;
1655 }
1656 continue;
1657 }
1658 else if (abi_split)
1659 {
1660 /* Some parts of this argument can be passed via GPRs. */
1661 while (goff < REND)
1662 {
1663 regval = extract_unsigned_integer (val, (len > 4) ? 4 : len,
1664 byte_order);
1665 regcache_cooked_write_unsigned (regcache,
1666 NDS32_R0_REGNUM + goff,
1667 regval);
1668 len -= 4;
1669 val += 4;
1670 goff++;
1671 }
1672 }
1673 }
1674
1675 use_stack:
1676 /*
1677 When pushing (split parts of) an argument into stack,
1678
1679 * A composite type not larger than 4 bytes is copied to different
1680 base address.
1681 In little-endian, the first byte of this argument is aligned
1682 at the low address of the next free word.
1683 In big-endian, the last byte of this argument is aligned
1684 at the high address of the next free word.
1685
1686 For example,
1687
1688 sp [ - ] [ c ] hi
1689 [ c ] [ b ]
1690 [ b ] [ a ]
1691 [ a ] [ - ] lo
1692 LITTLE BIG
1693 */
1694
1695 /* Adjust alignment. */
1696 soff = align_up (soff, align);
1697
1698 while (len > 0)
1699 {
1700 int rlen = (len > 4) ? 4 : len;
1701
1702 if (byte_order == BFD_ENDIAN_BIG)
1703 write_memory (sp + soff + 4 - rlen, val, rlen);
1704 else
1705 write_memory (sp + soff, val, rlen);
1706
1707 len -= 4;
1708 val += 4;
1709 soff += 4;
1710 }
1711 }
1712
1713 /* Finally, update the SP register. */
1714 regcache_cooked_write_unsigned (regcache, NDS32_SP_REGNUM, sp);
1715
1716 return sp;
1717
1718 error_no_fpr:
1719 /* If use_fpr, but no floating-point register exists,
1720 then it is an error. */
1721 error (_("Fail to call. FPU registers are required."));
1722 }
1723 \f
1724 /* Read, for architecture GDBARCH, a function return value of TYPE
1725 from REGCACHE, and copy that into VALBUF. */
1726
1727 static void
1728 nds32_extract_return_value (struct gdbarch *gdbarch, struct type *type,
1729 struct regcache *regcache, gdb_byte *valbuf)
1730 {
1731 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1732 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1733 int abi_use_fpr = nds32_abi_use_fpr (tdep->elf_abi);
1734 int calling_use_fpr;
1735 int len;
1736
1737 calling_use_fpr = nds32_check_calling_use_fpr (type);
1738 len = TYPE_LENGTH (type);
1739
1740 if (abi_use_fpr && calling_use_fpr)
1741 {
1742 if (len == 4)
1743 regcache_cooked_read (regcache, tdep->fs0_regnum, valbuf);
1744 else if (len == 8)
1745 regcache_cooked_read (regcache, NDS32_FD0_REGNUM, valbuf);
1746 else
1747 internal_error (__FILE__, __LINE__,
1748 _("Cannot extract return value of %d bytes "
1749 "long floating-point."), len);
1750 }
1751 else
1752 {
1753 /*
1754 When returning result,
1755
1756 * A composite type not larger than 4 bytes is returned in $r0.
1757 The format is as if the result is loaded with load instruction
1758 of corresponding size (e.g., LB, LH, LW).
1759
1760 For example,
1761
1762 r0
1763 31 0
1764 LITTLE: [x x b a]
1765 BIG: [x x a b]
1766
1767 * Otherwise, a composite type not larger than 8 bytes is returned
1768 in $r0 and $r1.
1769 In little-endian, the first word is loaded in $r0.
1770 In big-endian, the last word is loaded in $r1.
1771
1772 For example,
1773
1774 r0 r1
1775 31 0 31 0
1776 LITTLE: [d c b a] [x x x e]
1777 BIG: [x x x a] [b c d e]
1778 */
1779
1780 ULONGEST tmp;
1781
1782 if (len < 4)
1783 {
1784 /* By using store_unsigned_integer we avoid having to do
1785 anything special for small big-endian values. */
1786 regcache_cooked_read_unsigned (regcache, NDS32_R0_REGNUM, &tmp);
1787 store_unsigned_integer (valbuf, len, byte_order, tmp);
1788 }
1789 else if (len == 4)
1790 {
1791 regcache_cooked_read (regcache, NDS32_R0_REGNUM, valbuf);
1792 }
1793 else if (len < 8)
1794 {
1795 int len1, len2;
1796
1797 len1 = byte_order == BFD_ENDIAN_BIG ? len - 4 : 4;
1798 len2 = len - len1;
1799
1800 regcache_cooked_read_unsigned (regcache, NDS32_R0_REGNUM, &tmp);
1801 store_unsigned_integer (valbuf, len1, byte_order, tmp);
1802
1803 regcache_cooked_read_unsigned (regcache, NDS32_R0_REGNUM + 1, &tmp);
1804 store_unsigned_integer (valbuf + len1, len2, byte_order, tmp);
1805 }
1806 else
1807 {
1808 regcache_cooked_read (regcache, NDS32_R0_REGNUM, valbuf);
1809 regcache_cooked_read (regcache, NDS32_R0_REGNUM + 1, valbuf + 4);
1810 }
1811 }
1812 }
1813
1814 /* Write, for architecture GDBARCH, a function return value of TYPE
1815 from VALBUF into REGCACHE. */
1816
1817 static void
1818 nds32_store_return_value (struct gdbarch *gdbarch, struct type *type,
1819 struct regcache *regcache, const gdb_byte *valbuf)
1820 {
1821 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1822 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1823 int abi_use_fpr = nds32_abi_use_fpr (tdep->elf_abi);
1824 int calling_use_fpr;
1825 int len;
1826
1827 calling_use_fpr = nds32_check_calling_use_fpr (type);
1828 len = TYPE_LENGTH (type);
1829
1830 if (abi_use_fpr && calling_use_fpr)
1831 {
1832 if (len == 4)
1833 regcache_cooked_write (regcache, tdep->fs0_regnum, valbuf);
1834 else if (len == 8)
1835 regcache_cooked_write (regcache, NDS32_FD0_REGNUM, valbuf);
1836 else
1837 internal_error (__FILE__, __LINE__,
1838 _("Cannot store return value of %d bytes "
1839 "long floating-point."), len);
1840 }
1841 else
1842 {
1843 ULONGEST regval;
1844
1845 if (len < 4)
1846 {
1847 regval = extract_unsigned_integer (valbuf, len, byte_order);
1848 regcache_cooked_write_unsigned (regcache, NDS32_R0_REGNUM, regval);
1849 }
1850 else if (len == 4)
1851 {
1852 regcache_cooked_write (regcache, NDS32_R0_REGNUM, valbuf);
1853 }
1854 else if (len < 8)
1855 {
1856 int len1, len2;
1857
1858 len1 = byte_order == BFD_ENDIAN_BIG ? len - 4 : 4;
1859 len2 = len - len1;
1860
1861 regval = extract_unsigned_integer (valbuf, len1, byte_order);
1862 regcache_cooked_write_unsigned (regcache, NDS32_R0_REGNUM, regval);
1863
1864 regval = extract_unsigned_integer (valbuf + len1, len2, byte_order);
1865 regcache_cooked_write_unsigned (regcache, NDS32_R0_REGNUM + 1,
1866 regval);
1867 }
1868 else
1869 {
1870 regcache_cooked_write (regcache, NDS32_R0_REGNUM, valbuf);
1871 regcache_cooked_write (regcache, NDS32_R0_REGNUM + 1, valbuf + 4);
1872 }
1873 }
1874 }
1875
1876 /* Implement the "return_value" gdbarch method.
1877
1878 Determine, for architecture GDBARCH, how a return value of TYPE
1879 should be returned. If it is supposed to be returned in registers,
1880 and READBUF is non-zero, read the appropriate value from REGCACHE,
1881 and copy it into READBUF. If WRITEBUF is non-zero, write the value
1882 from WRITEBUF into REGCACHE. */
1883
1884 static enum return_value_convention
1885 nds32_return_value (struct gdbarch *gdbarch, struct value *func_type,
1886 struct type *type, struct regcache *regcache,
1887 gdb_byte *readbuf, const gdb_byte *writebuf)
1888 {
1889 if (TYPE_LENGTH (type) > 8)
1890 {
1891 return RETURN_VALUE_STRUCT_CONVENTION;
1892 }
1893 else
1894 {
1895 if (readbuf != NULL)
1896 nds32_extract_return_value (gdbarch, type, regcache, readbuf);
1897 if (writebuf != NULL)
1898 nds32_store_return_value (gdbarch, type, regcache, writebuf);
1899
1900 return RETURN_VALUE_REGISTER_CONVENTION;
1901 }
1902 }
1903 \f
1904 /* Implement the "get_longjmp_target" gdbarch method. */
1905
1906 static int
1907 nds32_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
1908 {
1909 gdb_byte buf[4];
1910 CORE_ADDR jb_addr;
1911 struct gdbarch *gdbarch = get_frame_arch (frame);
1912 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1913
1914 jb_addr = get_frame_register_unsigned (frame, NDS32_R0_REGNUM);
1915
1916 if (target_read_memory (jb_addr + 11 * 4, buf, 4))
1917 return 0;
1918
1919 *pc = extract_unsigned_integer (buf, 4, byte_order);
1920 return 1;
1921 }
1922 \f
1923 /* Validate the given TDESC, and fixed-number some registers in it.
1924 Return 0 if the given TDESC does not contain the required feature
1925 or not contain required registers. */
1926
1927 static int
1928 nds32_validate_tdesc_p (const struct target_desc *tdesc,
1929 struct tdesc_arch_data *tdesc_data,
1930 int *fpu_freg, int *use_pseudo_fsrs)
1931 {
1932 const struct tdesc_feature *feature;
1933 int i, valid_p;
1934
1935 feature = tdesc_find_feature (tdesc, "org.gnu.gdb.nds32.core");
1936 if (feature == NULL)
1937 return 0;
1938
1939 valid_p = 1;
1940 /* Validate and fixed-number R0-R10. */
1941 for (i = NDS32_R0_REGNUM; i <= NDS32_R0_REGNUM + 10; i++)
1942 valid_p &= tdesc_numbered_register (feature, tdesc_data, i,
1943 nds32_register_names[i]);
1944
1945 /* Validate R15. */
1946 valid_p &= tdesc_unnumbered_register (feature,
1947 nds32_register_names[NDS32_TA_REGNUM]);
1948
1949 /* Validate and fixed-number FP, GP, LP, SP, PC. */
1950 for (i = NDS32_FP_REGNUM; i <= NDS32_PC_REGNUM; i++)
1951 valid_p &= tdesc_numbered_register (feature, tdesc_data, i,
1952 nds32_register_names[i]);
1953
1954 if (!valid_p)
1955 return 0;
1956
1957 /* Fixed-number R11-R27. */
1958 for (i = NDS32_R0_REGNUM + 11; i <= NDS32_R0_REGNUM + 27; i++)
1959 tdesc_numbered_register (feature, tdesc_data, i, nds32_register_names[i]);
1960
1961 feature = tdesc_find_feature (tdesc, "org.gnu.gdb.nds32.fpu");
1962 if (feature != NULL)
1963 {
1964 int num_fdr_regs, num_fsr_regs, fs0_regnum, num_listed_fsr;
1965 int freg = -1;
1966
1967 /* Guess FPU configuration via listed registers. */
1968 if (tdesc_unnumbered_register (feature, "fd31"))
1969 freg = 3;
1970 else if (tdesc_unnumbered_register (feature, "fd15"))
1971 freg = 2;
1972 else if (tdesc_unnumbered_register (feature, "fd7"))
1973 freg = 1;
1974 else if (tdesc_unnumbered_register (feature, "fd3"))
1975 freg = 0;
1976
1977 if (freg == -1)
1978 /* Required FDR is not found. */
1979 return 0;
1980 else
1981 *fpu_freg = freg;
1982
1983 /* Validate and fixed-number required FDRs. */
1984 num_fdr_regs = num_fdr_map[freg];
1985 for (i = 0; i < num_fdr_regs; i++)
1986 valid_p &= tdesc_numbered_register (feature, tdesc_data,
1987 NDS32_FD0_REGNUM + i,
1988 nds32_fdr_register_names[i]);
1989 if (!valid_p)
1990 return 0;
1991
1992 /* Count the number of listed FSRs, and fixed-number them if present. */
1993 num_fsr_regs = num_fsr_map[freg];
1994 fs0_regnum = NDS32_FD0_REGNUM + num_fdr_regs;
1995 num_listed_fsr = 0;
1996 for (i = 0; i < num_fsr_regs; i++)
1997 num_listed_fsr += tdesc_numbered_register (feature, tdesc_data,
1998 fs0_regnum + i,
1999 nds32_fsr_register_names[i]);
2000
2001 if (num_listed_fsr == 0)
2002 /* No required FSRs are listed explicitly, make them pseudo registers
2003 of FDRs. */
2004 *use_pseudo_fsrs = 1;
2005 else if (num_listed_fsr == num_fsr_regs)
2006 /* All required FSRs are listed explicitly. */
2007 *use_pseudo_fsrs = 0;
2008 else
2009 /* Some required FSRs are missing. */
2010 return 0;
2011 }
2012
2013 return 1;
2014 }
2015
2016 /* Initialize the current architecture based on INFO. If possible,
2017 re-use an architecture from ARCHES, which is a list of
2018 architectures already created during this debugging session.
2019
2020 Called e.g. at program startup, when reading a core file, and when
2021 reading a binary file. */
2022
2023 static struct gdbarch *
2024 nds32_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
2025 {
2026 struct gdbarch *gdbarch;
2027 struct gdbarch_tdep *tdep;
2028 struct gdbarch_list *best_arch;
2029 struct tdesc_arch_data *tdesc_data = NULL;
2030 const struct target_desc *tdesc = info.target_desc;
2031 int elf_abi = E_NDS_ABI_AABI;
2032 int fpu_freg = -1;
2033 int use_pseudo_fsrs = 0;
2034 int i, num_regs, maxregs;
2035
2036 /* Extract the elf_flags if available. */
2037 if (info.abfd && bfd_get_flavour (info.abfd) == bfd_target_elf_flavour)
2038 elf_abi = elf_elfheader (info.abfd)->e_flags & EF_NDS_ABI;
2039
2040 /* If there is already a candidate, use it. */
2041 for (best_arch = gdbarch_list_lookup_by_info (arches, &info);
2042 best_arch != NULL;
2043 best_arch = gdbarch_list_lookup_by_info (best_arch->next, &info))
2044 {
2045 struct gdbarch_tdep *idep = gdbarch_tdep (best_arch->gdbarch);
2046
2047 if (idep->elf_abi != elf_abi)
2048 continue;
2049
2050 /* Found a match. */
2051 break;
2052 }
2053
2054 if (best_arch != NULL)
2055 return best_arch->gdbarch;
2056
2057 if (!tdesc_has_registers (tdesc))
2058 tdesc = tdesc_nds32;
2059
2060 tdesc_data = tdesc_data_alloc ();
2061
2062 if (!nds32_validate_tdesc_p (tdesc, tdesc_data, &fpu_freg, &use_pseudo_fsrs))
2063 {
2064 tdesc_data_cleanup (tdesc_data);
2065 return NULL;
2066 }
2067
2068 /* Allocate space for the new architecture. */
2069 tdep = XCNEW (struct gdbarch_tdep);
2070 tdep->fpu_freg = fpu_freg;
2071 tdep->use_pseudo_fsrs = use_pseudo_fsrs;
2072 tdep->fs0_regnum = -1;
2073 tdep->elf_abi = elf_abi;
2074
2075 gdbarch = gdbarch_alloc (&info, tdep);
2076
2077 set_gdbarch_wchar_bit (gdbarch, 16);
2078 set_gdbarch_wchar_signed (gdbarch, 0);
2079
2080 if (fpu_freg == -1)
2081 num_regs = NDS32_NUM_REGS;
2082 else if (use_pseudo_fsrs == 1)
2083 {
2084 set_gdbarch_pseudo_register_read (gdbarch, nds32_pseudo_register_read);
2085 set_gdbarch_pseudo_register_write (gdbarch, nds32_pseudo_register_write);
2086 set_tdesc_pseudo_register_name (gdbarch, nds32_pseudo_register_name);
2087 set_tdesc_pseudo_register_type (gdbarch, nds32_pseudo_register_type);
2088 set_gdbarch_num_pseudo_regs (gdbarch, num_fsr_map[fpu_freg]);
2089
2090 num_regs = NDS32_NUM_REGS + num_fdr_map[fpu_freg];
2091 }
2092 else
2093 num_regs = NDS32_NUM_REGS + num_fdr_map[fpu_freg] + num_fsr_map[fpu_freg];
2094
2095 set_gdbarch_num_regs (gdbarch, num_regs);
2096 tdesc_use_registers (gdbarch, tdesc, tdesc_data);
2097
2098 /* Cache the register number of fs0. */
2099 if (fpu_freg != -1)
2100 tdep->fs0_regnum = user_reg_map_name_to_regnum (gdbarch, "fs0", -1);
2101
2102 /* Add NDS32 register aliases. To avoid search in user register name space,
2103 user_reg_map_name_to_regnum is not used. */
2104 maxregs = (gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch));
2105 for (i = 0; i < ARRAY_SIZE (nds32_register_aliases); i++)
2106 {
2107 int regnum, j;
2108
2109 regnum = -1;
2110 /* Search register name space. */
2111 for (j = 0; j < maxregs; j++)
2112 {
2113 const char *regname = gdbarch_register_name (gdbarch, j);
2114
2115 if (regname != NULL
2116 && strcmp (regname, nds32_register_aliases[i].name) == 0)
2117 {
2118 regnum = j;
2119 break;
2120 }
2121 }
2122
2123 /* Try next alias entry if the given name can not be found in register
2124 name space. */
2125 if (regnum == -1)
2126 continue;
2127
2128 user_reg_add (gdbarch, nds32_register_aliases[i].alias,
2129 value_of_nds32_reg, (const void *) (intptr_t) regnum);
2130 }
2131
2132 nds32_add_reggroups (gdbarch);
2133
2134 /* Hook in ABI-specific overrides, if they have been registered. */
2135 info.tdesc_data = tdesc_data;
2136 gdbarch_init_osabi (info, gdbarch);
2137
2138 /* Override tdesc_register callbacks for system registers. */
2139 set_gdbarch_register_reggroup_p (gdbarch, nds32_register_reggroup_p);
2140
2141 set_gdbarch_sp_regnum (gdbarch, NDS32_SP_REGNUM);
2142 set_gdbarch_pc_regnum (gdbarch, NDS32_PC_REGNUM);
2143 set_gdbarch_unwind_sp (gdbarch, nds32_unwind_sp);
2144 set_gdbarch_unwind_pc (gdbarch, nds32_unwind_pc);
2145 set_gdbarch_stack_frame_destroyed_p (gdbarch, nds32_stack_frame_destroyed_p);
2146 set_gdbarch_dwarf2_reg_to_regnum (gdbarch, nds32_dwarf2_reg_to_regnum);
2147
2148 set_gdbarch_push_dummy_call (gdbarch, nds32_push_dummy_call);
2149 set_gdbarch_return_value (gdbarch, nds32_return_value);
2150 set_gdbarch_dummy_id (gdbarch, nds32_dummy_id);
2151
2152 set_gdbarch_skip_prologue (gdbarch, nds32_skip_prologue);
2153 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
2154 set_gdbarch_breakpoint_kind_from_pc (gdbarch,
2155 nds32_breakpoint::kind_from_pc);
2156 set_gdbarch_sw_breakpoint_from_kind (gdbarch,
2157 nds32_breakpoint::bp_from_kind);
2158
2159 set_gdbarch_frame_align (gdbarch, nds32_frame_align);
2160 frame_base_set_default (gdbarch, &nds32_frame_base);
2161
2162 /* Handle longjmp. */
2163 set_gdbarch_get_longjmp_target (gdbarch, nds32_get_longjmp_target);
2164
2165 /* The order of appending is the order it check frame. */
2166 dwarf2_append_unwinders (gdbarch);
2167 frame_unwind_append_unwinder (gdbarch, &nds32_epilogue_frame_unwind);
2168 frame_unwind_append_unwinder (gdbarch, &nds32_frame_unwind);
2169
2170 return gdbarch;
2171 }
2172
2173 void
2174 _initialize_nds32_tdep (void)
2175 {
2176 /* Initialize gdbarch. */
2177 register_gdbarch_init (bfd_arch_nds32, nds32_gdbarch_init);
2178
2179 initialize_tdesc_nds32 ();
2180 nds32_init_reggroups ();
2181 }
GDB Binutils - Deliverables
This page took 0.130994 seconds and 4 git commands to generate.