1 /* Target-machine dependent code for Nios II, for GDB.
2 Copyright (C) 2012-2014 Free Software Foundation, Inc.
3 Contributed by Peter Brookes (pbrookes@altera.com)
4 and Andrew Draper (adraper@altera.com).
5 Contributed by Mentor Graphics, Inc.
7 This file is part of GDB.
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.
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.
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/>. */
24 #include "frame-unwind.h"
25 #include "frame-base.h"
26 #include "trad-frame.h"
27 #include "dwarf2-frame.h"
39 #include "arch-utils.h"
40 #include "floatformat.h"
43 #include "target-descriptions.h"
45 /* To get entry_point_address. */
48 /* Nios II ISA specific encodings and macros. */
49 #include "opcode/nios2.h"
51 /* Nios II specific header. */
52 #include "nios2-tdep.h"
54 #include "features/nios2.c"
56 /* Control debugging information emitted in this file. */
58 static int nios2_debug
= 0;
60 /* The following structures are used in the cache for prologue
61 analysis; see the reg_value and reg_saved tables in
62 struct nios2_unwind_cache, respectively. */
64 /* struct reg_value is used to record that a register has the same value
65 as reg at the given offset from the start of a function. */
73 /* struct reg_saved is used to record that a register value has been saved at
74 basereg + addr, for basereg >= 0. If basereg < 0, that indicates
75 that the register is not known to have been saved. Note that when
76 basereg == NIOS2_Z_REGNUM (that is, r0, which holds value 0),
77 addr is an absolute address. */
85 struct nios2_unwind_cache
87 /* The frame's base, optionally used by the high-level debug info. */
90 /* The previous frame's inner most stack address. Used as this
91 frame ID's stack_addr. */
94 /* The address of the first instruction in this function. */
97 /* Which register holds the return address for the frame. */
100 /* Table indicating what changes have been made to each register. */
101 struct reg_value reg_value
[NIOS2_NUM_REGS
];
103 /* Table indicating where each register has been saved. */
104 struct reg_saved reg_saved
[NIOS2_NUM_REGS
];
108 /* This array is a mapping from Dwarf-2 register numbering to GDB's. */
110 static int nios2_dwarf2gdb_regno_map
[] =
119 NIOS2_GP_REGNUM
, /* 26 */
120 NIOS2_SP_REGNUM
, /* 27 */
121 NIOS2_FP_REGNUM
, /* 28 */
122 NIOS2_EA_REGNUM
, /* 29 */
123 NIOS2_BA_REGNUM
, /* 30 */
124 NIOS2_RA_REGNUM
, /* 31 */
125 NIOS2_PC_REGNUM
, /* 32 */
126 NIOS2_STATUS_REGNUM
, /* 33 */
127 NIOS2_ESTATUS_REGNUM
, /* 34 */
128 NIOS2_BSTATUS_REGNUM
, /* 35 */
129 NIOS2_IENABLE_REGNUM
, /* 36 */
130 NIOS2_IPENDING_REGNUM
, /* 37 */
131 NIOS2_CPUID_REGNUM
, /* 38 */
132 39, /* CTL6 */ /* 39 */
133 NIOS2_EXCEPTION_REGNUM
, /* 40 */
134 NIOS2_PTEADDR_REGNUM
, /* 41 */
135 NIOS2_TLBACC_REGNUM
, /* 42 */
136 NIOS2_TLBMISC_REGNUM
, /* 43 */
137 NIOS2_ECCINJ_REGNUM
, /* 44 */
138 NIOS2_BADADDR_REGNUM
, /* 45 */
139 NIOS2_CONFIG_REGNUM
, /* 46 */
140 NIOS2_MPUBASE_REGNUM
, /* 47 */
141 NIOS2_MPUACC_REGNUM
/* 48 */
145 /* Implement the dwarf2_reg_to_regnum gdbarch method. */
148 nios2_dwarf_reg_to_regnum (struct gdbarch
*gdbarch
, int dw_reg
)
150 if (dw_reg
< 0 || dw_reg
> NIOS2_NUM_REGS
)
152 warning (_("Dwarf-2 uses unmapped register #%d"), dw_reg
);
156 return nios2_dwarf2gdb_regno_map
[dw_reg
];
159 /* Canonical names for the 49 registers. */
161 static const char *const nios2_reg_names
[NIOS2_NUM_REGS
] =
163 "zero", "at", "r2", "r3", "r4", "r5", "r6", "r7",
164 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
165 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
166 "et", "bt", "gp", "sp", "fp", "ea", "sstatus", "ra",
168 "status", "estatus", "bstatus", "ienable",
169 "ipending", "cpuid", "ctl6", "exception",
170 "pteaddr", "tlbacc", "tlbmisc", "eccinj",
171 "badaddr", "config", "mpubase", "mpuacc"
174 /* Implement the register_name gdbarch method. */
177 nios2_register_name (struct gdbarch
*gdbarch
, int regno
)
179 /* Use mnemonic aliases for GPRs. */
180 if (regno
>= 0 && regno
< NIOS2_NUM_REGS
)
181 return nios2_reg_names
[regno
];
183 return tdesc_register_name (gdbarch
, regno
);
186 /* Implement the register_type gdbarch method. */
189 nios2_register_type (struct gdbarch
*gdbarch
, int regno
)
191 /* If the XML description has register information, use that to
192 determine the register type. */
193 if (tdesc_has_registers (gdbarch_target_desc (gdbarch
)))
194 return tdesc_register_type (gdbarch
, regno
);
196 if (regno
== NIOS2_PC_REGNUM
)
197 return builtin_type (gdbarch
)->builtin_func_ptr
;
198 else if (regno
== NIOS2_SP_REGNUM
)
199 return builtin_type (gdbarch
)->builtin_data_ptr
;
201 return builtin_type (gdbarch
)->builtin_uint32
;
204 /* Given a return value in REGCACHE with a type VALTYPE,
205 extract and copy its value into VALBUF. */
208 nios2_extract_return_value (struct gdbarch
*gdbarch
, struct type
*valtype
,
209 struct regcache
*regcache
, gdb_byte
*valbuf
)
211 int len
= TYPE_LENGTH (valtype
);
213 /* Return values of up to 8 bytes are returned in $r2 $r3. */
214 if (len
<= register_size (gdbarch
, NIOS2_R2_REGNUM
))
215 regcache_cooked_read (regcache
, NIOS2_R2_REGNUM
, valbuf
);
218 gdb_assert (len
<= (register_size (gdbarch
, NIOS2_R2_REGNUM
)
219 + register_size (gdbarch
, NIOS2_R3_REGNUM
)));
220 regcache_cooked_read (regcache
, NIOS2_R2_REGNUM
, valbuf
);
221 regcache_cooked_read (regcache
, NIOS2_R3_REGNUM
, valbuf
+ 4);
225 /* Write into appropriate registers a function return value
226 of type TYPE, given in virtual format. */
229 nios2_store_return_value (struct gdbarch
*gdbarch
, struct type
*valtype
,
230 struct regcache
*regcache
, const gdb_byte
*valbuf
)
232 int len
= TYPE_LENGTH (valtype
);
234 /* Return values of up to 8 bytes are returned in $r2 $r3. */
235 if (len
<= register_size (gdbarch
, NIOS2_R2_REGNUM
))
236 regcache_cooked_write (regcache
, NIOS2_R2_REGNUM
, valbuf
);
239 gdb_assert (len
<= (register_size (gdbarch
, NIOS2_R2_REGNUM
)
240 + register_size (gdbarch
, NIOS2_R3_REGNUM
)));
241 regcache_cooked_write (regcache
, NIOS2_R2_REGNUM
, valbuf
);
242 regcache_cooked_write (regcache
, NIOS2_R3_REGNUM
, valbuf
+ 4);
247 /* Set up the default values of the registers. */
250 nios2_setup_default (struct nios2_unwind_cache
*cache
)
254 for (i
= 0; i
< NIOS2_NUM_REGS
; i
++)
256 /* All registers start off holding their previous values. */
257 cache
->reg_value
[i
].reg
= i
;
258 cache
->reg_value
[i
].offset
= 0;
260 /* All registers start off not saved. */
261 cache
->reg_saved
[i
].basereg
= -1;
262 cache
->reg_saved
[i
].addr
= 0;
266 /* Initialize the unwind cache. */
269 nios2_init_cache (struct nios2_unwind_cache
*cache
, CORE_ADDR pc
)
274 cache
->return_regnum
= NIOS2_RA_REGNUM
;
275 nios2_setup_default (cache
);
278 /* Helper function to identify when we're in a function epilogue;
279 that is, the part of the function from the point at which the
280 stack adjustment is made, to the return or sibcall. On Nios II,
281 we want to check that the CURRENT_PC is a return-type instruction
282 and that the previous instruction is a stack adjustment.
283 START_PC is the beginning of the function in question. */
286 nios2_in_epilogue_p (struct gdbarch
*gdbarch
,
287 CORE_ADDR current_pc
,
290 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
292 /* There has to be a previous instruction in the function. */
293 if (current_pc
> start_pc
)
296 /* Check whether the previous instruction was a stack
299 = read_memory_unsigned_integer (current_pc
- NIOS2_OPCODE_SIZE
,
300 NIOS2_OPCODE_SIZE
, byte_order
);
302 if ((insn
& 0xffc0003c) == 0xdec00004 /* ADDI sp, sp, */
303 || (insn
& 0xffc1ffff) == 0xdec1883a /* ADD sp, sp, */
304 || (insn
& 0xffc0003f) == 0xdec00017) /* LDW sp, constant(sp) */
306 /* Then check if it's followed by a return or a tail
308 insn
= read_memory_unsigned_integer (current_pc
, NIOS2_OPCODE_SIZE
,
311 if (insn
== 0xf800283a /* RET */
312 || insn
== 0xe800083a /* ERET */
313 || (insn
& 0x07ffffff) == 0x0000683a /* JMP */
314 || (insn
& 0xffc0003f) == 6) /* BR */
321 /* Implement the in_function_epilogue_p gdbarch method. */
324 nios2_in_function_epilogue_p (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
328 if (find_pc_partial_function (pc
, NULL
, &func_addr
, NULL
))
329 return nios2_in_epilogue_p (gdbarch
, pc
, func_addr
);
334 /* Define some instruction patterns supporting wildcard bits via a
343 static const wild_insn profiler_insn
[] =
345 { 0x0010e03a, 0x00000000 }, /* nextpc r8 */
346 { 0xf813883a, 0x00000000 }, /* mov r9,ra */
347 { 0x02800034, 0x003fffc0 }, /* movhi r10,257 */
348 { 0x52800004, 0x003fffc0 }, /* addi r10,r10,-31992 */
349 { 0x00000000, 0xffffffc0 }, /* call <mcount> */
350 { 0x483f883a, 0x00000000 } /* mov ra,r9 */
353 static const wild_insn irqentry_insn
[] =
355 { 0x0031307a, 0x00000000 }, /* rdctl et,estatus */
356 { 0xc600004c, 0x00000000 }, /* andi et,et,1 */
357 { 0xc0000026, 0x003fffc0 }, /* beq et,zero, <software_exception> */
358 { 0x0031313a, 0x00000000 }, /* rdctl et,ipending */
359 { 0xc0000026, 0x003fffc0 } /* beq et,zero, <software_exception> */
363 /* Attempt to match SEQUENCE, which is COUNT insns long, at START_PC. */
366 nios2_match_sequence (struct gdbarch
*gdbarch
, CORE_ADDR start_pc
,
367 const wild_insn
*sequence
, int count
)
369 CORE_ADDR pc
= start_pc
;
372 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
374 for (i
= 0 ; i
< count
; i
++)
376 insn
= read_memory_unsigned_integer (pc
, NIOS2_OPCODE_SIZE
, byte_order
);
377 if ((insn
& ~sequence
[i
].mask
) != sequence
[i
].insn
)
380 pc
+= NIOS2_OPCODE_SIZE
;
386 /* Do prologue analysis, returning the PC of the first instruction
387 after the function prologue. Assumes CACHE has already been
388 initialized. THIS_FRAME can be null, in which case we are only
389 interested in skipping the prologue. Otherwise CACHE is filled in
390 from the frame information.
392 The prologue will consist of the following parts:
393 1) Optional profiling instrumentation. The old version uses six
394 instructions. We step over this if there is an exact match.
397 movhi r10, %hiadj(.LP2)
398 addi r10, r10, %lo(.LP2)
401 The new version uses two or three instructions (the last of
402 these might get merged in with the STW which saves RA to the
403 stack). We interpret these.
408 2) Optional interrupt entry decision. Again, we step over
409 this if there is an exact match.
412 beq et,zero, <software_exception>
414 beq et,zero, <software_exception>
416 3) A stack adjustment or stack which, which will be one of:
417 addi sp, sp, -constant
423 addi r8, r8, constant
426 movhi rx, %hiadj(newstack)
427 addhi rx, rx, %lo(newstack)
431 4) An optional stack check, which can take either of these forms:
435 bltu sp, rx, .Lstack_overflow
440 5) Saving any registers which need to be saved. These will
441 normally just be stored onto the stack:
443 but in the large frame case will use r8 as an offset back
446 stw rx, -constant(r8)
448 Saving control registers looks slightly different:
452 6) An optional FP setup, either if the user has requested a
453 frame pointer or if the function calls alloca.
457 The prologue instructions may be interleaved, and the register
458 saves and FP setup can occur in either order.
460 To cope with all this variability we decode all the instructions
461 from the start of the prologue until we hit a branch, call or
462 return. For each of the instructions mentioned in 3, 4 and 5 we
463 handle the limited cases of stores to the stack and operations
464 on constant values. */
467 nios2_analyze_prologue (struct gdbarch
*gdbarch
, const CORE_ADDR start_pc
,
468 const CORE_ADDR current_pc
,
469 struct nios2_unwind_cache
*cache
,
470 struct frame_info
*this_frame
)
472 /* Maximum lines of prologue to check.
473 Note that this number should not be too large, else we can
474 potentially end up iterating through unmapped memory. */
475 CORE_ADDR limit_pc
= start_pc
+ 200;
477 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
479 /* Does the frame set up the FP register? */
482 struct reg_value
*value
= cache
->reg_value
;
483 struct reg_value temp_value
[NIOS2_NUM_REGS
];
487 /* Save the starting PC so we can correct the pc after running
488 through the prolog, using symbol info. */
489 CORE_ADDR pc
= start_pc
;
491 /* Is this an exception handler? */
492 int exception_handler
= 0;
494 /* What was the original value of SP (or fake original value for
495 functions which switch stacks? */
496 CORE_ADDR frame_high
;
498 /* Is this the end of the prologue? */
499 int within_prologue
= 1;
501 CORE_ADDR prologue_end
;
503 /* Is this the innermost function? */
504 int innermost
= (this_frame
? (frame_relative_level (this_frame
) == 0) : 1);
507 fprintf_unfiltered (gdb_stdlog
,
508 "{ nios2_analyze_prologue start=%s, current=%s ",
509 paddress (gdbarch
, start_pc
),
510 paddress (gdbarch
, current_pc
));
512 /* Set up the default values of the registers. */
513 nios2_setup_default (cache
);
515 /* If the first few instructions are the profile entry, then skip
516 over them. Newer versions of the compiler use more efficient
518 if (nios2_match_sequence (gdbarch
, pc
, profiler_insn
,
519 ARRAY_SIZE (profiler_insn
)))
520 pc
+= ARRAY_SIZE (profiler_insn
) * NIOS2_OPCODE_SIZE
;
522 /* If the first few instructions are an interrupt entry, then skip
524 if (nios2_match_sequence (gdbarch
, pc
, irqentry_insn
,
525 ARRAY_SIZE (irqentry_insn
)))
527 pc
+= ARRAY_SIZE (irqentry_insn
) * NIOS2_OPCODE_SIZE
;
528 exception_handler
= 1;
531 prologue_end
= start_pc
;
533 /* Find the prologue instructions. */
534 while (pc
< limit_pc
&& within_prologue
)
536 /* Present instruction. */
539 int prologue_insn
= 0;
541 if (pc
== current_pc
)
543 /* When we reach the current PC we must save the current
544 register state (for the backtrace) but keep analysing
545 because there might be more to find out (eg. is this an
546 exception handler). */
547 memcpy (temp_value
, value
, sizeof (temp_value
));
550 fprintf_unfiltered (gdb_stdlog
, "*");
553 insn
= read_memory_unsigned_integer (pc
, NIOS2_OPCODE_SIZE
, byte_order
);
554 pc
+= NIOS2_OPCODE_SIZE
;
557 fprintf_unfiltered (gdb_stdlog
, "[%08X]", insn
);
559 /* The following instructions can appear in the prologue. */
561 if ((insn
& 0x0001ffff) == 0x0001883a)
563 /* ADD rc, ra, rb (also used for MOV) */
565 int ra
= GET_IW_A (insn
);
566 int rb
= GET_IW_B (insn
);
567 int rc
= GET_IW_C (insn
);
569 if (rc
== NIOS2_SP_REGNUM
571 && value
[ra
].reg
== cache
->reg_saved
[NIOS2_SP_REGNUM
].basereg
)
573 /* If the previous value of SP is available somewhere
574 near the new stack pointer value then this is a
577 /* If any registers were saved on the stack before then
578 we can't backtrace into them now. */
579 for (i
= 0 ; i
< NIOS2_NUM_REGS
; i
++)
581 if (cache
->reg_saved
[i
].basereg
== NIOS2_SP_REGNUM
)
582 cache
->reg_saved
[i
].basereg
= -1;
583 if (value
[i
].reg
== NIOS2_SP_REGNUM
)
587 /* Create a fake "high water mark" 4 bytes above where SP
588 was stored and fake up the registers to be consistent
590 value
[NIOS2_SP_REGNUM
].reg
= NIOS2_SP_REGNUM
;
591 value
[NIOS2_SP_REGNUM
].offset
593 - cache
->reg_saved
[NIOS2_SP_REGNUM
].addr
595 cache
->reg_saved
[NIOS2_SP_REGNUM
].basereg
= NIOS2_SP_REGNUM
;
596 cache
->reg_saved
[NIOS2_SP_REGNUM
].addr
= -4;
601 if (value
[rb
].reg
== 0)
602 value
[rc
].reg
= value
[ra
].reg
;
603 else if (value
[ra
].reg
== 0)
604 value
[rc
].reg
= value
[rb
].reg
;
607 value
[rc
].offset
= value
[ra
].offset
+ value
[rb
].offset
;
612 else if ((insn
& 0x0001ffff) == 0x0001983a)
616 int ra
= GET_IW_A (insn
);
617 int rb
= GET_IW_B (insn
);
618 int rc
= GET_IW_C (insn
);
622 if (value
[rb
].reg
== 0)
623 value
[rc
].reg
= value
[ra
].reg
;
626 value
[rc
].offset
= value
[ra
].offset
- value
[rb
].offset
;
630 else if ((insn
& 0x0000003f) == 0x00000004)
632 /* ADDI rb, ra, immed (also used for MOVI) */
633 short immed
= GET_IW_IMM16 (insn
);
634 int ra
= GET_IW_A (insn
);
635 int rb
= GET_IW_B (insn
);
637 /* The first stack adjustment is part of the prologue.
638 Any subsequent stack adjustments are either down to
639 alloca or the epilogue so stop analysing when we hit
641 if (rb
== NIOS2_SP_REGNUM
642 && (value
[rb
].offset
!= 0 || value
[ra
].reg
!= NIOS2_SP_REGNUM
))
647 value
[rb
].reg
= value
[ra
].reg
;
648 value
[rb
].offset
= value
[ra
].offset
+ immed
;
654 else if ((insn
& 0x0000003f) == 0x00000034)
656 /* ORHI rb, ra, immed (also used for MOVHI) */
657 unsigned int immed
= GET_IW_IMM16 (insn
);
658 int ra
= GET_IW_A (insn
);
659 int rb
= GET_IW_B (insn
);
663 value
[rb
].reg
= (value
[ra
].reg
== 0) ? 0 : -1;
664 value
[rb
].offset
= value
[ra
].offset
| (immed
<< 16);
668 else if ((insn
& IW_OP_MASK
) == OP_STW
669 || (insn
& IW_OP_MASK
) == OP_STWIO
)
671 /* STW rb, immediate(ra) */
673 short immed16
= GET_IW_IMM16 (insn
);
674 int ra
= GET_IW_A (insn
);
675 int rb
= GET_IW_B (insn
);
677 /* Are we storing the original value of a register?
678 For exception handlers the value of EA-4 (return
679 address from interrupts etc) is sometimes stored. */
680 int orig
= value
[rb
].reg
;
682 && (value
[rb
].offset
== 0
683 || (orig
== NIOS2_EA_REGNUM
&& value
[rb
].offset
== -4)))
685 /* We are most interested in stores to the stack, but
686 also take note of stores to other places as they
687 might be useful later. */
688 if ((value
[ra
].reg
== NIOS2_SP_REGNUM
689 && cache
->reg_saved
[orig
].basereg
!= NIOS2_SP_REGNUM
)
690 || cache
->reg_saved
[orig
].basereg
== -1)
694 /* Save off callee saved registers. */
695 cache
->reg_saved
[orig
].basereg
= value
[ra
].reg
;
696 cache
->reg_saved
[orig
].addr
697 = value
[ra
].offset
+ GET_IW_IMM16 (insn
);
702 if (orig
== NIOS2_EA_REGNUM
|| orig
== NIOS2_ESTATUS_REGNUM
)
703 exception_handler
= 1;
707 /* Non-stack memory writes are not part of the
712 else if ((insn
& 0xffc1f83f) == 0x0001303a)
715 int rc
= GET_IW_C (insn
);
716 int n
= GET_IW_CONTROL_REGNUM (insn
);
720 value
[rc
].reg
= NIOS2_STATUS_REGNUM
+ n
;
721 value
[rc
].offset
= 0;
727 else if ((insn
& 0x0000003f) == 0
728 && value
[8].reg
== NIOS2_RA_REGNUM
729 && value
[8].offset
== 0
730 && value
[NIOS2_SP_REGNUM
].reg
== NIOS2_SP_REGNUM
731 && value
[NIOS2_SP_REGNUM
].offset
== 0)
733 /* A CALL instruction. This is treated as a call to mcount
734 if ra has been stored into r8 beforehand and if it's
735 before the stack adjust.
736 Note mcount corrupts r2-r3, r9-r15 & ra. */
737 for (i
= 2 ; i
<= 3 ; i
++)
739 for (i
= 9 ; i
<= 15 ; i
++)
741 value
[NIOS2_RA_REGNUM
].reg
= -1;
746 else if ((insn
& 0xf83fffff) == 0xd800012e)
750 This instruction sequence is used in stack checking;
752 unsigned int next_insn
753 = read_memory_unsigned_integer (pc
, NIOS2_OPCODE_SIZE
, byte_order
);
755 if (next_insn
!= 0x003da0fa)
758 pc
+= NIOS2_OPCODE_SIZE
;
761 else if ((insn
& 0xf800003f) == 0xd8000036)
763 /* BLTU sp, rx, .Lstackoverflow
764 If the location branched to holds a BREAK 3 instruction
765 then this is also stack overflow detection. We can
767 CORE_ADDR target_pc
= pc
+ ((insn
& 0x3fffc0) >> 6);
768 unsigned int target_insn
769 = read_memory_unsigned_integer (target_pc
, NIOS2_OPCODE_SIZE
,
772 if (target_insn
!= 0x003da0fa)
776 /* Any other instructions are allowed to be moved up into the
777 prologue. If we reach a branch, call or return then the
778 prologue is considered over. We also consider a second stack
779 adjustment as terminating the prologue (see above). */
782 switch (GET_IW_OP (insn
))
795 if (GET_IW_OPX (insn
) == OPX_RET
796 || GET_IW_OPX (insn
) == OPX_ERET
797 || GET_IW_OPX (insn
) == OPX_BRET
798 || GET_IW_OPX (insn
) == OPX_CALLR
799 || GET_IW_OPX (insn
) == OPX_JMP
)
811 /* If THIS_FRAME is NULL, we are being called from skip_prologue
812 and are only interested in the PROLOGUE_END value, so just
813 return that now and skip over the cache updates, which depend
814 on having frame information. */
815 if (this_frame
== NULL
)
818 /* If we are in the function epilogue and have already popped
819 registers off the stack in preparation for returning, then we
820 want to go back to the original register values. */
821 if (innermost
&& nios2_in_epilogue_p (gdbarch
, current_pc
, start_pc
))
822 nios2_setup_default (cache
);
824 /* Exception handlers use a different return address register. */
825 if (exception_handler
)
826 cache
->return_regnum
= NIOS2_EA_REGNUM
;
829 fprintf_unfiltered (gdb_stdlog
, "\n-> retreg=%d, ", cache
->return_regnum
);
831 if (cache
->reg_value
[NIOS2_FP_REGNUM
].reg
== NIOS2_SP_REGNUM
)
832 /* If the FP now holds an offset from the CFA then this is a
833 normal frame which uses the frame pointer. */
834 base_reg
= NIOS2_FP_REGNUM
;
835 else if (cache
->reg_value
[NIOS2_SP_REGNUM
].reg
== NIOS2_SP_REGNUM
)
836 /* FP doesn't hold an offset from the CFA. If SP still holds an
837 offset from the CFA then we might be in a function which omits
838 the frame pointer, or we might be partway through the prologue.
839 In both cases we can find the CFA using SP. */
840 base_reg
= NIOS2_SP_REGNUM
;
843 /* Somehow the stack pointer has been corrupted.
846 fprintf_unfiltered (gdb_stdlog
, "<can't reach cfa> }\n");
850 if (cache
->reg_value
[base_reg
].offset
== 0
851 || cache
->reg_saved
[NIOS2_RA_REGNUM
].basereg
!= NIOS2_SP_REGNUM
852 || cache
->reg_saved
[cache
->return_regnum
].basereg
!= NIOS2_SP_REGNUM
)
854 /* If the frame didn't adjust the stack, didn't save RA or
855 didn't save EA in an exception handler then it must either
856 be a leaf function (doesn't call any other functions) or it
857 can't return. If it has called another function then it
858 can't be a leaf, so set base == 0 to indicate that we can't
859 backtrace past it. */
863 /* If it isn't the innermost function then it can't be a
864 leaf, unless it was interrupted. Check whether RA for
865 this frame is the same as PC. If so then it probably
866 wasn't interrupted. */
868 = get_frame_register_unsigned (this_frame
, NIOS2_RA_REGNUM
);
870 if (ra
== current_pc
)
875 "<noreturn ADJUST %s, r31@r%d+?>, r%d@r%d+?> }\n",
876 paddress (gdbarch
, cache
->reg_value
[base_reg
].offset
),
877 cache
->reg_saved
[NIOS2_RA_REGNUM
].basereg
,
878 cache
->return_regnum
,
879 cache
->reg_saved
[cache
->return_regnum
].basereg
);
885 /* Get the value of whichever register we are using for the
887 cache
->base
= get_frame_register_unsigned (this_frame
, base_reg
);
889 /* What was the value of SP at the start of this function (or just
890 after the stack switch). */
891 frame_high
= cache
->base
- cache
->reg_value
[base_reg
].offset
;
893 /* Adjust all the saved registers such that they contain addresses
894 instead of offsets. */
895 for (i
= 0; i
< NIOS2_NUM_REGS
; i
++)
896 if (cache
->reg_saved
[i
].basereg
== NIOS2_SP_REGNUM
)
898 cache
->reg_saved
[i
].basereg
= NIOS2_Z_REGNUM
;
899 cache
->reg_saved
[i
].addr
+= frame_high
;
902 for (i
= 0; i
< NIOS2_NUM_REGS
; i
++)
903 if (cache
->reg_saved
[i
].basereg
== NIOS2_GP_REGNUM
)
905 CORE_ADDR gp
= get_frame_register_unsigned (this_frame
,
908 for ( ; i
< NIOS2_NUM_REGS
; i
++)
909 if (cache
->reg_saved
[i
].basereg
== NIOS2_GP_REGNUM
)
911 cache
->reg_saved
[i
].basereg
= NIOS2_Z_REGNUM
;
912 cache
->reg_saved
[i
].addr
+= gp
;
916 /* Work out what the value of SP was on the first instruction of
917 this function. If we didn't switch stacks then this can be
918 trivially computed from the base address. */
919 if (cache
->reg_saved
[NIOS2_SP_REGNUM
].basereg
== NIOS2_Z_REGNUM
)
921 = read_memory_unsigned_integer (cache
->reg_saved
[NIOS2_SP_REGNUM
].addr
,
924 cache
->cfa
= frame_high
;
926 /* Exception handlers restore ESTATUS into STATUS. */
927 if (exception_handler
)
929 cache
->reg_saved
[NIOS2_STATUS_REGNUM
]
930 = cache
->reg_saved
[NIOS2_ESTATUS_REGNUM
];
931 cache
->reg_saved
[NIOS2_ESTATUS_REGNUM
].basereg
= -1;
935 fprintf_unfiltered (gdb_stdlog
, "cfa=%s }\n",
936 paddress (gdbarch
, cache
->cfa
));
941 /* Implement the skip_prologue gdbarch hook. */
944 nios2_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR start_pc
)
949 struct nios2_unwind_cache cache
;
951 /* See if we can determine the end of the prologue via the symbol
952 table. If so, then return either PC, or the PC after the
953 prologue, whichever is greater. */
954 if (find_pc_partial_function (start_pc
, NULL
, &func_addr
, NULL
))
956 CORE_ADDR post_prologue_pc
957 = skip_prologue_using_sal (gdbarch
, func_addr
);
959 if (post_prologue_pc
!= 0)
960 return max (start_pc
, post_prologue_pc
);
963 /* Prologue analysis does the rest.... */
964 nios2_init_cache (&cache
, start_pc
);
965 return nios2_analyze_prologue (gdbarch
, start_pc
, start_pc
, &cache
, NULL
);
968 /* Implement the breakpoint_from_pc gdbarch hook. */
970 static const gdb_byte
*
971 nios2_breakpoint_from_pc (struct gdbarch
*gdbarch
, CORE_ADDR
*bp_addr
,
974 /* break encoding: 31->27 26->22 21->17 16->11 10->6 5->0 */
975 /* 00000 00000 0x1d 0x2d 11111 0x3a */
976 /* 00000 00000 11101 101101 11111 111010 */
977 /* In bytes: 00000000 00111011 01101111 11111010 */
978 /* 0x0 0x3b 0x6f 0xfa */
979 static const gdb_byte breakpoint_le
[] = {0xfa, 0x6f, 0x3b, 0x0};
980 static const gdb_byte breakpoint_be
[] = {0x0, 0x3b, 0x6f, 0xfa};
982 enum bfd_endian byte_order_for_code
= gdbarch_byte_order_for_code (gdbarch
);
985 if (gdbarch_byte_order_for_code (gdbarch
) == BFD_ENDIAN_BIG
)
986 return breakpoint_be
;
988 return breakpoint_le
;
991 /* Implement the print_insn gdbarch method. */
994 nios2_print_insn (bfd_vma memaddr
, disassemble_info
*info
)
996 if (info
->endian
== BFD_ENDIAN_BIG
)
997 return print_insn_big_nios2 (memaddr
, info
);
999 return print_insn_little_nios2 (memaddr
, info
);
1003 /* Implement the frame_align gdbarch method. */
1006 nios2_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1008 return align_down (addr
, 4);
1012 /* Implement the return_value gdbarch method. */
1014 static enum return_value_convention
1015 nios2_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
1016 struct type
*type
, struct regcache
*regcache
,
1017 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
1019 if (TYPE_LENGTH (type
) > 8)
1020 return RETURN_VALUE_STRUCT_CONVENTION
;
1023 nios2_extract_return_value (gdbarch
, type
, regcache
, readbuf
);
1025 nios2_store_return_value (gdbarch
, type
, regcache
, writebuf
);
1027 return RETURN_VALUE_REGISTER_CONVENTION
;
1030 /* Implement the dummy_id gdbarch method. */
1032 static struct frame_id
1033 nios2_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*this_frame
)
1035 return frame_id_build
1036 (get_frame_register_unsigned (this_frame
, NIOS2_SP_REGNUM
),
1037 get_frame_pc (this_frame
));
1040 /* Implement the push_dummy_call gdbarch method. */
1043 nios2_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
1044 struct regcache
*regcache
, CORE_ADDR bp_addr
,
1045 int nargs
, struct value
**args
, CORE_ADDR sp
,
1046 int struct_return
, CORE_ADDR struct_addr
)
1052 int stack_offset
= 0;
1053 CORE_ADDR func_addr
= find_function_addr (function
, NULL
);
1054 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1056 /* Set the return address register to point to the entry point of
1057 the program, where a breakpoint lies in wait. */
1058 regcache_cooked_write_signed (regcache
, NIOS2_RA_REGNUM
, bp_addr
);
1060 /* Now make space on the stack for the args. */
1061 for (argnum
= 0; argnum
< nargs
; argnum
++)
1062 len
+= align_up (TYPE_LENGTH (value_type (args
[argnum
])), 4);
1065 /* Initialize the register pointer. */
1066 argreg
= NIOS2_FIRST_ARGREG
;
1068 /* The struct_return pointer occupies the first parameter-passing
1071 regcache_cooked_write_unsigned (regcache
, argreg
++, struct_addr
);
1073 /* Now load as many as possible of the first arguments into
1074 registers, and push the rest onto the stack. Loop through args
1075 from first to last. */
1076 for (argnum
= 0; argnum
< nargs
; argnum
++)
1078 const gdb_byte
*val
;
1079 gdb_byte valbuf
[MAX_REGISTER_SIZE
];
1080 struct value
*arg
= args
[argnum
];
1081 struct type
*arg_type
= check_typedef (value_type (arg
));
1082 int len
= TYPE_LENGTH (arg_type
);
1083 enum type_code typecode
= TYPE_CODE (arg_type
);
1085 val
= value_contents (arg
);
1087 /* Copy the argument to general registers or the stack in
1088 register-sized pieces. Large arguments are split between
1089 registers and stack. */
1092 int partial_len
= (len
< 4 ? len
: 4);
1094 if (argreg
<= NIOS2_LAST_ARGREG
)
1096 /* The argument is being passed in a register. */
1097 CORE_ADDR regval
= extract_unsigned_integer (val
, partial_len
,
1100 regcache_cooked_write_unsigned (regcache
, argreg
, regval
);
1105 /* The argument is being passed on the stack. */
1106 CORE_ADDR addr
= sp
+ stack_offset
;
1108 write_memory (addr
, val
, partial_len
);
1109 stack_offset
+= align_up (partial_len
, 4);
1117 regcache_cooked_write_signed (regcache
, NIOS2_SP_REGNUM
, sp
);
1119 /* Return adjusted stack pointer. */
1123 /* Implement the unwind_pc gdbarch method. */
1126 nios2_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1130 frame_unwind_register (next_frame
, NIOS2_PC_REGNUM
, buf
);
1131 return extract_typed_address (buf
, builtin_type (gdbarch
)->builtin_func_ptr
);
1134 /* Implement the unwind_sp gdbarch method. */
1137 nios2_unwind_sp (struct gdbarch
*gdbarch
, struct frame_info
*this_frame
)
1139 return frame_unwind_register_unsigned (this_frame
, NIOS2_SP_REGNUM
);
1142 /* Use prologue analysis to fill in the register cache
1143 *THIS_PROLOGUE_CACHE for THIS_FRAME. This function initializes
1144 *THIS_PROLOGUE_CACHE first. */
1146 static struct nios2_unwind_cache
*
1147 nios2_frame_unwind_cache (struct frame_info
*this_frame
,
1148 void **this_prologue_cache
)
1150 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1151 CORE_ADDR current_pc
;
1152 struct nios2_unwind_cache
*cache
;
1155 if (*this_prologue_cache
)
1156 return *this_prologue_cache
;
1158 cache
= FRAME_OBSTACK_ZALLOC (struct nios2_unwind_cache
);
1159 *this_prologue_cache
= cache
;
1161 /* Zero all fields. */
1162 nios2_init_cache (cache
, get_frame_func (this_frame
));
1164 /* Prologue analysis does the rest... */
1165 current_pc
= get_frame_pc (this_frame
);
1167 nios2_analyze_prologue (gdbarch
, cache
->pc
, current_pc
, cache
, this_frame
);
1172 /* Implement the this_id function for the normal unwinder. */
1175 nios2_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
1176 struct frame_id
*this_id
)
1178 struct nios2_unwind_cache
*cache
=
1179 nios2_frame_unwind_cache (this_frame
, this_cache
);
1181 /* This marks the outermost frame. */
1182 if (cache
->base
== 0)
1185 *this_id
= frame_id_build (cache
->cfa
, cache
->pc
);
1188 /* Implement the prev_register function for the normal unwinder. */
1190 static struct value
*
1191 nios2_frame_prev_register (struct frame_info
*this_frame
, void **this_cache
,
1194 struct nios2_unwind_cache
*cache
=
1195 nios2_frame_unwind_cache (this_frame
, this_cache
);
1197 gdb_assert (regnum
>= 0 && regnum
< NIOS2_NUM_REGS
);
1199 /* The PC of the previous frame is stored in the RA register of
1200 the current frame. Frob regnum so that we pull the value from
1201 the correct place. */
1202 if (regnum
== NIOS2_PC_REGNUM
)
1203 regnum
= cache
->return_regnum
;
1205 if (regnum
== NIOS2_SP_REGNUM
&& cache
->cfa
)
1206 return frame_unwind_got_constant (this_frame
, regnum
, cache
->cfa
);
1208 /* If we've worked out where a register is stored then load it from
1210 if (cache
->reg_saved
[regnum
].basereg
== NIOS2_Z_REGNUM
)
1211 return frame_unwind_got_memory (this_frame
, regnum
,
1212 cache
->reg_saved
[regnum
].addr
);
1214 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
1217 /* Implement the this_base, this_locals, and this_args hooks
1218 for the normal unwinder. */
1221 nios2_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
1223 struct nios2_unwind_cache
*info
1224 = nios2_frame_unwind_cache (this_frame
, this_cache
);
1229 /* Data structures for the normal prologue-analysis-based
1232 static const struct frame_unwind nios2_frame_unwind
=
1235 default_frame_unwind_stop_reason
,
1236 nios2_frame_this_id
,
1237 nios2_frame_prev_register
,
1239 default_frame_sniffer
1242 static const struct frame_base nios2_frame_base
=
1244 &nios2_frame_unwind
,
1245 nios2_frame_base_address
,
1246 nios2_frame_base_address
,
1247 nios2_frame_base_address
1250 /* Fill in the register cache *THIS_CACHE for THIS_FRAME for use
1251 in the stub unwinder. */
1253 static struct trad_frame_cache
*
1254 nios2_stub_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
1257 CORE_ADDR start_addr
;
1258 CORE_ADDR stack_addr
;
1259 struct trad_frame_cache
*this_trad_cache
;
1260 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1261 int num_regs
= gdbarch_num_regs (gdbarch
);
1263 if (*this_cache
!= NULL
)
1265 this_trad_cache
= trad_frame_cache_zalloc (this_frame
);
1266 *this_cache
= this_trad_cache
;
1268 /* The return address is in the link register. */
1269 trad_frame_set_reg_realreg (this_trad_cache
,
1270 gdbarch_pc_regnum (gdbarch
),
1273 /* Frame ID, since it's a frameless / stackless function, no stack
1274 space is allocated and SP on entry is the current SP. */
1275 pc
= get_frame_pc (this_frame
);
1276 find_pc_partial_function (pc
, NULL
, &start_addr
, NULL
);
1277 stack_addr
= get_frame_register_unsigned (this_frame
, NIOS2_SP_REGNUM
);
1278 trad_frame_set_id (this_trad_cache
, frame_id_build (start_addr
, stack_addr
));
1279 /* Assume that the frame's base is the same as the stack pointer. */
1280 trad_frame_set_this_base (this_trad_cache
, stack_addr
);
1282 return this_trad_cache
;
1285 /* Implement the this_id function for the stub unwinder. */
1288 nios2_stub_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
1289 struct frame_id
*this_id
)
1291 struct trad_frame_cache
*this_trad_cache
1292 = nios2_stub_frame_cache (this_frame
, this_cache
);
1294 trad_frame_get_id (this_trad_cache
, this_id
);
1297 /* Implement the prev_register function for the stub unwinder. */
1299 static struct value
*
1300 nios2_stub_frame_prev_register (struct frame_info
*this_frame
,
1301 void **this_cache
, int regnum
)
1303 struct trad_frame_cache
*this_trad_cache
1304 = nios2_stub_frame_cache (this_frame
, this_cache
);
1306 return trad_frame_get_register (this_trad_cache
, this_frame
, regnum
);
1309 /* Implement the sniffer function for the stub unwinder.
1310 This unwinder is used for cases where the normal
1311 prologue-analysis-based unwinder can't work,
1312 such as PLT stubs. */
1315 nios2_stub_frame_sniffer (const struct frame_unwind
*self
,
1316 struct frame_info
*this_frame
, void **cache
)
1319 struct obj_section
*s
;
1320 CORE_ADDR pc
= get_frame_address_in_block (this_frame
);
1322 /* Use the stub unwinder for unreadable code. */
1323 if (target_read_memory (get_frame_pc (this_frame
), dummy
, 4) != 0)
1326 if (in_plt_section (pc
))
1332 /* Define the data structures for the stub unwinder. */
1334 static const struct frame_unwind nios2_stub_frame_unwind
=
1337 default_frame_unwind_stop_reason
,
1338 nios2_stub_frame_this_id
,
1339 nios2_stub_frame_prev_register
,
1341 nios2_stub_frame_sniffer
1344 /* Helper function to read an instruction at PC. */
1346 static unsigned long
1347 nios2_fetch_instruction (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
1349 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1351 return read_memory_unsigned_integer (pc
, NIOS2_OPCODE_SIZE
, byte_order
);
1354 /* Determine where to set a single step breakpoint while considering
1355 branch prediction. */
1358 nios2_get_next_pc (struct frame_info
*frame
, CORE_ADDR pc
)
1360 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1361 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1372 inst
= nios2_fetch_instruction (gdbarch
, pc
);
1373 pc
+= NIOS2_OPCODE_SIZE
;
1375 imm16
= (short) GET_IW_IMM16 (inst
);
1376 ra
= GET_IW_A (inst
);
1377 rb
= GET_IW_B (inst
);
1378 ras
= get_frame_register_signed (frame
, ra
);
1379 rbs
= get_frame_register_signed (frame
, rb
);
1380 rau
= get_frame_register_unsigned (frame
, ra
);
1381 rbu
= get_frame_register_unsigned (frame
, rb
);
1383 switch (GET_IW_OP (inst
))
1421 pc
= (pc
& 0xf0000000) | (GET_IW_IMM26 (inst
) << 2);
1425 switch (GET_IW_OPX (inst
))
1434 if (tdep
->syscall_next_pc
!= NULL
)
1435 return tdep
->syscall_next_pc (frame
);
1447 /* Implement the software_single_step gdbarch method. */
1450 nios2_software_single_step (struct frame_info
*frame
)
1452 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1453 struct address_space
*aspace
= get_frame_address_space (frame
);
1454 CORE_ADDR next_pc
= nios2_get_next_pc (frame
, get_frame_pc (frame
));
1456 insert_single_step_breakpoint (gdbarch
, aspace
, next_pc
);
1461 /* Implement the get_longjump_target gdbarch method. */
1464 nios2_get_longjmp_target (struct frame_info
*frame
, CORE_ADDR
*pc
)
1466 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1467 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1468 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1469 CORE_ADDR jb_addr
= get_frame_register_unsigned (frame
, NIOS2_R4_REGNUM
);
1472 if (target_read_memory (jb_addr
+ (tdep
->jb_pc
* 4), buf
, 4))
1475 *pc
= extract_unsigned_integer (buf
, 4, byte_order
);
1479 /* Initialize the Nios II gdbarch. */
1481 static struct gdbarch
*
1482 nios2_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1484 struct gdbarch
*gdbarch
;
1485 struct gdbarch_tdep
*tdep
;
1486 int register_bytes
, i
;
1487 struct tdesc_arch_data
*tdesc_data
= NULL
;
1488 const struct target_desc
*tdesc
= info
.target_desc
;
1490 if (!tdesc_has_registers (tdesc
))
1491 /* Pick a default target description. */
1492 tdesc
= tdesc_nios2
;
1494 /* Check any target description for validity. */
1495 if (tdesc_has_registers (tdesc
))
1497 const struct tdesc_feature
*feature
;
1500 feature
= tdesc_find_feature (tdesc
, "org.gnu.gdb.nios2.cpu");
1501 if (feature
== NULL
)
1504 tdesc_data
= tdesc_data_alloc ();
1508 for (i
= 0; i
< NIOS2_NUM_REGS
; i
++)
1509 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
, i
,
1510 nios2_reg_names
[i
]);
1514 tdesc_data_cleanup (tdesc_data
);
1519 /* Find a candidate among the list of pre-declared architectures. */
1520 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1522 return arches
->gdbarch
;
1524 /* None found, create a new architecture from the information
1526 tdep
= xcalloc (1, sizeof (struct gdbarch_tdep
));
1527 gdbarch
= gdbarch_alloc (&info
, tdep
);
1529 /* longjmp support not enabled by default. */
1532 /* Data type sizes. */
1533 set_gdbarch_ptr_bit (gdbarch
, 32);
1534 set_gdbarch_addr_bit (gdbarch
, 32);
1535 set_gdbarch_short_bit (gdbarch
, 16);
1536 set_gdbarch_int_bit (gdbarch
, 32);
1537 set_gdbarch_long_bit (gdbarch
, 32);
1538 set_gdbarch_long_long_bit (gdbarch
, 64);
1539 set_gdbarch_float_bit (gdbarch
, 32);
1540 set_gdbarch_double_bit (gdbarch
, 64);
1542 set_gdbarch_float_format (gdbarch
, floatformats_ieee_single
);
1543 set_gdbarch_double_format (gdbarch
, floatformats_ieee_double
);
1545 /* The register set. */
1546 set_gdbarch_num_regs (gdbarch
, NIOS2_NUM_REGS
);
1547 set_gdbarch_sp_regnum (gdbarch
, NIOS2_SP_REGNUM
);
1548 set_gdbarch_pc_regnum (gdbarch
, NIOS2_PC_REGNUM
); /* Pseudo register PC */
1550 set_gdbarch_register_name (gdbarch
, nios2_register_name
);
1551 set_gdbarch_register_type (gdbarch
, nios2_register_type
);
1553 /* Provide register mappings for stabs and dwarf2. */
1554 set_gdbarch_stab_reg_to_regnum (gdbarch
, nios2_dwarf_reg_to_regnum
);
1555 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, nios2_dwarf_reg_to_regnum
);
1557 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1559 /* Call dummy code. */
1560 set_gdbarch_frame_align (gdbarch
, nios2_frame_align
);
1562 set_gdbarch_return_value (gdbarch
, nios2_return_value
);
1564 set_gdbarch_skip_prologue (gdbarch
, nios2_skip_prologue
);
1565 set_gdbarch_in_function_epilogue_p (gdbarch
, nios2_in_function_epilogue_p
);
1566 set_gdbarch_breakpoint_from_pc (gdbarch
, nios2_breakpoint_from_pc
);
1568 set_gdbarch_dummy_id (gdbarch
, nios2_dummy_id
);
1569 set_gdbarch_unwind_pc (gdbarch
, nios2_unwind_pc
);
1570 set_gdbarch_unwind_sp (gdbarch
, nios2_unwind_sp
);
1572 /* The dwarf2 unwinder will normally produce the best results if
1573 the debug information is available, so register it first. */
1574 dwarf2_append_unwinders (gdbarch
);
1575 frame_unwind_append_unwinder (gdbarch
, &nios2_stub_frame_unwind
);
1576 frame_unwind_append_unwinder (gdbarch
, &nios2_frame_unwind
);
1578 /* Single stepping. */
1579 set_gdbarch_software_single_step (gdbarch
, nios2_software_single_step
);
1581 /* Hook in ABI-specific overrides, if they have been registered. */
1582 gdbarch_init_osabi (info
, gdbarch
);
1584 if (tdep
->jb_pc
>= 0)
1585 set_gdbarch_get_longjmp_target (gdbarch
, nios2_get_longjmp_target
);
1587 frame_base_set_default (gdbarch
, &nios2_frame_base
);
1589 set_gdbarch_print_insn (gdbarch
, nios2_print_insn
);
1591 /* Enable inferior call support. */
1592 set_gdbarch_push_dummy_call (gdbarch
, nios2_push_dummy_call
);
1595 tdesc_use_registers (gdbarch
, tdesc
, tdesc_data
);
1600 extern initialize_file_ftype _initialize_nios2_tdep
; /* -Wmissing-prototypes */
1603 _initialize_nios2_tdep (void)
1605 gdbarch_register (bfd_arch_nios2
, nios2_gdbarch_init
, NULL
);
1606 initialize_tdesc_nios2 ();
1608 /* Allow debugging this file's internals. */
1609 add_setshow_boolean_cmd ("nios2", class_maintenance
, &nios2_debug
,
1610 _("Set Nios II debugging."),
1611 _("Show Nios II debugging."),
1612 _("When on, Nios II specific debugging is enabled."),
1615 &setdebuglist
, &showdebuglist
);