1 /* Target-dependent code for the SPARC for GDB, the GNU debugger.
3 Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation,
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 2 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, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
24 /* ??? Support for calling functions from gdb in sparc64 is unfinished. */
27 #include "arch-utils.h"
33 #include "gdb_string.h"
38 #include <sys/procfs.h>
39 /* Prototypes for supply_gregset etc. */
44 #include "gdb_assert.h"
46 #include "symfile.h" /* for 'entry_point_address' */
49 * Some local macros that have multi-arch and non-multi-arch versions:
52 #if (GDB_MULTI_ARCH > 0)
55 // OBSOLETE /* Does the target have Floating Point registers? */
56 // OBSOLETE #define SPARC_HAS_FPU (gdbarch_tdep (current_gdbarch)->has_fpu)
58 #define SPARC_HAS_FPU 1
59 /* Number of bytes devoted to Floating Point registers: */
60 #define FP_REGISTER_BYTES (gdbarch_tdep (current_gdbarch)->fp_register_bytes)
61 /* Highest numbered Floating Point register. */
62 #define FP_MAX_REGNUM (gdbarch_tdep (current_gdbarch)->fp_max_regnum)
63 /* Size of a general (integer) register: */
64 #define SPARC_INTREG_SIZE (gdbarch_tdep (current_gdbarch)->intreg_size)
65 /* Offset within the call dummy stack of the saved registers. */
66 #define DUMMY_REG_SAVE_OFFSET (gdbarch_tdep (current_gdbarch)->reg_save_offset)
68 #else /* non-multi-arch */
71 /* Does the target have Floating Point registers? */
73 // OBSOLETE #if defined(TARGET_SPARCLET) || defined(TARGET_SPARCLITE)
74 // OBSOLETE #define SPARC_HAS_FPU 0
76 // OBSOLETE #define SPARC_HAS_FPU 1
79 #define SPARC_HAS_FPU 1
81 /* Number of bytes devoted to Floating Point registers: */
82 #if (GDB_TARGET_IS_SPARC64)
83 #define FP_REGISTER_BYTES (64 * 4)
86 #define FP_REGISTER_BYTES (32 * 4)
88 #define FP_REGISTER_BYTES 0
92 /* Highest numbered Floating Point register. */
93 #if (GDB_TARGET_IS_SPARC64)
94 #define FP_MAX_REGNUM (FP0_REGNUM + 48)
96 #define FP_MAX_REGNUM (FP0_REGNUM + 32)
99 /* Size of a general (integer) register: */
100 #define SPARC_INTREG_SIZE (REGISTER_RAW_SIZE (G0_REGNUM))
102 /* Offset within the call dummy stack of the saved registers. */
103 #if (GDB_TARGET_IS_SPARC64)
104 #define DUMMY_REG_SAVE_OFFSET (128 + 16)
106 #define DUMMY_REG_SAVE_OFFSET 0x60
109 #endif /* GDB_MULTI_ARCH */
114 // OBSOLETE int has_fpu;
116 int fp_register_bytes
;
121 int call_dummy_call_offset
;
125 /* Now make GDB_TARGET_IS_SPARC64 a runtime test. */
126 /* FIXME MVS: or try testing bfd_arch_info.arch and bfd_arch_info.mach ...
127 * define GDB_TARGET_IS_SPARC64 \
128 * (TARGET_ARCHITECTURE->arch == bfd_arch_sparc && \
129 * (TARGET_ARCHITECTURE->mach == bfd_mach_sparc_v9 || \
130 * TARGET_ARCHITECTURE->mach == bfd_mach_sparc_v9a))
134 extern int stop_after_trap
;
136 /* We don't store all registers immediately when requested, since they
137 get sent over in large chunks anyway. Instead, we accumulate most
138 of the changes and send them over once. "deferred_stores" keeps
139 track of which sets of registers we have locally-changed copies of,
140 so we only need send the groups that have changed. */
142 int deferred_stores
= 0; /* Accumulated stores we want to do eventually. */
146 // OBSOLETE /* Some machines, such as Fujitsu SPARClite 86x, have a bi-endian mode
147 // OBSOLETE where instructions are big-endian and data are little-endian.
148 // OBSOLETE This flag is set when we detect that the target is of this type. */
150 // OBSOLETE int bi_endian = 0;
154 const unsigned char *
155 sparc_breakpoint_from_pc (CORE_ADDR
*pc
, int *len
)
157 static const char breakpoint
[] = {0x91, 0xd0, 0x20, 0x01};
158 (*len
) = sizeof (breakpoint
);
162 /* Fetch a single instruction. Even on bi-endian machines
163 such as sparc86x, instructions are always big-endian. */
166 fetch_instruction (CORE_ADDR pc
)
168 unsigned long retval
;
170 unsigned char buf
[4];
172 read_memory (pc
, buf
, sizeof (buf
));
174 /* Start at the most significant end of the integer, and work towards
175 the least significant. */
177 for (i
= 0; i
< sizeof (buf
); ++i
)
178 retval
= (retval
<< 8) | buf
[i
];
183 /* Branches with prediction are treated like their non-predicting cousins. */
184 /* FIXME: What about floating point branches? */
186 /* Macros to extract fields from sparc instructions. */
187 #define X_OP(i) (((i) >> 30) & 0x3)
188 #define X_RD(i) (((i) >> 25) & 0x1f)
189 #define X_A(i) (((i) >> 29) & 1)
190 #define X_COND(i) (((i) >> 25) & 0xf)
191 #define X_OP2(i) (((i) >> 22) & 0x7)
192 #define X_IMM22(i) ((i) & 0x3fffff)
193 #define X_OP3(i) (((i) >> 19) & 0x3f)
194 #define X_RS1(i) (((i) >> 14) & 0x1f)
195 #define X_I(i) (((i) >> 13) & 1)
196 #define X_IMM13(i) ((i) & 0x1fff)
197 /* Sign extension macros. */
198 #define X_SIMM13(i) ((X_IMM13 (i) ^ 0x1000) - 0x1000)
199 #define X_DISP22(i) ((X_IMM22 (i) ^ 0x200000) - 0x200000)
200 #define X_CC(i) (((i) >> 20) & 3)
201 #define X_P(i) (((i) >> 19) & 1)
202 #define X_DISP19(i) ((((i) & 0x7ffff) ^ 0x40000) - 0x40000)
203 #define X_RCOND(i) (((i) >> 25) & 7)
204 #define X_DISP16(i) ((((((i) >> 6) && 0xc000) | ((i) & 0x3fff)) ^ 0x8000) - 0x8000)
205 #define X_FCN(i) (((i) >> 25) & 31)
209 Error
, not_branch
, bicc
, bicca
, ba
, baa
, ticc
, ta
, done_retry
212 /* Simulate single-step ptrace call for sun4. Code written by Gary
213 Beihl (beihl@mcc.com). */
215 /* npc4 and next_pc describe the situation at the time that the
216 step-breakpoint was set, not necessary the current value of NPC_REGNUM. */
217 static CORE_ADDR next_pc
, npc4
, target
;
218 static int brknpc4
, brktrg
;
219 typedef char binsn_quantum
[BREAKPOINT_MAX
];
220 static binsn_quantum break_mem
[3];
222 static branch_type
isbranch (long, CORE_ADDR
, CORE_ADDR
*);
224 /* single_step() is called just before we want to resume the inferior,
225 if we want to single-step it but there is no hardware or kernel single-step
226 support (as on all SPARCs). We find all the possible targets of the
227 coming instruction and breakpoint them.
229 single_step is also called just after the inferior stops. If we had
230 set up a simulated single-step, we undo our damage. */
233 sparc_software_single_step (enum target_signal ignore
, /* pid, but we don't need it */
234 int insert_breakpoints_p
)
240 if (insert_breakpoints_p
)
242 /* Always set breakpoint for NPC. */
243 next_pc
= read_register (NPC_REGNUM
);
244 npc4
= next_pc
+ 4; /* branch not taken */
246 target_insert_breakpoint (next_pc
, break_mem
[0]);
247 /* printf_unfiltered ("set break at %x\n",next_pc); */
249 pc
= read_register (PC_REGNUM
);
250 pc_instruction
= fetch_instruction (pc
);
251 br
= isbranch (pc_instruction
, pc
, &target
);
252 brknpc4
= brktrg
= 0;
256 /* Conditional annulled branch will either end up at
257 npc (if taken) or at npc+4 (if not taken).
260 target_insert_breakpoint (npc4
, break_mem
[1]);
262 else if (br
== baa
&& target
!= next_pc
)
264 /* Unconditional annulled branch will always end up at
267 target_insert_breakpoint (target
, break_mem
[2]);
269 else if (GDB_TARGET_IS_SPARC64
&& br
== done_retry
)
272 target_insert_breakpoint (target
, break_mem
[2]);
277 /* Remove breakpoints */
278 target_remove_breakpoint (next_pc
, break_mem
[0]);
281 target_remove_breakpoint (npc4
, break_mem
[1]);
284 target_remove_breakpoint (target
, break_mem
[2]);
288 struct frame_extra_info
293 /* Following fields only relevant for flat frames. */
296 /* Add this to ->frame to get the value of the stack pointer at the
297 time of the register saves. */
301 /* Call this for each newly created frame. For SPARC, we need to
302 calculate the bottom of the frame, and do some extra work if the
303 prologue has been generated via the -mflat option to GCC. In
304 particular, we need to know where the previous fp and the pc have
305 been stashed, since their exact position within the frame may vary. */
308 sparc_init_extra_frame_info (int fromleaf
, struct frame_info
*fi
)
311 CORE_ADDR prologue_start
, prologue_end
;
314 frame_extra_info_zalloc (fi
, sizeof (struct frame_extra_info
));
315 frame_saved_regs_zalloc (fi
);
317 get_frame_extra_info (fi
)->bottom
=
319 ? (get_frame_base (fi
) == get_frame_base (get_next_frame (fi
))
320 ? get_frame_extra_info (get_next_frame (fi
))->bottom
321 : get_frame_base (get_next_frame (fi
)))
324 /* If fi->next is NULL, then we already set ->frame by passing
325 deprecated_read_fp() to create_new_frame. */
326 if (get_next_frame (fi
))
328 char buf
[MAX_REGISTER_SIZE
];
330 /* Compute ->frame as if not flat. If it is flat, we'll change
332 if (get_next_frame (get_next_frame (fi
)) != NULL
333 && ((get_frame_type (get_next_frame (get_next_frame (fi
))) == SIGTRAMP_FRAME
)
334 || deprecated_frame_in_dummy (get_next_frame (get_next_frame (fi
))))
335 && frameless_look_for_prologue (get_next_frame (fi
)))
337 /* A frameless function interrupted by a signal did not change
338 the frame pointer, fix up frame pointer accordingly. */
339 deprecated_update_frame_base_hack (fi
, get_frame_base (get_next_frame (fi
)));
340 get_frame_extra_info (fi
)->bottom
=
341 get_frame_extra_info (get_next_frame (fi
))->bottom
;
345 /* Should we adjust for stack bias here? */
347 frame_read_unsigned_register (fi
, DEPRECATED_FP_REGNUM
, &tmp
);
348 deprecated_update_frame_base_hack (fi
, tmp
);
349 if (GDB_TARGET_IS_SPARC64
&& (get_frame_base (fi
) & 1))
350 deprecated_update_frame_base_hack (fi
, get_frame_base (fi
) + 2047);
354 /* Decide whether this is a function with a ``flat register window''
355 frame. For such functions, the frame pointer is actually in %i7. */
356 get_frame_extra_info (fi
)->flat
= 0;
357 get_frame_extra_info (fi
)->in_prologue
= 0;
358 if (find_pc_partial_function (get_frame_pc (fi
), &name
, &prologue_start
, &prologue_end
))
360 /* See if the function starts with an add (which will be of a
361 negative number if a flat frame) to the sp. FIXME: Does not
362 handle large frames which will need more than one instruction
364 insn
= fetch_instruction (prologue_start
);
365 if (X_OP (insn
) == 2 && X_RD (insn
) == 14 && X_OP3 (insn
) == 0
366 && X_I (insn
) && X_SIMM13 (insn
) < 0)
368 int offset
= X_SIMM13 (insn
);
370 /* Then look for a save of %i7 into the frame. */
371 insn
= fetch_instruction (prologue_start
+ 4);
375 && X_RS1 (insn
) == 14)
377 char buf
[MAX_REGISTER_SIZE
];
379 /* We definitely have a flat frame now. */
380 get_frame_extra_info (fi
)->flat
= 1;
382 get_frame_extra_info (fi
)->sp_offset
= offset
;
384 /* Overwrite the frame's address with the value in %i7. */
387 frame_read_unsigned_register (fi
, I7_REGNUM
, &tmp
);
388 deprecated_update_frame_base_hack (fi
, tmp
);
391 if (GDB_TARGET_IS_SPARC64
&& (get_frame_base (fi
) & 1))
392 deprecated_update_frame_base_hack (fi
, get_frame_base (fi
) + 2047);
394 /* Record where the fp got saved. */
395 get_frame_extra_info (fi
)->fp_addr
=
396 get_frame_base (fi
) + get_frame_extra_info (fi
)->sp_offset
+ X_SIMM13 (insn
);
398 /* Also try to collect where the pc got saved to. */
399 get_frame_extra_info (fi
)->pc_addr
= 0;
400 insn
= fetch_instruction (prologue_start
+ 12);
404 && X_RS1 (insn
) == 14)
405 get_frame_extra_info (fi
)->pc_addr
=
406 get_frame_base (fi
) + get_frame_extra_info (fi
)->sp_offset
+ X_SIMM13 (insn
);
411 /* Check if the PC is in the function prologue before a SAVE
412 instruction has been executed yet. If so, set the frame
413 to the current value of the stack pointer and set
414 the in_prologue flag. */
416 struct symtab_and_line sal
;
418 sal
= find_pc_line (prologue_start
, 0);
419 if (sal
.line
== 0) /* no line info, use PC */
420 prologue_end
= get_frame_pc (fi
);
421 else if (sal
.end
< prologue_end
)
422 prologue_end
= sal
.end
;
423 if (get_frame_pc (fi
) < prologue_end
)
425 for (addr
= prologue_start
; addr
< get_frame_pc (fi
); addr
+= 4)
427 insn
= read_memory_integer (addr
, 4);
428 if (X_OP (insn
) == 2 && X_OP3 (insn
) == 0x3c)
429 break; /* SAVE seen, stop searching */
431 if (addr
>= get_frame_pc (fi
))
433 get_frame_extra_info (fi
)->in_prologue
= 1;
434 deprecated_update_frame_base_hack (fi
, read_register (SP_REGNUM
));
439 if (get_next_frame (fi
) && get_frame_base (fi
) == 0)
441 /* Kludge to cause init_prev_frame_info to destroy the new frame. */
442 deprecated_update_frame_base_hack (fi
, get_frame_base (get_next_frame (fi
)));
443 deprecated_update_frame_pc_hack (fi
, get_frame_pc (get_next_frame (fi
)));
448 sparc_frame_chain (struct frame_info
*frame
)
450 /* Value that will cause DEPRECATED_FRAME_CHAIN_VALID to not worry
451 about the chain value. If it really is zero, we detect it later
452 in sparc_init_prev_frame.
454 Note: kevinb/2003-02-18: The constant 1 used to be returned here,
455 but, after some recent changes to legacy_frame_chain_valid(),
456 this value is no longer suitable for causing
457 legacy_frame_chain_valid() to "not worry about the chain value."
458 The constant ~0 (i.e, 0xfff...) causes the failing test in
459 legacy_frame_chain_valid() to succeed thus preserving the "not
460 worry" property. I had considered using something like
461 ``get_frame_base (frame) + 1''. However, I think a constant
462 value is better, because when debugging this problem, I knew that
463 something funny was going on as soon as I saw the constant 1
464 being used as the frame chain elsewhere in GDB. */
466 return ~ (CORE_ADDR
) 0;
470 sparc_extract_struct_value_address (char *regbuf
)
472 return extract_address (regbuf
+ REGISTER_BYTE (O0_REGNUM
),
473 REGISTER_RAW_SIZE (O0_REGNUM
));
476 /* Find the pc saved in frame FRAME. */
479 sparc_frame_saved_pc (struct frame_info
*frame
)
481 char buf
[MAX_REGISTER_SIZE
];
484 if ((get_frame_type (frame
) == SIGTRAMP_FRAME
))
486 /* This is the signal trampoline frame.
487 Get the saved PC from the sigcontext structure. */
489 #ifndef SIGCONTEXT_PC_OFFSET
490 #define SIGCONTEXT_PC_OFFSET 12
493 CORE_ADDR sigcontext_addr
;
495 int saved_pc_offset
= SIGCONTEXT_PC_OFFSET
;
498 scbuf
= alloca (TARGET_PTR_BIT
/ HOST_CHAR_BIT
);
500 /* Solaris2 ucbsigvechandler passes a pointer to a sigcontext
501 as the third parameter. The offset to the saved pc is 12. */
502 find_pc_partial_function (get_frame_pc (frame
), &name
,
503 (CORE_ADDR
*) NULL
, (CORE_ADDR
*) NULL
);
504 if (name
&& STREQ (name
, "ucbsigvechandler"))
505 saved_pc_offset
= 12;
507 /* The sigcontext address is contained in register O2. */
510 frame_read_unsigned_register (frame
, O0_REGNUM
+ 2, &tmp
);
511 sigcontext_addr
= tmp
;
514 /* Don't cause a memory_error when accessing sigcontext in case the
515 stack layout has changed or the stack is corrupt. */
516 target_read_memory (sigcontext_addr
+ saved_pc_offset
,
517 scbuf
, sizeof (scbuf
));
518 return extract_address (scbuf
, sizeof (scbuf
));
520 else if (get_frame_extra_info (frame
)->in_prologue
||
521 (get_next_frame (frame
) != NULL
&&
522 ((get_frame_type (get_next_frame (frame
)) == SIGTRAMP_FRAME
) ||
523 deprecated_frame_in_dummy (get_next_frame (frame
))) &&
524 frameless_look_for_prologue (frame
)))
526 /* A frameless function interrupted by a signal did not save
527 the PC, it is still in %o7. */
529 frame_read_unsigned_register (frame
, O7_REGNUM
, &tmp
);
530 return PC_ADJUST (tmp
);
532 if (get_frame_extra_info (frame
)->flat
)
533 addr
= get_frame_extra_info (frame
)->pc_addr
;
535 addr
= get_frame_extra_info (frame
)->bottom
+ FRAME_SAVED_I0
+
536 SPARC_INTREG_SIZE
* (I7_REGNUM
- I0_REGNUM
);
539 /* A flat frame leaf function might not save the PC anywhere,
540 just leave it in %o7. */
541 return PC_ADJUST (read_register (O7_REGNUM
));
543 read_memory (addr
, buf
, SPARC_INTREG_SIZE
);
544 return PC_ADJUST (extract_address (buf
, SPARC_INTREG_SIZE
));
547 /* Since an individual frame in the frame cache is defined by two
548 arguments (a frame pointer and a stack pointer), we need two
549 arguments to get info for an arbitrary stack frame. This routine
550 takes two arguments and makes the cached frames look as if these
551 two arguments defined a frame on the cache. This allows the rest
552 of info frame to extract the important arguments without
556 setup_arbitrary_frame (int argc
, CORE_ADDR
*argv
)
558 struct frame_info
*frame
;
561 error ("Sparc frame specifications require two arguments: fp and sp");
563 frame
= create_new_frame (argv
[0], 0);
566 internal_error (__FILE__
, __LINE__
,
567 "create_new_frame returned invalid frame");
569 get_frame_extra_info (frame
)->bottom
= argv
[1];
570 deprecated_update_frame_pc_hack (frame
, DEPRECATED_FRAME_SAVED_PC (frame
));
574 /* Given a pc value, skip it forward past the function prologue by
575 disassembling instructions that appear to be a prologue.
577 If FRAMELESS_P is set, we are only testing to see if the function
578 is frameless. This allows a quicker answer.
580 This routine should be more specific in its actions; making sure
581 that it uses the same register in the initial prologue section. */
583 static CORE_ADDR
examine_prologue (CORE_ADDR
, int, struct frame_info
*,
587 examine_prologue (CORE_ADDR start_pc
, int frameless_p
, struct frame_info
*fi
,
588 CORE_ADDR
*saved_regs
)
592 CORE_ADDR pc
= start_pc
;
595 insn
= fetch_instruction (pc
);
597 /* Recognize the `sethi' insn and record its destination. */
598 if (X_OP (insn
) == 0 && X_OP2 (insn
) == 4)
602 insn
= fetch_instruction (pc
);
605 /* Recognize an add immediate value to register to either %g1 or
606 the destination register recorded above. Actually, this might
607 well recognize several different arithmetic operations.
608 It doesn't check that rs1 == rd because in theory "sub %g0, 5, %g1"
609 followed by "save %sp, %g1, %sp" is a valid prologue (Not that
610 I imagine any compiler really does that, however). */
613 && (X_RD (insn
) == 1 || X_RD (insn
) == dest
))
616 insn
= fetch_instruction (pc
);
619 /* Recognize any SAVE insn. */
620 if (X_OP (insn
) == 2 && X_OP3 (insn
) == 60)
623 if (frameless_p
) /* If the save is all we care about, */
624 return pc
; /* return before doing more work */
625 insn
= fetch_instruction (pc
);
627 /* Recognize add to %sp. */
628 else if (X_OP (insn
) == 2 && X_RD (insn
) == 14 && X_OP3 (insn
) == 0)
631 if (frameless_p
) /* If the add is all we care about, */
632 return pc
; /* return before doing more work */
634 insn
= fetch_instruction (pc
);
635 /* Recognize store of frame pointer (i7). */
639 && X_RS1 (insn
) == 14)
642 insn
= fetch_instruction (pc
);
644 /* Recognize sub %sp, <anything>, %i7. */
647 && X_RS1 (insn
) == 14
648 && X_RD (insn
) == 31)
651 insn
= fetch_instruction (pc
);
660 /* Without a save or add instruction, it's not a prologue. */
665 /* Recognize stores into the frame from the input registers.
666 This recognizes all non alternate stores of an input register,
667 into a location offset from the frame pointer between
670 /* The above will fail for arguments that are promoted
671 (eg. shorts to ints or floats to doubles), because the compiler
672 will pass them in positive-offset frame space, but the prologue
673 will save them (after conversion) in negative frame space at an
674 unpredictable offset. Therefore I am going to remove the
675 restriction on the target-address of the save, on the theory
676 that any unbroken sequence of saves from input registers must
677 be part of the prologue. In un-optimized code (at least), I'm
678 fairly sure that the compiler would emit SOME other instruction
679 (eg. a move or add) before emitting another save that is actually
680 a part of the function body.
682 Besides, the reserved stack space is different for SPARC64 anyway.
687 && (X_OP3 (insn
) & 0x3c) == 4 /* Store, non-alternate. */
688 && (X_RD (insn
) & 0x18) == 0x18 /* Input register. */
689 && X_I (insn
) /* Immediate mode. */
690 && X_RS1 (insn
) == 30) /* Off of frame pointer. */
691 ; /* empty statement -- fall thru to end of loop */
692 else if (GDB_TARGET_IS_SPARC64
694 && (X_OP3 (insn
) & 0x3c) == 12 /* store, extended (64-bit) */
695 && (X_RD (insn
) & 0x18) == 0x18 /* input register */
696 && X_I (insn
) /* immediate mode */
697 && X_RS1 (insn
) == 30) /* off of frame pointer */
698 ; /* empty statement -- fall thru to end of loop */
699 else if (X_OP (insn
) == 3
700 && (X_OP3 (insn
) & 0x3c) == 36 /* store, floating-point */
701 && X_I (insn
) /* immediate mode */
702 && X_RS1 (insn
) == 30) /* off of frame pointer */
703 ; /* empty statement -- fall thru to end of loop */
706 && X_OP3 (insn
) == 4 /* store? */
707 && X_RS1 (insn
) == 14) /* off of frame pointer */
709 if (saved_regs
&& X_I (insn
))
710 saved_regs
[X_RD (insn
)] =
711 get_frame_base (fi
) + get_frame_extra_info (fi
)->sp_offset
+ X_SIMM13 (insn
);
716 insn
= fetch_instruction (pc
);
722 /* Advance PC across any function entry prologue instructions to reach
726 sparc_skip_prologue (CORE_ADDR start_pc
)
728 struct symtab_and_line sal
;
729 CORE_ADDR func_start
, func_end
;
731 /* This is the preferred method, find the end of the prologue by
732 using the debugging information. */
733 if (find_pc_partial_function (start_pc
, NULL
, &func_start
, &func_end
))
735 sal
= find_pc_line (func_start
, 0);
737 if (sal
.end
< func_end
738 && start_pc
<= sal
.end
)
742 /* Oh well, examine the code by hand. */
743 return examine_prologue (start_pc
, 0, NULL
, NULL
);
746 /* Is the prologue at IP frameless? */
749 sparc_prologue_frameless_p (CORE_ADDR ip
)
751 return ip
== examine_prologue (ip
, 1, NULL
, NULL
);
754 /* Check instruction at ADDR to see if it is a branch.
755 All non-annulled instructions will go to NPC or will trap.
756 Set *TARGET if we find a candidate branch; set to zero if not.
758 This isn't static as it's used by remote-sa.sparc.c. */
761 isbranch (long instruction
, CORE_ADDR addr
, CORE_ADDR
*target
)
763 branch_type val
= not_branch
;
764 long int offset
= 0; /* Must be signed for sign-extend. */
768 if (X_OP (instruction
) == 0
769 && (X_OP2 (instruction
) == 2
770 || X_OP2 (instruction
) == 6
771 || X_OP2 (instruction
) == 1
772 || X_OP2 (instruction
) == 3
773 || X_OP2 (instruction
) == 5
774 || (GDB_TARGET_IS_SPARC64
&& X_OP2 (instruction
) == 7)))
776 if (X_COND (instruction
) == 8)
777 val
= X_A (instruction
) ? baa
: ba
;
779 val
= X_A (instruction
) ? bicca
: bicc
;
780 switch (X_OP2 (instruction
))
783 if (!GDB_TARGET_IS_SPARC64
)
788 offset
= 4 * X_DISP22 (instruction
);
792 offset
= 4 * X_DISP19 (instruction
);
795 offset
= 4 * X_DISP16 (instruction
);
798 *target
= addr
+ offset
;
800 else if (GDB_TARGET_IS_SPARC64
801 && X_OP (instruction
) == 2
802 && X_OP3 (instruction
) == 62)
804 if (X_FCN (instruction
) == 0)
807 *target
= read_register (TNPC_REGNUM
);
810 else if (X_FCN (instruction
) == 1)
813 *target
= read_register (TPC_REGNUM
);
821 /* Find register number REGNUM relative to FRAME and put its
822 (raw) contents in *RAW_BUFFER. Set *OPTIMIZED if the variable
823 was optimized out (and thus can't be fetched). If the variable
824 was fetched from memory, set *ADDRP to where it was fetched from,
825 otherwise it was fetched from a register.
827 The argument RAW_BUFFER must point to aligned memory. */
830 sparc_get_saved_register (char *raw_buffer
, int *optimized
, CORE_ADDR
*addrp
,
831 struct frame_info
*frame
, int regnum
,
832 enum lval_type
*lval
)
834 struct frame_info
*frame1
;
837 if (!target_has_registers
)
838 error ("No registers.");
845 /* FIXME This code extracted from infcmd.c; should put elsewhere! */
848 /* error ("No selected frame."); */
849 if (!target_has_registers
)
850 error ("The program has no registers now.");
851 if (deprecated_selected_frame
== NULL
)
852 error ("No selected frame.");
853 /* Try to use selected frame */
854 frame
= get_prev_frame (deprecated_selected_frame
);
856 error ("Cmd not meaningful in the outermost frame.");
860 frame1
= get_next_frame (frame
);
862 /* Get saved PC from the frame info if not in innermost frame. */
863 if (regnum
== PC_REGNUM
&& frame1
!= NULL
)
867 if (raw_buffer
!= NULL
)
869 /* Put it back in target format. */
870 store_unsigned_integer (raw_buffer
, REGISTER_RAW_SIZE (regnum
), get_frame_pc (frame
));
877 while (frame1
!= NULL
)
879 /* FIXME MVS: wrong test for dummy frame at entry. */
881 if (get_frame_pc (frame1
) >= (get_frame_extra_info (frame1
)->bottom
882 ? get_frame_extra_info (frame1
)->bottom
884 && get_frame_pc (frame1
) <= get_frame_base (frame1
))
886 /* Dummy frame. All but the window regs are in there somewhere.
887 The window registers are saved on the stack, just like in a
889 if (regnum
>= G1_REGNUM
&& regnum
< G1_REGNUM
+ 7)
890 addr
= get_frame_base (frame1
) + (regnum
- G0_REGNUM
) * SPARC_INTREG_SIZE
891 - (FP_REGISTER_BYTES
+ 8 * SPARC_INTREG_SIZE
);
892 else if (regnum
>= I0_REGNUM
&& regnum
< I0_REGNUM
+ 8)
893 /* NOTE: cagney/2002-05-04: The call to get_prev_frame()
894 is safe/cheap - there will always be a prev frame.
895 This is because frame1 is initialized to frame->next
896 (frame1->prev == frame) and is then advanced towards
897 the innermost (next) frame. */
898 addr
= (get_frame_extra_info (get_prev_frame (frame1
))->bottom
899 + (regnum
- I0_REGNUM
) * SPARC_INTREG_SIZE
901 else if (regnum
>= L0_REGNUM
&& regnum
< L0_REGNUM
+ 8)
902 /* NOTE: cagney/2002-05-04: The call to get_prev_frame()
903 is safe/cheap - there will always be a prev frame.
904 This is because frame1 is initialized to frame->next
905 (frame1->prev == frame) and is then advanced towards
906 the innermost (next) frame. */
907 addr
= (get_frame_extra_info (get_prev_frame (frame1
))->bottom
908 + (regnum
- L0_REGNUM
) * SPARC_INTREG_SIZE
910 else if (regnum
>= O0_REGNUM
&& regnum
< O0_REGNUM
+ 8)
911 addr
= get_frame_base (frame1
) + (regnum
- O0_REGNUM
) * SPARC_INTREG_SIZE
912 - (FP_REGISTER_BYTES
+ 16 * SPARC_INTREG_SIZE
);
913 else if (SPARC_HAS_FPU
&&
914 regnum
>= FP0_REGNUM
&& regnum
< FP0_REGNUM
+ 32)
915 addr
= get_frame_base (frame1
) + (regnum
- FP0_REGNUM
) * 4
916 - (FP_REGISTER_BYTES
);
917 else if (GDB_TARGET_IS_SPARC64
&& SPARC_HAS_FPU
&&
918 regnum
>= FP0_REGNUM
+ 32 && regnum
< FP_MAX_REGNUM
)
919 addr
= get_frame_base (frame1
) + 32 * 4 + (regnum
- FP0_REGNUM
- 32) * 8
920 - (FP_REGISTER_BYTES
);
921 else if (regnum
>= Y_REGNUM
&& regnum
< NUM_REGS
)
922 addr
= get_frame_base (frame1
) + (regnum
- Y_REGNUM
) * SPARC_INTREG_SIZE
923 - (FP_REGISTER_BYTES
+ 24 * SPARC_INTREG_SIZE
);
925 else if (get_frame_extra_info (frame1
)->flat
)
928 if (regnum
== RP_REGNUM
)
929 addr
= get_frame_extra_info (frame1
)->pc_addr
;
930 else if (regnum
== I7_REGNUM
)
931 addr
= get_frame_extra_info (frame1
)->fp_addr
;
934 CORE_ADDR func_start
;
937 regs
= alloca (NUM_REGS
* sizeof (CORE_ADDR
));
938 memset (regs
, 0, NUM_REGS
* sizeof (CORE_ADDR
));
940 find_pc_partial_function (get_frame_pc (frame1
), NULL
, &func_start
, NULL
);
941 examine_prologue (func_start
, 0, frame1
, regs
);
947 /* Normal frame. Local and In registers are saved on stack. */
948 if (regnum
>= I0_REGNUM
&& regnum
< I0_REGNUM
+ 8)
949 addr
= (get_frame_extra_info (get_prev_frame (frame1
))->bottom
950 + (regnum
- I0_REGNUM
) * SPARC_INTREG_SIZE
952 else if (regnum
>= L0_REGNUM
&& regnum
< L0_REGNUM
+ 8)
953 addr
= (get_frame_extra_info (get_prev_frame (frame1
))->bottom
954 + (regnum
- L0_REGNUM
) * SPARC_INTREG_SIZE
956 else if (regnum
>= O0_REGNUM
&& regnum
< O0_REGNUM
+ 8)
958 /* Outs become ins. */
960 frame_register (frame1
, (regnum
- O0_REGNUM
+ I0_REGNUM
),
961 optimized
, lval
, addrp
, &realnum
, raw_buffer
);
967 frame1
= get_next_frame (frame1
);
973 if (regnum
== SP_REGNUM
)
975 if (raw_buffer
!= NULL
)
977 /* Put it back in target format. */
978 store_unsigned_integer (raw_buffer
, REGISTER_RAW_SIZE (regnum
), addr
);
984 if (raw_buffer
!= NULL
)
985 read_memory (addr
, raw_buffer
, REGISTER_RAW_SIZE (regnum
));
990 *lval
= lval_register
;
991 addr
= REGISTER_BYTE (regnum
);
992 if (raw_buffer
!= NULL
)
993 deprecated_read_register_gen (regnum
, raw_buffer
);
999 /* Push an empty stack frame, and record in it the current PC, regs, etc.
1001 We save the non-windowed registers and the ins. The locals and outs
1002 are new; they don't need to be saved. The i's and l's of
1003 the last frame were already saved on the stack. */
1005 /* Definitely see tm-sparc.h for more doc of the frame format here. */
1007 /* See tm-sparc.h for how this is calculated. */
1009 #define DUMMY_STACK_REG_BUF_SIZE \
1010 (((8+8+8) * SPARC_INTREG_SIZE) + FP_REGISTER_BYTES)
1011 #define DUMMY_STACK_SIZE \
1012 (DUMMY_STACK_REG_BUF_SIZE + DUMMY_REG_SAVE_OFFSET)
1015 sparc_push_dummy_frame (void)
1017 CORE_ADDR sp
, old_sp
;
1018 char *register_temp
;
1020 register_temp
= alloca (DUMMY_STACK_SIZE
);
1022 old_sp
= sp
= read_sp ();
1024 if (GDB_TARGET_IS_SPARC64
)
1026 /* PC, NPC, CCR, FSR, FPRS, Y, ASI */
1027 deprecated_read_register_bytes (REGISTER_BYTE (PC_REGNUM
),
1029 REGISTER_RAW_SIZE (PC_REGNUM
) * 7);
1030 deprecated_read_register_bytes (REGISTER_BYTE (PSTATE_REGNUM
),
1031 ®ister_temp
[7 * SPARC_INTREG_SIZE
],
1032 REGISTER_RAW_SIZE (PSTATE_REGNUM
));
1033 /* FIXME: not sure what needs to be saved here. */
1037 /* Y, PS, WIM, TBR, PC, NPC, FPS, CPS regs */
1038 deprecated_read_register_bytes (REGISTER_BYTE (Y_REGNUM
),
1040 REGISTER_RAW_SIZE (Y_REGNUM
) * 8);
1043 deprecated_read_register_bytes (REGISTER_BYTE (O0_REGNUM
),
1044 ®ister_temp
[8 * SPARC_INTREG_SIZE
],
1045 SPARC_INTREG_SIZE
* 8);
1047 deprecated_read_register_bytes (REGISTER_BYTE (G0_REGNUM
),
1048 ®ister_temp
[16 * SPARC_INTREG_SIZE
],
1049 SPARC_INTREG_SIZE
* 8);
1052 deprecated_read_register_bytes (REGISTER_BYTE (FP0_REGNUM
),
1053 ®ister_temp
[24 * SPARC_INTREG_SIZE
],
1056 sp
-= DUMMY_STACK_SIZE
;
1058 DEPRECATED_DUMMY_WRITE_SP (sp
);
1060 write_memory (sp
+ DUMMY_REG_SAVE_OFFSET
, ®ister_temp
[0],
1061 DUMMY_STACK_REG_BUF_SIZE
);
1063 if (strcmp (target_shortname
, "sim") != 0)
1065 /* NOTE: cagney/2002-04-04: The code below originally contained
1066 GDB's _only_ call to write_fp(). That call was eliminated by
1067 inlining the corresponding code. For the 64 bit case, the
1068 old function (sparc64_write_fp) did the below although I'm
1069 not clear why. The same goes for why this is only done when
1070 the underlying target is a simulator. */
1071 if (GDB_TARGET_IS_SPARC64
)
1073 /* Target is a 64 bit SPARC. */
1074 CORE_ADDR oldfp
= read_register (DEPRECATED_FP_REGNUM
);
1076 write_register (DEPRECATED_FP_REGNUM
, old_sp
- 2047);
1078 write_register (DEPRECATED_FP_REGNUM
, old_sp
);
1082 /* Target is a 32 bit SPARC. */
1083 write_register (DEPRECATED_FP_REGNUM
, old_sp
);
1085 /* Set return address register for the call dummy to the current PC. */
1086 write_register (I7_REGNUM
, read_pc () - 8);
1090 /* The call dummy will write this value to FP before executing
1091 the 'save'. This ensures that register window flushes work
1092 correctly in the simulator. */
1093 write_register (G0_REGNUM
+ 1, read_register (DEPRECATED_FP_REGNUM
));
1095 /* The call dummy will write this value to FP after executing
1097 write_register (G0_REGNUM
+ 2, old_sp
);
1099 /* The call dummy will write this value to the return address (%i7) after
1100 executing the 'save'. */
1101 write_register (G0_REGNUM
+ 3, read_pc () - 8);
1103 /* Set the FP that the call dummy will be using after the 'save'.
1104 This makes backtraces from an inferior function call work properly. */
1105 write_register (DEPRECATED_FP_REGNUM
, old_sp
);
1109 /* sparc_frame_find_saved_regs (). This function is here only because
1110 pop_frame uses it. Note there is an interesting corner case which
1111 I think few ports of GDB get right--if you are popping a frame
1112 which does not save some register that *is* saved by a more inner
1113 frame (such a frame will never be a dummy frame because dummy
1114 frames save all registers).
1116 NOTE: cagney/2003-03-12: Since pop_frame has been rewritten to use
1117 frame_unwind_register() the need for this function is questionable.
1119 Stores, into an array of CORE_ADDR,
1120 the addresses of the saved registers of frame described by FRAME_INFO.
1121 This includes special registers such as pc and fp saved in special
1122 ways in the stack frame. sp is even more special:
1123 the address we return for it IS the sp for the next frame.
1125 Note that on register window machines, we are currently making the
1126 assumption that window registers are being saved somewhere in the
1127 frame in which they are being used. If they are stored in an
1128 inferior frame, find_saved_register will break.
1130 On the Sun 4, the only time all registers are saved is when
1131 a dummy frame is involved. Otherwise, the only saved registers
1132 are the LOCAL and IN registers which are saved as a result
1133 of the "save/restore" opcodes. This condition is determined
1134 by address rather than by value.
1136 The "pc" is not stored in a frame on the SPARC. (What is stored
1137 is a return address minus 8.) sparc_pop_frame knows how to
1138 deal with that. Other routines might or might not.
1140 See tm-sparc.h (PUSH_DUMMY_FRAME and friends) for CRITICAL information
1141 about how this works. */
1143 static void sparc_frame_find_saved_regs (struct frame_info
*, CORE_ADDR
*);
1146 sparc_frame_find_saved_regs (struct frame_info
*fi
, CORE_ADDR
*saved_regs_addr
)
1148 register int regnum
;
1149 CORE_ADDR frame_addr
= get_frame_base (fi
);
1151 gdb_assert (fi
!= NULL
);
1153 memset (saved_regs_addr
, 0, NUM_REGS
* sizeof (CORE_ADDR
));
1155 if (get_frame_pc (fi
) >= (get_frame_extra_info (fi
)->bottom
1156 ? get_frame_extra_info (fi
)->bottom
1158 && get_frame_pc (fi
) <= get_frame_base (fi
))
1160 /* Dummy frame. All but the window regs are in there somewhere. */
1161 for (regnum
= G1_REGNUM
; regnum
< G1_REGNUM
+ 7; regnum
++)
1162 saved_regs_addr
[regnum
] =
1163 frame_addr
+ (regnum
- G0_REGNUM
) * SPARC_INTREG_SIZE
1164 - DUMMY_STACK_REG_BUF_SIZE
+ 16 * SPARC_INTREG_SIZE
;
1166 for (regnum
= I0_REGNUM
; regnum
< I0_REGNUM
+ 8; regnum
++)
1167 saved_regs_addr
[regnum
] =
1168 frame_addr
+ (regnum
- I0_REGNUM
) * SPARC_INTREG_SIZE
1169 - DUMMY_STACK_REG_BUF_SIZE
+ 8 * SPARC_INTREG_SIZE
;
1172 for (regnum
= FP0_REGNUM
; regnum
< FP_MAX_REGNUM
; regnum
++)
1173 saved_regs_addr
[regnum
] = frame_addr
+ (regnum
- FP0_REGNUM
) * 4
1174 - DUMMY_STACK_REG_BUF_SIZE
+ 24 * SPARC_INTREG_SIZE
;
1176 if (GDB_TARGET_IS_SPARC64
)
1178 for (regnum
= PC_REGNUM
; regnum
< PC_REGNUM
+ 7; regnum
++)
1180 saved_regs_addr
[regnum
] =
1181 frame_addr
+ (regnum
- PC_REGNUM
) * SPARC_INTREG_SIZE
1182 - DUMMY_STACK_REG_BUF_SIZE
;
1184 saved_regs_addr
[PSTATE_REGNUM
] =
1185 frame_addr
+ 8 * SPARC_INTREG_SIZE
- DUMMY_STACK_REG_BUF_SIZE
;
1188 for (regnum
= Y_REGNUM
; regnum
< NUM_REGS
; regnum
++)
1189 saved_regs_addr
[regnum
] =
1190 frame_addr
+ (regnum
- Y_REGNUM
) * SPARC_INTREG_SIZE
1191 - DUMMY_STACK_REG_BUF_SIZE
;
1193 frame_addr
= (get_frame_extra_info (fi
)->bottom
1194 ? get_frame_extra_info (fi
)->bottom
1197 else if (get_frame_extra_info (fi
)->flat
)
1199 CORE_ADDR func_start
;
1200 find_pc_partial_function (get_frame_pc (fi
), NULL
, &func_start
, NULL
);
1201 examine_prologue (func_start
, 0, fi
, saved_regs_addr
);
1203 /* Flat register window frame. */
1204 saved_regs_addr
[RP_REGNUM
] = get_frame_extra_info (fi
)->pc_addr
;
1205 saved_regs_addr
[I7_REGNUM
] = get_frame_extra_info (fi
)->fp_addr
;
1209 /* Normal frame. Just Local and In registers */
1210 frame_addr
= (get_frame_extra_info (fi
)->bottom
1211 ? get_frame_extra_info (fi
)->bottom
1213 for (regnum
= L0_REGNUM
; regnum
< L0_REGNUM
+ 8; regnum
++)
1214 saved_regs_addr
[regnum
] =
1215 (frame_addr
+ (regnum
- L0_REGNUM
) * SPARC_INTREG_SIZE
1217 for (regnum
= I0_REGNUM
; regnum
< I0_REGNUM
+ 8; regnum
++)
1218 saved_regs_addr
[regnum
] =
1219 (frame_addr
+ (regnum
- I0_REGNUM
) * SPARC_INTREG_SIZE
1222 if (get_next_frame (fi
))
1224 if (get_frame_extra_info (fi
)->flat
)
1226 saved_regs_addr
[O7_REGNUM
] = get_frame_extra_info (fi
)->pc_addr
;
1230 /* Pull off either the next frame pointer or the stack pointer */
1231 CORE_ADDR next_next_frame_addr
=
1232 (get_frame_extra_info (get_next_frame (fi
))->bottom
1233 ? get_frame_extra_info (get_next_frame (fi
))->bottom
1235 for (regnum
= O0_REGNUM
; regnum
< O0_REGNUM
+ 8; regnum
++)
1236 saved_regs_addr
[regnum
] =
1237 (next_next_frame_addr
1238 + (regnum
- O0_REGNUM
) * SPARC_INTREG_SIZE
1242 /* Otherwise, whatever we would get from ptrace(GETREGS) is accurate */
1243 /* FIXME -- should this adjust for the sparc64 offset? */
1244 saved_regs_addr
[SP_REGNUM
] = get_frame_base (fi
);
1247 /* Discard from the stack the innermost frame, restoring all saved registers.
1249 Note that the values stored in fsr by
1250 deprecated_get_frame_saved_regs are *in the context of the called
1251 frame*. What this means is that the i regs of fsr must be restored
1252 into the o regs of the (calling) frame that we pop into. We don't
1253 care about the output regs of the calling frame, since unless it's
1254 a dummy frame, it won't have any output regs in it.
1256 We never have to bother with %l (local) regs, since the called routine's
1257 locals get tossed, and the calling routine's locals are already saved
1260 /* Definitely see tm-sparc.h for more doc of the frame format here. */
1263 sparc_pop_frame (void)
1265 register struct frame_info
*frame
= get_current_frame ();
1266 register CORE_ADDR pc
;
1271 fsr
= alloca (NUM_REGS
* sizeof (CORE_ADDR
));
1272 raw_buffer
= alloca (REGISTER_BYTES
);
1273 sparc_frame_find_saved_regs (frame
, &fsr
[0]);
1276 if (fsr
[FP0_REGNUM
])
1278 read_memory (fsr
[FP0_REGNUM
], raw_buffer
, FP_REGISTER_BYTES
);
1279 deprecated_write_register_bytes (REGISTER_BYTE (FP0_REGNUM
),
1280 raw_buffer
, FP_REGISTER_BYTES
);
1282 if (!(GDB_TARGET_IS_SPARC64
))
1284 if (fsr
[FPS_REGNUM
])
1286 read_memory (fsr
[FPS_REGNUM
], raw_buffer
, SPARC_INTREG_SIZE
);
1287 deprecated_write_register_gen (FPS_REGNUM
, raw_buffer
);
1289 if (fsr
[CPS_REGNUM
])
1291 read_memory (fsr
[CPS_REGNUM
], raw_buffer
, SPARC_INTREG_SIZE
);
1292 deprecated_write_register_gen (CPS_REGNUM
, raw_buffer
);
1298 read_memory (fsr
[G1_REGNUM
], raw_buffer
, 7 * SPARC_INTREG_SIZE
);
1299 deprecated_write_register_bytes (REGISTER_BYTE (G1_REGNUM
), raw_buffer
,
1300 7 * SPARC_INTREG_SIZE
);
1303 if (get_frame_extra_info (frame
)->flat
)
1305 /* Each register might or might not have been saved, need to test
1307 for (regnum
= L0_REGNUM
; regnum
< L0_REGNUM
+ 8; ++regnum
)
1309 write_register (regnum
, read_memory_integer (fsr
[regnum
],
1310 SPARC_INTREG_SIZE
));
1311 for (regnum
= I0_REGNUM
; regnum
< I0_REGNUM
+ 8; ++regnum
)
1313 write_register (regnum
, read_memory_integer (fsr
[regnum
],
1314 SPARC_INTREG_SIZE
));
1316 /* Handle all outs except stack pointer (o0-o5; o7). */
1317 for (regnum
= O0_REGNUM
; regnum
< O0_REGNUM
+ 6; ++regnum
)
1319 write_register (regnum
, read_memory_integer (fsr
[regnum
],
1320 SPARC_INTREG_SIZE
));
1321 if (fsr
[O0_REGNUM
+ 7])
1322 write_register (O0_REGNUM
+ 7,
1323 read_memory_integer (fsr
[O0_REGNUM
+ 7],
1324 SPARC_INTREG_SIZE
));
1326 DEPRECATED_DUMMY_WRITE_SP (get_frame_base (frame
));
1328 else if (fsr
[I0_REGNUM
])
1334 reg_temp
= alloca (SPARC_INTREG_SIZE
* 16);
1336 read_memory (fsr
[I0_REGNUM
], raw_buffer
, 8 * SPARC_INTREG_SIZE
);
1338 /* Get the ins and locals which we are about to restore. Just
1339 moving the stack pointer is all that is really needed, except
1340 store_inferior_registers is then going to write the ins and
1341 locals from the registers array, so we need to muck with the
1343 sp
= fsr
[SP_REGNUM
];
1345 if (GDB_TARGET_IS_SPARC64
&& (sp
& 1))
1348 read_memory (sp
, reg_temp
, SPARC_INTREG_SIZE
* 16);
1350 /* Restore the out registers.
1351 Among other things this writes the new stack pointer. */
1352 deprecated_write_register_bytes (REGISTER_BYTE (O0_REGNUM
), raw_buffer
,
1353 SPARC_INTREG_SIZE
* 8);
1355 deprecated_write_register_bytes (REGISTER_BYTE (L0_REGNUM
), reg_temp
,
1356 SPARC_INTREG_SIZE
* 16);
1359 if (!(GDB_TARGET_IS_SPARC64
))
1361 write_register (PS_REGNUM
,
1362 read_memory_integer (fsr
[PS_REGNUM
],
1363 REGISTER_RAW_SIZE (PS_REGNUM
)));
1366 write_register (Y_REGNUM
,
1367 read_memory_integer (fsr
[Y_REGNUM
],
1368 REGISTER_RAW_SIZE (Y_REGNUM
)));
1371 /* Explicitly specified PC (and maybe NPC) -- just restore them. */
1372 write_register (PC_REGNUM
,
1373 read_memory_integer (fsr
[PC_REGNUM
],
1374 REGISTER_RAW_SIZE (PC_REGNUM
)));
1375 if (fsr
[NPC_REGNUM
])
1376 write_register (NPC_REGNUM
,
1377 read_memory_integer (fsr
[NPC_REGNUM
],
1378 REGISTER_RAW_SIZE (NPC_REGNUM
)));
1380 else if (get_frame_extra_info (frame
)->flat
)
1382 if (get_frame_extra_info (frame
)->pc_addr
)
1383 pc
= PC_ADJUST ((CORE_ADDR
)
1384 read_memory_integer (get_frame_extra_info (frame
)->pc_addr
,
1385 REGISTER_RAW_SIZE (PC_REGNUM
)));
1388 /* I think this happens only in the innermost frame, if so then
1389 it is a complicated way of saying
1390 "pc = read_register (O7_REGNUM);". */
1392 frame_read_unsigned_register (frame
, O7_REGNUM
, &tmp
);
1393 pc
= PC_ADJUST (tmp
);
1396 write_register (PC_REGNUM
, pc
);
1397 write_register (NPC_REGNUM
, pc
+ 4);
1399 else if (fsr
[I7_REGNUM
])
1401 /* Return address in %i7 -- adjust it, then restore PC and NPC from it */
1402 pc
= PC_ADJUST ((CORE_ADDR
) read_memory_integer (fsr
[I7_REGNUM
],
1403 SPARC_INTREG_SIZE
));
1404 write_register (PC_REGNUM
, pc
);
1405 write_register (NPC_REGNUM
, pc
+ 4);
1407 flush_cached_frames ();
1410 /* On the Sun 4 under SunOS, the compile will leave a fake insn which
1411 encodes the structure size being returned. If we detect such
1412 a fake insn, step past it. */
1415 sparc_pc_adjust (CORE_ADDR pc
)
1421 err
= target_read_memory (pc
+ 8, buf
, 4);
1422 insn
= extract_unsigned_integer (buf
, 4);
1423 if ((err
== 0) && (insn
& 0xffc00000) == 0)
1429 /* If pc is in a shared library trampoline, return its target.
1430 The SunOs 4.x linker rewrites the jump table entries for PIC
1431 compiled modules in the main executable to bypass the dynamic linker
1432 with jumps of the form
1435 and removes the corresponding jump table relocation entry in the
1436 dynamic relocations.
1437 find_solib_trampoline_target relies on the presence of the jump
1438 table relocation entry, so we have to detect these jump instructions
1442 sunos4_skip_trampoline_code (CORE_ADDR pc
)
1444 unsigned long insn1
;
1448 err
= target_read_memory (pc
, buf
, 4);
1449 insn1
= extract_unsigned_integer (buf
, 4);
1450 if (err
== 0 && (insn1
& 0xffc00000) == 0x03000000)
1452 unsigned long insn2
;
1454 err
= target_read_memory (pc
+ 4, buf
, 4);
1455 insn2
= extract_unsigned_integer (buf
, 4);
1456 if (err
== 0 && (insn2
& 0xffffe000) == 0x81c06000)
1458 CORE_ADDR target_pc
= (insn1
& 0x3fffff) << 10;
1459 int delta
= insn2
& 0x1fff;
1461 /* Sign extend the displacement. */
1464 return target_pc
+ delta
;
1467 return find_solib_trampoline_target (pc
);
1470 #ifdef USE_PROC_FS /* Target dependent support for /proc */
1472 /* The /proc interface divides the target machine's register set up into
1473 two different sets, the general register set (gregset) and the floating
1474 point register set (fpregset). For each set, there is an ioctl to get
1475 the current register set and another ioctl to set the current values.
1477 The actual structure passed through the ioctl interface is, of course,
1478 naturally machine dependent, and is different for each set of registers.
1479 For the sparc for example, the general register set is typically defined
1482 typedef int gregset_t[38];
1488 and the floating point set by:
1490 typedef struct prfpregset {
1493 double pr_dregs[16];
1498 u_char pr_q_entrysize;
1503 These routines provide the packing and unpacking of gregset_t and
1504 fpregset_t formatted data.
1509 /* Given a pointer to a general register set in /proc format (gregset_t *),
1510 unpack the register contents and supply them as gdb's idea of the current
1514 supply_gregset (gdb_gregset_t
*gregsetp
)
1516 prgreg_t
*regp
= (prgreg_t
*) gregsetp
;
1517 int regi
, offset
= 0;
1519 /* If the host is 64-bit sparc, but the target is 32-bit sparc,
1520 then the gregset may contain 64-bit ints while supply_register
1521 is expecting 32-bit ints. Compensate. */
1522 if (sizeof (regp
[0]) == 8 && SPARC_INTREG_SIZE
== 4)
1525 /* GDB register numbers for Gn, On, Ln, In all match /proc reg numbers. */
1526 /* FIXME MVS: assumes the order of the first 32 elements... */
1527 for (regi
= G0_REGNUM
; regi
<= I7_REGNUM
; regi
++)
1529 supply_register (regi
, ((char *) (regp
+ regi
)) + offset
);
1532 /* These require a bit more care. */
1533 supply_register (PC_REGNUM
, ((char *) (regp
+ R_PC
)) + offset
);
1534 supply_register (NPC_REGNUM
, ((char *) (regp
+ R_nPC
)) + offset
);
1535 supply_register (Y_REGNUM
, ((char *) (regp
+ R_Y
)) + offset
);
1537 if (GDB_TARGET_IS_SPARC64
)
1540 supply_register (CCR_REGNUM
, ((char *) (regp
+ R_CCR
)) + offset
);
1542 supply_register (CCR_REGNUM
, NULL
);
1545 supply_register (FPRS_REGNUM
, ((char *) (regp
+ R_FPRS
)) + offset
);
1547 supply_register (FPRS_REGNUM
, NULL
);
1550 supply_register (ASI_REGNUM
, ((char *) (regp
+ R_ASI
)) + offset
);
1552 supply_register (ASI_REGNUM
, NULL
);
1558 supply_register (PS_REGNUM
, ((char *) (regp
+ R_PS
)) + offset
);
1560 supply_register (PS_REGNUM
, NULL
);
1563 /* For 64-bit hosts, R_WIM and R_TBR may not be defined.
1564 Steal R_ASI and R_FPRS, and hope for the best! */
1566 #if !defined (R_WIM) && defined (R_ASI)
1570 #if !defined (R_TBR) && defined (R_FPRS)
1571 #define R_TBR R_FPRS
1575 supply_register (WIM_REGNUM
, ((char *) (regp
+ R_WIM
)) + offset
);
1577 supply_register (WIM_REGNUM
, NULL
);
1581 supply_register (TBR_REGNUM
, ((char *) (regp
+ R_TBR
)) + offset
);
1583 supply_register (TBR_REGNUM
, NULL
);
1587 /* Fill inaccessible registers with zero. */
1588 if (GDB_TARGET_IS_SPARC64
)
1591 * don't know how to get value of any of the following:
1593 supply_register (VER_REGNUM
, NULL
);
1594 supply_register (TICK_REGNUM
, NULL
);
1595 supply_register (PIL_REGNUM
, NULL
);
1596 supply_register (PSTATE_REGNUM
, NULL
);
1597 supply_register (TSTATE_REGNUM
, NULL
);
1598 supply_register (TBA_REGNUM
, NULL
);
1599 supply_register (TL_REGNUM
, NULL
);
1600 supply_register (TT_REGNUM
, NULL
);
1601 supply_register (TPC_REGNUM
, NULL
);
1602 supply_register (TNPC_REGNUM
, NULL
);
1603 supply_register (WSTATE_REGNUM
, NULL
);
1604 supply_register (CWP_REGNUM
, NULL
);
1605 supply_register (CANSAVE_REGNUM
, NULL
);
1606 supply_register (CANRESTORE_REGNUM
, NULL
);
1607 supply_register (CLEANWIN_REGNUM
, NULL
);
1608 supply_register (OTHERWIN_REGNUM
, NULL
);
1609 supply_register (ASR16_REGNUM
, NULL
);
1610 supply_register (ASR17_REGNUM
, NULL
);
1611 supply_register (ASR18_REGNUM
, NULL
);
1612 supply_register (ASR19_REGNUM
, NULL
);
1613 supply_register (ASR20_REGNUM
, NULL
);
1614 supply_register (ASR21_REGNUM
, NULL
);
1615 supply_register (ASR22_REGNUM
, NULL
);
1616 supply_register (ASR23_REGNUM
, NULL
);
1617 supply_register (ASR24_REGNUM
, NULL
);
1618 supply_register (ASR25_REGNUM
, NULL
);
1619 supply_register (ASR26_REGNUM
, NULL
);
1620 supply_register (ASR27_REGNUM
, NULL
);
1621 supply_register (ASR28_REGNUM
, NULL
);
1622 supply_register (ASR29_REGNUM
, NULL
);
1623 supply_register (ASR30_REGNUM
, NULL
);
1624 supply_register (ASR31_REGNUM
, NULL
);
1625 supply_register (ICC_REGNUM
, NULL
);
1626 supply_register (XCC_REGNUM
, NULL
);
1630 supply_register (CPS_REGNUM
, NULL
);
1635 fill_gregset (gdb_gregset_t
*gregsetp
, int regno
)
1637 prgreg_t
*regp
= (prgreg_t
*) gregsetp
;
1638 int regi
, offset
= 0;
1640 /* If the host is 64-bit sparc, but the target is 32-bit sparc,
1641 then the gregset may contain 64-bit ints while supply_register
1642 is expecting 32-bit ints. Compensate. */
1643 if (sizeof (regp
[0]) == 8 && SPARC_INTREG_SIZE
== 4)
1646 for (regi
= 0; regi
<= R_I7
; regi
++)
1647 if ((regno
== -1) || (regno
== regi
))
1648 deprecated_read_register_gen (regi
, (char *) (regp
+ regi
) + offset
);
1650 if ((regno
== -1) || (regno
== PC_REGNUM
))
1651 deprecated_read_register_gen (PC_REGNUM
, (char *) (regp
+ R_PC
) + offset
);
1653 if ((regno
== -1) || (regno
== NPC_REGNUM
))
1654 deprecated_read_register_gen (NPC_REGNUM
, (char *) (regp
+ R_nPC
) + offset
);
1656 if ((regno
== -1) || (regno
== Y_REGNUM
))
1657 deprecated_read_register_gen (Y_REGNUM
, (char *) (regp
+ R_Y
) + offset
);
1659 if (GDB_TARGET_IS_SPARC64
)
1662 if (regno
== -1 || regno
== CCR_REGNUM
)
1663 deprecated_read_register_gen (CCR_REGNUM
, ((char *) (regp
+ R_CCR
)) + offset
);
1666 if (regno
== -1 || regno
== FPRS_REGNUM
)
1667 deprecated_read_register_gen (FPRS_REGNUM
, ((char *) (regp
+ R_FPRS
)) + offset
);
1670 if (regno
== -1 || regno
== ASI_REGNUM
)
1671 deprecated_read_register_gen (ASI_REGNUM
, ((char *) (regp
+ R_ASI
)) + offset
);
1677 if (regno
== -1 || regno
== PS_REGNUM
)
1678 deprecated_read_register_gen (PS_REGNUM
, ((char *) (regp
+ R_PS
)) + offset
);
1681 /* For 64-bit hosts, R_WIM and R_TBR may not be defined.
1682 Steal R_ASI and R_FPRS, and hope for the best! */
1684 #if !defined (R_WIM) && defined (R_ASI)
1688 #if !defined (R_TBR) && defined (R_FPRS)
1689 #define R_TBR R_FPRS
1693 if (regno
== -1 || regno
== WIM_REGNUM
)
1694 deprecated_read_register_gen (WIM_REGNUM
, ((char *) (regp
+ R_WIM
)) + offset
);
1696 if (regno
== -1 || regno
== WIM_REGNUM
)
1697 deprecated_read_register_gen (WIM_REGNUM
, NULL
);
1701 if (regno
== -1 || regno
== TBR_REGNUM
)
1702 deprecated_read_register_gen (TBR_REGNUM
, ((char *) (regp
+ R_TBR
)) + offset
);
1704 if (regno
== -1 || regno
== TBR_REGNUM
)
1705 deprecated_read_register_gen (TBR_REGNUM
, NULL
);
1710 /* Given a pointer to a floating point register set in /proc format
1711 (fpregset_t *), unpack the register contents and supply them as gdb's
1712 idea of the current floating point register values. */
1715 supply_fpregset (gdb_fpregset_t
*fpregsetp
)
1723 for (regi
= FP0_REGNUM
; regi
< FP_MAX_REGNUM
; regi
++)
1725 from
= (char *) &fpregsetp
->pr_fr
.pr_regs
[regi
- FP0_REGNUM
];
1726 supply_register (regi
, from
);
1729 if (GDB_TARGET_IS_SPARC64
)
1732 * don't know how to get value of the following.
1734 supply_register (FSR_REGNUM
, NULL
); /* zero it out for now */
1735 supply_register (FCC0_REGNUM
, NULL
);
1736 supply_register (FCC1_REGNUM
, NULL
); /* don't know how to get value */
1737 supply_register (FCC2_REGNUM
, NULL
); /* don't know how to get value */
1738 supply_register (FCC3_REGNUM
, NULL
); /* don't know how to get value */
1742 supply_register (FPS_REGNUM
, (char *) &(fpregsetp
->pr_fsr
));
1746 /* Given a pointer to a floating point register set in /proc format
1747 (fpregset_t *), update the register specified by REGNO from gdb's idea
1748 of the current floating point register set. If REGNO is -1, update
1750 /* This will probably need some changes for sparc64. */
1753 fill_fpregset (gdb_fpregset_t
*fpregsetp
, int regno
)
1762 for (regi
= FP0_REGNUM
; regi
< FP_MAX_REGNUM
; regi
++)
1764 if ((regno
== -1) || (regno
== regi
))
1766 from
= (char *) &deprecated_registers
[REGISTER_BYTE (regi
)];
1767 to
= (char *) &fpregsetp
->pr_fr
.pr_regs
[regi
- FP0_REGNUM
];
1768 memcpy (to
, from
, REGISTER_RAW_SIZE (regi
));
1772 if (!(GDB_TARGET_IS_SPARC64
)) /* FIXME: does Sparc64 have this register? */
1773 if ((regno
== -1) || (regno
== FPS_REGNUM
))
1775 from
= (char *)&deprecated_registers
[REGISTER_BYTE (FPS_REGNUM
)];
1776 to
= (char *) &fpregsetp
->pr_fsr
;
1777 memcpy (to
, from
, REGISTER_RAW_SIZE (FPS_REGNUM
));
1781 #endif /* USE_PROC_FS */
1783 /* Because of Multi-arch, GET_LONGJMP_TARGET is always defined. So test
1784 for a definition of JB_PC. */
1787 /* Figure out where the longjmp will land. We expect that we have just entered
1788 longjmp and haven't yet setup the stack frame, so the args are still in the
1789 output regs. %o0 (O0_REGNUM) points at the jmp_buf structure from which we
1790 extract the pc (JB_PC) that we will land at. The pc is copied into ADDR.
1791 This routine returns true on success */
1794 get_longjmp_target (CORE_ADDR
*pc
)
1797 #define LONGJMP_TARGET_SIZE 4
1798 char buf
[LONGJMP_TARGET_SIZE
];
1800 jb_addr
= read_register (O0_REGNUM
);
1802 if (target_read_memory (jb_addr
+ JB_PC
* JB_ELEMENT_SIZE
, buf
,
1803 LONGJMP_TARGET_SIZE
))
1806 *pc
= extract_address (buf
, LONGJMP_TARGET_SIZE
);
1810 #endif /* GET_LONGJMP_TARGET */
1812 #ifdef STATIC_TRANSFORM_NAME
1813 /* SunPRO (3.0 at least), encodes the static variables. This is not
1814 related to C++ mangling, it is done for C too. */
1817 sunpro_static_transform_name (char *name
)
1822 /* For file-local statics there will be a dollar sign, a bunch
1823 of junk (the contents of which match a string given in the
1824 N_OPT), a period and the name. For function-local statics
1825 there will be a bunch of junk (which seems to change the
1826 second character from 'A' to 'B'), a period, the name of the
1827 function, and the name. So just skip everything before the
1829 p
= strrchr (name
, '.');
1835 #endif /* STATIC_TRANSFORM_NAME */
1838 /* Utilities for printing registers.
1839 Page numbers refer to the SPARC Architecture Manual. */
1841 static void dump_ccreg (char *, int);
1844 dump_ccreg (char *reg
, int val
)
1847 printf_unfiltered ("%s:%s,%s,%s,%s", reg
,
1848 val
& 8 ? "N" : "NN",
1849 val
& 4 ? "Z" : "NZ",
1850 val
& 2 ? "O" : "NO",
1851 val
& 1 ? "C" : "NC");
1855 decode_asi (int val
)
1861 return "ASI_NUCLEUS";
1863 return "ASI_NUCLEUS_LITTLE";
1865 return "ASI_AS_IF_USER_PRIMARY";
1867 return "ASI_AS_IF_USER_SECONDARY";
1869 return "ASI_AS_IF_USER_PRIMARY_LITTLE";
1871 return "ASI_AS_IF_USER_SECONDARY_LITTLE";
1873 return "ASI_PRIMARY";
1875 return "ASI_SECONDARY";
1877 return "ASI_PRIMARY_NOFAULT";
1879 return "ASI_SECONDARY_NOFAULT";
1881 return "ASI_PRIMARY_LITTLE";
1883 return "ASI_SECONDARY_LITTLE";
1885 return "ASI_PRIMARY_NOFAULT_LITTLE";
1887 return "ASI_SECONDARY_NOFAULT_LITTLE";
1893 /* Pretty print various registers. */
1894 /* FIXME: Would be nice if this did some fancy things for 32 bit sparc. */
1897 sparc_print_register_hook (int regno
)
1901 /* Handle double/quad versions of lower 32 fp regs. */
1902 if (regno
>= FP0_REGNUM
&& regno
< FP0_REGNUM
+ 32
1903 && (regno
& 1) == 0)
1907 if (frame_register_read (deprecated_selected_frame
, regno
, value
)
1908 && frame_register_read (deprecated_selected_frame
, regno
+ 1, value
+ 4))
1910 printf_unfiltered ("\t");
1911 print_floating (value
, builtin_type_double
, gdb_stdout
);
1913 #if 0 /* FIXME: gdb doesn't handle long doubles */
1914 if ((regno
& 3) == 0)
1916 if (frame_register_read (deprecated_selected_frame
, regno
+ 2, value
+ 8)
1917 && frame_register_read (deprecated_selected_frame
, regno
+ 3, value
+ 12))
1919 printf_unfiltered ("\t");
1920 print_floating (value
, builtin_type_long_double
, gdb_stdout
);
1927 #if 0 /* FIXME: gdb doesn't handle long doubles */
1928 /* Print upper fp regs as long double if appropriate. */
1929 if (regno
>= FP0_REGNUM
+ 32 && regno
< FP_MAX_REGNUM
1930 /* We test for even numbered regs and not a multiple of 4 because
1931 the upper fp regs are recorded as doubles. */
1932 && (regno
& 1) == 0)
1936 if (frame_register_read (deprecated_selected_frame
, regno
, value
)
1937 && frame_register_read (deprecated_selected_frame
, regno
+ 1, value
+ 8))
1939 printf_unfiltered ("\t");
1940 print_floating (value
, builtin_type_long_double
, gdb_stdout
);
1946 /* FIXME: Some of these are priviledged registers.
1947 Not sure how they should be handled. */
1949 #define BITS(n, mask) ((int) (((val) >> (n)) & (mask)))
1951 val
= read_register (regno
);
1954 if (GDB_TARGET_IS_SPARC64
)
1958 printf_unfiltered ("\t");
1959 dump_ccreg ("xcc", val
>> 4);
1960 printf_unfiltered (", ");
1961 dump_ccreg ("icc", val
& 15);
1964 printf ("\tfef:%d, du:%d, dl:%d",
1965 BITS (2, 1), BITS (1, 1), BITS (0, 1));
1969 static char *fcc
[4] =
1970 {"=", "<", ">", "?"};
1971 static char *rd
[4] =
1972 {"N", "0", "+", "-"};
1973 /* Long, but I'd rather leave it as is and use a wide screen. */
1974 printf_filtered ("\t0:%s, 1:%s, 2:%s, 3:%s, rd:%s, tem:%d, ",
1975 fcc
[BITS (10, 3)], fcc
[BITS (32, 3)],
1976 fcc
[BITS (34, 3)], fcc
[BITS (36, 3)],
1977 rd
[BITS (30, 3)], BITS (23, 31));
1978 printf_filtered ("ns:%d, ver:%d, ftt:%d, qne:%d, aexc:%d, cexc:%d",
1979 BITS (22, 1), BITS (17, 7), BITS (14, 7),
1980 BITS (13, 1), BITS (5, 31), BITS (0, 31));
1985 char *asi
= decode_asi (val
);
1987 printf ("\t%s", asi
);
1991 printf ("\tmanuf:%d, impl:%d, mask:%d, maxtl:%d, maxwin:%d",
1992 BITS (48, 0xffff), BITS (32, 0xffff),
1993 BITS (24, 0xff), BITS (8, 0xff), BITS (0, 31));
1997 static char *mm
[4] =
1998 {"tso", "pso", "rso", "?"};
1999 printf_filtered ("\tcle:%d, tle:%d, mm:%s, red:%d, ",
2000 BITS (9, 1), BITS (8, 1),
2001 mm
[BITS (6, 3)], BITS (5, 1));
2002 printf_filtered ("pef:%d, am:%d, priv:%d, ie:%d, ag:%d",
2003 BITS (4, 1), BITS (3, 1), BITS (2, 1),
2004 BITS (1, 1), BITS (0, 1));
2008 /* FIXME: print all 4? */
2011 /* FIXME: print all 4? */
2014 /* FIXME: print all 4? */
2017 /* FIXME: print all 4? */
2020 printf ("\tother:%d, normal:%d", BITS (3, 7), BITS (0, 7));
2023 printf ("\t%d", BITS (0, 31));
2025 case CANSAVE_REGNUM
:
2026 printf ("\t%-2d before spill", BITS (0, 31));
2028 case CANRESTORE_REGNUM
:
2029 printf ("\t%-2d before fill", BITS (0, 31));
2031 case CLEANWIN_REGNUM
:
2032 printf ("\t%-2d before clean", BITS (0, 31));
2034 case OTHERWIN_REGNUM
:
2035 printf ("\t%d", BITS (0, 31));
2042 printf ("\ticc:%c%c%c%c, pil:%d, s:%d, ps:%d, et:%d, cwp:%d",
2043 BITS (23, 1) ? 'N' : '-', BITS (22, 1) ? 'Z' : '-',
2044 BITS (21, 1) ? 'V' : '-', BITS (20, 1) ? 'C' : '-',
2045 BITS (8, 15), BITS (7, 1), BITS (6, 1), BITS (5, 1),
2050 static char *fcc
[4] =
2051 {"=", "<", ">", "?"};
2052 static char *rd
[4] =
2053 {"N", "0", "+", "-"};
2054 /* Long, but I'd rather leave it as is and use a wide screen. */
2055 printf ("\trd:%s, tem:%d, ns:%d, ver:%d, ftt:%d, qne:%d, "
2056 "fcc:%s, aexc:%d, cexc:%d",
2057 rd
[BITS (30, 3)], BITS (23, 31), BITS (22, 1), BITS (17, 7),
2058 BITS (14, 7), BITS (13, 1), fcc
[BITS (10, 3)], BITS (5, 31),
2068 sparc_print_registers (struct gdbarch
*gdbarch
,
2069 struct ui_file
*file
,
2070 struct frame_info
*frame
,
2071 int regnum
, int print_all
,
2072 void (*print_register_hook
) (int))
2075 const int numregs
= NUM_REGS
+ NUM_PSEUDO_REGS
;
2076 char raw_buffer
[MAX_REGISTER_SIZE
];
2077 char virtual_buffer
[MAX_REGISTER_SIZE
];
2079 for (i
= 0; i
< numregs
; i
++)
2081 /* Decide between printing all regs, non-float / vector regs, or
2087 if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (i
)) == TYPE_CODE_FLT
)
2089 if (TYPE_VECTOR (REGISTER_VIRTUAL_TYPE (i
)))
2099 /* If the register name is empty, it is undefined for this
2100 processor, so don't display anything. */
2101 if (REGISTER_NAME (i
) == NULL
|| *(REGISTER_NAME (i
)) == '\0')
2104 fputs_filtered (REGISTER_NAME (i
), file
);
2105 print_spaces_filtered (15 - strlen (REGISTER_NAME (i
)), file
);
2107 /* Get the data in raw format. */
2108 if (! frame_register_read (frame
, i
, raw_buffer
))
2110 fprintf_filtered (file
, "*value not available*\n");
2114 /* FIXME: cagney/2002-08-03: This code shouldn't be necessary.
2115 The function frame_register_read() should have returned the
2116 pre-cooked register so no conversion is necessary. */
2117 /* Convert raw data to virtual format if necessary. */
2118 if (REGISTER_CONVERTIBLE (i
))
2120 REGISTER_CONVERT_TO_VIRTUAL (i
, REGISTER_VIRTUAL_TYPE (i
),
2121 raw_buffer
, virtual_buffer
);
2125 memcpy (virtual_buffer
, raw_buffer
,
2126 REGISTER_VIRTUAL_SIZE (i
));
2129 /* If virtual format is floating, print it that way, and in raw
2131 if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (i
)) == TYPE_CODE_FLT
)
2135 val_print (REGISTER_VIRTUAL_TYPE (i
), virtual_buffer
, 0, 0,
2136 file
, 0, 1, 0, Val_pretty_default
);
2138 fprintf_filtered (file
, "\t(raw 0x");
2139 for (j
= 0; j
< REGISTER_RAW_SIZE (i
); j
++)
2142 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
2145 idx
= REGISTER_RAW_SIZE (i
) - 1 - j
;
2146 fprintf_filtered (file
, "%02x", (unsigned char) raw_buffer
[idx
]);
2148 fprintf_filtered (file
, ")");
2152 /* Print the register in hex. */
2153 val_print (REGISTER_VIRTUAL_TYPE (i
), virtual_buffer
, 0, 0,
2154 file
, 'x', 1, 0, Val_pretty_default
);
2155 /* If not a vector register, print it also according to its
2157 if (TYPE_VECTOR (REGISTER_VIRTUAL_TYPE (i
)) == 0)
2159 fprintf_filtered (file
, "\t");
2160 val_print (REGISTER_VIRTUAL_TYPE (i
), virtual_buffer
, 0, 0,
2161 file
, 0, 1, 0, Val_pretty_default
);
2165 /* Some sparc specific info. */
2166 if (print_register_hook
!= NULL
)
2167 print_register_hook (i
);
2169 fprintf_filtered (file
, "\n");
2174 sparc_print_registers_info (struct gdbarch
*gdbarch
,
2175 struct ui_file
*file
,
2176 struct frame_info
*frame
,
2177 int regnum
, int print_all
)
2179 sparc_print_registers (gdbarch
, file
, frame
, regnum
, print_all
,
2180 sparc_print_register_hook
);
2184 sparc_do_registers_info (int regnum
, int all
)
2186 sparc_print_registers_info (current_gdbarch
, gdb_stdout
, deprecated_selected_frame
,
2191 // OBSOLETE static void
2192 // OBSOLETE sparclet_print_registers_info (struct gdbarch *gdbarch,
2193 // OBSOLETE struct ui_file *file,
2194 // OBSOLETE struct frame_info *frame,
2195 // OBSOLETE int regnum, int print_all)
2197 // OBSOLETE sparc_print_registers (gdbarch, file, frame, regnum, print_all, NULL);
2201 // OBSOLETE sparclet_do_registers_info (int regnum, int all)
2203 // OBSOLETE sparclet_print_registers_info (current_gdbarch, gdb_stdout,
2204 // OBSOLETE deprecated_selected_frame, regnum, all);
2210 gdb_print_insn_sparc (bfd_vma memaddr
, disassemble_info
*info
)
2212 /* It's necessary to override mach again because print_insn messes it up. */
2213 info
->mach
= TARGET_ARCHITECTURE
->mach
;
2214 return print_insn_sparc (memaddr
, info
);
2217 /* The SPARC passes the arguments on the stack; arguments smaller
2218 than an int are promoted to an int. The first 6 words worth of
2219 args are also passed in registers o0 - o5. */
2222 sparc32_push_arguments (int nargs
, struct value
**args
, CORE_ADDR sp
,
2223 int struct_return
, CORE_ADDR struct_addr
)
2226 int accumulate_size
= 0;
2233 struct sparc_arg
*sparc_args
=
2234 (struct sparc_arg
*) alloca (nargs
* sizeof (struct sparc_arg
));
2235 struct sparc_arg
*m_arg
;
2237 /* Promote arguments if necessary, and calculate their stack offsets
2239 for (i
= 0, m_arg
= sparc_args
; i
< nargs
; i
++, m_arg
++)
2241 struct value
*arg
= args
[i
];
2242 struct type
*arg_type
= check_typedef (VALUE_TYPE (arg
));
2243 /* Cast argument to long if necessary as the compiler does it too. */
2244 switch (TYPE_CODE (arg_type
))
2247 case TYPE_CODE_BOOL
:
2248 case TYPE_CODE_CHAR
:
2249 case TYPE_CODE_RANGE
:
2250 case TYPE_CODE_ENUM
:
2251 if (TYPE_LENGTH (arg_type
) < TYPE_LENGTH (builtin_type_long
))
2253 arg_type
= builtin_type_long
;
2254 arg
= value_cast (arg_type
, arg
);
2260 m_arg
->len
= TYPE_LENGTH (arg_type
);
2261 m_arg
->offset
= accumulate_size
;
2262 accumulate_size
= (accumulate_size
+ m_arg
->len
+ 3) & ~3;
2263 m_arg
->contents
= VALUE_CONTENTS (arg
);
2266 /* Make room for the arguments on the stack. */
2267 accumulate_size
+= DEPRECATED_CALL_DUMMY_STACK_ADJUST
;
2268 sp
= ((sp
- accumulate_size
) & ~7) + DEPRECATED_CALL_DUMMY_STACK_ADJUST
;
2270 /* `Push' arguments on the stack. */
2271 for (i
= 0, oregnum
= 0, m_arg
= sparc_args
;
2275 write_memory (sp
+ m_arg
->offset
, m_arg
->contents
, m_arg
->len
);
2277 j
< m_arg
->len
&& oregnum
< 6;
2278 j
+= SPARC_INTREG_SIZE
, oregnum
++)
2279 deprecated_write_register_gen (O0_REGNUM
+ oregnum
, m_arg
->contents
+ j
);
2286 /* Extract from an array REGBUF containing the (raw) register state
2287 a function return value of type TYPE, and copy that, in virtual format,
2291 sparc32_extract_return_value (struct type
*type
, char *regbuf
, char *valbuf
)
2293 int typelen
= TYPE_LENGTH (type
);
2294 int regsize
= REGISTER_RAW_SIZE (O0_REGNUM
);
2296 if (TYPE_CODE (type
) == TYPE_CODE_FLT
&& SPARC_HAS_FPU
)
2297 memcpy (valbuf
, ®buf
[REGISTER_BYTE (FP0_REGNUM
)], typelen
);
2300 ®buf
[O0_REGNUM
* regsize
+
2302 || TARGET_BYTE_ORDER
== BFD_ENDIAN_LITTLE
? 0
2303 : regsize
- typelen
)],
2308 /* Write into appropriate registers a function return value
2309 of type TYPE, given in virtual format. On SPARCs with FPUs,
2310 float values are returned in %f0 (and %f1). In all other cases,
2311 values are returned in register %o0. */
2314 sparc_store_return_value (struct type
*type
, char *valbuf
)
2317 char buffer
[MAX_REGISTER_SIZE
];
2319 if (TYPE_CODE (type
) == TYPE_CODE_FLT
&& SPARC_HAS_FPU
)
2320 /* Floating-point values are returned in the register pair */
2321 /* formed by %f0 and %f1 (doubles are, anyway). */
2324 /* Other values are returned in register %o0. */
2327 /* Add leading zeros to the value. */
2328 if (TYPE_LENGTH (type
) < REGISTER_RAW_SIZE (regno
))
2330 memset (buffer
, 0, REGISTER_RAW_SIZE (regno
));
2331 memcpy (buffer
+ REGISTER_RAW_SIZE (regno
) - TYPE_LENGTH (type
), valbuf
,
2332 TYPE_LENGTH (type
));
2333 deprecated_write_register_gen (regno
, buffer
);
2336 deprecated_write_register_bytes (REGISTER_BYTE (regno
), valbuf
,
2337 TYPE_LENGTH (type
));
2341 // OBSOLETE extern void
2342 // OBSOLETE sparclet_store_return_value (struct type *type, char *valbuf)
2344 // OBSOLETE /* Other values are returned in register %o0. */
2345 // OBSOLETE deprecated_write_register_bytes (REGISTER_BYTE (O0_REGNUM), valbuf,
2346 // OBSOLETE TYPE_LENGTH (type));
2351 #ifndef CALL_DUMMY_CALL_OFFSET
2352 #define CALL_DUMMY_CALL_OFFSET \
2353 (gdbarch_tdep (current_gdbarch)->call_dummy_call_offset)
2354 #endif /* CALL_DUMMY_CALL_OFFSET */
2356 /* Insert the function address into a call dummy instruction sequence
2359 For structs and unions, if the function was compiled with Sun cc,
2360 it expects 'unimp' after the call. But gcc doesn't use that
2361 (twisted) convention. So leave a nop there for gcc
2362 (DEPRECATED_FIX_CALL_DUMMY can assume it is operating on a pristine
2363 CALL_DUMMY, not one that has already been customized for a
2364 different function). */
2367 sparc_fix_call_dummy (char *dummy
, CORE_ADDR pc
, CORE_ADDR fun
,
2368 struct type
*value_type
, int using_gcc
)
2372 /* Store the relative adddress of the target function into the
2373 'call' instruction. */
2374 store_unsigned_integer (dummy
+ CALL_DUMMY_CALL_OFFSET
, 4,
2376 | (((fun
- (pc
+ CALL_DUMMY_CALL_OFFSET
)) >> 2)
2379 /* If the called function returns an aggregate value, fill in the UNIMP
2380 instruction containing the size of the returned aggregate return value,
2381 which follows the call instruction.
2382 For details see the SPARC Architecture Manual Version 8, Appendix D.3.
2384 Adjust the call_dummy_breakpoint_offset for the bp_call_dummy breakpoint
2385 to the proper address in the call dummy, so that `finish' after a stop
2386 in a call dummy works.
2388 Tweeking current_gdbarch is not an optimal solution, but the call
2389 to sparc_fix_call_dummy is immediately followed by a call to
2390 call_function_by_hand, which is the only function where
2391 dummy_breakpoint_offset is actually used, if it is non-zero. */
2392 if (TYPE_CODE (value_type
) == TYPE_CODE_STRUCT
2393 || TYPE_CODE (value_type
) == TYPE_CODE_UNION
)
2395 store_unsigned_integer (dummy
+ CALL_DUMMY_CALL_OFFSET
+ 8, 4,
2396 TYPE_LENGTH (value_type
) & 0x1fff);
2397 set_gdbarch_deprecated_call_dummy_breakpoint_offset (current_gdbarch
, 0x30);
2400 set_gdbarch_deprecated_call_dummy_breakpoint_offset (current_gdbarch
, 0x2c);
2402 if (!(GDB_TARGET_IS_SPARC64
))
2404 /* If this is not a simulator target, change the first four
2405 instructions of the call dummy to NOPs. Those instructions
2406 include a 'save' instruction and are designed to work around
2407 problems with register window flushing in the simulator. */
2409 if (strcmp (target_shortname
, "sim") != 0)
2411 for (i
= 0; i
< 4; i
++)
2412 store_unsigned_integer (dummy
+ (i
* 4), 4, 0x01000000);
2417 // OBSOLETE /* If this is a bi-endian target, GDB has written the call dummy
2418 // OBSOLETE in little-endian order. We must byte-swap it back to big-endian. */
2419 // OBSOLETE if (bi_endian)
2421 // OBSOLETE for (i = 0; i < CALL_DUMMY_LENGTH; i += 4)
2423 // OBSOLETE char tmp = dummy[i];
2424 // OBSOLETE dummy[i] = dummy[i + 3];
2425 // OBSOLETE dummy[i + 3] = tmp;
2426 // OBSOLETE tmp = dummy[i + 1];
2427 // OBSOLETE dummy[i + 1] = dummy[i + 2];
2428 // OBSOLETE dummy[i + 2] = tmp;
2436 // OBSOLETE /* Set target byte order based on machine type. */
2438 // OBSOLETE static int
2439 // OBSOLETE sparc_target_architecture_hook (const bfd_arch_info_type *ap)
2441 // OBSOLETE int i, j;
2443 // OBSOLETE if (ap->mach == bfd_mach_sparc_sparclite_le)
2445 // OBSOLETE target_byte_order = BFD_ENDIAN_LITTLE;
2446 // OBSOLETE bi_endian = 1;
2449 // OBSOLETE bi_endian = 0;
2450 // OBSOLETE return 1;
2455 * Module "constructor" function.
2458 static struct gdbarch
* sparc_gdbarch_init (struct gdbarch_info info
,
2459 struct gdbarch_list
*arches
);
2460 static void sparc_dump_tdep (struct gdbarch
*, struct ui_file
*);
2463 _initialize_sparc_tdep (void)
2465 /* Hook us into the gdbarch mechanism. */
2466 gdbarch_register (bfd_arch_sparc
, sparc_gdbarch_init
, sparc_dump_tdep
);
2468 deprecated_tm_print_insn
= gdb_print_insn_sparc
;
2469 deprecated_tm_print_insn_info
.mach
= TM_PRINT_INSN_MACH
; /* Selects sparc/sparclite */
2470 /* OBSOLETE target_architecture_hook = sparc_target_architecture_hook; */
2473 /* Compensate for stack bias. Note that we currently don't handle
2474 mixed 32/64 bit code. */
2477 sparc64_read_sp (void)
2479 CORE_ADDR sp
= read_register (SP_REGNUM
);
2487 sparc64_read_fp (void)
2489 CORE_ADDR fp
= read_register (DEPRECATED_FP_REGNUM
);
2497 sparc64_write_sp (CORE_ADDR val
)
2499 CORE_ADDR oldsp
= read_register (SP_REGNUM
);
2501 write_register (SP_REGNUM
, val
- 2047);
2503 write_register (SP_REGNUM
, val
);
2506 /* The SPARC 64 ABI passes floating-point arguments in FP0 to FP31,
2507 and all other arguments in O0 to O5. They are also copied onto
2508 the stack in the correct places. Apparently (empirically),
2509 structs of less than 16 bytes are passed member-by-member in
2510 separate registers, but I am unable to figure out the algorithm.
2511 Some members go in floating point regs, but I don't know which.
2513 FIXME: Handle small structs (less than 16 bytes containing floats).
2515 The counting regimen for using both integer and FP registers
2516 for argument passing is rather odd -- a single counter is used
2517 for both; this means that if the arguments alternate between
2518 int and float, we will waste every other register of both types. */
2521 sparc64_push_arguments (int nargs
, struct value
**args
, CORE_ADDR sp
,
2522 int struct_return
, CORE_ADDR struct_retaddr
)
2524 int i
, j
, register_counter
= 0;
2526 struct type
*sparc_intreg_type
=
2527 TYPE_LENGTH (builtin_type_long
) == SPARC_INTREG_SIZE
?
2528 builtin_type_long
: builtin_type_long_long
;
2530 sp
= (sp
& ~(((unsigned long) SPARC_INTREG_SIZE
) - 1UL));
2532 /* Figure out how much space we'll need. */
2533 for (i
= nargs
- 1; i
>= 0; i
--)
2535 int len
= TYPE_LENGTH (check_typedef (VALUE_TYPE (args
[i
])));
2536 struct value
*copyarg
= args
[i
];
2539 if (copylen
< SPARC_INTREG_SIZE
)
2541 copyarg
= value_cast (sparc_intreg_type
, copyarg
);
2542 copylen
= SPARC_INTREG_SIZE
;
2551 /* if STRUCT_RETURN, then first argument is the struct return location. */
2553 write_register (O0_REGNUM
+ register_counter
++, struct_retaddr
);
2555 /* Now write the arguments onto the stack, while writing FP
2556 arguments into the FP registers, and other arguments into the
2557 first six 'O' registers. */
2559 for (i
= 0; i
< nargs
; i
++)
2561 int len
= TYPE_LENGTH (check_typedef (VALUE_TYPE (args
[i
])));
2562 struct value
*copyarg
= args
[i
];
2563 enum type_code typecode
= TYPE_CODE (VALUE_TYPE (args
[i
]));
2566 if (typecode
== TYPE_CODE_INT
||
2567 typecode
== TYPE_CODE_BOOL
||
2568 typecode
== TYPE_CODE_CHAR
||
2569 typecode
== TYPE_CODE_RANGE
||
2570 typecode
== TYPE_CODE_ENUM
)
2571 if (len
< SPARC_INTREG_SIZE
)
2573 /* Small ints will all take up the size of one intreg on
2575 copyarg
= value_cast (sparc_intreg_type
, copyarg
);
2576 copylen
= SPARC_INTREG_SIZE
;
2579 write_memory (tempsp
, VALUE_CONTENTS (copyarg
), copylen
);
2582 /* Corner case: Structs consisting of a single float member are floats.
2583 * FIXME! I don't know about structs containing multiple floats!
2584 * Structs containing mixed floats and ints are even more weird.
2589 /* Separate float args from all other args. */
2590 if (typecode
== TYPE_CODE_FLT
&& SPARC_HAS_FPU
)
2592 if (register_counter
< 16)
2594 /* This arg gets copied into a FP register. */
2598 case 4: /* Single-precision (float) */
2599 fpreg
= FP0_REGNUM
+ 2 * register_counter
+ 1;
2600 register_counter
+= 1;
2602 case 8: /* Double-precision (double) */
2603 fpreg
= FP0_REGNUM
+ 2 * register_counter
;
2604 register_counter
+= 1;
2606 case 16: /* Quad-precision (long double) */
2607 fpreg
= FP0_REGNUM
+ 2 * register_counter
;
2608 register_counter
+= 2;
2611 internal_error (__FILE__
, __LINE__
, "bad switch");
2613 deprecated_write_register_bytes (REGISTER_BYTE (fpreg
),
2614 VALUE_CONTENTS (args
[i
]),
2618 else /* all other args go into the first six 'o' registers */
2621 j
< len
&& register_counter
< 6;
2622 j
+= SPARC_INTREG_SIZE
)
2624 int oreg
= O0_REGNUM
+ register_counter
;
2626 deprecated_write_register_gen (oreg
, VALUE_CONTENTS (copyarg
) + j
);
2627 register_counter
+= 1;
2634 /* Values <= 32 bytes are returned in o0-o3 (floating-point values are
2635 returned in f0-f3). */
2638 sp64_extract_return_value (struct type
*type
, char *regbuf
, char *valbuf
,
2641 int typelen
= TYPE_LENGTH (type
);
2642 int regsize
= REGISTER_RAW_SIZE (O0_REGNUM
);
2644 if (TYPE_CODE (type
) == TYPE_CODE_FLT
&& SPARC_HAS_FPU
)
2646 memcpy (valbuf
, ®buf
[REGISTER_BYTE (FP0_REGNUM
)], typelen
);
2650 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
2651 || (TYPE_LENGTH (type
) > 32))
2654 ®buf
[O0_REGNUM
* regsize
+
2655 (typelen
>= regsize
? 0 : regsize
- typelen
)],
2661 char *o0
= ®buf
[O0_REGNUM
* regsize
];
2662 char *f0
= ®buf
[FP0_REGNUM
* regsize
];
2665 for (x
= 0; x
< TYPE_NFIELDS (type
); x
++)
2667 struct field
*f
= &TYPE_FIELDS (type
)[x
];
2668 /* FIXME: We may need to handle static fields here. */
2669 int whichreg
= (f
->loc
.bitpos
+ bitoffset
) / 32;
2670 int remainder
= ((f
->loc
.bitpos
+ bitoffset
) % 32) / 8;
2671 int where
= (f
->loc
.bitpos
+ bitoffset
) / 8;
2672 int size
= TYPE_LENGTH (f
->type
);
2673 int typecode
= TYPE_CODE (f
->type
);
2675 if (typecode
== TYPE_CODE_STRUCT
)
2677 sp64_extract_return_value (f
->type
,
2680 bitoffset
+ f
->loc
.bitpos
);
2682 else if (typecode
== TYPE_CODE_FLT
&& SPARC_HAS_FPU
)
2684 memcpy (valbuf
+ where
, &f0
[whichreg
* 4] + remainder
, size
);
2688 memcpy (valbuf
+ where
, &o0
[whichreg
* 4] + remainder
, size
);
2695 sparc64_extract_return_value (struct type
*type
, char *regbuf
, char *valbuf
)
2697 sp64_extract_return_value (type
, regbuf
, valbuf
, 0);
2701 // OBSOLETE extern void
2702 // OBSOLETE sparclet_extract_return_value (struct type *type,
2703 // OBSOLETE char *regbuf,
2704 // OBSOLETE char *valbuf)
2706 // OBSOLETE regbuf += REGISTER_RAW_SIZE (O0_REGNUM) * 8;
2707 // OBSOLETE if (TYPE_LENGTH (type) < REGISTER_RAW_SIZE (O0_REGNUM))
2708 // OBSOLETE regbuf += REGISTER_RAW_SIZE (O0_REGNUM) - TYPE_LENGTH (type);
2710 // OBSOLETE memcpy ((void *) valbuf, regbuf, TYPE_LENGTH (type));
2715 sparc32_stack_align (CORE_ADDR addr
)
2717 return ((addr
+ 7) & -8);
2721 sparc64_stack_align (CORE_ADDR addr
)
2723 return ((addr
+ 15) & -16);
2727 sparc_print_extra_frame_info (struct frame_info
*fi
)
2729 if (fi
&& get_frame_extra_info (fi
) && get_frame_extra_info (fi
)->flat
)
2730 printf_filtered (" flat, pc saved at 0x%s, fp saved at 0x%s\n",
2731 paddr_nz (get_frame_extra_info (fi
)->pc_addr
),
2732 paddr_nz (get_frame_extra_info (fi
)->fp_addr
));
2735 /* MULTI_ARCH support */
2738 sparc32_register_name (int regno
)
2740 static char *register_names
[] =
2741 { "g0", "g1", "g2", "g3", "g4", "g5", "g6", "g7",
2742 "o0", "o1", "o2", "o3", "o4", "o5", "sp", "o7",
2743 "l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7",
2744 "i0", "i1", "i2", "i3", "i4", "i5", "fp", "i7",
2746 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
2747 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
2748 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
2749 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
2751 "y", "psr", "wim", "tbr", "pc", "npc", "fpsr", "cpsr"
2755 regno
>= (sizeof (register_names
) / sizeof (register_names
[0])))
2758 return register_names
[regno
];
2762 sparc64_register_name (int regno
)
2764 static char *register_names
[] =
2765 { "g0", "g1", "g2", "g3", "g4", "g5", "g6", "g7",
2766 "o0", "o1", "o2", "o3", "o4", "o5", "sp", "o7",
2767 "l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7",
2768 "i0", "i1", "i2", "i3", "i4", "i5", "fp", "i7",
2770 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
2771 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
2772 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
2773 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
2774 "f32", "f34", "f36", "f38", "f40", "f42", "f44", "f46",
2775 "f48", "f50", "f52", "f54", "f56", "f58", "f60", "f62",
2777 "pc", "npc", "ccr", "fsr", "fprs", "y", "asi", "ver",
2778 "tick", "pil", "pstate", "tstate", "tba", "tl", "tt", "tpc",
2779 "tnpc", "wstate", "cwp", "cansave", "canrestore", "cleanwin", "otherwin",
2780 "asr16", "asr17", "asr18", "asr19", "asr20", "asr21", "asr22", "asr23",
2781 "asr24", "asr25", "asr26", "asr27", "asr28", "asr29", "asr30", "asr31",
2782 /* These are here at the end to simplify removing them if we have to. */
2783 "icc", "xcc", "fcc0", "fcc1", "fcc2", "fcc3"
2787 regno
>= (sizeof (register_names
) / sizeof (register_names
[0])))
2790 return register_names
[regno
];
2794 // OBSOLETE static const char *
2795 // OBSOLETE sparclite_register_name (int regno)
2797 // OBSOLETE static char *register_names[] =
2798 // OBSOLETE { "g0", "g1", "g2", "g3", "g4", "g5", "g6", "g7",
2799 // OBSOLETE "o0", "o1", "o2", "o3", "o4", "o5", "sp", "o7",
2800 // OBSOLETE "l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7",
2801 // OBSOLETE "i0", "i1", "i2", "i3", "i4", "i5", "fp", "i7",
2803 // OBSOLETE "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
2804 // OBSOLETE "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
2805 // OBSOLETE "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
2806 // OBSOLETE "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
2808 // OBSOLETE "y", "psr", "wim", "tbr", "pc", "npc", "fpsr", "cpsr",
2809 // OBSOLETE "dia1", "dia2", "dda1", "dda2", "ddv1", "ddv2", "dcr", "dsr"
2812 // OBSOLETE if (regno < 0 ||
2813 // OBSOLETE regno >= (sizeof (register_names) / sizeof (register_names[0])))
2814 // OBSOLETE return NULL;
2816 // OBSOLETE return register_names[regno];
2821 // OBSOLETE static const char *
2822 // OBSOLETE sparclet_register_name (int regno)
2824 // OBSOLETE static char *register_names[] =
2825 // OBSOLETE { "g0", "g1", "g2", "g3", "g4", "g5", "g6", "g7",
2826 // OBSOLETE "o0", "o1", "o2", "o3", "o4", "o5", "sp", "o7",
2827 // OBSOLETE "l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7",
2828 // OBSOLETE "i0", "i1", "i2", "i3", "i4", "i5", "fp", "i7",
2830 // OBSOLETE "", "", "", "", "", "", "", "", /* no floating point registers */
2831 // OBSOLETE "", "", "", "", "", "", "", "",
2832 // OBSOLETE "", "", "", "", "", "", "", "",
2833 // OBSOLETE "", "", "", "", "", "", "", "",
2835 // OBSOLETE "y", "psr", "wim", "tbr", "pc", "npc", "", "", /* no FPSR or CPSR */
2836 // OBSOLETE "ccsr", "ccpr", "cccrcr", "ccor", "ccobr", "ccibr", "ccir", "",
2838 // OBSOLETE /* ASR15 ASR19 (don't display them) */
2839 // OBSOLETE "asr1", "", "asr17", "asr18", "", "asr20", "asr21", "asr22"
2840 // OBSOLETE /* None of the rest get displayed */
2842 // OBSOLETE "awr0", "awr1", "awr2", "awr3", "awr4", "awr5", "awr6", "awr7",
2843 // OBSOLETE "awr8", "awr9", "awr10", "awr11", "awr12", "awr13", "awr14", "awr15",
2844 // OBSOLETE "awr16", "awr17", "awr18", "awr19", "awr20", "awr21", "awr22", "awr23",
2845 // OBSOLETE "awr24", "awr25", "awr26", "awr27", "awr28", "awr29", "awr30", "awr31",
2847 // OBSOLETE #endif /* 0 */
2850 // OBSOLETE if (regno < 0 ||
2851 // OBSOLETE regno >= (sizeof (register_names) / sizeof (register_names[0])))
2852 // OBSOLETE return NULL;
2854 // OBSOLETE return register_names[regno];
2859 sparc_push_return_address (CORE_ADDR pc_unused
, CORE_ADDR sp
)
2861 if (CALL_DUMMY_LOCATION
== AT_ENTRY_POINT
)
2863 /* The return PC of the dummy_frame is the former 'current' PC
2864 (where we were before we made the target function call).
2865 This is saved in %i7 by push_dummy_frame.
2867 We will save the 'call dummy location' (ie. the address
2868 to which the target function will return) in %o7.
2869 This address will actually be the program's entry point.
2870 There will be a special call_dummy breakpoint there. */
2872 write_register (O7_REGNUM
,
2873 CALL_DUMMY_ADDRESS () - 8);
2879 /* Should call_function allocate stack space for a struct return? */
2882 sparc64_use_struct_convention (int gcc_p
, struct type
*type
)
2884 return (TYPE_LENGTH (type
) > 32);
2887 /* Store the address of the place in which to copy the structure the
2888 subroutine will return. This is called from call_function_by_hand.
2889 The ultimate mystery is, tho, what is the value "16"?
2891 MVS: That's the offset from where the sp is now, to where the
2892 subroutine is gonna expect to find the struct return address. */
2895 sparc32_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
)
2900 val
= alloca (SPARC_INTREG_SIZE
);
2901 store_unsigned_integer (val
, SPARC_INTREG_SIZE
, addr
);
2902 write_memory (sp
+ (16 * SPARC_INTREG_SIZE
), val
, SPARC_INTREG_SIZE
);
2904 if (CALL_DUMMY_LOCATION
== AT_ENTRY_POINT
)
2906 /* Now adjust the value of the link register, which was previously
2907 stored by push_return_address. Functions that return structs are
2908 peculiar in that they return to link register + 12, rather than
2909 link register + 8. */
2911 o7
= read_register (O7_REGNUM
);
2912 write_register (O7_REGNUM
, o7
- 4);
2917 sparc64_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
)
2919 /* FIXME: V9 uses %o0 for this. */
2920 /* FIXME MVS: Only for small enough structs!!! */
2922 target_write_memory (sp
+ (16 * SPARC_INTREG_SIZE
),
2923 (char *) &addr
, SPARC_INTREG_SIZE
);
2925 if (CALL_DUMMY_LOCATION
== AT_ENTRY_POINT
)
2927 /* Now adjust the value of the link register, which was previously
2928 stored by push_return_address. Functions that return structs are
2929 peculiar in that they return to link register + 12, rather than
2930 link register + 8. */
2932 write_register (O7_REGNUM
, read_register (O7_REGNUM
) - 4);
2937 /* Default target data type for register REGNO. */
2939 static struct type
*
2940 sparc32_register_virtual_type (int regno
)
2942 if (regno
== PC_REGNUM
||
2943 regno
== DEPRECATED_FP_REGNUM
||
2945 return builtin_type_unsigned_int
;
2947 return builtin_type_int
;
2949 return builtin_type_float
;
2950 return builtin_type_int
;
2953 static struct type
*
2954 sparc64_register_virtual_type (int regno
)
2956 if (regno
== PC_REGNUM
||
2957 regno
== DEPRECATED_FP_REGNUM
||
2959 return builtin_type_unsigned_long_long
;
2961 return builtin_type_long_long
;
2963 return builtin_type_float
;
2965 return builtin_type_double
;
2966 return builtin_type_long_long
;
2969 /* Number of bytes of storage in the actual machine representation for
2973 sparc32_register_size (int regno
)
2979 sparc64_register_size (int regno
)
2981 return (regno
< 32 ? 8 : regno
< 64 ? 4 : 8);
2984 /* Index within the `registers' buffer of the first byte of the space
2985 for register REGNO. */
2988 sparc32_register_byte (int regno
)
2994 sparc64_register_byte (int regno
)
2998 else if (regno
< 64)
2999 return 32 * 8 + (regno
- 32) * 4;
3000 else if (regno
< 80)
3001 return 32 * 8 + 32 * 4 + (regno
- 64) * 8;
3003 return 64 * 8 + (regno
- 80) * 8;
3006 /* Immediately after a function call, return the saved pc.
3007 Can't go through the frames for this because on some machines
3008 the new frame is not set up until the new function executes
3009 some instructions. */
3012 sparc_saved_pc_after_call (struct frame_info
*fi
)
3014 return sparc_pc_adjust (read_register (RP_REGNUM
));
3017 /* Convert registers between 'raw' and 'virtual' formats.
3018 They are the same on sparc, so there's nothing to do. */
3021 sparc_convert_to_virtual (int regnum
, struct type
*type
, char *from
, char *to
)
3022 { /* do nothing (should never be called) */
3026 sparc_convert_to_raw (struct type
*type
, int regnum
, char *from
, char *to
)
3027 { /* do nothing (should never be called) */
3030 /* Init saved regs: nothing to do, just a place-holder function. */
3033 sparc_frame_init_saved_regs (struct frame_info
*fi_ignored
)
3037 /* gdbarch fix call dummy:
3038 All this function does is rearrange the arguments before calling
3039 sparc_fix_call_dummy (which does the real work). */
3042 sparc_gdbarch_fix_call_dummy (char *dummy
,
3046 struct value
**args
,
3050 if (CALL_DUMMY_LOCATION
== ON_STACK
)
3051 sparc_fix_call_dummy (dummy
, pc
, fun
, type
, gcc_p
);
3054 /* CALL_DUMMY_ADDRESS: fetch the breakpoint address for a call dummy. */
3057 sparc_call_dummy_address (void)
3059 return (DEPRECATED_CALL_DUMMY_START_OFFSET
) + DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET
;
3062 /* Supply the Y register number to those that need it. */
3065 sparc_y_regnum (void)
3067 return gdbarch_tdep (current_gdbarch
)->y_regnum
;
3071 sparc_reg_struct_has_addr (int gcc_p
, struct type
*type
)
3073 if (GDB_TARGET_IS_SPARC64
)
3074 return (TYPE_LENGTH (type
) > 32);
3076 return (gcc_p
!= 1);
3080 sparc_intreg_size (void)
3082 return SPARC_INTREG_SIZE
;
3086 sparc_return_value_on_stack (struct type
*type
)
3088 if (TYPE_CODE (type
) == TYPE_CODE_FLT
&&
3089 TYPE_LENGTH (type
) > 8)
3096 * Gdbarch "constructor" function.
3099 #define SPARC32_CALL_DUMMY_ON_STACK
3101 #define SPARC_SP_REGNUM 14
3102 #define SPARC_FP_REGNUM 30
3103 #define SPARC_FP0_REGNUM 32
3104 #define SPARC32_NPC_REGNUM 69
3105 #define SPARC32_PC_REGNUM 68
3106 #define SPARC32_Y_REGNUM 64
3107 #define SPARC64_PC_REGNUM 80
3108 #define SPARC64_NPC_REGNUM 81
3109 #define SPARC64_Y_REGNUM 85
3111 static struct gdbarch
*
3112 sparc_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
3114 struct gdbarch
*gdbarch
;
3115 struct gdbarch_tdep
*tdep
;
3117 static LONGEST call_dummy_32
[] =
3118 { 0xbc100001, 0x9de38000, 0xbc100002, 0xbe100003,
3119 0xda03a058, 0xd803a054, 0xd603a050, 0xd403a04c,
3120 0xd203a048, 0x40000000, 0xd003a044, 0x01000000,
3121 0x91d02001, 0x01000000
3123 static LONGEST call_dummy_64
[] =
3124 { 0x9de3bec0fd3fa7f7LL
, 0xf93fa7eff53fa7e7LL
,
3125 0xf13fa7dfed3fa7d7LL
, 0xe93fa7cfe53fa7c7LL
,
3126 0xe13fa7bfdd3fa7b7LL
, 0xd93fa7afd53fa7a7LL
,
3127 0xd13fa79fcd3fa797LL
, 0xc93fa78fc53fa787LL
,
3128 0xc13fa77fcc3fa777LL
, 0xc83fa76fc43fa767LL
,
3129 0xc03fa75ffc3fa757LL
, 0xf83fa74ff43fa747LL
,
3130 0xf03fa73f01000000LL
, 0x0100000001000000LL
,
3131 0x0100000091580000LL
, 0xd027a72b93500000LL
,
3132 0xd027a72791480000LL
, 0xd027a72391400000LL
,
3133 0xd027a71fda5ba8a7LL
, 0xd85ba89fd65ba897LL
,
3134 0xd45ba88fd25ba887LL
, 0x9fc02000d05ba87fLL
,
3135 0x0100000091d02001LL
, 0x0100000001000000LL
3137 static LONGEST call_dummy_nil
[] = {0};
3139 /* Try to determine the OS ABI of the object we are loading. */
3141 if (info
.abfd
!= NULL
3142 && info
.osabi
== GDB_OSABI_UNKNOWN
)
3144 /* If it's an ELF file, assume it's Solaris. */
3145 if (bfd_get_flavour (info
.abfd
) == bfd_target_elf_flavour
)
3146 info
.osabi
= GDB_OSABI_SOLARIS
;
3149 /* First see if there is already a gdbarch that can satisfy the request. */
3150 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
3152 return arches
->gdbarch
;
3154 /* None found: is the request for a sparc architecture? */
3155 if (info
.bfd_arch_info
->arch
!= bfd_arch_sparc
)
3156 return NULL
; /* No; then it's not for us. */
3158 /* Yes: create a new gdbarch for the specified machine type. */
3159 tdep
= (struct gdbarch_tdep
*) xmalloc (sizeof (struct gdbarch_tdep
));
3160 gdbarch
= gdbarch_alloc (&info
, tdep
);
3162 /* First set settings that are common for all sparc architectures. */
3163 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
3164 set_gdbarch_breakpoint_from_pc (gdbarch
, sparc_breakpoint_from_pc
);
3165 set_gdbarch_decr_pc_after_break (gdbarch
, 0);
3166 set_gdbarch_double_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
3167 set_gdbarch_deprecated_extract_struct_value_address (gdbarch
, sparc_extract_struct_value_address
);
3168 set_gdbarch_deprecated_fix_call_dummy (gdbarch
, sparc_gdbarch_fix_call_dummy
);
3169 set_gdbarch_float_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
3170 set_gdbarch_deprecated_fp_regnum (gdbarch
, SPARC_FP_REGNUM
);
3171 set_gdbarch_fp0_regnum (gdbarch
, SPARC_FP0_REGNUM
);
3172 set_gdbarch_deprecated_frame_chain (gdbarch
, sparc_frame_chain
);
3173 set_gdbarch_deprecated_frame_init_saved_regs (gdbarch
, sparc_frame_init_saved_regs
);
3174 set_gdbarch_frame_num_args (gdbarch
, frame_num_args_unknown
);
3175 set_gdbarch_deprecated_frame_saved_pc (gdbarch
, sparc_frame_saved_pc
);
3176 set_gdbarch_frameless_function_invocation (gdbarch
,
3177 frameless_look_for_prologue
);
3178 set_gdbarch_deprecated_get_saved_register (gdbarch
, sparc_get_saved_register
);
3179 set_gdbarch_deprecated_init_extra_frame_info (gdbarch
, sparc_init_extra_frame_info
);
3180 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
3181 set_gdbarch_int_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
3182 set_gdbarch_long_double_bit (gdbarch
, 16 * TARGET_CHAR_BIT
);
3183 set_gdbarch_long_long_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
3184 set_gdbarch_deprecated_max_register_raw_size (gdbarch
, 8);
3185 set_gdbarch_deprecated_max_register_virtual_size (gdbarch
, 8);
3186 set_gdbarch_deprecated_pop_frame (gdbarch
, sparc_pop_frame
);
3187 set_gdbarch_deprecated_push_return_address (gdbarch
, sparc_push_return_address
);
3188 set_gdbarch_deprecated_push_dummy_frame (gdbarch
, sparc_push_dummy_frame
);
3189 set_gdbarch_read_pc (gdbarch
, generic_target_read_pc
);
3190 set_gdbarch_register_convert_to_raw (gdbarch
, sparc_convert_to_raw
);
3191 set_gdbarch_register_convert_to_virtual (gdbarch
,
3192 sparc_convert_to_virtual
);
3193 set_gdbarch_register_convertible (gdbarch
,
3194 generic_register_convertible_not
);
3195 set_gdbarch_reg_struct_has_addr (gdbarch
, sparc_reg_struct_has_addr
);
3196 set_gdbarch_return_value_on_stack (gdbarch
, sparc_return_value_on_stack
);
3197 set_gdbarch_deprecated_saved_pc_after_call (gdbarch
, sparc_saved_pc_after_call
);
3198 set_gdbarch_prologue_frameless_p (gdbarch
, sparc_prologue_frameless_p
);
3199 set_gdbarch_short_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
3200 set_gdbarch_skip_prologue (gdbarch
, sparc_skip_prologue
);
3201 set_gdbarch_sp_regnum (gdbarch
, SPARC_SP_REGNUM
);
3202 set_gdbarch_deprecated_use_generic_dummy_frames (gdbarch
, 0);
3203 set_gdbarch_write_pc (gdbarch
, generic_target_write_pc
);
3206 * Settings that depend only on 32/64 bit word size
3209 switch (info
.bfd_arch_info
->mach
)
3211 case bfd_mach_sparc
:
3213 // OBSOLETE case bfd_mach_sparc_sparclet:
3214 // OBSOLETE case bfd_mach_sparc_sparclite:
3216 case bfd_mach_sparc_v8plus
:
3217 case bfd_mach_sparc_v8plusa
:
3219 // OBSOLETE case bfd_mach_sparc_sparclite_le:
3221 /* 32-bit machine types: */
3223 #ifdef SPARC32_CALL_DUMMY_ON_STACK
3224 set_gdbarch_deprecated_pc_in_call_dummy (gdbarch
, deprecated_pc_in_call_dummy_on_stack
);
3225 set_gdbarch_call_dummy_address (gdbarch
, sparc_call_dummy_address
);
3226 set_gdbarch_deprecated_call_dummy_breakpoint_offset (gdbarch
, 0x30);
3227 set_gdbarch_deprecated_call_dummy_length (gdbarch
, 0x38);
3229 /* NOTE: cagney/2003-05-01: Using the just added push_dummy_code
3230 architecture method, it is now possible to implement a
3231 generic dummy frames based inferior function call that stores
3232 the breakpoint (and struct info) on the stack. Further, by
3233 treating a SIGSEG at a breakpoint as equivalent to a SIGTRAP
3234 it is even possible to make this work when the stack is
3237 NOTE: cagney/2002-04-26: Based from info posted by Peter
3238 Schauer around Oct '99. Briefly, due to aspects of the SPARC
3239 ABI, it isn't possible to use ON_STACK with a strictly
3242 Peter Schauer writes ...
3244 No, any call from GDB to a user function returning a
3245 struct/union will fail miserably. Try this:
3264 for (i = 0; i < 4; i++)
3270 Set a breakpoint at the gx = sret () statement, run to it and
3271 issue a `print sret()'. It will not succed with your
3272 approach, and I doubt that continuing the program will work
3275 For details of the ABI see the Sparc Architecture Manual. I
3276 have Version 8 (Prentice Hall ISBN 0-13-825001-4) and the
3277 calling conventions for functions returning aggregate values
3278 are explained in Appendix D.3. */
3280 set_gdbarch_call_dummy_location (gdbarch
, ON_STACK
);
3281 set_gdbarch_deprecated_call_dummy_words (gdbarch
, call_dummy_32
);
3283 set_gdbarch_deprecated_pc_in_call_dummy (gdbarch
, deprecated_pc_in_call_dummy_at_entry_point
);
3284 set_gdbarch_deprecated_call_dummy_words (gdbarch
, call_dummy_nil
);
3286 set_gdbarch_deprecated_call_dummy_stack_adjust (gdbarch
, 68);
3287 set_gdbarch_frame_args_skip (gdbarch
, 68);
3288 set_gdbarch_function_start_offset (gdbarch
, 0);
3289 set_gdbarch_long_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
3290 set_gdbarch_npc_regnum (gdbarch
, SPARC32_NPC_REGNUM
);
3291 set_gdbarch_pc_regnum (gdbarch
, SPARC32_PC_REGNUM
);
3292 set_gdbarch_ptr_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
3293 set_gdbarch_deprecated_push_arguments (gdbarch
, sparc32_push_arguments
);
3294 set_gdbarch_read_sp (gdbarch
, generic_target_read_sp
);
3296 set_gdbarch_register_byte (gdbarch
, sparc32_register_byte
);
3297 set_gdbarch_register_raw_size (gdbarch
, sparc32_register_size
);
3298 set_gdbarch_deprecated_register_size (gdbarch
, 4);
3299 set_gdbarch_register_virtual_size (gdbarch
, sparc32_register_size
);
3300 set_gdbarch_register_virtual_type (gdbarch
,
3301 sparc32_register_virtual_type
);
3302 #ifdef SPARC32_CALL_DUMMY_ON_STACK
3303 set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch
, sizeof (call_dummy_32
));
3305 set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch
, 0);
3307 set_gdbarch_stack_align (gdbarch
, sparc32_stack_align
);
3308 set_gdbarch_deprecated_extra_stack_alignment_needed (gdbarch
, 1);
3309 set_gdbarch_deprecated_store_struct_return (gdbarch
, sparc32_store_struct_return
);
3310 set_gdbarch_use_struct_convention (gdbarch
,
3311 generic_use_struct_convention
);
3312 set_gdbarch_deprecated_dummy_write_sp (gdbarch
, generic_target_write_sp
);
3313 tdep
->y_regnum
= SPARC32_Y_REGNUM
;
3314 tdep
->fp_max_regnum
= SPARC_FP0_REGNUM
+ 32;
3315 tdep
->intreg_size
= 4;
3316 tdep
->reg_save_offset
= 0x60;
3317 tdep
->call_dummy_call_offset
= 0x24;
3320 case bfd_mach_sparc_v9
:
3321 case bfd_mach_sparc_v9a
:
3322 /* 64-bit machine types: */
3323 default: /* Any new machine type is likely to be 64-bit. */
3325 #ifdef SPARC64_CALL_DUMMY_ON_STACK
3326 set_gdbarch_deprecated_pc_in_call_dummy (gdbarch
, deprecated_pc_in_call_dummy_on_stack
);
3327 set_gdbarch_call_dummy_address (gdbarch
, sparc_call_dummy_address
);
3328 set_gdbarch_deprecated_call_dummy_breakpoint_offset (gdbarch
, 8 * 4);
3329 set_gdbarch_deprecated_call_dummy_length (gdbarch
, 192);
3330 set_gdbarch_call_dummy_location (gdbarch
, ON_STACK
);
3331 set_gdbarch_deprecated_call_dummy_start_offset (gdbarch
, 148);
3332 set_gdbarch_deprecated_call_dummy_words (gdbarch
, call_dummy_64
);
3334 set_gdbarch_deprecated_pc_in_call_dummy (gdbarch
, deprecated_pc_in_call_dummy_at_entry_point
);
3335 set_gdbarch_deprecated_call_dummy_words (gdbarch
, call_dummy_nil
);
3337 set_gdbarch_deprecated_call_dummy_stack_adjust (gdbarch
, 128);
3338 set_gdbarch_frame_args_skip (gdbarch
, 136);
3339 set_gdbarch_function_start_offset (gdbarch
, 0);
3340 set_gdbarch_long_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
3341 set_gdbarch_npc_regnum (gdbarch
, SPARC64_NPC_REGNUM
);
3342 set_gdbarch_pc_regnum (gdbarch
, SPARC64_PC_REGNUM
);
3343 set_gdbarch_ptr_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
3344 set_gdbarch_deprecated_push_arguments (gdbarch
, sparc64_push_arguments
);
3345 /* NOTE different for at_entry */
3346 set_gdbarch_deprecated_target_read_fp (gdbarch
, sparc64_read_fp
);
3347 set_gdbarch_read_sp (gdbarch
, sparc64_read_sp
);
3348 /* Some of the registers aren't 64 bits, but it's a lot simpler just
3349 to assume they all are (since most of them are). */
3350 set_gdbarch_register_byte (gdbarch
, sparc64_register_byte
);
3351 set_gdbarch_register_raw_size (gdbarch
, sparc64_register_size
);
3352 set_gdbarch_deprecated_register_size (gdbarch
, 8);
3353 set_gdbarch_register_virtual_size (gdbarch
, sparc64_register_size
);
3354 set_gdbarch_register_virtual_type (gdbarch
,
3355 sparc64_register_virtual_type
);
3356 #ifdef SPARC64_CALL_DUMMY_ON_STACK
3357 set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch
, sizeof (call_dummy_64
));
3359 set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch
, 0);
3361 set_gdbarch_stack_align (gdbarch
, sparc64_stack_align
);
3362 set_gdbarch_deprecated_extra_stack_alignment_needed (gdbarch
, 1);
3363 set_gdbarch_deprecated_store_struct_return (gdbarch
, sparc64_store_struct_return
);
3364 set_gdbarch_use_struct_convention (gdbarch
,
3365 sparc64_use_struct_convention
);
3366 set_gdbarch_deprecated_dummy_write_sp (gdbarch
, sparc64_write_sp
);
3367 tdep
->y_regnum
= SPARC64_Y_REGNUM
;
3368 tdep
->fp_max_regnum
= SPARC_FP0_REGNUM
+ 48;
3369 tdep
->intreg_size
= 8;
3370 tdep
->reg_save_offset
= 0x90;
3371 tdep
->call_dummy_call_offset
= 148 + 4 * 5;
3376 * Settings that vary per-architecture:
3379 switch (info
.bfd_arch_info
->mach
)
3381 case bfd_mach_sparc
:
3382 set_gdbarch_deprecated_extract_return_value (gdbarch
, sparc32_extract_return_value
);
3383 set_gdbarch_num_regs (gdbarch
, 72);
3384 set_gdbarch_register_bytes (gdbarch
, 32*4 + 32*4 + 8*4);
3385 set_gdbarch_register_name (gdbarch
, sparc32_register_name
);
3386 set_gdbarch_deprecated_store_return_value (gdbarch
, sparc_store_return_value
);
3388 // OBSOLETE tdep->has_fpu = 1; /* (all but sparclet and sparclite) */
3390 tdep
->fp_register_bytes
= 32 * 4;
3391 tdep
->print_insn_mach
= bfd_mach_sparc
;
3394 // OBSOLETE case bfd_mach_sparc_sparclet:
3395 // OBSOLETE set_gdbarch_deprecated_extract_return_value (gdbarch, sparclet_extract_return_value);
3396 // OBSOLETE set_gdbarch_num_regs (gdbarch, 32 + 32 + 8 + 8 + 8);
3397 // OBSOLETE set_gdbarch_register_bytes (gdbarch, 32*4 + 32*4 + 8*4 + 8*4 + 8*4);
3398 // OBSOLETE set_gdbarch_register_name (gdbarch, sparclet_register_name);
3399 // OBSOLETE set_gdbarch_deprecated_store_return_value (gdbarch, sparclet_store_return_value);
3400 // OBSOLETE tdep->has_fpu = 0; /* (all but sparclet and sparclite) */
3401 // OBSOLETE tdep->fp_register_bytes = 0;
3402 // OBSOLETE tdep->print_insn_mach = bfd_mach_sparc_sparclet;
3406 // OBSOLETE case bfd_mach_sparc_sparclite:
3407 // OBSOLETE set_gdbarch_deprecated_extract_return_value (gdbarch, sparc32_extract_return_value);
3408 // OBSOLETE set_gdbarch_num_regs (gdbarch, 80);
3409 // OBSOLETE set_gdbarch_register_bytes (gdbarch, 32*4 + 32*4 + 8*4 + 8*4);
3410 // OBSOLETE set_gdbarch_register_name (gdbarch, sparclite_register_name);
3411 // OBSOLETE set_gdbarch_deprecated_store_return_value (gdbarch, sparc_store_return_value);
3412 // OBSOLETE tdep->has_fpu = 0; /* (all but sparclet and sparclite) */
3413 // OBSOLETE tdep->fp_register_bytes = 0;
3414 // OBSOLETE tdep->print_insn_mach = bfd_mach_sparc_sparclite;
3417 case bfd_mach_sparc_v8plus
:
3418 set_gdbarch_deprecated_extract_return_value (gdbarch
, sparc32_extract_return_value
);
3419 set_gdbarch_num_regs (gdbarch
, 72);
3420 set_gdbarch_register_bytes (gdbarch
, 32*4 + 32*4 + 8*4);
3421 set_gdbarch_register_name (gdbarch
, sparc32_register_name
);
3422 set_gdbarch_deprecated_store_return_value (gdbarch
, sparc_store_return_value
);
3423 tdep
->print_insn_mach
= bfd_mach_sparc
;
3424 tdep
->fp_register_bytes
= 32 * 4;
3426 // OBSOLETE tdep->has_fpu = 1; /* (all but sparclet and sparclite) */
3429 case bfd_mach_sparc_v8plusa
:
3430 set_gdbarch_deprecated_extract_return_value (gdbarch
, sparc32_extract_return_value
);
3431 set_gdbarch_num_regs (gdbarch
, 72);
3432 set_gdbarch_register_bytes (gdbarch
, 32*4 + 32*4 + 8*4);
3433 set_gdbarch_register_name (gdbarch
, sparc32_register_name
);
3434 set_gdbarch_deprecated_store_return_value (gdbarch
, sparc_store_return_value
);
3436 // OBSOLETE tdep->has_fpu = 1; /* (all but sparclet and sparclite) */
3438 tdep
->fp_register_bytes
= 32 * 4;
3439 tdep
->print_insn_mach
= bfd_mach_sparc
;
3442 // OBSOLETE case bfd_mach_sparc_sparclite_le:
3443 // OBSOLETE set_gdbarch_deprecated_extract_return_value (gdbarch, sparc32_extract_return_value);
3444 // OBSOLETE set_gdbarch_num_regs (gdbarch, 80);
3445 // OBSOLETE set_gdbarch_register_bytes (gdbarch, 32*4 + 32*4 + 8*4 + 8*4);
3446 // OBSOLETE set_gdbarch_register_name (gdbarch, sparclite_register_name);
3447 // OBSOLETE set_gdbarch_deprecated_store_return_value (gdbarch, sparc_store_return_value);
3448 // OBSOLETE tdep->has_fpu = 0; /* (all but sparclet and sparclite) */
3449 // OBSOLETE tdep->fp_register_bytes = 0;
3450 // OBSOLETE tdep->print_insn_mach = bfd_mach_sparc_sparclite;
3453 case bfd_mach_sparc_v9
:
3454 set_gdbarch_deprecated_extract_return_value (gdbarch
, sparc64_extract_return_value
);
3455 set_gdbarch_num_regs (gdbarch
, 125);
3456 set_gdbarch_register_bytes (gdbarch
, 32*8 + 32*8 + 45*8);
3457 set_gdbarch_register_name (gdbarch
, sparc64_register_name
);
3458 set_gdbarch_deprecated_store_return_value (gdbarch
, sparc_store_return_value
);
3460 // OBSOLETE tdep->has_fpu = 1; /* (all but sparclet and sparclite) */
3462 tdep
->fp_register_bytes
= 64 * 4;
3463 tdep
->print_insn_mach
= bfd_mach_sparc_v9a
;
3465 case bfd_mach_sparc_v9a
:
3466 set_gdbarch_deprecated_extract_return_value (gdbarch
, sparc64_extract_return_value
);
3467 set_gdbarch_num_regs (gdbarch
, 125);
3468 set_gdbarch_register_bytes (gdbarch
, 32*8 + 32*8 + 45*8);
3469 set_gdbarch_register_name (gdbarch
, sparc64_register_name
);
3470 set_gdbarch_deprecated_store_return_value (gdbarch
, sparc_store_return_value
);
3472 // OBSOLETE tdep->has_fpu = 1; /* (all but sparclet and sparclite) */
3474 tdep
->fp_register_bytes
= 64 * 4;
3475 tdep
->print_insn_mach
= bfd_mach_sparc_v9a
;
3479 /* Hook in OS ABI-specific overrides, if they have been registered. */
3480 gdbarch_init_osabi (info
, gdbarch
);
3486 sparc_dump_tdep (struct gdbarch
*current_gdbarch
, struct ui_file
*file
)
3488 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
3494 // OBSOLETE fprintf_unfiltered (file, "sparc_dump_tdep: has_fpu = %d\n",
3495 // OBSOLETE tdep->has_fpu);
3497 fprintf_unfiltered (file
, "sparc_dump_tdep: fp_register_bytes = %d\n",
3498 tdep
->fp_register_bytes
);
3499 fprintf_unfiltered (file
, "sparc_dump_tdep: y_regnum = %d\n",
3501 fprintf_unfiltered (file
, "sparc_dump_tdep: fp_max_regnum = %d\n",
3502 tdep
->fp_max_regnum
);
3503 fprintf_unfiltered (file
, "sparc_dump_tdep: intreg_size = %d\n",
3505 fprintf_unfiltered (file
, "sparc_dump_tdep: reg_save_offset = %d\n",
3506 tdep
->reg_save_offset
);
3507 fprintf_unfiltered (file
, "sparc_dump_tdep: call_dummy_call_offset = %d\n",
3508 tdep
->call_dummy_call_offset
);
3509 fprintf_unfiltered (file
, "sparc_dump_tdep: print_insn_match = %d\n",
3510 tdep
->print_insn_mach
);