1 /* Target-dependent code for the SPARC for GDB, the GNU debugger.
3 Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation,
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
24 /* ??? Support for calling functions from gdb in sparc64 is unfinished. */
27 #include "arch-utils.h"
33 #include "gdb_string.h"
38 #include <sys/procfs.h>
39 /* Prototypes for supply_gregset etc. */
44 #include "gdb_assert.h"
46 #include "symfile.h" /* for 'entry_point_address' */
49 * Some local macros that have multi-arch and non-multi-arch versions:
52 #if (GDB_MULTI_ARCH > 0)
55 // OBSOLETE /* Does the target have Floating Point registers? */
56 // OBSOLETE #define SPARC_HAS_FPU (gdbarch_tdep (current_gdbarch)->has_fpu)
58 #define SPARC_HAS_FPU 1
59 /* Number of bytes devoted to Floating Point registers: */
60 #define FP_REGISTER_BYTES (gdbarch_tdep (current_gdbarch)->fp_register_bytes)
61 /* Highest numbered Floating Point register. */
62 #define FP_MAX_REGNUM (gdbarch_tdep (current_gdbarch)->fp_max_regnum)
63 /* Size of a general (integer) register: */
64 #define SPARC_INTREG_SIZE (gdbarch_tdep (current_gdbarch)->intreg_size)
65 /* Offset within the call dummy stack of the saved registers. */
66 #define DUMMY_REG_SAVE_OFFSET (gdbarch_tdep (current_gdbarch)->reg_save_offset)
68 #else /* non-multi-arch */
71 /* Does the target have Floating Point registers? */
73 // OBSOLETE #if defined(TARGET_SPARCLET) || defined(TARGET_SPARCLITE)
74 // OBSOLETE #define SPARC_HAS_FPU 0
76 // OBSOLETE #define SPARC_HAS_FPU 1
79 #define SPARC_HAS_FPU 1
81 /* Number of bytes devoted to Floating Point registers: */
82 #if (GDB_TARGET_IS_SPARC64)
83 #define FP_REGISTER_BYTES (64 * 4)
86 #define FP_REGISTER_BYTES (32 * 4)
88 #define FP_REGISTER_BYTES 0
92 /* Highest numbered Floating Point register. */
93 #if (GDB_TARGET_IS_SPARC64)
94 #define FP_MAX_REGNUM (FP0_REGNUM + 48)
96 #define FP_MAX_REGNUM (FP0_REGNUM + 32)
99 /* Size of a general (integer) register: */
100 #define SPARC_INTREG_SIZE (REGISTER_RAW_SIZE (G0_REGNUM))
102 /* Offset within the call dummy stack of the saved registers. */
103 #if (GDB_TARGET_IS_SPARC64)
104 #define DUMMY_REG_SAVE_OFFSET (128 + 16)
106 #define DUMMY_REG_SAVE_OFFSET 0x60
109 #endif /* GDB_MULTI_ARCH */
114 // OBSOLETE int has_fpu;
116 int fp_register_bytes;
121 int call_dummy_call_offset;
125 /* Now make GDB_TARGET_IS_SPARC64 a runtime test. */
126 /* FIXME MVS: or try testing bfd_arch_info.arch and bfd_arch_info.mach ...
127 * define GDB_TARGET_IS_SPARC64 \
128 * (TARGET_ARCHITECTURE->arch == bfd_arch_sparc && \
129 * (TARGET_ARCHITECTURE->mach == bfd_mach_sparc_v9 || \
130 * TARGET_ARCHITECTURE->mach == bfd_mach_sparc_v9a))
134 extern int stop_after_trap;
136 /* We don't store all registers immediately when requested, since they
137 get sent over in large chunks anyway. Instead, we accumulate most
138 of the changes and send them over once. "deferred_stores" keeps
139 track of which sets of registers we have locally-changed copies of,
140 so we only need send the groups that have changed. */
142 int deferred_stores = 0; /* Accumulated stores we want to do eventually. */
146 // OBSOLETE /* Some machines, such as Fujitsu SPARClite 86x, have a bi-endian mode
147 // OBSOLETE where instructions are big-endian and data are little-endian.
148 // OBSOLETE This flag is set when we detect that the target is of this type. */
150 // OBSOLETE int bi_endian = 0;
154 const unsigned char *
155 sparc_breakpoint_from_pc (CORE_ADDR *pc, int *len)
157 static const char breakpoint[] = {0x91, 0xd0, 0x20, 0x01};
158 (*len) = sizeof (breakpoint);
162 /* Fetch a single instruction. Even on bi-endian machines
163 such as sparc86x, instructions are always big-endian. */
166 fetch_instruction (CORE_ADDR pc)
168 unsigned long retval;
170 unsigned char buf[4];
172 read_memory (pc, buf, sizeof (buf));
174 /* Start at the most significant end of the integer, and work towards
175 the least significant. */
177 for (i = 0; i < sizeof (buf); ++i)
178 retval = (retval << 8) | buf[i];
183 /* Branches with prediction are treated like their non-predicting cousins. */
184 /* FIXME: What about floating point branches? */
186 /* Macros to extract fields from sparc instructions. */
187 #define X_OP(i) (((i) >> 30) & 0x3)
188 #define X_RD(i) (((i) >> 25) & 0x1f)
189 #define X_A(i) (((i) >> 29) & 1)
190 #define X_COND(i) (((i) >> 25) & 0xf)
191 #define X_OP2(i) (((i) >> 22) & 0x7)
192 #define X_IMM22(i) ((i) & 0x3fffff)
193 #define X_OP3(i) (((i) >> 19) & 0x3f)
194 #define X_RS1(i) (((i) >> 14) & 0x1f)
195 #define X_I(i) (((i) >> 13) & 1)
196 #define X_IMM13(i) ((i) & 0x1fff)
197 /* Sign extension macros. */
198 #define X_SIMM13(i) ((X_IMM13 (i) ^ 0x1000) - 0x1000)
199 #define X_DISP22(i) ((X_IMM22 (i) ^ 0x200000) - 0x200000)
200 #define X_CC(i) (((i) >> 20) & 3)
201 #define X_P(i) (((i) >> 19) & 1)
202 #define X_DISP19(i) ((((i) & 0x7ffff) ^ 0x40000) - 0x40000)
203 #define X_RCOND(i) (((i) >> 25) & 7)
204 #define X_DISP16(i) ((((((i) >> 6) && 0xc000) | ((i) & 0x3fff)) ^ 0x8000) - 0x8000)
205 #define X_FCN(i) (((i) >> 25) & 31)
209 Error, not_branch, bicc, bicca, ba, baa, ticc, ta, done_retry
212 /* Simulate single-step ptrace call for sun4. Code written by Gary
213 Beihl (beihl@mcc.com). */
215 /* npc4 and next_pc describe the situation at the time that the
216 step-breakpoint was set, not necessary the current value of NPC_REGNUM. */
217 static CORE_ADDR next_pc, npc4, target;
218 static int brknpc4, brktrg;
219 typedef char binsn_quantum[BREAKPOINT_MAX];
220 static binsn_quantum break_mem[3];
222 static branch_type isbranch (long, CORE_ADDR, CORE_ADDR *);
224 /* single_step() is called just before we want to resume the inferior,
225 if we want to single-step it but there is no hardware or kernel single-step
226 support (as on all SPARCs). We find all the possible targets of the
227 coming instruction and breakpoint them.
229 single_step is also called just after the inferior stops. If we had
230 set up a simulated single-step, we undo our damage. */
233 sparc_software_single_step (enum target_signal ignore, /* pid, but we don't need it */
234 int insert_breakpoints_p)
240 if (insert_breakpoints_p)
242 /* Always set breakpoint for NPC. */
243 next_pc = read_register (NPC_REGNUM);
244 npc4 = next_pc + 4; /* branch not taken */
246 target_insert_breakpoint (next_pc, break_mem[0]);
247 /* printf_unfiltered ("set break at %x\n",next_pc); */
249 pc = read_register (PC_REGNUM);
250 pc_instruction = fetch_instruction (pc);
251 br = isbranch (pc_instruction, pc, &target);
252 brknpc4 = brktrg = 0;
256 /* Conditional annulled branch will either end up at
257 npc (if taken) or at npc+4 (if not taken).
260 target_insert_breakpoint (npc4, break_mem[1]);
262 else if (br == baa && target != next_pc)
264 /* Unconditional annulled branch will always end up at
267 target_insert_breakpoint (target, break_mem[2]);
269 else if (GDB_TARGET_IS_SPARC64 && br == done_retry)
272 target_insert_breakpoint (target, break_mem[2]);
277 /* Remove breakpoints */
278 target_remove_breakpoint (next_pc, break_mem[0]);
281 target_remove_breakpoint (npc4, break_mem[1]);
284 target_remove_breakpoint (target, break_mem[2]);
288 struct frame_extra_info
293 /* Following fields only relevant for flat frames. */
296 /* Add this to ->frame to get the value of the stack pointer at the
297 time of the register saves. */
301 /* Call this for each newly created frame. For SPARC, we need to
302 calculate the bottom of the frame, and do some extra work if the
303 prologue has been generated via the -mflat option to GCC. In
304 particular, we need to know where the previous fp and the pc have
305 been stashed, since their exact position within the frame may vary. */
308 sparc_init_extra_frame_info (int fromleaf, struct frame_info *fi)
311 CORE_ADDR prologue_start, prologue_end;
314 frame_extra_info_zalloc (fi, sizeof (struct frame_extra_info));
315 frame_saved_regs_zalloc (fi);
317 get_frame_extra_info (fi)->bottom =
319 ? (get_frame_base (fi) == get_frame_base (get_next_frame (fi))
320 ? get_frame_extra_info (get_next_frame (fi))->bottom
321 : get_frame_base (get_next_frame (fi)))
324 /* If fi->next is NULL, then we already set ->frame by passing
325 deprecated_read_fp() to create_new_frame. */
326 if (get_next_frame (fi))
328 char buf[MAX_REGISTER_SIZE];
330 /* Compute ->frame as if not flat. If it is flat, we'll change
332 if (get_next_frame (get_next_frame (fi)) != NULL
333 && ((get_frame_type (get_next_frame (get_next_frame (fi))) == SIGTRAMP_FRAME)
334 || deprecated_frame_in_dummy (get_next_frame (get_next_frame (fi))))
335 && frameless_look_for_prologue (get_next_frame (fi)))
337 /* A frameless function interrupted by a signal did not change
338 the frame pointer, fix up frame pointer accordingly. */
339 deprecated_update_frame_base_hack (fi, get_frame_base (get_next_frame (fi)));
340 get_frame_extra_info (fi)->bottom =
341 get_frame_extra_info (get_next_frame (fi))->bottom;
345 /* Should we adjust for stack bias here? */
347 frame_read_unsigned_register (fi, DEPRECATED_FP_REGNUM, &tmp);
348 deprecated_update_frame_base_hack (fi, tmp);
349 if (GDB_TARGET_IS_SPARC64 && (get_frame_base (fi) & 1))
350 deprecated_update_frame_base_hack (fi, get_frame_base (fi) + 2047);
354 /* Decide whether this is a function with a ``flat register window''
355 frame. For such functions, the frame pointer is actually in %i7. */
356 get_frame_extra_info (fi)->flat = 0;
357 get_frame_extra_info (fi)->in_prologue = 0;
358 if (find_pc_partial_function (get_frame_pc (fi), &name, &prologue_start, &prologue_end))
360 /* See if the function starts with an add (which will be of a
361 negative number if a flat frame) to the sp. FIXME: Does not
362 handle large frames which will need more than one instruction
364 insn = fetch_instruction (prologue_start);
365 if (X_OP (insn) == 2 && X_RD (insn) == 14 && X_OP3 (insn) == 0
366 && X_I (insn) && X_SIMM13 (insn) < 0)
368 int offset = X_SIMM13 (insn);
370 /* Then look for a save of %i7 into the frame. */
371 insn = fetch_instruction (prologue_start + 4);
375 && X_RS1 (insn) == 14)
377 char buf[MAX_REGISTER_SIZE];
379 /* We definitely have a flat frame now. */
380 get_frame_extra_info (fi)->flat = 1;
382 get_frame_extra_info (fi)->sp_offset = offset;
384 /* Overwrite the frame's address with the value in %i7. */
387 frame_read_unsigned_register (fi, I7_REGNUM, &tmp);
388 deprecated_update_frame_base_hack (fi, tmp);
391 if (GDB_TARGET_IS_SPARC64 && (get_frame_base (fi) & 1))
392 deprecated_update_frame_base_hack (fi, get_frame_base (fi) + 2047);
394 /* Record where the fp got saved. */
395 get_frame_extra_info (fi)->fp_addr =
396 get_frame_base (fi) + get_frame_extra_info (fi)->sp_offset + X_SIMM13 (insn);
398 /* Also try to collect where the pc got saved to. */
399 get_frame_extra_info (fi)->pc_addr = 0;
400 insn = fetch_instruction (prologue_start + 12);
404 && X_RS1 (insn) == 14)
405 get_frame_extra_info (fi)->pc_addr =
406 get_frame_base (fi) + get_frame_extra_info (fi)->sp_offset + X_SIMM13 (insn);
411 /* Check if the PC is in the function prologue before a SAVE
412 instruction has been executed yet. If so, set the frame
413 to the current value of the stack pointer and set
414 the in_prologue flag. */
416 struct symtab_and_line sal;
418 sal = find_pc_line (prologue_start, 0);
419 if (sal.line == 0) /* no line info, use PC */
420 prologue_end = get_frame_pc (fi);
421 else if (sal.end < prologue_end)
422 prologue_end = sal.end;
423 if (get_frame_pc (fi) < prologue_end)
425 for (addr = prologue_start; addr < get_frame_pc (fi); addr += 4)
427 insn = read_memory_integer (addr, 4);
428 if (X_OP (insn) == 2 && X_OP3 (insn) == 0x3c)
429 break; /* SAVE seen, stop searching */
431 if (addr >= get_frame_pc (fi))
433 get_frame_extra_info (fi)->in_prologue = 1;
434 deprecated_update_frame_base_hack (fi, read_register (SP_REGNUM));
439 if (get_next_frame (fi) && get_frame_base (fi) == 0)
441 /* Kludge to cause init_prev_frame_info to destroy the new frame. */
442 deprecated_update_frame_base_hack (fi, get_frame_base (get_next_frame (fi)));
443 deprecated_update_frame_pc_hack (fi, get_frame_pc (get_next_frame (fi)));
448 sparc_frame_chain (struct frame_info *frame)
450 /* Value that will cause DEPRECATED_FRAME_CHAIN_VALID to not worry
451 about the chain value. If it really is zero, we detect it later
452 in sparc_init_prev_frame.
454 Note: kevinb/2003-02-18: The constant 1 used to be returned here,
455 but, after some recent changes to legacy_frame_chain_valid(),
456 this value is no longer suitable for causing
457 legacy_frame_chain_valid() to "not worry about the chain value."
458 The constant ~0 (i.e, 0xfff...) causes the failing test in
459 legacy_frame_chain_valid() to succeed thus preserving the "not
460 worry" property. I had considered using something like
461 ``get_frame_base (frame) + 1''. However, I think a constant
462 value is better, because when debugging this problem, I knew that
463 something funny was going on as soon as I saw the constant 1
464 being used as the frame chain elsewhere in GDB. */
466 return ~ (CORE_ADDR) 0;
469 /* Find the pc saved in frame FRAME. */
472 sparc_frame_saved_pc (struct frame_info *frame)
474 char buf[MAX_REGISTER_SIZE];
477 if ((get_frame_type (frame) == SIGTRAMP_FRAME))
479 /* This is the signal trampoline frame.
480 Get the saved PC from the sigcontext structure. */
482 #ifndef SIGCONTEXT_PC_OFFSET
483 #define SIGCONTEXT_PC_OFFSET 12
486 CORE_ADDR sigcontext_addr;
488 int saved_pc_offset = SIGCONTEXT_PC_OFFSET;
491 scbuf = alloca (TARGET_PTR_BIT / HOST_CHAR_BIT);
493 /* Solaris2 ucbsigvechandler passes a pointer to a sigcontext
494 as the third parameter. The offset to the saved pc is 12. */
495 find_pc_partial_function (get_frame_pc (frame), &name,
496 (CORE_ADDR *) NULL, (CORE_ADDR *) NULL);
497 if (name && STREQ (name, "ucbsigvechandler"))
498 saved_pc_offset = 12;
500 /* The sigcontext address is contained in register O2. */
503 frame_read_unsigned_register (frame, O0_REGNUM + 2, &tmp);
504 sigcontext_addr = tmp;
507 /* Don't cause a memory_error when accessing sigcontext in case the
508 stack layout has changed or the stack is corrupt. */
509 target_read_memory (sigcontext_addr + saved_pc_offset,
510 scbuf, sizeof (scbuf));
511 return extract_unsigned_integer (scbuf, sizeof (scbuf));
513 else if (get_frame_extra_info (frame)->in_prologue ||
514 (get_next_frame (frame) != NULL &&
515 ((get_frame_type (get_next_frame (frame)) == SIGTRAMP_FRAME) ||
516 deprecated_frame_in_dummy (get_next_frame (frame))) &&
517 frameless_look_for_prologue (frame)))
519 /* A frameless function interrupted by a signal did not save
520 the PC, it is still in %o7. */
522 frame_read_unsigned_register (frame, O7_REGNUM, &tmp);
523 return PC_ADJUST (tmp);
525 if (get_frame_extra_info (frame)->flat)
526 addr = get_frame_extra_info (frame)->pc_addr;
528 addr = get_frame_extra_info (frame)->bottom + FRAME_SAVED_I0 +
529 SPARC_INTREG_SIZE * (I7_REGNUM - I0_REGNUM);
532 /* A flat frame leaf function might not save the PC anywhere,
533 just leave it in %o7. */
534 return PC_ADJUST (read_register (O7_REGNUM));
536 read_memory (addr, buf, SPARC_INTREG_SIZE);
537 return PC_ADJUST (extract_unsigned_integer (buf, SPARC_INTREG_SIZE));
540 /* Since an individual frame in the frame cache is defined by two
541 arguments (a frame pointer and a stack pointer), we need two
542 arguments to get info for an arbitrary stack frame. This routine
543 takes two arguments and makes the cached frames look as if these
544 two arguments defined a frame on the cache. This allows the rest
545 of info frame to extract the important arguments without
549 setup_arbitrary_frame (int argc, CORE_ADDR *argv)
551 struct frame_info *frame;
554 error ("Sparc frame specifications require two arguments: fp and sp");
556 frame = create_new_frame (argv[0], 0);
559 internal_error (__FILE__, __LINE__,
560 "create_new_frame returned invalid frame");
562 get_frame_extra_info (frame)->bottom = argv[1];
563 deprecated_update_frame_pc_hack (frame, DEPRECATED_FRAME_SAVED_PC (frame));
567 /* Given a pc value, skip it forward past the function prologue by
568 disassembling instructions that appear to be a prologue.
570 If FRAMELESS_P is set, we are only testing to see if the function
571 is frameless. This allows a quicker answer.
573 This routine should be more specific in its actions; making sure
574 that it uses the same register in the initial prologue section. */
576 static CORE_ADDR examine_prologue (CORE_ADDR, int, struct frame_info *,
580 examine_prologue (CORE_ADDR start_pc, int frameless_p, struct frame_info *fi,
581 CORE_ADDR *saved_regs)
585 CORE_ADDR pc = start_pc;
588 insn = fetch_instruction (pc);
590 /* Recognize the `sethi' insn and record its destination. */
591 if (X_OP (insn) == 0 && X_OP2 (insn) == 4)
595 insn = fetch_instruction (pc);
598 /* Recognize an add immediate value to register to either %g1 or
599 the destination register recorded above. Actually, this might
600 well recognize several different arithmetic operations.
601 It doesn't check that rs1 == rd because in theory "sub %g0, 5, %g1"
602 followed by "save %sp, %g1, %sp" is a valid prologue (Not that
603 I imagine any compiler really does that, however). */
606 && (X_RD (insn) == 1 || X_RD (insn) == dest))
609 insn = fetch_instruction (pc);
612 /* Recognize any SAVE insn. */
613 if (X_OP (insn) == 2 && X_OP3 (insn) == 60)
616 if (frameless_p) /* If the save is all we care about, */
617 return pc; /* return before doing more work */
618 insn = fetch_instruction (pc);
620 /* Recognize add to %sp. */
621 else if (X_OP (insn) == 2 && X_RD (insn) == 14 && X_OP3 (insn) == 0)
624 if (frameless_p) /* If the add is all we care about, */
625 return pc; /* return before doing more work */
627 insn = fetch_instruction (pc);
628 /* Recognize store of frame pointer (i7). */
632 && X_RS1 (insn) == 14)
635 insn = fetch_instruction (pc);
637 /* Recognize sub %sp, <anything>, %i7. */
640 && X_RS1 (insn) == 14
641 && X_RD (insn) == 31)
644 insn = fetch_instruction (pc);
653 /* Without a save or add instruction, it's not a prologue. */
658 /* Recognize stores into the frame from the input registers.
659 This recognizes all non alternate stores of an input register,
660 into a location offset from the frame pointer between
663 /* The above will fail for arguments that are promoted
664 (eg. shorts to ints or floats to doubles), because the compiler
665 will pass them in positive-offset frame space, but the prologue
666 will save them (after conversion) in negative frame space at an
667 unpredictable offset. Therefore I am going to remove the
668 restriction on the target-address of the save, on the theory
669 that any unbroken sequence of saves from input registers must
670 be part of the prologue. In un-optimized code (at least), I'm
671 fairly sure that the compiler would emit SOME other instruction
672 (eg. a move or add) before emitting another save that is actually
673 a part of the function body.
675 Besides, the reserved stack space is different for SPARC64 anyway.
680 && (X_OP3 (insn) & 0x3c) == 4 /* Store, non-alternate. */
681 && (X_RD (insn) & 0x18) == 0x18 /* Input register. */
682 && X_I (insn) /* Immediate mode. */
683 && X_RS1 (insn) == 30) /* Off of frame pointer. */
684 ; /* empty statement -- fall thru to end of loop */
685 else if (GDB_TARGET_IS_SPARC64
687 && (X_OP3 (insn) & 0x3c) == 12 /* store, extended (64-bit) */
688 && (X_RD (insn) & 0x18) == 0x18 /* input register */
689 && X_I (insn) /* immediate mode */
690 && X_RS1 (insn) == 30) /* off of frame pointer */
691 ; /* empty statement -- fall thru to end of loop */
692 else if (X_OP (insn) == 3
693 && (X_OP3 (insn) & 0x3c) == 36 /* store, floating-point */
694 && X_I (insn) /* immediate mode */
695 && X_RS1 (insn) == 30) /* off of frame pointer */
696 ; /* empty statement -- fall thru to end of loop */
699 && X_OP3 (insn) == 4 /* store? */
700 && X_RS1 (insn) == 14) /* off of frame pointer */
702 if (saved_regs && X_I (insn))
703 saved_regs[X_RD (insn)] =
704 get_frame_base (fi) + get_frame_extra_info (fi)->sp_offset + X_SIMM13 (insn);
709 insn = fetch_instruction (pc);
715 /* Advance PC across any function entry prologue instructions to reach
719 sparc_skip_prologue (CORE_ADDR start_pc)
721 struct symtab_and_line sal;
722 CORE_ADDR func_start, func_end;
724 /* This is the preferred method, find the end of the prologue by
725 using the debugging information. */
726 if (find_pc_partial_function (start_pc, NULL, &func_start, &func_end))
728 sal = find_pc_line (func_start, 0);
730 if (sal.end < func_end
731 && start_pc <= sal.end)
735 /* Oh well, examine the code by hand. */
736 return examine_prologue (start_pc, 0, NULL, NULL);
739 /* Is the prologue at IP frameless? */
742 sparc_prologue_frameless_p (CORE_ADDR ip)
744 return ip == examine_prologue (ip, 1, NULL, NULL);
747 /* Check instruction at ADDR to see if it is a branch.
748 All non-annulled instructions will go to NPC or will trap.
749 Set *TARGET if we find a candidate branch; set to zero if not.
751 This isn't static as it's used by remote-sa.sparc.c. */
754 isbranch (long instruction, CORE_ADDR addr, CORE_ADDR *target)
756 branch_type val = not_branch;
757 long int offset = 0; /* Must be signed for sign-extend. */
761 if (X_OP (instruction) == 0
762 && (X_OP2 (instruction) == 2
763 || X_OP2 (instruction) == 6
764 || X_OP2 (instruction) == 1
765 || X_OP2 (instruction) == 3
766 || X_OP2 (instruction) == 5
767 || (GDB_TARGET_IS_SPARC64 && X_OP2 (instruction) == 7)))
769 if (X_COND (instruction) == 8)
770 val = X_A (instruction) ? baa : ba;
772 val = X_A (instruction) ? bicca : bicc;
773 switch (X_OP2 (instruction))
776 if (!GDB_TARGET_IS_SPARC64)
781 offset = 4 * X_DISP22 (instruction);
785 offset = 4 * X_DISP19 (instruction);
788 offset = 4 * X_DISP16 (instruction);
791 *target = addr + offset;
793 else if (GDB_TARGET_IS_SPARC64
794 && X_OP (instruction) == 2
795 && X_OP3 (instruction) == 62)
797 if (X_FCN (instruction) == 0)
800 *target = read_register (TNPC_REGNUM);
803 else if (X_FCN (instruction) == 1)
806 *target = read_register (TPC_REGNUM);
814 /* Find register number REGNUM relative to FRAME and put its
815 (raw) contents in *RAW_BUFFER. Set *OPTIMIZED if the variable
816 was optimized out (and thus can't be fetched). If the variable
817 was fetched from memory, set *ADDRP to where it was fetched from,
818 otherwise it was fetched from a register.
820 The argument RAW_BUFFER must point to aligned memory. */
823 sparc_get_saved_register (char *raw_buffer, int *optimized, CORE_ADDR *addrp,
824 struct frame_info *frame, int regnum,
825 enum lval_type *lval)
827 struct frame_info *frame1;
830 if (!target_has_registers)
831 error ("No registers.");
838 /* FIXME This code extracted from infcmd.c; should put elsewhere! */
841 /* error ("No selected frame."); */
842 if (!target_has_registers)
843 error ("The program has no registers now.");
844 if (deprecated_selected_frame == NULL)
845 error ("No selected frame.");
846 /* Try to use selected frame */
847 frame = get_prev_frame (deprecated_selected_frame);
849 error ("Cmd not meaningful in the outermost frame.");
853 frame1 = get_next_frame (frame);
855 /* Get saved PC from the frame info if not in innermost frame. */
856 if (regnum == PC_REGNUM && frame1 != NULL)
860 if (raw_buffer != NULL)
862 /* Put it back in target format. */
863 store_unsigned_integer (raw_buffer, REGISTER_RAW_SIZE (regnum), get_frame_pc (frame));
870 while (frame1 != NULL)
872 /* FIXME MVS: wrong test for dummy frame at entry. */
874 if (get_frame_pc (frame1) >= (get_frame_extra_info (frame1)->bottom
875 ? get_frame_extra_info (frame1)->bottom
877 && get_frame_pc (frame1) <= get_frame_base (frame1))
879 /* Dummy frame. All but the window regs are in there somewhere.
880 The window registers are saved on the stack, just like in a
882 if (regnum >= G1_REGNUM && regnum < G1_REGNUM + 7)
883 addr = get_frame_base (frame1) + (regnum - G0_REGNUM) * SPARC_INTREG_SIZE
884 - (FP_REGISTER_BYTES + 8 * SPARC_INTREG_SIZE);
885 else if (regnum >= I0_REGNUM && regnum < I0_REGNUM + 8)
886 /* NOTE: cagney/2002-05-04: The call to get_prev_frame()
887 is safe/cheap - there will always be a prev frame.
888 This is because frame1 is initialized to frame->next
889 (frame1->prev == frame) and is then advanced towards
890 the innermost (next) frame. */
891 addr = (get_frame_extra_info (get_prev_frame (frame1))->bottom
892 + (regnum - I0_REGNUM) * SPARC_INTREG_SIZE
894 else if (regnum >= L0_REGNUM && regnum < L0_REGNUM + 8)
895 /* NOTE: cagney/2002-05-04: The call to get_prev_frame()
896 is safe/cheap - there will always be a prev frame.
897 This is because frame1 is initialized to frame->next
898 (frame1->prev == frame) and is then advanced towards
899 the innermost (next) frame. */
900 addr = (get_frame_extra_info (get_prev_frame (frame1))->bottom
901 + (regnum - L0_REGNUM) * SPARC_INTREG_SIZE
903 else if (regnum >= O0_REGNUM && regnum < O0_REGNUM + 8)
904 addr = get_frame_base (frame1) + (regnum - O0_REGNUM) * SPARC_INTREG_SIZE
905 - (FP_REGISTER_BYTES + 16 * SPARC_INTREG_SIZE);
906 else if (SPARC_HAS_FPU &&
907 regnum >= FP0_REGNUM && regnum < FP0_REGNUM + 32)
908 addr = get_frame_base (frame1) + (regnum - FP0_REGNUM) * 4
909 - (FP_REGISTER_BYTES);
910 else if (GDB_TARGET_IS_SPARC64 && SPARC_HAS_FPU &&
911 regnum >= FP0_REGNUM + 32 && regnum < FP_MAX_REGNUM)
912 addr = get_frame_base (frame1) + 32 * 4 + (regnum - FP0_REGNUM - 32) * 8
913 - (FP_REGISTER_BYTES);
914 else if (regnum >= Y_REGNUM && regnum < NUM_REGS)
915 addr = get_frame_base (frame1) + (regnum - Y_REGNUM) * SPARC_INTREG_SIZE
916 - (FP_REGISTER_BYTES + 24 * SPARC_INTREG_SIZE);
918 else if (get_frame_extra_info (frame1)->flat)
921 if (regnum == RP_REGNUM)
922 addr = get_frame_extra_info (frame1)->pc_addr;
923 else if (regnum == I7_REGNUM)
924 addr = get_frame_extra_info (frame1)->fp_addr;
927 CORE_ADDR func_start;
930 regs = alloca (NUM_REGS * sizeof (CORE_ADDR));
931 memset (regs, 0, NUM_REGS * sizeof (CORE_ADDR));
933 find_pc_partial_function (get_frame_pc (frame1), NULL, &func_start, NULL);
934 examine_prologue (func_start, 0, frame1, regs);
940 /* Normal frame. Local and In registers are saved on stack. */
941 if (regnum >= I0_REGNUM && regnum < I0_REGNUM + 8)
942 addr = (get_frame_extra_info (get_prev_frame (frame1))->bottom
943 + (regnum - I0_REGNUM) * SPARC_INTREG_SIZE
945 else if (regnum >= L0_REGNUM && regnum < L0_REGNUM + 8)
946 addr = (get_frame_extra_info (get_prev_frame (frame1))->bottom
947 + (regnum - L0_REGNUM) * SPARC_INTREG_SIZE
949 else if (regnum >= O0_REGNUM && regnum < O0_REGNUM + 8)
951 /* Outs become ins. */
953 frame_register (frame1, (regnum - O0_REGNUM + I0_REGNUM),
954 optimized, lval, addrp, &realnum, raw_buffer);
960 frame1 = get_next_frame (frame1);
966 if (regnum == SP_REGNUM)
968 if (raw_buffer != NULL)
970 /* Put it back in target format. */
971 store_unsigned_integer (raw_buffer, REGISTER_RAW_SIZE (regnum), addr);
977 if (raw_buffer != NULL)
978 read_memory (addr, raw_buffer, REGISTER_RAW_SIZE (regnum));
983 *lval = lval_register;
984 addr = REGISTER_BYTE (regnum);
985 if (raw_buffer != NULL)
986 deprecated_read_register_gen (regnum, raw_buffer);
992 /* Push an empty stack frame, and record in it the current PC, regs, etc.
994 We save the non-windowed registers and the ins. The locals and outs
995 are new; they don't need to be saved. The i's and l's of
996 the last frame were already saved on the stack. */
998 /* Definitely see tm-sparc.h for more doc of the frame format here. */
1000 /* See tm-sparc.h for how this is calculated. */
1002 #define DUMMY_STACK_REG_BUF_SIZE \
1003 (((8+8+8) * SPARC_INTREG_SIZE) + FP_REGISTER_BYTES)
1004 #define DUMMY_STACK_SIZE \
1005 (DUMMY_STACK_REG_BUF_SIZE + DUMMY_REG_SAVE_OFFSET)
1008 sparc_push_dummy_frame (void)
1010 CORE_ADDR sp, old_sp;
1011 char *register_temp;
1013 register_temp = alloca (DUMMY_STACK_SIZE);
1015 old_sp = sp = read_sp ();
1017 if (GDB_TARGET_IS_SPARC64)
1019 /* PC, NPC, CCR, FSR, FPRS, Y, ASI */
1020 deprecated_read_register_bytes (REGISTER_BYTE (PC_REGNUM),
1022 REGISTER_RAW_SIZE (PC_REGNUM) * 7);
1023 deprecated_read_register_bytes (REGISTER_BYTE (PSTATE_REGNUM),
1024 ®ister_temp[7 * SPARC_INTREG_SIZE],
1025 REGISTER_RAW_SIZE (PSTATE_REGNUM));
1026 /* FIXME: not sure what needs to be saved here. */
1030 /* Y, PS, WIM, TBR, PC, NPC, FPS, CPS regs */
1031 deprecated_read_register_bytes (REGISTER_BYTE (Y_REGNUM),
1033 REGISTER_RAW_SIZE (Y_REGNUM) * 8);
1036 deprecated_read_register_bytes (REGISTER_BYTE (O0_REGNUM),
1037 ®ister_temp[8 * SPARC_INTREG_SIZE],
1038 SPARC_INTREG_SIZE * 8);
1040 deprecated_read_register_bytes (REGISTER_BYTE (G0_REGNUM),
1041 ®ister_temp[16 * SPARC_INTREG_SIZE],
1042 SPARC_INTREG_SIZE * 8);
1045 deprecated_read_register_bytes (REGISTER_BYTE (FP0_REGNUM),
1046 ®ister_temp[24 * SPARC_INTREG_SIZE],
1049 sp -= DUMMY_STACK_SIZE;
1051 DEPRECATED_DUMMY_WRITE_SP (sp);
1053 write_memory (sp + DUMMY_REG_SAVE_OFFSET, ®ister_temp[0],
1054 DUMMY_STACK_REG_BUF_SIZE);
1056 if (strcmp (target_shortname, "sim") != 0)
1058 /* NOTE: cagney/2002-04-04: The code below originally contained
1059 GDB's _only_ call to write_fp(). That call was eliminated by
1060 inlining the corresponding code. For the 64 bit case, the
1061 old function (sparc64_write_fp) did the below although I'm
1062 not clear why. The same goes for why this is only done when
1063 the underlying target is a simulator. */
1064 if (GDB_TARGET_IS_SPARC64)
1066 /* Target is a 64 bit SPARC. */
1067 CORE_ADDR oldfp = read_register (DEPRECATED_FP_REGNUM);
1069 write_register (DEPRECATED_FP_REGNUM, old_sp - 2047);
1071 write_register (DEPRECATED_FP_REGNUM, old_sp);
1075 /* Target is a 32 bit SPARC. */
1076 write_register (DEPRECATED_FP_REGNUM, old_sp);
1078 /* Set return address register for the call dummy to the current PC. */
1079 write_register (I7_REGNUM, read_pc () - 8);
1083 /* The call dummy will write this value to FP before executing
1084 the 'save'. This ensures that register window flushes work
1085 correctly in the simulator. */
1086 write_register (G0_REGNUM + 1, read_register (DEPRECATED_FP_REGNUM));
1088 /* The call dummy will write this value to FP after executing
1090 write_register (G0_REGNUM + 2, old_sp);
1092 /* The call dummy will write this value to the return address (%i7) after
1093 executing the 'save'. */
1094 write_register (G0_REGNUM + 3, read_pc () - 8);
1096 /* Set the FP that the call dummy will be using after the 'save'.
1097 This makes backtraces from an inferior function call work properly. */
1098 write_register (DEPRECATED_FP_REGNUM, old_sp);
1102 /* sparc_frame_find_saved_regs (). This function is here only because
1103 pop_frame uses it. Note there is an interesting corner case which
1104 I think few ports of GDB get right--if you are popping a frame
1105 which does not save some register that *is* saved by a more inner
1106 frame (such a frame will never be a dummy frame because dummy
1107 frames save all registers).
1109 NOTE: cagney/2003-03-12: Since pop_frame has been rewritten to use
1110 frame_unwind_register() the need for this function is questionable.
1112 Stores, into an array of CORE_ADDR,
1113 the addresses of the saved registers of frame described by FRAME_INFO.
1114 This includes special registers such as pc and fp saved in special
1115 ways in the stack frame. sp is even more special:
1116 the address we return for it IS the sp for the next frame.
1118 Note that on register window machines, we are currently making the
1119 assumption that window registers are being saved somewhere in the
1120 frame in which they are being used. If they are stored in an
1121 inferior frame, find_saved_register will break.
1123 On the Sun 4, the only time all registers are saved is when
1124 a dummy frame is involved. Otherwise, the only saved registers
1125 are the LOCAL and IN registers which are saved as a result
1126 of the "save/restore" opcodes. This condition is determined
1127 by address rather than by value.
1129 The "pc" is not stored in a frame on the SPARC. (What is stored
1130 is a return address minus 8.) sparc_pop_frame knows how to
1131 deal with that. Other routines might or might not.
1133 See tm-sparc.h (PUSH_DUMMY_FRAME and friends) for CRITICAL information
1134 about how this works. */
1136 static void sparc_frame_find_saved_regs (struct frame_info *, CORE_ADDR *);
1139 sparc_frame_find_saved_regs (struct frame_info *fi, CORE_ADDR *saved_regs_addr)
1141 register int regnum;
1142 CORE_ADDR frame_addr = get_frame_base (fi);
1144 gdb_assert (fi != NULL);
1146 memset (saved_regs_addr, 0, NUM_REGS * sizeof (CORE_ADDR));
1148 if (get_frame_pc (fi) >= (get_frame_extra_info (fi)->bottom
1149 ? get_frame_extra_info (fi)->bottom
1151 && get_frame_pc (fi) <= get_frame_base (fi))
1153 /* Dummy frame. All but the window regs are in there somewhere. */
1154 for (regnum = G1_REGNUM; regnum < G1_REGNUM + 7; regnum++)
1155 saved_regs_addr[regnum] =
1156 frame_addr + (regnum - G0_REGNUM) * SPARC_INTREG_SIZE
1157 - DUMMY_STACK_REG_BUF_SIZE + 16 * SPARC_INTREG_SIZE;
1159 for (regnum = I0_REGNUM; regnum < I0_REGNUM + 8; regnum++)
1160 saved_regs_addr[regnum] =
1161 frame_addr + (regnum - I0_REGNUM) * SPARC_INTREG_SIZE
1162 - DUMMY_STACK_REG_BUF_SIZE + 8 * SPARC_INTREG_SIZE;
1165 for (regnum = FP0_REGNUM; regnum < FP_MAX_REGNUM; regnum++)
1166 saved_regs_addr[regnum] = frame_addr + (regnum - FP0_REGNUM) * 4
1167 - DUMMY_STACK_REG_BUF_SIZE + 24 * SPARC_INTREG_SIZE;
1169 if (GDB_TARGET_IS_SPARC64)
1171 for (regnum = PC_REGNUM; regnum < PC_REGNUM + 7; regnum++)
1173 saved_regs_addr[regnum] =
1174 frame_addr + (regnum - PC_REGNUM) * SPARC_INTREG_SIZE
1175 - DUMMY_STACK_REG_BUF_SIZE;
1177 saved_regs_addr[PSTATE_REGNUM] =
1178 frame_addr + 8 * SPARC_INTREG_SIZE - DUMMY_STACK_REG_BUF_SIZE;
1181 for (regnum = Y_REGNUM; regnum < NUM_REGS; regnum++)
1182 saved_regs_addr[regnum] =
1183 frame_addr + (regnum - Y_REGNUM) * SPARC_INTREG_SIZE
1184 - DUMMY_STACK_REG_BUF_SIZE;
1186 frame_addr = (get_frame_extra_info (fi)->bottom
1187 ? get_frame_extra_info (fi)->bottom
1190 else if (get_frame_extra_info (fi)->flat)
1192 CORE_ADDR func_start;
1193 find_pc_partial_function (get_frame_pc (fi), NULL, &func_start, NULL);
1194 examine_prologue (func_start, 0, fi, saved_regs_addr);
1196 /* Flat register window frame. */
1197 saved_regs_addr[RP_REGNUM] = get_frame_extra_info (fi)->pc_addr;
1198 saved_regs_addr[I7_REGNUM] = get_frame_extra_info (fi)->fp_addr;
1202 /* Normal frame. Just Local and In registers */
1203 frame_addr = (get_frame_extra_info (fi)->bottom
1204 ? get_frame_extra_info (fi)->bottom
1206 for (regnum = L0_REGNUM; regnum < L0_REGNUM + 8; regnum++)
1207 saved_regs_addr[regnum] =
1208 (frame_addr + (regnum - L0_REGNUM) * SPARC_INTREG_SIZE
1210 for (regnum = I0_REGNUM; regnum < I0_REGNUM + 8; regnum++)
1211 saved_regs_addr[regnum] =
1212 (frame_addr + (regnum - I0_REGNUM) * SPARC_INTREG_SIZE
1215 if (get_next_frame (fi))
1217 if (get_frame_extra_info (fi)->flat)
1219 saved_regs_addr[O7_REGNUM] = get_frame_extra_info (fi)->pc_addr;
1223 /* Pull off either the next frame pointer or the stack pointer */
1224 CORE_ADDR next_next_frame_addr =
1225 (get_frame_extra_info (get_next_frame (fi))->bottom
1226 ? get_frame_extra_info (get_next_frame (fi))->bottom
1228 for (regnum = O0_REGNUM; regnum < O0_REGNUM + 8; regnum++)
1229 saved_regs_addr[regnum] =
1230 (next_next_frame_addr
1231 + (regnum - O0_REGNUM) * SPARC_INTREG_SIZE
1235 /* Otherwise, whatever we would get from ptrace(GETREGS) is accurate */
1236 /* FIXME -- should this adjust for the sparc64 offset? */
1237 saved_regs_addr[SP_REGNUM] = get_frame_base (fi);
1240 /* Discard from the stack the innermost frame, restoring all saved registers.
1242 Note that the values stored in fsr by
1243 deprecated_get_frame_saved_regs are *in the context of the called
1244 frame*. What this means is that the i regs of fsr must be restored
1245 into the o regs of the (calling) frame that we pop into. We don't
1246 care about the output regs of the calling frame, since unless it's
1247 a dummy frame, it won't have any output regs in it.
1249 We never have to bother with %l (local) regs, since the called routine's
1250 locals get tossed, and the calling routine's locals are already saved
1253 /* Definitely see tm-sparc.h for more doc of the frame format here. */
1256 sparc_pop_frame (void)
1258 register struct frame_info *frame = get_current_frame ();
1259 register CORE_ADDR pc;
1264 fsr = alloca (NUM_REGS * sizeof (CORE_ADDR));
1265 raw_buffer = alloca (DEPRECATED_REGISTER_BYTES);
1266 sparc_frame_find_saved_regs (frame, &fsr[0]);
1269 if (fsr[FP0_REGNUM])
1271 read_memory (fsr[FP0_REGNUM], raw_buffer, FP_REGISTER_BYTES);
1272 deprecated_write_register_bytes (REGISTER_BYTE (FP0_REGNUM),
1273 raw_buffer, FP_REGISTER_BYTES);
1275 if (!(GDB_TARGET_IS_SPARC64))
1277 if (fsr[FPS_REGNUM])
1279 read_memory (fsr[FPS_REGNUM], raw_buffer, SPARC_INTREG_SIZE);
1280 deprecated_write_register_gen (FPS_REGNUM, raw_buffer);
1282 if (fsr[CPS_REGNUM])
1284 read_memory (fsr[CPS_REGNUM], raw_buffer, SPARC_INTREG_SIZE);
1285 deprecated_write_register_gen (CPS_REGNUM, raw_buffer);
1291 read_memory (fsr[G1_REGNUM], raw_buffer, 7 * SPARC_INTREG_SIZE);
1292 deprecated_write_register_bytes (REGISTER_BYTE (G1_REGNUM), raw_buffer,
1293 7 * SPARC_INTREG_SIZE);
1296 if (get_frame_extra_info (frame)->flat)
1298 /* Each register might or might not have been saved, need to test
1300 for (regnum = L0_REGNUM; regnum < L0_REGNUM + 8; ++regnum)
1302 write_register (regnum, read_memory_integer (fsr[regnum],
1303 SPARC_INTREG_SIZE));
1304 for (regnum = I0_REGNUM; regnum < I0_REGNUM + 8; ++regnum)
1306 write_register (regnum, read_memory_integer (fsr[regnum],
1307 SPARC_INTREG_SIZE));
1309 /* Handle all outs except stack pointer (o0-o5; o7). */
1310 for (regnum = O0_REGNUM; regnum < O0_REGNUM + 6; ++regnum)
1312 write_register (regnum, read_memory_integer (fsr[regnum],
1313 SPARC_INTREG_SIZE));
1314 if (fsr[O0_REGNUM + 7])
1315 write_register (O0_REGNUM + 7,
1316 read_memory_integer (fsr[O0_REGNUM + 7],
1317 SPARC_INTREG_SIZE));
1319 DEPRECATED_DUMMY_WRITE_SP (get_frame_base (frame));
1321 else if (fsr[I0_REGNUM])
1327 reg_temp = alloca (SPARC_INTREG_SIZE * 16);
1329 read_memory (fsr[I0_REGNUM], raw_buffer, 8 * SPARC_INTREG_SIZE);
1331 /* Get the ins and locals which we are about to restore. Just
1332 moving the stack pointer is all that is really needed, except
1333 store_inferior_registers is then going to write the ins and
1334 locals from the registers array, so we need to muck with the
1336 sp = fsr[SP_REGNUM];
1338 if (GDB_TARGET_IS_SPARC64 && (sp & 1))
1341 read_memory (sp, reg_temp, SPARC_INTREG_SIZE * 16);
1343 /* Restore the out registers.
1344 Among other things this writes the new stack pointer. */
1345 deprecated_write_register_bytes (REGISTER_BYTE (O0_REGNUM), raw_buffer,
1346 SPARC_INTREG_SIZE * 8);
1348 deprecated_write_register_bytes (REGISTER_BYTE (L0_REGNUM), reg_temp,
1349 SPARC_INTREG_SIZE * 16);
1352 if (!(GDB_TARGET_IS_SPARC64))
1354 write_register (PS_REGNUM,
1355 read_memory_integer (fsr[PS_REGNUM],
1356 REGISTER_RAW_SIZE (PS_REGNUM)));
1359 write_register (Y_REGNUM,
1360 read_memory_integer (fsr[Y_REGNUM],
1361 REGISTER_RAW_SIZE (Y_REGNUM)));
1364 /* Explicitly specified PC (and maybe NPC) -- just restore them. */
1365 write_register (PC_REGNUM,
1366 read_memory_integer (fsr[PC_REGNUM],
1367 REGISTER_RAW_SIZE (PC_REGNUM)));
1368 if (fsr[NPC_REGNUM])
1369 write_register (NPC_REGNUM,
1370 read_memory_integer (fsr[NPC_REGNUM],
1371 REGISTER_RAW_SIZE (NPC_REGNUM)));
1373 else if (get_frame_extra_info (frame)->flat)
1375 if (get_frame_extra_info (frame)->pc_addr)
1376 pc = PC_ADJUST ((CORE_ADDR)
1377 read_memory_integer (get_frame_extra_info (frame)->pc_addr,
1378 REGISTER_RAW_SIZE (PC_REGNUM)));
1381 /* I think this happens only in the innermost frame, if so then
1382 it is a complicated way of saying
1383 "pc = read_register (O7_REGNUM);". */
1385 frame_read_unsigned_register (frame, O7_REGNUM, &tmp);
1386 pc = PC_ADJUST (tmp);
1389 write_register (PC_REGNUM, pc);
1390 write_register (NPC_REGNUM, pc + 4);
1392 else if (fsr[I7_REGNUM])
1394 /* Return address in %i7 -- adjust it, then restore PC and NPC from it */
1395 pc = PC_ADJUST ((CORE_ADDR) read_memory_integer (fsr[I7_REGNUM],
1396 SPARC_INTREG_SIZE));
1397 write_register (PC_REGNUM, pc);
1398 write_register (NPC_REGNUM, pc + 4);
1400 flush_cached_frames ();
1403 /* On the Sun 4 under SunOS, the compile will leave a fake insn which
1404 encodes the structure size being returned. If we detect such
1405 a fake insn, step past it. */
1408 sparc_pc_adjust (CORE_ADDR pc)
1414 err = target_read_memory (pc + 8, buf, 4);
1415 insn = extract_unsigned_integer (buf, 4);
1416 if ((err == 0) && (insn & 0xffc00000) == 0)
1422 /* If pc is in a shared library trampoline, return its target.
1423 The SunOs 4.x linker rewrites the jump table entries for PIC
1424 compiled modules in the main executable to bypass the dynamic linker
1425 with jumps of the form
1428 and removes the corresponding jump table relocation entry in the
1429 dynamic relocations.
1430 find_solib_trampoline_target relies on the presence of the jump
1431 table relocation entry, so we have to detect these jump instructions
1435 sunos4_skip_trampoline_code (CORE_ADDR pc)
1437 unsigned long insn1;
1441 err = target_read_memory (pc, buf, 4);
1442 insn1 = extract_unsigned_integer (buf, 4);
1443 if (err == 0 && (insn1 & 0xffc00000) == 0x03000000)
1445 unsigned long insn2;
1447 err = target_read_memory (pc + 4, buf, 4);
1448 insn2 = extract_unsigned_integer (buf, 4);
1449 if (err == 0 && (insn2 & 0xffffe000) == 0x81c06000)
1451 CORE_ADDR target_pc = (insn1 & 0x3fffff) << 10;
1452 int delta = insn2 & 0x1fff;
1454 /* Sign extend the displacement. */
1457 return target_pc + delta;
1460 return find_solib_trampoline_target (pc);
1463 #ifdef USE_PROC_FS /* Target dependent support for /proc */
1465 /* The /proc interface divides the target machine's register set up into
1466 two different sets, the general register set (gregset) and the floating
1467 point register set (fpregset). For each set, there is an ioctl to get
1468 the current register set and another ioctl to set the current values.
1470 The actual structure passed through the ioctl interface is, of course,
1471 naturally machine dependent, and is different for each set of registers.
1472 For the sparc for example, the general register set is typically defined
1475 typedef int gregset_t[38];
1481 and the floating point set by:
1483 typedef struct prfpregset {
1486 double pr_dregs[16];
1491 u_char pr_q_entrysize;
1496 These routines provide the packing and unpacking of gregset_t and
1497 fpregset_t formatted data.
1502 /* Given a pointer to a general register set in /proc format (gregset_t *),
1503 unpack the register contents and supply them as gdb's idea of the current
1507 supply_gregset (gdb_gregset_t *gregsetp)
1509 prgreg_t *regp = (prgreg_t *) gregsetp;
1510 int regi, offset = 0;
1512 /* If the host is 64-bit sparc, but the target is 32-bit sparc,
1513 then the gregset may contain 64-bit ints while supply_register
1514 is expecting 32-bit ints. Compensate. */
1515 if (sizeof (regp[0]) == 8 && SPARC_INTREG_SIZE == 4)
1518 /* GDB register numbers for Gn, On, Ln, In all match /proc reg numbers. */
1519 /* FIXME MVS: assumes the order of the first 32 elements... */
1520 for (regi = G0_REGNUM; regi <= I7_REGNUM; regi++)
1522 supply_register (regi, ((char *) (regp + regi)) + offset);
1525 /* These require a bit more care. */
1526 supply_register (PC_REGNUM, ((char *) (regp + R_PC)) + offset);
1527 supply_register (NPC_REGNUM, ((char *) (regp + R_nPC)) + offset);
1528 supply_register (Y_REGNUM, ((char *) (regp + R_Y)) + offset);
1530 if (GDB_TARGET_IS_SPARC64)
1533 supply_register (CCR_REGNUM, ((char *) (regp + R_CCR)) + offset);
1535 supply_register (CCR_REGNUM, NULL);
1538 supply_register (FPRS_REGNUM, ((char *) (regp + R_FPRS)) + offset);
1540 supply_register (FPRS_REGNUM, NULL);
1543 supply_register (ASI_REGNUM, ((char *) (regp + R_ASI)) + offset);
1545 supply_register (ASI_REGNUM, NULL);
1551 supply_register (PS_REGNUM, ((char *) (regp + R_PS)) + offset);
1553 supply_register (PS_REGNUM, NULL);
1556 /* For 64-bit hosts, R_WIM and R_TBR may not be defined.
1557 Steal R_ASI and R_FPRS, and hope for the best! */
1559 #if !defined (R_WIM) && defined (R_ASI)
1563 #if !defined (R_TBR) && defined (R_FPRS)
1564 #define R_TBR R_FPRS
1568 supply_register (WIM_REGNUM, ((char *) (regp + R_WIM)) + offset);
1570 supply_register (WIM_REGNUM, NULL);
1574 supply_register (TBR_REGNUM, ((char *) (regp + R_TBR)) + offset);
1576 supply_register (TBR_REGNUM, NULL);
1580 /* Fill inaccessible registers with zero. */
1581 if (GDB_TARGET_IS_SPARC64)
1584 * don't know how to get value of any of the following:
1586 supply_register (VER_REGNUM, NULL);
1587 supply_register (TICK_REGNUM, NULL);
1588 supply_register (PIL_REGNUM, NULL);
1589 supply_register (PSTATE_REGNUM, NULL);
1590 supply_register (TSTATE_REGNUM, NULL);
1591 supply_register (TBA_REGNUM, NULL);
1592 supply_register (TL_REGNUM, NULL);
1593 supply_register (TT_REGNUM, NULL);
1594 supply_register (TPC_REGNUM, NULL);
1595 supply_register (TNPC_REGNUM, NULL);
1596 supply_register (WSTATE_REGNUM, NULL);
1597 supply_register (CWP_REGNUM, NULL);
1598 supply_register (CANSAVE_REGNUM, NULL);
1599 supply_register (CANRESTORE_REGNUM, NULL);
1600 supply_register (CLEANWIN_REGNUM, NULL);
1601 supply_register (OTHERWIN_REGNUM, NULL);
1602 supply_register (ASR16_REGNUM, NULL);
1603 supply_register (ASR17_REGNUM, NULL);
1604 supply_register (ASR18_REGNUM, NULL);
1605 supply_register (ASR19_REGNUM, NULL);
1606 supply_register (ASR20_REGNUM, NULL);
1607 supply_register (ASR21_REGNUM, NULL);
1608 supply_register (ASR22_REGNUM, NULL);
1609 supply_register (ASR23_REGNUM, NULL);
1610 supply_register (ASR24_REGNUM, NULL);
1611 supply_register (ASR25_REGNUM, NULL);
1612 supply_register (ASR26_REGNUM, NULL);
1613 supply_register (ASR27_REGNUM, NULL);
1614 supply_register (ASR28_REGNUM, NULL);
1615 supply_register (ASR29_REGNUM, NULL);
1616 supply_register (ASR30_REGNUM, NULL);
1617 supply_register (ASR31_REGNUM, NULL);
1618 supply_register (ICC_REGNUM, NULL);
1619 supply_register (XCC_REGNUM, NULL);
1623 supply_register (CPS_REGNUM, NULL);
1628 fill_gregset (gdb_gregset_t *gregsetp, int regno)
1630 prgreg_t *regp = (prgreg_t *) gregsetp;
1631 int regi, offset = 0;
1633 /* If the host is 64-bit sparc, but the target is 32-bit sparc,
1634 then the gregset may contain 64-bit ints while supply_register
1635 is expecting 32-bit ints. Compensate. */
1636 if (sizeof (regp[0]) == 8 && SPARC_INTREG_SIZE == 4)
1639 for (regi = 0; regi <= R_I7; regi++)
1640 if ((regno == -1) || (regno == regi))
1641 deprecated_read_register_gen (regi, (char *) (regp + regi) + offset);
1643 if ((regno == -1) || (regno == PC_REGNUM))
1644 deprecated_read_register_gen (PC_REGNUM, (char *) (regp + R_PC) + offset);
1646 if ((regno == -1) || (regno == NPC_REGNUM))
1647 deprecated_read_register_gen (NPC_REGNUM, (char *) (regp + R_nPC) + offset);
1649 if ((regno == -1) || (regno == Y_REGNUM))
1650 deprecated_read_register_gen (Y_REGNUM, (char *) (regp + R_Y) + offset);
1652 if (GDB_TARGET_IS_SPARC64)
1655 if (regno == -1 || regno == CCR_REGNUM)
1656 deprecated_read_register_gen (CCR_REGNUM, ((char *) (regp + R_CCR)) + offset);
1659 if (regno == -1 || regno == FPRS_REGNUM)
1660 deprecated_read_register_gen (FPRS_REGNUM, ((char *) (regp + R_FPRS)) + offset);
1663 if (regno == -1 || regno == ASI_REGNUM)
1664 deprecated_read_register_gen (ASI_REGNUM, ((char *) (regp + R_ASI)) + offset);
1670 if (regno == -1 || regno == PS_REGNUM)
1671 deprecated_read_register_gen (PS_REGNUM, ((char *) (regp + R_PS)) + offset);
1674 /* For 64-bit hosts, R_WIM and R_TBR may not be defined.
1675 Steal R_ASI and R_FPRS, and hope for the best! */
1677 #if !defined (R_WIM) && defined (R_ASI)
1681 #if !defined (R_TBR) && defined (R_FPRS)
1682 #define R_TBR R_FPRS
1686 if (regno == -1 || regno == WIM_REGNUM)
1687 deprecated_read_register_gen (WIM_REGNUM, ((char *) (regp + R_WIM)) + offset);
1689 if (regno == -1 || regno == WIM_REGNUM)
1690 deprecated_read_register_gen (WIM_REGNUM, NULL);
1694 if (regno == -1 || regno == TBR_REGNUM)
1695 deprecated_read_register_gen (TBR_REGNUM, ((char *) (regp + R_TBR)) + offset);
1697 if (regno == -1 || regno == TBR_REGNUM)
1698 deprecated_read_register_gen (TBR_REGNUM, NULL);
1703 /* Given a pointer to a floating point register set in /proc format
1704 (fpregset_t *), unpack the register contents and supply them as gdb's
1705 idea of the current floating point register values. */
1708 supply_fpregset (gdb_fpregset_t *fpregsetp)
1716 for (regi = FP0_REGNUM; regi < FP_MAX_REGNUM; regi++)
1718 from = (char *) &fpregsetp->pr_fr.pr_regs[regi - FP0_REGNUM];
1719 supply_register (regi, from);
1722 if (GDB_TARGET_IS_SPARC64)
1725 * don't know how to get value of the following.
1727 supply_register (FSR_REGNUM, NULL); /* zero it out for now */
1728 supply_register (FCC0_REGNUM, NULL);
1729 supply_register (FCC1_REGNUM, NULL); /* don't know how to get value */
1730 supply_register (FCC2_REGNUM, NULL); /* don't know how to get value */
1731 supply_register (FCC3_REGNUM, NULL); /* don't know how to get value */
1735 supply_register (FPS_REGNUM, (char *) &(fpregsetp->pr_fsr));
1739 /* Given a pointer to a floating point register set in /proc format
1740 (fpregset_t *), update the register specified by REGNO from gdb's idea
1741 of the current floating point register set. If REGNO is -1, update
1743 /* This will probably need some changes for sparc64. */
1746 fill_fpregset (gdb_fpregset_t *fpregsetp, int regno)
1755 for (regi = FP0_REGNUM; regi < FP_MAX_REGNUM; regi++)
1757 if ((regno == -1) || (regno == regi))
1759 from = (char *) &deprecated_registers[REGISTER_BYTE (regi)];
1760 to = (char *) &fpregsetp->pr_fr.pr_regs[regi - FP0_REGNUM];
1761 memcpy (to, from, REGISTER_RAW_SIZE (regi));
1765 if (!(GDB_TARGET_IS_SPARC64)) /* FIXME: does Sparc64 have this register? */
1766 if ((regno == -1) || (regno == FPS_REGNUM))
1768 from = (char *)&deprecated_registers[REGISTER_BYTE (FPS_REGNUM)];
1769 to = (char *) &fpregsetp->pr_fsr;
1770 memcpy (to, from, REGISTER_RAW_SIZE (FPS_REGNUM));
1774 #endif /* USE_PROC_FS */
1776 /* Because of Multi-arch, GET_LONGJMP_TARGET is always defined. So test
1777 for a definition of JB_PC. */
1780 /* Figure out where the longjmp will land. We expect that we have just entered
1781 longjmp and haven't yet setup the stack frame, so the args are still in the
1782 output regs. %o0 (O0_REGNUM) points at the jmp_buf structure from which we
1783 extract the pc (JB_PC) that we will land at. The pc is copied into ADDR.
1784 This routine returns true on success */
1787 get_longjmp_target (CORE_ADDR *pc)
1790 #define LONGJMP_TARGET_SIZE 4
1791 char buf[LONGJMP_TARGET_SIZE];
1793 jb_addr = read_register (O0_REGNUM);
1795 if (target_read_memory (jb_addr + JB_PC * JB_ELEMENT_SIZE, buf,
1796 LONGJMP_TARGET_SIZE))
1799 *pc = extract_unsigned_integer (buf, LONGJMP_TARGET_SIZE);
1803 #endif /* GET_LONGJMP_TARGET */
1805 #ifdef STATIC_TRANSFORM_NAME
1806 /* SunPRO (3.0 at least), encodes the static variables. This is not
1807 related to C++ mangling, it is done for C too. */
1810 sunpro_static_transform_name (char *name)
1815 /* For file-local statics there will be a dollar sign, a bunch
1816 of junk (the contents of which match a string given in the
1817 N_OPT), a period and the name. For function-local statics
1818 there will be a bunch of junk (which seems to change the
1819 second character from 'A' to 'B'), a period, the name of the
1820 function, and the name. So just skip everything before the
1822 p = strrchr (name, '.');
1828 #endif /* STATIC_TRANSFORM_NAME */
1831 /* Utilities for printing registers.
1832 Page numbers refer to the SPARC Architecture Manual. */
1834 static void dump_ccreg (char *, int);
1837 dump_ccreg (char *reg, int val)
1840 printf_unfiltered ("%s:%s,%s,%s,%s", reg,
1841 val & 8 ? "N" : "NN",
1842 val & 4 ? "Z" : "NZ",
1843 val & 2 ? "O" : "NO",
1844 val & 1 ? "C" : "NC");
1848 decode_asi (int val)
1854 return "ASI_NUCLEUS";
1856 return "ASI_NUCLEUS_LITTLE";
1858 return "ASI_AS_IF_USER_PRIMARY";
1860 return "ASI_AS_IF_USER_SECONDARY";
1862 return "ASI_AS_IF_USER_PRIMARY_LITTLE";
1864 return "ASI_AS_IF_USER_SECONDARY_LITTLE";
1866 return "ASI_PRIMARY";
1868 return "ASI_SECONDARY";
1870 return "ASI_PRIMARY_NOFAULT";
1872 return "ASI_SECONDARY_NOFAULT";
1874 return "ASI_PRIMARY_LITTLE";
1876 return "ASI_SECONDARY_LITTLE";
1878 return "ASI_PRIMARY_NOFAULT_LITTLE";
1880 return "ASI_SECONDARY_NOFAULT_LITTLE";
1886 /* Pretty print various registers. */
1887 /* FIXME: Would be nice if this did some fancy things for 32 bit sparc. */
1890 sparc_print_register_hook (int regno)
1894 /* Handle double/quad versions of lower 32 fp regs. */
1895 if (regno >= FP0_REGNUM && regno < FP0_REGNUM + 32
1896 && (regno & 1) == 0)
1900 if (frame_register_read (deprecated_selected_frame, regno, value)
1901 && frame_register_read (deprecated_selected_frame, regno + 1, value + 4))
1903 printf_unfiltered ("\t");
1904 print_floating (value, builtin_type_double, gdb_stdout);
1906 #if 0 /* FIXME: gdb doesn't handle long doubles */
1907 if ((regno & 3) == 0)
1909 if (frame_register_read (deprecated_selected_frame, regno + 2, value + 8)
1910 && frame_register_read (deprecated_selected_frame, regno + 3, value + 12))
1912 printf_unfiltered ("\t");
1913 print_floating (value, builtin_type_long_double, gdb_stdout);
1920 #if 0 /* FIXME: gdb doesn't handle long doubles */
1921 /* Print upper fp regs as long double if appropriate. */
1922 if (regno >= FP0_REGNUM + 32 && regno < FP_MAX_REGNUM
1923 /* We test for even numbered regs and not a multiple of 4 because
1924 the upper fp regs are recorded as doubles. */
1925 && (regno & 1) == 0)
1929 if (frame_register_read (deprecated_selected_frame, regno, value)
1930 && frame_register_read (deprecated_selected_frame, regno + 1, value + 8))
1932 printf_unfiltered ("\t");
1933 print_floating (value, builtin_type_long_double, gdb_stdout);
1939 /* FIXME: Some of these are priviledged registers.
1940 Not sure how they should be handled. */
1942 #define BITS(n, mask) ((int) (((val) >> (n)) & (mask)))
1944 val = read_register (regno);
1947 if (GDB_TARGET_IS_SPARC64)
1951 printf_unfiltered ("\t");
1952 dump_ccreg ("xcc", val >> 4);
1953 printf_unfiltered (", ");
1954 dump_ccreg ("icc", val & 15);
1957 printf ("\tfef:%d, du:%d, dl:%d",
1958 BITS (2, 1), BITS (1, 1), BITS (0, 1));
1962 static char *fcc[4] =
1963 {"=", "<", ">", "?"};
1964 static char *rd[4] =
1965 {"N", "0", "+", "-"};
1966 /* Long, but I'd rather leave it as is and use a wide screen. */
1967 printf_filtered ("\t0:%s, 1:%s, 2:%s, 3:%s, rd:%s, tem:%d, ",
1968 fcc[BITS (10, 3)], fcc[BITS (32, 3)],
1969 fcc[BITS (34, 3)], fcc[BITS (36, 3)],
1970 rd[BITS (30, 3)], BITS (23, 31));
1971 printf_filtered ("ns:%d, ver:%d, ftt:%d, qne:%d, aexc:%d, cexc:%d",
1972 BITS (22, 1), BITS (17, 7), BITS (14, 7),
1973 BITS (13, 1), BITS (5, 31), BITS (0, 31));
1978 char *asi = decode_asi (val);
1980 printf ("\t%s", asi);
1984 printf ("\tmanuf:%d, impl:%d, mask:%d, maxtl:%d, maxwin:%d",
1985 BITS (48, 0xffff), BITS (32, 0xffff),
1986 BITS (24, 0xff), BITS (8, 0xff), BITS (0, 31));
1990 static char *mm[4] =
1991 {"tso", "pso", "rso", "?"};
1992 printf_filtered ("\tcle:%d, tle:%d, mm:%s, red:%d, ",
1993 BITS (9, 1), BITS (8, 1),
1994 mm[BITS (6, 3)], BITS (5, 1));
1995 printf_filtered ("pef:%d, am:%d, priv:%d, ie:%d, ag:%d",
1996 BITS (4, 1), BITS (3, 1), BITS (2, 1),
1997 BITS (1, 1), BITS (0, 1));
2001 /* FIXME: print all 4? */
2004 /* FIXME: print all 4? */
2007 /* FIXME: print all 4? */
2010 /* FIXME: print all 4? */
2013 printf ("\tother:%d, normal:%d", BITS (3, 7), BITS (0, 7));
2016 printf ("\t%d", BITS (0, 31));
2018 case CANSAVE_REGNUM:
2019 printf ("\t%-2d before spill", BITS (0, 31));
2021 case CANRESTORE_REGNUM:
2022 printf ("\t%-2d before fill", BITS (0, 31));
2024 case CLEANWIN_REGNUM:
2025 printf ("\t%-2d before clean", BITS (0, 31));
2027 case OTHERWIN_REGNUM:
2028 printf ("\t%d", BITS (0, 31));
2035 printf ("\ticc:%c%c%c%c, pil:%d, s:%d, ps:%d, et:%d, cwp:%d",
2036 BITS (23, 1) ? 'N' : '-', BITS (22, 1) ? 'Z' : '-',
2037 BITS (21, 1) ? 'V' : '-', BITS (20, 1) ? 'C' : '-',
2038 BITS (8, 15), BITS (7, 1), BITS (6, 1), BITS (5, 1),
2043 static char *fcc[4] =
2044 {"=", "<", ">", "?"};
2045 static char *rd[4] =
2046 {"N", "0", "+", "-"};
2047 /* Long, but I'd rather leave it as is and use a wide screen. */
2048 printf ("\trd:%s, tem:%d, ns:%d, ver:%d, ftt:%d, qne:%d, "
2049 "fcc:%s, aexc:%d, cexc:%d",
2050 rd[BITS (30, 3)], BITS (23, 31), BITS (22, 1), BITS (17, 7),
2051 BITS (14, 7), BITS (13, 1), fcc[BITS (10, 3)], BITS (5, 31),
2061 sparc_print_registers (struct gdbarch *gdbarch,
2062 struct ui_file *file,
2063 struct frame_info *frame,
2064 int regnum, int print_all,
2065 void (*print_register_hook) (int))
2068 const int numregs = NUM_REGS + NUM_PSEUDO_REGS;
2069 char raw_buffer[MAX_REGISTER_SIZE];
2070 char virtual_buffer[MAX_REGISTER_SIZE];
2072 for (i = 0; i < numregs; i++)
2074 /* Decide between printing all regs, non-float / vector regs, or
2080 if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (i)) == TYPE_CODE_FLT)
2082 if (TYPE_VECTOR (REGISTER_VIRTUAL_TYPE (i)))
2092 /* If the register name is empty, it is undefined for this
2093 processor, so don't display anything. */
2094 if (REGISTER_NAME (i) == NULL || *(REGISTER_NAME (i)) == '\0')
2097 fputs_filtered (REGISTER_NAME (i), file);
2098 print_spaces_filtered (15 - strlen (REGISTER_NAME (i)), file);
2100 /* Get the data in raw format. */
2101 if (! frame_register_read (frame, i, raw_buffer))
2103 fprintf_filtered (file, "*value not available*\n");
2107 memcpy (virtual_buffer, raw_buffer, REGISTER_VIRTUAL_SIZE (i));
2109 /* If virtual format is floating, print it that way, and in raw
2111 if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (i)) == TYPE_CODE_FLT)
2115 val_print (REGISTER_VIRTUAL_TYPE (i), virtual_buffer, 0, 0,
2116 file, 0, 1, 0, Val_pretty_default);
2118 fprintf_filtered (file, "\t(raw 0x");
2119 for (j = 0; j < REGISTER_RAW_SIZE (i); j++)
2122 if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
2125 idx = REGISTER_RAW_SIZE (i) - 1 - j;
2126 fprintf_filtered (file, "%02x", (unsigned char) raw_buffer[idx]);
2128 fprintf_filtered (file, ")");
2132 /* Print the register in hex. */
2133 val_print (REGISTER_VIRTUAL_TYPE (i), virtual_buffer, 0, 0,
2134 file, 'x', 1, 0, Val_pretty_default);
2135 /* If not a vector register, print it also according to its
2137 if (TYPE_VECTOR (REGISTER_VIRTUAL_TYPE (i)) == 0)
2139 fprintf_filtered (file, "\t");
2140 val_print (REGISTER_VIRTUAL_TYPE (i), virtual_buffer, 0, 0,
2141 file, 0, 1, 0, Val_pretty_default);
2145 /* Some sparc specific info. */
2146 if (print_register_hook != NULL)
2147 print_register_hook (i);
2149 fprintf_filtered (file, "\n");
2154 sparc_print_registers_info (struct gdbarch *gdbarch,
2155 struct ui_file *file,
2156 struct frame_info *frame,
2157 int regnum, int print_all)
2159 sparc_print_registers (gdbarch, file, frame, regnum, print_all,
2160 sparc_print_register_hook);
2164 sparc_do_registers_info (int regnum, int all)
2166 sparc_print_registers_info (current_gdbarch, gdb_stdout, deprecated_selected_frame,
2171 // OBSOLETE static void
2172 // OBSOLETE sparclet_print_registers_info (struct gdbarch *gdbarch,
2173 // OBSOLETE struct ui_file *file,
2174 // OBSOLETE struct frame_info *frame,
2175 // OBSOLETE int regnum, int print_all)
2177 // OBSOLETE sparc_print_registers (gdbarch, file, frame, regnum, print_all, NULL);
2181 // OBSOLETE sparclet_do_registers_info (int regnum, int all)
2183 // OBSOLETE sparclet_print_registers_info (current_gdbarch, gdb_stdout,
2184 // OBSOLETE deprecated_selected_frame, regnum, all);
2190 gdb_print_insn_sparc (bfd_vma memaddr, disassemble_info *info)
2192 /* It's necessary to override mach again because print_insn messes it up. */
2193 info->mach = TARGET_ARCHITECTURE->mach;
2194 return print_insn_sparc (memaddr, info);
2198 #define SPARC_F0_REGNUM FP0_REGNUM /* %f0 */
2199 #define SPARC_F1_REGNUM (FP0_REGNUM + 1)/* %f1 */
2200 #define SPARC_O0_REGNUM O0_REGNUM /* %o0 */
2201 #define SPARC_O1_REGNUM O1_REGNUM /* %o1 */
2203 /* Push the arguments onto the stack and into the appropriate registers. */
2206 sparc32_do_push_arguments (struct regcache *regcache, int nargs,
2207 struct value **args, CORE_ADDR sp)
2213 /* Structure, union and quad-precision arguments are passed by
2214 reference. We allocate space for these arguments on the stack
2215 and record their addresses in an array. Array elements for
2216 arguments that are passed by value will be set to zero.*/
2217 addr = alloca (nargs * sizeof (CORE_ADDR));
2219 for (i = nargs - 1; i >= 0; i--)
2221 struct type *type = VALUE_ENCLOSING_TYPE (args[i]);
2222 enum type_code code = TYPE_CODE (type);
2223 int len = TYPE_LENGTH (type);
2225 /* Push the contents of structure, union and quad-precision
2226 arguments on the stack. */
2227 if (code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION || len > 8)
2229 /* Keep the stack doubleword aligned. */
2230 sp -= (len + 7) & ~7;
2231 write_memory (sp, VALUE_CONTENTS_ALL (args[i]), len);
2238 size += (len > 4) ? 8 : 4;
2242 /* The needed space for outgoing arguments should be a multiple of 4. */
2243 gdb_assert (size % 4 == 0);
2245 /* Make sure we reserve space for the first six words of arguments
2246 in the stack frame, even if we don't need them. */
2250 /* Make sure we end up with a doubleword aligned stack in the end.
2251 Reserve an extra word if necessary in order to accomplish this. */
2252 if ((sp - size) % 8 == 0)
2255 /* Now push the arguments onto the stack. */
2256 for (i = nargs - 1; i >=0; i--)
2263 store_unsigned_integer (buf, 4, addr[i]);
2268 struct value *arg = args[i];
2270 len = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (arg));
2272 /* Expand signed and unsigned bytes and halfwords as needed. */
2275 arg = value_cast (builtin_type_long, arg);
2278 else if (len > 4 && len < 8)
2280 arg = value_cast (builtin_type_long_long, arg);
2284 gdb_assert (len == 4 || len == 8);
2285 memcpy (buf, VALUE_CONTENTS_ALL (arg), len);
2288 /* We always write the argument word on the stack. */
2290 write_memory (sp, buf, len);
2292 /* If this argument occupies one of the first 6 words, write it
2293 into the appropriate register too. */
2297 int regnum = SPARC_O0_REGNUM + (size / 4);
2299 regcache_cooked_write (regcache, regnum, buf);
2300 if (len == 8 && size < 20)
2301 regcache_cooked_write (regcache, regnum + 1, buf + 4);
2305 /* Reserve space for the struct/union return value pointer. */
2308 /* Stack should be doubleword aligned at this point. */
2309 gdb_assert (sp % 8 == 0);
2311 /* Return the adjusted stack pointer. */
2315 /* The SPARC passes the arguments on the stack; arguments smaller
2316 than an int are promoted to an int. The first 6 words worth of
2317 args are also passed in registers o0 - o5. */
2320 sparc32_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
2321 int struct_return, CORE_ADDR struct_addr)
2323 sp = sparc32_do_push_arguments (current_regcache, nargs, args, sp);
2325 /* FIXME: kettenis/20030525: We don't let this function set the
2326 struct/union return pointer just yet. */
2332 /* The space for the struct/union return value pointer has
2333 already been reserved. */
2334 store_unsigned_integer (buf, 4, struct_addr);
2344 /* Extract from REGCACHE a function return value of type TYPE and copy
2347 Note that REGCACHE specifies the register values for the frame of
2348 the calling function. This means that we need to fetch the value
2349 form %o0 and %o1, which correspond to %i0 and %i1 in the frame of
2350 the called function. */
2353 sparc32_extract_return_value (struct type *type, struct regcache *regcache,
2356 int len = TYPE_LENGTH (type);
2359 if (TYPE_CODE (type) == TYPE_CODE_FLT && SPARC_HAS_FPU)
2361 if (len == 4 || len == 8)
2363 regcache_cooked_read (regcache, SPARC_F0_REGNUM, buf);
2364 regcache_cooked_read (regcache, SPARC_F1_REGNUM, buf + 4);
2365 memcpy (valbuf, buf, len);
2369 internal_error (__FILE__, __LINE__, "\
2370 Cannot extract floating-point return value of %d bytes long.", len);
2375 regcache_cooked_read (regcache, SPARC_O0_REGNUM, buf);
2376 memcpy (valbuf, buf + 4 - len, len);
2380 regcache_cooked_read (regcache, SPARC_O0_REGNUM, buf);
2381 regcache_cooked_read (regcache, SPARC_O1_REGNUM, buf + 4);
2382 memcpy (valbuf, buf + 8 - len, len);
2385 internal_error (__FILE__, __LINE__,
2386 "Cannot extract return value of %d bytes long.", len);
2389 /* Write into REGBUF a function return value VALBUF of type TYPE. */
2392 sparc32_store_return_value (struct type *type, struct regcache *regcache,
2395 int len = TYPE_LENGTH (type);
2398 if (TYPE_CODE (type) == TYPE_CODE_FLT && SPARC_HAS_FPU)
2400 const char *buf = valbuf;
2404 regcache_cooked_write (regcache, SPARC_F0_REGNUM, buf);
2409 regcache_cooked_write (regcache, SPARC_F0_REGNUM, buf);
2410 regcache_cooked_write (regcache, SPARC_F1_REGNUM, buf + 4);
2414 internal_error (__FILE__, __LINE__, "\
2415 Cannot extract floating-point return value of %d bytes long.", len);
2418 /* Add leading zeros to the value. */
2419 memset (buf, 0, sizeof buf);
2423 memcpy (buf + 4 - len, valbuf, len);
2424 regcache_cooked_write (regcache, SPARC_O0_REGNUM, buf);
2428 memcpy (buf + 8 - len, valbuf, len);
2429 regcache_cooked_write (regcache, SPARC_O0_REGNUM, buf);
2430 regcache_cooked_write (regcache, SPARC_O1_REGNUM, buf);
2433 internal_error (__FILE__, __LINE__,
2434 "Cannot extract return value of %d bytes long.", len);
2437 /* Extract from REGCACHE the address in which a function should return
2438 its structure value. */
2441 sparc_extract_struct_value_address (struct regcache *regcache)
2445 regcache_cooked_read_unsigned (regcache, SPARC_O0_REGNUM, &addr);
2449 /* FIXME: kettenis/2003/05/24: Still used for sparc64. */
2452 sparc_store_return_value (struct type *type, char *valbuf)
2455 char buffer[MAX_REGISTER_SIZE];
2457 if (TYPE_CODE (type) == TYPE_CODE_FLT && SPARC_HAS_FPU)
2458 /* Floating-point values are returned in the register pair */
2459 /* formed by %f0 and %f1 (doubles are, anyway). */
2462 /* Other values are returned in register %o0. */
2465 /* Add leading zeros to the value. */
2466 if (TYPE_LENGTH (type) < REGISTER_RAW_SIZE (regno))
2468 memset (buffer, 0, REGISTER_RAW_SIZE (regno));
2469 memcpy (buffer + REGISTER_RAW_SIZE (regno) - TYPE_LENGTH (type), valbuf,
2470 TYPE_LENGTH (type));
2471 deprecated_write_register_gen (regno, buffer);
2474 deprecated_write_register_bytes (REGISTER_BYTE (regno), valbuf,
2475 TYPE_LENGTH (type));
2479 // OBSOLETE extern void
2480 // OBSOLETE sparclet_store_return_value (struct type *type, char *valbuf)
2482 // OBSOLETE /* Other values are returned in register %o0. */
2483 // OBSOLETE deprecated_write_register_bytes (REGISTER_BYTE (O0_REGNUM), valbuf,
2484 // OBSOLETE TYPE_LENGTH (type));
2489 #ifndef CALL_DUMMY_CALL_OFFSET
2490 #define CALL_DUMMY_CALL_OFFSET \
2491 (gdbarch_tdep (current_gdbarch)->call_dummy_call_offset)
2492 #endif /* CALL_DUMMY_CALL_OFFSET */
2494 /* Insert the function address into a call dummy instruction sequence
2497 For structs and unions, if the function was compiled with Sun cc,
2498 it expects 'unimp' after the call. But gcc doesn't use that
2499 (twisted) convention. So leave a nop there for gcc
2500 (DEPRECATED_FIX_CALL_DUMMY can assume it is operating on a pristine
2501 CALL_DUMMY, not one that has already been customized for a
2502 different function). */
2505 sparc_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun,
2506 struct type *value_type, int using_gcc)
2510 /* Store the relative adddress of the target function into the
2511 'call' instruction. */
2512 store_unsigned_integer (dummy + CALL_DUMMY_CALL_OFFSET, 4,
2514 | (((fun - (pc + CALL_DUMMY_CALL_OFFSET)) >> 2)
2517 /* If the called function returns an aggregate value, fill in the UNIMP
2518 instruction containing the size of the returned aggregate return value,
2519 which follows the call instruction.
2520 For details see the SPARC Architecture Manual Version 8, Appendix D.3.
2522 Adjust the call_dummy_breakpoint_offset for the bp_call_dummy breakpoint
2523 to the proper address in the call dummy, so that `finish' after a stop
2524 in a call dummy works.
2526 Tweeking current_gdbarch is not an optimal solution, but the call
2527 to sparc_fix_call_dummy is immediately followed by a call to
2528 call_function_by_hand, which is the only function where
2529 dummy_breakpoint_offset is actually used, if it is non-zero. */
2530 if (TYPE_CODE (value_type) == TYPE_CODE_STRUCT
2531 || TYPE_CODE (value_type) == TYPE_CODE_UNION)
2533 store_unsigned_integer (dummy + CALL_DUMMY_CALL_OFFSET + 8, 4,
2534 TYPE_LENGTH (value_type) & 0x1fff);
2535 set_gdbarch_deprecated_call_dummy_breakpoint_offset (current_gdbarch, 0x30);
2538 set_gdbarch_deprecated_call_dummy_breakpoint_offset (current_gdbarch, 0x2c);
2540 if (!(GDB_TARGET_IS_SPARC64))
2542 /* If this is not a simulator target, change the first four
2543 instructions of the call dummy to NOPs. Those instructions
2544 include a 'save' instruction and are designed to work around
2545 problems with register window flushing in the simulator. */
2547 if (strcmp (target_shortname, "sim") != 0)
2549 for (i = 0; i < 4; i++)
2550 store_unsigned_integer (dummy + (i * 4), 4, 0x01000000);
2555 // OBSOLETE /* If this is a bi-endian target, GDB has written the call dummy
2556 // OBSOLETE in little-endian order. We must byte-swap it back to big-endian. */
2557 // OBSOLETE if (bi_endian)
2559 // OBSOLETE for (i = 0; i < CALL_DUMMY_LENGTH; i += 4)
2561 // OBSOLETE char tmp = dummy[i];
2562 // OBSOLETE dummy[i] = dummy[i + 3];
2563 // OBSOLETE dummy[i + 3] = tmp;
2564 // OBSOLETE tmp = dummy[i + 1];
2565 // OBSOLETE dummy[i + 1] = dummy[i + 2];
2566 // OBSOLETE dummy[i + 2] = tmp;
2574 // OBSOLETE /* Set target byte order based on machine type. */
2576 // OBSOLETE static int
2577 // OBSOLETE sparc_target_architecture_hook (const bfd_arch_info_type *ap)
2579 // OBSOLETE int i, j;
2581 // OBSOLETE if (ap->mach == bfd_mach_sparc_sparclite_le)
2583 // OBSOLETE target_byte_order = BFD_ENDIAN_LITTLE;
2584 // OBSOLETE bi_endian = 1;
2587 // OBSOLETE bi_endian = 0;
2588 // OBSOLETE return 1;
2593 * Module "constructor" function.
2596 static struct gdbarch * sparc_gdbarch_init (struct gdbarch_info info,
2597 struct gdbarch_list *arches);
2598 static void sparc_dump_tdep (struct gdbarch *, struct ui_file *);
2601 _initialize_sparc_tdep (void)
2603 /* Hook us into the gdbarch mechanism. */
2604 gdbarch_register (bfd_arch_sparc, sparc_gdbarch_init, sparc_dump_tdep);
2606 deprecated_tm_print_insn = gdb_print_insn_sparc;
2607 deprecated_tm_print_insn_info.mach = TM_PRINT_INSN_MACH; /* Selects sparc/sparclite */
2608 /* OBSOLETE target_architecture_hook = sparc_target_architecture_hook; */
2611 /* Compensate for stack bias. Note that we currently don't handle
2612 mixed 32/64 bit code. */
2615 sparc64_read_sp (void)
2617 CORE_ADDR sp = read_register (SP_REGNUM);
2625 sparc64_read_fp (void)
2627 CORE_ADDR fp = read_register (DEPRECATED_FP_REGNUM);
2635 sparc64_write_sp (CORE_ADDR val)
2637 CORE_ADDR oldsp = read_register (SP_REGNUM);
2639 write_register (SP_REGNUM, val - 2047);
2641 write_register (SP_REGNUM, val);
2644 /* The SPARC 64 ABI passes floating-point arguments in FP0 to FP31,
2645 and all other arguments in O0 to O5. They are also copied onto
2646 the stack in the correct places. Apparently (empirically),
2647 structs of less than 16 bytes are passed member-by-member in
2648 separate registers, but I am unable to figure out the algorithm.
2649 Some members go in floating point regs, but I don't know which.
2651 FIXME: Handle small structs (less than 16 bytes containing floats).
2653 The counting regimen for using both integer and FP registers
2654 for argument passing is rather odd -- a single counter is used
2655 for both; this means that if the arguments alternate between
2656 int and float, we will waste every other register of both types. */
2659 sparc64_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
2660 int struct_return, CORE_ADDR struct_retaddr)
2662 int i, j, register_counter = 0;
2664 struct type *sparc_intreg_type =
2665 TYPE_LENGTH (builtin_type_long) == SPARC_INTREG_SIZE ?
2666 builtin_type_long : builtin_type_long_long;
2668 sp = (sp & ~(((unsigned long) SPARC_INTREG_SIZE) - 1UL));
2670 /* Figure out how much space we'll need. */
2671 for (i = nargs - 1; i >= 0; i--)
2673 int len = TYPE_LENGTH (check_typedef (VALUE_TYPE (args[i])));
2674 struct value *copyarg = args[i];
2677 if (copylen < SPARC_INTREG_SIZE)
2679 copyarg = value_cast (sparc_intreg_type, copyarg);
2680 copylen = SPARC_INTREG_SIZE;
2689 /* if STRUCT_RETURN, then first argument is the struct return location. */
2691 write_register (O0_REGNUM + register_counter++, struct_retaddr);
2693 /* Now write the arguments onto the stack, while writing FP
2694 arguments into the FP registers, and other arguments into the
2695 first six 'O' registers. */
2697 for (i = 0; i < nargs; i++)
2699 int len = TYPE_LENGTH (check_typedef (VALUE_TYPE (args[i])));
2700 struct value *copyarg = args[i];
2701 enum type_code typecode = TYPE_CODE (VALUE_TYPE (args[i]));
2704 if (typecode == TYPE_CODE_INT ||
2705 typecode == TYPE_CODE_BOOL ||
2706 typecode == TYPE_CODE_CHAR ||
2707 typecode == TYPE_CODE_RANGE ||
2708 typecode == TYPE_CODE_ENUM)
2709 if (len < SPARC_INTREG_SIZE)
2711 /* Small ints will all take up the size of one intreg on
2713 copyarg = value_cast (sparc_intreg_type, copyarg);
2714 copylen = SPARC_INTREG_SIZE;
2717 write_memory (tempsp, VALUE_CONTENTS (copyarg), copylen);
2720 /* Corner case: Structs consisting of a single float member are floats.
2721 * FIXME! I don't know about structs containing multiple floats!
2722 * Structs containing mixed floats and ints are even more weird.
2727 /* Separate float args from all other args. */
2728 if (typecode == TYPE_CODE_FLT && SPARC_HAS_FPU)
2730 if (register_counter < 16)
2732 /* This arg gets copied into a FP register. */
2736 case 4: /* Single-precision (float) */
2737 fpreg = FP0_REGNUM + 2 * register_counter + 1;
2738 register_counter += 1;
2740 case 8: /* Double-precision (double) */
2741 fpreg = FP0_REGNUM + 2 * register_counter;
2742 register_counter += 1;
2744 case 16: /* Quad-precision (long double) */
2745 fpreg = FP0_REGNUM + 2 * register_counter;
2746 register_counter += 2;
2749 internal_error (__FILE__, __LINE__, "bad switch");
2751 deprecated_write_register_bytes (REGISTER_BYTE (fpreg),
2752 VALUE_CONTENTS (args[i]),
2756 else /* all other args go into the first six 'o' registers */
2759 j < len && register_counter < 6;
2760 j += SPARC_INTREG_SIZE)
2762 int oreg = O0_REGNUM + register_counter;
2764 deprecated_write_register_gen (oreg, VALUE_CONTENTS (copyarg) + j);
2765 register_counter += 1;
2772 /* Values <= 32 bytes are returned in o0-o3 (floating-point values are
2773 returned in f0-f3). */
2776 sp64_extract_return_value (struct type *type, char *regbuf, char *valbuf,
2779 int typelen = TYPE_LENGTH (type);
2780 int regsize = REGISTER_RAW_SIZE (O0_REGNUM);
2782 if (TYPE_CODE (type) == TYPE_CODE_FLT && SPARC_HAS_FPU)
2784 memcpy (valbuf, ®buf[REGISTER_BYTE (FP0_REGNUM)], typelen);
2788 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
2789 || (TYPE_LENGTH (type) > 32))
2792 ®buf[O0_REGNUM * regsize +
2793 (typelen >= regsize ? 0 : regsize - typelen)],
2799 char *o0 = ®buf[O0_REGNUM * regsize];
2800 char *f0 = ®buf[FP0_REGNUM * regsize];
2803 for (x = 0; x < TYPE_NFIELDS (type); x++)
2805 struct field *f = &TYPE_FIELDS (type)[x];
2806 /* FIXME: We may need to handle static fields here. */
2807 int whichreg = (f->loc.bitpos + bitoffset) / 32;
2808 int remainder = ((f->loc.bitpos + bitoffset) % 32) / 8;
2809 int where = (f->loc.bitpos + bitoffset) / 8;
2810 int size = TYPE_LENGTH (f->type);
2811 int typecode = TYPE_CODE (f->type);
2813 if (typecode == TYPE_CODE_STRUCT)
2815 sp64_extract_return_value (f->type,
2818 bitoffset + f->loc.bitpos);
2820 else if (typecode == TYPE_CODE_FLT && SPARC_HAS_FPU)
2822 memcpy (valbuf + where, &f0[whichreg * 4] + remainder, size);
2826 memcpy (valbuf + where, &o0[whichreg * 4] + remainder, size);
2833 sparc64_extract_return_value (struct type *type, char *regbuf, char *valbuf)
2835 sp64_extract_return_value (type, regbuf, valbuf, 0);
2839 // OBSOLETE extern void
2840 // OBSOLETE sparclet_extract_return_value (struct type *type,
2841 // OBSOLETE char *regbuf,
2842 // OBSOLETE char *valbuf)
2844 // OBSOLETE regbuf += REGISTER_RAW_SIZE (O0_REGNUM) * 8;
2845 // OBSOLETE if (TYPE_LENGTH (type) < REGISTER_RAW_SIZE (O0_REGNUM))
2846 // OBSOLETE regbuf += REGISTER_RAW_SIZE (O0_REGNUM) - TYPE_LENGTH (type);
2848 // OBSOLETE memcpy ((void *) valbuf, regbuf, TYPE_LENGTH (type));
2853 sparc32_stack_align (CORE_ADDR addr)
2855 return ((addr + 7) & -8);
2859 sparc64_stack_align (CORE_ADDR addr)
2861 return ((addr + 15) & -16);
2865 sparc_print_extra_frame_info (struct frame_info *fi)
2867 if (fi && get_frame_extra_info (fi) && get_frame_extra_info (fi)->flat)
2868 printf_filtered (" flat, pc saved at 0x%s, fp saved at 0x%s\n",
2869 paddr_nz (get_frame_extra_info (fi)->pc_addr),
2870 paddr_nz (get_frame_extra_info (fi)->fp_addr));
2873 /* MULTI_ARCH support */
2876 sparc32_register_name (int regno)
2878 static char *register_names[] =
2879 { "g0", "g1", "g2", "g3", "g4", "g5", "g6", "g7",
2880 "o0", "o1", "o2", "o3", "o4", "o5", "sp", "o7",
2881 "l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7",
2882 "i0", "i1", "i2", "i3", "i4", "i5", "fp", "i7",
2884 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
2885 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
2886 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
2887 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
2889 "y", "psr", "wim", "tbr", "pc", "npc", "fpsr", "cpsr"
2893 regno >= (sizeof (register_names) / sizeof (register_names[0])))
2896 return register_names[regno];
2900 sparc64_register_name (int regno)
2902 static char *register_names[] =
2903 { "g0", "g1", "g2", "g3", "g4", "g5", "g6", "g7",
2904 "o0", "o1", "o2", "o3", "o4", "o5", "sp", "o7",
2905 "l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7",
2906 "i0", "i1", "i2", "i3", "i4", "i5", "fp", "i7",
2908 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
2909 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
2910 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
2911 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
2912 "f32", "f34", "f36", "f38", "f40", "f42", "f44", "f46",
2913 "f48", "f50", "f52", "f54", "f56", "f58", "f60", "f62",
2915 "pc", "npc", "ccr", "fsr", "fprs", "y", "asi", "ver",
2916 "tick", "pil", "pstate", "tstate", "tba", "tl", "tt", "tpc",
2917 "tnpc", "wstate", "cwp", "cansave", "canrestore", "cleanwin", "otherwin",
2918 "asr16", "asr17", "asr18", "asr19", "asr20", "asr21", "asr22", "asr23",
2919 "asr24", "asr25", "asr26", "asr27", "asr28", "asr29", "asr30", "asr31",
2920 /* These are here at the end to simplify removing them if we have to. */
2921 "icc", "xcc", "fcc0", "fcc1", "fcc2", "fcc3"
2925 regno >= (sizeof (register_names) / sizeof (register_names[0])))
2928 return register_names[regno];
2932 // OBSOLETE static const char *
2933 // OBSOLETE sparclite_register_name (int regno)
2935 // OBSOLETE static char *register_names[] =
2936 // OBSOLETE { "g0", "g1", "g2", "g3", "g4", "g5", "g6", "g7",
2937 // OBSOLETE "o0", "o1", "o2", "o3", "o4", "o5", "sp", "o7",
2938 // OBSOLETE "l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7",
2939 // OBSOLETE "i0", "i1", "i2", "i3", "i4", "i5", "fp", "i7",
2941 // OBSOLETE "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
2942 // OBSOLETE "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
2943 // OBSOLETE "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
2944 // OBSOLETE "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
2946 // OBSOLETE "y", "psr", "wim", "tbr", "pc", "npc", "fpsr", "cpsr",
2947 // OBSOLETE "dia1", "dia2", "dda1", "dda2", "ddv1", "ddv2", "dcr", "dsr"
2950 // OBSOLETE if (regno < 0 ||
2951 // OBSOLETE regno >= (sizeof (register_names) / sizeof (register_names[0])))
2952 // OBSOLETE return NULL;
2954 // OBSOLETE return register_names[regno];
2959 // OBSOLETE static const char *
2960 // OBSOLETE sparclet_register_name (int regno)
2962 // OBSOLETE static char *register_names[] =
2963 // OBSOLETE { "g0", "g1", "g2", "g3", "g4", "g5", "g6", "g7",
2964 // OBSOLETE "o0", "o1", "o2", "o3", "o4", "o5", "sp", "o7",
2965 // OBSOLETE "l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7",
2966 // OBSOLETE "i0", "i1", "i2", "i3", "i4", "i5", "fp", "i7",
2968 // OBSOLETE "", "", "", "", "", "", "", "", /* no floating point registers */
2969 // OBSOLETE "", "", "", "", "", "", "", "",
2970 // OBSOLETE "", "", "", "", "", "", "", "",
2971 // OBSOLETE "", "", "", "", "", "", "", "",
2973 // OBSOLETE "y", "psr", "wim", "tbr", "pc", "npc", "", "", /* no FPSR or CPSR */
2974 // OBSOLETE "ccsr", "ccpr", "cccrcr", "ccor", "ccobr", "ccibr", "ccir", "",
2976 // OBSOLETE /* ASR15 ASR19 (don't display them) */
2977 // OBSOLETE "asr1", "", "asr17", "asr18", "", "asr20", "asr21", "asr22"
2978 // OBSOLETE /* None of the rest get displayed */
2980 // OBSOLETE "awr0", "awr1", "awr2", "awr3", "awr4", "awr5", "awr6", "awr7",
2981 // OBSOLETE "awr8", "awr9", "awr10", "awr11", "awr12", "awr13", "awr14", "awr15",
2982 // OBSOLETE "awr16", "awr17", "awr18", "awr19", "awr20", "awr21", "awr22", "awr23",
2983 // OBSOLETE "awr24", "awr25", "awr26", "awr27", "awr28", "awr29", "awr30", "awr31",
2985 // OBSOLETE #endif /* 0 */
2988 // OBSOLETE if (regno < 0 ||
2989 // OBSOLETE regno >= (sizeof (register_names) / sizeof (register_names[0])))
2990 // OBSOLETE return NULL;
2992 // OBSOLETE return register_names[regno];
2997 sparc_push_return_address (CORE_ADDR pc_unused, CORE_ADDR sp)
2999 if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT)
3001 /* The return PC of the dummy_frame is the former 'current' PC
3002 (where we were before we made the target function call).
3003 This is saved in %i7 by push_dummy_frame.
3005 We will save the 'call dummy location' (ie. the address
3006 to which the target function will return) in %o7.
3007 This address will actually be the program's entry point.
3008 There will be a special call_dummy breakpoint there. */
3010 write_register (O7_REGNUM,
3011 CALL_DUMMY_ADDRESS () - 8);
3017 /* Should call_function allocate stack space for a struct return? */
3020 sparc64_use_struct_convention (int gcc_p, struct type *type)
3022 return (TYPE_LENGTH (type) > 32);
3025 /* Store the address of the place in which to copy the structure the
3026 subroutine will return. This is called from call_function_by_hand.
3027 The ultimate mystery is, tho, what is the value "16"?
3029 MVS: That's the offset from where the sp is now, to where the
3030 subroutine is gonna expect to find the struct return address. */
3033 sparc32_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
3038 val = alloca (SPARC_INTREG_SIZE);
3039 store_unsigned_integer (val, SPARC_INTREG_SIZE, addr);
3040 write_memory (sp + (16 * SPARC_INTREG_SIZE), val, SPARC_INTREG_SIZE);
3042 if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT)
3044 /* Now adjust the value of the link register, which was previously
3045 stored by push_return_address. Functions that return structs are
3046 peculiar in that they return to link register + 12, rather than
3047 link register + 8. */
3049 o7 = read_register (O7_REGNUM);
3050 write_register (O7_REGNUM, o7 - 4);
3055 sparc64_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
3057 /* FIXME: V9 uses %o0 for this. */
3058 /* FIXME MVS: Only for small enough structs!!! */
3060 target_write_memory (sp + (16 * SPARC_INTREG_SIZE),
3061 (char *) &addr, SPARC_INTREG_SIZE);
3063 if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT)
3065 /* Now adjust the value of the link register, which was previously
3066 stored by push_return_address. Functions that return structs are
3067 peculiar in that they return to link register + 12, rather than
3068 link register + 8. */
3070 write_register (O7_REGNUM, read_register (O7_REGNUM) - 4);
3075 /* Default target data type for register REGNO. */
3077 static struct type *
3078 sparc32_register_virtual_type (int regno)
3080 if (regno == PC_REGNUM ||
3081 regno == DEPRECATED_FP_REGNUM ||
3083 return builtin_type_unsigned_int;
3085 return builtin_type_int;
3087 return builtin_type_float;
3088 return builtin_type_int;
3091 static struct type *
3092 sparc64_register_virtual_type (int regno)
3094 if (regno == PC_REGNUM ||
3095 regno == DEPRECATED_FP_REGNUM ||
3097 return builtin_type_unsigned_long_long;
3099 return builtin_type_long_long;
3101 return builtin_type_float;
3103 return builtin_type_double;
3104 return builtin_type_long_long;
3107 /* Number of bytes of storage in the actual machine representation for
3111 sparc32_register_size (int regno)
3117 sparc64_register_size (int regno)
3119 return (regno < 32 ? 8 : regno < 64 ? 4 : 8);
3122 /* Index within the `registers' buffer of the first byte of the space
3123 for register REGNO. */
3126 sparc32_register_byte (int regno)
3132 sparc64_register_byte (int regno)
3136 else if (regno < 64)
3137 return 32 * 8 + (regno - 32) * 4;
3138 else if (regno < 80)
3139 return 32 * 8 + 32 * 4 + (regno - 64) * 8;
3141 return 64 * 8 + (regno - 80) * 8;
3144 /* Immediately after a function call, return the saved pc.
3145 Can't go through the frames for this because on some machines
3146 the new frame is not set up until the new function executes
3147 some instructions. */
3150 sparc_saved_pc_after_call (struct frame_info *fi)
3152 return sparc_pc_adjust (read_register (RP_REGNUM));
3155 /* Init saved regs: nothing to do, just a place-holder function. */
3158 sparc_frame_init_saved_regs (struct frame_info *fi_ignored)
3162 /* gdbarch fix call dummy:
3163 All this function does is rearrange the arguments before calling
3164 sparc_fix_call_dummy (which does the real work). */
3167 sparc_gdbarch_fix_call_dummy (char *dummy,
3171 struct value **args,
3175 if (CALL_DUMMY_LOCATION == ON_STACK)
3176 sparc_fix_call_dummy (dummy, pc, fun, type, gcc_p);
3179 /* CALL_DUMMY_ADDRESS: fetch the breakpoint address for a call dummy. */
3182 sparc_call_dummy_address (void)
3184 return (DEPRECATED_CALL_DUMMY_START_OFFSET) + DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET;
3187 /* Supply the Y register number to those that need it. */
3190 sparc_y_regnum (void)
3192 return gdbarch_tdep (current_gdbarch)->y_regnum;
3196 sparc_reg_struct_has_addr (int gcc_p, struct type *type)
3198 if (GDB_TARGET_IS_SPARC64)
3199 return (TYPE_LENGTH (type) > 32);
3201 return (gcc_p != 1);
3205 sparc_intreg_size (void)
3207 return SPARC_INTREG_SIZE;
3211 sparc_return_value_on_stack (struct type *type)
3213 if (TYPE_CODE (type) == TYPE_CODE_FLT &&
3214 TYPE_LENGTH (type) > 8)
3220 /* Get the ith function argument for the current function. */
3222 sparc_fetch_pointer_argument (struct frame_info *frame, int argi, struct type *type)
3225 frame_read_register (frame, O0_REGNUM + argi, &addr);
3230 * Gdbarch "constructor" function.
3233 #define SPARC32_CALL_DUMMY_ON_STACK
3235 #define SPARC_SP_REGNUM 14
3236 #define SPARC_FP_REGNUM 30
3237 #define SPARC_FP0_REGNUM 32
3238 #define SPARC32_NPC_REGNUM 69
3239 #define SPARC32_PC_REGNUM 68
3240 #define SPARC32_Y_REGNUM 64
3241 #define SPARC64_PC_REGNUM 80
3242 #define SPARC64_NPC_REGNUM 81
3243 #define SPARC64_Y_REGNUM 85
3245 static struct gdbarch *
3246 sparc_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
3248 struct gdbarch *gdbarch;
3249 struct gdbarch_tdep *tdep;
3251 static LONGEST call_dummy_32[] =
3252 { 0xbc100001, 0x9de38000, 0xbc100002, 0xbe100003,
3253 0xda03a058, 0xd803a054, 0xd603a050, 0xd403a04c,
3254 0xd203a048, 0x40000000, 0xd003a044, 0x01000000,
3255 0x91d02001, 0x01000000
3257 static LONGEST call_dummy_64[] =
3258 { 0x9de3bec0fd3fa7f7LL, 0xf93fa7eff53fa7e7LL,
3259 0xf13fa7dfed3fa7d7LL, 0xe93fa7cfe53fa7c7LL,
3260 0xe13fa7bfdd3fa7b7LL, 0xd93fa7afd53fa7a7LL,
3261 0xd13fa79fcd3fa797LL, 0xc93fa78fc53fa787LL,
3262 0xc13fa77fcc3fa777LL, 0xc83fa76fc43fa767LL,
3263 0xc03fa75ffc3fa757LL, 0xf83fa74ff43fa747LL,
3264 0xf03fa73f01000000LL, 0x0100000001000000LL,
3265 0x0100000091580000LL, 0xd027a72b93500000LL,
3266 0xd027a72791480000LL, 0xd027a72391400000LL,
3267 0xd027a71fda5ba8a7LL, 0xd85ba89fd65ba897LL,
3268 0xd45ba88fd25ba887LL, 0x9fc02000d05ba87fLL,
3269 0x0100000091d02001LL, 0x0100000001000000LL
3271 static LONGEST call_dummy_nil[] = {0};
3273 /* Try to determine the OS ABI of the object we are loading. */
3275 if (info.abfd != NULL
3276 && info.osabi == GDB_OSABI_UNKNOWN)
3278 /* If it's an ELF file, assume it's Solaris. */
3279 if (bfd_get_flavour (info.abfd) == bfd_target_elf_flavour)
3280 info.osabi = GDB_OSABI_SOLARIS;
3283 /* First see if there is already a gdbarch that can satisfy the request. */
3284 arches = gdbarch_list_lookup_by_info (arches, &info);
3286 return arches->gdbarch;
3288 /* None found: is the request for a sparc architecture? */
3289 if (info.bfd_arch_info->arch != bfd_arch_sparc)
3290 return NULL; /* No; then it's not for us. */
3292 /* Yes: create a new gdbarch for the specified machine type. */
3293 tdep = (struct gdbarch_tdep *) xmalloc (sizeof (struct gdbarch_tdep));
3294 gdbarch = gdbarch_alloc (&info, tdep);
3296 /* First set settings that are common for all sparc architectures. */
3297 set_gdbarch_believe_pcc_promotion (gdbarch, 1);
3298 set_gdbarch_breakpoint_from_pc (gdbarch, sparc_breakpoint_from_pc);
3299 set_gdbarch_decr_pc_after_break (gdbarch, 0);
3300 set_gdbarch_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
3301 set_gdbarch_extract_struct_value_address (gdbarch,
3302 sparc_extract_struct_value_address);
3303 set_gdbarch_deprecated_fix_call_dummy (gdbarch, sparc_gdbarch_fix_call_dummy);
3304 set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
3305 set_gdbarch_deprecated_fp_regnum (gdbarch, SPARC_FP_REGNUM);
3306 set_gdbarch_fp0_regnum (gdbarch, SPARC_FP0_REGNUM);
3307 set_gdbarch_deprecated_frame_chain (gdbarch, sparc_frame_chain);
3308 set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, sparc_frame_init_saved_regs);
3309 set_gdbarch_frame_num_args (gdbarch, frame_num_args_unknown);
3310 set_gdbarch_deprecated_frame_saved_pc (gdbarch, sparc_frame_saved_pc);
3311 set_gdbarch_frameless_function_invocation (gdbarch,
3312 frameless_look_for_prologue);
3313 set_gdbarch_deprecated_get_saved_register (gdbarch, sparc_get_saved_register);
3314 set_gdbarch_deprecated_init_extra_frame_info (gdbarch, sparc_init_extra_frame_info);
3315 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
3316 set_gdbarch_int_bit (gdbarch, 4 * TARGET_CHAR_BIT);
3317 set_gdbarch_long_double_bit (gdbarch, 16 * TARGET_CHAR_BIT);
3318 set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
3319 set_gdbarch_deprecated_max_register_raw_size (gdbarch, 8);
3320 set_gdbarch_deprecated_max_register_virtual_size (gdbarch, 8);
3321 set_gdbarch_deprecated_pop_frame (gdbarch, sparc_pop_frame);
3322 set_gdbarch_deprecated_push_return_address (gdbarch, sparc_push_return_address);
3323 set_gdbarch_deprecated_push_dummy_frame (gdbarch, sparc_push_dummy_frame);
3324 set_gdbarch_reg_struct_has_addr (gdbarch, sparc_reg_struct_has_addr);
3325 set_gdbarch_return_value_on_stack (gdbarch, sparc_return_value_on_stack);
3326 set_gdbarch_deprecated_saved_pc_after_call (gdbarch, sparc_saved_pc_after_call);
3327 set_gdbarch_prologue_frameless_p (gdbarch, sparc_prologue_frameless_p);
3328 set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
3329 set_gdbarch_skip_prologue (gdbarch, sparc_skip_prologue);
3330 set_gdbarch_sp_regnum (gdbarch, SPARC_SP_REGNUM);
3331 set_gdbarch_deprecated_use_generic_dummy_frames (gdbarch, 0);
3332 set_gdbarch_write_pc (gdbarch, generic_target_write_pc);
3334 /* Helper for function argument information. */
3335 set_gdbarch_fetch_pointer_argument (gdbarch, sparc_fetch_pointer_argument);
3338 * Settings that depend only on 32/64 bit word size
3341 switch (info.bfd_arch_info->mach)
3343 case bfd_mach_sparc:
3345 // OBSOLETE case bfd_mach_sparc_sparclet:
3346 // OBSOLETE case bfd_mach_sparc_sparclite:
3348 case bfd_mach_sparc_v8plus:
3349 case bfd_mach_sparc_v8plusa:
3351 // OBSOLETE case bfd_mach_sparc_sparclite_le:
3353 /* 32-bit machine types: */
3355 #ifdef SPARC32_CALL_DUMMY_ON_STACK
3356 set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_on_stack);
3357 set_gdbarch_call_dummy_address (gdbarch, sparc_call_dummy_address);
3358 set_gdbarch_deprecated_call_dummy_breakpoint_offset (gdbarch, 0x30);
3359 set_gdbarch_deprecated_call_dummy_length (gdbarch, 0x38);
3361 /* NOTE: cagney/2003-05-01: Using the just added push_dummy_code
3362 architecture method, it is now possible to implement a
3363 generic dummy frames based inferior function call that stores
3364 the breakpoint (and struct info) on the stack. Further, by
3365 treating a SIGSEG at a breakpoint as equivalent to a SIGTRAP
3366 it is even possible to make this work when the stack is
3369 NOTE: cagney/2002-04-26: Based from info posted by Peter
3370 Schauer around Oct '99. Briefly, due to aspects of the SPARC
3371 ABI, it isn't possible to use ON_STACK with a strictly
3374 Peter Schauer writes ...
3376 No, any call from GDB to a user function returning a
3377 struct/union will fail miserably. Try this:
3396 for (i = 0; i < 4; i++)
3402 Set a breakpoint at the gx = sret () statement, run to it and
3403 issue a `print sret()'. It will not succed with your
3404 approach, and I doubt that continuing the program will work
3407 For details of the ABI see the Sparc Architecture Manual. I
3408 have Version 8 (Prentice Hall ISBN 0-13-825001-4) and the
3409 calling conventions for functions returning aggregate values
3410 are explained in Appendix D.3. */
3412 set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
3413 set_gdbarch_deprecated_call_dummy_words (gdbarch, call_dummy_32);
3415 set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_at_entry_point);
3416 set_gdbarch_deprecated_call_dummy_words (gdbarch, call_dummy_nil);
3418 set_gdbarch_deprecated_call_dummy_stack_adjust (gdbarch, 68);
3419 set_gdbarch_frame_args_skip (gdbarch, 68);
3420 set_gdbarch_function_start_offset (gdbarch, 0);
3421 set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
3422 set_gdbarch_npc_regnum (gdbarch, SPARC32_NPC_REGNUM);
3423 set_gdbarch_pc_regnum (gdbarch, SPARC32_PC_REGNUM);
3424 set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
3425 set_gdbarch_deprecated_push_arguments (gdbarch, sparc32_push_arguments);
3426 set_gdbarch_read_sp (gdbarch, generic_target_read_sp);
3428 set_gdbarch_register_byte (gdbarch, sparc32_register_byte);
3429 set_gdbarch_register_raw_size (gdbarch, sparc32_register_size);
3430 set_gdbarch_deprecated_register_size (gdbarch, 4);
3431 set_gdbarch_register_virtual_size (gdbarch, sparc32_register_size);
3432 set_gdbarch_register_virtual_type (gdbarch,
3433 sparc32_register_virtual_type);
3434 #ifdef SPARC32_CALL_DUMMY_ON_STACK
3435 set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof (call_dummy_32));
3437 set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, 0);
3439 set_gdbarch_stack_align (gdbarch, sparc32_stack_align);
3440 set_gdbarch_deprecated_extra_stack_alignment_needed (gdbarch, 1);
3441 set_gdbarch_deprecated_store_struct_return (gdbarch, sparc32_store_struct_return);
3442 set_gdbarch_use_struct_convention (gdbarch,
3443 generic_use_struct_convention);
3444 set_gdbarch_deprecated_dummy_write_sp (gdbarch, generic_target_write_sp);
3445 tdep->y_regnum = SPARC32_Y_REGNUM;
3446 tdep->fp_max_regnum = SPARC_FP0_REGNUM + 32;
3447 tdep->intreg_size = 4;
3448 tdep->reg_save_offset = 0x60;
3449 tdep->call_dummy_call_offset = 0x24;
3452 case bfd_mach_sparc_v9:
3453 case bfd_mach_sparc_v9a:
3454 /* 64-bit machine types: */
3455 default: /* Any new machine type is likely to be 64-bit. */
3457 #ifdef SPARC64_CALL_DUMMY_ON_STACK
3458 set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_on_stack);
3459 set_gdbarch_call_dummy_address (gdbarch, sparc_call_dummy_address);
3460 set_gdbarch_deprecated_call_dummy_breakpoint_offset (gdbarch, 8 * 4);
3461 set_gdbarch_deprecated_call_dummy_length (gdbarch, 192);
3462 set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
3463 set_gdbarch_deprecated_call_dummy_start_offset (gdbarch, 148);
3464 set_gdbarch_deprecated_call_dummy_words (gdbarch, call_dummy_64);
3466 set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_at_entry_point);
3467 set_gdbarch_deprecated_call_dummy_words (gdbarch, call_dummy_nil);
3469 set_gdbarch_deprecated_call_dummy_stack_adjust (gdbarch, 128);
3470 set_gdbarch_frame_args_skip (gdbarch, 136);
3471 set_gdbarch_function_start_offset (gdbarch, 0);
3472 set_gdbarch_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
3473 set_gdbarch_npc_regnum (gdbarch, SPARC64_NPC_REGNUM);
3474 set_gdbarch_pc_regnum (gdbarch, SPARC64_PC_REGNUM);
3475 set_gdbarch_ptr_bit (gdbarch, 8 * TARGET_CHAR_BIT);
3476 set_gdbarch_deprecated_push_arguments (gdbarch, sparc64_push_arguments);
3477 /* NOTE different for at_entry */
3478 set_gdbarch_deprecated_target_read_fp (gdbarch, sparc64_read_fp);
3479 set_gdbarch_read_sp (gdbarch, sparc64_read_sp);
3480 /* Some of the registers aren't 64 bits, but it's a lot simpler just
3481 to assume they all are (since most of them are). */
3482 set_gdbarch_register_byte (gdbarch, sparc64_register_byte);
3483 set_gdbarch_register_raw_size (gdbarch, sparc64_register_size);
3484 set_gdbarch_deprecated_register_size (gdbarch, 8);
3485 set_gdbarch_register_virtual_size (gdbarch, sparc64_register_size);
3486 set_gdbarch_register_virtual_type (gdbarch,
3487 sparc64_register_virtual_type);
3488 #ifdef SPARC64_CALL_DUMMY_ON_STACK
3489 set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof (call_dummy_64));
3491 set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, 0);
3493 set_gdbarch_stack_align (gdbarch, sparc64_stack_align);
3494 set_gdbarch_deprecated_extra_stack_alignment_needed (gdbarch, 1);
3495 set_gdbarch_deprecated_store_struct_return (gdbarch, sparc64_store_struct_return);
3496 set_gdbarch_use_struct_convention (gdbarch,
3497 sparc64_use_struct_convention);
3498 set_gdbarch_deprecated_dummy_write_sp (gdbarch, sparc64_write_sp);
3499 tdep->y_regnum = SPARC64_Y_REGNUM;
3500 tdep->fp_max_regnum = SPARC_FP0_REGNUM + 48;
3501 tdep->intreg_size = 8;
3502 tdep->reg_save_offset = 0x90;
3503 tdep->call_dummy_call_offset = 148 + 4 * 5;
3508 * Settings that vary per-architecture:
3511 switch (info.bfd_arch_info->mach)
3513 case bfd_mach_sparc:
3514 set_gdbarch_extract_return_value (gdbarch, sparc32_extract_return_value);
3515 set_gdbarch_store_return_value (gdbarch, sparc32_store_return_value);
3516 set_gdbarch_num_regs (gdbarch, 72);
3517 set_gdbarch_deprecated_register_bytes (gdbarch, 32*4 + 32*4 + 8*4);
3518 set_gdbarch_register_name (gdbarch, sparc32_register_name);
3520 // OBSOLETE tdep->has_fpu = 1; /* (all but sparclet and sparclite) */
3522 tdep->fp_register_bytes = 32 * 4;
3523 tdep->print_insn_mach = bfd_mach_sparc;
3526 // OBSOLETE case bfd_mach_sparc_sparclet:
3527 // OBSOLETE set_gdbarch_deprecated_extract_return_value (gdbarch, sparclet_extract_return_value);
3528 // OBSOLETE set_gdbarch_num_regs (gdbarch, 32 + 32 + 8 + 8 + 8);
3529 // OBSOLETE set_gdbarch_register_bytes (gdbarch, 32*4 + 32*4 + 8*4 + 8*4 + 8*4);
3530 // OBSOLETE set_gdbarch_register_name (gdbarch, sparclet_register_name);
3531 // OBSOLETE set_gdbarch_deprecated_store_return_value (gdbarch, sparclet_store_return_value);
3532 // OBSOLETE tdep->has_fpu = 0; /* (all but sparclet and sparclite) */
3533 // OBSOLETE tdep->fp_register_bytes = 0;
3534 // OBSOLETE tdep->print_insn_mach = bfd_mach_sparc_sparclet;
3538 // OBSOLETE case bfd_mach_sparc_sparclite:
3539 // OBSOLETE set_gdbarch_deprecated_extract_return_value (gdbarch, sparc32_extract_return_value);
3540 // OBSOLETE set_gdbarch_num_regs (gdbarch, 80);
3541 // OBSOLETE set_gdbarch_register_bytes (gdbarch, 32*4 + 32*4 + 8*4 + 8*4);
3542 // OBSOLETE set_gdbarch_register_name (gdbarch, sparclite_register_name);
3543 // OBSOLETE set_gdbarch_deprecated_store_return_value (gdbarch, sparc_store_return_value);
3544 // OBSOLETE tdep->has_fpu = 0; /* (all but sparclet and sparclite) */
3545 // OBSOLETE tdep->fp_register_bytes = 0;
3546 // OBSOLETE tdep->print_insn_mach = bfd_mach_sparc_sparclite;
3549 case bfd_mach_sparc_v8plus:
3550 set_gdbarch_extract_return_value (gdbarch, sparc32_extract_return_value);
3551 set_gdbarch_store_return_value (gdbarch, sparc32_store_return_value);
3552 set_gdbarch_num_regs (gdbarch, 72);
3553 set_gdbarch_deprecated_register_bytes (gdbarch, 32*4 + 32*4 + 8*4);
3554 set_gdbarch_register_name (gdbarch, sparc32_register_name);
3555 tdep->print_insn_mach = bfd_mach_sparc;
3556 tdep->fp_register_bytes = 32 * 4;
3558 // OBSOLETE tdep->has_fpu = 1; /* (all but sparclet and sparclite) */
3561 case bfd_mach_sparc_v8plusa:
3562 set_gdbarch_extract_return_value (gdbarch, sparc32_extract_return_value);
3563 set_gdbarch_store_return_value (gdbarch, sparc32_store_return_value);
3564 set_gdbarch_num_regs (gdbarch, 72);
3565 set_gdbarch_deprecated_register_bytes (gdbarch, 32*4 + 32*4 + 8*4);
3566 set_gdbarch_register_name (gdbarch, sparc32_register_name);
3568 // OBSOLETE tdep->has_fpu = 1; /* (all but sparclet and sparclite) */
3570 tdep->fp_register_bytes = 32 * 4;
3571 tdep->print_insn_mach = bfd_mach_sparc;
3574 // OBSOLETE case bfd_mach_sparc_sparclite_le:
3575 // OBSOLETE set_gdbarch_deprecated_extract_return_value (gdbarch, sparc32_extract_return_value);
3576 // OBSOLETE set_gdbarch_num_regs (gdbarch, 80);
3577 // OBSOLETE set_gdbarch_register_bytes (gdbarch, 32*4 + 32*4 + 8*4 + 8*4);
3578 // OBSOLETE set_gdbarch_register_name (gdbarch, sparclite_register_name);
3579 // OBSOLETE set_gdbarch_deprecated_store_return_value (gdbarch, sparc_store_return_value);
3580 // OBSOLETE tdep->has_fpu = 0; /* (all but sparclet and sparclite) */
3581 // OBSOLETE tdep->fp_register_bytes = 0;
3582 // OBSOLETE tdep->print_insn_mach = bfd_mach_sparc_sparclite;
3585 case bfd_mach_sparc_v9:
3586 set_gdbarch_deprecated_extract_return_value (gdbarch, sparc64_extract_return_value);
3587 set_gdbarch_num_regs (gdbarch, 125);
3588 set_gdbarch_deprecated_register_bytes (gdbarch, 32*8 + 32*8 + 45*8);
3589 set_gdbarch_register_name (gdbarch, sparc64_register_name);
3590 set_gdbarch_deprecated_store_return_value (gdbarch, sparc_store_return_value);
3592 // OBSOLETE tdep->has_fpu = 1; /* (all but sparclet and sparclite) */
3594 tdep->fp_register_bytes = 64 * 4;
3595 tdep->print_insn_mach = bfd_mach_sparc_v9a;
3597 case bfd_mach_sparc_v9a:
3598 set_gdbarch_deprecated_extract_return_value (gdbarch, sparc64_extract_return_value);
3599 set_gdbarch_num_regs (gdbarch, 125);
3600 set_gdbarch_deprecated_register_bytes (gdbarch, 32*8 + 32*8 + 45*8);
3601 set_gdbarch_register_name (gdbarch, sparc64_register_name);
3602 set_gdbarch_deprecated_store_return_value (gdbarch, sparc_store_return_value);
3604 // OBSOLETE tdep->has_fpu = 1; /* (all but sparclet and sparclite) */
3606 tdep->fp_register_bytes = 64 * 4;
3607 tdep->print_insn_mach = bfd_mach_sparc_v9a;
3611 /* Hook in OS ABI-specific overrides, if they have been registered. */
3612 gdbarch_init_osabi (info, gdbarch);
3618 sparc_dump_tdep (struct gdbarch *current_gdbarch, struct ui_file *file)
3620 struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
3626 // OBSOLETE fprintf_unfiltered (file, "sparc_dump_tdep: has_fpu = %d\n",
3627 // OBSOLETE tdep->has_fpu);
3629 fprintf_unfiltered (file, "sparc_dump_tdep: fp_register_bytes = %d\n",
3630 tdep->fp_register_bytes);
3631 fprintf_unfiltered (file, "sparc_dump_tdep: y_regnum = %d\n",
3633 fprintf_unfiltered (file, "sparc_dump_tdep: fp_max_regnum = %d\n",
3634 tdep->fp_max_regnum);
3635 fprintf_unfiltered (file, "sparc_dump_tdep: intreg_size = %d\n",
3637 fprintf_unfiltered (file, "sparc_dump_tdep: reg_save_offset = %d\n",
3638 tdep->reg_save_offset);
3639 fprintf_unfiltered (file, "sparc_dump_tdep: call_dummy_call_offset = %d\n",
3640 tdep->call_dummy_call_offset);
3641 fprintf_unfiltered (file, "sparc_dump_tdep: print_insn_match = %d\n",
3642 tdep->print_insn_mach);