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"
37 #include "sparc-tdep.h"
40 #include <sys/procfs.h>
41 /* Prototypes for supply_gregset etc. */
46 #include "gdb_assert.h"
48 #include "symfile.h" /* for 'entry_point_address' */
51 * Some local macros that have multi-arch and non-multi-arch versions:
54 #if (GDB_MULTI_ARCH > 0)
57 // OBSOLETE /* Does the target have Floating Point registers? */
58 // OBSOLETE #define SPARC_HAS_FPU (gdbarch_tdep (current_gdbarch)->has_fpu)
60 #define SPARC_HAS_FPU 1
61 /* Number of bytes devoted to Floating Point registers: */
62 #define FP_REGISTER_BYTES (gdbarch_tdep (current_gdbarch)->fp_register_bytes)
63 /* Highest numbered Floating Point register. */
64 #define FP_MAX_REGNUM (gdbarch_tdep (current_gdbarch)->fp_max_regnum)
65 /* Size of a general (integer) register: */
66 #define SPARC_INTREG_SIZE (gdbarch_tdep (current_gdbarch)->intreg_size)
67 /* Offset within the call dummy stack of the saved registers. */
68 #define DUMMY_REG_SAVE_OFFSET (gdbarch_tdep (current_gdbarch)->reg_save_offset)
70 #else /* non-multi-arch */
73 /* Does the target have Floating Point registers? */
75 // OBSOLETE #if defined(TARGET_SPARCLET) || defined(TARGET_SPARCLITE)
76 // OBSOLETE #define SPARC_HAS_FPU 0
78 // OBSOLETE #define SPARC_HAS_FPU 1
81 #define SPARC_HAS_FPU 1
83 /* Number of bytes devoted to Floating Point registers: */
84 #if (GDB_TARGET_IS_SPARC64)
85 #define FP_REGISTER_BYTES (64 * 4)
88 #define FP_REGISTER_BYTES (32 * 4)
90 #define FP_REGISTER_BYTES 0
94 /* Highest numbered Floating Point register. */
95 #if (GDB_TARGET_IS_SPARC64)
96 #define FP_MAX_REGNUM (FP0_REGNUM + 48)
98 #define FP_MAX_REGNUM (FP0_REGNUM + 32)
101 /* Size of a general (integer) register: */
102 #define SPARC_INTREG_SIZE (REGISTER_RAW_SIZE (G0_REGNUM))
104 /* Offset within the call dummy stack of the saved registers. */
105 #if (GDB_TARGET_IS_SPARC64)
106 #define DUMMY_REG_SAVE_OFFSET (128 + 16)
108 #define DUMMY_REG_SAVE_OFFSET 0x60
111 #endif /* GDB_MULTI_ARCH */
116 // OBSOLETE int has_fpu;
118 int fp_register_bytes
;
123 int call_dummy_call_offset
;
127 /* Now make GDB_TARGET_IS_SPARC64 a runtime test. */
128 /* FIXME MVS: or try testing bfd_arch_info.arch and bfd_arch_info.mach ...
129 * define GDB_TARGET_IS_SPARC64 \
130 * (TARGET_ARCHITECTURE->arch == bfd_arch_sparc && \
131 * (TARGET_ARCHITECTURE->mach == bfd_mach_sparc_v9 || \
132 * TARGET_ARCHITECTURE->mach == bfd_mach_sparc_v9a))
135 /* We don't store all registers immediately when requested, since they
136 get sent over in large chunks anyway. Instead, we accumulate most
137 of the changes and send them over once. "deferred_stores" keeps
138 track of which sets of registers we have locally-changed copies of,
139 so we only need send the groups that have changed. */
141 int deferred_stores
= 0; /* Accumulated stores we want to do eventually. */
145 // OBSOLETE /* Some machines, such as Fujitsu SPARClite 86x, have a bi-endian mode
146 // OBSOLETE where instructions are big-endian and data are little-endian.
147 // OBSOLETE This flag is set when we detect that the target is of this type. */
149 // OBSOLETE int bi_endian = 0;
153 const unsigned char *
154 sparc_breakpoint_from_pc (CORE_ADDR
*pc
, int *len
)
156 static const char breakpoint
[] = {0x91, 0xd0, 0x20, 0x01};
157 (*len
) = sizeof (breakpoint
);
161 /* Fetch a single instruction. Even on bi-endian machines
162 such as sparc86x, instructions are always big-endian. */
165 fetch_instruction (CORE_ADDR pc
)
167 unsigned long retval
;
169 unsigned char buf
[4];
171 read_memory (pc
, buf
, sizeof (buf
));
173 /* Start at the most significant end of the integer, and work towards
174 the least significant. */
176 for (i
= 0; i
< sizeof (buf
); ++i
)
177 retval
= (retval
<< 8) | buf
[i
];
182 /* Branches with prediction are treated like their non-predicting cousins. */
183 /* FIXME: What about floating point branches? */
185 /* Macros to extract fields from sparc instructions. */
186 #define X_OP(i) (((i) >> 30) & 0x3)
187 #define X_RD(i) (((i) >> 25) & 0x1f)
188 #define X_A(i) (((i) >> 29) & 1)
189 #define X_COND(i) (((i) >> 25) & 0xf)
190 #define X_OP2(i) (((i) >> 22) & 0x7)
191 #define X_IMM22(i) ((i) & 0x3fffff)
192 #define X_OP3(i) (((i) >> 19) & 0x3f)
193 #define X_RS1(i) (((i) >> 14) & 0x1f)
194 #define X_I(i) (((i) >> 13) & 1)
195 #define X_IMM13(i) ((i) & 0x1fff)
196 /* Sign extension macros. */
197 #define X_SIMM13(i) ((X_IMM13 (i) ^ 0x1000) - 0x1000)
198 #define X_DISP22(i) ((X_IMM22 (i) ^ 0x200000) - 0x200000)
199 #define X_CC(i) (((i) >> 20) & 3)
200 #define X_P(i) (((i) >> 19) & 1)
201 #define X_DISP19(i) ((((i) & 0x7ffff) ^ 0x40000) - 0x40000)
202 #define X_RCOND(i) (((i) >> 25) & 7)
203 #define X_DISP16(i) ((((((i) >> 6) && 0xc000) | ((i) & 0x3fff)) ^ 0x8000) - 0x8000)
204 #define X_FCN(i) (((i) >> 25) & 31)
208 Error
, not_branch
, bicc
, bicca
, ba
, baa
, ticc
, ta
, done_retry
211 /* Simulate single-step ptrace call for sun4. Code written by Gary
212 Beihl (beihl@mcc.com). */
214 /* npc4 and next_pc describe the situation at the time that the
215 step-breakpoint was set, not necessary the current value of NPC_REGNUM. */
216 static CORE_ADDR next_pc
, npc4
, target
;
217 static int brknpc4
, brktrg
;
218 typedef char binsn_quantum
[BREAKPOINT_MAX
];
219 static binsn_quantum break_mem
[3];
221 static branch_type
isbranch (long, CORE_ADDR
, CORE_ADDR
*);
223 /* single_step() is called just before we want to resume the inferior,
224 if we want to single-step it but there is no hardware or kernel single-step
225 support (as on all SPARCs). We find all the possible targets of the
226 coming instruction and breakpoint them.
228 single_step is also called just after the inferior stops. If we had
229 set up a simulated single-step, we undo our damage. */
232 sparc_software_single_step (enum target_signal ignore
, /* pid, but we don't need it */
233 int insert_breakpoints_p
)
239 if (insert_breakpoints_p
)
241 /* Always set breakpoint for NPC. */
242 next_pc
= read_register (NPC_REGNUM
);
243 npc4
= next_pc
+ 4; /* branch not taken */
245 target_insert_breakpoint (next_pc
, break_mem
[0]);
246 /* printf_unfiltered ("set break at %x\n",next_pc); */
248 pc
= read_register (PC_REGNUM
);
249 pc_instruction
= fetch_instruction (pc
);
250 br
= isbranch (pc_instruction
, pc
, &target
);
251 brknpc4
= brktrg
= 0;
255 /* Conditional annulled branch will either end up at
256 npc (if taken) or at npc+4 (if not taken).
259 target_insert_breakpoint (npc4
, break_mem
[1]);
261 else if (br
== baa
&& target
!= next_pc
)
263 /* Unconditional annulled branch will always end up at
266 target_insert_breakpoint (target
, break_mem
[2]);
268 else if (GDB_TARGET_IS_SPARC64
&& br
== done_retry
)
271 target_insert_breakpoint (target
, break_mem
[2]);
276 /* Remove breakpoints */
277 target_remove_breakpoint (next_pc
, break_mem
[0]);
280 target_remove_breakpoint (npc4
, break_mem
[1]);
283 target_remove_breakpoint (target
, break_mem
[2]);
287 struct frame_extra_info
292 /* Following fields only relevant for flat frames. */
295 /* Add this to ->frame to get the value of the stack pointer at the
296 time of the register saves. */
300 /* Call this for each newly created frame. For SPARC, we need to
301 calculate the bottom of the frame, and do some extra work if the
302 prologue has been generated via the -mflat option to GCC. In
303 particular, we need to know where the previous fp and the pc have
304 been stashed, since their exact position within the frame may vary. */
307 sparc_init_extra_frame_info (int fromleaf
, struct frame_info
*fi
)
310 CORE_ADDR prologue_start
, prologue_end
;
313 frame_extra_info_zalloc (fi
, sizeof (struct frame_extra_info
));
314 frame_saved_regs_zalloc (fi
);
316 get_frame_extra_info (fi
)->bottom
=
318 ? (get_frame_base (fi
) == get_frame_base (get_next_frame (fi
))
319 ? get_frame_extra_info (get_next_frame (fi
))->bottom
320 : get_frame_base (get_next_frame (fi
)))
323 /* If fi->next is NULL, then we already set ->frame by passing
324 deprecated_read_fp() to create_new_frame. */
325 if (get_next_frame (fi
))
327 char buf
[MAX_REGISTER_SIZE
];
329 /* Compute ->frame as if not flat. If it is flat, we'll change
331 if (get_next_frame (get_next_frame (fi
)) != NULL
332 && ((get_frame_type (get_next_frame (get_next_frame (fi
))) == SIGTRAMP_FRAME
)
333 || deprecated_frame_in_dummy (get_next_frame (get_next_frame (fi
))))
334 && frameless_look_for_prologue (get_next_frame (fi
)))
336 /* A frameless function interrupted by a signal did not change
337 the frame pointer, fix up frame pointer accordingly. */
338 deprecated_update_frame_base_hack (fi
, get_frame_base (get_next_frame (fi
)));
339 get_frame_extra_info (fi
)->bottom
=
340 get_frame_extra_info (get_next_frame (fi
))->bottom
;
344 /* Should we adjust for stack bias here? */
346 frame_read_unsigned_register (fi
, DEPRECATED_FP_REGNUM
, &tmp
);
347 deprecated_update_frame_base_hack (fi
, tmp
);
348 if (GDB_TARGET_IS_SPARC64
&& (get_frame_base (fi
) & 1))
349 deprecated_update_frame_base_hack (fi
, get_frame_base (fi
) + 2047);
353 /* Decide whether this is a function with a ``flat register window''
354 frame. For such functions, the frame pointer is actually in %i7. */
355 get_frame_extra_info (fi
)->flat
= 0;
356 get_frame_extra_info (fi
)->in_prologue
= 0;
357 if (find_pc_partial_function (get_frame_pc (fi
), &name
, &prologue_start
, &prologue_end
))
359 /* See if the function starts with an add (which will be of a
360 negative number if a flat frame) to the sp. FIXME: Does not
361 handle large frames which will need more than one instruction
363 insn
= fetch_instruction (prologue_start
);
364 if (X_OP (insn
) == 2 && X_RD (insn
) == 14 && X_OP3 (insn
) == 0
365 && X_I (insn
) && X_SIMM13 (insn
) < 0)
367 int offset
= X_SIMM13 (insn
);
369 /* Then look for a save of %i7 into the frame. */
370 insn
= fetch_instruction (prologue_start
+ 4);
374 && X_RS1 (insn
) == 14)
376 char buf
[MAX_REGISTER_SIZE
];
378 /* We definitely have a flat frame now. */
379 get_frame_extra_info (fi
)->flat
= 1;
381 get_frame_extra_info (fi
)->sp_offset
= offset
;
383 /* Overwrite the frame's address with the value in %i7. */
386 frame_read_unsigned_register (fi
, I7_REGNUM
, &tmp
);
387 deprecated_update_frame_base_hack (fi
, tmp
);
390 if (GDB_TARGET_IS_SPARC64
&& (get_frame_base (fi
) & 1))
391 deprecated_update_frame_base_hack (fi
, get_frame_base (fi
) + 2047);
393 /* Record where the fp got saved. */
394 get_frame_extra_info (fi
)->fp_addr
=
395 get_frame_base (fi
) + get_frame_extra_info (fi
)->sp_offset
+ X_SIMM13 (insn
);
397 /* Also try to collect where the pc got saved to. */
398 get_frame_extra_info (fi
)->pc_addr
= 0;
399 insn
= fetch_instruction (prologue_start
+ 12);
403 && X_RS1 (insn
) == 14)
404 get_frame_extra_info (fi
)->pc_addr
=
405 get_frame_base (fi
) + get_frame_extra_info (fi
)->sp_offset
+ X_SIMM13 (insn
);
410 /* Check if the PC is in the function prologue before a SAVE
411 instruction has been executed yet. If so, set the frame
412 to the current value of the stack pointer and set
413 the in_prologue flag. */
415 struct symtab_and_line sal
;
417 sal
= find_pc_line (prologue_start
, 0);
418 if (sal
.line
== 0) /* no line info, use PC */
419 prologue_end
= get_frame_pc (fi
);
420 else if (sal
.end
< prologue_end
)
421 prologue_end
= sal
.end
;
422 if (get_frame_pc (fi
) < prologue_end
)
424 for (addr
= prologue_start
; addr
< get_frame_pc (fi
); addr
+= 4)
426 insn
= read_memory_integer (addr
, 4);
427 if (X_OP (insn
) == 2 && X_OP3 (insn
) == 0x3c)
428 break; /* SAVE seen, stop searching */
430 if (addr
>= get_frame_pc (fi
))
432 get_frame_extra_info (fi
)->in_prologue
= 1;
433 deprecated_update_frame_base_hack (fi
, read_register (SP_REGNUM
));
438 if (get_next_frame (fi
) && get_frame_base (fi
) == 0)
440 /* Kludge to cause init_prev_frame_info to destroy the new frame. */
441 deprecated_update_frame_base_hack (fi
, get_frame_base (get_next_frame (fi
)));
442 deprecated_update_frame_pc_hack (fi
, get_frame_pc (get_next_frame (fi
)));
447 sparc_frame_chain (struct frame_info
*frame
)
449 /* Value that will cause DEPRECATED_FRAME_CHAIN_VALID to not worry
450 about the chain value. If it really is zero, we detect it later
451 in sparc_init_prev_frame.
453 Note: kevinb/2003-02-18: The constant 1 used to be returned here,
454 but, after some recent changes to legacy_frame_chain_valid(),
455 this value is no longer suitable for causing
456 legacy_frame_chain_valid() to "not worry about the chain value."
457 The constant ~0 (i.e, 0xfff...) causes the failing test in
458 legacy_frame_chain_valid() to succeed thus preserving the "not
459 worry" property. I had considered using something like
460 ``get_frame_base (frame) + 1''. However, I think a constant
461 value is better, because when debugging this problem, I knew that
462 something funny was going on as soon as I saw the constant 1
463 being used as the frame chain elsewhere in GDB. */
465 return ~ (CORE_ADDR
) 0;
468 /* Find the pc saved in frame FRAME. */
471 sparc_frame_saved_pc (struct frame_info
*frame
)
473 char buf
[MAX_REGISTER_SIZE
];
476 if ((get_frame_type (frame
) == SIGTRAMP_FRAME
))
478 /* This is the signal trampoline frame.
479 Get the saved PC from the sigcontext structure. */
481 #ifndef SIGCONTEXT_PC_OFFSET
482 #define SIGCONTEXT_PC_OFFSET 12
485 CORE_ADDR sigcontext_addr
;
487 int saved_pc_offset
= SIGCONTEXT_PC_OFFSET
;
490 scbuf
= alloca (TARGET_PTR_BIT
/ HOST_CHAR_BIT
);
492 /* Solaris2 ucbsigvechandler passes a pointer to a sigcontext
493 as the third parameter. The offset to the saved pc is 12. */
494 find_pc_partial_function (get_frame_pc (frame
), &name
,
495 (CORE_ADDR
*) NULL
, (CORE_ADDR
*) NULL
);
496 if (name
&& STREQ (name
, "ucbsigvechandler"))
497 saved_pc_offset
= 12;
499 /* The sigcontext address is contained in register O2. */
502 frame_read_unsigned_register (frame
, O0_REGNUM
+ 2, &tmp
);
503 sigcontext_addr
= tmp
;
506 /* Don't cause a memory_error when accessing sigcontext in case the
507 stack layout has changed or the stack is corrupt. */
508 target_read_memory (sigcontext_addr
+ saved_pc_offset
,
509 scbuf
, sizeof (scbuf
));
510 return extract_unsigned_integer (scbuf
, sizeof (scbuf
));
512 else if (get_frame_extra_info (frame
)->in_prologue
||
513 (get_next_frame (frame
) != NULL
&&
514 ((get_frame_type (get_next_frame (frame
)) == SIGTRAMP_FRAME
) ||
515 deprecated_frame_in_dummy (get_next_frame (frame
))) &&
516 frameless_look_for_prologue (frame
)))
518 /* A frameless function interrupted by a signal did not save
519 the PC, it is still in %o7. */
521 frame_read_unsigned_register (frame
, O7_REGNUM
, &tmp
);
522 return PC_ADJUST (tmp
);
524 if (get_frame_extra_info (frame
)->flat
)
525 addr
= get_frame_extra_info (frame
)->pc_addr
;
527 addr
= get_frame_extra_info (frame
)->bottom
+ FRAME_SAVED_I0
+
528 SPARC_INTREG_SIZE
* (I7_REGNUM
- I0_REGNUM
);
531 /* A flat frame leaf function might not save the PC anywhere,
532 just leave it in %o7. */
533 return PC_ADJUST (read_register (O7_REGNUM
));
535 read_memory (addr
, buf
, SPARC_INTREG_SIZE
);
536 return PC_ADJUST (extract_unsigned_integer (buf
, SPARC_INTREG_SIZE
));
539 /* Since an individual frame in the frame cache is defined by two
540 arguments (a frame pointer and a stack pointer), we need two
541 arguments to get info for an arbitrary stack frame. This routine
542 takes two arguments and makes the cached frames look as if these
543 two arguments defined a frame on the cache. This allows the rest
544 of info frame to extract the important arguments without
548 setup_arbitrary_frame (int argc
, CORE_ADDR
*argv
)
550 struct frame_info
*frame
;
553 error ("Sparc frame specifications require two arguments: fp and sp");
555 frame
= create_new_frame (argv
[0], 0);
558 internal_error (__FILE__
, __LINE__
,
559 "create_new_frame returned invalid frame");
561 get_frame_extra_info (frame
)->bottom
= argv
[1];
562 deprecated_update_frame_pc_hack (frame
, DEPRECATED_FRAME_SAVED_PC (frame
));
566 /* Given a pc value, skip it forward past the function prologue by
567 disassembling instructions that appear to be a prologue.
569 If FRAMELESS_P is set, we are only testing to see if the function
570 is frameless. This allows a quicker answer.
572 This routine should be more specific in its actions; making sure
573 that it uses the same register in the initial prologue section. */
575 static CORE_ADDR
examine_prologue (CORE_ADDR
, int, struct frame_info
*,
579 examine_prologue (CORE_ADDR start_pc
, int frameless_p
, struct frame_info
*fi
,
580 CORE_ADDR
*saved_regs
)
584 CORE_ADDR pc
= start_pc
;
587 insn
= fetch_instruction (pc
);
589 /* Recognize the `sethi' insn and record its destination. */
590 if (X_OP (insn
) == 0 && X_OP2 (insn
) == 4)
594 insn
= fetch_instruction (pc
);
597 /* Recognize an add immediate value to register to either %g1 or
598 the destination register recorded above. Actually, this might
599 well recognize several different arithmetic operations.
600 It doesn't check that rs1 == rd because in theory "sub %g0, 5, %g1"
601 followed by "save %sp, %g1, %sp" is a valid prologue (Not that
602 I imagine any compiler really does that, however). */
605 && (X_RD (insn
) == 1 || X_RD (insn
) == dest
))
608 insn
= fetch_instruction (pc
);
611 /* Recognize any SAVE insn. */
612 if (X_OP (insn
) == 2 && X_OP3 (insn
) == 60)
615 if (frameless_p
) /* If the save is all we care about, */
616 return pc
; /* return before doing more work */
617 insn
= fetch_instruction (pc
);
619 /* Recognize add to %sp. */
620 else if (X_OP (insn
) == 2 && X_RD (insn
) == 14 && X_OP3 (insn
) == 0)
623 if (frameless_p
) /* If the add is all we care about, */
624 return pc
; /* return before doing more work */
626 insn
= fetch_instruction (pc
);
627 /* Recognize store of frame pointer (i7). */
631 && X_RS1 (insn
) == 14)
634 insn
= fetch_instruction (pc
);
636 /* Recognize sub %sp, <anything>, %i7. */
639 && X_RS1 (insn
) == 14
640 && X_RD (insn
) == 31)
643 insn
= fetch_instruction (pc
);
652 /* Without a save or add instruction, it's not a prologue. */
657 /* Recognize stores into the frame from the input registers.
658 This recognizes all non alternate stores of an input register,
659 into a location offset from the frame pointer between
662 /* The above will fail for arguments that are promoted
663 (eg. shorts to ints or floats to doubles), because the compiler
664 will pass them in positive-offset frame space, but the prologue
665 will save them (after conversion) in negative frame space at an
666 unpredictable offset. Therefore I am going to remove the
667 restriction on the target-address of the save, on the theory
668 that any unbroken sequence of saves from input registers must
669 be part of the prologue. In un-optimized code (at least), I'm
670 fairly sure that the compiler would emit SOME other instruction
671 (eg. a move or add) before emitting another save that is actually
672 a part of the function body.
674 Besides, the reserved stack space is different for SPARC64 anyway.
679 && (X_OP3 (insn
) & 0x3c) == 4 /* Store, non-alternate. */
680 && (X_RD (insn
) & 0x18) == 0x18 /* Input register. */
681 && X_I (insn
) /* Immediate mode. */
682 && X_RS1 (insn
) == 30) /* Off of frame pointer. */
683 ; /* empty statement -- fall thru to end of loop */
684 else if (GDB_TARGET_IS_SPARC64
686 && (X_OP3 (insn
) & 0x3c) == 12 /* store, extended (64-bit) */
687 && (X_RD (insn
) & 0x18) == 0x18 /* input register */
688 && X_I (insn
) /* immediate mode */
689 && X_RS1 (insn
) == 30) /* off of frame pointer */
690 ; /* empty statement -- fall thru to end of loop */
691 else if (X_OP (insn
) == 3
692 && (X_OP3 (insn
) & 0x3c) == 36 /* store, floating-point */
693 && X_I (insn
) /* immediate mode */
694 && X_RS1 (insn
) == 30) /* off of frame pointer */
695 ; /* empty statement -- fall thru to end of loop */
698 && X_OP3 (insn
) == 4 /* store? */
699 && X_RS1 (insn
) == 14) /* off of frame pointer */
701 if (saved_regs
&& X_I (insn
))
702 saved_regs
[X_RD (insn
)] =
703 get_frame_base (fi
) + get_frame_extra_info (fi
)->sp_offset
+ X_SIMM13 (insn
);
708 insn
= fetch_instruction (pc
);
714 /* Advance PC across any function entry prologue instructions to reach
718 sparc_skip_prologue (CORE_ADDR start_pc
)
720 struct symtab_and_line sal
;
721 CORE_ADDR func_start
, func_end
;
723 /* This is the preferred method, find the end of the prologue by
724 using the debugging information. */
725 if (find_pc_partial_function (start_pc
, NULL
, &func_start
, &func_end
))
727 sal
= find_pc_line (func_start
, 0);
729 if (sal
.end
< func_end
730 && start_pc
<= sal
.end
)
734 /* Oh well, examine the code by hand. */
735 return examine_prologue (start_pc
, 0, NULL
, NULL
);
738 /* Is the prologue at IP frameless? */
741 sparc_prologue_frameless_p (CORE_ADDR ip
)
743 return ip
== examine_prologue (ip
, 1, NULL
, NULL
);
746 /* Check instruction at ADDR to see if it is a branch.
747 All non-annulled instructions will go to NPC or will trap.
748 Set *TARGET if we find a candidate branch; set to zero if not.
750 This isn't static as it's used by remote-sa.sparc.c. */
753 isbranch (long instruction
, CORE_ADDR addr
, CORE_ADDR
*target
)
755 branch_type val
= not_branch
;
756 long int offset
= 0; /* Must be signed for sign-extend. */
760 if (X_OP (instruction
) == 0
761 && (X_OP2 (instruction
) == 2
762 || X_OP2 (instruction
) == 6
763 || X_OP2 (instruction
) == 1
764 || X_OP2 (instruction
) == 3
765 || X_OP2 (instruction
) == 5
766 || (GDB_TARGET_IS_SPARC64
&& X_OP2 (instruction
) == 7)))
768 if (X_COND (instruction
) == 8)
769 val
= X_A (instruction
) ? baa
: ba
;
771 val
= X_A (instruction
) ? bicca
: bicc
;
772 switch (X_OP2 (instruction
))
775 if (!GDB_TARGET_IS_SPARC64
)
780 offset
= 4 * X_DISP22 (instruction
);
784 offset
= 4 * X_DISP19 (instruction
);
787 offset
= 4 * X_DISP16 (instruction
);
790 *target
= addr
+ offset
;
792 else if (GDB_TARGET_IS_SPARC64
793 && X_OP (instruction
) == 2
794 && X_OP3 (instruction
) == 62)
796 if (X_FCN (instruction
) == 0)
799 *target
= read_register (TNPC_REGNUM
);
802 else if (X_FCN (instruction
) == 1)
805 *target
= read_register (TPC_REGNUM
);
813 /* Find register number REGNUM relative to FRAME and put its
814 (raw) contents in *RAW_BUFFER. Set *OPTIMIZED if the variable
815 was optimized out (and thus can't be fetched). If the variable
816 was fetched from memory, set *ADDRP to where it was fetched from,
817 otherwise it was fetched from a register.
819 The argument RAW_BUFFER must point to aligned memory. */
822 sparc_get_saved_register (char *raw_buffer
, int *optimized
, CORE_ADDR
*addrp
,
823 struct frame_info
*frame
, int regnum
,
824 enum lval_type
*lval
)
826 struct frame_info
*frame1
;
829 if (!target_has_registers
)
830 error ("No registers.");
837 /* FIXME This code extracted from infcmd.c; should put elsewhere! */
840 /* error ("No selected frame."); */
841 if (!target_has_registers
)
842 error ("The program has no registers now.");
843 if (deprecated_selected_frame
== NULL
)
844 error ("No selected frame.");
845 /* Try to use selected frame */
846 frame
= get_prev_frame (deprecated_selected_frame
);
848 error ("Cmd not meaningful in the outermost frame.");
852 frame1
= get_next_frame (frame
);
854 /* Get saved PC from the frame info if not in innermost frame. */
855 if (regnum
== PC_REGNUM
&& frame1
!= NULL
)
859 if (raw_buffer
!= NULL
)
861 /* Put it back in target format. */
862 store_unsigned_integer (raw_buffer
, REGISTER_RAW_SIZE (regnum
), get_frame_pc (frame
));
869 while (frame1
!= NULL
)
871 /* FIXME MVS: wrong test for dummy frame at entry. */
873 if (get_frame_pc (frame1
) >= (get_frame_extra_info (frame1
)->bottom
874 ? get_frame_extra_info (frame1
)->bottom
876 && get_frame_pc (frame1
) <= get_frame_base (frame1
))
878 /* Dummy frame. All but the window regs are in there somewhere.
879 The window registers are saved on the stack, just like in a
881 if (regnum
>= G1_REGNUM
&& regnum
< G1_REGNUM
+ 7)
882 addr
= get_frame_base (frame1
) + (regnum
- G0_REGNUM
) * SPARC_INTREG_SIZE
883 - (FP_REGISTER_BYTES
+ 8 * SPARC_INTREG_SIZE
);
884 else if (regnum
>= I0_REGNUM
&& regnum
< I0_REGNUM
+ 8)
885 /* NOTE: cagney/2002-05-04: The call to get_prev_frame()
886 is safe/cheap - there will always be a prev frame.
887 This is because frame1 is initialized to frame->next
888 (frame1->prev == frame) and is then advanced towards
889 the innermost (next) frame. */
890 addr
= (get_frame_extra_info (get_prev_frame (frame1
))->bottom
891 + (regnum
- I0_REGNUM
) * SPARC_INTREG_SIZE
893 else if (regnum
>= L0_REGNUM
&& regnum
< L0_REGNUM
+ 8)
894 /* NOTE: cagney/2002-05-04: The call to get_prev_frame()
895 is safe/cheap - there will always be a prev frame.
896 This is because frame1 is initialized to frame->next
897 (frame1->prev == frame) and is then advanced towards
898 the innermost (next) frame. */
899 addr
= (get_frame_extra_info (get_prev_frame (frame1
))->bottom
900 + (regnum
- L0_REGNUM
) * SPARC_INTREG_SIZE
902 else if (regnum
>= O0_REGNUM
&& regnum
< O0_REGNUM
+ 8)
903 addr
= get_frame_base (frame1
) + (regnum
- O0_REGNUM
) * SPARC_INTREG_SIZE
904 - (FP_REGISTER_BYTES
+ 16 * SPARC_INTREG_SIZE
);
905 else if (SPARC_HAS_FPU
&&
906 regnum
>= FP0_REGNUM
&& regnum
< FP0_REGNUM
+ 32)
907 addr
= get_frame_base (frame1
) + (regnum
- FP0_REGNUM
) * 4
908 - (FP_REGISTER_BYTES
);
909 else if (GDB_TARGET_IS_SPARC64
&& SPARC_HAS_FPU
&&
910 regnum
>= FP0_REGNUM
+ 32 && regnum
< FP_MAX_REGNUM
)
911 addr
= get_frame_base (frame1
) + 32 * 4 + (regnum
- FP0_REGNUM
- 32) * 8
912 - (FP_REGISTER_BYTES
);
913 else if (regnum
>= Y_REGNUM
&& regnum
< NUM_REGS
)
914 addr
= get_frame_base (frame1
) + (regnum
- Y_REGNUM
) * SPARC_INTREG_SIZE
915 - (FP_REGISTER_BYTES
+ 24 * SPARC_INTREG_SIZE
);
917 else if (get_frame_extra_info (frame1
)->flat
)
920 if (regnum
== RP_REGNUM
)
921 addr
= get_frame_extra_info (frame1
)->pc_addr
;
922 else if (regnum
== I7_REGNUM
)
923 addr
= get_frame_extra_info (frame1
)->fp_addr
;
926 CORE_ADDR func_start
;
929 regs
= alloca (NUM_REGS
* sizeof (CORE_ADDR
));
930 memset (regs
, 0, NUM_REGS
* sizeof (CORE_ADDR
));
932 find_pc_partial_function (get_frame_pc (frame1
), NULL
, &func_start
, NULL
);
933 examine_prologue (func_start
, 0, frame1
, regs
);
939 /* Normal frame. Local and In registers are saved on stack. */
940 if (regnum
>= I0_REGNUM
&& regnum
< I0_REGNUM
+ 8)
941 addr
= (get_frame_extra_info (get_prev_frame (frame1
))->bottom
942 + (regnum
- I0_REGNUM
) * SPARC_INTREG_SIZE
944 else if (regnum
>= L0_REGNUM
&& regnum
< L0_REGNUM
+ 8)
945 addr
= (get_frame_extra_info (get_prev_frame (frame1
))->bottom
946 + (regnum
- L0_REGNUM
) * SPARC_INTREG_SIZE
948 else if (regnum
>= O0_REGNUM
&& regnum
< O0_REGNUM
+ 8)
950 /* Outs become ins. */
952 frame_register (frame1
, (regnum
- O0_REGNUM
+ I0_REGNUM
),
953 optimized
, lval
, addrp
, &realnum
, raw_buffer
);
959 frame1
= get_next_frame (frame1
);
965 if (regnum
== SP_REGNUM
)
967 if (raw_buffer
!= NULL
)
969 /* Put it back in target format. */
970 store_unsigned_integer (raw_buffer
, REGISTER_RAW_SIZE (regnum
), addr
);
976 if (raw_buffer
!= NULL
)
977 read_memory (addr
, raw_buffer
, REGISTER_RAW_SIZE (regnum
));
982 *lval
= lval_register
;
983 addr
= REGISTER_BYTE (regnum
);
984 if (raw_buffer
!= NULL
)
985 deprecated_read_register_gen (regnum
, raw_buffer
);
991 /* Push an empty stack frame, and record in it the current PC, regs, etc.
993 We save the non-windowed registers and the ins. The locals and outs
994 are new; they don't need to be saved. The i's and l's of
995 the last frame were already saved on the stack. */
997 /* Definitely see tm-sparc.h for more doc of the frame format here. */
999 /* See tm-sparc.h for how this is calculated. */
1001 #define DUMMY_STACK_REG_BUF_SIZE \
1002 (((8+8+8) * SPARC_INTREG_SIZE) + FP_REGISTER_BYTES)
1003 #define DUMMY_STACK_SIZE \
1004 (DUMMY_STACK_REG_BUF_SIZE + DUMMY_REG_SAVE_OFFSET)
1007 sparc_push_dummy_frame (void)
1009 CORE_ADDR sp
, old_sp
;
1010 char *register_temp
;
1012 register_temp
= alloca (DUMMY_STACK_SIZE
);
1014 old_sp
= sp
= read_sp ();
1016 if (GDB_TARGET_IS_SPARC64
)
1018 /* PC, NPC, CCR, FSR, FPRS, Y, ASI */
1019 deprecated_read_register_bytes (REGISTER_BYTE (PC_REGNUM
),
1021 REGISTER_RAW_SIZE (PC_REGNUM
) * 7);
1022 deprecated_read_register_bytes (REGISTER_BYTE (PSTATE_REGNUM
),
1023 ®ister_temp
[7 * SPARC_INTREG_SIZE
],
1024 REGISTER_RAW_SIZE (PSTATE_REGNUM
));
1025 /* FIXME: not sure what needs to be saved here. */
1029 /* Y, PS, WIM, TBR, PC, NPC, FPS, CPS regs */
1030 deprecated_read_register_bytes (REGISTER_BYTE (Y_REGNUM
),
1032 REGISTER_RAW_SIZE (Y_REGNUM
) * 8);
1035 deprecated_read_register_bytes (REGISTER_BYTE (O0_REGNUM
),
1036 ®ister_temp
[8 * SPARC_INTREG_SIZE
],
1037 SPARC_INTREG_SIZE
* 8);
1039 deprecated_read_register_bytes (REGISTER_BYTE (G0_REGNUM
),
1040 ®ister_temp
[16 * SPARC_INTREG_SIZE
],
1041 SPARC_INTREG_SIZE
* 8);
1044 deprecated_read_register_bytes (REGISTER_BYTE (FP0_REGNUM
),
1045 ®ister_temp
[24 * SPARC_INTREG_SIZE
],
1048 sp
-= DUMMY_STACK_SIZE
;
1050 DEPRECATED_DUMMY_WRITE_SP (sp
);
1052 write_memory (sp
+ DUMMY_REG_SAVE_OFFSET
, ®ister_temp
[0],
1053 DUMMY_STACK_REG_BUF_SIZE
);
1055 if (strcmp (target_shortname
, "sim") != 0)
1057 /* NOTE: cagney/2002-04-04: The code below originally contained
1058 GDB's _only_ call to write_fp(). That call was eliminated by
1059 inlining the corresponding code. For the 64 bit case, the
1060 old function (sparc64_write_fp) did the below although I'm
1061 not clear why. The same goes for why this is only done when
1062 the underlying target is a simulator. */
1063 if (GDB_TARGET_IS_SPARC64
)
1065 /* Target is a 64 bit SPARC. */
1066 CORE_ADDR oldfp
= read_register (DEPRECATED_FP_REGNUM
);
1068 write_register (DEPRECATED_FP_REGNUM
, old_sp
- 2047);
1070 write_register (DEPRECATED_FP_REGNUM
, old_sp
);
1074 /* Target is a 32 bit SPARC. */
1075 write_register (DEPRECATED_FP_REGNUM
, old_sp
);
1077 /* Set return address register for the call dummy to the current PC. */
1078 write_register (I7_REGNUM
, read_pc () - 8);
1082 /* The call dummy will write this value to FP before executing
1083 the 'save'. This ensures that register window flushes work
1084 correctly in the simulator. */
1085 write_register (G0_REGNUM
+ 1, read_register (DEPRECATED_FP_REGNUM
));
1087 /* The call dummy will write this value to FP after executing
1089 write_register (G0_REGNUM
+ 2, old_sp
);
1091 /* The call dummy will write this value to the return address (%i7) after
1092 executing the 'save'. */
1093 write_register (G0_REGNUM
+ 3, read_pc () - 8);
1095 /* Set the FP that the call dummy will be using after the 'save'.
1096 This makes backtraces from an inferior function call work properly. */
1097 write_register (DEPRECATED_FP_REGNUM
, old_sp
);
1101 /* sparc_frame_find_saved_regs (). This function is here only because
1102 pop_frame uses it. Note there is an interesting corner case which
1103 I think few ports of GDB get right--if you are popping a frame
1104 which does not save some register that *is* saved by a more inner
1105 frame (such a frame will never be a dummy frame because dummy
1106 frames save all registers).
1108 NOTE: cagney/2003-03-12: Since pop_frame has been rewritten to use
1109 frame_unwind_register() the need for this function is questionable.
1111 Stores, into an array of CORE_ADDR,
1112 the addresses of the saved registers of frame described by FRAME_INFO.
1113 This includes special registers such as pc and fp saved in special
1114 ways in the stack frame. sp is even more special:
1115 the address we return for it IS the sp for the next frame.
1117 Note that on register window machines, we are currently making the
1118 assumption that window registers are being saved somewhere in the
1119 frame in which they are being used. If they are stored in an
1120 inferior frame, find_saved_register will break.
1122 On the Sun 4, the only time all registers are saved is when
1123 a dummy frame is involved. Otherwise, the only saved registers
1124 are the LOCAL and IN registers which are saved as a result
1125 of the "save/restore" opcodes. This condition is determined
1126 by address rather than by value.
1128 The "pc" is not stored in a frame on the SPARC. (What is stored
1129 is a return address minus 8.) sparc_pop_frame knows how to
1130 deal with that. Other routines might or might not.
1132 See tm-sparc.h (PUSH_DUMMY_FRAME and friends) for CRITICAL information
1133 about how this works. */
1135 static void sparc_frame_find_saved_regs (struct frame_info
*, CORE_ADDR
*);
1138 sparc_frame_find_saved_regs (struct frame_info
*fi
, CORE_ADDR
*saved_regs_addr
)
1140 register int regnum
;
1141 CORE_ADDR frame_addr
= get_frame_base (fi
);
1143 gdb_assert (fi
!= NULL
);
1145 memset (saved_regs_addr
, 0, NUM_REGS
* sizeof (CORE_ADDR
));
1147 if (get_frame_pc (fi
) >= (get_frame_extra_info (fi
)->bottom
1148 ? get_frame_extra_info (fi
)->bottom
1150 && get_frame_pc (fi
) <= get_frame_base (fi
))
1152 /* Dummy frame. All but the window regs are in there somewhere. */
1153 for (regnum
= G1_REGNUM
; regnum
< G1_REGNUM
+ 7; regnum
++)
1154 saved_regs_addr
[regnum
] =
1155 frame_addr
+ (regnum
- G0_REGNUM
) * SPARC_INTREG_SIZE
1156 - DUMMY_STACK_REG_BUF_SIZE
+ 16 * SPARC_INTREG_SIZE
;
1158 for (regnum
= I0_REGNUM
; regnum
< I0_REGNUM
+ 8; regnum
++)
1159 saved_regs_addr
[regnum
] =
1160 frame_addr
+ (regnum
- I0_REGNUM
) * SPARC_INTREG_SIZE
1161 - DUMMY_STACK_REG_BUF_SIZE
+ 8 * SPARC_INTREG_SIZE
;
1164 for (regnum
= FP0_REGNUM
; regnum
< FP_MAX_REGNUM
; regnum
++)
1165 saved_regs_addr
[regnum
] = frame_addr
+ (regnum
- FP0_REGNUM
) * 4
1166 - DUMMY_STACK_REG_BUF_SIZE
+ 24 * SPARC_INTREG_SIZE
;
1168 if (GDB_TARGET_IS_SPARC64
)
1170 for (regnum
= PC_REGNUM
; regnum
< PC_REGNUM
+ 7; regnum
++)
1172 saved_regs_addr
[regnum
] =
1173 frame_addr
+ (regnum
- PC_REGNUM
) * SPARC_INTREG_SIZE
1174 - DUMMY_STACK_REG_BUF_SIZE
;
1176 saved_regs_addr
[PSTATE_REGNUM
] =
1177 frame_addr
+ 8 * SPARC_INTREG_SIZE
- DUMMY_STACK_REG_BUF_SIZE
;
1180 for (regnum
= Y_REGNUM
; regnum
< NUM_REGS
; regnum
++)
1181 saved_regs_addr
[regnum
] =
1182 frame_addr
+ (regnum
- Y_REGNUM
) * SPARC_INTREG_SIZE
1183 - DUMMY_STACK_REG_BUF_SIZE
;
1185 frame_addr
= (get_frame_extra_info (fi
)->bottom
1186 ? get_frame_extra_info (fi
)->bottom
1189 else if (get_frame_extra_info (fi
)->flat
)
1191 CORE_ADDR func_start
;
1192 find_pc_partial_function (get_frame_pc (fi
), NULL
, &func_start
, NULL
);
1193 examine_prologue (func_start
, 0, fi
, saved_regs_addr
);
1195 /* Flat register window frame. */
1196 saved_regs_addr
[RP_REGNUM
] = get_frame_extra_info (fi
)->pc_addr
;
1197 saved_regs_addr
[I7_REGNUM
] = get_frame_extra_info (fi
)->fp_addr
;
1201 /* Normal frame. Just Local and In registers */
1202 frame_addr
= (get_frame_extra_info (fi
)->bottom
1203 ? get_frame_extra_info (fi
)->bottom
1205 for (regnum
= L0_REGNUM
; regnum
< L0_REGNUM
+ 8; regnum
++)
1206 saved_regs_addr
[regnum
] =
1207 (frame_addr
+ (regnum
- L0_REGNUM
) * SPARC_INTREG_SIZE
1209 for (regnum
= I0_REGNUM
; regnum
< I0_REGNUM
+ 8; regnum
++)
1210 saved_regs_addr
[regnum
] =
1211 (frame_addr
+ (regnum
- I0_REGNUM
) * SPARC_INTREG_SIZE
1214 if (get_next_frame (fi
))
1216 if (get_frame_extra_info (fi
)->flat
)
1218 saved_regs_addr
[O7_REGNUM
] = get_frame_extra_info (fi
)->pc_addr
;
1222 /* Pull off either the next frame pointer or the stack pointer */
1223 CORE_ADDR next_next_frame_addr
=
1224 (get_frame_extra_info (get_next_frame (fi
))->bottom
1225 ? get_frame_extra_info (get_next_frame (fi
))->bottom
1227 for (regnum
= O0_REGNUM
; regnum
< O0_REGNUM
+ 8; regnum
++)
1228 saved_regs_addr
[regnum
] =
1229 (next_next_frame_addr
1230 + (regnum
- O0_REGNUM
) * SPARC_INTREG_SIZE
1234 /* Otherwise, whatever we would get from ptrace(GETREGS) is accurate */
1235 /* FIXME -- should this adjust for the sparc64 offset? */
1236 saved_regs_addr
[SP_REGNUM
] = get_frame_base (fi
);
1239 /* Discard from the stack the innermost frame, restoring all saved registers.
1241 Note that the values stored in fsr by
1242 deprecated_get_frame_saved_regs are *in the context of the called
1243 frame*. What this means is that the i regs of fsr must be restored
1244 into the o regs of the (calling) frame that we pop into. We don't
1245 care about the output regs of the calling frame, since unless it's
1246 a dummy frame, it won't have any output regs in it.
1248 We never have to bother with %l (local) regs, since the called routine's
1249 locals get tossed, and the calling routine's locals are already saved
1252 /* Definitely see tm-sparc.h for more doc of the frame format here. */
1255 sparc_pop_frame (void)
1257 register struct frame_info
*frame
= get_current_frame ();
1258 register CORE_ADDR pc
;
1263 fsr
= alloca (NUM_REGS
* sizeof (CORE_ADDR
));
1264 raw_buffer
= alloca (DEPRECATED_REGISTER_BYTES
);
1265 sparc_frame_find_saved_regs (frame
, &fsr
[0]);
1268 if (fsr
[FP0_REGNUM
])
1270 read_memory (fsr
[FP0_REGNUM
], raw_buffer
, FP_REGISTER_BYTES
);
1271 deprecated_write_register_bytes (REGISTER_BYTE (FP0_REGNUM
),
1272 raw_buffer
, FP_REGISTER_BYTES
);
1274 if (!(GDB_TARGET_IS_SPARC64
))
1276 if (fsr
[FPS_REGNUM
])
1278 read_memory (fsr
[FPS_REGNUM
], raw_buffer
, SPARC_INTREG_SIZE
);
1279 deprecated_write_register_gen (FPS_REGNUM
, raw_buffer
);
1281 if (fsr
[CPS_REGNUM
])
1283 read_memory (fsr
[CPS_REGNUM
], raw_buffer
, SPARC_INTREG_SIZE
);
1284 deprecated_write_register_gen (CPS_REGNUM
, raw_buffer
);
1290 read_memory (fsr
[G1_REGNUM
], raw_buffer
, 7 * SPARC_INTREG_SIZE
);
1291 deprecated_write_register_bytes (REGISTER_BYTE (G1_REGNUM
), raw_buffer
,
1292 7 * SPARC_INTREG_SIZE
);
1295 if (get_frame_extra_info (frame
)->flat
)
1297 /* Each register might or might not have been saved, need to test
1299 for (regnum
= L0_REGNUM
; regnum
< L0_REGNUM
+ 8; ++regnum
)
1301 write_register (regnum
, read_memory_integer (fsr
[regnum
],
1302 SPARC_INTREG_SIZE
));
1303 for (regnum
= I0_REGNUM
; regnum
< I0_REGNUM
+ 8; ++regnum
)
1305 write_register (regnum
, read_memory_integer (fsr
[regnum
],
1306 SPARC_INTREG_SIZE
));
1308 /* Handle all outs except stack pointer (o0-o5; o7). */
1309 for (regnum
= O0_REGNUM
; regnum
< O0_REGNUM
+ 6; ++regnum
)
1311 write_register (regnum
, read_memory_integer (fsr
[regnum
],
1312 SPARC_INTREG_SIZE
));
1313 if (fsr
[O0_REGNUM
+ 7])
1314 write_register (O0_REGNUM
+ 7,
1315 read_memory_integer (fsr
[O0_REGNUM
+ 7],
1316 SPARC_INTREG_SIZE
));
1318 DEPRECATED_DUMMY_WRITE_SP (get_frame_base (frame
));
1320 else if (fsr
[I0_REGNUM
])
1326 reg_temp
= alloca (SPARC_INTREG_SIZE
* 16);
1328 read_memory (fsr
[I0_REGNUM
], raw_buffer
, 8 * SPARC_INTREG_SIZE
);
1330 /* Get the ins and locals which we are about to restore. Just
1331 moving the stack pointer is all that is really needed, except
1332 store_inferior_registers is then going to write the ins and
1333 locals from the registers array, so we need to muck with the
1335 sp
= fsr
[SP_REGNUM
];
1337 if (GDB_TARGET_IS_SPARC64
&& (sp
& 1))
1340 read_memory (sp
, reg_temp
, SPARC_INTREG_SIZE
* 16);
1342 /* Restore the out registers.
1343 Among other things this writes the new stack pointer. */
1344 deprecated_write_register_bytes (REGISTER_BYTE (O0_REGNUM
), raw_buffer
,
1345 SPARC_INTREG_SIZE
* 8);
1347 deprecated_write_register_bytes (REGISTER_BYTE (L0_REGNUM
), reg_temp
,
1348 SPARC_INTREG_SIZE
* 16);
1351 if (!(GDB_TARGET_IS_SPARC64
))
1353 write_register (PS_REGNUM
,
1354 read_memory_integer (fsr
[PS_REGNUM
],
1355 REGISTER_RAW_SIZE (PS_REGNUM
)));
1358 write_register (Y_REGNUM
,
1359 read_memory_integer (fsr
[Y_REGNUM
],
1360 REGISTER_RAW_SIZE (Y_REGNUM
)));
1363 /* Explicitly specified PC (and maybe NPC) -- just restore them. */
1364 write_register (PC_REGNUM
,
1365 read_memory_integer (fsr
[PC_REGNUM
],
1366 REGISTER_RAW_SIZE (PC_REGNUM
)));
1367 if (fsr
[NPC_REGNUM
])
1368 write_register (NPC_REGNUM
,
1369 read_memory_integer (fsr
[NPC_REGNUM
],
1370 REGISTER_RAW_SIZE (NPC_REGNUM
)));
1372 else if (get_frame_extra_info (frame
)->flat
)
1374 if (get_frame_extra_info (frame
)->pc_addr
)
1375 pc
= PC_ADJUST ((CORE_ADDR
)
1376 read_memory_integer (get_frame_extra_info (frame
)->pc_addr
,
1377 REGISTER_RAW_SIZE (PC_REGNUM
)));
1380 /* I think this happens only in the innermost frame, if so then
1381 it is a complicated way of saying
1382 "pc = read_register (O7_REGNUM);". */
1384 frame_read_unsigned_register (frame
, O7_REGNUM
, &tmp
);
1385 pc
= PC_ADJUST (tmp
);
1388 write_register (PC_REGNUM
, pc
);
1389 write_register (NPC_REGNUM
, pc
+ 4);
1391 else if (fsr
[I7_REGNUM
])
1393 /* Return address in %i7 -- adjust it, then restore PC and NPC from it */
1394 pc
= PC_ADJUST ((CORE_ADDR
) read_memory_integer (fsr
[I7_REGNUM
],
1395 SPARC_INTREG_SIZE
));
1396 write_register (PC_REGNUM
, pc
);
1397 write_register (NPC_REGNUM
, pc
+ 4);
1399 flush_cached_frames ();
1402 /* On the Sun 4 under SunOS, the compile will leave a fake insn which
1403 encodes the structure size being returned. If we detect such
1404 a fake insn, step past it. */
1407 sparc_pc_adjust (CORE_ADDR pc
)
1413 err
= target_read_memory (pc
+ 8, buf
, 4);
1414 insn
= extract_unsigned_integer (buf
, 4);
1415 if ((err
== 0) && (insn
& 0xffc00000) == 0)
1421 /* If pc is in a shared library trampoline, return its target.
1422 The SunOs 4.x linker rewrites the jump table entries for PIC
1423 compiled modules in the main executable to bypass the dynamic linker
1424 with jumps of the form
1427 and removes the corresponding jump table relocation entry in the
1428 dynamic relocations.
1429 find_solib_trampoline_target relies on the presence of the jump
1430 table relocation entry, so we have to detect these jump instructions
1434 sunos4_skip_trampoline_code (CORE_ADDR pc
)
1436 unsigned long insn1
;
1440 err
= target_read_memory (pc
, buf
, 4);
1441 insn1
= extract_unsigned_integer (buf
, 4);
1442 if (err
== 0 && (insn1
& 0xffc00000) == 0x03000000)
1444 unsigned long insn2
;
1446 err
= target_read_memory (pc
+ 4, buf
, 4);
1447 insn2
= extract_unsigned_integer (buf
, 4);
1448 if (err
== 0 && (insn2
& 0xffffe000) == 0x81c06000)
1450 CORE_ADDR target_pc
= (insn1
& 0x3fffff) << 10;
1451 int delta
= insn2
& 0x1fff;
1453 /* Sign extend the displacement. */
1456 return target_pc
+ delta
;
1459 return find_solib_trampoline_target (pc
);
1462 #ifdef USE_PROC_FS /* Target dependent support for /proc */
1464 /* The /proc interface divides the target machine's register set up into
1465 two different sets, the general register set (gregset) and the floating
1466 point register set (fpregset). For each set, there is an ioctl to get
1467 the current register set and another ioctl to set the current values.
1469 The actual structure passed through the ioctl interface is, of course,
1470 naturally machine dependent, and is different for each set of registers.
1471 For the sparc for example, the general register set is typically defined
1474 typedef int gregset_t[38];
1480 and the floating point set by:
1482 typedef struct prfpregset {
1485 double pr_dregs[16];
1490 u_char pr_q_entrysize;
1495 These routines provide the packing and unpacking of gregset_t and
1496 fpregset_t formatted data.
1501 /* Given a pointer to a general register set in /proc format (gregset_t *),
1502 unpack the register contents and supply them as gdb's idea of the current
1506 supply_gregset (gdb_gregset_t
*gregsetp
)
1508 prgreg_t
*regp
= (prgreg_t
*) gregsetp
;
1509 int regi
, offset
= 0;
1511 /* If the host is 64-bit sparc, but the target is 32-bit sparc,
1512 then the gregset may contain 64-bit ints while supply_register
1513 is expecting 32-bit ints. Compensate. */
1514 if (sizeof (regp
[0]) == 8 && SPARC_INTREG_SIZE
== 4)
1517 /* GDB register numbers for Gn, On, Ln, In all match /proc reg numbers. */
1518 /* FIXME MVS: assumes the order of the first 32 elements... */
1519 for (regi
= G0_REGNUM
; regi
<= I7_REGNUM
; regi
++)
1521 supply_register (regi
, ((char *) (regp
+ regi
)) + offset
);
1524 /* These require a bit more care. */
1525 supply_register (PC_REGNUM
, ((char *) (regp
+ R_PC
)) + offset
);
1526 supply_register (NPC_REGNUM
, ((char *) (regp
+ R_nPC
)) + offset
);
1527 supply_register (Y_REGNUM
, ((char *) (regp
+ R_Y
)) + offset
);
1529 if (GDB_TARGET_IS_SPARC64
)
1532 supply_register (CCR_REGNUM
, ((char *) (regp
+ R_CCR
)) + offset
);
1534 supply_register (CCR_REGNUM
, NULL
);
1537 supply_register (FPRS_REGNUM
, ((char *) (regp
+ R_FPRS
)) + offset
);
1539 supply_register (FPRS_REGNUM
, NULL
);
1542 supply_register (ASI_REGNUM
, ((char *) (regp
+ R_ASI
)) + offset
);
1544 supply_register (ASI_REGNUM
, NULL
);
1550 supply_register (PS_REGNUM
, ((char *) (regp
+ R_PS
)) + offset
);
1552 supply_register (PS_REGNUM
, NULL
);
1555 /* For 64-bit hosts, R_WIM and R_TBR may not be defined.
1556 Steal R_ASI and R_FPRS, and hope for the best! */
1558 #if !defined (R_WIM) && defined (R_ASI)
1562 #if !defined (R_TBR) && defined (R_FPRS)
1563 #define R_TBR R_FPRS
1567 supply_register (WIM_REGNUM
, ((char *) (regp
+ R_WIM
)) + offset
);
1569 supply_register (WIM_REGNUM
, NULL
);
1573 supply_register (TBR_REGNUM
, ((char *) (regp
+ R_TBR
)) + offset
);
1575 supply_register (TBR_REGNUM
, NULL
);
1579 /* Fill inaccessible registers with zero. */
1580 if (GDB_TARGET_IS_SPARC64
)
1583 * don't know how to get value of any of the following:
1585 supply_register (VER_REGNUM
, NULL
);
1586 supply_register (TICK_REGNUM
, NULL
);
1587 supply_register (PIL_REGNUM
, NULL
);
1588 supply_register (PSTATE_REGNUM
, NULL
);
1589 supply_register (TSTATE_REGNUM
, NULL
);
1590 supply_register (TBA_REGNUM
, NULL
);
1591 supply_register (TL_REGNUM
, NULL
);
1592 supply_register (TT_REGNUM
, NULL
);
1593 supply_register (TPC_REGNUM
, NULL
);
1594 supply_register (TNPC_REGNUM
, NULL
);
1595 supply_register (WSTATE_REGNUM
, NULL
);
1596 supply_register (CWP_REGNUM
, NULL
);
1597 supply_register (CANSAVE_REGNUM
, NULL
);
1598 supply_register (CANRESTORE_REGNUM
, NULL
);
1599 supply_register (CLEANWIN_REGNUM
, NULL
);
1600 supply_register (OTHERWIN_REGNUM
, NULL
);
1601 supply_register (ASR16_REGNUM
, NULL
);
1602 supply_register (ASR17_REGNUM
, NULL
);
1603 supply_register (ASR18_REGNUM
, NULL
);
1604 supply_register (ASR19_REGNUM
, NULL
);
1605 supply_register (ASR20_REGNUM
, NULL
);
1606 supply_register (ASR21_REGNUM
, NULL
);
1607 supply_register (ASR22_REGNUM
, NULL
);
1608 supply_register (ASR23_REGNUM
, NULL
);
1609 supply_register (ASR24_REGNUM
, NULL
);
1610 supply_register (ASR25_REGNUM
, NULL
);
1611 supply_register (ASR26_REGNUM
, NULL
);
1612 supply_register (ASR27_REGNUM
, NULL
);
1613 supply_register (ASR28_REGNUM
, NULL
);
1614 supply_register (ASR29_REGNUM
, NULL
);
1615 supply_register (ASR30_REGNUM
, NULL
);
1616 supply_register (ASR31_REGNUM
, NULL
);
1617 supply_register (ICC_REGNUM
, NULL
);
1618 supply_register (XCC_REGNUM
, NULL
);
1622 supply_register (CPS_REGNUM
, NULL
);
1627 fill_gregset (gdb_gregset_t
*gregsetp
, int regno
)
1629 prgreg_t
*regp
= (prgreg_t
*) gregsetp
;
1630 int regi
, offset
= 0;
1632 /* If the host is 64-bit sparc, but the target is 32-bit sparc,
1633 then the gregset may contain 64-bit ints while supply_register
1634 is expecting 32-bit ints. Compensate. */
1635 if (sizeof (regp
[0]) == 8 && SPARC_INTREG_SIZE
== 4)
1638 for (regi
= 0; regi
<= R_I7
; regi
++)
1639 if ((regno
== -1) || (regno
== regi
))
1640 deprecated_read_register_gen (regi
, (char *) (regp
+ regi
) + offset
);
1642 if ((regno
== -1) || (regno
== PC_REGNUM
))
1643 deprecated_read_register_gen (PC_REGNUM
, (char *) (regp
+ R_PC
) + offset
);
1645 if ((regno
== -1) || (regno
== NPC_REGNUM
))
1646 deprecated_read_register_gen (NPC_REGNUM
, (char *) (regp
+ R_nPC
) + offset
);
1648 if ((regno
== -1) || (regno
== Y_REGNUM
))
1649 deprecated_read_register_gen (Y_REGNUM
, (char *) (regp
+ R_Y
) + offset
);
1651 if (GDB_TARGET_IS_SPARC64
)
1654 if (regno
== -1 || regno
== CCR_REGNUM
)
1655 deprecated_read_register_gen (CCR_REGNUM
, ((char *) (regp
+ R_CCR
)) + offset
);
1658 if (regno
== -1 || regno
== FPRS_REGNUM
)
1659 deprecated_read_register_gen (FPRS_REGNUM
, ((char *) (regp
+ R_FPRS
)) + offset
);
1662 if (regno
== -1 || regno
== ASI_REGNUM
)
1663 deprecated_read_register_gen (ASI_REGNUM
, ((char *) (regp
+ R_ASI
)) + offset
);
1669 if (regno
== -1 || regno
== PS_REGNUM
)
1670 deprecated_read_register_gen (PS_REGNUM
, ((char *) (regp
+ R_PS
)) + offset
);
1673 /* For 64-bit hosts, R_WIM and R_TBR may not be defined.
1674 Steal R_ASI and R_FPRS, and hope for the best! */
1676 #if !defined (R_WIM) && defined (R_ASI)
1680 #if !defined (R_TBR) && defined (R_FPRS)
1681 #define R_TBR R_FPRS
1685 if (regno
== -1 || regno
== WIM_REGNUM
)
1686 deprecated_read_register_gen (WIM_REGNUM
, ((char *) (regp
+ R_WIM
)) + offset
);
1688 if (regno
== -1 || regno
== WIM_REGNUM
)
1689 deprecated_read_register_gen (WIM_REGNUM
, NULL
);
1693 if (regno
== -1 || regno
== TBR_REGNUM
)
1694 deprecated_read_register_gen (TBR_REGNUM
, ((char *) (regp
+ R_TBR
)) + offset
);
1696 if (regno
== -1 || regno
== TBR_REGNUM
)
1697 deprecated_read_register_gen (TBR_REGNUM
, NULL
);
1702 /* Given a pointer to a floating point register set in /proc format
1703 (fpregset_t *), unpack the register contents and supply them as gdb's
1704 idea of the current floating point register values. */
1707 supply_fpregset (gdb_fpregset_t
*fpregsetp
)
1715 for (regi
= FP0_REGNUM
; regi
< FP_MAX_REGNUM
; regi
++)
1717 from
= (char *) &fpregsetp
->pr_fr
.pr_regs
[regi
- FP0_REGNUM
];
1718 supply_register (regi
, from
);
1721 if (GDB_TARGET_IS_SPARC64
)
1724 * don't know how to get value of the following.
1726 supply_register (FSR_REGNUM
, NULL
); /* zero it out for now */
1727 supply_register (FCC0_REGNUM
, NULL
);
1728 supply_register (FCC1_REGNUM
, NULL
); /* don't know how to get value */
1729 supply_register (FCC2_REGNUM
, NULL
); /* don't know how to get value */
1730 supply_register (FCC3_REGNUM
, NULL
); /* don't know how to get value */
1734 supply_register (FPS_REGNUM
, (char *) &(fpregsetp
->pr_fsr
));
1738 /* Given a pointer to a floating point register set in /proc format
1739 (fpregset_t *), update the register specified by REGNO from gdb's idea
1740 of the current floating point register set. If REGNO is -1, update
1742 /* This will probably need some changes for sparc64. */
1745 fill_fpregset (gdb_fpregset_t
*fpregsetp
, int regno
)
1754 for (regi
= FP0_REGNUM
; regi
< FP_MAX_REGNUM
; regi
++)
1756 if ((regno
== -1) || (regno
== regi
))
1758 from
= (char *) &deprecated_registers
[REGISTER_BYTE (regi
)];
1759 to
= (char *) &fpregsetp
->pr_fr
.pr_regs
[regi
- FP0_REGNUM
];
1760 memcpy (to
, from
, REGISTER_RAW_SIZE (regi
));
1764 if (!(GDB_TARGET_IS_SPARC64
)) /* FIXME: does Sparc64 have this register? */
1765 if ((regno
== -1) || (regno
== FPS_REGNUM
))
1767 from
= (char *)&deprecated_registers
[REGISTER_BYTE (FPS_REGNUM
)];
1768 to
= (char *) &fpregsetp
->pr_fsr
;
1769 memcpy (to
, from
, REGISTER_RAW_SIZE (FPS_REGNUM
));
1773 #endif /* USE_PROC_FS */
1775 /* Because of Multi-arch, GET_LONGJMP_TARGET is always defined. So test
1776 for a definition of JB_PC. */
1779 /* Figure out where the longjmp will land. We expect that we have just entered
1780 longjmp and haven't yet setup the stack frame, so the args are still in the
1781 output regs. %o0 (O0_REGNUM) points at the jmp_buf structure from which we
1782 extract the pc (JB_PC) that we will land at. The pc is copied into ADDR.
1783 This routine returns true on success */
1786 get_longjmp_target (CORE_ADDR
*pc
)
1789 #define LONGJMP_TARGET_SIZE 4
1790 char buf
[LONGJMP_TARGET_SIZE
];
1792 jb_addr
= read_register (O0_REGNUM
);
1794 if (target_read_memory (jb_addr
+ JB_PC
* JB_ELEMENT_SIZE
, buf
,
1795 LONGJMP_TARGET_SIZE
))
1798 *pc
= extract_unsigned_integer (buf
, LONGJMP_TARGET_SIZE
);
1802 #endif /* GET_LONGJMP_TARGET */
1804 #ifdef STATIC_TRANSFORM_NAME
1805 /* SunPRO (3.0 at least), encodes the static variables. This is not
1806 related to C++ mangling, it is done for C too. */
1809 sunpro_static_transform_name (char *name
)
1814 /* For file-local statics there will be a dollar sign, a bunch
1815 of junk (the contents of which match a string given in the
1816 N_OPT), a period and the name. For function-local statics
1817 there will be a bunch of junk (which seems to change the
1818 second character from 'A' to 'B'), a period, the name of the
1819 function, and the name. So just skip everything before the
1821 p
= strrchr (name
, '.');
1827 #endif /* STATIC_TRANSFORM_NAME */
1830 /* Utilities for printing registers.
1831 Page numbers refer to the SPARC Architecture Manual. */
1833 static void dump_ccreg (char *, int);
1836 dump_ccreg (char *reg
, int val
)
1839 printf_unfiltered ("%s:%s,%s,%s,%s", reg
,
1840 val
& 8 ? "N" : "NN",
1841 val
& 4 ? "Z" : "NZ",
1842 val
& 2 ? "O" : "NO",
1843 val
& 1 ? "C" : "NC");
1847 decode_asi (int val
)
1853 return "ASI_NUCLEUS";
1855 return "ASI_NUCLEUS_LITTLE";
1857 return "ASI_AS_IF_USER_PRIMARY";
1859 return "ASI_AS_IF_USER_SECONDARY";
1861 return "ASI_AS_IF_USER_PRIMARY_LITTLE";
1863 return "ASI_AS_IF_USER_SECONDARY_LITTLE";
1865 return "ASI_PRIMARY";
1867 return "ASI_SECONDARY";
1869 return "ASI_PRIMARY_NOFAULT";
1871 return "ASI_SECONDARY_NOFAULT";
1873 return "ASI_PRIMARY_LITTLE";
1875 return "ASI_SECONDARY_LITTLE";
1877 return "ASI_PRIMARY_NOFAULT_LITTLE";
1879 return "ASI_SECONDARY_NOFAULT_LITTLE";
1885 /* Pretty print various registers. */
1886 /* FIXME: Would be nice if this did some fancy things for 32 bit sparc. */
1889 sparc_print_register_hook (int regno
)
1893 /* Handle double/quad versions of lower 32 fp regs. */
1894 if (regno
>= FP0_REGNUM
&& regno
< FP0_REGNUM
+ 32
1895 && (regno
& 1) == 0)
1899 if (frame_register_read (deprecated_selected_frame
, regno
, value
)
1900 && frame_register_read (deprecated_selected_frame
, regno
+ 1, value
+ 4))
1902 printf_unfiltered ("\t");
1903 print_floating (value
, builtin_type_double
, gdb_stdout
);
1905 #if 0 /* FIXME: gdb doesn't handle long doubles */
1906 if ((regno
& 3) == 0)
1908 if (frame_register_read (deprecated_selected_frame
, regno
+ 2, value
+ 8)
1909 && frame_register_read (deprecated_selected_frame
, regno
+ 3, value
+ 12))
1911 printf_unfiltered ("\t");
1912 print_floating (value
, builtin_type_long_double
, gdb_stdout
);
1919 #if 0 /* FIXME: gdb doesn't handle long doubles */
1920 /* Print upper fp regs as long double if appropriate. */
1921 if (regno
>= FP0_REGNUM
+ 32 && regno
< FP_MAX_REGNUM
1922 /* We test for even numbered regs and not a multiple of 4 because
1923 the upper fp regs are recorded as doubles. */
1924 && (regno
& 1) == 0)
1928 if (frame_register_read (deprecated_selected_frame
, regno
, value
)
1929 && frame_register_read (deprecated_selected_frame
, regno
+ 1, value
+ 8))
1931 printf_unfiltered ("\t");
1932 print_floating (value
, builtin_type_long_double
, gdb_stdout
);
1938 /* FIXME: Some of these are priviledged registers.
1939 Not sure how they should be handled. */
1941 #define BITS(n, mask) ((int) (((val) >> (n)) & (mask)))
1943 val
= read_register (regno
);
1946 if (GDB_TARGET_IS_SPARC64
)
1950 printf_unfiltered ("\t");
1951 dump_ccreg ("xcc", val
>> 4);
1952 printf_unfiltered (", ");
1953 dump_ccreg ("icc", val
& 15);
1956 printf ("\tfef:%d, du:%d, dl:%d",
1957 BITS (2, 1), BITS (1, 1), BITS (0, 1));
1961 static char *fcc
[4] =
1962 {"=", "<", ">", "?"};
1963 static char *rd
[4] =
1964 {"N", "0", "+", "-"};
1965 /* Long, but I'd rather leave it as is and use a wide screen. */
1966 printf_filtered ("\t0:%s, 1:%s, 2:%s, 3:%s, rd:%s, tem:%d, ",
1967 fcc
[BITS (10, 3)], fcc
[BITS (32, 3)],
1968 fcc
[BITS (34, 3)], fcc
[BITS (36, 3)],
1969 rd
[BITS (30, 3)], BITS (23, 31));
1970 printf_filtered ("ns:%d, ver:%d, ftt:%d, qne:%d, aexc:%d, cexc:%d",
1971 BITS (22, 1), BITS (17, 7), BITS (14, 7),
1972 BITS (13, 1), BITS (5, 31), BITS (0, 31));
1977 char *asi
= decode_asi (val
);
1979 printf ("\t%s", asi
);
1983 printf ("\tmanuf:%d, impl:%d, mask:%d, maxtl:%d, maxwin:%d",
1984 BITS (48, 0xffff), BITS (32, 0xffff),
1985 BITS (24, 0xff), BITS (8, 0xff), BITS (0, 31));
1989 static char *mm
[4] =
1990 {"tso", "pso", "rso", "?"};
1991 printf_filtered ("\tcle:%d, tle:%d, mm:%s, red:%d, ",
1992 BITS (9, 1), BITS (8, 1),
1993 mm
[BITS (6, 3)], BITS (5, 1));
1994 printf_filtered ("pef:%d, am:%d, priv:%d, ie:%d, ag:%d",
1995 BITS (4, 1), BITS (3, 1), BITS (2, 1),
1996 BITS (1, 1), BITS (0, 1));
2000 /* FIXME: print all 4? */
2003 /* FIXME: print all 4? */
2006 /* FIXME: print all 4? */
2009 /* FIXME: print all 4? */
2012 printf ("\tother:%d, normal:%d", BITS (3, 7), BITS (0, 7));
2015 printf ("\t%d", BITS (0, 31));
2017 case CANSAVE_REGNUM
:
2018 printf ("\t%-2d before spill", BITS (0, 31));
2020 case CANRESTORE_REGNUM
:
2021 printf ("\t%-2d before fill", BITS (0, 31));
2023 case CLEANWIN_REGNUM
:
2024 printf ("\t%-2d before clean", BITS (0, 31));
2026 case OTHERWIN_REGNUM
:
2027 printf ("\t%d", BITS (0, 31));
2034 printf ("\ticc:%c%c%c%c, pil:%d, s:%d, ps:%d, et:%d, cwp:%d",
2035 BITS (23, 1) ? 'N' : '-', BITS (22, 1) ? 'Z' : '-',
2036 BITS (21, 1) ? 'V' : '-', BITS (20, 1) ? 'C' : '-',
2037 BITS (8, 15), BITS (7, 1), BITS (6, 1), BITS (5, 1),
2042 static char *fcc
[4] =
2043 {"=", "<", ">", "?"};
2044 static char *rd
[4] =
2045 {"N", "0", "+", "-"};
2046 /* Long, but I'd rather leave it as is and use a wide screen. */
2047 printf ("\trd:%s, tem:%d, ns:%d, ver:%d, ftt:%d, qne:%d, "
2048 "fcc:%s, aexc:%d, cexc:%d",
2049 rd
[BITS (30, 3)], BITS (23, 31), BITS (22, 1), BITS (17, 7),
2050 BITS (14, 7), BITS (13, 1), fcc
[BITS (10, 3)], BITS (5, 31),
2060 sparc_print_registers (struct gdbarch
*gdbarch
,
2061 struct ui_file
*file
,
2062 struct frame_info
*frame
,
2063 int regnum
, int print_all
,
2064 void (*print_register_hook
) (int))
2067 const int numregs
= NUM_REGS
+ NUM_PSEUDO_REGS
;
2068 char raw_buffer
[MAX_REGISTER_SIZE
];
2069 char virtual_buffer
[MAX_REGISTER_SIZE
];
2071 for (i
= 0; i
< numregs
; i
++)
2073 /* Decide between printing all regs, non-float / vector regs, or
2079 if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (i
)) == TYPE_CODE_FLT
)
2081 if (TYPE_VECTOR (REGISTER_VIRTUAL_TYPE (i
)))
2091 /* If the register name is empty, it is undefined for this
2092 processor, so don't display anything. */
2093 if (REGISTER_NAME (i
) == NULL
|| *(REGISTER_NAME (i
)) == '\0')
2096 fputs_filtered (REGISTER_NAME (i
), file
);
2097 print_spaces_filtered (15 - strlen (REGISTER_NAME (i
)), file
);
2099 /* Get the data in raw format. */
2100 if (! frame_register_read (frame
, i
, raw_buffer
))
2102 fprintf_filtered (file
, "*value not available*\n");
2106 memcpy (virtual_buffer
, raw_buffer
, REGISTER_VIRTUAL_SIZE (i
));
2108 /* If virtual format is floating, print it that way, and in raw
2110 if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (i
)) == TYPE_CODE_FLT
)
2114 val_print (REGISTER_VIRTUAL_TYPE (i
), virtual_buffer
, 0, 0,
2115 file
, 0, 1, 0, Val_pretty_default
);
2117 fprintf_filtered (file
, "\t(raw 0x");
2118 for (j
= 0; j
< REGISTER_RAW_SIZE (i
); j
++)
2121 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
2124 idx
= REGISTER_RAW_SIZE (i
) - 1 - j
;
2125 fprintf_filtered (file
, "%02x", (unsigned char) raw_buffer
[idx
]);
2127 fprintf_filtered (file
, ")");
2131 /* Print the register in hex. */
2132 val_print (REGISTER_VIRTUAL_TYPE (i
), virtual_buffer
, 0, 0,
2133 file
, 'x', 1, 0, Val_pretty_default
);
2134 /* If not a vector register, print it also according to its
2136 if (TYPE_VECTOR (REGISTER_VIRTUAL_TYPE (i
)) == 0)
2138 fprintf_filtered (file
, "\t");
2139 val_print (REGISTER_VIRTUAL_TYPE (i
), virtual_buffer
, 0, 0,
2140 file
, 0, 1, 0, Val_pretty_default
);
2144 /* Some sparc specific info. */
2145 if (print_register_hook
!= NULL
)
2146 print_register_hook (i
);
2148 fprintf_filtered (file
, "\n");
2153 sparc_print_registers_info (struct gdbarch
*gdbarch
,
2154 struct ui_file
*file
,
2155 struct frame_info
*frame
,
2156 int regnum
, int print_all
)
2158 sparc_print_registers (gdbarch
, file
, frame
, regnum
, print_all
,
2159 sparc_print_register_hook
);
2163 sparc_do_registers_info (int regnum
, int all
)
2165 sparc_print_registers_info (current_gdbarch
, gdb_stdout
, deprecated_selected_frame
,
2170 // OBSOLETE static void
2171 // OBSOLETE sparclet_print_registers_info (struct gdbarch *gdbarch,
2172 // OBSOLETE struct ui_file *file,
2173 // OBSOLETE struct frame_info *frame,
2174 // OBSOLETE int regnum, int print_all)
2176 // OBSOLETE sparc_print_registers (gdbarch, file, frame, regnum, print_all, NULL);
2180 // OBSOLETE sparclet_do_registers_info (int regnum, int all)
2182 // OBSOLETE sparclet_print_registers_info (current_gdbarch, gdb_stdout,
2183 // OBSOLETE deprecated_selected_frame, regnum, all);
2189 gdb_print_insn_sparc (bfd_vma memaddr
, disassemble_info
*info
)
2191 /* It's necessary to override mach again because print_insn messes it up. */
2192 info
->mach
= TARGET_ARCHITECTURE
->mach
;
2193 return print_insn_sparc (memaddr
, info
);
2197 #define SPARC_F0_REGNUM FP0_REGNUM /* %f0 */
2198 #define SPARC_F1_REGNUM (FP0_REGNUM + 1)/* %f1 */
2199 #define SPARC_O0_REGNUM O0_REGNUM /* %o0 */
2200 #define SPARC_O1_REGNUM O1_REGNUM /* %o1 */
2202 /* Push the arguments onto the stack and into the appropriate registers. */
2205 sparc32_do_push_arguments (struct regcache
*regcache
, int nargs
,
2206 struct value
**args
, CORE_ADDR sp
)
2212 /* Structure, union and quad-precision arguments are passed by
2213 reference. We allocate space for these arguments on the stack
2214 and record their addresses in an array. Array elements for
2215 arguments that are passed by value will be set to zero.*/
2216 addr
= alloca (nargs
* sizeof (CORE_ADDR
));
2218 for (i
= nargs
- 1; i
>= 0; i
--)
2220 struct type
*type
= VALUE_ENCLOSING_TYPE (args
[i
]);
2221 enum type_code code
= TYPE_CODE (type
);
2222 int len
= TYPE_LENGTH (type
);
2224 /* Push the contents of structure, union and quad-precision
2225 arguments on the stack. */
2226 if (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
|| len
> 8)
2228 /* Keep the stack doubleword aligned. */
2229 sp
-= (len
+ 7) & ~7;
2230 write_memory (sp
, VALUE_CONTENTS_ALL (args
[i
]), len
);
2237 size
+= (len
> 4) ? 8 : 4;
2241 /* The needed space for outgoing arguments should be a multiple of 4. */
2242 gdb_assert (size
% 4 == 0);
2244 /* Make sure we reserve space for the first six words of arguments
2245 in the stack frame, even if we don't need them. */
2249 /* Make sure we end up with a doubleword aligned stack in the end.
2250 Reserve an extra word if necessary in order to accomplish this. */
2251 if ((sp
- size
) % 8 == 0)
2254 /* Now push the arguments onto the stack. */
2255 for (i
= nargs
- 1; i
>=0; i
--)
2262 store_unsigned_integer (buf
, 4, addr
[i
]);
2267 struct value
*arg
= args
[i
];
2269 len
= TYPE_LENGTH (VALUE_ENCLOSING_TYPE (arg
));
2271 /* Expand signed and unsigned bytes and halfwords as needed. */
2274 arg
= value_cast (builtin_type_long
, arg
);
2277 else if (len
> 4 && len
< 8)
2279 arg
= value_cast (builtin_type_long_long
, arg
);
2283 gdb_assert (len
== 4 || len
== 8);
2284 memcpy (buf
, VALUE_CONTENTS_ALL (arg
), len
);
2287 /* We always write the argument word on the stack. */
2289 write_memory (sp
, buf
, len
);
2291 /* If this argument occupies one of the first 6 words, write it
2292 into the appropriate register too. */
2296 int regnum
= SPARC_O0_REGNUM
+ (size
/ 4);
2298 regcache_cooked_write (regcache
, regnum
, buf
);
2299 if (len
== 8 && size
< 20)
2300 regcache_cooked_write (regcache
, regnum
+ 1, buf
+ 4);
2304 /* Reserve space for the struct/union return value pointer. */
2307 /* Stack should be doubleword aligned at this point. */
2308 gdb_assert (sp
% 8 == 0);
2310 /* Return the adjusted stack pointer. */
2314 /* The SPARC passes the arguments on the stack; arguments smaller
2315 than an int are promoted to an int. The first 6 words worth of
2316 args are also passed in registers o0 - o5. */
2319 sparc32_push_arguments (int nargs
, struct value
**args
, CORE_ADDR sp
,
2320 int struct_return
, CORE_ADDR struct_addr
)
2322 sp
= sparc32_do_push_arguments (current_regcache
, nargs
, args
, sp
);
2324 /* FIXME: kettenis/20030525: We don't let this function set the
2325 struct/union return pointer just yet. */
2331 /* The space for the struct/union return value pointer has
2332 already been reserved. */
2333 store_unsigned_integer (buf
, 4, struct_addr
);
2343 /* Extract from REGCACHE a function return value of type TYPE and copy
2346 Note that REGCACHE specifies the register values for the frame of
2347 the calling function. This means that we need to fetch the value
2348 form %o0 and %o1, which correspond to %i0 and %i1 in the frame of
2349 the called function. */
2352 sparc32_extract_return_value (struct type
*type
, struct regcache
*regcache
,
2355 int len
= TYPE_LENGTH (type
);
2358 if (TYPE_CODE (type
) == TYPE_CODE_FLT
&& SPARC_HAS_FPU
)
2360 if (len
== 4 || len
== 8)
2362 regcache_cooked_read (regcache
, SPARC_F0_REGNUM
, buf
);
2363 regcache_cooked_read (regcache
, SPARC_F1_REGNUM
, buf
+ 4);
2364 memcpy (valbuf
, buf
, len
);
2368 internal_error (__FILE__
, __LINE__
, "\
2369 Cannot extract floating-point return value of %d bytes long.", len
);
2374 regcache_cooked_read (regcache
, SPARC_O0_REGNUM
, buf
);
2375 memcpy (valbuf
, buf
+ 4 - len
, len
);
2379 regcache_cooked_read (regcache
, SPARC_O0_REGNUM
, buf
);
2380 regcache_cooked_read (regcache
, SPARC_O1_REGNUM
, buf
+ 4);
2381 memcpy (valbuf
, buf
+ 8 - len
, len
);
2384 internal_error (__FILE__
, __LINE__
,
2385 "Cannot extract return value of %d bytes long.", len
);
2388 /* Write into REGBUF a function return value VALBUF of type TYPE. */
2391 sparc32_store_return_value (struct type
*type
, struct regcache
*regcache
,
2394 int len
= TYPE_LENGTH (type
);
2397 if (TYPE_CODE (type
) == TYPE_CODE_FLT
&& SPARC_HAS_FPU
)
2399 const char *buf
= valbuf
;
2403 regcache_cooked_write (regcache
, SPARC_F0_REGNUM
, buf
);
2408 regcache_cooked_write (regcache
, SPARC_F0_REGNUM
, buf
);
2409 regcache_cooked_write (regcache
, SPARC_F1_REGNUM
, buf
+ 4);
2413 internal_error (__FILE__
, __LINE__
, "\
2414 Cannot extract floating-point return value of %d bytes long.", len
);
2417 /* Add leading zeros to the value. */
2418 memset (buf
, 0, sizeof buf
);
2422 memcpy (buf
+ 4 - len
, valbuf
, len
);
2423 regcache_cooked_write (regcache
, SPARC_O0_REGNUM
, buf
);
2427 memcpy (buf
+ 8 - len
, valbuf
, len
);
2428 regcache_cooked_write (regcache
, SPARC_O0_REGNUM
, buf
);
2429 regcache_cooked_write (regcache
, SPARC_O1_REGNUM
, buf
);
2432 internal_error (__FILE__
, __LINE__
,
2433 "Cannot extract return value of %d bytes long.", len
);
2436 /* Extract from REGCACHE the address in which a function should return
2437 its structure value. */
2440 sparc_extract_struct_value_address (struct regcache
*regcache
)
2444 regcache_cooked_read_unsigned (regcache
, SPARC_O0_REGNUM
, &addr
);
2448 /* FIXME: kettenis/2003/05/24: Still used for sparc64. */
2451 sparc_store_return_value (struct type
*type
, char *valbuf
)
2454 char buffer
[MAX_REGISTER_SIZE
];
2456 if (TYPE_CODE (type
) == TYPE_CODE_FLT
&& SPARC_HAS_FPU
)
2457 /* Floating-point values are returned in the register pair */
2458 /* formed by %f0 and %f1 (doubles are, anyway). */
2461 /* Other values are returned in register %o0. */
2464 /* Add leading zeros to the value. */
2465 if (TYPE_LENGTH (type
) < REGISTER_RAW_SIZE (regno
))
2467 memset (buffer
, 0, REGISTER_RAW_SIZE (regno
));
2468 memcpy (buffer
+ REGISTER_RAW_SIZE (regno
) - TYPE_LENGTH (type
), valbuf
,
2469 TYPE_LENGTH (type
));
2470 deprecated_write_register_gen (regno
, buffer
);
2473 deprecated_write_register_bytes (REGISTER_BYTE (regno
), valbuf
,
2474 TYPE_LENGTH (type
));
2478 // OBSOLETE extern void
2479 // OBSOLETE sparclet_store_return_value (struct type *type, char *valbuf)
2481 // OBSOLETE /* Other values are returned in register %o0. */
2482 // OBSOLETE deprecated_write_register_bytes (REGISTER_BYTE (O0_REGNUM), valbuf,
2483 // OBSOLETE TYPE_LENGTH (type));
2488 #ifndef CALL_DUMMY_CALL_OFFSET
2489 #define CALL_DUMMY_CALL_OFFSET \
2490 (gdbarch_tdep (current_gdbarch)->call_dummy_call_offset)
2491 #endif /* CALL_DUMMY_CALL_OFFSET */
2493 /* Insert the function address into a call dummy instruction sequence
2496 For structs and unions, if the function was compiled with Sun cc,
2497 it expects 'unimp' after the call. But gcc doesn't use that
2498 (twisted) convention. So leave a nop there for gcc
2499 (DEPRECATED_FIX_CALL_DUMMY can assume it is operating on a pristine
2500 CALL_DUMMY, not one that has already been customized for a
2501 different function). */
2504 sparc_fix_call_dummy (char *dummy
, CORE_ADDR pc
, CORE_ADDR fun
,
2505 struct type
*value_type
, int using_gcc
)
2509 /* Store the relative adddress of the target function into the
2510 'call' instruction. */
2511 store_unsigned_integer (dummy
+ CALL_DUMMY_CALL_OFFSET
, 4,
2513 | (((fun
- (pc
+ CALL_DUMMY_CALL_OFFSET
)) >> 2)
2516 /* If the called function returns an aggregate value, fill in the UNIMP
2517 instruction containing the size of the returned aggregate return value,
2518 which follows the call instruction.
2519 For details see the SPARC Architecture Manual Version 8, Appendix D.3.
2521 Adjust the call_dummy_breakpoint_offset for the bp_call_dummy breakpoint
2522 to the proper address in the call dummy, so that `finish' after a stop
2523 in a call dummy works.
2525 Tweeking current_gdbarch is not an optimal solution, but the call
2526 to sparc_fix_call_dummy is immediately followed by a call to
2527 call_function_by_hand, which is the only function where
2528 dummy_breakpoint_offset is actually used, if it is non-zero. */
2529 if (TYPE_CODE (value_type
) == TYPE_CODE_STRUCT
2530 || TYPE_CODE (value_type
) == TYPE_CODE_UNION
)
2532 store_unsigned_integer (dummy
+ CALL_DUMMY_CALL_OFFSET
+ 8, 4,
2533 TYPE_LENGTH (value_type
) & 0x1fff);
2534 set_gdbarch_deprecated_call_dummy_breakpoint_offset (current_gdbarch
, 0x30);
2537 set_gdbarch_deprecated_call_dummy_breakpoint_offset (current_gdbarch
, 0x2c);
2539 if (!(GDB_TARGET_IS_SPARC64
))
2541 /* If this is not a simulator target, change the first four
2542 instructions of the call dummy to NOPs. Those instructions
2543 include a 'save' instruction and are designed to work around
2544 problems with register window flushing in the simulator. */
2546 if (strcmp (target_shortname
, "sim") != 0)
2548 for (i
= 0; i
< 4; i
++)
2549 store_unsigned_integer (dummy
+ (i
* 4), 4, 0x01000000);
2554 // OBSOLETE /* If this is a bi-endian target, GDB has written the call dummy
2555 // OBSOLETE in little-endian order. We must byte-swap it back to big-endian. */
2556 // OBSOLETE if (bi_endian)
2558 // OBSOLETE for (i = 0; i < CALL_DUMMY_LENGTH; i += 4)
2560 // OBSOLETE char tmp = dummy[i];
2561 // OBSOLETE dummy[i] = dummy[i + 3];
2562 // OBSOLETE dummy[i + 3] = tmp;
2563 // OBSOLETE tmp = dummy[i + 1];
2564 // OBSOLETE dummy[i + 1] = dummy[i + 2];
2565 // OBSOLETE dummy[i + 2] = tmp;
2573 // OBSOLETE /* Set target byte order based on machine type. */
2575 // OBSOLETE static int
2576 // OBSOLETE sparc_target_architecture_hook (const bfd_arch_info_type *ap)
2578 // OBSOLETE int i, j;
2580 // OBSOLETE if (ap->mach == bfd_mach_sparc_sparclite_le)
2582 // OBSOLETE target_byte_order = BFD_ENDIAN_LITTLE;
2583 // OBSOLETE bi_endian = 1;
2586 // OBSOLETE bi_endian = 0;
2587 // OBSOLETE return 1;
2592 * Module "constructor" function.
2595 static struct gdbarch
* sparc_gdbarch_init (struct gdbarch_info info
,
2596 struct gdbarch_list
*arches
);
2597 static void sparc_dump_tdep (struct gdbarch
*, struct ui_file
*);
2599 extern initialize_file_ftype _initialize_sparc_tdep
; /* -Wmissing-prototypes */
2602 _initialize_sparc_tdep (void)
2604 /* Hook us into the gdbarch mechanism. */
2605 gdbarch_register (bfd_arch_sparc
, sparc_gdbarch_init
, sparc_dump_tdep
);
2607 deprecated_tm_print_insn
= gdb_print_insn_sparc
;
2608 deprecated_tm_print_insn_info
.mach
= TM_PRINT_INSN_MACH
; /* Selects sparc/sparclite */
2609 /* OBSOLETE target_architecture_hook = sparc_target_architecture_hook; */
2612 /* Compensate for stack bias. Note that we currently don't handle
2613 mixed 32/64 bit code. */
2616 sparc64_read_sp (void)
2618 CORE_ADDR sp
= read_register (SP_REGNUM
);
2626 sparc64_read_fp (void)
2628 CORE_ADDR fp
= read_register (DEPRECATED_FP_REGNUM
);
2636 sparc64_write_sp (CORE_ADDR val
)
2638 CORE_ADDR oldsp
= read_register (SP_REGNUM
);
2640 write_register (SP_REGNUM
, val
- 2047);
2642 write_register (SP_REGNUM
, val
);
2645 /* The SPARC 64 ABI passes floating-point arguments in FP0 to FP31,
2646 and all other arguments in O0 to O5. They are also copied onto
2647 the stack in the correct places. Apparently (empirically),
2648 structs of less than 16 bytes are passed member-by-member in
2649 separate registers, but I am unable to figure out the algorithm.
2650 Some members go in floating point regs, but I don't know which.
2652 FIXME: Handle small structs (less than 16 bytes containing floats).
2654 The counting regimen for using both integer and FP registers
2655 for argument passing is rather odd -- a single counter is used
2656 for both; this means that if the arguments alternate between
2657 int and float, we will waste every other register of both types. */
2660 sparc64_push_arguments (int nargs
, struct value
**args
, CORE_ADDR sp
,
2661 int struct_return
, CORE_ADDR struct_retaddr
)
2663 int i
, j
, register_counter
= 0;
2665 struct type
*sparc_intreg_type
=
2666 TYPE_LENGTH (builtin_type_long
) == SPARC_INTREG_SIZE
?
2667 builtin_type_long
: builtin_type_long_long
;
2669 sp
= (sp
& ~(((unsigned long) SPARC_INTREG_SIZE
) - 1UL));
2671 /* Figure out how much space we'll need. */
2672 for (i
= nargs
- 1; i
>= 0; i
--)
2674 int len
= TYPE_LENGTH (check_typedef (VALUE_TYPE (args
[i
])));
2675 struct value
*copyarg
= args
[i
];
2678 if (copylen
< SPARC_INTREG_SIZE
)
2680 copyarg
= value_cast (sparc_intreg_type
, copyarg
);
2681 copylen
= SPARC_INTREG_SIZE
;
2690 /* if STRUCT_RETURN, then first argument is the struct return location. */
2692 write_register (O0_REGNUM
+ register_counter
++, struct_retaddr
);
2694 /* Now write the arguments onto the stack, while writing FP
2695 arguments into the FP registers, and other arguments into the
2696 first six 'O' registers. */
2698 for (i
= 0; i
< nargs
; i
++)
2700 int len
= TYPE_LENGTH (check_typedef (VALUE_TYPE (args
[i
])));
2701 struct value
*copyarg
= args
[i
];
2702 enum type_code typecode
= TYPE_CODE (VALUE_TYPE (args
[i
]));
2705 if (typecode
== TYPE_CODE_INT
||
2706 typecode
== TYPE_CODE_BOOL
||
2707 typecode
== TYPE_CODE_CHAR
||
2708 typecode
== TYPE_CODE_RANGE
||
2709 typecode
== TYPE_CODE_ENUM
)
2710 if (len
< SPARC_INTREG_SIZE
)
2712 /* Small ints will all take up the size of one intreg on
2714 copyarg
= value_cast (sparc_intreg_type
, copyarg
);
2715 copylen
= SPARC_INTREG_SIZE
;
2718 write_memory (tempsp
, VALUE_CONTENTS (copyarg
), copylen
);
2721 /* Corner case: Structs consisting of a single float member are floats.
2722 * FIXME! I don't know about structs containing multiple floats!
2723 * Structs containing mixed floats and ints are even more weird.
2728 /* Separate float args from all other args. */
2729 if (typecode
== TYPE_CODE_FLT
&& SPARC_HAS_FPU
)
2731 if (register_counter
< 16)
2733 /* This arg gets copied into a FP register. */
2737 case 4: /* Single-precision (float) */
2738 fpreg
= FP0_REGNUM
+ 2 * register_counter
+ 1;
2739 register_counter
+= 1;
2741 case 8: /* Double-precision (double) */
2742 fpreg
= FP0_REGNUM
+ 2 * register_counter
;
2743 register_counter
+= 1;
2745 case 16: /* Quad-precision (long double) */
2746 fpreg
= FP0_REGNUM
+ 2 * register_counter
;
2747 register_counter
+= 2;
2750 internal_error (__FILE__
, __LINE__
, "bad switch");
2752 deprecated_write_register_bytes (REGISTER_BYTE (fpreg
),
2753 VALUE_CONTENTS (args
[i
]),
2757 else /* all other args go into the first six 'o' registers */
2760 j
< len
&& register_counter
< 6;
2761 j
+= SPARC_INTREG_SIZE
)
2763 int oreg
= O0_REGNUM
+ register_counter
;
2765 deprecated_write_register_gen (oreg
, VALUE_CONTENTS (copyarg
) + j
);
2766 register_counter
+= 1;
2773 /* Values <= 32 bytes are returned in o0-o3 (floating-point values are
2774 returned in f0-f3). */
2777 sp64_extract_return_value (struct type
*type
, char *regbuf
, char *valbuf
,
2780 int typelen
= TYPE_LENGTH (type
);
2781 int regsize
= REGISTER_RAW_SIZE (O0_REGNUM
);
2783 if (TYPE_CODE (type
) == TYPE_CODE_FLT
&& SPARC_HAS_FPU
)
2785 memcpy (valbuf
, ®buf
[REGISTER_BYTE (FP0_REGNUM
)], typelen
);
2789 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
2790 || (TYPE_LENGTH (type
) > 32))
2793 ®buf
[O0_REGNUM
* regsize
+
2794 (typelen
>= regsize
? 0 : regsize
- typelen
)],
2800 char *o0
= ®buf
[O0_REGNUM
* regsize
];
2801 char *f0
= ®buf
[FP0_REGNUM
* regsize
];
2804 for (x
= 0; x
< TYPE_NFIELDS (type
); x
++)
2806 struct field
*f
= &TYPE_FIELDS (type
)[x
];
2807 /* FIXME: We may need to handle static fields here. */
2808 int whichreg
= (f
->loc
.bitpos
+ bitoffset
) / 32;
2809 int remainder
= ((f
->loc
.bitpos
+ bitoffset
) % 32) / 8;
2810 int where
= (f
->loc
.bitpos
+ bitoffset
) / 8;
2811 int size
= TYPE_LENGTH (f
->type
);
2812 int typecode
= TYPE_CODE (f
->type
);
2814 if (typecode
== TYPE_CODE_STRUCT
)
2816 sp64_extract_return_value (f
->type
,
2819 bitoffset
+ f
->loc
.bitpos
);
2821 else if (typecode
== TYPE_CODE_FLT
&& SPARC_HAS_FPU
)
2823 memcpy (valbuf
+ where
, &f0
[whichreg
* 4] + remainder
, size
);
2827 memcpy (valbuf
+ where
, &o0
[whichreg
* 4] + remainder
, size
);
2834 sparc64_extract_return_value (struct type
*type
, char *regbuf
, char *valbuf
)
2836 sp64_extract_return_value (type
, regbuf
, valbuf
, 0);
2840 // OBSOLETE extern void
2841 // OBSOLETE sparclet_extract_return_value (struct type *type,
2842 // OBSOLETE char *regbuf,
2843 // OBSOLETE char *valbuf)
2845 // OBSOLETE regbuf += REGISTER_RAW_SIZE (O0_REGNUM) * 8;
2846 // OBSOLETE if (TYPE_LENGTH (type) < REGISTER_RAW_SIZE (O0_REGNUM))
2847 // OBSOLETE regbuf += REGISTER_RAW_SIZE (O0_REGNUM) - TYPE_LENGTH (type);
2849 // OBSOLETE memcpy ((void *) valbuf, regbuf, TYPE_LENGTH (type));
2854 sparc32_stack_align (CORE_ADDR addr
)
2856 return ((addr
+ 7) & -8);
2860 sparc64_stack_align (CORE_ADDR addr
)
2862 return ((addr
+ 15) & -16);
2866 sparc_print_extra_frame_info (struct frame_info
*fi
)
2868 if (fi
&& get_frame_extra_info (fi
) && get_frame_extra_info (fi
)->flat
)
2869 printf_filtered (" flat, pc saved at 0x%s, fp saved at 0x%s\n",
2870 paddr_nz (get_frame_extra_info (fi
)->pc_addr
),
2871 paddr_nz (get_frame_extra_info (fi
)->fp_addr
));
2874 /* MULTI_ARCH support */
2877 legacy_register_name (int i
)
2879 #ifdef REGISTER_NAMES
2880 static char *names
[] = REGISTER_NAMES
;
2881 if (i
< 0 || i
>= (sizeof (names
) / sizeof (*names
)))
2886 internal_error (__FILE__
, __LINE__
,
2887 "legacy_register_name: called.");
2893 sparc32_register_name (int regno
)
2895 static char *register_names
[] =
2896 { "g0", "g1", "g2", "g3", "g4", "g5", "g6", "g7",
2897 "o0", "o1", "o2", "o3", "o4", "o5", "sp", "o7",
2898 "l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7",
2899 "i0", "i1", "i2", "i3", "i4", "i5", "fp", "i7",
2901 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
2902 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
2903 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
2904 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
2906 "y", "psr", "wim", "tbr", "pc", "npc", "fpsr", "cpsr"
2910 regno
>= (sizeof (register_names
) / sizeof (register_names
[0])))
2913 return register_names
[regno
];
2917 sparc64_register_name (int regno
)
2919 static char *register_names
[] =
2920 { "g0", "g1", "g2", "g3", "g4", "g5", "g6", "g7",
2921 "o0", "o1", "o2", "o3", "o4", "o5", "sp", "o7",
2922 "l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7",
2923 "i0", "i1", "i2", "i3", "i4", "i5", "fp", "i7",
2925 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
2926 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
2927 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
2928 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
2929 "f32", "f34", "f36", "f38", "f40", "f42", "f44", "f46",
2930 "f48", "f50", "f52", "f54", "f56", "f58", "f60", "f62",
2932 "pc", "npc", "ccr", "fsr", "fprs", "y", "asi", "ver",
2933 "tick", "pil", "pstate", "tstate", "tba", "tl", "tt", "tpc",
2934 "tnpc", "wstate", "cwp", "cansave", "canrestore", "cleanwin", "otherwin",
2935 "asr16", "asr17", "asr18", "asr19", "asr20", "asr21", "asr22", "asr23",
2936 "asr24", "asr25", "asr26", "asr27", "asr28", "asr29", "asr30", "asr31",
2937 /* These are here at the end to simplify removing them if we have to. */
2938 "icc", "xcc", "fcc0", "fcc1", "fcc2", "fcc3"
2942 regno
>= (sizeof (register_names
) / sizeof (register_names
[0])))
2945 return register_names
[regno
];
2949 // OBSOLETE static const char *
2950 // OBSOLETE sparclite_register_name (int regno)
2952 // OBSOLETE static char *register_names[] =
2953 // OBSOLETE { "g0", "g1", "g2", "g3", "g4", "g5", "g6", "g7",
2954 // OBSOLETE "o0", "o1", "o2", "o3", "o4", "o5", "sp", "o7",
2955 // OBSOLETE "l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7",
2956 // OBSOLETE "i0", "i1", "i2", "i3", "i4", "i5", "fp", "i7",
2958 // OBSOLETE "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
2959 // OBSOLETE "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
2960 // OBSOLETE "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
2961 // OBSOLETE "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
2963 // OBSOLETE "y", "psr", "wim", "tbr", "pc", "npc", "fpsr", "cpsr",
2964 // OBSOLETE "dia1", "dia2", "dda1", "dda2", "ddv1", "ddv2", "dcr", "dsr"
2967 // OBSOLETE if (regno < 0 ||
2968 // OBSOLETE regno >= (sizeof (register_names) / sizeof (register_names[0])))
2969 // OBSOLETE return NULL;
2971 // OBSOLETE return register_names[regno];
2976 // OBSOLETE static const char *
2977 // OBSOLETE sparclet_register_name (int regno)
2979 // OBSOLETE static char *register_names[] =
2980 // OBSOLETE { "g0", "g1", "g2", "g3", "g4", "g5", "g6", "g7",
2981 // OBSOLETE "o0", "o1", "o2", "o3", "o4", "o5", "sp", "o7",
2982 // OBSOLETE "l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7",
2983 // OBSOLETE "i0", "i1", "i2", "i3", "i4", "i5", "fp", "i7",
2985 // OBSOLETE "", "", "", "", "", "", "", "", /* no floating point registers */
2986 // OBSOLETE "", "", "", "", "", "", "", "",
2987 // OBSOLETE "", "", "", "", "", "", "", "",
2988 // OBSOLETE "", "", "", "", "", "", "", "",
2990 // OBSOLETE "y", "psr", "wim", "tbr", "pc", "npc", "", "", /* no FPSR or CPSR */
2991 // OBSOLETE "ccsr", "ccpr", "cccrcr", "ccor", "ccobr", "ccibr", "ccir", "",
2993 // OBSOLETE /* ASR15 ASR19 (don't display them) */
2994 // OBSOLETE "asr1", "", "asr17", "asr18", "", "asr20", "asr21", "asr22"
2995 // OBSOLETE /* None of the rest get displayed */
2997 // OBSOLETE "awr0", "awr1", "awr2", "awr3", "awr4", "awr5", "awr6", "awr7",
2998 // OBSOLETE "awr8", "awr9", "awr10", "awr11", "awr12", "awr13", "awr14", "awr15",
2999 // OBSOLETE "awr16", "awr17", "awr18", "awr19", "awr20", "awr21", "awr22", "awr23",
3000 // OBSOLETE "awr24", "awr25", "awr26", "awr27", "awr28", "awr29", "awr30", "awr31",
3002 // OBSOLETE #endif /* 0 */
3005 // OBSOLETE if (regno < 0 ||
3006 // OBSOLETE regno >= (sizeof (register_names) / sizeof (register_names[0])))
3007 // OBSOLETE return NULL;
3009 // OBSOLETE return register_names[regno];
3014 sparc_push_return_address (CORE_ADDR pc_unused
, CORE_ADDR sp
)
3016 if (CALL_DUMMY_LOCATION
== AT_ENTRY_POINT
)
3018 /* The return PC of the dummy_frame is the former 'current' PC
3019 (where we were before we made the target function call).
3020 This is saved in %i7 by push_dummy_frame.
3022 We will save the 'call dummy location' (ie. the address
3023 to which the target function will return) in %o7.
3024 This address will actually be the program's entry point.
3025 There will be a special call_dummy breakpoint there. */
3027 write_register (O7_REGNUM
,
3028 CALL_DUMMY_ADDRESS () - 8);
3034 /* Should call_function allocate stack space for a struct return? */
3037 sparc64_use_struct_convention (int gcc_p
, struct type
*type
)
3039 return (TYPE_LENGTH (type
) > 32);
3042 /* Store the address of the place in which to copy the structure the
3043 subroutine will return. This is called from call_function_by_hand.
3044 The ultimate mystery is, tho, what is the value "16"?
3046 MVS: That's the offset from where the sp is now, to where the
3047 subroutine is gonna expect to find the struct return address. */
3050 sparc32_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
)
3055 val
= alloca (SPARC_INTREG_SIZE
);
3056 store_unsigned_integer (val
, SPARC_INTREG_SIZE
, addr
);
3057 write_memory (sp
+ (16 * SPARC_INTREG_SIZE
), val
, SPARC_INTREG_SIZE
);
3059 if (CALL_DUMMY_LOCATION
== AT_ENTRY_POINT
)
3061 /* Now adjust the value of the link register, which was previously
3062 stored by push_return_address. Functions that return structs are
3063 peculiar in that they return to link register + 12, rather than
3064 link register + 8. */
3066 o7
= read_register (O7_REGNUM
);
3067 write_register (O7_REGNUM
, o7
- 4);
3072 sparc64_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
)
3074 /* FIXME: V9 uses %o0 for this. */
3075 /* FIXME MVS: Only for small enough structs!!! */
3077 target_write_memory (sp
+ (16 * SPARC_INTREG_SIZE
),
3078 (char *) &addr
, SPARC_INTREG_SIZE
);
3080 if (CALL_DUMMY_LOCATION
== AT_ENTRY_POINT
)
3082 /* Now adjust the value of the link register, which was previously
3083 stored by push_return_address. Functions that return structs are
3084 peculiar in that they return to link register + 12, rather than
3085 link register + 8. */
3087 write_register (O7_REGNUM
, read_register (O7_REGNUM
) - 4);
3092 /* Default target data type for register REGNO. */
3094 static struct type
*
3095 sparc32_register_virtual_type (int regno
)
3097 if (regno
== PC_REGNUM
||
3098 regno
== DEPRECATED_FP_REGNUM
||
3100 return builtin_type_unsigned_int
;
3102 return builtin_type_int
;
3104 return builtin_type_float
;
3105 return builtin_type_int
;
3108 static struct type
*
3109 sparc64_register_virtual_type (int regno
)
3111 if (regno
== PC_REGNUM
||
3112 regno
== DEPRECATED_FP_REGNUM
||
3114 return builtin_type_unsigned_long_long
;
3116 return builtin_type_long_long
;
3118 return builtin_type_float
;
3120 return builtin_type_double
;
3121 return builtin_type_long_long
;
3124 /* Number of bytes of storage in the actual machine representation for
3128 sparc32_register_size (int regno
)
3134 sparc64_register_size (int regno
)
3136 return (regno
< 32 ? 8 : regno
< 64 ? 4 : 8);
3139 /* Index within the `registers' buffer of the first byte of the space
3140 for register REGNO. */
3143 sparc32_register_byte (int regno
)
3149 sparc64_register_byte (int regno
)
3153 else if (regno
< 64)
3154 return 32 * 8 + (regno
- 32) * 4;
3155 else if (regno
< 80)
3156 return 32 * 8 + 32 * 4 + (regno
- 64) * 8;
3158 return 64 * 8 + (regno
- 80) * 8;
3161 /* Immediately after a function call, return the saved pc.
3162 Can't go through the frames for this because on some machines
3163 the new frame is not set up until the new function executes
3164 some instructions. */
3167 sparc_saved_pc_after_call (struct frame_info
*fi
)
3169 return sparc_pc_adjust (read_register (RP_REGNUM
));
3172 /* Init saved regs: nothing to do, just a place-holder function. */
3175 sparc_frame_init_saved_regs (struct frame_info
*fi_ignored
)
3179 /* gdbarch fix call dummy:
3180 All this function does is rearrange the arguments before calling
3181 sparc_fix_call_dummy (which does the real work). */
3184 sparc_gdbarch_fix_call_dummy (char *dummy
,
3188 struct value
**args
,
3192 if (CALL_DUMMY_LOCATION
== ON_STACK
)
3193 sparc_fix_call_dummy (dummy
, pc
, fun
, type
, gcc_p
);
3196 /* CALL_DUMMY_ADDRESS: fetch the breakpoint address for a call dummy. */
3199 sparc_call_dummy_address (void)
3201 return (DEPRECATED_CALL_DUMMY_START_OFFSET
) + DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET
;
3204 /* Supply the Y register number to those that need it. */
3207 sparc_y_regnum (void)
3209 return gdbarch_tdep (current_gdbarch
)->y_regnum
;
3213 sparc_reg_struct_has_addr (int gcc_p
, struct type
*type
)
3215 if (GDB_TARGET_IS_SPARC64
)
3216 return (TYPE_LENGTH (type
) > 32);
3218 return (gcc_p
!= 1);
3222 sparc_intreg_size (void)
3224 return SPARC_INTREG_SIZE
;
3228 sparc_return_value_on_stack (struct type
*type
)
3230 if (TYPE_CODE (type
) == TYPE_CODE_FLT
&&
3231 TYPE_LENGTH (type
) > 8)
3237 /* Get the ith function argument for the current function. */
3239 sparc_fetch_pointer_argument (struct frame_info
*frame
, int argi
,
3243 frame_read_register (frame
, O0_REGNUM
+ argi
, &addr
);
3248 * Gdbarch "constructor" function.
3251 #define SPARC32_CALL_DUMMY_ON_STACK
3253 #define SPARC_SP_REGNUM 14
3254 #define SPARC_FP_REGNUM 30
3255 #define SPARC_FP0_REGNUM 32
3256 #define SPARC32_NPC_REGNUM 69
3257 #define SPARC32_PC_REGNUM 68
3258 #define SPARC32_Y_REGNUM 64
3259 #define SPARC64_PC_REGNUM 80
3260 #define SPARC64_NPC_REGNUM 81
3261 #define SPARC64_Y_REGNUM 85
3263 static struct gdbarch
*
3264 sparc_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
3266 struct gdbarch
*gdbarch
;
3267 struct gdbarch_tdep
*tdep
;
3269 static LONGEST call_dummy_32
[] =
3270 { 0xbc100001, 0x9de38000, 0xbc100002, 0xbe100003,
3271 0xda03a058, 0xd803a054, 0xd603a050, 0xd403a04c,
3272 0xd203a048, 0x40000000, 0xd003a044, 0x01000000,
3273 0x91d02001, 0x01000000
3275 static LONGEST call_dummy_64
[] =
3276 { 0x9de3bec0fd3fa7f7LL
, 0xf93fa7eff53fa7e7LL
,
3277 0xf13fa7dfed3fa7d7LL
, 0xe93fa7cfe53fa7c7LL
,
3278 0xe13fa7bfdd3fa7b7LL
, 0xd93fa7afd53fa7a7LL
,
3279 0xd13fa79fcd3fa797LL
, 0xc93fa78fc53fa787LL
,
3280 0xc13fa77fcc3fa777LL
, 0xc83fa76fc43fa767LL
,
3281 0xc03fa75ffc3fa757LL
, 0xf83fa74ff43fa747LL
,
3282 0xf03fa73f01000000LL
, 0x0100000001000000LL
,
3283 0x0100000091580000LL
, 0xd027a72b93500000LL
,
3284 0xd027a72791480000LL
, 0xd027a72391400000LL
,
3285 0xd027a71fda5ba8a7LL
, 0xd85ba89fd65ba897LL
,
3286 0xd45ba88fd25ba887LL
, 0x9fc02000d05ba87fLL
,
3287 0x0100000091d02001LL
, 0x0100000001000000LL
3289 static LONGEST call_dummy_nil
[] = {0};
3291 /* Try to determine the OS ABI of the object we are loading. */
3293 if (info
.abfd
!= NULL
3294 && info
.osabi
== GDB_OSABI_UNKNOWN
)
3296 /* If it's an ELF file, assume it's Solaris. */
3297 if (bfd_get_flavour (info
.abfd
) == bfd_target_elf_flavour
)
3298 info
.osabi
= GDB_OSABI_SOLARIS
;
3301 /* First see if there is already a gdbarch that can satisfy the request. */
3302 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
3304 return arches
->gdbarch
;
3306 /* None found: is the request for a sparc architecture? */
3307 if (info
.bfd_arch_info
->arch
!= bfd_arch_sparc
)
3308 return NULL
; /* No; then it's not for us. */
3310 /* Yes: create a new gdbarch for the specified machine type. */
3311 tdep
= (struct gdbarch_tdep
*) xmalloc (sizeof (struct gdbarch_tdep
));
3312 gdbarch
= gdbarch_alloc (&info
, tdep
);
3314 /* First set settings that are common for all sparc architectures. */
3315 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
3316 set_gdbarch_breakpoint_from_pc (gdbarch
, sparc_breakpoint_from_pc
);
3317 set_gdbarch_decr_pc_after_break (gdbarch
, 0);
3318 set_gdbarch_double_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
3319 set_gdbarch_extract_struct_value_address (gdbarch
,
3320 sparc_extract_struct_value_address
);
3321 set_gdbarch_deprecated_fix_call_dummy (gdbarch
, sparc_gdbarch_fix_call_dummy
);
3322 set_gdbarch_float_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
3323 set_gdbarch_deprecated_fp_regnum (gdbarch
, SPARC_FP_REGNUM
);
3324 set_gdbarch_fp0_regnum (gdbarch
, SPARC_FP0_REGNUM
);
3325 set_gdbarch_deprecated_frame_chain (gdbarch
, sparc_frame_chain
);
3326 set_gdbarch_deprecated_frame_init_saved_regs (gdbarch
, sparc_frame_init_saved_regs
);
3327 set_gdbarch_deprecated_frame_saved_pc (gdbarch
, sparc_frame_saved_pc
);
3328 set_gdbarch_frameless_function_invocation (gdbarch
,
3329 frameless_look_for_prologue
);
3330 set_gdbarch_deprecated_get_saved_register (gdbarch
, sparc_get_saved_register
);
3331 set_gdbarch_deprecated_init_extra_frame_info (gdbarch
, sparc_init_extra_frame_info
);
3332 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
3333 set_gdbarch_int_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
3334 set_gdbarch_long_double_bit (gdbarch
, 16 * TARGET_CHAR_BIT
);
3335 set_gdbarch_long_long_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
3336 set_gdbarch_deprecated_max_register_raw_size (gdbarch
, 8);
3337 set_gdbarch_deprecated_max_register_virtual_size (gdbarch
, 8);
3338 set_gdbarch_deprecated_pop_frame (gdbarch
, sparc_pop_frame
);
3339 set_gdbarch_deprecated_push_return_address (gdbarch
, sparc_push_return_address
);
3340 set_gdbarch_deprecated_push_dummy_frame (gdbarch
, sparc_push_dummy_frame
);
3341 set_gdbarch_reg_struct_has_addr (gdbarch
, sparc_reg_struct_has_addr
);
3342 set_gdbarch_return_value_on_stack (gdbarch
, sparc_return_value_on_stack
);
3343 set_gdbarch_deprecated_saved_pc_after_call (gdbarch
, sparc_saved_pc_after_call
);
3344 set_gdbarch_prologue_frameless_p (gdbarch
, sparc_prologue_frameless_p
);
3345 set_gdbarch_short_bit (gdbarch
, 2 * TARGET_CHAR_BIT
);
3346 set_gdbarch_skip_prologue (gdbarch
, sparc_skip_prologue
);
3347 set_gdbarch_sp_regnum (gdbarch
, SPARC_SP_REGNUM
);
3348 set_gdbarch_deprecated_use_generic_dummy_frames (gdbarch
, 0);
3349 set_gdbarch_write_pc (gdbarch
, generic_target_write_pc
);
3351 /* Helper for function argument information. */
3352 set_gdbarch_fetch_pointer_argument (gdbarch
, sparc_fetch_pointer_argument
);
3355 * Settings that depend only on 32/64 bit word size
3358 switch (info
.bfd_arch_info
->mach
)
3360 case bfd_mach_sparc
:
3362 // OBSOLETE case bfd_mach_sparc_sparclet:
3363 // OBSOLETE case bfd_mach_sparc_sparclite:
3365 case bfd_mach_sparc_v8plus
:
3366 case bfd_mach_sparc_v8plusa
:
3368 // OBSOLETE case bfd_mach_sparc_sparclite_le:
3370 /* 32-bit machine types: */
3372 #ifdef SPARC32_CALL_DUMMY_ON_STACK
3373 set_gdbarch_deprecated_pc_in_call_dummy (gdbarch
, deprecated_pc_in_call_dummy_on_stack
);
3374 set_gdbarch_call_dummy_address (gdbarch
, sparc_call_dummy_address
);
3375 set_gdbarch_deprecated_call_dummy_breakpoint_offset (gdbarch
, 0x30);
3376 set_gdbarch_deprecated_call_dummy_length (gdbarch
, 0x38);
3378 /* NOTE: cagney/2003-05-01: Using the just added push_dummy_code
3379 architecture method, it is now possible to implement a
3380 generic dummy frames based inferior function call that stores
3381 the breakpoint (and struct info) on the stack. Further, by
3382 treating a SIGSEG at a breakpoint as equivalent to a SIGTRAP
3383 it is even possible to make this work when the stack is
3386 NOTE: cagney/2002-04-26: Based from info posted by Peter
3387 Schauer around Oct '99. Briefly, due to aspects of the SPARC
3388 ABI, it isn't possible to use ON_STACK with a strictly
3391 Peter Schauer writes ...
3393 No, any call from GDB to a user function returning a
3394 struct/union will fail miserably. Try this:
3413 for (i = 0; i < 4; i++)
3419 Set a breakpoint at the gx = sret () statement, run to it and
3420 issue a `print sret()'. It will not succed with your
3421 approach, and I doubt that continuing the program will work
3424 For details of the ABI see the Sparc Architecture Manual. I
3425 have Version 8 (Prentice Hall ISBN 0-13-825001-4) and the
3426 calling conventions for functions returning aggregate values
3427 are explained in Appendix D.3. */
3429 set_gdbarch_call_dummy_location (gdbarch
, ON_STACK
);
3430 set_gdbarch_deprecated_call_dummy_words (gdbarch
, call_dummy_32
);
3432 set_gdbarch_deprecated_pc_in_call_dummy (gdbarch
, deprecated_pc_in_call_dummy_at_entry_point
);
3433 set_gdbarch_deprecated_call_dummy_words (gdbarch
, call_dummy_nil
);
3435 set_gdbarch_deprecated_call_dummy_stack_adjust (gdbarch
, 68);
3436 set_gdbarch_frame_args_skip (gdbarch
, 68);
3437 set_gdbarch_function_start_offset (gdbarch
, 0);
3438 set_gdbarch_long_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
3439 set_gdbarch_npc_regnum (gdbarch
, SPARC32_NPC_REGNUM
);
3440 set_gdbarch_pc_regnum (gdbarch
, SPARC32_PC_REGNUM
);
3441 set_gdbarch_ptr_bit (gdbarch
, 4 * TARGET_CHAR_BIT
);
3442 set_gdbarch_deprecated_push_arguments (gdbarch
, sparc32_push_arguments
);
3444 set_gdbarch_deprecated_register_byte (gdbarch
, sparc32_register_byte
);
3445 set_gdbarch_deprecated_register_raw_size (gdbarch
, sparc32_register_size
);
3446 set_gdbarch_deprecated_register_size (gdbarch
, 4);
3447 set_gdbarch_deprecated_register_virtual_size (gdbarch
, sparc32_register_size
);
3448 set_gdbarch_deprecated_register_virtual_type (gdbarch
, sparc32_register_virtual_type
);
3449 #ifdef SPARC32_CALL_DUMMY_ON_STACK
3450 set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch
, sizeof (call_dummy_32
));
3452 set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch
, 0);
3454 set_gdbarch_stack_align (gdbarch
, sparc32_stack_align
);
3455 set_gdbarch_deprecated_extra_stack_alignment_needed (gdbarch
, 1);
3456 set_gdbarch_deprecated_store_struct_return (gdbarch
, sparc32_store_struct_return
);
3457 set_gdbarch_use_struct_convention (gdbarch
,
3458 generic_use_struct_convention
);
3459 set_gdbarch_deprecated_dummy_write_sp (gdbarch
, deprecated_write_sp
);
3460 tdep
->y_regnum
= SPARC32_Y_REGNUM
;
3461 tdep
->fp_max_regnum
= SPARC_FP0_REGNUM
+ 32;
3462 tdep
->intreg_size
= 4;
3463 tdep
->reg_save_offset
= 0x60;
3464 tdep
->call_dummy_call_offset
= 0x24;
3467 case bfd_mach_sparc_v9
:
3468 case bfd_mach_sparc_v9a
:
3469 /* 64-bit machine types: */
3470 default: /* Any new machine type is likely to be 64-bit. */
3472 #ifdef SPARC64_CALL_DUMMY_ON_STACK
3473 set_gdbarch_deprecated_pc_in_call_dummy (gdbarch
, deprecated_pc_in_call_dummy_on_stack
);
3474 set_gdbarch_call_dummy_address (gdbarch
, sparc_call_dummy_address
);
3475 set_gdbarch_deprecated_call_dummy_breakpoint_offset (gdbarch
, 8 * 4);
3476 set_gdbarch_deprecated_call_dummy_length (gdbarch
, 192);
3477 set_gdbarch_call_dummy_location (gdbarch
, ON_STACK
);
3478 set_gdbarch_deprecated_call_dummy_start_offset (gdbarch
, 148);
3479 set_gdbarch_deprecated_call_dummy_words (gdbarch
, call_dummy_64
);
3481 set_gdbarch_deprecated_pc_in_call_dummy (gdbarch
, deprecated_pc_in_call_dummy_at_entry_point
);
3482 set_gdbarch_deprecated_call_dummy_words (gdbarch
, call_dummy_nil
);
3484 set_gdbarch_deprecated_call_dummy_stack_adjust (gdbarch
, 128);
3485 set_gdbarch_frame_args_skip (gdbarch
, 136);
3486 set_gdbarch_function_start_offset (gdbarch
, 0);
3487 set_gdbarch_long_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
3488 set_gdbarch_npc_regnum (gdbarch
, SPARC64_NPC_REGNUM
);
3489 set_gdbarch_pc_regnum (gdbarch
, SPARC64_PC_REGNUM
);
3490 set_gdbarch_ptr_bit (gdbarch
, 8 * TARGET_CHAR_BIT
);
3491 set_gdbarch_deprecated_push_arguments (gdbarch
, sparc64_push_arguments
);
3492 /* NOTE different for at_entry */
3493 set_gdbarch_deprecated_target_read_fp (gdbarch
, sparc64_read_fp
);
3494 set_gdbarch_read_sp (gdbarch
, sparc64_read_sp
);
3495 /* Some of the registers aren't 64 bits, but it's a lot simpler just
3496 to assume they all are (since most of them are). */
3497 set_gdbarch_deprecated_register_byte (gdbarch
, sparc64_register_byte
);
3498 set_gdbarch_deprecated_register_raw_size (gdbarch
, sparc64_register_size
);
3499 set_gdbarch_deprecated_register_size (gdbarch
, 8);
3500 set_gdbarch_deprecated_register_virtual_size (gdbarch
, sparc64_register_size
);
3501 set_gdbarch_deprecated_register_virtual_type (gdbarch
, sparc64_register_virtual_type
);
3502 #ifdef SPARC64_CALL_DUMMY_ON_STACK
3503 set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch
, sizeof (call_dummy_64
));
3505 set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch
, 0);
3507 set_gdbarch_stack_align (gdbarch
, sparc64_stack_align
);
3508 set_gdbarch_deprecated_extra_stack_alignment_needed (gdbarch
, 1);
3509 set_gdbarch_deprecated_store_struct_return (gdbarch
, sparc64_store_struct_return
);
3510 set_gdbarch_use_struct_convention (gdbarch
,
3511 sparc64_use_struct_convention
);
3512 set_gdbarch_deprecated_dummy_write_sp (gdbarch
, sparc64_write_sp
);
3513 tdep
->y_regnum
= SPARC64_Y_REGNUM
;
3514 tdep
->fp_max_regnum
= SPARC_FP0_REGNUM
+ 48;
3515 tdep
->intreg_size
= 8;
3516 tdep
->reg_save_offset
= 0x90;
3517 tdep
->call_dummy_call_offset
= 148 + 4 * 5;
3522 * Settings that vary per-architecture:
3525 switch (info
.bfd_arch_info
->mach
)
3527 case bfd_mach_sparc
:
3528 set_gdbarch_extract_return_value (gdbarch
, sparc32_extract_return_value
);
3529 set_gdbarch_store_return_value (gdbarch
, sparc32_store_return_value
);
3530 set_gdbarch_num_regs (gdbarch
, 72);
3531 set_gdbarch_deprecated_register_bytes (gdbarch
, 32*4 + 32*4 + 8*4);
3532 set_gdbarch_register_name (gdbarch
, sparc32_register_name
);
3534 // OBSOLETE tdep->has_fpu = 1; /* (all but sparclet and sparclite) */
3536 tdep
->fp_register_bytes
= 32 * 4;
3537 tdep
->print_insn_mach
= bfd_mach_sparc
;
3540 // OBSOLETE case bfd_mach_sparc_sparclet:
3541 // OBSOLETE set_gdbarch_deprecated_extract_return_value (gdbarch, sparclet_extract_return_value);
3542 // OBSOLETE set_gdbarch_num_regs (gdbarch, 32 + 32 + 8 + 8 + 8);
3543 // OBSOLETE set_gdbarch_register_bytes (gdbarch, 32*4 + 32*4 + 8*4 + 8*4 + 8*4);
3544 // OBSOLETE set_gdbarch_register_name (gdbarch, sparclet_register_name);
3545 // OBSOLETE set_gdbarch_deprecated_store_return_value (gdbarch, sparclet_store_return_value);
3546 // OBSOLETE tdep->has_fpu = 0; /* (all but sparclet and sparclite) */
3547 // OBSOLETE tdep->fp_register_bytes = 0;
3548 // OBSOLETE tdep->print_insn_mach = bfd_mach_sparc_sparclet;
3552 // OBSOLETE case bfd_mach_sparc_sparclite:
3553 // OBSOLETE set_gdbarch_deprecated_extract_return_value (gdbarch, sparc32_extract_return_value);
3554 // OBSOLETE set_gdbarch_num_regs (gdbarch, 80);
3555 // OBSOLETE set_gdbarch_register_bytes (gdbarch, 32*4 + 32*4 + 8*4 + 8*4);
3556 // OBSOLETE set_gdbarch_register_name (gdbarch, sparclite_register_name);
3557 // OBSOLETE set_gdbarch_deprecated_store_return_value (gdbarch, sparc_store_return_value);
3558 // OBSOLETE tdep->has_fpu = 0; /* (all but sparclet and sparclite) */
3559 // OBSOLETE tdep->fp_register_bytes = 0;
3560 // OBSOLETE tdep->print_insn_mach = bfd_mach_sparc_sparclite;
3563 case bfd_mach_sparc_v8plus
:
3564 set_gdbarch_extract_return_value (gdbarch
, sparc32_extract_return_value
);
3565 set_gdbarch_store_return_value (gdbarch
, sparc32_store_return_value
);
3566 set_gdbarch_num_regs (gdbarch
, 72);
3567 set_gdbarch_deprecated_register_bytes (gdbarch
, 32*4 + 32*4 + 8*4);
3568 set_gdbarch_register_name (gdbarch
, sparc32_register_name
);
3569 tdep
->print_insn_mach
= bfd_mach_sparc
;
3570 tdep
->fp_register_bytes
= 32 * 4;
3572 // OBSOLETE tdep->has_fpu = 1; /* (all but sparclet and sparclite) */
3575 case bfd_mach_sparc_v8plusa
:
3576 set_gdbarch_extract_return_value (gdbarch
, sparc32_extract_return_value
);
3577 set_gdbarch_store_return_value (gdbarch
, sparc32_store_return_value
);
3578 set_gdbarch_num_regs (gdbarch
, 72);
3579 set_gdbarch_deprecated_register_bytes (gdbarch
, 32*4 + 32*4 + 8*4);
3580 set_gdbarch_register_name (gdbarch
, sparc32_register_name
);
3582 // OBSOLETE tdep->has_fpu = 1; /* (all but sparclet and sparclite) */
3584 tdep
->fp_register_bytes
= 32 * 4;
3585 tdep
->print_insn_mach
= bfd_mach_sparc
;
3588 // OBSOLETE case bfd_mach_sparc_sparclite_le:
3589 // OBSOLETE set_gdbarch_deprecated_extract_return_value (gdbarch, sparc32_extract_return_value);
3590 // OBSOLETE set_gdbarch_num_regs (gdbarch, 80);
3591 // OBSOLETE set_gdbarch_register_bytes (gdbarch, 32*4 + 32*4 + 8*4 + 8*4);
3592 // OBSOLETE set_gdbarch_register_name (gdbarch, sparclite_register_name);
3593 // OBSOLETE set_gdbarch_deprecated_store_return_value (gdbarch, sparc_store_return_value);
3594 // OBSOLETE tdep->has_fpu = 0; /* (all but sparclet and sparclite) */
3595 // OBSOLETE tdep->fp_register_bytes = 0;
3596 // OBSOLETE tdep->print_insn_mach = bfd_mach_sparc_sparclite;
3599 case bfd_mach_sparc_v9
:
3600 set_gdbarch_deprecated_extract_return_value (gdbarch
, sparc64_extract_return_value
);
3601 set_gdbarch_num_regs (gdbarch
, 125);
3602 set_gdbarch_deprecated_register_bytes (gdbarch
, 32*8 + 32*8 + 45*8);
3603 set_gdbarch_register_name (gdbarch
, sparc64_register_name
);
3604 set_gdbarch_deprecated_store_return_value (gdbarch
, sparc_store_return_value
);
3606 // OBSOLETE tdep->has_fpu = 1; /* (all but sparclet and sparclite) */
3608 tdep
->fp_register_bytes
= 64 * 4;
3609 tdep
->print_insn_mach
= bfd_mach_sparc_v9a
;
3611 case bfd_mach_sparc_v9a
:
3612 set_gdbarch_deprecated_extract_return_value (gdbarch
, sparc64_extract_return_value
);
3613 set_gdbarch_num_regs (gdbarch
, 125);
3614 set_gdbarch_deprecated_register_bytes (gdbarch
, 32*8 + 32*8 + 45*8);
3615 set_gdbarch_register_name (gdbarch
, sparc64_register_name
);
3616 set_gdbarch_deprecated_store_return_value (gdbarch
, sparc_store_return_value
);
3618 // OBSOLETE tdep->has_fpu = 1; /* (all but sparclet and sparclite) */
3620 tdep
->fp_register_bytes
= 64 * 4;
3621 tdep
->print_insn_mach
= bfd_mach_sparc_v9a
;
3625 /* Hook in OS ABI-specific overrides, if they have been registered. */
3626 gdbarch_init_osabi (info
, gdbarch
);
3632 sparc_dump_tdep (struct gdbarch
*current_gdbarch
, struct ui_file
*file
)
3634 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
3640 // OBSOLETE fprintf_unfiltered (file, "sparc_dump_tdep: has_fpu = %d\n",
3641 // OBSOLETE tdep->has_fpu);
3643 fprintf_unfiltered (file
, "sparc_dump_tdep: fp_register_bytes = %d\n",
3644 tdep
->fp_register_bytes
);
3645 fprintf_unfiltered (file
, "sparc_dump_tdep: y_regnum = %d\n",
3647 fprintf_unfiltered (file
, "sparc_dump_tdep: fp_max_regnum = %d\n",
3648 tdep
->fp_max_regnum
);
3649 fprintf_unfiltered (file
, "sparc_dump_tdep: intreg_size = %d\n",
3651 fprintf_unfiltered (file
, "sparc_dump_tdep: reg_save_offset = %d\n",
3652 tdep
->reg_save_offset
);
3653 fprintf_unfiltered (file
, "sparc_dump_tdep: call_dummy_call_offset = %d\n",
3654 tdep
->call_dummy_call_offset
);
3655 fprintf_unfiltered (file
, "sparc_dump_tdep: print_insn_match = %d\n",
3656 tdep
->print_insn_mach
);