1 /* Target-dependent code for the SPARC for GDB, the GNU debugger.
3 Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation,
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
24 /* ??? Support for calling functions from gdb in sparc64 is unfinished. */
27 #include "arch-utils.h"
33 #include "gdb_string.h"
38 #include "sparc-tdep.h"
41 #include <sys/procfs.h>
42 /* Prototypes for supply_gregset etc. */
47 #include "gdb_assert.h"
49 #include "symfile.h" /* for 'entry_point_address' */
52 * Some local macros that have multi-arch and non-multi-arch versions:
56 // OBSOLETE /* Does the target have Floating Point registers? */
57 // OBSOLETE #define SPARC_HAS_FPU (gdbarch_tdep (current_gdbarch)->has_fpu)
59 #define SPARC_HAS_FPU 1
60 /* Number of bytes devoted to Floating Point registers: */
61 #define FP_REGISTER_BYTES (gdbarch_tdep (current_gdbarch)->fp_register_bytes)
62 /* Highest numbered Floating Point register. */
63 #define FP_MAX_REGNUM (gdbarch_tdep (current_gdbarch)->fp_max_regnum)
64 /* Size of a general (integer) register: */
65 #define SPARC_INTREG_SIZE (gdbarch_tdep (current_gdbarch)->intreg_size)
66 /* Offset within the call dummy stack of the saved registers. */
67 #define DUMMY_REG_SAVE_OFFSET (gdbarch_tdep (current_gdbarch)->reg_save_offset)
72 // OBSOLETE int has_fpu;
74 int fp_register_bytes;
79 int call_dummy_call_offset;
83 /* Now make GDB_TARGET_IS_SPARC64 a runtime test. */
84 /* FIXME MVS: or try testing bfd_arch_info.arch and bfd_arch_info.mach ...
85 * define GDB_TARGET_IS_SPARC64 \
86 * (TARGET_ARCHITECTURE->arch == bfd_arch_sparc && \
87 * (TARGET_ARCHITECTURE->mach == bfd_mach_sparc_v9 || \
88 * TARGET_ARCHITECTURE->mach == bfd_mach_sparc_v9a))
91 /* We don't store all registers immediately when requested, since they
92 get sent over in large chunks anyway. Instead, we accumulate most
93 of the changes and send them over once. "deferred_stores" keeps
94 track of which sets of registers we have locally-changed copies of,
95 so we only need send the groups that have changed. */
97 int deferred_stores = 0; /* Accumulated stores we want to do eventually. */
101 // OBSOLETE /* Some machines, such as Fujitsu SPARClite 86x, have a bi-endian mode
102 // OBSOLETE where instructions are big-endian and data are little-endian.
103 // OBSOLETE This flag is set when we detect that the target is of this type. */
105 // OBSOLETE int bi_endian = 0;
109 const unsigned char *
110 sparc_breakpoint_from_pc (CORE_ADDR *pc, int *len)
112 static const char breakpoint[] = {0x91, 0xd0, 0x20, 0x01};
113 (*len) = sizeof (breakpoint);
117 /* Fetch a single instruction. Even on bi-endian machines
118 such as sparc86x, instructions are always big-endian. */
121 fetch_instruction (CORE_ADDR pc)
123 unsigned long retval;
125 unsigned char buf[4];
127 read_memory (pc, buf, sizeof (buf));
129 /* Start at the most significant end of the integer, and work towards
130 the least significant. */
132 for (i = 0; i < sizeof (buf); ++i)
133 retval = (retval << 8) | buf[i];
138 /* Branches with prediction are treated like their non-predicting cousins. */
139 /* FIXME: What about floating point branches? */
141 /* Macros to extract fields from sparc instructions. */
142 #define X_OP(i) (((i) >> 30) & 0x3)
143 #define X_RD(i) (((i) >> 25) & 0x1f)
144 #define X_A(i) (((i) >> 29) & 1)
145 #define X_COND(i) (((i) >> 25) & 0xf)
146 #define X_OP2(i) (((i) >> 22) & 0x7)
147 #define X_IMM22(i) ((i) & 0x3fffff)
148 #define X_OP3(i) (((i) >> 19) & 0x3f)
149 #define X_RS1(i) (((i) >> 14) & 0x1f)
150 #define X_I(i) (((i) >> 13) & 1)
151 #define X_IMM13(i) ((i) & 0x1fff)
152 /* Sign extension macros. */
153 #define X_SIMM13(i) ((X_IMM13 (i) ^ 0x1000) - 0x1000)
154 #define X_DISP22(i) ((X_IMM22 (i) ^ 0x200000) - 0x200000)
155 #define X_CC(i) (((i) >> 20) & 3)
156 #define X_P(i) (((i) >> 19) & 1)
157 #define X_DISP19(i) ((((i) & 0x7ffff) ^ 0x40000) - 0x40000)
158 #define X_RCOND(i) (((i) >> 25) & 7)
159 #define X_DISP16(i) ((((((i) >> 6) && 0xc000) | ((i) & 0x3fff)) ^ 0x8000) - 0x8000)
160 #define X_FCN(i) (((i) >> 25) & 31)
164 Error, not_branch, bicc, bicca, ba, baa, ticc, ta, done_retry
167 /* Simulate single-step ptrace call for sun4. Code written by Gary
168 Beihl (beihl@mcc.com). */
170 /* npc4 and next_pc describe the situation at the time that the
171 step-breakpoint was set, not necessary the current value of NPC_REGNUM. */
172 static CORE_ADDR next_pc, npc4, target;
173 static int brknpc4, brktrg;
174 typedef char binsn_quantum[BREAKPOINT_MAX];
175 static binsn_quantum break_mem[3];
177 static branch_type isbranch (long, CORE_ADDR, CORE_ADDR *);
179 /* single_step() is called just before we want to resume the inferior,
180 if we want to single-step it but there is no hardware or kernel single-step
181 support (as on all SPARCs). We find all the possible targets of the
182 coming instruction and breakpoint them.
184 single_step is also called just after the inferior stops. If we had
185 set up a simulated single-step, we undo our damage. */
188 sparc_software_single_step (enum target_signal ignore, /* pid, but we don't need it */
189 int insert_breakpoints_p)
195 if (insert_breakpoints_p)
197 /* Always set breakpoint for NPC. */
198 next_pc = read_register (NPC_REGNUM);
199 npc4 = next_pc + 4; /* branch not taken */
201 target_insert_breakpoint (next_pc, break_mem[0]);
202 /* printf_unfiltered ("set break at %x\n",next_pc); */
204 pc = read_register (PC_REGNUM);
205 pc_instruction = fetch_instruction (pc);
206 br = isbranch (pc_instruction, pc, &target);
207 brknpc4 = brktrg = 0;
211 /* Conditional annulled branch will either end up at
212 npc (if taken) or at npc+4 (if not taken).
215 target_insert_breakpoint (npc4, break_mem[1]);
217 else if (br == baa && target != next_pc)
219 /* Unconditional annulled branch will always end up at
222 target_insert_breakpoint (target, break_mem[2]);
224 else if (GDB_TARGET_IS_SPARC64 && br == done_retry)
227 target_insert_breakpoint (target, break_mem[2]);
232 /* Remove breakpoints */
233 target_remove_breakpoint (next_pc, break_mem[0]);
236 target_remove_breakpoint (npc4, break_mem[1]);
239 target_remove_breakpoint (target, break_mem[2]);
243 struct frame_extra_info
248 /* Following fields only relevant for flat frames. */
251 /* Add this to ->frame to get the value of the stack pointer at the
252 time of the register saves. */
256 /* Call this for each newly created frame. For SPARC, we need to
257 calculate the bottom of the frame, and do some extra work if the
258 prologue has been generated via the -mflat option to GCC. In
259 particular, we need to know where the previous fp and the pc have
260 been stashed, since their exact position within the frame may vary. */
263 sparc_init_extra_frame_info (int fromleaf, struct frame_info *fi)
266 CORE_ADDR prologue_start, prologue_end;
269 frame_extra_info_zalloc (fi, sizeof (struct frame_extra_info));
270 frame_saved_regs_zalloc (fi);
272 get_frame_extra_info (fi)->bottom =
274 ? (get_frame_base (fi) == get_frame_base (get_next_frame (fi))
275 ? get_frame_extra_info (get_next_frame (fi))->bottom
276 : get_frame_base (get_next_frame (fi)))
279 /* If fi->next is NULL, then we already set ->frame by passing
280 deprecated_read_fp() to create_new_frame. */
281 if (get_next_frame (fi))
283 char buf[MAX_REGISTER_SIZE];
285 /* Compute ->frame as if not flat. If it is flat, we'll change
287 if (get_next_frame (get_next_frame (fi)) != NULL
288 && ((get_frame_type (get_next_frame (get_next_frame (fi))) == SIGTRAMP_FRAME)
289 || deprecated_frame_in_dummy (get_next_frame (get_next_frame (fi))))
290 && frameless_look_for_prologue (get_next_frame (fi)))
292 /* A frameless function interrupted by a signal did not change
293 the frame pointer, fix up frame pointer accordingly. */
294 deprecated_update_frame_base_hack (fi, get_frame_base (get_next_frame (fi)));
295 get_frame_extra_info (fi)->bottom =
296 get_frame_extra_info (get_next_frame (fi))->bottom;
300 /* Should we adjust for stack bias here? */
302 frame_read_unsigned_register (fi, DEPRECATED_FP_REGNUM, &tmp);
303 deprecated_update_frame_base_hack (fi, tmp);
304 if (GDB_TARGET_IS_SPARC64 && (get_frame_base (fi) & 1))
305 deprecated_update_frame_base_hack (fi, get_frame_base (fi) + 2047);
309 /* Decide whether this is a function with a ``flat register window''
310 frame. For such functions, the frame pointer is actually in %i7. */
311 get_frame_extra_info (fi)->flat = 0;
312 get_frame_extra_info (fi)->in_prologue = 0;
313 if (find_pc_partial_function (get_frame_pc (fi), &name, &prologue_start, &prologue_end))
315 /* See if the function starts with an add (which will be of a
316 negative number if a flat frame) to the sp. FIXME: Does not
317 handle large frames which will need more than one instruction
319 insn = fetch_instruction (prologue_start);
320 if (X_OP (insn) == 2 && X_RD (insn) == 14 && X_OP3 (insn) == 0
321 && X_I (insn) && X_SIMM13 (insn) < 0)
323 int offset = X_SIMM13 (insn);
325 /* Then look for a save of %i7 into the frame. */
326 insn = fetch_instruction (prologue_start + 4);
330 && X_RS1 (insn) == 14)
332 char buf[MAX_REGISTER_SIZE];
334 /* We definitely have a flat frame now. */
335 get_frame_extra_info (fi)->flat = 1;
337 get_frame_extra_info (fi)->sp_offset = offset;
339 /* Overwrite the frame's address with the value in %i7. */
342 frame_read_unsigned_register (fi, I7_REGNUM, &tmp);
343 deprecated_update_frame_base_hack (fi, tmp);
346 if (GDB_TARGET_IS_SPARC64 && (get_frame_base (fi) & 1))
347 deprecated_update_frame_base_hack (fi, get_frame_base (fi) + 2047);
349 /* Record where the fp got saved. */
350 get_frame_extra_info (fi)->fp_addr =
351 get_frame_base (fi) + get_frame_extra_info (fi)->sp_offset + X_SIMM13 (insn);
353 /* Also try to collect where the pc got saved to. */
354 get_frame_extra_info (fi)->pc_addr = 0;
355 insn = fetch_instruction (prologue_start + 12);
359 && X_RS1 (insn) == 14)
360 get_frame_extra_info (fi)->pc_addr =
361 get_frame_base (fi) + get_frame_extra_info (fi)->sp_offset + X_SIMM13 (insn);
366 /* Check if the PC is in the function prologue before a SAVE
367 instruction has been executed yet. If so, set the frame
368 to the current value of the stack pointer and set
369 the in_prologue flag. */
371 struct symtab_and_line sal;
373 sal = find_pc_line (prologue_start, 0);
374 if (sal.line == 0) /* no line info, use PC */
375 prologue_end = get_frame_pc (fi);
376 else if (sal.end < prologue_end)
377 prologue_end = sal.end;
378 if (get_frame_pc (fi) < prologue_end)
380 for (addr = prologue_start; addr < get_frame_pc (fi); addr += 4)
382 insn = read_memory_integer (addr, 4);
383 if (X_OP (insn) == 2 && X_OP3 (insn) == 0x3c)
384 break; /* SAVE seen, stop searching */
386 if (addr >= get_frame_pc (fi))
388 get_frame_extra_info (fi)->in_prologue = 1;
389 deprecated_update_frame_base_hack (fi, read_register (SP_REGNUM));
394 if (get_next_frame (fi) && get_frame_base (fi) == 0)
396 /* Kludge to cause init_prev_frame_info to destroy the new frame. */
397 deprecated_update_frame_base_hack (fi, get_frame_base (get_next_frame (fi)));
398 deprecated_update_frame_pc_hack (fi, get_frame_pc (get_next_frame (fi)));
403 sparc_frame_chain (struct frame_info *frame)
405 /* Value that will cause DEPRECATED_FRAME_CHAIN_VALID to not worry
406 about the chain value. If it really is zero, we detect it later
407 in sparc_init_prev_frame.
409 Note: kevinb/2003-02-18: The constant 1 used to be returned here,
410 but, after some recent changes to legacy_frame_chain_valid(),
411 this value is no longer suitable for causing
412 legacy_frame_chain_valid() to "not worry about the chain value."
413 The constant ~0 (i.e, 0xfff...) causes the failing test in
414 legacy_frame_chain_valid() to succeed thus preserving the "not
415 worry" property. I had considered using something like
416 ``get_frame_base (frame) + 1''. However, I think a constant
417 value is better, because when debugging this problem, I knew that
418 something funny was going on as soon as I saw the constant 1
419 being used as the frame chain elsewhere in GDB. */
421 return ~ (CORE_ADDR) 0;
424 /* Find the pc saved in frame FRAME. */
427 sparc_frame_saved_pc (struct frame_info *frame)
429 char buf[MAX_REGISTER_SIZE];
432 if ((get_frame_type (frame) == SIGTRAMP_FRAME))
434 /* This is the signal trampoline frame.
435 Get the saved PC from the sigcontext structure. */
437 #ifndef SIGCONTEXT_PC_OFFSET
438 #define SIGCONTEXT_PC_OFFSET 12
441 CORE_ADDR sigcontext_addr;
443 int saved_pc_offset = SIGCONTEXT_PC_OFFSET;
446 scbuf = alloca (TARGET_PTR_BIT / HOST_CHAR_BIT);
448 /* Solaris2 ucbsigvechandler passes a pointer to a sigcontext
449 as the third parameter. The offset to the saved pc is 12. */
450 find_pc_partial_function (get_frame_pc (frame), &name,
451 (CORE_ADDR *) NULL, (CORE_ADDR *) NULL);
452 if (name && STREQ (name, "ucbsigvechandler"))
453 saved_pc_offset = 12;
455 /* The sigcontext address is contained in register O2. */
458 frame_read_unsigned_register (frame, O0_REGNUM + 2, &tmp);
459 sigcontext_addr = tmp;
462 /* Don't cause a memory_error when accessing sigcontext in case the
463 stack layout has changed or the stack is corrupt. */
464 target_read_memory (sigcontext_addr + saved_pc_offset,
465 scbuf, sizeof (scbuf));
466 return extract_unsigned_integer (scbuf, sizeof (scbuf));
468 else if (get_frame_extra_info (frame)->in_prologue ||
469 (get_next_frame (frame) != NULL &&
470 ((get_frame_type (get_next_frame (frame)) == SIGTRAMP_FRAME) ||
471 deprecated_frame_in_dummy (get_next_frame (frame))) &&
472 frameless_look_for_prologue (frame)))
474 /* A frameless function interrupted by a signal did not save
475 the PC, it is still in %o7. */
477 frame_read_unsigned_register (frame, O7_REGNUM, &tmp);
478 return PC_ADJUST (tmp);
480 if (get_frame_extra_info (frame)->flat)
481 addr = get_frame_extra_info (frame)->pc_addr;
483 addr = get_frame_extra_info (frame)->bottom + FRAME_SAVED_I0 +
484 SPARC_INTREG_SIZE * (I7_REGNUM - I0_REGNUM);
487 /* A flat frame leaf function might not save the PC anywhere,
488 just leave it in %o7. */
489 return PC_ADJUST (read_register (O7_REGNUM));
491 read_memory (addr, buf, SPARC_INTREG_SIZE);
492 return PC_ADJUST (extract_unsigned_integer (buf, SPARC_INTREG_SIZE));
495 /* Since an individual frame in the frame cache is defined by two
496 arguments (a frame pointer and a stack pointer), we need two
497 arguments to get info for an arbitrary stack frame. This routine
498 takes two arguments and makes the cached frames look as if these
499 two arguments defined a frame on the cache. This allows the rest
500 of info frame to extract the important arguments without
504 setup_arbitrary_frame (int argc, CORE_ADDR *argv)
506 struct frame_info *frame;
509 error ("Sparc frame specifications require two arguments: fp and sp");
511 frame = create_new_frame (argv[0], 0);
514 internal_error (__FILE__, __LINE__,
515 "create_new_frame returned invalid frame");
517 get_frame_extra_info (frame)->bottom = argv[1];
518 deprecated_update_frame_pc_hack (frame, DEPRECATED_FRAME_SAVED_PC (frame));
522 /* Given a pc value, skip it forward past the function prologue by
523 disassembling instructions that appear to be a prologue.
525 If FRAMELESS_P is set, we are only testing to see if the function
526 is frameless. This allows a quicker answer.
528 This routine should be more specific in its actions; making sure
529 that it uses the same register in the initial prologue section. */
531 static CORE_ADDR examine_prologue (CORE_ADDR, int, struct frame_info *,
535 examine_prologue (CORE_ADDR start_pc, int frameless_p, struct frame_info *fi,
536 CORE_ADDR *saved_regs)
540 CORE_ADDR pc = start_pc;
543 insn = fetch_instruction (pc);
545 /* Recognize the `sethi' insn and record its destination. */
546 if (X_OP (insn) == 0 && X_OP2 (insn) == 4)
550 insn = fetch_instruction (pc);
553 /* Recognize an add immediate value to register to either %g1 or
554 the destination register recorded above. Actually, this might
555 well recognize several different arithmetic operations.
556 It doesn't check that rs1 == rd because in theory "sub %g0, 5, %g1"
557 followed by "save %sp, %g1, %sp" is a valid prologue (Not that
558 I imagine any compiler really does that, however). */
561 && (X_RD (insn) == 1 || X_RD (insn) == dest))
564 insn = fetch_instruction (pc);
567 /* Recognize any SAVE insn. */
568 if (X_OP (insn) == 2 && X_OP3 (insn) == 60)
571 if (frameless_p) /* If the save is all we care about, */
572 return pc; /* return before doing more work */
573 insn = fetch_instruction (pc);
575 /* Recognize add to %sp. */
576 else if (X_OP (insn) == 2 && X_RD (insn) == 14 && X_OP3 (insn) == 0)
579 if (frameless_p) /* If the add is all we care about, */
580 return pc; /* return before doing more work */
582 insn = fetch_instruction (pc);
583 /* Recognize store of frame pointer (i7). */
587 && X_RS1 (insn) == 14)
590 insn = fetch_instruction (pc);
592 /* Recognize sub %sp, <anything>, %i7. */
595 && X_RS1 (insn) == 14
596 && X_RD (insn) == 31)
599 insn = fetch_instruction (pc);
608 /* Without a save or add instruction, it's not a prologue. */
613 /* Recognize stores into the frame from the input registers.
614 This recognizes all non alternate stores of an input register,
615 into a location offset from the frame pointer between
618 /* The above will fail for arguments that are promoted
619 (eg. shorts to ints or floats to doubles), because the compiler
620 will pass them in positive-offset frame space, but the prologue
621 will save them (after conversion) in negative frame space at an
622 unpredictable offset. Therefore I am going to remove the
623 restriction on the target-address of the save, on the theory
624 that any unbroken sequence of saves from input registers must
625 be part of the prologue. In un-optimized code (at least), I'm
626 fairly sure that the compiler would emit SOME other instruction
627 (eg. a move or add) before emitting another save that is actually
628 a part of the function body.
630 Besides, the reserved stack space is different for SPARC64 anyway.
635 && (X_OP3 (insn) & 0x3c) == 4 /* Store, non-alternate. */
636 && (X_RD (insn) & 0x18) == 0x18 /* Input register. */
637 && X_I (insn) /* Immediate mode. */
638 && X_RS1 (insn) == 30) /* Off of frame pointer. */
639 ; /* empty statement -- fall thru to end of loop */
640 else if (GDB_TARGET_IS_SPARC64
642 && (X_OP3 (insn) & 0x3c) == 12 /* store, extended (64-bit) */
643 && (X_RD (insn) & 0x18) == 0x18 /* input register */
644 && X_I (insn) /* immediate mode */
645 && X_RS1 (insn) == 30) /* off of frame pointer */
646 ; /* empty statement -- fall thru to end of loop */
647 else if (X_OP (insn) == 3
648 && (X_OP3 (insn) & 0x3c) == 36 /* store, floating-point */
649 && X_I (insn) /* immediate mode */
650 && X_RS1 (insn) == 30) /* off of frame pointer */
651 ; /* empty statement -- fall thru to end of loop */
654 && X_OP3 (insn) == 4 /* store? */
655 && X_RS1 (insn) == 14) /* off of frame pointer */
657 if (saved_regs && X_I (insn))
658 saved_regs[X_RD (insn)] =
659 get_frame_base (fi) + get_frame_extra_info (fi)->sp_offset + X_SIMM13 (insn);
664 insn = fetch_instruction (pc);
670 /* Advance PC across any function entry prologue instructions to reach
674 sparc_skip_prologue (CORE_ADDR start_pc)
676 struct symtab_and_line sal;
677 CORE_ADDR func_start, func_end;
679 /* This is the preferred method, find the end of the prologue by
680 using the debugging information. */
681 if (find_pc_partial_function (start_pc, NULL, &func_start, &func_end))
683 sal = find_pc_line (func_start, 0);
685 if (sal.end < func_end
686 && start_pc <= sal.end)
690 /* Oh well, examine the code by hand. */
691 return examine_prologue (start_pc, 0, NULL, NULL);
694 /* Is the prologue at IP frameless? */
697 sparc_prologue_frameless_p (CORE_ADDR ip)
699 return ip == examine_prologue (ip, 1, NULL, NULL);
702 /* Check instruction at ADDR to see if it is a branch.
703 All non-annulled instructions will go to NPC or will trap.
704 Set *TARGET if we find a candidate branch; set to zero if not.
706 This isn't static as it's used by remote-sa.sparc.c. */
709 isbranch (long instruction, CORE_ADDR addr, CORE_ADDR *target)
711 branch_type val = not_branch;
712 long int offset = 0; /* Must be signed for sign-extend. */
716 if (X_OP (instruction) == 0
717 && (X_OP2 (instruction) == 2
718 || X_OP2 (instruction) == 6
719 || X_OP2 (instruction) == 1
720 || X_OP2 (instruction) == 3
721 || X_OP2 (instruction) == 5
722 || (GDB_TARGET_IS_SPARC64 && X_OP2 (instruction) == 7)))
724 if (X_COND (instruction) == 8)
725 val = X_A (instruction) ? baa : ba;
727 val = X_A (instruction) ? bicca : bicc;
728 switch (X_OP2 (instruction))
731 if (!GDB_TARGET_IS_SPARC64)
736 offset = 4 * X_DISP22 (instruction);
740 offset = 4 * X_DISP19 (instruction);
743 offset = 4 * X_DISP16 (instruction);
746 *target = addr + offset;
748 else if (GDB_TARGET_IS_SPARC64
749 && X_OP (instruction) == 2
750 && X_OP3 (instruction) == 62)
752 if (X_FCN (instruction) == 0)
755 *target = read_register (TNPC_REGNUM);
758 else if (X_FCN (instruction) == 1)
761 *target = read_register (TPC_REGNUM);
769 /* Find register number REGNUM relative to FRAME and put its
770 (raw) contents in *RAW_BUFFER. Set *OPTIMIZED if the variable
771 was optimized out (and thus can't be fetched). If the variable
772 was fetched from memory, set *ADDRP to where it was fetched from,
773 otherwise it was fetched from a register.
775 The argument RAW_BUFFER must point to aligned memory. */
778 sparc_get_saved_register (char *raw_buffer, int *optimized, CORE_ADDR *addrp,
779 struct frame_info *frame, int regnum,
780 enum lval_type *lval)
782 struct frame_info *frame1;
785 if (!target_has_registers)
786 error ("No registers.");
793 /* FIXME This code extracted from infcmd.c; should put elsewhere! */
796 /* error ("No selected frame."); */
797 if (!target_has_registers)
798 error ("The program has no registers now.");
799 if (deprecated_selected_frame == NULL)
800 error ("No selected frame.");
801 /* Try to use selected frame */
802 frame = get_prev_frame (deprecated_selected_frame);
804 error ("Cmd not meaningful in the outermost frame.");
808 frame1 = get_next_frame (frame);
810 /* Get saved PC from the frame info if not in innermost frame. */
811 if (regnum == PC_REGNUM && frame1 != NULL)
815 if (raw_buffer != NULL)
817 /* Put it back in target format. */
818 store_unsigned_integer (raw_buffer, REGISTER_RAW_SIZE (regnum), get_frame_pc (frame));
825 while (frame1 != NULL)
827 /* FIXME MVS: wrong test for dummy frame at entry. */
829 if (get_frame_pc (frame1) >= (get_frame_extra_info (frame1)->bottom
830 ? get_frame_extra_info (frame1)->bottom
832 && get_frame_pc (frame1) <= get_frame_base (frame1))
834 /* Dummy frame. All but the window regs are in there somewhere.
835 The window registers are saved on the stack, just like in a
837 if (regnum >= G1_REGNUM && regnum < G1_REGNUM + 7)
838 addr = get_frame_base (frame1) + (regnum - G0_REGNUM) * SPARC_INTREG_SIZE
839 - (FP_REGISTER_BYTES + 8 * SPARC_INTREG_SIZE);
840 else if (regnum >= I0_REGNUM && regnum < I0_REGNUM + 8)
841 /* NOTE: cagney/2002-05-04: The call to get_prev_frame()
842 is safe/cheap - there will always be a prev frame.
843 This is because frame1 is initialized to frame->next
844 (frame1->prev == frame) and is then advanced towards
845 the innermost (next) frame. */
846 addr = (get_frame_extra_info (get_prev_frame (frame1))->bottom
847 + (regnum - I0_REGNUM) * SPARC_INTREG_SIZE
849 else if (regnum >= L0_REGNUM && regnum < L0_REGNUM + 8)
850 /* NOTE: cagney/2002-05-04: The call to get_prev_frame()
851 is safe/cheap - there will always be a prev frame.
852 This is because frame1 is initialized to frame->next
853 (frame1->prev == frame) and is then advanced towards
854 the innermost (next) frame. */
855 addr = (get_frame_extra_info (get_prev_frame (frame1))->bottom
856 + (regnum - L0_REGNUM) * SPARC_INTREG_SIZE
858 else if (regnum >= O0_REGNUM && regnum < O0_REGNUM + 8)
859 addr = get_frame_base (frame1) + (regnum - O0_REGNUM) * SPARC_INTREG_SIZE
860 - (FP_REGISTER_BYTES + 16 * SPARC_INTREG_SIZE);
861 else if (SPARC_HAS_FPU &&
862 regnum >= FP0_REGNUM && regnum < FP0_REGNUM + 32)
863 addr = get_frame_base (frame1) + (regnum - FP0_REGNUM) * 4
864 - (FP_REGISTER_BYTES);
865 else if (GDB_TARGET_IS_SPARC64 && SPARC_HAS_FPU &&
866 regnum >= FP0_REGNUM + 32 && regnum < FP_MAX_REGNUM)
867 addr = get_frame_base (frame1) + 32 * 4 + (regnum - FP0_REGNUM - 32) * 8
868 - (FP_REGISTER_BYTES);
869 else if (regnum >= Y_REGNUM && regnum < NUM_REGS)
870 addr = get_frame_base (frame1) + (regnum - Y_REGNUM) * SPARC_INTREG_SIZE
871 - (FP_REGISTER_BYTES + 24 * SPARC_INTREG_SIZE);
873 else if (get_frame_extra_info (frame1)->flat)
876 if (regnum == RP_REGNUM)
877 addr = get_frame_extra_info (frame1)->pc_addr;
878 else if (regnum == I7_REGNUM)
879 addr = get_frame_extra_info (frame1)->fp_addr;
882 CORE_ADDR func_start;
885 regs = alloca (NUM_REGS * sizeof (CORE_ADDR));
886 memset (regs, 0, NUM_REGS * sizeof (CORE_ADDR));
888 find_pc_partial_function (get_frame_pc (frame1), NULL, &func_start, NULL);
889 examine_prologue (func_start, 0, frame1, regs);
895 /* Normal frame. Local and In registers are saved on stack. */
896 if (regnum >= I0_REGNUM && regnum < I0_REGNUM + 8)
897 addr = (get_frame_extra_info (get_prev_frame (frame1))->bottom
898 + (regnum - I0_REGNUM) * SPARC_INTREG_SIZE
900 else if (regnum >= L0_REGNUM && regnum < L0_REGNUM + 8)
901 addr = (get_frame_extra_info (get_prev_frame (frame1))->bottom
902 + (regnum - L0_REGNUM) * SPARC_INTREG_SIZE
904 else if (regnum >= O0_REGNUM && regnum < O0_REGNUM + 8)
906 /* Outs become ins. */
908 frame_register (frame1, (regnum - O0_REGNUM + I0_REGNUM),
909 optimized, lval, addrp, &realnum, raw_buffer);
915 frame1 = get_next_frame (frame1);
921 if (regnum == SP_REGNUM)
923 if (raw_buffer != NULL)
925 /* Put it back in target format. */
926 store_unsigned_integer (raw_buffer, REGISTER_RAW_SIZE (regnum), addr);
932 if (raw_buffer != NULL)
933 read_memory (addr, raw_buffer, REGISTER_RAW_SIZE (regnum));
938 *lval = lval_register;
939 addr = REGISTER_BYTE (regnum);
940 if (raw_buffer != NULL)
941 deprecated_read_register_gen (regnum, raw_buffer);
947 /* Push an empty stack frame, and record in it the current PC, regs, etc.
949 We save the non-windowed registers and the ins. The locals and outs
950 are new; they don't need to be saved. The i's and l's of
951 the last frame were already saved on the stack. */
953 /* Definitely see tm-sparc.h for more doc of the frame format here. */
955 /* See tm-sparc.h for how this is calculated. */
957 #define DUMMY_STACK_REG_BUF_SIZE \
958 (((8+8+8) * SPARC_INTREG_SIZE) + FP_REGISTER_BYTES)
959 #define DUMMY_STACK_SIZE \
960 (DUMMY_STACK_REG_BUF_SIZE + DUMMY_REG_SAVE_OFFSET)
963 sparc_push_dummy_frame (void)
965 CORE_ADDR sp, old_sp;
968 register_temp = alloca (DUMMY_STACK_SIZE);
970 old_sp = sp = read_sp ();
972 if (GDB_TARGET_IS_SPARC64)
974 /* PC, NPC, CCR, FSR, FPRS, Y, ASI */
975 deprecated_read_register_bytes (REGISTER_BYTE (PC_REGNUM),
977 REGISTER_RAW_SIZE (PC_REGNUM) * 7);
978 deprecated_read_register_bytes (REGISTER_BYTE (PSTATE_REGNUM),
979 ®ister_temp[7 * SPARC_INTREG_SIZE],
980 REGISTER_RAW_SIZE (PSTATE_REGNUM));
981 /* FIXME: not sure what needs to be saved here. */
985 /* Y, PS, WIM, TBR, PC, NPC, FPS, CPS regs */
986 deprecated_read_register_bytes (REGISTER_BYTE (Y_REGNUM),
988 REGISTER_RAW_SIZE (Y_REGNUM) * 8);
991 deprecated_read_register_bytes (REGISTER_BYTE (O0_REGNUM),
992 ®ister_temp[8 * SPARC_INTREG_SIZE],
993 SPARC_INTREG_SIZE * 8);
995 deprecated_read_register_bytes (REGISTER_BYTE (G0_REGNUM),
996 ®ister_temp[16 * SPARC_INTREG_SIZE],
997 SPARC_INTREG_SIZE * 8);
1000 deprecated_read_register_bytes (REGISTER_BYTE (FP0_REGNUM),
1001 ®ister_temp[24 * SPARC_INTREG_SIZE],
1004 sp -= DUMMY_STACK_SIZE;
1006 DEPRECATED_DUMMY_WRITE_SP (sp);
1008 write_memory (sp + DUMMY_REG_SAVE_OFFSET, ®ister_temp[0],
1009 DUMMY_STACK_REG_BUF_SIZE);
1011 if (strcmp (target_shortname, "sim") != 0)
1013 /* NOTE: cagney/2002-04-04: The code below originally contained
1014 GDB's _only_ call to write_fp(). That call was eliminated by
1015 inlining the corresponding code. For the 64 bit case, the
1016 old function (sparc64_write_fp) did the below although I'm
1017 not clear why. The same goes for why this is only done when
1018 the underlying target is a simulator. */
1019 if (GDB_TARGET_IS_SPARC64)
1021 /* Target is a 64 bit SPARC. */
1022 CORE_ADDR oldfp = read_register (DEPRECATED_FP_REGNUM);
1024 write_register (DEPRECATED_FP_REGNUM, old_sp - 2047);
1026 write_register (DEPRECATED_FP_REGNUM, old_sp);
1030 /* Target is a 32 bit SPARC. */
1031 write_register (DEPRECATED_FP_REGNUM, old_sp);
1033 /* Set return address register for the call dummy to the current PC. */
1034 write_register (I7_REGNUM, read_pc () - 8);
1038 /* The call dummy will write this value to FP before executing
1039 the 'save'. This ensures that register window flushes work
1040 correctly in the simulator. */
1041 write_register (G0_REGNUM + 1, read_register (DEPRECATED_FP_REGNUM));
1043 /* The call dummy will write this value to FP after executing
1045 write_register (G0_REGNUM + 2, old_sp);
1047 /* The call dummy will write this value to the return address (%i7) after
1048 executing the 'save'. */
1049 write_register (G0_REGNUM + 3, read_pc () - 8);
1051 /* Set the FP that the call dummy will be using after the 'save'.
1052 This makes backtraces from an inferior function call work properly. */
1053 write_register (DEPRECATED_FP_REGNUM, old_sp);
1057 /* sparc_frame_find_saved_regs (). This function is here only because
1058 pop_frame uses it. Note there is an interesting corner case which
1059 I think few ports of GDB get right--if you are popping a frame
1060 which does not save some register that *is* saved by a more inner
1061 frame (such a frame will never be a dummy frame because dummy
1062 frames save all registers).
1064 NOTE: cagney/2003-03-12: Since pop_frame has been rewritten to use
1065 frame_unwind_register() the need for this function is questionable.
1067 Stores, into an array of CORE_ADDR,
1068 the addresses of the saved registers of frame described by FRAME_INFO.
1069 This includes special registers such as pc and fp saved in special
1070 ways in the stack frame. sp is even more special:
1071 the address we return for it IS the sp for the next frame.
1073 Note that on register window machines, we are currently making the
1074 assumption that window registers are being saved somewhere in the
1075 frame in which they are being used. If they are stored in an
1076 inferior frame, find_saved_register will break.
1078 On the Sun 4, the only time all registers are saved is when
1079 a dummy frame is involved. Otherwise, the only saved registers
1080 are the LOCAL and IN registers which are saved as a result
1081 of the "save/restore" opcodes. This condition is determined
1082 by address rather than by value.
1084 The "pc" is not stored in a frame on the SPARC. (What is stored
1085 is a return address minus 8.) sparc_pop_frame knows how to
1086 deal with that. Other routines might or might not.
1088 See tm-sparc.h (PUSH_DUMMY_FRAME and friends) for CRITICAL information
1089 about how this works. */
1091 static void sparc_frame_find_saved_regs (struct frame_info *, CORE_ADDR *);
1094 sparc_frame_find_saved_regs (struct frame_info *fi, CORE_ADDR *saved_regs_addr)
1096 register int regnum;
1097 CORE_ADDR frame_addr = get_frame_base (fi);
1099 gdb_assert (fi != NULL);
1101 memset (saved_regs_addr, 0, NUM_REGS * sizeof (CORE_ADDR));
1103 if (get_frame_pc (fi) >= (get_frame_extra_info (fi)->bottom
1104 ? get_frame_extra_info (fi)->bottom
1106 && get_frame_pc (fi) <= get_frame_base (fi))
1108 /* Dummy frame. All but the window regs are in there somewhere. */
1109 for (regnum = G1_REGNUM; regnum < G1_REGNUM + 7; regnum++)
1110 saved_regs_addr[regnum] =
1111 frame_addr + (regnum - G0_REGNUM) * SPARC_INTREG_SIZE
1112 - DUMMY_STACK_REG_BUF_SIZE + 16 * SPARC_INTREG_SIZE;
1114 for (regnum = I0_REGNUM; regnum < I0_REGNUM + 8; regnum++)
1115 saved_regs_addr[regnum] =
1116 frame_addr + (regnum - I0_REGNUM) * SPARC_INTREG_SIZE
1117 - DUMMY_STACK_REG_BUF_SIZE + 8 * SPARC_INTREG_SIZE;
1120 for (regnum = FP0_REGNUM; regnum < FP_MAX_REGNUM; regnum++)
1121 saved_regs_addr[regnum] = frame_addr + (regnum - FP0_REGNUM) * 4
1122 - DUMMY_STACK_REG_BUF_SIZE + 24 * SPARC_INTREG_SIZE;
1124 if (GDB_TARGET_IS_SPARC64)
1126 for (regnum = PC_REGNUM; regnum < PC_REGNUM + 7; regnum++)
1128 saved_regs_addr[regnum] =
1129 frame_addr + (regnum - PC_REGNUM) * SPARC_INTREG_SIZE
1130 - DUMMY_STACK_REG_BUF_SIZE;
1132 saved_regs_addr[PSTATE_REGNUM] =
1133 frame_addr + 8 * SPARC_INTREG_SIZE - DUMMY_STACK_REG_BUF_SIZE;
1136 for (regnum = Y_REGNUM; regnum < NUM_REGS; regnum++)
1137 saved_regs_addr[regnum] =
1138 frame_addr + (regnum - Y_REGNUM) * SPARC_INTREG_SIZE
1139 - DUMMY_STACK_REG_BUF_SIZE;
1141 frame_addr = (get_frame_extra_info (fi)->bottom
1142 ? get_frame_extra_info (fi)->bottom
1145 else if (get_frame_extra_info (fi)->flat)
1147 CORE_ADDR func_start;
1148 find_pc_partial_function (get_frame_pc (fi), NULL, &func_start, NULL);
1149 examine_prologue (func_start, 0, fi, saved_regs_addr);
1151 /* Flat register window frame. */
1152 saved_regs_addr[RP_REGNUM] = get_frame_extra_info (fi)->pc_addr;
1153 saved_regs_addr[I7_REGNUM] = get_frame_extra_info (fi)->fp_addr;
1157 /* Normal frame. Just Local and In registers */
1158 frame_addr = (get_frame_extra_info (fi)->bottom
1159 ? get_frame_extra_info (fi)->bottom
1161 for (regnum = L0_REGNUM; regnum < L0_REGNUM + 8; regnum++)
1162 saved_regs_addr[regnum] =
1163 (frame_addr + (regnum - L0_REGNUM) * SPARC_INTREG_SIZE
1165 for (regnum = I0_REGNUM; regnum < I0_REGNUM + 8; regnum++)
1166 saved_regs_addr[regnum] =
1167 (frame_addr + (regnum - I0_REGNUM) * SPARC_INTREG_SIZE
1170 if (get_next_frame (fi))
1172 if (get_frame_extra_info (fi)->flat)
1174 saved_regs_addr[O7_REGNUM] = get_frame_extra_info (fi)->pc_addr;
1178 /* Pull off either the next frame pointer or the stack pointer */
1179 CORE_ADDR next_next_frame_addr =
1180 (get_frame_extra_info (get_next_frame (fi))->bottom
1181 ? get_frame_extra_info (get_next_frame (fi))->bottom
1183 for (regnum = O0_REGNUM; regnum < O0_REGNUM + 8; regnum++)
1184 saved_regs_addr[regnum] =
1185 (next_next_frame_addr
1186 + (regnum - O0_REGNUM) * SPARC_INTREG_SIZE
1190 /* Otherwise, whatever we would get from ptrace(GETREGS) is accurate */
1191 /* FIXME -- should this adjust for the sparc64 offset? */
1192 saved_regs_addr[SP_REGNUM] = get_frame_base (fi);
1195 /* Discard from the stack the innermost frame, restoring all saved registers.
1197 Note that the values stored in fsr by
1198 deprecated_get_frame_saved_regs are *in the context of the called
1199 frame*. What this means is that the i regs of fsr must be restored
1200 into the o regs of the (calling) frame that we pop into. We don't
1201 care about the output regs of the calling frame, since unless it's
1202 a dummy frame, it won't have any output regs in it.
1204 We never have to bother with %l (local) regs, since the called routine's
1205 locals get tossed, and the calling routine's locals are already saved
1208 /* Definitely see tm-sparc.h for more doc of the frame format here. */
1211 sparc_pop_frame (void)
1213 register struct frame_info *frame = get_current_frame ();
1214 register CORE_ADDR pc;
1219 fsr = alloca (NUM_REGS * sizeof (CORE_ADDR));
1220 raw_buffer = alloca (DEPRECATED_REGISTER_BYTES);
1221 sparc_frame_find_saved_regs (frame, &fsr[0]);
1224 if (fsr[FP0_REGNUM])
1226 read_memory (fsr[FP0_REGNUM], raw_buffer, FP_REGISTER_BYTES);
1227 deprecated_write_register_bytes (REGISTER_BYTE (FP0_REGNUM),
1228 raw_buffer, FP_REGISTER_BYTES);
1230 if (!(GDB_TARGET_IS_SPARC64))
1232 if (fsr[FPS_REGNUM])
1234 read_memory (fsr[FPS_REGNUM], raw_buffer, SPARC_INTREG_SIZE);
1235 deprecated_write_register_gen (FPS_REGNUM, raw_buffer);
1237 if (fsr[CPS_REGNUM])
1239 read_memory (fsr[CPS_REGNUM], raw_buffer, SPARC_INTREG_SIZE);
1240 deprecated_write_register_gen (CPS_REGNUM, raw_buffer);
1246 read_memory (fsr[G1_REGNUM], raw_buffer, 7 * SPARC_INTREG_SIZE);
1247 deprecated_write_register_bytes (REGISTER_BYTE (G1_REGNUM), raw_buffer,
1248 7 * SPARC_INTREG_SIZE);
1251 if (get_frame_extra_info (frame)->flat)
1253 /* Each register might or might not have been saved, need to test
1255 for (regnum = L0_REGNUM; regnum < L0_REGNUM + 8; ++regnum)
1257 write_register (regnum, read_memory_integer (fsr[regnum],
1258 SPARC_INTREG_SIZE));
1259 for (regnum = I0_REGNUM; regnum < I0_REGNUM + 8; ++regnum)
1261 write_register (regnum, read_memory_integer (fsr[regnum],
1262 SPARC_INTREG_SIZE));
1264 /* Handle all outs except stack pointer (o0-o5; o7). */
1265 for (regnum = O0_REGNUM; regnum < O0_REGNUM + 6; ++regnum)
1267 write_register (regnum, read_memory_integer (fsr[regnum],
1268 SPARC_INTREG_SIZE));
1269 if (fsr[O0_REGNUM + 7])
1270 write_register (O0_REGNUM + 7,
1271 read_memory_integer (fsr[O0_REGNUM + 7],
1272 SPARC_INTREG_SIZE));
1274 DEPRECATED_DUMMY_WRITE_SP (get_frame_base (frame));
1276 else if (fsr[I0_REGNUM])
1282 reg_temp = alloca (SPARC_INTREG_SIZE * 16);
1284 read_memory (fsr[I0_REGNUM], raw_buffer, 8 * SPARC_INTREG_SIZE);
1286 /* Get the ins and locals which we are about to restore. Just
1287 moving the stack pointer is all that is really needed, except
1288 store_inferior_registers is then going to write the ins and
1289 locals from the registers array, so we need to muck with the
1291 sp = fsr[SP_REGNUM];
1293 if (GDB_TARGET_IS_SPARC64 && (sp & 1))
1296 read_memory (sp, reg_temp, SPARC_INTREG_SIZE * 16);
1298 /* Restore the out registers.
1299 Among other things this writes the new stack pointer. */
1300 deprecated_write_register_bytes (REGISTER_BYTE (O0_REGNUM), raw_buffer,
1301 SPARC_INTREG_SIZE * 8);
1303 deprecated_write_register_bytes (REGISTER_BYTE (L0_REGNUM), reg_temp,
1304 SPARC_INTREG_SIZE * 16);
1307 if (!(GDB_TARGET_IS_SPARC64))
1309 write_register (PS_REGNUM,
1310 read_memory_integer (fsr[PS_REGNUM],
1311 REGISTER_RAW_SIZE (PS_REGNUM)));
1314 write_register (Y_REGNUM,
1315 read_memory_integer (fsr[Y_REGNUM],
1316 REGISTER_RAW_SIZE (Y_REGNUM)));
1319 /* Explicitly specified PC (and maybe NPC) -- just restore them. */
1320 write_register (PC_REGNUM,
1321 read_memory_integer (fsr[PC_REGNUM],
1322 REGISTER_RAW_SIZE (PC_REGNUM)));
1323 if (fsr[NPC_REGNUM])
1324 write_register (NPC_REGNUM,
1325 read_memory_integer (fsr[NPC_REGNUM],
1326 REGISTER_RAW_SIZE (NPC_REGNUM)));
1328 else if (get_frame_extra_info (frame)->flat)
1330 if (get_frame_extra_info (frame)->pc_addr)
1331 pc = PC_ADJUST ((CORE_ADDR)
1332 read_memory_integer (get_frame_extra_info (frame)->pc_addr,
1333 REGISTER_RAW_SIZE (PC_REGNUM)));
1336 /* I think this happens only in the innermost frame, if so then
1337 it is a complicated way of saying
1338 "pc = read_register (O7_REGNUM);". */
1340 frame_read_unsigned_register (frame, O7_REGNUM, &tmp);
1341 pc = PC_ADJUST (tmp);
1344 write_register (PC_REGNUM, pc);
1345 write_register (NPC_REGNUM, pc + 4);
1347 else if (fsr[I7_REGNUM])
1349 /* Return address in %i7 -- adjust it, then restore PC and NPC from it */
1350 pc = PC_ADJUST ((CORE_ADDR) read_memory_integer (fsr[I7_REGNUM],
1351 SPARC_INTREG_SIZE));
1352 write_register (PC_REGNUM, pc);
1353 write_register (NPC_REGNUM, pc + 4);
1355 flush_cached_frames ();
1358 /* On the Sun 4 under SunOS, the compile will leave a fake insn which
1359 encodes the structure size being returned. If we detect such
1360 a fake insn, step past it. */
1363 sparc_pc_adjust (CORE_ADDR pc)
1369 err = target_read_memory (pc + 8, buf, 4);
1370 insn = extract_unsigned_integer (buf, 4);
1371 if ((err == 0) && (insn & 0xffc00000) == 0)
1377 /* If pc is in a shared library trampoline, return its target.
1378 The SunOs 4.x linker rewrites the jump table entries for PIC
1379 compiled modules in the main executable to bypass the dynamic linker
1380 with jumps of the form
1383 and removes the corresponding jump table relocation entry in the
1384 dynamic relocations.
1385 find_solib_trampoline_target relies on the presence of the jump
1386 table relocation entry, so we have to detect these jump instructions
1390 sunos4_skip_trampoline_code (CORE_ADDR pc)
1392 unsigned long insn1;
1396 err = target_read_memory (pc, buf, 4);
1397 insn1 = extract_unsigned_integer (buf, 4);
1398 if (err == 0 && (insn1 & 0xffc00000) == 0x03000000)
1400 unsigned long insn2;
1402 err = target_read_memory (pc + 4, buf, 4);
1403 insn2 = extract_unsigned_integer (buf, 4);
1404 if (err == 0 && (insn2 & 0xffffe000) == 0x81c06000)
1406 CORE_ADDR target_pc = (insn1 & 0x3fffff) << 10;
1407 int delta = insn2 & 0x1fff;
1409 /* Sign extend the displacement. */
1412 return target_pc + delta;
1415 return find_solib_trampoline_target (pc);
1418 #ifdef USE_PROC_FS /* Target dependent support for /proc */
1420 /* The /proc interface divides the target machine's register set up into
1421 two different sets, the general register set (gregset) and the floating
1422 point register set (fpregset). For each set, there is an ioctl to get
1423 the current register set and another ioctl to set the current values.
1425 The actual structure passed through the ioctl interface is, of course,
1426 naturally machine dependent, and is different for each set of registers.
1427 For the sparc for example, the general register set is typically defined
1430 typedef int gregset_t[38];
1436 and the floating point set by:
1438 typedef struct prfpregset {
1441 double pr_dregs[16];
1446 u_char pr_q_entrysize;
1451 These routines provide the packing and unpacking of gregset_t and
1452 fpregset_t formatted data.
1457 /* Given a pointer to a general register set in /proc format (gregset_t *),
1458 unpack the register contents and supply them as gdb's idea of the current
1462 supply_gregset (gdb_gregset_t *gregsetp)
1464 prgreg_t *regp = (prgreg_t *) gregsetp;
1465 int regi, offset = 0;
1467 /* If the host is 64-bit sparc, but the target is 32-bit sparc,
1468 then the gregset may contain 64-bit ints while supply_register
1469 is expecting 32-bit ints. Compensate. */
1470 if (sizeof (regp[0]) == 8 && SPARC_INTREG_SIZE == 4)
1473 /* GDB register numbers for Gn, On, Ln, In all match /proc reg numbers. */
1474 /* FIXME MVS: assumes the order of the first 32 elements... */
1475 for (regi = G0_REGNUM; regi <= I7_REGNUM; regi++)
1477 supply_register (regi, ((char *) (regp + regi)) + offset);
1480 /* These require a bit more care. */
1481 supply_register (PC_REGNUM, ((char *) (regp + R_PC)) + offset);
1482 supply_register (NPC_REGNUM, ((char *) (regp + R_nPC)) + offset);
1483 supply_register (Y_REGNUM, ((char *) (regp + R_Y)) + offset);
1485 if (GDB_TARGET_IS_SPARC64)
1488 supply_register (CCR_REGNUM, ((char *) (regp + R_CCR)) + offset);
1490 supply_register (CCR_REGNUM, NULL);
1493 supply_register (FPRS_REGNUM, ((char *) (regp + R_FPRS)) + offset);
1495 supply_register (FPRS_REGNUM, NULL);
1498 supply_register (ASI_REGNUM, ((char *) (regp + R_ASI)) + offset);
1500 supply_register (ASI_REGNUM, NULL);
1506 supply_register (PS_REGNUM, ((char *) (regp + R_PS)) + offset);
1508 supply_register (PS_REGNUM, NULL);
1511 /* For 64-bit hosts, R_WIM and R_TBR may not be defined.
1512 Steal R_ASI and R_FPRS, and hope for the best! */
1514 #if !defined (R_WIM) && defined (R_ASI)
1518 #if !defined (R_TBR) && defined (R_FPRS)
1519 #define R_TBR R_FPRS
1523 supply_register (WIM_REGNUM, ((char *) (regp + R_WIM)) + offset);
1525 supply_register (WIM_REGNUM, NULL);
1529 supply_register (TBR_REGNUM, ((char *) (regp + R_TBR)) + offset);
1531 supply_register (TBR_REGNUM, NULL);
1535 /* Fill inaccessible registers with zero. */
1536 if (GDB_TARGET_IS_SPARC64)
1539 * don't know how to get value of any of the following:
1541 supply_register (VER_REGNUM, NULL);
1542 supply_register (TICK_REGNUM, NULL);
1543 supply_register (PIL_REGNUM, NULL);
1544 supply_register (PSTATE_REGNUM, NULL);
1545 supply_register (TSTATE_REGNUM, NULL);
1546 supply_register (TBA_REGNUM, NULL);
1547 supply_register (TL_REGNUM, NULL);
1548 supply_register (TT_REGNUM, NULL);
1549 supply_register (TPC_REGNUM, NULL);
1550 supply_register (TNPC_REGNUM, NULL);
1551 supply_register (WSTATE_REGNUM, NULL);
1552 supply_register (CWP_REGNUM, NULL);
1553 supply_register (CANSAVE_REGNUM, NULL);
1554 supply_register (CANRESTORE_REGNUM, NULL);
1555 supply_register (CLEANWIN_REGNUM, NULL);
1556 supply_register (OTHERWIN_REGNUM, NULL);
1557 supply_register (ASR16_REGNUM, NULL);
1558 supply_register (ASR17_REGNUM, NULL);
1559 supply_register (ASR18_REGNUM, NULL);
1560 supply_register (ASR19_REGNUM, NULL);
1561 supply_register (ASR20_REGNUM, NULL);
1562 supply_register (ASR21_REGNUM, NULL);
1563 supply_register (ASR22_REGNUM, NULL);
1564 supply_register (ASR23_REGNUM, NULL);
1565 supply_register (ASR24_REGNUM, NULL);
1566 supply_register (ASR25_REGNUM, NULL);
1567 supply_register (ASR26_REGNUM, NULL);
1568 supply_register (ASR27_REGNUM, NULL);
1569 supply_register (ASR28_REGNUM, NULL);
1570 supply_register (ASR29_REGNUM, NULL);
1571 supply_register (ASR30_REGNUM, NULL);
1572 supply_register (ASR31_REGNUM, NULL);
1573 supply_register (ICC_REGNUM, NULL);
1574 supply_register (XCC_REGNUM, NULL);
1578 supply_register (CPS_REGNUM, NULL);
1583 fill_gregset (gdb_gregset_t *gregsetp, int regno)
1585 prgreg_t *regp = (prgreg_t *) gregsetp;
1586 int regi, offset = 0;
1588 /* If the host is 64-bit sparc, but the target is 32-bit sparc,
1589 then the gregset may contain 64-bit ints while supply_register
1590 is expecting 32-bit ints. Compensate. */
1591 if (sizeof (regp[0]) == 8 && SPARC_INTREG_SIZE == 4)
1594 for (regi = 0; regi <= R_I7; regi++)
1595 if ((regno == -1) || (regno == regi))
1596 deprecated_read_register_gen (regi, (char *) (regp + regi) + offset);
1598 if ((regno == -1) || (regno == PC_REGNUM))
1599 deprecated_read_register_gen (PC_REGNUM, (char *) (regp + R_PC) + offset);
1601 if ((regno == -1) || (regno == NPC_REGNUM))
1602 deprecated_read_register_gen (NPC_REGNUM, (char *) (regp + R_nPC) + offset);
1604 if ((regno == -1) || (regno == Y_REGNUM))
1605 deprecated_read_register_gen (Y_REGNUM, (char *) (regp + R_Y) + offset);
1607 if (GDB_TARGET_IS_SPARC64)
1610 if (regno == -1 || regno == CCR_REGNUM)
1611 deprecated_read_register_gen (CCR_REGNUM, ((char *) (regp + R_CCR)) + offset);
1614 if (regno == -1 || regno == FPRS_REGNUM)
1615 deprecated_read_register_gen (FPRS_REGNUM, ((char *) (regp + R_FPRS)) + offset);
1618 if (regno == -1 || regno == ASI_REGNUM)
1619 deprecated_read_register_gen (ASI_REGNUM, ((char *) (regp + R_ASI)) + offset);
1625 if (regno == -1 || regno == PS_REGNUM)
1626 deprecated_read_register_gen (PS_REGNUM, ((char *) (regp + R_PS)) + offset);
1629 /* For 64-bit hosts, R_WIM and R_TBR may not be defined.
1630 Steal R_ASI and R_FPRS, and hope for the best! */
1632 #if !defined (R_WIM) && defined (R_ASI)
1636 #if !defined (R_TBR) && defined (R_FPRS)
1637 #define R_TBR R_FPRS
1641 if (regno == -1 || regno == WIM_REGNUM)
1642 deprecated_read_register_gen (WIM_REGNUM, ((char *) (regp + R_WIM)) + offset);
1644 if (regno == -1 || regno == WIM_REGNUM)
1645 deprecated_read_register_gen (WIM_REGNUM, NULL);
1649 if (regno == -1 || regno == TBR_REGNUM)
1650 deprecated_read_register_gen (TBR_REGNUM, ((char *) (regp + R_TBR)) + offset);
1652 if (regno == -1 || regno == TBR_REGNUM)
1653 deprecated_read_register_gen (TBR_REGNUM, NULL);
1658 /* Given a pointer to a floating point register set in /proc format
1659 (fpregset_t *), unpack the register contents and supply them as gdb's
1660 idea of the current floating point register values. */
1663 supply_fpregset (gdb_fpregset_t *fpregsetp)
1671 for (regi = FP0_REGNUM; regi < FP_MAX_REGNUM; regi++)
1673 from = (char *) &fpregsetp->pr_fr.pr_regs[regi - FP0_REGNUM];
1674 supply_register (regi, from);
1677 if (GDB_TARGET_IS_SPARC64)
1680 * don't know how to get value of the following.
1682 supply_register (FSR_REGNUM, NULL); /* zero it out for now */
1683 supply_register (FCC0_REGNUM, NULL);
1684 supply_register (FCC1_REGNUM, NULL); /* don't know how to get value */
1685 supply_register (FCC2_REGNUM, NULL); /* don't know how to get value */
1686 supply_register (FCC3_REGNUM, NULL); /* don't know how to get value */
1690 supply_register (FPS_REGNUM, (char *) &(fpregsetp->pr_fsr));
1694 /* Given a pointer to a floating point register set in /proc format
1695 (fpregset_t *), update the register specified by REGNO from gdb's idea
1696 of the current floating point register set. If REGNO is -1, update
1698 /* This will probably need some changes for sparc64. */
1701 fill_fpregset (gdb_fpregset_t *fpregsetp, int regno)
1710 for (regi = FP0_REGNUM; regi < FP_MAX_REGNUM; regi++)
1712 if ((regno == -1) || (regno == regi))
1714 from = (char *) &deprecated_registers[REGISTER_BYTE (regi)];
1715 to = (char *) &fpregsetp->pr_fr.pr_regs[regi - FP0_REGNUM];
1716 memcpy (to, from, REGISTER_RAW_SIZE (regi));
1720 if (!(GDB_TARGET_IS_SPARC64)) /* FIXME: does Sparc64 have this register? */
1721 if ((regno == -1) || (regno == FPS_REGNUM))
1723 from = (char *)&deprecated_registers[REGISTER_BYTE (FPS_REGNUM)];
1724 to = (char *) &fpregsetp->pr_fsr;
1725 memcpy (to, from, REGISTER_RAW_SIZE (FPS_REGNUM));
1729 #endif /* USE_PROC_FS */
1731 /* Because of Multi-arch, GET_LONGJMP_TARGET is always defined. So test
1732 for a definition of JB_PC. */
1735 /* Figure out where the longjmp will land. We expect that we have just entered
1736 longjmp and haven't yet setup the stack frame, so the args are still in the
1737 output regs. %o0 (O0_REGNUM) points at the jmp_buf structure from which we
1738 extract the pc (JB_PC) that we will land at. The pc is copied into ADDR.
1739 This routine returns true on success */
1742 get_longjmp_target (CORE_ADDR *pc)
1745 #define LONGJMP_TARGET_SIZE 4
1746 char buf[LONGJMP_TARGET_SIZE];
1748 jb_addr = read_register (O0_REGNUM);
1750 if (target_read_memory (jb_addr + JB_PC * JB_ELEMENT_SIZE, buf,
1751 LONGJMP_TARGET_SIZE))
1754 *pc = extract_unsigned_integer (buf, LONGJMP_TARGET_SIZE);
1758 #endif /* GET_LONGJMP_TARGET */
1760 #ifdef STATIC_TRANSFORM_NAME
1761 /* SunPRO (3.0 at least), encodes the static variables. This is not
1762 related to C++ mangling, it is done for C too. */
1765 sunpro_static_transform_name (char *name)
1770 /* For file-local statics there will be a dollar sign, a bunch
1771 of junk (the contents of which match a string given in the
1772 N_OPT), a period and the name. For function-local statics
1773 there will be a bunch of junk (which seems to change the
1774 second character from 'A' to 'B'), a period, the name of the
1775 function, and the name. So just skip everything before the
1777 p = strrchr (name, '.');
1783 #endif /* STATIC_TRANSFORM_NAME */
1786 /* Utilities for printing registers.
1787 Page numbers refer to the SPARC Architecture Manual. */
1789 static void dump_ccreg (char *, int);
1792 dump_ccreg (char *reg, int val)
1795 printf_unfiltered ("%s:%s,%s,%s,%s", reg,
1796 val & 8 ? "N" : "NN",
1797 val & 4 ? "Z" : "NZ",
1798 val & 2 ? "O" : "NO",
1799 val & 1 ? "C" : "NC");
1803 decode_asi (int val)
1809 return "ASI_NUCLEUS";
1811 return "ASI_NUCLEUS_LITTLE";
1813 return "ASI_AS_IF_USER_PRIMARY";
1815 return "ASI_AS_IF_USER_SECONDARY";
1817 return "ASI_AS_IF_USER_PRIMARY_LITTLE";
1819 return "ASI_AS_IF_USER_SECONDARY_LITTLE";
1821 return "ASI_PRIMARY";
1823 return "ASI_SECONDARY";
1825 return "ASI_PRIMARY_NOFAULT";
1827 return "ASI_SECONDARY_NOFAULT";
1829 return "ASI_PRIMARY_LITTLE";
1831 return "ASI_SECONDARY_LITTLE";
1833 return "ASI_PRIMARY_NOFAULT_LITTLE";
1835 return "ASI_SECONDARY_NOFAULT_LITTLE";
1841 /* Pretty print various registers. */
1842 /* FIXME: Would be nice if this did some fancy things for 32 bit sparc. */
1845 sparc_print_register_hook (int regno)
1849 /* Handle double/quad versions of lower 32 fp regs. */
1850 if (regno >= FP0_REGNUM && regno < FP0_REGNUM + 32
1851 && (regno & 1) == 0)
1855 if (frame_register_read (deprecated_selected_frame, regno, value)
1856 && frame_register_read (deprecated_selected_frame, regno + 1, value + 4))
1858 printf_unfiltered ("\t");
1859 print_floating (value, builtin_type_double, gdb_stdout);
1861 #if 0 /* FIXME: gdb doesn't handle long doubles */
1862 if ((regno & 3) == 0)
1864 if (frame_register_read (deprecated_selected_frame, regno + 2, value + 8)
1865 && frame_register_read (deprecated_selected_frame, regno + 3, value + 12))
1867 printf_unfiltered ("\t");
1868 print_floating (value, builtin_type_long_double, gdb_stdout);
1875 #if 0 /* FIXME: gdb doesn't handle long doubles */
1876 /* Print upper fp regs as long double if appropriate. */
1877 if (regno >= FP0_REGNUM + 32 && regno < FP_MAX_REGNUM
1878 /* We test for even numbered regs and not a multiple of 4 because
1879 the upper fp regs are recorded as doubles. */
1880 && (regno & 1) == 0)
1884 if (frame_register_read (deprecated_selected_frame, regno, value)
1885 && frame_register_read (deprecated_selected_frame, regno + 1, value + 8))
1887 printf_unfiltered ("\t");
1888 print_floating (value, builtin_type_long_double, gdb_stdout);
1894 /* FIXME: Some of these are priviledged registers.
1895 Not sure how they should be handled. */
1897 #define BITS(n, mask) ((int) (((val) >> (n)) & (mask)))
1899 val = read_register (regno);
1902 if (GDB_TARGET_IS_SPARC64)
1906 printf_unfiltered ("\t");
1907 dump_ccreg ("xcc", val >> 4);
1908 printf_unfiltered (", ");
1909 dump_ccreg ("icc", val & 15);
1912 printf ("\tfef:%d, du:%d, dl:%d",
1913 BITS (2, 1), BITS (1, 1), BITS (0, 1));
1917 static char *fcc[4] =
1918 {"=", "<", ">", "?"};
1919 static char *rd[4] =
1920 {"N", "0", "+", "-"};
1921 /* Long, but I'd rather leave it as is and use a wide screen. */
1922 printf_filtered ("\t0:%s, 1:%s, 2:%s, 3:%s, rd:%s, tem:%d, ",
1923 fcc[BITS (10, 3)], fcc[BITS (32, 3)],
1924 fcc[BITS (34, 3)], fcc[BITS (36, 3)],
1925 rd[BITS (30, 3)], BITS (23, 31));
1926 printf_filtered ("ns:%d, ver:%d, ftt:%d, qne:%d, aexc:%d, cexc:%d",
1927 BITS (22, 1), BITS (17, 7), BITS (14, 7),
1928 BITS (13, 1), BITS (5, 31), BITS (0, 31));
1933 char *asi = decode_asi (val);
1935 printf ("\t%s", asi);
1939 printf ("\tmanuf:%d, impl:%d, mask:%d, maxtl:%d, maxwin:%d",
1940 BITS (48, 0xffff), BITS (32, 0xffff),
1941 BITS (24, 0xff), BITS (8, 0xff), BITS (0, 31));
1945 static char *mm[4] =
1946 {"tso", "pso", "rso", "?"};
1947 printf_filtered ("\tcle:%d, tle:%d, mm:%s, red:%d, ",
1948 BITS (9, 1), BITS (8, 1),
1949 mm[BITS (6, 3)], BITS (5, 1));
1950 printf_filtered ("pef:%d, am:%d, priv:%d, ie:%d, ag:%d",
1951 BITS (4, 1), BITS (3, 1), BITS (2, 1),
1952 BITS (1, 1), BITS (0, 1));
1956 /* FIXME: print all 4? */
1959 /* FIXME: print all 4? */
1962 /* FIXME: print all 4? */
1965 /* FIXME: print all 4? */
1968 printf ("\tother:%d, normal:%d", BITS (3, 7), BITS (0, 7));
1971 printf ("\t%d", BITS (0, 31));
1973 case CANSAVE_REGNUM:
1974 printf ("\t%-2d before spill", BITS (0, 31));
1976 case CANRESTORE_REGNUM:
1977 printf ("\t%-2d before fill", BITS (0, 31));
1979 case CLEANWIN_REGNUM:
1980 printf ("\t%-2d before clean", BITS (0, 31));
1982 case OTHERWIN_REGNUM:
1983 printf ("\t%d", BITS (0, 31));
1990 printf ("\ticc:%c%c%c%c, pil:%d, s:%d, ps:%d, et:%d, cwp:%d",
1991 BITS (23, 1) ? 'N' : '-', BITS (22, 1) ? 'Z' : '-',
1992 BITS (21, 1) ? 'V' : '-', BITS (20, 1) ? 'C' : '-',
1993 BITS (8, 15), BITS (7, 1), BITS (6, 1), BITS (5, 1),
1998 static char *fcc[4] =
1999 {"=", "<", ">", "?"};
2000 static char *rd[4] =
2001 {"N", "0", "+", "-"};
2002 /* Long, but I'd rather leave it as is and use a wide screen. */
2003 printf ("\trd:%s, tem:%d, ns:%d, ver:%d, ftt:%d, qne:%d, "
2004 "fcc:%s, aexc:%d, cexc:%d",
2005 rd[BITS (30, 3)], BITS (23, 31), BITS (22, 1), BITS (17, 7),
2006 BITS (14, 7), BITS (13, 1), fcc[BITS (10, 3)], BITS (5, 31),
2016 sparc_print_registers (struct gdbarch *gdbarch,
2017 struct ui_file *file,
2018 struct frame_info *frame,
2019 int regnum, int print_all,
2020 void (*print_register_hook) (int))
2023 const int numregs = NUM_REGS + NUM_PSEUDO_REGS;
2024 char raw_buffer[MAX_REGISTER_SIZE];
2025 char virtual_buffer[MAX_REGISTER_SIZE];
2027 for (i = 0; i < numregs; i++)
2029 /* Decide between printing all regs, non-float / vector regs, or
2035 if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (i)) == TYPE_CODE_FLT)
2037 if (TYPE_VECTOR (REGISTER_VIRTUAL_TYPE (i)))
2047 /* If the register name is empty, it is undefined for this
2048 processor, so don't display anything. */
2049 if (REGISTER_NAME (i) == NULL || *(REGISTER_NAME (i)) == '\0')
2052 fputs_filtered (REGISTER_NAME (i), file);
2053 print_spaces_filtered (15 - strlen (REGISTER_NAME (i)), file);
2055 /* Get the data in raw format. */
2056 if (! frame_register_read (frame, i, raw_buffer))
2058 fprintf_filtered (file, "*value not available*\n");
2062 memcpy (virtual_buffer, raw_buffer, REGISTER_VIRTUAL_SIZE (i));
2064 /* If virtual format is floating, print it that way, and in raw
2066 if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (i)) == TYPE_CODE_FLT)
2070 val_print (REGISTER_VIRTUAL_TYPE (i), virtual_buffer, 0, 0,
2071 file, 0, 1, 0, Val_pretty_default);
2073 fprintf_filtered (file, "\t(raw 0x");
2074 for (j = 0; j < REGISTER_RAW_SIZE (i); j++)
2077 if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
2080 idx = REGISTER_RAW_SIZE (i) - 1 - j;
2081 fprintf_filtered (file, "%02x", (unsigned char) raw_buffer[idx]);
2083 fprintf_filtered (file, ")");
2087 /* Print the register in hex. */
2088 val_print (REGISTER_VIRTUAL_TYPE (i), virtual_buffer, 0, 0,
2089 file, 'x', 1, 0, Val_pretty_default);
2090 /* If not a vector register, print it also according to its
2092 if (TYPE_VECTOR (REGISTER_VIRTUAL_TYPE (i)) == 0)
2094 fprintf_filtered (file, "\t");
2095 val_print (REGISTER_VIRTUAL_TYPE (i), virtual_buffer, 0, 0,
2096 file, 0, 1, 0, Val_pretty_default);
2100 /* Some sparc specific info. */
2101 if (print_register_hook != NULL)
2102 print_register_hook (i);
2104 fprintf_filtered (file, "\n");
2109 sparc_print_registers_info (struct gdbarch *gdbarch,
2110 struct ui_file *file,
2111 struct frame_info *frame,
2112 int regnum, int print_all)
2114 sparc_print_registers (gdbarch, file, frame, regnum, print_all,
2115 sparc_print_register_hook);
2119 sparc_do_registers_info (int regnum, int all)
2121 sparc_print_registers_info (current_gdbarch, gdb_stdout, deprecated_selected_frame,
2126 // OBSOLETE static void
2127 // OBSOLETE sparclet_print_registers_info (struct gdbarch *gdbarch,
2128 // OBSOLETE struct ui_file *file,
2129 // OBSOLETE struct frame_info *frame,
2130 // OBSOLETE int regnum, int print_all)
2132 // OBSOLETE sparc_print_registers (gdbarch, file, frame, regnum, print_all, NULL);
2136 // OBSOLETE sparclet_do_registers_info (int regnum, int all)
2138 // OBSOLETE sparclet_print_registers_info (current_gdbarch, gdb_stdout,
2139 // OBSOLETE deprecated_selected_frame, regnum, all);
2143 #define SPARC_F0_REGNUM FP0_REGNUM /* %f0 */
2144 #define SPARC_F1_REGNUM (FP0_REGNUM + 1)/* %f1 */
2145 #define SPARC_O0_REGNUM O0_REGNUM /* %o0 */
2146 #define SPARC_O1_REGNUM O1_REGNUM /* %o1 */
2148 /* Push the arguments onto the stack and into the appropriate registers. */
2151 sparc32_do_push_arguments (struct regcache *regcache, int nargs,
2152 struct value **args, CORE_ADDR sp)
2158 /* Structure, union and quad-precision arguments are passed by
2159 reference. We allocate space for these arguments on the stack
2160 and record their addresses in an array. Array elements for
2161 arguments that are passed by value will be set to zero.*/
2162 addr = alloca (nargs * sizeof (CORE_ADDR));
2164 for (i = nargs - 1; i >= 0; i--)
2166 struct type *type = VALUE_ENCLOSING_TYPE (args[i]);
2167 enum type_code code = TYPE_CODE (type);
2168 int len = TYPE_LENGTH (type);
2170 /* Push the contents of structure, union and quad-precision
2171 arguments on the stack. */
2172 if (code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION || len > 8)
2174 /* Keep the stack doubleword aligned. */
2175 sp -= (len + 7) & ~7;
2176 write_memory (sp, VALUE_CONTENTS_ALL (args[i]), len);
2183 size += (len > 4) ? 8 : 4;
2187 /* The needed space for outgoing arguments should be a multiple of 4. */
2188 gdb_assert (size % 4 == 0);
2190 /* Make sure we reserve space for the first six words of arguments
2191 in the stack frame, even if we don't need them. */
2195 /* Make sure we end up with a doubleword aligned stack in the end.
2196 Reserve an extra word if necessary in order to accomplish this. */
2197 if ((sp - size) % 8 == 0)
2200 /* Now push the arguments onto the stack. */
2201 for (i = nargs - 1; i >=0; i--)
2208 store_unsigned_integer (buf, 4, addr[i]);
2213 struct value *arg = args[i];
2215 len = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (arg));
2217 /* Expand signed and unsigned bytes and halfwords as needed. */
2220 arg = value_cast (builtin_type_long, arg);
2223 else if (len > 4 && len < 8)
2225 arg = value_cast (builtin_type_long_long, arg);
2229 gdb_assert (len == 4 || len == 8);
2230 memcpy (buf, VALUE_CONTENTS_ALL (arg), len);
2233 /* We always write the argument word on the stack. */
2235 write_memory (sp, buf, len);
2237 /* If this argument occupies one of the first 6 words, write it
2238 into the appropriate register too. */
2242 int regnum = SPARC_O0_REGNUM + (size / 4);
2244 regcache_cooked_write (regcache, regnum, buf);
2245 if (len == 8 && size < 20)
2246 regcache_cooked_write (regcache, regnum + 1, buf + 4);
2250 /* Reserve space for the struct/union return value pointer. */
2253 /* Stack should be doubleword aligned at this point. */
2254 gdb_assert (sp % 8 == 0);
2256 /* Return the adjusted stack pointer. */
2260 /* The SPARC passes the arguments on the stack; arguments smaller
2261 than an int are promoted to an int. The first 6 words worth of
2262 args are also passed in registers o0 - o5. */
2265 sparc32_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
2266 int struct_return, CORE_ADDR struct_addr)
2268 sp = sparc32_do_push_arguments (current_regcache, nargs, args, sp);
2270 /* FIXME: kettenis/20030525: We don't let this function set the
2271 struct/union return pointer just yet. */
2277 /* The space for the struct/union return value pointer has
2278 already been reserved. */
2279 store_unsigned_integer (buf, 4, struct_addr);
2289 /* Extract from REGCACHE a function return value of type TYPE and copy
2292 Note that REGCACHE specifies the register values for the frame of
2293 the calling function. This means that we need to fetch the value
2294 form %o0 and %o1, which correspond to %i0 and %i1 in the frame of
2295 the called function. */
2298 sparc32_extract_return_value (struct type *type, struct regcache *regcache,
2301 int len = TYPE_LENGTH (type);
2304 if (TYPE_CODE (type) == TYPE_CODE_FLT && SPARC_HAS_FPU)
2306 if (len == 4 || len == 8)
2308 regcache_cooked_read (regcache, SPARC_F0_REGNUM, buf);
2309 regcache_cooked_read (regcache, SPARC_F1_REGNUM, buf + 4);
2310 memcpy (valbuf, buf, len);
2314 internal_error (__FILE__, __LINE__, "\
2315 Cannot extract floating-point return value of %d bytes long.", len);
2320 regcache_cooked_read (regcache, SPARC_O0_REGNUM, buf);
2321 memcpy (valbuf, buf + 4 - len, len);
2325 regcache_cooked_read (regcache, SPARC_O0_REGNUM, buf);
2326 regcache_cooked_read (regcache, SPARC_O1_REGNUM, buf + 4);
2327 memcpy (valbuf, buf + 8 - len, len);
2330 internal_error (__FILE__, __LINE__,
2331 "Cannot extract return value of %d bytes long.", len);
2334 /* Write into REGBUF a function return value VALBUF of type TYPE. */
2337 sparc32_store_return_value (struct type *type, struct regcache *regcache,
2340 int len = TYPE_LENGTH (type);
2343 if (TYPE_CODE (type) == TYPE_CODE_FLT && SPARC_HAS_FPU)
2345 const char *buf = valbuf;
2349 regcache_cooked_write (regcache, SPARC_F0_REGNUM, buf);
2354 regcache_cooked_write (regcache, SPARC_F0_REGNUM, buf);
2355 regcache_cooked_write (regcache, SPARC_F1_REGNUM, buf + 4);
2359 internal_error (__FILE__, __LINE__, "\
2360 Cannot extract floating-point return value of %d bytes long.", len);
2363 /* Add leading zeros to the value. */
2364 memset (buf, 0, sizeof buf);
2368 memcpy (buf + 4 - len, valbuf, len);
2369 regcache_cooked_write (regcache, SPARC_O0_REGNUM, buf);
2373 memcpy (buf + 8 - len, valbuf, len);
2374 regcache_cooked_write (regcache, SPARC_O0_REGNUM, buf);
2375 regcache_cooked_write (regcache, SPARC_O1_REGNUM, buf);
2378 internal_error (__FILE__, __LINE__,
2379 "Cannot extract return value of %d bytes long.", len);
2382 /* Extract from REGCACHE the address in which a function should return
2383 its structure value. */
2386 sparc_extract_struct_value_address (struct regcache *regcache)
2390 regcache_cooked_read_unsigned (regcache, SPARC_O0_REGNUM, &addr);
2394 /* FIXME: kettenis/2003/05/24: Still used for sparc64. */
2397 sparc_store_return_value (struct type *type, char *valbuf)
2400 char buffer[MAX_REGISTER_SIZE];
2402 if (TYPE_CODE (type) == TYPE_CODE_FLT && SPARC_HAS_FPU)
2403 /* Floating-point values are returned in the register pair */
2404 /* formed by %f0 and %f1 (doubles are, anyway). */
2407 /* Other values are returned in register %o0. */
2410 /* Add leading zeros to the value. */
2411 if (TYPE_LENGTH (type) < REGISTER_RAW_SIZE (regno))
2413 memset (buffer, 0, REGISTER_RAW_SIZE (regno));
2414 memcpy (buffer + REGISTER_RAW_SIZE (regno) - TYPE_LENGTH (type), valbuf,
2415 TYPE_LENGTH (type));
2416 deprecated_write_register_gen (regno, buffer);
2419 deprecated_write_register_bytes (REGISTER_BYTE (regno), valbuf,
2420 TYPE_LENGTH (type));
2424 // OBSOLETE extern void
2425 // OBSOLETE sparclet_store_return_value (struct type *type, char *valbuf)
2427 // OBSOLETE /* Other values are returned in register %o0. */
2428 // OBSOLETE deprecated_write_register_bytes (REGISTER_BYTE (O0_REGNUM), valbuf,
2429 // OBSOLETE TYPE_LENGTH (type));
2434 #ifndef CALL_DUMMY_CALL_OFFSET
2435 #define CALL_DUMMY_CALL_OFFSET \
2436 (gdbarch_tdep (current_gdbarch)->call_dummy_call_offset)
2437 #endif /* CALL_DUMMY_CALL_OFFSET */
2439 /* Insert the function address into a call dummy instruction sequence
2442 For structs and unions, if the function was compiled with Sun cc,
2443 it expects 'unimp' after the call. But gcc doesn't use that
2444 (twisted) convention. So leave a nop there for gcc
2445 (DEPRECATED_FIX_CALL_DUMMY can assume it is operating on a pristine
2446 CALL_DUMMY, not one that has already been customized for a
2447 different function). */
2450 sparc_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun,
2451 struct type *value_type, int using_gcc)
2455 /* Store the relative adddress of the target function into the
2456 'call' instruction. */
2457 store_unsigned_integer (dummy + CALL_DUMMY_CALL_OFFSET, 4,
2459 | (((fun - (pc + CALL_DUMMY_CALL_OFFSET)) >> 2)
2462 /* If the called function returns an aggregate value, fill in the UNIMP
2463 instruction containing the size of the returned aggregate return value,
2464 which follows the call instruction.
2465 For details see the SPARC Architecture Manual Version 8, Appendix D.3.
2467 Adjust the call_dummy_breakpoint_offset for the bp_call_dummy breakpoint
2468 to the proper address in the call dummy, so that `finish' after a stop
2469 in a call dummy works.
2471 Tweeking current_gdbarch is not an optimal solution, but the call
2472 to sparc_fix_call_dummy is immediately followed by a call to
2473 call_function_by_hand, which is the only function where
2474 dummy_breakpoint_offset is actually used, if it is non-zero. */
2475 if (TYPE_CODE (value_type) == TYPE_CODE_STRUCT
2476 || TYPE_CODE (value_type) == TYPE_CODE_UNION)
2478 store_unsigned_integer (dummy + CALL_DUMMY_CALL_OFFSET + 8, 4,
2479 TYPE_LENGTH (value_type) & 0x1fff);
2480 set_gdbarch_deprecated_call_dummy_breakpoint_offset (current_gdbarch, 0x30);
2483 set_gdbarch_deprecated_call_dummy_breakpoint_offset (current_gdbarch, 0x2c);
2485 if (!(GDB_TARGET_IS_SPARC64))
2487 /* If this is not a simulator target, change the first four
2488 instructions of the call dummy to NOPs. Those instructions
2489 include a 'save' instruction and are designed to work around
2490 problems with register window flushing in the simulator. */
2492 if (strcmp (target_shortname, "sim") != 0)
2494 for (i = 0; i < 4; i++)
2495 store_unsigned_integer (dummy + (i * 4), 4, 0x01000000);
2500 // OBSOLETE /* If this is a bi-endian target, GDB has written the call dummy
2501 // OBSOLETE in little-endian order. We must byte-swap it back to big-endian. */
2502 // OBSOLETE if (bi_endian)
2504 // OBSOLETE for (i = 0; i < CALL_DUMMY_LENGTH; i += 4)
2506 // OBSOLETE char tmp = dummy[i];
2507 // OBSOLETE dummy[i] = dummy[i + 3];
2508 // OBSOLETE dummy[i + 3] = tmp;
2509 // OBSOLETE tmp = dummy[i + 1];
2510 // OBSOLETE dummy[i + 1] = dummy[i + 2];
2511 // OBSOLETE dummy[i + 2] = tmp;
2519 // OBSOLETE /* Set target byte order based on machine type. */
2521 // OBSOLETE static int
2522 // OBSOLETE sparc_target_architecture_hook (const bfd_arch_info_type *ap)
2524 // OBSOLETE int i, j;
2526 // OBSOLETE if (ap->mach == bfd_mach_sparc_sparclite_le)
2528 // OBSOLETE target_byte_order = BFD_ENDIAN_LITTLE;
2529 // OBSOLETE bi_endian = 1;
2532 // OBSOLETE bi_endian = 0;
2533 // OBSOLETE return 1;
2538 * Module "constructor" function.
2541 static struct gdbarch * sparc_gdbarch_init (struct gdbarch_info info,
2542 struct gdbarch_list *arches);
2543 static void sparc_dump_tdep (struct gdbarch *, struct ui_file *);
2545 extern initialize_file_ftype _initialize_sparc_tdep; /* -Wmissing-prototypes */
2548 _initialize_sparc_tdep (void)
2550 /* Hook us into the gdbarch mechanism. */
2551 gdbarch_register (bfd_arch_sparc, sparc_gdbarch_init, sparc_dump_tdep);
2553 /* OBSOLETE target_architecture_hook = sparc_target_architecture_hook; */
2556 /* Compensate for stack bias. Note that we currently don't handle
2557 mixed 32/64 bit code. */
2560 sparc64_read_sp (void)
2562 CORE_ADDR sp = read_register (SP_REGNUM);
2570 sparc64_read_fp (void)
2572 CORE_ADDR fp = read_register (DEPRECATED_FP_REGNUM);
2580 sparc64_write_sp (CORE_ADDR val)
2582 CORE_ADDR oldsp = read_register (SP_REGNUM);
2584 write_register (SP_REGNUM, val - 2047);
2586 write_register (SP_REGNUM, val);
2589 /* The SPARC 64 ABI passes floating-point arguments in FP0 to FP31,
2590 and all other arguments in O0 to O5. They are also copied onto
2591 the stack in the correct places. Apparently (empirically),
2592 structs of less than 16 bytes are passed member-by-member in
2593 separate registers, but I am unable to figure out the algorithm.
2594 Some members go in floating point regs, but I don't know which.
2596 FIXME: Handle small structs (less than 16 bytes containing floats).
2598 The counting regimen for using both integer and FP registers
2599 for argument passing is rather odd -- a single counter is used
2600 for both; this means that if the arguments alternate between
2601 int and float, we will waste every other register of both types. */
2604 sparc64_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
2605 int struct_return, CORE_ADDR struct_retaddr)
2607 int i, j, register_counter = 0;
2609 struct type *sparc_intreg_type =
2610 TYPE_LENGTH (builtin_type_long) == SPARC_INTREG_SIZE ?
2611 builtin_type_long : builtin_type_long_long;
2613 sp = (sp & ~(((unsigned long) SPARC_INTREG_SIZE) - 1UL));
2615 /* Figure out how much space we'll need. */
2616 for (i = nargs - 1; i >= 0; i--)
2618 int len = TYPE_LENGTH (check_typedef (VALUE_TYPE (args[i])));
2619 struct value *copyarg = args[i];
2622 if (copylen < SPARC_INTREG_SIZE)
2624 copyarg = value_cast (sparc_intreg_type, copyarg);
2625 copylen = SPARC_INTREG_SIZE;
2634 /* if STRUCT_RETURN, then first argument is the struct return location. */
2636 write_register (O0_REGNUM + register_counter++, struct_retaddr);
2638 /* Now write the arguments onto the stack, while writing FP
2639 arguments into the FP registers, and other arguments into the
2640 first six 'O' registers. */
2642 for (i = 0; i < nargs; i++)
2644 int len = TYPE_LENGTH (check_typedef (VALUE_TYPE (args[i])));
2645 struct value *copyarg = args[i];
2646 enum type_code typecode = TYPE_CODE (VALUE_TYPE (args[i]));
2649 if (typecode == TYPE_CODE_INT ||
2650 typecode == TYPE_CODE_BOOL ||
2651 typecode == TYPE_CODE_CHAR ||
2652 typecode == TYPE_CODE_RANGE ||
2653 typecode == TYPE_CODE_ENUM)
2654 if (len < SPARC_INTREG_SIZE)
2656 /* Small ints will all take up the size of one intreg on
2658 copyarg = value_cast (sparc_intreg_type, copyarg);
2659 copylen = SPARC_INTREG_SIZE;
2662 write_memory (tempsp, VALUE_CONTENTS (copyarg), copylen);
2665 /* Corner case: Structs consisting of a single float member are floats.
2666 * FIXME! I don't know about structs containing multiple floats!
2667 * Structs containing mixed floats and ints are even more weird.
2672 /* Separate float args from all other args. */
2673 if (typecode == TYPE_CODE_FLT && SPARC_HAS_FPU)
2675 if (register_counter < 16)
2677 /* This arg gets copied into a FP register. */
2681 case 4: /* Single-precision (float) */
2682 fpreg = FP0_REGNUM + 2 * register_counter + 1;
2683 register_counter += 1;
2685 case 8: /* Double-precision (double) */
2686 fpreg = FP0_REGNUM + 2 * register_counter;
2687 register_counter += 1;
2689 case 16: /* Quad-precision (long double) */
2690 fpreg = FP0_REGNUM + 2 * register_counter;
2691 register_counter += 2;
2694 internal_error (__FILE__, __LINE__, "bad switch");
2696 deprecated_write_register_bytes (REGISTER_BYTE (fpreg),
2697 VALUE_CONTENTS (args[i]),
2701 else /* all other args go into the first six 'o' registers */
2704 j < len && register_counter < 6;
2705 j += SPARC_INTREG_SIZE)
2707 int oreg = O0_REGNUM + register_counter;
2709 deprecated_write_register_gen (oreg, VALUE_CONTENTS (copyarg) + j);
2710 register_counter += 1;
2717 /* Values <= 32 bytes are returned in o0-o3 (floating-point values are
2718 returned in f0-f3). */
2721 sp64_extract_return_value (struct type *type, char *regbuf, char *valbuf,
2724 int typelen = TYPE_LENGTH (type);
2725 int regsize = REGISTER_RAW_SIZE (O0_REGNUM);
2727 if (TYPE_CODE (type) == TYPE_CODE_FLT && SPARC_HAS_FPU)
2729 memcpy (valbuf, ®buf[REGISTER_BYTE (FP0_REGNUM)], typelen);
2733 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
2734 || (TYPE_LENGTH (type) > 32))
2737 ®buf[O0_REGNUM * regsize +
2738 (typelen >= regsize ? 0 : regsize - typelen)],
2744 char *o0 = ®buf[O0_REGNUM * regsize];
2745 char *f0 = ®buf[FP0_REGNUM * regsize];
2748 for (x = 0; x < TYPE_NFIELDS (type); x++)
2750 struct field *f = &TYPE_FIELDS (type)[x];
2751 /* FIXME: We may need to handle static fields here. */
2752 int whichreg = (f->loc.bitpos + bitoffset) / 32;
2753 int remainder = ((f->loc.bitpos + bitoffset) % 32) / 8;
2754 int where = (f->loc.bitpos + bitoffset) / 8;
2755 int size = TYPE_LENGTH (f->type);
2756 int typecode = TYPE_CODE (f->type);
2758 if (typecode == TYPE_CODE_STRUCT)
2760 sp64_extract_return_value (f->type,
2763 bitoffset + f->loc.bitpos);
2765 else if (typecode == TYPE_CODE_FLT && SPARC_HAS_FPU)
2767 memcpy (valbuf + where, &f0[whichreg * 4] + remainder, size);
2771 memcpy (valbuf + where, &o0[whichreg * 4] + remainder, size);
2778 sparc64_extract_return_value (struct type *type, char *regbuf, char *valbuf)
2780 sp64_extract_return_value (type, regbuf, valbuf, 0);
2784 // OBSOLETE extern void
2785 // OBSOLETE sparclet_extract_return_value (struct type *type,
2786 // OBSOLETE char *regbuf,
2787 // OBSOLETE char *valbuf)
2789 // OBSOLETE regbuf += REGISTER_RAW_SIZE (O0_REGNUM) * 8;
2790 // OBSOLETE if (TYPE_LENGTH (type) < REGISTER_RAW_SIZE (O0_REGNUM))
2791 // OBSOLETE regbuf += REGISTER_RAW_SIZE (O0_REGNUM) - TYPE_LENGTH (type);
2793 // OBSOLETE memcpy ((void *) valbuf, regbuf, TYPE_LENGTH (type));
2798 sparc32_stack_align (CORE_ADDR addr)
2800 return ((addr + 7) & -8);
2804 sparc64_stack_align (CORE_ADDR addr)
2806 return ((addr + 15) & -16);
2810 sparc_print_extra_frame_info (struct frame_info *fi)
2812 if (fi && get_frame_extra_info (fi) && get_frame_extra_info (fi)->flat)
2813 printf_filtered (" flat, pc saved at 0x%s, fp saved at 0x%s\n",
2814 paddr_nz (get_frame_extra_info (fi)->pc_addr),
2815 paddr_nz (get_frame_extra_info (fi)->fp_addr));
2818 /* MULTI_ARCH support */
2821 legacy_register_name (int i)
2823 #ifdef REGISTER_NAMES
2824 static char *names[] = REGISTER_NAMES;
2825 if (i < 0 || i >= (sizeof (names) / sizeof (*names)))
2830 internal_error (__FILE__, __LINE__,
2831 "legacy_register_name: called.");
2837 sparc32_register_name (int regno)
2839 static char *register_names[] =
2840 { "g0", "g1", "g2", "g3", "g4", "g5", "g6", "g7",
2841 "o0", "o1", "o2", "o3", "o4", "o5", "sp", "o7",
2842 "l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7",
2843 "i0", "i1", "i2", "i3", "i4", "i5", "fp", "i7",
2845 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
2846 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
2847 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
2848 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
2850 "y", "psr", "wim", "tbr", "pc", "npc", "fpsr", "cpsr"
2854 regno >= (sizeof (register_names) / sizeof (register_names[0])))
2857 return register_names[regno];
2861 sparc64_register_name (int regno)
2863 static char *register_names[] =
2864 { "g0", "g1", "g2", "g3", "g4", "g5", "g6", "g7",
2865 "o0", "o1", "o2", "o3", "o4", "o5", "sp", "o7",
2866 "l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7",
2867 "i0", "i1", "i2", "i3", "i4", "i5", "fp", "i7",
2869 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
2870 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
2871 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
2872 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
2873 "f32", "f34", "f36", "f38", "f40", "f42", "f44", "f46",
2874 "f48", "f50", "f52", "f54", "f56", "f58", "f60", "f62",
2876 "pc", "npc", "ccr", "fsr", "fprs", "y", "asi", "ver",
2877 "tick", "pil", "pstate", "tstate", "tba", "tl", "tt", "tpc",
2878 "tnpc", "wstate", "cwp", "cansave", "canrestore", "cleanwin", "otherwin",
2879 "asr16", "asr17", "asr18", "asr19", "asr20", "asr21", "asr22", "asr23",
2880 "asr24", "asr25", "asr26", "asr27", "asr28", "asr29", "asr30", "asr31",
2881 /* These are here at the end to simplify removing them if we have to. */
2882 "icc", "xcc", "fcc0", "fcc1", "fcc2", "fcc3"
2886 regno >= (sizeof (register_names) / sizeof (register_names[0])))
2889 return register_names[regno];
2893 // OBSOLETE static const char *
2894 // OBSOLETE sparclite_register_name (int regno)
2896 // OBSOLETE static char *register_names[] =
2897 // OBSOLETE { "g0", "g1", "g2", "g3", "g4", "g5", "g6", "g7",
2898 // OBSOLETE "o0", "o1", "o2", "o3", "o4", "o5", "sp", "o7",
2899 // OBSOLETE "l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7",
2900 // OBSOLETE "i0", "i1", "i2", "i3", "i4", "i5", "fp", "i7",
2902 // OBSOLETE "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
2903 // OBSOLETE "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
2904 // OBSOLETE "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
2905 // OBSOLETE "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
2907 // OBSOLETE "y", "psr", "wim", "tbr", "pc", "npc", "fpsr", "cpsr",
2908 // OBSOLETE "dia1", "dia2", "dda1", "dda2", "ddv1", "ddv2", "dcr", "dsr"
2911 // OBSOLETE if (regno < 0 ||
2912 // OBSOLETE regno >= (sizeof (register_names) / sizeof (register_names[0])))
2913 // OBSOLETE return NULL;
2915 // OBSOLETE return register_names[regno];
2920 // OBSOLETE static const char *
2921 // OBSOLETE sparclet_register_name (int regno)
2923 // OBSOLETE static char *register_names[] =
2924 // OBSOLETE { "g0", "g1", "g2", "g3", "g4", "g5", "g6", "g7",
2925 // OBSOLETE "o0", "o1", "o2", "o3", "o4", "o5", "sp", "o7",
2926 // OBSOLETE "l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7",
2927 // OBSOLETE "i0", "i1", "i2", "i3", "i4", "i5", "fp", "i7",
2929 // OBSOLETE "", "", "", "", "", "", "", "", /* no floating point registers */
2930 // OBSOLETE "", "", "", "", "", "", "", "",
2931 // OBSOLETE "", "", "", "", "", "", "", "",
2932 // OBSOLETE "", "", "", "", "", "", "", "",
2934 // OBSOLETE "y", "psr", "wim", "tbr", "pc", "npc", "", "", /* no FPSR or CPSR */
2935 // OBSOLETE "ccsr", "ccpr", "cccrcr", "ccor", "ccobr", "ccibr", "ccir", "",
2937 // OBSOLETE /* ASR15 ASR19 (don't display them) */
2938 // OBSOLETE "asr1", "", "asr17", "asr18", "", "asr20", "asr21", "asr22"
2939 // OBSOLETE /* None of the rest get displayed */
2941 // OBSOLETE "awr0", "awr1", "awr2", "awr3", "awr4", "awr5", "awr6", "awr7",
2942 // OBSOLETE "awr8", "awr9", "awr10", "awr11", "awr12", "awr13", "awr14", "awr15",
2943 // OBSOLETE "awr16", "awr17", "awr18", "awr19", "awr20", "awr21", "awr22", "awr23",
2944 // OBSOLETE "awr24", "awr25", "awr26", "awr27", "awr28", "awr29", "awr30", "awr31",
2946 // OBSOLETE #endif /* 0 */
2949 // OBSOLETE if (regno < 0 ||
2950 // OBSOLETE regno >= (sizeof (register_names) / sizeof (register_names[0])))
2951 // OBSOLETE return NULL;
2953 // OBSOLETE return register_names[regno];
2958 sparc_push_return_address (CORE_ADDR pc_unused, CORE_ADDR sp)
2960 if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT)
2962 /* The return PC of the dummy_frame is the former 'current' PC
2963 (where we were before we made the target function call).
2964 This is saved in %i7 by push_dummy_frame.
2966 We will save the 'call dummy location' (ie. the address
2967 to which the target function will return) in %o7.
2968 This address will actually be the program's entry point.
2969 There will be a special call_dummy breakpoint there. */
2971 if (DEPRECATED_CALL_DUMMY_ADDRESS_P ())
2972 write_register (O7_REGNUM, DEPRECATED_CALL_DUMMY_ADDRESS () - 8);
2974 write_register (O7_REGNUM, entry_point_address () - 8);
2980 /* Should call_function allocate stack space for a struct return? */
2983 sparc64_use_struct_convention (int gcc_p, struct type *type)
2985 return (TYPE_LENGTH (type) > 32);
2988 /* Store the address of the place in which to copy the structure the
2989 subroutine will return. This is called from call_function_by_hand.
2990 The ultimate mystery is, tho, what is the value "16"?
2992 MVS: That's the offset from where the sp is now, to where the
2993 subroutine is gonna expect to find the struct return address. */
2996 sparc32_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
3001 val = alloca (SPARC_INTREG_SIZE);
3002 store_unsigned_integer (val, SPARC_INTREG_SIZE, addr);
3003 write_memory (sp + (16 * SPARC_INTREG_SIZE), val, SPARC_INTREG_SIZE);
3005 if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT)
3007 /* Now adjust the value of the link register, which was previously
3008 stored by push_return_address. Functions that return structs are
3009 peculiar in that they return to link register + 12, rather than
3010 link register + 8. */
3012 o7 = read_register (O7_REGNUM);
3013 write_register (O7_REGNUM, o7 - 4);
3018 sparc64_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
3020 /* FIXME: V9 uses %o0 for this. */
3021 /* FIXME MVS: Only for small enough structs!!! */
3023 target_write_memory (sp + (16 * SPARC_INTREG_SIZE),
3024 (char *) &addr, SPARC_INTREG_SIZE);
3026 if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT)
3028 /* Now adjust the value of the link register, which was previously
3029 stored by push_return_address. Functions that return structs are
3030 peculiar in that they return to link register + 12, rather than
3031 link register + 8. */
3033 write_register (O7_REGNUM, read_register (O7_REGNUM) - 4);
3038 /* Default target data type for register REGNO. */
3040 static struct type *
3041 sparc32_register_virtual_type (int regno)
3043 if (regno == PC_REGNUM ||
3044 regno == DEPRECATED_FP_REGNUM ||
3046 return builtin_type_unsigned_int;
3048 return builtin_type_int;
3050 return builtin_type_float;
3051 return builtin_type_int;
3054 static struct type *
3055 sparc64_register_virtual_type (int regno)
3057 if (regno == PC_REGNUM ||
3058 regno == DEPRECATED_FP_REGNUM ||
3060 return builtin_type_unsigned_long_long;
3062 return builtin_type_long_long;
3064 return builtin_type_float;
3066 return builtin_type_double;
3067 return builtin_type_long_long;
3070 /* Number of bytes of storage in the actual machine representation for
3074 sparc32_register_size (int regno)
3080 sparc64_register_size (int regno)
3082 return (regno < 32 ? 8 : regno < 64 ? 4 : 8);
3085 /* Index within the `registers' buffer of the first byte of the space
3086 for register REGNO. */
3089 sparc32_register_byte (int regno)
3095 sparc64_register_byte (int regno)
3099 else if (regno < 64)
3100 return 32 * 8 + (regno - 32) * 4;
3101 else if (regno < 80)
3102 return 32 * 8 + 32 * 4 + (regno - 64) * 8;
3104 return 64 * 8 + (regno - 80) * 8;
3107 /* Immediately after a function call, return the saved pc.
3108 Can't go through the frames for this because on some machines
3109 the new frame is not set up until the new function executes
3110 some instructions. */
3113 sparc_saved_pc_after_call (struct frame_info *fi)
3115 return sparc_pc_adjust (read_register (RP_REGNUM));
3118 /* Init saved regs: nothing to do, just a place-holder function. */
3121 sparc_frame_init_saved_regs (struct frame_info *fi_ignored)
3125 /* gdbarch fix call dummy:
3126 All this function does is rearrange the arguments before calling
3127 sparc_fix_call_dummy (which does the real work). */
3130 sparc_gdbarch_fix_call_dummy (char *dummy,
3134 struct value **args,
3138 if (CALL_DUMMY_LOCATION == ON_STACK)
3139 sparc_fix_call_dummy (dummy, pc, fun, type, gcc_p);
3142 /* DEPRECATED_CALL_DUMMY_ADDRESS: fetch the breakpoint address for a
3146 sparc_call_dummy_address (void)
3148 return (DEPRECATED_CALL_DUMMY_START_OFFSET) + DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET;
3151 /* Supply the Y register number to those that need it. */
3154 sparc_y_regnum (void)
3156 return gdbarch_tdep (current_gdbarch)->y_regnum;
3160 sparc_reg_struct_has_addr (int gcc_p, struct type *type)
3162 if (GDB_TARGET_IS_SPARC64)
3163 return (TYPE_LENGTH (type) > 32);
3165 return (gcc_p != 1);
3169 sparc_intreg_size (void)
3171 return SPARC_INTREG_SIZE;
3175 sparc_return_value_on_stack (struct type *type)
3177 if (TYPE_CODE (type) == TYPE_CODE_FLT &&
3178 TYPE_LENGTH (type) > 8)
3184 /* Get the ith function argument for the current function. */
3186 sparc_fetch_pointer_argument (struct frame_info *frame, int argi,
3190 frame_read_register (frame, O0_REGNUM + argi, &addr);
3195 * Gdbarch "constructor" function.
3198 #define SPARC32_CALL_DUMMY_ON_STACK
3200 #define SPARC_SP_REGNUM 14
3201 #define SPARC_FP_REGNUM 30
3202 #define SPARC_FP0_REGNUM 32
3203 #define SPARC32_NPC_REGNUM 69
3204 #define SPARC32_PC_REGNUM 68
3205 #define SPARC32_Y_REGNUM 64
3206 #define SPARC64_PC_REGNUM 80
3207 #define SPARC64_NPC_REGNUM 81
3208 #define SPARC64_Y_REGNUM 85
3210 static struct gdbarch *
3211 sparc_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
3213 struct gdbarch *gdbarch;
3214 struct gdbarch_tdep *tdep;
3216 static LONGEST call_dummy_32[] =
3217 { 0xbc100001, 0x9de38000, 0xbc100002, 0xbe100003,
3218 0xda03a058, 0xd803a054, 0xd603a050, 0xd403a04c,
3219 0xd203a048, 0x40000000, 0xd003a044, 0x01000000,
3220 0x91d02001, 0x01000000
3222 static LONGEST call_dummy_64[] =
3223 { 0x9de3bec0fd3fa7f7LL, 0xf93fa7eff53fa7e7LL,
3224 0xf13fa7dfed3fa7d7LL, 0xe93fa7cfe53fa7c7LL,
3225 0xe13fa7bfdd3fa7b7LL, 0xd93fa7afd53fa7a7LL,
3226 0xd13fa79fcd3fa797LL, 0xc93fa78fc53fa787LL,
3227 0xc13fa77fcc3fa777LL, 0xc83fa76fc43fa767LL,
3228 0xc03fa75ffc3fa757LL, 0xf83fa74ff43fa747LL,
3229 0xf03fa73f01000000LL, 0x0100000001000000LL,
3230 0x0100000091580000LL, 0xd027a72b93500000LL,
3231 0xd027a72791480000LL, 0xd027a72391400000LL,
3232 0xd027a71fda5ba8a7LL, 0xd85ba89fd65ba897LL,
3233 0xd45ba88fd25ba887LL, 0x9fc02000d05ba87fLL,
3234 0x0100000091d02001LL, 0x0100000001000000LL
3236 static LONGEST call_dummy_nil[] = {0};
3238 /* Try to determine the OS ABI of the object we are loading. */
3240 if (info.abfd != NULL
3241 && info.osabi == GDB_OSABI_UNKNOWN)
3243 /* If it's an ELF file, assume it's Solaris. */
3244 if (bfd_get_flavour (info.abfd) == bfd_target_elf_flavour)
3245 info.osabi = GDB_OSABI_SOLARIS;
3248 /* First see if there is already a gdbarch that can satisfy the request. */
3249 arches = gdbarch_list_lookup_by_info (arches, &info);
3251 return arches->gdbarch;
3253 /* None found: is the request for a sparc architecture? */
3254 if (info.bfd_arch_info->arch != bfd_arch_sparc)
3255 return NULL; /* No; then it's not for us. */
3257 /* Yes: create a new gdbarch for the specified machine type. */
3258 tdep = (struct gdbarch_tdep *) xmalloc (sizeof (struct gdbarch_tdep));
3259 gdbarch = gdbarch_alloc (&info, tdep);
3261 /* First set settings that are common for all sparc architectures. */
3262 set_gdbarch_believe_pcc_promotion (gdbarch, 1);
3263 set_gdbarch_breakpoint_from_pc (gdbarch, sparc_breakpoint_from_pc);
3264 set_gdbarch_decr_pc_after_break (gdbarch, 0);
3265 set_gdbarch_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
3266 set_gdbarch_extract_struct_value_address (gdbarch,
3267 sparc_extract_struct_value_address);
3268 set_gdbarch_deprecated_fix_call_dummy (gdbarch, sparc_gdbarch_fix_call_dummy);
3269 set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
3270 set_gdbarch_deprecated_fp_regnum (gdbarch, SPARC_FP_REGNUM);
3271 set_gdbarch_fp0_regnum (gdbarch, SPARC_FP0_REGNUM);
3272 set_gdbarch_deprecated_frame_chain (gdbarch, sparc_frame_chain);
3273 set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, sparc_frame_init_saved_regs);
3274 set_gdbarch_deprecated_frame_saved_pc (gdbarch, sparc_frame_saved_pc);
3275 set_gdbarch_frameless_function_invocation (gdbarch,
3276 frameless_look_for_prologue);
3277 set_gdbarch_deprecated_get_saved_register (gdbarch, sparc_get_saved_register);
3278 set_gdbarch_deprecated_init_extra_frame_info (gdbarch, sparc_init_extra_frame_info);
3279 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
3280 set_gdbarch_int_bit (gdbarch, 4 * TARGET_CHAR_BIT);
3281 set_gdbarch_long_double_bit (gdbarch, 16 * TARGET_CHAR_BIT);
3282 set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
3283 set_gdbarch_deprecated_max_register_raw_size (gdbarch, 8);
3284 set_gdbarch_deprecated_max_register_virtual_size (gdbarch, 8);
3285 set_gdbarch_deprecated_pop_frame (gdbarch, sparc_pop_frame);
3286 set_gdbarch_deprecated_push_return_address (gdbarch, sparc_push_return_address);
3287 set_gdbarch_deprecated_push_dummy_frame (gdbarch, sparc_push_dummy_frame);
3288 set_gdbarch_reg_struct_has_addr (gdbarch, sparc_reg_struct_has_addr);
3289 set_gdbarch_return_value_on_stack (gdbarch, sparc_return_value_on_stack);
3290 set_gdbarch_deprecated_saved_pc_after_call (gdbarch, sparc_saved_pc_after_call);
3291 set_gdbarch_prologue_frameless_p (gdbarch, sparc_prologue_frameless_p);
3292 set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
3293 set_gdbarch_skip_prologue (gdbarch, sparc_skip_prologue);
3294 set_gdbarch_sp_regnum (gdbarch, SPARC_SP_REGNUM);
3295 set_gdbarch_deprecated_use_generic_dummy_frames (gdbarch, 0);
3296 set_gdbarch_write_pc (gdbarch, generic_target_write_pc);
3298 /* Helper for function argument information. */
3299 set_gdbarch_fetch_pointer_argument (gdbarch, sparc_fetch_pointer_argument);
3302 * Settings that depend only on 32/64 bit word size
3305 switch (info.bfd_arch_info->mach)
3307 case bfd_mach_sparc:
3309 // OBSOLETE case bfd_mach_sparc_sparclet:
3310 // OBSOLETE case bfd_mach_sparc_sparclite:
3312 case bfd_mach_sparc_v8plus:
3313 case bfd_mach_sparc_v8plusa:
3315 // OBSOLETE case bfd_mach_sparc_sparclite_le:
3317 /* 32-bit machine types: */
3319 #ifdef SPARC32_CALL_DUMMY_ON_STACK
3320 set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_on_stack);
3321 set_gdbarch_deprecated_call_dummy_address (gdbarch, sparc_call_dummy_address);
3322 set_gdbarch_deprecated_call_dummy_breakpoint_offset (gdbarch, 0x30);
3323 set_gdbarch_deprecated_call_dummy_length (gdbarch, 0x38);
3325 /* NOTE: cagney/2003-05-01: Using the just added push_dummy_code
3326 architecture method, it is now possible to implement a
3327 generic dummy frames based inferior function call that stores
3328 the breakpoint (and struct info) on the stack. Further, by
3329 treating a SIGSEG at a breakpoint as equivalent to a SIGTRAP
3330 it is even possible to make this work when the stack is
3333 NOTE: cagney/2002-04-26: Based from info posted by Peter
3334 Schauer around Oct '99. Briefly, due to aspects of the SPARC
3335 ABI, it isn't possible to use ON_STACK with a strictly
3338 Peter Schauer writes ...
3340 No, any call from GDB to a user function returning a
3341 struct/union will fail miserably. Try this:
3360 for (i = 0; i < 4; i++)
3366 Set a breakpoint at the gx = sret () statement, run to it and
3367 issue a `print sret()'. It will not succed with your
3368 approach, and I doubt that continuing the program will work
3371 For details of the ABI see the Sparc Architecture Manual. I
3372 have Version 8 (Prentice Hall ISBN 0-13-825001-4) and the
3373 calling conventions for functions returning aggregate values
3374 are explained in Appendix D.3. */
3376 set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
3377 set_gdbarch_deprecated_call_dummy_words (gdbarch, call_dummy_32);
3379 set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_at_entry_point);
3380 set_gdbarch_deprecated_call_dummy_words (gdbarch, call_dummy_nil);
3382 set_gdbarch_deprecated_call_dummy_stack_adjust (gdbarch, 68);
3383 set_gdbarch_frame_args_skip (gdbarch, 68);
3384 set_gdbarch_function_start_offset (gdbarch, 0);
3385 set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
3386 set_gdbarch_npc_regnum (gdbarch, SPARC32_NPC_REGNUM);
3387 set_gdbarch_pc_regnum (gdbarch, SPARC32_PC_REGNUM);
3388 set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
3389 set_gdbarch_deprecated_push_arguments (gdbarch, sparc32_push_arguments);
3391 set_gdbarch_deprecated_register_byte (gdbarch, sparc32_register_byte);
3392 set_gdbarch_deprecated_register_raw_size (gdbarch, sparc32_register_size);
3393 set_gdbarch_deprecated_register_size (gdbarch, 4);
3394 set_gdbarch_deprecated_register_virtual_size (gdbarch, sparc32_register_size);
3395 set_gdbarch_deprecated_register_virtual_type (gdbarch, sparc32_register_virtual_type);
3396 #ifdef SPARC32_CALL_DUMMY_ON_STACK
3397 set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof (call_dummy_32));
3399 set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, 0);
3401 set_gdbarch_deprecated_stack_align (gdbarch, sparc32_stack_align);
3402 set_gdbarch_deprecated_extra_stack_alignment_needed (gdbarch, 1);
3403 set_gdbarch_deprecated_store_struct_return (gdbarch, sparc32_store_struct_return);
3404 set_gdbarch_use_struct_convention (gdbarch,
3405 generic_use_struct_convention);
3406 set_gdbarch_deprecated_dummy_write_sp (gdbarch, deprecated_write_sp);
3407 tdep->y_regnum = SPARC32_Y_REGNUM;
3408 tdep->fp_max_regnum = SPARC_FP0_REGNUM + 32;
3409 tdep->intreg_size = 4;
3410 tdep->reg_save_offset = 0x60;
3411 tdep->call_dummy_call_offset = 0x24;
3414 case bfd_mach_sparc_v9:
3415 case bfd_mach_sparc_v9a:
3416 /* 64-bit machine types: */
3417 default: /* Any new machine type is likely to be 64-bit. */
3419 #ifdef SPARC64_CALL_DUMMY_ON_STACK
3420 set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_on_stack);
3421 set_gdbarch_deprecated_call_dummy_address (gdbarch, sparc_call_dummy_address);
3422 set_gdbarch_deprecated_call_dummy_breakpoint_offset (gdbarch, 8 * 4);
3423 set_gdbarch_deprecated_call_dummy_length (gdbarch, 192);
3424 set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
3425 set_gdbarch_deprecated_call_dummy_start_offset (gdbarch, 148);
3426 set_gdbarch_deprecated_call_dummy_words (gdbarch, call_dummy_64);
3428 set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_at_entry_point);
3429 set_gdbarch_deprecated_call_dummy_words (gdbarch, call_dummy_nil);
3431 set_gdbarch_deprecated_call_dummy_stack_adjust (gdbarch, 128);
3432 set_gdbarch_frame_args_skip (gdbarch, 136);
3433 set_gdbarch_function_start_offset (gdbarch, 0);
3434 set_gdbarch_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
3435 set_gdbarch_npc_regnum (gdbarch, SPARC64_NPC_REGNUM);
3436 set_gdbarch_pc_regnum (gdbarch, SPARC64_PC_REGNUM);
3437 set_gdbarch_ptr_bit (gdbarch, 8 * TARGET_CHAR_BIT);
3438 set_gdbarch_deprecated_push_arguments (gdbarch, sparc64_push_arguments);
3439 /* NOTE different for at_entry */
3440 set_gdbarch_deprecated_target_read_fp (gdbarch, sparc64_read_fp);
3441 set_gdbarch_read_sp (gdbarch, sparc64_read_sp);
3442 /* Some of the registers aren't 64 bits, but it's a lot simpler just
3443 to assume they all are (since most of them are). */
3444 set_gdbarch_deprecated_register_byte (gdbarch, sparc64_register_byte);
3445 set_gdbarch_deprecated_register_raw_size (gdbarch, sparc64_register_size);
3446 set_gdbarch_deprecated_register_size (gdbarch, 8);
3447 set_gdbarch_deprecated_register_virtual_size (gdbarch, sparc64_register_size);
3448 set_gdbarch_deprecated_register_virtual_type (gdbarch, sparc64_register_virtual_type);
3449 #ifdef SPARC64_CALL_DUMMY_ON_STACK
3450 set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof (call_dummy_64));
3452 set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, 0);
3454 set_gdbarch_deprecated_stack_align (gdbarch, sparc64_stack_align);
3455 set_gdbarch_deprecated_extra_stack_alignment_needed (gdbarch, 1);
3456 set_gdbarch_deprecated_store_struct_return (gdbarch, sparc64_store_struct_return);
3457 set_gdbarch_use_struct_convention (gdbarch,
3458 sparc64_use_struct_convention);
3459 set_gdbarch_deprecated_dummy_write_sp (gdbarch, sparc64_write_sp);
3460 tdep->y_regnum = SPARC64_Y_REGNUM;
3461 tdep->fp_max_regnum = SPARC_FP0_REGNUM + 48;
3462 tdep->intreg_size = 8;
3463 tdep->reg_save_offset = 0x90;
3464 tdep->call_dummy_call_offset = 148 + 4 * 5;
3469 * Settings that vary per-architecture:
3472 switch (info.bfd_arch_info->mach)
3474 case bfd_mach_sparc:
3475 set_gdbarch_extract_return_value (gdbarch, sparc32_extract_return_value);
3476 set_gdbarch_store_return_value (gdbarch, sparc32_store_return_value);
3477 set_gdbarch_num_regs (gdbarch, 72);
3478 set_gdbarch_deprecated_register_bytes (gdbarch, 32*4 + 32*4 + 8*4);
3479 set_gdbarch_register_name (gdbarch, sparc32_register_name);
3481 // OBSOLETE tdep->has_fpu = 1; /* (all but sparclet and sparclite) */
3483 tdep->fp_register_bytes = 32 * 4;
3484 tdep->print_insn_mach = bfd_mach_sparc;
3487 // OBSOLETE case bfd_mach_sparc_sparclet:
3488 // OBSOLETE set_gdbarch_deprecated_extract_return_value (gdbarch, sparclet_extract_return_value);
3489 // OBSOLETE set_gdbarch_num_regs (gdbarch, 32 + 32 + 8 + 8 + 8);
3490 // OBSOLETE set_gdbarch_register_bytes (gdbarch, 32*4 + 32*4 + 8*4 + 8*4 + 8*4);
3491 // OBSOLETE set_gdbarch_register_name (gdbarch, sparclet_register_name);
3492 // OBSOLETE set_gdbarch_deprecated_store_return_value (gdbarch, sparclet_store_return_value);
3493 // OBSOLETE tdep->has_fpu = 0; /* (all but sparclet and sparclite) */
3494 // OBSOLETE tdep->fp_register_bytes = 0;
3495 // OBSOLETE tdep->print_insn_mach = bfd_mach_sparc_sparclet;
3499 // OBSOLETE case bfd_mach_sparc_sparclite:
3500 // OBSOLETE set_gdbarch_deprecated_extract_return_value (gdbarch, sparc32_extract_return_value);
3501 // OBSOLETE set_gdbarch_num_regs (gdbarch, 80);
3502 // OBSOLETE set_gdbarch_register_bytes (gdbarch, 32*4 + 32*4 + 8*4 + 8*4);
3503 // OBSOLETE set_gdbarch_register_name (gdbarch, sparclite_register_name);
3504 // OBSOLETE set_gdbarch_deprecated_store_return_value (gdbarch, sparc_store_return_value);
3505 // OBSOLETE tdep->has_fpu = 0; /* (all but sparclet and sparclite) */
3506 // OBSOLETE tdep->fp_register_bytes = 0;
3507 // OBSOLETE tdep->print_insn_mach = bfd_mach_sparc_sparclite;
3510 case bfd_mach_sparc_v8plus:
3511 set_gdbarch_extract_return_value (gdbarch, sparc32_extract_return_value);
3512 set_gdbarch_store_return_value (gdbarch, sparc32_store_return_value);
3513 set_gdbarch_num_regs (gdbarch, 72);
3514 set_gdbarch_deprecated_register_bytes (gdbarch, 32*4 + 32*4 + 8*4);
3515 set_gdbarch_register_name (gdbarch, sparc32_register_name);
3516 tdep->print_insn_mach = bfd_mach_sparc;
3517 tdep->fp_register_bytes = 32 * 4;
3519 // OBSOLETE tdep->has_fpu = 1; /* (all but sparclet and sparclite) */
3522 case bfd_mach_sparc_v8plusa:
3523 set_gdbarch_extract_return_value (gdbarch, sparc32_extract_return_value);
3524 set_gdbarch_store_return_value (gdbarch, sparc32_store_return_value);
3525 set_gdbarch_num_regs (gdbarch, 72);
3526 set_gdbarch_deprecated_register_bytes (gdbarch, 32*4 + 32*4 + 8*4);
3527 set_gdbarch_register_name (gdbarch, sparc32_register_name);
3529 // OBSOLETE tdep->has_fpu = 1; /* (all but sparclet and sparclite) */
3531 tdep->fp_register_bytes = 32 * 4;
3532 tdep->print_insn_mach = bfd_mach_sparc;
3535 // OBSOLETE case bfd_mach_sparc_sparclite_le:
3536 // OBSOLETE set_gdbarch_deprecated_extract_return_value (gdbarch, sparc32_extract_return_value);
3537 // OBSOLETE set_gdbarch_num_regs (gdbarch, 80);
3538 // OBSOLETE set_gdbarch_register_bytes (gdbarch, 32*4 + 32*4 + 8*4 + 8*4);
3539 // OBSOLETE set_gdbarch_register_name (gdbarch, sparclite_register_name);
3540 // OBSOLETE set_gdbarch_deprecated_store_return_value (gdbarch, sparc_store_return_value);
3541 // OBSOLETE tdep->has_fpu = 0; /* (all but sparclet and sparclite) */
3542 // OBSOLETE tdep->fp_register_bytes = 0;
3543 // OBSOLETE tdep->print_insn_mach = bfd_mach_sparc_sparclite;
3546 case bfd_mach_sparc_v9:
3547 set_gdbarch_deprecated_extract_return_value (gdbarch, sparc64_extract_return_value);
3548 set_gdbarch_num_regs (gdbarch, 125);
3549 set_gdbarch_deprecated_register_bytes (gdbarch, 32*8 + 32*8 + 45*8);
3550 set_gdbarch_register_name (gdbarch, sparc64_register_name);
3551 set_gdbarch_deprecated_store_return_value (gdbarch, sparc_store_return_value);
3553 // OBSOLETE tdep->has_fpu = 1; /* (all but sparclet and sparclite) */
3555 tdep->fp_register_bytes = 64 * 4;
3556 tdep->print_insn_mach = bfd_mach_sparc_v9a;
3558 case bfd_mach_sparc_v9a:
3559 set_gdbarch_deprecated_extract_return_value (gdbarch, sparc64_extract_return_value);
3560 set_gdbarch_num_regs (gdbarch, 125);
3561 set_gdbarch_deprecated_register_bytes (gdbarch, 32*8 + 32*8 + 45*8);
3562 set_gdbarch_register_name (gdbarch, sparc64_register_name);
3563 set_gdbarch_deprecated_store_return_value (gdbarch, sparc_store_return_value);
3565 // OBSOLETE tdep->has_fpu = 1; /* (all but sparclet and sparclite) */
3567 tdep->fp_register_bytes = 64 * 4;
3568 tdep->print_insn_mach = bfd_mach_sparc_v9a;
3572 set_gdbarch_print_insn (gdbarch, print_insn_sparc);
3574 /* Hook in OS ABI-specific overrides, if they have been registered. */
3575 gdbarch_init_osabi (info, gdbarch);
3581 sparc_dump_tdep (struct gdbarch *current_gdbarch, struct ui_file *file)
3583 struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
3589 // OBSOLETE fprintf_unfiltered (file, "sparc_dump_tdep: has_fpu = %d\n",
3590 // OBSOLETE tdep->has_fpu);
3592 fprintf_unfiltered (file, "sparc_dump_tdep: fp_register_bytes = %d\n",
3593 tdep->fp_register_bytes);
3594 fprintf_unfiltered (file, "sparc_dump_tdep: y_regnum = %d\n",
3596 fprintf_unfiltered (file, "sparc_dump_tdep: fp_max_regnum = %d\n",
3597 tdep->fp_max_regnum);
3598 fprintf_unfiltered (file, "sparc_dump_tdep: intreg_size = %d\n",
3600 fprintf_unfiltered (file, "sparc_dump_tdep: reg_save_offset = %d\n",
3601 tdep->reg_save_offset);
3602 fprintf_unfiltered (file, "sparc_dump_tdep: call_dummy_call_offset = %d\n",
3603 tdep->call_dummy_call_offset);
3604 fprintf_unfiltered (file, "sparc_dump_tdep: print_insn_match = %d\n",
3605 tdep->print_insn_mach);