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 DEPRECATED_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 (DEPRECATED_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 tmp = get_frame_register_unsigned (fi, DEPRECATED_FP_REGNUM);
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 tmp = get_frame_register_unsigned (fi, I7_REGNUM);
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 tmp = get_frame_register_unsigned (frame, O0_REGNUM + 2);
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 tmp = get_frame_register_unsigned (frame, O7_REGNUM);
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 = DEPRECATED_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 (DEPRECATED_REGISTER_BYTE (PC_REGNUM),
977 REGISTER_RAW_SIZE (PC_REGNUM) * 7);
978 deprecated_read_register_bytes (DEPRECATED_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 (DEPRECATED_REGISTER_BYTE (Y_REGNUM),
988 REGISTER_RAW_SIZE (Y_REGNUM) * 8);
991 deprecated_read_register_bytes (DEPRECATED_REGISTER_BYTE (O0_REGNUM),
992 ®ister_temp[8 * SPARC_INTREG_SIZE],
993 SPARC_INTREG_SIZE * 8);
995 deprecated_read_register_bytes (DEPRECATED_REGISTER_BYTE (G0_REGNUM),
996 ®ister_temp[16 * SPARC_INTREG_SIZE],
997 SPARC_INTREG_SIZE * 8);
1000 deprecated_read_register_bytes (DEPRECATED_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)
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 struct frame_info *frame = get_current_frame ();
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 (DEPRECATED_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 (DEPRECATED_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 (DEPRECATED_REGISTER_BYTE (O0_REGNUM), raw_buffer,
1301 SPARC_INTREG_SIZE * 8);
1303 deprecated_write_register_bytes (DEPRECATED_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[DEPRECATED_NPC_REGNUM])
1324 write_register (DEPRECATED_NPC_REGNUM,
1325 read_memory_integer (fsr[DEPRECATED_NPC_REGNUM],
1326 REGISTER_RAW_SIZE (DEPRECATED_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 tmp = get_frame_register_unsigned (frame, O7_REGNUM);
1341 pc = PC_ADJUST (tmp);
1344 write_register (PC_REGNUM, pc);
1345 write_register (DEPRECATED_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 (DEPRECATED_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 (DEPRECATED_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 == DEPRECATED_NPC_REGNUM))
1602 deprecated_read_register_gen (DEPRECATED_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[DEPRECATED_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[DEPRECATED_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 (DEPRECATED_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 (DEPRECATED_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[DEPRECATED_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));
2819 sparc32_register_name (int regno)
2821 static char *register_names[] =
2822 { "g0", "g1", "g2", "g3", "g4", "g5", "g6", "g7",
2823 "o0", "o1", "o2", "o3", "o4", "o5", "sp", "o7",
2824 "l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7",
2825 "i0", "i1", "i2", "i3", "i4", "i5", "fp", "i7",
2827 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
2828 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
2829 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
2830 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
2832 "y", "psr", "wim", "tbr", "pc", "npc", "fpsr", "cpsr"
2836 regno >= (sizeof (register_names) / sizeof (register_names[0])))
2839 return register_names[regno];
2843 sparc64_register_name (int regno)
2845 static char *register_names[] =
2846 { "g0", "g1", "g2", "g3", "g4", "g5", "g6", "g7",
2847 "o0", "o1", "o2", "o3", "o4", "o5", "sp", "o7",
2848 "l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7",
2849 "i0", "i1", "i2", "i3", "i4", "i5", "fp", "i7",
2851 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
2852 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
2853 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
2854 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
2855 "f32", "f34", "f36", "f38", "f40", "f42", "f44", "f46",
2856 "f48", "f50", "f52", "f54", "f56", "f58", "f60", "f62",
2858 "pc", "npc", "ccr", "fsr", "fprs", "y", "asi", "ver",
2859 "tick", "pil", "pstate", "tstate", "tba", "tl", "tt", "tpc",
2860 "tnpc", "wstate", "cwp", "cansave", "canrestore", "cleanwin", "otherwin",
2861 "asr16", "asr17", "asr18", "asr19", "asr20", "asr21", "asr22", "asr23",
2862 "asr24", "asr25", "asr26", "asr27", "asr28", "asr29", "asr30", "asr31",
2863 /* These are here at the end to simplify removing them if we have to. */
2864 "icc", "xcc", "fcc0", "fcc1", "fcc2", "fcc3"
2868 regno >= (sizeof (register_names) / sizeof (register_names[0])))
2871 return register_names[regno];
2875 // OBSOLETE static const char *
2876 // OBSOLETE sparclite_register_name (int regno)
2878 // OBSOLETE static char *register_names[] =
2879 // OBSOLETE { "g0", "g1", "g2", "g3", "g4", "g5", "g6", "g7",
2880 // OBSOLETE "o0", "o1", "o2", "o3", "o4", "o5", "sp", "o7",
2881 // OBSOLETE "l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7",
2882 // OBSOLETE "i0", "i1", "i2", "i3", "i4", "i5", "fp", "i7",
2884 // OBSOLETE "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
2885 // OBSOLETE "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
2886 // OBSOLETE "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
2887 // OBSOLETE "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
2889 // OBSOLETE "y", "psr", "wim", "tbr", "pc", "npc", "fpsr", "cpsr",
2890 // OBSOLETE "dia1", "dia2", "dda1", "dda2", "ddv1", "ddv2", "dcr", "dsr"
2893 // OBSOLETE if (regno < 0 ||
2894 // OBSOLETE regno >= (sizeof (register_names) / sizeof (register_names[0])))
2895 // OBSOLETE return NULL;
2897 // OBSOLETE return register_names[regno];
2902 // OBSOLETE static const char *
2903 // OBSOLETE sparclet_register_name (int regno)
2905 // OBSOLETE static char *register_names[] =
2906 // OBSOLETE { "g0", "g1", "g2", "g3", "g4", "g5", "g6", "g7",
2907 // OBSOLETE "o0", "o1", "o2", "o3", "o4", "o5", "sp", "o7",
2908 // OBSOLETE "l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7",
2909 // OBSOLETE "i0", "i1", "i2", "i3", "i4", "i5", "fp", "i7",
2911 // OBSOLETE "", "", "", "", "", "", "", "", /* no floating point registers */
2912 // OBSOLETE "", "", "", "", "", "", "", "",
2913 // OBSOLETE "", "", "", "", "", "", "", "",
2914 // OBSOLETE "", "", "", "", "", "", "", "",
2916 // OBSOLETE "y", "psr", "wim", "tbr", "pc", "npc", "", "", /* no FPSR or CPSR */
2917 // OBSOLETE "ccsr", "ccpr", "cccrcr", "ccor", "ccobr", "ccibr", "ccir", "",
2919 // OBSOLETE /* ASR15 ASR19 (don't display them) */
2920 // OBSOLETE "asr1", "", "asr17", "asr18", "", "asr20", "asr21", "asr22"
2921 // OBSOLETE /* None of the rest get displayed */
2923 // OBSOLETE "awr0", "awr1", "awr2", "awr3", "awr4", "awr5", "awr6", "awr7",
2924 // OBSOLETE "awr8", "awr9", "awr10", "awr11", "awr12", "awr13", "awr14", "awr15",
2925 // OBSOLETE "awr16", "awr17", "awr18", "awr19", "awr20", "awr21", "awr22", "awr23",
2926 // OBSOLETE "awr24", "awr25", "awr26", "awr27", "awr28", "awr29", "awr30", "awr31",
2928 // OBSOLETE #endif /* 0 */
2931 // OBSOLETE if (regno < 0 ||
2932 // OBSOLETE regno >= (sizeof (register_names) / sizeof (register_names[0])))
2933 // OBSOLETE return NULL;
2935 // OBSOLETE return register_names[regno];
2940 sparc_push_return_address (CORE_ADDR pc_unused, CORE_ADDR sp)
2942 if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT)
2944 /* The return PC of the dummy_frame is the former 'current' PC
2945 (where we were before we made the target function call).
2946 This is saved in %i7 by push_dummy_frame.
2948 We will save the 'call dummy location' (ie. the address
2949 to which the target function will return) in %o7.
2950 This address will actually be the program's entry point.
2951 There will be a special call_dummy breakpoint there. */
2953 if (DEPRECATED_CALL_DUMMY_ADDRESS_P ())
2954 write_register (O7_REGNUM, DEPRECATED_CALL_DUMMY_ADDRESS () - 8);
2956 write_register (O7_REGNUM, entry_point_address () - 8);
2962 /* Should call_function allocate stack space for a struct return? */
2965 sparc64_use_struct_convention (int gcc_p, struct type *type)
2967 return (TYPE_LENGTH (type) > 32);
2970 /* Store the address of the place in which to copy the structure the
2971 subroutine will return. This is called from call_function_by_hand.
2972 The ultimate mystery is, tho, what is the value "16"?
2974 MVS: That's the offset from where the sp is now, to where the
2975 subroutine is gonna expect to find the struct return address. */
2978 sparc32_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
2983 val = alloca (SPARC_INTREG_SIZE);
2984 store_unsigned_integer (val, SPARC_INTREG_SIZE, addr);
2985 write_memory (sp + (16 * SPARC_INTREG_SIZE), val, SPARC_INTREG_SIZE);
2987 if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT)
2989 /* Now adjust the value of the link register, which was previously
2990 stored by push_return_address. Functions that return structs are
2991 peculiar in that they return to link register + 12, rather than
2992 link register + 8. */
2994 o7 = read_register (O7_REGNUM);
2995 write_register (O7_REGNUM, o7 - 4);
3000 sparc64_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
3002 /* FIXME: V9 uses %o0 for this. */
3003 /* FIXME MVS: Only for small enough structs!!! */
3005 target_write_memory (sp + (16 * SPARC_INTREG_SIZE),
3006 (char *) &addr, SPARC_INTREG_SIZE);
3008 if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT)
3010 /* Now adjust the value of the link register, which was previously
3011 stored by push_return_address. Functions that return structs are
3012 peculiar in that they return to link register + 12, rather than
3013 link register + 8. */
3015 write_register (O7_REGNUM, read_register (O7_REGNUM) - 4);
3020 /* Default target data type for register REGNO. */
3022 static struct type *
3023 sparc32_register_virtual_type (int regno)
3025 if (regno == PC_REGNUM ||
3026 regno == DEPRECATED_FP_REGNUM ||
3028 return builtin_type_unsigned_int;
3030 return builtin_type_int;
3032 return builtin_type_float;
3033 return builtin_type_int;
3036 static struct type *
3037 sparc64_register_virtual_type (int regno)
3039 if (regno == PC_REGNUM ||
3040 regno == DEPRECATED_FP_REGNUM ||
3042 return builtin_type_unsigned_long_long;
3044 return builtin_type_long_long;
3046 return builtin_type_float;
3048 return builtin_type_double;
3049 return builtin_type_long_long;
3052 /* Number of bytes of storage in the actual machine representation for
3056 sparc32_register_size (int regno)
3062 sparc64_register_size (int regno)
3064 return (regno < 32 ? 8 : regno < 64 ? 4 : 8);
3067 /* Index within the `registers' buffer of the first byte of the space
3068 for register REGNO. */
3071 sparc32_register_byte (int regno)
3077 sparc64_register_byte (int regno)
3081 else if (regno < 64)
3082 return 32 * 8 + (regno - 32) * 4;
3083 else if (regno < 80)
3084 return 32 * 8 + 32 * 4 + (regno - 64) * 8;
3086 return 64 * 8 + (regno - 80) * 8;
3089 /* Immediately after a function call, return the saved pc.
3090 Can't go through the frames for this because on some machines
3091 the new frame is not set up until the new function executes
3092 some instructions. */
3095 sparc_saved_pc_after_call (struct frame_info *fi)
3097 return sparc_pc_adjust (read_register (RP_REGNUM));
3100 /* Init saved regs: nothing to do, just a place-holder function. */
3103 sparc_frame_init_saved_regs (struct frame_info *fi_ignored)
3107 /* gdbarch fix call dummy:
3108 All this function does is rearrange the arguments before calling
3109 sparc_fix_call_dummy (which does the real work). */
3112 sparc_gdbarch_fix_call_dummy (char *dummy,
3116 struct value **args,
3120 if (CALL_DUMMY_LOCATION == ON_STACK)
3121 sparc_fix_call_dummy (dummy, pc, fun, type, gcc_p);
3124 /* DEPRECATED_CALL_DUMMY_ADDRESS: fetch the breakpoint address for a
3128 sparc_call_dummy_address (void)
3130 return (DEPRECATED_CALL_DUMMY_START_OFFSET) + DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET;
3133 /* Supply the Y register number to those that need it. */
3136 sparc_y_regnum (void)
3138 return gdbarch_tdep (current_gdbarch)->y_regnum;
3142 sparc_reg_struct_has_addr (int gcc_p, struct type *type)
3144 if (GDB_TARGET_IS_SPARC64)
3145 return (TYPE_LENGTH (type) > 32);
3147 return (gcc_p != 1);
3151 sparc_intreg_size (void)
3153 return SPARC_INTREG_SIZE;
3157 sparc_return_value_on_stack (struct type *type)
3159 if (TYPE_CODE (type) == TYPE_CODE_FLT &&
3160 TYPE_LENGTH (type) > 8)
3166 /* Get the ith function argument for the current function. */
3168 sparc_fetch_pointer_argument (struct frame_info *frame, int argi,
3172 get_frame_register (frame, O0_REGNUM + argi, &addr);
3177 * Gdbarch "constructor" function.
3180 #define SPARC32_CALL_DUMMY_ON_STACK
3182 #define SPARC_SP_REGNUM 14
3183 #define SPARC_FP_REGNUM 30
3184 #define SPARC_FP0_REGNUM 32
3185 #define SPARC32_NPC_REGNUM 69
3186 #define SPARC32_PC_REGNUM 68
3187 #define SPARC32_Y_REGNUM 64
3188 #define SPARC64_PC_REGNUM 80
3189 #define SPARC64_NPC_REGNUM 81
3190 #define SPARC64_Y_REGNUM 85
3192 static struct gdbarch *
3193 sparc_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
3195 struct gdbarch *gdbarch;
3196 struct gdbarch_tdep *tdep;
3198 static LONGEST call_dummy_32[] =
3199 { 0xbc100001, 0x9de38000, 0xbc100002, 0xbe100003,
3200 0xda03a058, 0xd803a054, 0xd603a050, 0xd403a04c,
3201 0xd203a048, 0x40000000, 0xd003a044, 0x01000000,
3202 0x91d02001, 0x01000000
3204 static LONGEST call_dummy_64[] =
3205 { 0x9de3bec0fd3fa7f7LL, 0xf93fa7eff53fa7e7LL,
3206 0xf13fa7dfed3fa7d7LL, 0xe93fa7cfe53fa7c7LL,
3207 0xe13fa7bfdd3fa7b7LL, 0xd93fa7afd53fa7a7LL,
3208 0xd13fa79fcd3fa797LL, 0xc93fa78fc53fa787LL,
3209 0xc13fa77fcc3fa777LL, 0xc83fa76fc43fa767LL,
3210 0xc03fa75ffc3fa757LL, 0xf83fa74ff43fa747LL,
3211 0xf03fa73f01000000LL, 0x0100000001000000LL,
3212 0x0100000091580000LL, 0xd027a72b93500000LL,
3213 0xd027a72791480000LL, 0xd027a72391400000LL,
3214 0xd027a71fda5ba8a7LL, 0xd85ba89fd65ba897LL,
3215 0xd45ba88fd25ba887LL, 0x9fc02000d05ba87fLL,
3216 0x0100000091d02001LL, 0x0100000001000000LL
3218 static LONGEST call_dummy_nil[] = {0};
3220 /* Try to determine the OS ABI of the object we are loading. */
3222 if (info.abfd != NULL
3223 && info.osabi == GDB_OSABI_UNKNOWN)
3225 /* If it's an ELF file, assume it's Solaris. */
3226 if (bfd_get_flavour (info.abfd) == bfd_target_elf_flavour)
3227 info.osabi = GDB_OSABI_SOLARIS;
3230 /* First see if there is already a gdbarch that can satisfy the request. */
3231 arches = gdbarch_list_lookup_by_info (arches, &info);
3233 return arches->gdbarch;
3235 /* None found: is the request for a sparc architecture? */
3236 if (info.bfd_arch_info->arch != bfd_arch_sparc)
3237 return NULL; /* No; then it's not for us. */
3239 /* Yes: create a new gdbarch for the specified machine type. */
3240 tdep = (struct gdbarch_tdep *) xmalloc (sizeof (struct gdbarch_tdep));
3241 gdbarch = gdbarch_alloc (&info, tdep);
3243 /* First set settings that are common for all sparc architectures. */
3244 set_gdbarch_believe_pcc_promotion (gdbarch, 1);
3245 set_gdbarch_breakpoint_from_pc (gdbarch, sparc_breakpoint_from_pc);
3246 set_gdbarch_decr_pc_after_break (gdbarch, 0);
3247 set_gdbarch_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
3248 set_gdbarch_extract_struct_value_address (gdbarch,
3249 sparc_extract_struct_value_address);
3250 set_gdbarch_deprecated_fix_call_dummy (gdbarch, sparc_gdbarch_fix_call_dummy);
3251 set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
3252 set_gdbarch_deprecated_fp_regnum (gdbarch, SPARC_FP_REGNUM);
3253 set_gdbarch_fp0_regnum (gdbarch, SPARC_FP0_REGNUM);
3254 set_gdbarch_deprecated_frame_chain (gdbarch, sparc_frame_chain);
3255 set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, sparc_frame_init_saved_regs);
3256 set_gdbarch_deprecated_frame_saved_pc (gdbarch, sparc_frame_saved_pc);
3257 set_gdbarch_frameless_function_invocation (gdbarch,
3258 frameless_look_for_prologue);
3259 set_gdbarch_deprecated_get_saved_register (gdbarch, sparc_get_saved_register);
3260 set_gdbarch_deprecated_init_extra_frame_info (gdbarch, sparc_init_extra_frame_info);
3261 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
3262 set_gdbarch_int_bit (gdbarch, 4 * TARGET_CHAR_BIT);
3263 set_gdbarch_long_double_bit (gdbarch, 16 * TARGET_CHAR_BIT);
3264 set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
3265 set_gdbarch_deprecated_max_register_raw_size (gdbarch, 8);
3266 set_gdbarch_deprecated_max_register_virtual_size (gdbarch, 8);
3267 set_gdbarch_deprecated_pop_frame (gdbarch, sparc_pop_frame);
3268 set_gdbarch_deprecated_push_return_address (gdbarch, sparc_push_return_address);
3269 set_gdbarch_deprecated_push_dummy_frame (gdbarch, sparc_push_dummy_frame);
3270 set_gdbarch_deprecated_reg_struct_has_addr
3271 (gdbarch, sparc_reg_struct_has_addr);
3272 set_gdbarch_return_value_on_stack (gdbarch, sparc_return_value_on_stack);
3273 set_gdbarch_deprecated_saved_pc_after_call (gdbarch, sparc_saved_pc_after_call);
3274 set_gdbarch_prologue_frameless_p (gdbarch, sparc_prologue_frameless_p);
3275 set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
3276 set_gdbarch_skip_prologue (gdbarch, sparc_skip_prologue);
3277 set_gdbarch_sp_regnum (gdbarch, SPARC_SP_REGNUM);
3278 set_gdbarch_deprecated_use_generic_dummy_frames (gdbarch, 0);
3279 set_gdbarch_write_pc (gdbarch, generic_target_write_pc);
3281 /* Helper for function argument information. */
3282 set_gdbarch_fetch_pointer_argument (gdbarch, sparc_fetch_pointer_argument);
3285 * Settings that depend only on 32/64 bit word size
3288 switch (info.bfd_arch_info->mach)
3290 case bfd_mach_sparc:
3292 // OBSOLETE case bfd_mach_sparc_sparclet:
3293 // OBSOLETE case bfd_mach_sparc_sparclite:
3295 case bfd_mach_sparc_v8plus:
3296 case bfd_mach_sparc_v8plusa:
3298 // OBSOLETE case bfd_mach_sparc_sparclite_le:
3300 /* 32-bit machine types: */
3302 #ifdef SPARC32_CALL_DUMMY_ON_STACK
3303 set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_on_stack);
3304 set_gdbarch_deprecated_call_dummy_address (gdbarch, sparc_call_dummy_address);
3305 set_gdbarch_deprecated_call_dummy_breakpoint_offset (gdbarch, 0x30);
3306 set_gdbarch_deprecated_call_dummy_length (gdbarch, 0x38);
3308 /* NOTE: cagney/2003-05-01: Using the just added push_dummy_code
3309 architecture method, it is now possible to implement a
3310 generic dummy frames based inferior function call that stores
3311 the breakpoint (and struct info) on the stack. Further, by
3312 treating a SIGSEG at a breakpoint as equivalent to a SIGTRAP
3313 it is even possible to make this work when the stack is
3316 NOTE: cagney/2002-04-26: Based from info posted by Peter
3317 Schauer around Oct '99. Briefly, due to aspects of the SPARC
3318 ABI, it isn't possible to use ON_STACK with a strictly
3321 Peter Schauer writes ...
3323 No, any call from GDB to a user function returning a
3324 struct/union will fail miserably. Try this:
3343 for (i = 0; i < 4; i++)
3349 Set a breakpoint at the gx = sret () statement, run to it and
3350 issue a `print sret()'. It will not succed with your
3351 approach, and I doubt that continuing the program will work
3354 For details of the ABI see the Sparc Architecture Manual. I
3355 have Version 8 (Prentice Hall ISBN 0-13-825001-4) and the
3356 calling conventions for functions returning aggregate values
3357 are explained in Appendix D.3. */
3359 set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
3360 set_gdbarch_deprecated_call_dummy_words (gdbarch, call_dummy_32);
3362 set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_at_entry_point);
3363 set_gdbarch_deprecated_call_dummy_words (gdbarch, call_dummy_nil);
3365 set_gdbarch_deprecated_call_dummy_stack_adjust (gdbarch, 68);
3366 set_gdbarch_frame_args_skip (gdbarch, 68);
3367 set_gdbarch_function_start_offset (gdbarch, 0);
3368 set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
3369 set_gdbarch_deprecated_npc_regnum (gdbarch, SPARC32_NPC_REGNUM);
3370 set_gdbarch_pc_regnum (gdbarch, SPARC32_PC_REGNUM);
3371 set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
3372 set_gdbarch_deprecated_push_arguments (gdbarch, sparc32_push_arguments);
3374 set_gdbarch_deprecated_register_byte (gdbarch, sparc32_register_byte);
3375 set_gdbarch_deprecated_register_raw_size (gdbarch, sparc32_register_size);
3376 set_gdbarch_deprecated_register_size (gdbarch, 4);
3377 set_gdbarch_deprecated_register_virtual_size (gdbarch, sparc32_register_size);
3378 set_gdbarch_deprecated_register_virtual_type (gdbarch, sparc32_register_virtual_type);
3379 #ifdef SPARC32_CALL_DUMMY_ON_STACK
3380 set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof (call_dummy_32));
3382 set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, 0);
3384 set_gdbarch_deprecated_stack_align (gdbarch, sparc32_stack_align);
3385 set_gdbarch_deprecated_extra_stack_alignment_needed (gdbarch, 1);
3386 set_gdbarch_deprecated_store_struct_return (gdbarch, sparc32_store_struct_return);
3387 set_gdbarch_use_struct_convention (gdbarch,
3388 generic_use_struct_convention);
3389 set_gdbarch_deprecated_dummy_write_sp (gdbarch, deprecated_write_sp);
3390 tdep->y_regnum = SPARC32_Y_REGNUM;
3391 tdep->fp_max_regnum = SPARC_FP0_REGNUM + 32;
3392 tdep->intreg_size = 4;
3393 tdep->reg_save_offset = 0x60;
3394 tdep->call_dummy_call_offset = 0x24;
3397 case bfd_mach_sparc_v9:
3398 case bfd_mach_sparc_v9a:
3399 /* 64-bit machine types: */
3400 default: /* Any new machine type is likely to be 64-bit. */
3402 #ifdef SPARC64_CALL_DUMMY_ON_STACK
3403 set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_on_stack);
3404 set_gdbarch_deprecated_call_dummy_address (gdbarch, sparc_call_dummy_address);
3405 set_gdbarch_deprecated_call_dummy_breakpoint_offset (gdbarch, 8 * 4);
3406 set_gdbarch_deprecated_call_dummy_length (gdbarch, 192);
3407 set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
3408 set_gdbarch_deprecated_call_dummy_start_offset (gdbarch, 148);
3409 set_gdbarch_deprecated_call_dummy_words (gdbarch, call_dummy_64);
3411 set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_at_entry_point);
3412 set_gdbarch_deprecated_call_dummy_words (gdbarch, call_dummy_nil);
3414 set_gdbarch_deprecated_call_dummy_stack_adjust (gdbarch, 128);
3415 set_gdbarch_frame_args_skip (gdbarch, 136);
3416 set_gdbarch_function_start_offset (gdbarch, 0);
3417 set_gdbarch_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
3418 set_gdbarch_deprecated_npc_regnum (gdbarch, SPARC64_NPC_REGNUM);
3419 set_gdbarch_pc_regnum (gdbarch, SPARC64_PC_REGNUM);
3420 set_gdbarch_ptr_bit (gdbarch, 8 * TARGET_CHAR_BIT);
3421 set_gdbarch_deprecated_push_arguments (gdbarch, sparc64_push_arguments);
3422 /* NOTE different for at_entry */
3423 set_gdbarch_deprecated_target_read_fp (gdbarch, sparc64_read_fp);
3424 set_gdbarch_read_sp (gdbarch, sparc64_read_sp);
3425 /* Some of the registers aren't 64 bits, but it's a lot simpler just
3426 to assume they all are (since most of them are). */
3427 set_gdbarch_deprecated_register_byte (gdbarch, sparc64_register_byte);
3428 set_gdbarch_deprecated_register_raw_size (gdbarch, sparc64_register_size);
3429 set_gdbarch_deprecated_register_size (gdbarch, 8);
3430 set_gdbarch_deprecated_register_virtual_size (gdbarch, sparc64_register_size);
3431 set_gdbarch_deprecated_register_virtual_type (gdbarch, sparc64_register_virtual_type);
3432 #ifdef SPARC64_CALL_DUMMY_ON_STACK
3433 set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof (call_dummy_64));
3435 set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, 0);
3437 set_gdbarch_deprecated_stack_align (gdbarch, sparc64_stack_align);
3438 set_gdbarch_deprecated_extra_stack_alignment_needed (gdbarch, 1);
3439 set_gdbarch_deprecated_store_struct_return (gdbarch, sparc64_store_struct_return);
3440 set_gdbarch_use_struct_convention (gdbarch,
3441 sparc64_use_struct_convention);
3442 set_gdbarch_deprecated_dummy_write_sp (gdbarch, sparc64_write_sp);
3443 tdep->y_regnum = SPARC64_Y_REGNUM;
3444 tdep->fp_max_regnum = SPARC_FP0_REGNUM + 48;
3445 tdep->intreg_size = 8;
3446 tdep->reg_save_offset = 0x90;
3447 tdep->call_dummy_call_offset = 148 + 4 * 5;
3452 * Settings that vary per-architecture:
3455 switch (info.bfd_arch_info->mach)
3457 case bfd_mach_sparc:
3458 set_gdbarch_extract_return_value (gdbarch, sparc32_extract_return_value);
3459 set_gdbarch_store_return_value (gdbarch, sparc32_store_return_value);
3460 set_gdbarch_num_regs (gdbarch, 72);
3461 set_gdbarch_deprecated_register_bytes (gdbarch, 32*4 + 32*4 + 8*4);
3462 set_gdbarch_register_name (gdbarch, sparc32_register_name);
3464 // OBSOLETE tdep->has_fpu = 1; /* (all but sparclet and sparclite) */
3466 tdep->fp_register_bytes = 32 * 4;
3467 tdep->print_insn_mach = bfd_mach_sparc;
3470 // OBSOLETE case bfd_mach_sparc_sparclet:
3471 // OBSOLETE set_gdbarch_deprecated_extract_return_value (gdbarch, sparclet_extract_return_value);
3472 // OBSOLETE set_gdbarch_num_regs (gdbarch, 32 + 32 + 8 + 8 + 8);
3473 // OBSOLETE set_gdbarch_register_bytes (gdbarch, 32*4 + 32*4 + 8*4 + 8*4 + 8*4);
3474 // OBSOLETE set_gdbarch_register_name (gdbarch, sparclet_register_name);
3475 // OBSOLETE set_gdbarch_deprecated_store_return_value (gdbarch, sparclet_store_return_value);
3476 // OBSOLETE tdep->has_fpu = 0; /* (all but sparclet and sparclite) */
3477 // OBSOLETE tdep->fp_register_bytes = 0;
3478 // OBSOLETE tdep->print_insn_mach = bfd_mach_sparc_sparclet;
3482 // OBSOLETE case bfd_mach_sparc_sparclite:
3483 // OBSOLETE set_gdbarch_deprecated_extract_return_value (gdbarch, sparc32_extract_return_value);
3484 // OBSOLETE set_gdbarch_num_regs (gdbarch, 80);
3485 // OBSOLETE set_gdbarch_register_bytes (gdbarch, 32*4 + 32*4 + 8*4 + 8*4);
3486 // OBSOLETE set_gdbarch_register_name (gdbarch, sparclite_register_name);
3487 // OBSOLETE set_gdbarch_deprecated_store_return_value (gdbarch, sparc_store_return_value);
3488 // OBSOLETE tdep->has_fpu = 0; /* (all but sparclet and sparclite) */
3489 // OBSOLETE tdep->fp_register_bytes = 0;
3490 // OBSOLETE tdep->print_insn_mach = bfd_mach_sparc_sparclite;
3493 case bfd_mach_sparc_v8plus:
3494 set_gdbarch_extract_return_value (gdbarch, sparc32_extract_return_value);
3495 set_gdbarch_store_return_value (gdbarch, sparc32_store_return_value);
3496 set_gdbarch_num_regs (gdbarch, 72);
3497 set_gdbarch_deprecated_register_bytes (gdbarch, 32*4 + 32*4 + 8*4);
3498 set_gdbarch_register_name (gdbarch, sparc32_register_name);
3499 tdep->print_insn_mach = bfd_mach_sparc;
3500 tdep->fp_register_bytes = 32 * 4;
3502 // OBSOLETE tdep->has_fpu = 1; /* (all but sparclet and sparclite) */
3505 case bfd_mach_sparc_v8plusa:
3506 set_gdbarch_extract_return_value (gdbarch, sparc32_extract_return_value);
3507 set_gdbarch_store_return_value (gdbarch, sparc32_store_return_value);
3508 set_gdbarch_num_regs (gdbarch, 72);
3509 set_gdbarch_deprecated_register_bytes (gdbarch, 32*4 + 32*4 + 8*4);
3510 set_gdbarch_register_name (gdbarch, sparc32_register_name);
3512 // OBSOLETE tdep->has_fpu = 1; /* (all but sparclet and sparclite) */
3514 tdep->fp_register_bytes = 32 * 4;
3515 tdep->print_insn_mach = bfd_mach_sparc;
3518 // OBSOLETE case bfd_mach_sparc_sparclite_le:
3519 // OBSOLETE set_gdbarch_deprecated_extract_return_value (gdbarch, sparc32_extract_return_value);
3520 // OBSOLETE set_gdbarch_num_regs (gdbarch, 80);
3521 // OBSOLETE set_gdbarch_register_bytes (gdbarch, 32*4 + 32*4 + 8*4 + 8*4);
3522 // OBSOLETE set_gdbarch_register_name (gdbarch, sparclite_register_name);
3523 // OBSOLETE set_gdbarch_deprecated_store_return_value (gdbarch, sparc_store_return_value);
3524 // OBSOLETE tdep->has_fpu = 0; /* (all but sparclet and sparclite) */
3525 // OBSOLETE tdep->fp_register_bytes = 0;
3526 // OBSOLETE tdep->print_insn_mach = bfd_mach_sparc_sparclite;
3529 case bfd_mach_sparc_v9:
3530 set_gdbarch_deprecated_extract_return_value (gdbarch, sparc64_extract_return_value);
3531 set_gdbarch_num_regs (gdbarch, 125);
3532 set_gdbarch_deprecated_register_bytes (gdbarch, 32*8 + 32*8 + 45*8);
3533 set_gdbarch_register_name (gdbarch, sparc64_register_name);
3534 set_gdbarch_deprecated_store_return_value (gdbarch, sparc_store_return_value);
3536 // OBSOLETE tdep->has_fpu = 1; /* (all but sparclet and sparclite) */
3538 tdep->fp_register_bytes = 64 * 4;
3539 tdep->print_insn_mach = bfd_mach_sparc_v9a;
3541 case bfd_mach_sparc_v9a:
3542 set_gdbarch_deprecated_extract_return_value (gdbarch, sparc64_extract_return_value);
3543 set_gdbarch_num_regs (gdbarch, 125);
3544 set_gdbarch_deprecated_register_bytes (gdbarch, 32*8 + 32*8 + 45*8);
3545 set_gdbarch_register_name (gdbarch, sparc64_register_name);
3546 set_gdbarch_deprecated_store_return_value (gdbarch, sparc_store_return_value);
3548 // OBSOLETE tdep->has_fpu = 1; /* (all but sparclet and sparclite) */
3550 tdep->fp_register_bytes = 64 * 4;
3551 tdep->print_insn_mach = bfd_mach_sparc_v9a;
3555 set_gdbarch_print_insn (gdbarch, print_insn_sparc);
3557 /* Hook in OS ABI-specific overrides, if they have been registered. */
3558 gdbarch_init_osabi (info, gdbarch);
3564 sparc_dump_tdep (struct gdbarch *current_gdbarch, struct ui_file *file)
3566 struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
3572 // OBSOLETE fprintf_unfiltered (file, "sparc_dump_tdep: has_fpu = %d\n",
3573 // OBSOLETE tdep->has_fpu);
3575 fprintf_unfiltered (file, "sparc_dump_tdep: fp_register_bytes = %d\n",
3576 tdep->fp_register_bytes);
3577 fprintf_unfiltered (file, "sparc_dump_tdep: y_regnum = %d\n",
3579 fprintf_unfiltered (file, "sparc_dump_tdep: fp_max_regnum = %d\n",
3580 tdep->fp_max_regnum);
3581 fprintf_unfiltered (file, "sparc_dump_tdep: intreg_size = %d\n",
3583 fprintf_unfiltered (file, "sparc_dump_tdep: reg_save_offset = %d\n",
3584 tdep->reg_save_offset);
3585 fprintf_unfiltered (file, "sparc_dump_tdep: call_dummy_call_offset = %d\n",
3586 tdep->call_dummy_call_offset);
3587 fprintf_unfiltered (file, "sparc_dump_tdep: print_insn_match = %d\n",
3588 tdep->print_insn_mach);