]> Git Repo - binutils.git/blob - gdb/sparc-tdep.c
0a901b1e2d77bd9dc5fa4bc555f2b62783dacbad
[binutils.git] / gdb / sparc-tdep.c
1 /* Target-dependent code for the SPARC for GDB, the GNU debugger.
2    Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997
3    Free Software Foundation, Inc.
4
5    This file is part of GDB.
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 2 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with this program; if not, write to the Free Software
19    Foundation, Inc., 59 Temple Place - Suite 330,
20    Boston, MA 02111-1307, USA.  */
21
22 /* ??? Support for calling functions from gdb in sparc64 is unfinished.  */
23
24 #include "defs.h"
25 #include "arch-utils.h"
26 #include "frame.h"
27 #include "inferior.h"
28 #include "obstack.h"
29 #include "target.h"
30 #include "value.h"
31 #include "bfd.h"
32 #include "gdb_string.h"
33
34 #ifdef  USE_PROC_FS
35 #include <sys/procfs.h>
36 #endif
37
38 #include "gdbcore.h"
39
40 #include "symfile.h"    /* for 'entry_point_address' */
41
42 /* Prototypes for supply_gregset etc. */
43 #include "gregset.h"
44
45 /*
46  * Some local macros that have multi-arch and non-multi-arch versions:
47  */
48
49 #if (GDB_MULTI_ARCH > 0)
50
51 /* Does the target have Floating Point registers?  */
52 #define SPARC_HAS_FPU     (gdbarch_tdep (current_gdbarch)->has_fpu)
53 /* Number of bytes devoted to Floating Point registers: */
54 #define FP_REGISTER_BYTES (gdbarch_tdep (current_gdbarch)->fp_register_bytes)
55 /* Highest numbered Floating Point register.  */
56 #define FP_MAX_REGNUM     (gdbarch_tdep (current_gdbarch)->fp_max_regnum)
57 /* Size of a general (integer) register: */
58 #define SPARC_INTREG_SIZE (gdbarch_tdep (current_gdbarch)->intreg_size)
59 /* Offset within the call dummy stack of the saved registers.  */
60 #define DUMMY_REG_SAVE_OFFSET (gdbarch_tdep (current_gdbarch)->reg_save_offset)
61
62 #else /* non-multi-arch */
63
64
65 /* Does the target have Floating Point registers?  */
66 #if defined(TARGET_SPARCLET) || defined(TARGET_SPARCLITE)
67 #define SPARC_HAS_FPU 0
68 #else
69 #define SPARC_HAS_FPU 1
70 #endif
71
72 /* Number of bytes devoted to Floating Point registers: */
73 #if (GDB_TARGET_IS_SPARC64)
74 #define FP_REGISTER_BYTES (64 * 4)
75 #else
76 #if (SPARC_HAS_FPU)
77 #define FP_REGISTER_BYTES (32 * 4)
78 #else
79 #define FP_REGISTER_BYTES 0
80 #endif
81 #endif
82
83 /* Highest numbered Floating Point register.  */
84 #if (GDB_TARGET_IS_SPARC64)
85 #define FP_MAX_REGNUM (FP0_REGNUM + 48)
86 #else
87 #define FP_MAX_REGNUM (FP0_REGNUM + 32)
88 #endif
89
90 /* Size of a general (integer) register: */
91 #define SPARC_INTREG_SIZE (REGISTER_RAW_SIZE (G0_REGNUM))
92
93 /* Offset within the call dummy stack of the saved registers.  */
94 #if (GDB_TARGET_IS_SPARC64)
95 #define DUMMY_REG_SAVE_OFFSET (128 + 16)
96 #else
97 #define DUMMY_REG_SAVE_OFFSET 0x60
98 #endif
99
100 #endif /* GDB_MULTI_ARCH */
101
102 struct gdbarch_tdep
103   {
104     int has_fpu;
105     int fp_register_bytes;
106     int y_regnum;
107     int fp_max_regnum;
108     int intreg_size;
109     int reg_save_offset;
110     int call_dummy_call_offset;
111     int print_insn_mach;
112   };
113
114 /* Now make GDB_TARGET_IS_SPARC64 a runtime test.  */
115 /* FIXME MVS: or try testing bfd_arch_info.arch and bfd_arch_info.mach ... 
116  * define GDB_TARGET_IS_SPARC64 \
117  *      (TARGET_ARCHITECTURE->arch == bfd_arch_sparc &&    \
118  *      (TARGET_ARCHITECTURE->mach == bfd_mach_sparc_v9 || \
119  *       TARGET_ARCHITECTURE->mach == bfd_mach_sparc_v9a))
120  */
121
122 /* From infrun.c */
123 extern int stop_after_trap;
124
125 /* We don't store all registers immediately when requested, since they
126    get sent over in large chunks anyway.  Instead, we accumulate most
127    of the changes and send them over once.  "deferred_stores" keeps
128    track of which sets of registers we have locally-changed copies of,
129    so we only need send the groups that have changed.  */
130
131 int deferred_stores = 0;    /* Accumulated stores we want to do eventually. */
132
133
134 /* Some machines, such as Fujitsu SPARClite 86x, have a bi-endian mode
135    where instructions are big-endian and data are little-endian.
136    This flag is set when we detect that the target is of this type. */
137
138 int bi_endian = 0;
139
140
141 /* Fetch a single instruction.  Even on bi-endian machines
142    such as sparc86x, instructions are always big-endian.  */
143
144 static unsigned long
145 fetch_instruction (pc)
146      CORE_ADDR pc;
147 {
148   unsigned long retval;
149   int i;
150   unsigned char buf[4];
151
152   read_memory (pc, buf, sizeof (buf));
153
154   /* Start at the most significant end of the integer, and work towards
155      the least significant.  */
156   retval = 0;
157   for (i = 0; i < sizeof (buf); ++i)
158     retval = (retval << 8) | buf[i];
159   return retval;
160 }
161
162
163 /* Branches with prediction are treated like their non-predicting cousins.  */
164 /* FIXME: What about floating point branches?  */
165
166 /* Macros to extract fields from sparc instructions.  */
167 #define X_OP(i) (((i) >> 30) & 0x3)
168 #define X_RD(i) (((i) >> 25) & 0x1f)
169 #define X_A(i) (((i) >> 29) & 1)
170 #define X_COND(i) (((i) >> 25) & 0xf)
171 #define X_OP2(i) (((i) >> 22) & 0x7)
172 #define X_IMM22(i) ((i) & 0x3fffff)
173 #define X_OP3(i) (((i) >> 19) & 0x3f)
174 #define X_RS1(i) (((i) >> 14) & 0x1f)
175 #define X_I(i) (((i) >> 13) & 1)
176 #define X_IMM13(i) ((i) & 0x1fff)
177 /* Sign extension macros.  */
178 #define X_SIMM13(i) ((X_IMM13 (i) ^ 0x1000) - 0x1000)
179 #define X_DISP22(i) ((X_IMM22 (i) ^ 0x200000) - 0x200000)
180 #define X_CC(i) (((i) >> 20) & 3)
181 #define X_P(i) (((i) >> 19) & 1)
182 #define X_DISP19(i) ((((i) & 0x7ffff) ^ 0x40000) - 0x40000)
183 #define X_RCOND(i) (((i) >> 25) & 7)
184 #define X_DISP16(i) ((((((i) >> 6) && 0xc000) | ((i) & 0x3fff)) ^ 0x8000) - 0x8000)
185 #define X_FCN(i) (((i) >> 25) & 31)
186
187 typedef enum
188 {
189   Error, not_branch, bicc, bicca, ba, baa, ticc, ta, done_retry
190 } branch_type;
191
192 /* Simulate single-step ptrace call for sun4.  Code written by Gary
193    Beihl ([email protected]).  */
194
195 /* npc4 and next_pc describe the situation at the time that the
196    step-breakpoint was set, not necessary the current value of NPC_REGNUM.  */
197 static CORE_ADDR next_pc, npc4, target;
198 static int brknpc4, brktrg;
199 typedef char binsn_quantum[BREAKPOINT_MAX];
200 static binsn_quantum break_mem[3];
201
202 static branch_type isbranch (long, CORE_ADDR, CORE_ADDR *);
203
204 /* single_step() is called just before we want to resume the inferior,
205    if we want to single-step it but there is no hardware or kernel single-step
206    support (as on all SPARCs).  We find all the possible targets of the
207    coming instruction and breakpoint them.
208
209    single_step is also called just after the inferior stops.  If we had
210    set up a simulated single-step, we undo our damage.  */
211
212 void
213 sparc_software_single_step (ignore, insert_breakpoints_p)
214      enum target_signal ignore; /* pid, but we don't need it */
215      int insert_breakpoints_p;
216 {
217   branch_type br;
218   CORE_ADDR pc;
219   long pc_instruction;
220
221   if (insert_breakpoints_p)
222     {
223       /* Always set breakpoint for NPC.  */
224       next_pc = read_register (NPC_REGNUM);
225       npc4 = next_pc + 4;       /* branch not taken */
226
227       target_insert_breakpoint (next_pc, break_mem[0]);
228       /* printf_unfiltered ("set break at %x\n",next_pc); */
229
230       pc = read_register (PC_REGNUM);
231       pc_instruction = fetch_instruction (pc);
232       br = isbranch (pc_instruction, pc, &target);
233       brknpc4 = brktrg = 0;
234
235       if (br == bicca)
236         {
237           /* Conditional annulled branch will either end up at
238              npc (if taken) or at npc+4 (if not taken).
239              Trap npc+4.  */
240           brknpc4 = 1;
241           target_insert_breakpoint (npc4, break_mem[1]);
242         }
243       else if (br == baa && target != next_pc)
244         {
245           /* Unconditional annulled branch will always end up at
246              the target.  */
247           brktrg = 1;
248           target_insert_breakpoint (target, break_mem[2]);
249         }
250       else if (GDB_TARGET_IS_SPARC64 && br == done_retry)
251         {
252           brktrg = 1;
253           target_insert_breakpoint (target, break_mem[2]);
254         }
255     }
256   else
257     {
258       /* Remove breakpoints */
259       target_remove_breakpoint (next_pc, break_mem[0]);
260
261       if (brknpc4)
262         target_remove_breakpoint (npc4, break_mem[1]);
263
264       if (brktrg)
265         target_remove_breakpoint (target, break_mem[2]);
266     }
267 }
268 \f
269 struct frame_extra_info 
270 {
271   CORE_ADDR bottom;
272   int in_prologue;
273   int flat;
274   /* Following fields only relevant for flat frames.  */
275   CORE_ADDR pc_addr;
276   CORE_ADDR fp_addr;
277   /* Add this to ->frame to get the value of the stack pointer at the 
278      time of the register saves.  */
279   int sp_offset;
280 };
281
282 /* Call this for each newly created frame.  For SPARC, we need to
283    calculate the bottom of the frame, and do some extra work if the
284    prologue has been generated via the -mflat option to GCC.  In
285    particular, we need to know where the previous fp and the pc have
286    been stashed, since their exact position within the frame may vary.  */
287
288 void
289 sparc_init_extra_frame_info (fromleaf, fi)
290      int fromleaf;
291      struct frame_info *fi;
292 {
293   char *name;
294   CORE_ADDR prologue_start, prologue_end;
295   int insn;
296
297   fi->extra_info = (struct frame_extra_info *)
298     frame_obstack_alloc (sizeof (struct frame_extra_info));
299   frame_saved_regs_zalloc (fi);
300
301   fi->extra_info->bottom =
302     (fi->next ?
303      (fi->frame == fi->next->frame ? fi->next->extra_info->bottom : 
304       fi->next->frame) : read_sp ());
305
306   /* If fi->next is NULL, then we already set ->frame by passing read_fp()
307      to create_new_frame.  */
308   if (fi->next)
309     {
310       char *buf;
311
312       buf = alloca (MAX_REGISTER_RAW_SIZE);
313
314       /* Compute ->frame as if not flat.  If it is flat, we'll change
315          it later.  */
316       if (fi->next->next != NULL
317           && (fi->next->next->signal_handler_caller
318               || frame_in_dummy (fi->next->next))
319           && frameless_look_for_prologue (fi->next))
320         {
321           /* A frameless function interrupted by a signal did not change
322              the frame pointer, fix up frame pointer accordingly.  */
323           fi->frame = FRAME_FP (fi->next);
324           fi->extra_info->bottom = fi->next->extra_info->bottom;
325         }
326       else
327         {
328           /* Should we adjust for stack bias here? */
329           get_saved_register (buf, 0, 0, fi, FP_REGNUM, 0);
330           fi->frame = extract_address (buf, REGISTER_RAW_SIZE (FP_REGNUM));
331
332           if (GDB_TARGET_IS_SPARC64 && (fi->frame & 1))
333             fi->frame += 2047;
334         }
335     }
336
337   /* Decide whether this is a function with a ``flat register window''
338      frame.  For such functions, the frame pointer is actually in %i7.  */
339   fi->extra_info->flat = 0;
340   fi->extra_info->in_prologue = 0;
341   if (find_pc_partial_function (fi->pc, &name, &prologue_start, &prologue_end))
342     {
343       /* See if the function starts with an add (which will be of a
344          negative number if a flat frame) to the sp.  FIXME: Does not
345          handle large frames which will need more than one instruction
346          to adjust the sp.  */
347       insn = fetch_instruction (prologue_start, 4);
348       if (X_OP (insn) == 2 && X_RD (insn) == 14 && X_OP3 (insn) == 0
349           && X_I (insn) && X_SIMM13 (insn) < 0)
350         {
351           int offset = X_SIMM13 (insn);
352
353           /* Then look for a save of %i7 into the frame.  */
354           insn = fetch_instruction (prologue_start + 4);
355           if (X_OP (insn) == 3
356               && X_RD (insn) == 31
357               && X_OP3 (insn) == 4
358               && X_RS1 (insn) == 14)
359             {
360               char *buf;
361               
362               buf = alloca (MAX_REGISTER_RAW_SIZE);
363
364               /* We definitely have a flat frame now.  */
365               fi->extra_info->flat = 1;
366
367               fi->extra_info->sp_offset = offset;
368
369               /* Overwrite the frame's address with the value in %i7.  */
370               get_saved_register (buf, 0, 0, fi, I7_REGNUM, 0);
371               fi->frame = extract_address (buf, REGISTER_RAW_SIZE (I7_REGNUM));
372
373               if (GDB_TARGET_IS_SPARC64 && (fi->frame & 1))
374                 fi->frame += 2047;
375
376               /* Record where the fp got saved.  */
377               fi->extra_info->fp_addr = 
378                 fi->frame + fi->extra_info->sp_offset + X_SIMM13 (insn);
379
380               /* Also try to collect where the pc got saved to.  */
381               fi->extra_info->pc_addr = 0;
382               insn = fetch_instruction (prologue_start + 12);
383               if (X_OP (insn) == 3
384                   && X_RD (insn) == 15
385                   && X_OP3 (insn) == 4
386                   && X_RS1 (insn) == 14)
387                 fi->extra_info->pc_addr = 
388                   fi->frame + fi->extra_info->sp_offset + X_SIMM13 (insn);
389             }
390         }
391       else
392         {
393           /* Check if the PC is in the function prologue before a SAVE
394              instruction has been executed yet.  If so, set the frame
395              to the current value of the stack pointer and set
396              the in_prologue flag.  */
397           CORE_ADDR addr;
398           struct symtab_and_line sal;
399
400           sal = find_pc_line (prologue_start, 0);
401           if (sal.line == 0)    /* no line info, use PC */
402             prologue_end = fi->pc;
403           else if (sal.end < prologue_end)
404             prologue_end = sal.end;
405           if (fi->pc < prologue_end)
406             {
407               for (addr = prologue_start; addr < fi->pc; addr += 4)
408                 {
409                   insn = read_memory_integer (addr, 4);
410                   if (X_OP (insn) == 2 && X_OP3 (insn) == 0x3c)
411                     break;      /* SAVE seen, stop searching */
412                 }
413               if (addr >= fi->pc)
414                 {
415                   fi->extra_info->in_prologue = 1;
416                   fi->frame = read_register (SP_REGNUM);
417                 }
418             }
419         }
420     }
421   if (fi->next && fi->frame == 0)
422     {
423       /* Kludge to cause init_prev_frame_info to destroy the new frame.  */
424       fi->frame = fi->next->frame;
425       fi->pc = fi->next->pc;
426     }
427 }
428
429 CORE_ADDR
430 sparc_frame_chain (frame)
431      struct frame_info *frame;
432 {
433   /* Value that will cause FRAME_CHAIN_VALID to not worry about the chain
434      value.  If it realy is zero, we detect it later in
435      sparc_init_prev_frame.  */
436   return (CORE_ADDR) 1;
437 }
438
439 CORE_ADDR
440 sparc_extract_struct_value_address (regbuf)
441      char *regbuf;
442 {
443   return extract_address (regbuf + REGISTER_BYTE (O0_REGNUM),
444                           REGISTER_RAW_SIZE (O0_REGNUM));
445 }
446
447 /* Find the pc saved in frame FRAME.  */
448
449 CORE_ADDR
450 sparc_frame_saved_pc (frame)
451      struct frame_info *frame;
452 {
453   char *buf;
454   CORE_ADDR addr;
455
456   buf = alloca (MAX_REGISTER_RAW_SIZE);
457   if (frame->signal_handler_caller)
458     {
459       /* This is the signal trampoline frame.
460          Get the saved PC from the sigcontext structure.  */
461
462 #ifndef SIGCONTEXT_PC_OFFSET
463 #define SIGCONTEXT_PC_OFFSET 12
464 #endif
465
466       CORE_ADDR sigcontext_addr;
467       char *scbuf;
468       int saved_pc_offset = SIGCONTEXT_PC_OFFSET;
469       char *name = NULL;
470
471       scbuf = alloca (TARGET_PTR_BIT / HOST_CHAR_BIT);
472
473       /* Solaris2 ucbsigvechandler passes a pointer to a sigcontext
474          as the third parameter.  The offset to the saved pc is 12.  */
475       find_pc_partial_function (frame->pc, &name,
476                                 (CORE_ADDR *) NULL, (CORE_ADDR *) NULL);
477       if (name && STREQ (name, "ucbsigvechandler"))
478         saved_pc_offset = 12;
479
480       /* The sigcontext address is contained in register O2.  */
481       get_saved_register (buf, (int *) NULL, (CORE_ADDR *) NULL,
482                           frame, O0_REGNUM + 2, (enum lval_type *) NULL);
483       sigcontext_addr = extract_address (buf, REGISTER_RAW_SIZE (O0_REGNUM + 2));
484
485       /* Don't cause a memory_error when accessing sigcontext in case the
486          stack layout has changed or the stack is corrupt.  */
487       target_read_memory (sigcontext_addr + saved_pc_offset,
488                           scbuf, sizeof (scbuf));
489       return extract_address (scbuf, sizeof (scbuf));
490     }
491   else if (frame->extra_info->in_prologue ||
492            (frame->next != NULL &&
493             (frame->next->signal_handler_caller ||
494              frame_in_dummy (frame->next)) &&
495             frameless_look_for_prologue (frame)))
496     {
497       /* A frameless function interrupted by a signal did not save
498          the PC, it is still in %o7.  */
499       get_saved_register (buf, (int *) NULL, (CORE_ADDR *) NULL,
500                           frame, O7_REGNUM, (enum lval_type *) NULL);
501       return PC_ADJUST (extract_address (buf, SPARC_INTREG_SIZE));
502     }
503   if (frame->extra_info->flat)
504     addr = frame->extra_info->pc_addr;
505   else
506     addr = frame->extra_info->bottom + FRAME_SAVED_I0 +
507       SPARC_INTREG_SIZE * (I7_REGNUM - I0_REGNUM);
508
509   if (addr == 0)
510     /* A flat frame leaf function might not save the PC anywhere,
511        just leave it in %o7.  */
512     return PC_ADJUST (read_register (O7_REGNUM));
513
514   read_memory (addr, buf, SPARC_INTREG_SIZE);
515   return PC_ADJUST (extract_address (buf, SPARC_INTREG_SIZE));
516 }
517
518 /* Since an individual frame in the frame cache is defined by two
519    arguments (a frame pointer and a stack pointer), we need two
520    arguments to get info for an arbitrary stack frame.  This routine
521    takes two arguments and makes the cached frames look as if these
522    two arguments defined a frame on the cache.  This allows the rest
523    of info frame to extract the important arguments without
524    difficulty.  */
525
526 struct frame_info *
527 setup_arbitrary_frame (argc, argv)
528      int argc;
529      CORE_ADDR *argv;
530 {
531   struct frame_info *frame;
532
533   if (argc != 2)
534     error ("Sparc frame specifications require two arguments: fp and sp");
535
536   frame = create_new_frame (argv[0], 0);
537
538   if (!frame)
539     internal_error ("create_new_frame returned invalid frame");
540
541   frame->extra_info->bottom = argv[1];
542   frame->pc = FRAME_SAVED_PC (frame);
543   return frame;
544 }
545
546 /* Given a pc value, skip it forward past the function prologue by
547    disassembling instructions that appear to be a prologue.
548
549    If FRAMELESS_P is set, we are only testing to see if the function
550    is frameless.  This allows a quicker answer.
551
552    This routine should be more specific in its actions; making sure
553    that it uses the same register in the initial prologue section.  */
554
555 static CORE_ADDR examine_prologue (CORE_ADDR, int, struct frame_info *,
556                                    CORE_ADDR *);
557
558 static CORE_ADDR
559 examine_prologue (start_pc, frameless_p, fi, saved_regs)
560      CORE_ADDR start_pc;
561      int frameless_p;
562      struct frame_info *fi;
563      CORE_ADDR *saved_regs;
564 {
565   int insn;
566   int dest = -1;
567   CORE_ADDR pc = start_pc;
568   int is_flat = 0;
569
570   insn = fetch_instruction (pc);
571
572   /* Recognize the `sethi' insn and record its destination.  */
573   if (X_OP (insn) == 0 && X_OP2 (insn) == 4)
574     {
575       dest = X_RD (insn);
576       pc += 4;
577       insn = fetch_instruction (pc);
578     }
579
580   /* Recognize an add immediate value to register to either %g1 or
581      the destination register recorded above.  Actually, this might
582      well recognize several different arithmetic operations.
583      It doesn't check that rs1 == rd because in theory "sub %g0, 5, %g1"
584      followed by "save %sp, %g1, %sp" is a valid prologue (Not that
585      I imagine any compiler really does that, however).  */
586   if (X_OP (insn) == 2
587       && X_I (insn)
588       && (X_RD (insn) == 1 || X_RD (insn) == dest))
589     {
590       pc += 4;
591       insn = fetch_instruction (pc);
592     }
593
594   /* Recognize any SAVE insn.  */
595   if (X_OP (insn) == 2 && X_OP3 (insn) == 60)
596     {
597       pc += 4;
598       if (frameless_p)          /* If the save is all we care about, */
599         return pc;              /* return before doing more work */
600       insn = fetch_instruction (pc);
601     }
602   /* Recognize add to %sp.  */
603   else if (X_OP (insn) == 2 && X_RD (insn) == 14 && X_OP3 (insn) == 0)
604     {
605       pc += 4;
606       if (frameless_p)          /* If the add is all we care about, */
607         return pc;              /* return before doing more work */
608       is_flat = 1;
609       insn = fetch_instruction (pc);
610       /* Recognize store of frame pointer (i7).  */
611       if (X_OP (insn) == 3
612           && X_RD (insn) == 31
613           && X_OP3 (insn) == 4
614           && X_RS1 (insn) == 14)
615         {
616           pc += 4;
617           insn = fetch_instruction (pc);
618
619           /* Recognize sub %sp, <anything>, %i7.  */
620           if (X_OP (insn) == 2
621               && X_OP3 (insn) == 4
622               && X_RS1 (insn) == 14
623               && X_RD (insn) == 31)
624             {
625               pc += 4;
626               insn = fetch_instruction (pc);
627             }
628           else
629             return pc;
630         }
631       else
632         return pc;
633     }
634   else
635     /* Without a save or add instruction, it's not a prologue.  */
636     return start_pc;
637
638   while (1)
639     {
640       /* Recognize stores into the frame from the input registers.
641          This recognizes all non alternate stores of an input register,
642          into a location offset from the frame pointer between
643          +68 and +92.  */
644
645       /* The above will fail for arguments that are promoted 
646          (eg. shorts to ints or floats to doubles), because the compiler
647          will pass them in positive-offset frame space, but the prologue
648          will save them (after conversion) in negative frame space at an
649          unpredictable offset.  Therefore I am going to remove the 
650          restriction on the target-address of the save, on the theory
651          that any unbroken sequence of saves from input registers must
652          be part of the prologue.  In un-optimized code (at least), I'm
653          fairly sure that the compiler would emit SOME other instruction
654          (eg. a move or add) before emitting another save that is actually
655          a part of the function body.
656
657          Besides, the reserved stack space is different for SPARC64 anyway.
658
659          MVS  4/23/2000  */
660
661       if (X_OP (insn) == 3
662           && (X_OP3 (insn) & 0x3c)       == 4   /* Store, non-alternate.  */
663           && (X_RD (insn) & 0x18) == 0x18       /* Input register.  */
664           && X_I (insn)                         /* Immediate mode.  */
665           && X_RS1 (insn) == 30)                /* Off of frame pointer.  */
666         ; /* empty statement -- fall thru to end of loop */
667       else if (GDB_TARGET_IS_SPARC64
668                && X_OP (insn) == 3
669                && (X_OP3 (insn) & 0x3c) == 12   /* store, extended (64-bit) */
670                && (X_RD (insn) & 0x18) == 0x18  /* input register */
671                && X_I (insn)                    /* immediate mode */
672                && X_RS1 (insn) == 30)           /* off of frame pointer */
673         ; /* empty statement -- fall thru to end of loop */
674       else if (X_OP (insn) == 3
675                && (X_OP3 (insn) & 0x3c) == 36   /* store, floating-point */
676                && X_I (insn)                    /* immediate mode */
677                && X_RS1 (insn) == 30)           /* off of frame pointer */
678         ; /* empty statement -- fall thru to end of loop */
679       else if (is_flat
680                && X_OP (insn) == 3
681                && X_OP3 (insn) == 4             /* store? */
682                && X_RS1 (insn) == 14)           /* off of frame pointer */
683         {
684           if (saved_regs && X_I (insn))
685             saved_regs[X_RD (insn)] =
686               fi->frame + fi->extra_info->sp_offset + X_SIMM13 (insn);
687         }
688       else
689         break;
690       pc += 4;
691       insn = fetch_instruction (pc);
692     }
693
694   return pc;
695 }
696
697 CORE_ADDR
698 sparc_skip_prologue (start_pc, frameless_p)
699      CORE_ADDR start_pc;
700      int frameless_p;
701 {
702   return examine_prologue (start_pc, frameless_p, NULL, NULL);
703 }
704
705 /* Check instruction at ADDR to see if it is a branch.
706    All non-annulled instructions will go to NPC or will trap.
707    Set *TARGET if we find a candidate branch; set to zero if not.
708
709    This isn't static as it's used by remote-sa.sparc.c.  */
710
711 static branch_type
712 isbranch (instruction, addr, target)
713      long instruction;
714      CORE_ADDR addr, *target;
715 {
716   branch_type val = not_branch;
717   long int offset = 0;          /* Must be signed for sign-extend.  */
718
719   *target = 0;
720
721   if (X_OP (instruction) == 0
722       && (X_OP2 (instruction) == 2
723           || X_OP2 (instruction) == 6
724           || X_OP2 (instruction) == 1
725           || X_OP2 (instruction) == 3
726           || X_OP2 (instruction) == 5
727           || (GDB_TARGET_IS_SPARC64 && X_OP2 (instruction) == 7)))
728     {
729       if (X_COND (instruction) == 8)
730         val = X_A (instruction) ? baa : ba;
731       else
732         val = X_A (instruction) ? bicca : bicc;
733       switch (X_OP2 (instruction))
734         {
735         case 7:
736         if (!GDB_TARGET_IS_SPARC64)
737           break;
738         /* else fall thru */
739         case 2:
740         case 6:
741           offset = 4 * X_DISP22 (instruction);
742           break;
743         case 1:
744         case 5:
745           offset = 4 * X_DISP19 (instruction);
746           break;
747         case 3:
748           offset = 4 * X_DISP16 (instruction);
749           break;
750         }
751       *target = addr + offset;
752     }
753   else if (GDB_TARGET_IS_SPARC64
754            && X_OP (instruction) == 2
755            && X_OP3 (instruction) == 62)
756     {
757       if (X_FCN (instruction) == 0)
758         {
759           /* done */
760           *target = read_register (TNPC_REGNUM);
761           val = done_retry;
762         }
763       else if (X_FCN (instruction) == 1)
764         {
765           /* retry */
766           *target = read_register (TPC_REGNUM);
767           val = done_retry;
768         }
769     }
770
771   return val;
772 }
773 \f
774 /* Find register number REGNUM relative to FRAME and put its
775    (raw) contents in *RAW_BUFFER.  Set *OPTIMIZED if the variable
776    was optimized out (and thus can't be fetched).  If the variable
777    was fetched from memory, set *ADDRP to where it was fetched from,
778    otherwise it was fetched from a register.
779
780    The argument RAW_BUFFER must point to aligned memory.  */
781
782 void
783 sparc_get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
784      char *raw_buffer;
785      int *optimized;
786      CORE_ADDR *addrp;
787      struct frame_info *frame;
788      int regnum;
789      enum lval_type *lval;
790 {
791   struct frame_info *frame1;
792   CORE_ADDR addr;
793
794   if (!target_has_registers)
795     error ("No registers.");
796
797   if (optimized)
798     *optimized = 0;
799
800   addr = 0;
801
802   /* FIXME This code extracted from infcmd.c; should put elsewhere! */
803   if (frame == NULL)
804     {
805       /* error ("No selected frame."); */
806       if (!target_has_registers)
807         error ("The program has no registers now.");
808       if (selected_frame == NULL)
809         error ("No selected frame.");
810       /* Try to use selected frame */
811       frame = get_prev_frame (selected_frame);
812       if (frame == 0)
813         error ("Cmd not meaningful in the outermost frame.");
814     }
815
816
817   frame1 = frame->next;
818
819   /* Get saved PC from the frame info if not in innermost frame.  */
820   if (regnum == PC_REGNUM && frame1 != NULL)
821     {
822       if (lval != NULL)
823         *lval = not_lval;
824       if (raw_buffer != NULL)
825         {
826           /* Put it back in target format.  */
827           store_address (raw_buffer, REGISTER_RAW_SIZE (regnum), frame->pc);
828         }
829       if (addrp != NULL)
830         *addrp = 0;
831       return;
832     }
833
834   while (frame1 != NULL)
835     {
836       /* FIXME MVS: wrong test for dummy frame at entry.  */
837
838       if (frame1->pc >= (frame1->extra_info->bottom ? 
839                          frame1->extra_info->bottom : read_sp ())
840           && frame1->pc <= FRAME_FP (frame1))
841         {
842           /* Dummy frame.  All but the window regs are in there somewhere.
843              The window registers are saved on the stack, just like in a
844              normal frame.  */
845           if (regnum >= G1_REGNUM && regnum < G1_REGNUM + 7)
846             addr = frame1->frame + (regnum - G0_REGNUM) * SPARC_INTREG_SIZE
847               - (FP_REGISTER_BYTES + 8 * SPARC_INTREG_SIZE);
848           else if (regnum >= I0_REGNUM && regnum < I0_REGNUM + 8)
849             addr = (frame1->prev->extra_info->bottom
850                     + (regnum - I0_REGNUM) * SPARC_INTREG_SIZE
851                     + FRAME_SAVED_I0);
852           else if (regnum >= L0_REGNUM && regnum < L0_REGNUM + 8)
853             addr = (frame1->prev->extra_info->bottom
854                     + (regnum - L0_REGNUM) * SPARC_INTREG_SIZE
855                     + FRAME_SAVED_L0);
856           else if (regnum >= O0_REGNUM && regnum < O0_REGNUM + 8)
857             addr = frame1->frame + (regnum - O0_REGNUM) * SPARC_INTREG_SIZE
858               - (FP_REGISTER_BYTES + 16 * SPARC_INTREG_SIZE);
859           else if (SPARC_HAS_FPU &&
860                    regnum >= FP0_REGNUM && regnum < FP0_REGNUM + 32)
861             addr = frame1->frame + (regnum - FP0_REGNUM) * 4
862               - (FP_REGISTER_BYTES);
863           else if (GDB_TARGET_IS_SPARC64 && SPARC_HAS_FPU && 
864                    regnum >= FP0_REGNUM + 32 && regnum < FP_MAX_REGNUM)
865             addr = frame1->frame + 32 * 4 + (regnum - FP0_REGNUM - 32) * 8
866               - (FP_REGISTER_BYTES);
867           else if (regnum >= Y_REGNUM && regnum < NUM_REGS)
868             addr = frame1->frame + (regnum - Y_REGNUM) * SPARC_INTREG_SIZE
869               - (FP_REGISTER_BYTES + 24 * SPARC_INTREG_SIZE);
870         }
871       else if (frame1->extra_info->flat)
872         {
873
874           if (regnum == RP_REGNUM)
875             addr = frame1->extra_info->pc_addr;
876           else if (regnum == I7_REGNUM)
877             addr = frame1->extra_info->fp_addr;
878           else
879             {
880               CORE_ADDR func_start;
881               CORE_ADDR *regs;
882
883               regs = alloca (NUM_REGS * sizeof (CORE_ADDR)); 
884               memset (regs, 0, NUM_REGS * sizeof (CORE_ADDR));
885
886               find_pc_partial_function (frame1->pc, NULL, &func_start, NULL);
887               examine_prologue (func_start, 0, frame1, regs);
888               addr = regs[regnum];
889             }
890         }
891       else
892         {
893           /* Normal frame.  Local and In registers are saved on stack.  */
894           if (regnum >= I0_REGNUM && regnum < I0_REGNUM + 8)
895             addr = (frame1->prev->extra_info->bottom
896                     + (regnum - I0_REGNUM) * SPARC_INTREG_SIZE
897                     + FRAME_SAVED_I0);
898           else if (regnum >= L0_REGNUM && regnum < L0_REGNUM + 8)
899             addr = (frame1->prev->extra_info->bottom
900                     + (regnum - L0_REGNUM) * SPARC_INTREG_SIZE
901                     + FRAME_SAVED_L0);
902           else if (regnum >= O0_REGNUM && regnum < O0_REGNUM + 8)
903             {
904               /* Outs become ins.  */
905               get_saved_register (raw_buffer, optimized, addrp, frame1,
906                                   (regnum - O0_REGNUM + I0_REGNUM), lval);
907               return;
908             }
909         }
910       if (addr != 0)
911         break;
912       frame1 = frame1->next;
913     }
914   if (addr != 0)
915     {
916       if (lval != NULL)
917         *lval = lval_memory;
918       if (regnum == SP_REGNUM)
919         {
920           if (raw_buffer != NULL)
921             {
922               /* Put it back in target format.  */
923               store_address (raw_buffer, REGISTER_RAW_SIZE (regnum), addr);
924             }
925           if (addrp != NULL)
926             *addrp = 0;
927           return;
928         }
929       if (raw_buffer != NULL)
930         read_memory (addr, raw_buffer, REGISTER_RAW_SIZE (regnum));
931     }
932   else
933     {
934       if (lval != NULL)
935         *lval = lval_register;
936       addr = REGISTER_BYTE (regnum);
937       if (raw_buffer != NULL)
938         read_register_gen (regnum, raw_buffer);
939     }
940   if (addrp != NULL)
941     *addrp = addr;
942 }
943
944 /* Push an empty stack frame, and record in it the current PC, regs, etc.
945
946    We save the non-windowed registers and the ins.  The locals and outs
947    are new; they don't need to be saved. The i's and l's of
948    the last frame were already saved on the stack.  */
949
950 /* Definitely see tm-sparc.h for more doc of the frame format here.  */
951
952 /* See tm-sparc.h for how this is calculated.  */
953
954 #define DUMMY_STACK_REG_BUF_SIZE \
955      (((8+8+8) * SPARC_INTREG_SIZE) + FP_REGISTER_BYTES)
956 #define DUMMY_STACK_SIZE \
957      (DUMMY_STACK_REG_BUF_SIZE + DUMMY_REG_SAVE_OFFSET)
958
959 void
960 sparc_push_dummy_frame ()
961 {
962   CORE_ADDR sp, old_sp;
963   char *register_temp;
964
965   register_temp = alloca (DUMMY_STACK_SIZE);
966
967   old_sp = sp = read_sp ();
968
969   if (GDB_TARGET_IS_SPARC64)
970     {
971       /* PC, NPC, CCR, FSR, FPRS, Y, ASI */
972       read_register_bytes (REGISTER_BYTE (PC_REGNUM), &register_temp[0],
973                            REGISTER_RAW_SIZE (PC_REGNUM) * 7);
974       read_register_bytes (REGISTER_BYTE (PSTATE_REGNUM), 
975                            &register_temp[7 * SPARC_INTREG_SIZE],
976                            REGISTER_RAW_SIZE (PSTATE_REGNUM));
977       /* FIXME: not sure what needs to be saved here.  */
978     }
979   else
980     {
981       /* Y, PS, WIM, TBR, PC, NPC, FPS, CPS regs */
982       read_register_bytes (REGISTER_BYTE (Y_REGNUM), &register_temp[0],
983                            REGISTER_RAW_SIZE (Y_REGNUM) * 8);
984     }
985
986   read_register_bytes (REGISTER_BYTE (O0_REGNUM),
987                        &register_temp[8 * SPARC_INTREG_SIZE],
988                        SPARC_INTREG_SIZE * 8);
989
990   read_register_bytes (REGISTER_BYTE (G0_REGNUM),
991                        &register_temp[16 * SPARC_INTREG_SIZE],
992                        SPARC_INTREG_SIZE * 8);
993
994   if (SPARC_HAS_FPU)
995     read_register_bytes (REGISTER_BYTE (FP0_REGNUM),
996                          &register_temp[24 * SPARC_INTREG_SIZE],
997                          FP_REGISTER_BYTES);
998
999   sp -= DUMMY_STACK_SIZE;
1000
1001   write_sp (sp);
1002
1003   write_memory (sp + DUMMY_REG_SAVE_OFFSET, &register_temp[0],
1004                 DUMMY_STACK_REG_BUF_SIZE);
1005
1006   if (strcmp (target_shortname, "sim") != 0)
1007     {
1008       write_fp (old_sp);
1009
1010       /* Set return address register for the call dummy to the current PC.  */
1011       write_register (I7_REGNUM, read_pc () - 8);
1012     }
1013   else
1014     {
1015       /* The call dummy will write this value to FP before executing
1016          the 'save'.  This ensures that register window flushes work
1017          correctly in the simulator.  */
1018       write_register (G0_REGNUM + 1, read_register (FP_REGNUM));
1019
1020       /* The call dummy will write this value to FP after executing
1021          the 'save'. */
1022       write_register (G0_REGNUM + 2, old_sp);
1023
1024       /* The call dummy will write this value to the return address (%i7) after
1025          executing the 'save'. */
1026       write_register (G0_REGNUM + 3, read_pc () - 8);
1027
1028       /* Set the FP that the call dummy will be using after the 'save'.
1029          This makes backtraces from an inferior function call work properly.  */
1030       write_register (FP_REGNUM, old_sp);
1031     }
1032 }
1033
1034 /* sparc_frame_find_saved_regs ().  This function is here only because
1035    pop_frame uses it.  Note there is an interesting corner case which
1036    I think few ports of GDB get right--if you are popping a frame
1037    which does not save some register that *is* saved by a more inner
1038    frame (such a frame will never be a dummy frame because dummy
1039    frames save all registers).  Rewriting pop_frame to use
1040    get_saved_register would solve this problem and also get rid of the
1041    ugly duplication between sparc_frame_find_saved_regs and
1042    get_saved_register.
1043
1044    Stores, into an array of CORE_ADDR, 
1045    the addresses of the saved registers of frame described by FRAME_INFO.
1046    This includes special registers such as pc and fp saved in special
1047    ways in the stack frame.  sp is even more special:
1048    the address we return for it IS the sp for the next frame.
1049
1050    Note that on register window machines, we are currently making the
1051    assumption that window registers are being saved somewhere in the
1052    frame in which they are being used.  If they are stored in an
1053    inferior frame, find_saved_register will break.
1054
1055    On the Sun 4, the only time all registers are saved is when
1056    a dummy frame is involved.  Otherwise, the only saved registers
1057    are the LOCAL and IN registers which are saved as a result
1058    of the "save/restore" opcodes.  This condition is determined
1059    by address rather than by value.
1060
1061    The "pc" is not stored in a frame on the SPARC.  (What is stored
1062    is a return address minus 8.)  sparc_pop_frame knows how to
1063    deal with that.  Other routines might or might not.
1064
1065    See tm-sparc.h (PUSH_DUMMY_FRAME and friends) for CRITICAL information
1066    about how this works.  */
1067
1068 static void sparc_frame_find_saved_regs (struct frame_info *, CORE_ADDR *);
1069
1070 static void
1071 sparc_frame_find_saved_regs (fi, saved_regs_addr)
1072      struct frame_info *fi;
1073      CORE_ADDR *saved_regs_addr;
1074 {
1075   register int regnum;
1076   CORE_ADDR frame_addr = FRAME_FP (fi);
1077
1078   if (!fi)
1079     internal_error ("Bad frame info struct in FRAME_FIND_SAVED_REGS");
1080
1081   memset (saved_regs_addr, 0, NUM_REGS * sizeof (CORE_ADDR));
1082
1083   if (fi->pc >= (fi->extra_info->bottom ? 
1084                  fi->extra_info->bottom : read_sp ())
1085       && fi->pc <= FRAME_FP (fi))
1086     {
1087       /* Dummy frame.  All but the window regs are in there somewhere. */
1088       for (regnum = G1_REGNUM; regnum < G1_REGNUM + 7; regnum++)
1089         saved_regs_addr[regnum] =
1090           frame_addr + (regnum - G0_REGNUM) * SPARC_INTREG_SIZE
1091           - DUMMY_STACK_REG_BUF_SIZE + 16 * SPARC_INTREG_SIZE;
1092
1093       for (regnum = I0_REGNUM; regnum < I0_REGNUM + 8; regnum++)
1094         saved_regs_addr[regnum] =
1095           frame_addr + (regnum - I0_REGNUM) * SPARC_INTREG_SIZE
1096           - DUMMY_STACK_REG_BUF_SIZE + 8 * SPARC_INTREG_SIZE;
1097
1098       if (SPARC_HAS_FPU)
1099         for (regnum = FP0_REGNUM; regnum < FP_MAX_REGNUM; regnum++)
1100           saved_regs_addr[regnum] = frame_addr + (regnum - FP0_REGNUM) * 4
1101             - DUMMY_STACK_REG_BUF_SIZE + 24 * SPARC_INTREG_SIZE;
1102
1103       if (GDB_TARGET_IS_SPARC64)
1104         {
1105           for (regnum = PC_REGNUM; regnum < PC_REGNUM + 7; regnum++)
1106             {
1107               saved_regs_addr[regnum] =
1108                 frame_addr + (regnum - PC_REGNUM) * SPARC_INTREG_SIZE
1109                 - DUMMY_STACK_REG_BUF_SIZE;
1110             }
1111           saved_regs_addr[PSTATE_REGNUM] =
1112             frame_addr + 8 * SPARC_INTREG_SIZE - DUMMY_STACK_REG_BUF_SIZE;
1113         }
1114       else
1115         for (regnum = Y_REGNUM; regnum < NUM_REGS; regnum++)
1116           saved_regs_addr[regnum] =
1117             frame_addr + (regnum - Y_REGNUM) * SPARC_INTREG_SIZE
1118             - DUMMY_STACK_REG_BUF_SIZE;
1119
1120       frame_addr = fi->extra_info->bottom ?
1121         fi->extra_info->bottom : read_sp ();
1122     }
1123   else if (fi->extra_info->flat)
1124     {
1125       CORE_ADDR func_start;
1126       find_pc_partial_function (fi->pc, NULL, &func_start, NULL);
1127       examine_prologue (func_start, 0, fi, saved_regs_addr);
1128
1129       /* Flat register window frame.  */
1130       saved_regs_addr[RP_REGNUM] = fi->extra_info->pc_addr;
1131       saved_regs_addr[I7_REGNUM] = fi->extra_info->fp_addr;
1132     }
1133   else
1134     {
1135       /* Normal frame.  Just Local and In registers */
1136       frame_addr = fi->extra_info->bottom ?
1137         fi->extra_info->bottom : read_sp ();
1138       for (regnum = L0_REGNUM; regnum < L0_REGNUM + 8; regnum++)
1139         saved_regs_addr[regnum] =
1140           (frame_addr + (regnum - L0_REGNUM) * SPARC_INTREG_SIZE
1141            + FRAME_SAVED_L0);
1142       for (regnum = I0_REGNUM; regnum < I0_REGNUM + 8; regnum++)
1143         saved_regs_addr[regnum] =
1144           (frame_addr + (regnum - I0_REGNUM) * SPARC_INTREG_SIZE
1145            + FRAME_SAVED_I0);
1146     }
1147   if (fi->next)
1148     {
1149       if (fi->extra_info->flat)
1150         {
1151           saved_regs_addr[O7_REGNUM] = fi->extra_info->pc_addr;
1152         }
1153       else
1154         {
1155           /* Pull off either the next frame pointer or the stack pointer */
1156           CORE_ADDR next_next_frame_addr =
1157           (fi->next->extra_info->bottom ?
1158            fi->next->extra_info->bottom : read_sp ());
1159           for (regnum = O0_REGNUM; regnum < O0_REGNUM + 8; regnum++)
1160             saved_regs_addr[regnum] =
1161               (next_next_frame_addr
1162                + (regnum - O0_REGNUM) * SPARC_INTREG_SIZE
1163                + FRAME_SAVED_I0);
1164         }
1165     }
1166   /* Otherwise, whatever we would get from ptrace(GETREGS) is accurate */
1167   /* FIXME -- should this adjust for the sparc64 offset? */
1168   saved_regs_addr[SP_REGNUM] = FRAME_FP (fi);
1169 }
1170
1171 /* Discard from the stack the innermost frame, restoring all saved registers.
1172
1173    Note that the values stored in fsr by get_frame_saved_regs are *in
1174    the context of the called frame*.  What this means is that the i
1175    regs of fsr must be restored into the o regs of the (calling) frame that
1176    we pop into.  We don't care about the output regs of the calling frame,
1177    since unless it's a dummy frame, it won't have any output regs in it.
1178
1179    We never have to bother with %l (local) regs, since the called routine's
1180    locals get tossed, and the calling routine's locals are already saved
1181    on its stack.  */
1182
1183 /* Definitely see tm-sparc.h for more doc of the frame format here.  */
1184
1185 void
1186 sparc_pop_frame ()
1187 {
1188   register struct frame_info *frame = get_current_frame ();
1189   register CORE_ADDR pc;
1190   CORE_ADDR *fsr;
1191   char *raw_buffer;
1192   int regnum;
1193
1194   fsr = alloca (NUM_REGS * sizeof (CORE_ADDR));
1195   raw_buffer = alloca (REGISTER_BYTES);
1196   sparc_frame_find_saved_regs (frame, &fsr[0]);
1197   if (SPARC_HAS_FPU)
1198     {
1199       if (fsr[FP0_REGNUM])
1200         {
1201           read_memory (fsr[FP0_REGNUM], raw_buffer, FP_REGISTER_BYTES);
1202           write_register_bytes (REGISTER_BYTE (FP0_REGNUM),
1203                                 raw_buffer, FP_REGISTER_BYTES);
1204         }
1205       if (!(GDB_TARGET_IS_SPARC64))
1206         {
1207           if (fsr[FPS_REGNUM])
1208             {
1209               read_memory (fsr[FPS_REGNUM], raw_buffer, SPARC_INTREG_SIZE);
1210               write_register_gen (FPS_REGNUM, raw_buffer);
1211             }
1212           if (fsr[CPS_REGNUM])
1213             {
1214               read_memory (fsr[CPS_REGNUM], raw_buffer, SPARC_INTREG_SIZE);
1215               write_register_gen (CPS_REGNUM, raw_buffer);
1216             }
1217         }
1218     }
1219   if (fsr[G1_REGNUM])
1220     {
1221       read_memory (fsr[G1_REGNUM], raw_buffer, 7 * SPARC_INTREG_SIZE);
1222       write_register_bytes (REGISTER_BYTE (G1_REGNUM), raw_buffer,
1223                             7 * SPARC_INTREG_SIZE);
1224     }
1225
1226   if (frame->extra_info->flat)
1227     {
1228       /* Each register might or might not have been saved, need to test
1229          individually.  */
1230       for (regnum = L0_REGNUM; regnum < L0_REGNUM + 8; ++regnum)
1231         if (fsr[regnum])
1232           write_register (regnum, read_memory_integer (fsr[regnum],
1233                                                        SPARC_INTREG_SIZE));
1234       for (regnum = I0_REGNUM; regnum < I0_REGNUM + 8; ++regnum)
1235         if (fsr[regnum])
1236           write_register (regnum, read_memory_integer (fsr[regnum],
1237                                                        SPARC_INTREG_SIZE));
1238
1239       /* Handle all outs except stack pointer (o0-o5; o7).  */
1240       for (regnum = O0_REGNUM; regnum < O0_REGNUM + 6; ++regnum)
1241         if (fsr[regnum])
1242           write_register (regnum, read_memory_integer (fsr[regnum],
1243                                                        SPARC_INTREG_SIZE));
1244       if (fsr[O0_REGNUM + 7])
1245         write_register (O0_REGNUM + 7,
1246                         read_memory_integer (fsr[O0_REGNUM + 7],
1247                                              SPARC_INTREG_SIZE));
1248
1249       write_sp (frame->frame);
1250     }
1251   else if (fsr[I0_REGNUM])
1252     {
1253       CORE_ADDR sp;
1254
1255       char *reg_temp;
1256
1257       reg_temp = alloca (REGISTER_BYTES);
1258
1259       read_memory (fsr[I0_REGNUM], raw_buffer, 8 * SPARC_INTREG_SIZE);
1260
1261       /* Get the ins and locals which we are about to restore.  Just
1262          moving the stack pointer is all that is really needed, except
1263          store_inferior_registers is then going to write the ins and
1264          locals from the registers array, so we need to muck with the
1265          registers array.  */
1266       sp = fsr[SP_REGNUM];
1267  
1268       if (GDB_TARGET_IS_SPARC64 && (sp & 1))
1269         sp += 2047;
1270
1271       read_memory (sp, reg_temp, SPARC_INTREG_SIZE * 16);
1272
1273       /* Restore the out registers.
1274          Among other things this writes the new stack pointer.  */
1275       write_register_bytes (REGISTER_BYTE (O0_REGNUM), raw_buffer,
1276                             SPARC_INTREG_SIZE * 8);
1277
1278       write_register_bytes (REGISTER_BYTE (L0_REGNUM), reg_temp,
1279                             SPARC_INTREG_SIZE * 16);
1280     }
1281
1282   if (!(GDB_TARGET_IS_SPARC64))
1283     if (fsr[PS_REGNUM])
1284       write_register (PS_REGNUM, 
1285                       read_memory_integer (fsr[PS_REGNUM], 
1286                                            REGISTER_RAW_SIZE (PS_REGNUM)));
1287
1288   if (fsr[Y_REGNUM])
1289     write_register (Y_REGNUM, 
1290                     read_memory_integer (fsr[Y_REGNUM], 
1291                                          REGISTER_RAW_SIZE (Y_REGNUM)));
1292   if (fsr[PC_REGNUM])
1293     {
1294       /* Explicitly specified PC (and maybe NPC) -- just restore them. */
1295       write_register (PC_REGNUM, 
1296                       read_memory_integer (fsr[PC_REGNUM],
1297                                            REGISTER_RAW_SIZE (PC_REGNUM)));
1298       if (fsr[NPC_REGNUM])
1299         write_register (NPC_REGNUM,
1300                         read_memory_integer (fsr[NPC_REGNUM],
1301                                              REGISTER_RAW_SIZE (NPC_REGNUM)));
1302     }
1303   else if (frame->extra_info->flat)
1304     {
1305       if (frame->extra_info->pc_addr)
1306         pc = PC_ADJUST ((CORE_ADDR)
1307                         read_memory_integer (frame->extra_info->pc_addr,
1308                                              REGISTER_RAW_SIZE (PC_REGNUM)));
1309       else
1310         {
1311           /* I think this happens only in the innermost frame, if so then
1312              it is a complicated way of saying
1313              "pc = read_register (O7_REGNUM);".  */
1314           char *buf;
1315
1316           buf = alloca (MAX_REGISTER_RAW_SIZE);
1317           get_saved_register (buf, 0, 0, frame, O7_REGNUM, 0);
1318           pc = PC_ADJUST (extract_address
1319                           (buf, REGISTER_RAW_SIZE (O7_REGNUM)));
1320         }
1321
1322       write_register (PC_REGNUM, pc);
1323       write_register (NPC_REGNUM, pc + 4);
1324     }
1325   else if (fsr[I7_REGNUM])
1326     {
1327       /* Return address in %i7 -- adjust it, then restore PC and NPC from it */
1328       pc = PC_ADJUST ((CORE_ADDR) read_memory_integer (fsr[I7_REGNUM],
1329                                                        SPARC_INTREG_SIZE));
1330       write_register (PC_REGNUM, pc);
1331       write_register (NPC_REGNUM, pc + 4);
1332     }
1333   flush_cached_frames ();
1334 }
1335
1336 /* On the Sun 4 under SunOS, the compile will leave a fake insn which
1337    encodes the structure size being returned.  If we detect such
1338    a fake insn, step past it.  */
1339
1340 CORE_ADDR
1341 sparc_pc_adjust (pc)
1342      CORE_ADDR pc;
1343 {
1344   unsigned long insn;
1345   char buf[4];
1346   int err;
1347
1348   err = target_read_memory (pc + 8, buf, 4);
1349   insn = extract_unsigned_integer (buf, 4);
1350   if ((err == 0) && (insn & 0xffc00000) == 0)
1351     return pc + 12;
1352   else
1353     return pc + 8;
1354 }
1355
1356 /* If pc is in a shared library trampoline, return its target.
1357    The SunOs 4.x linker rewrites the jump table entries for PIC
1358    compiled modules in the main executable to bypass the dynamic linker
1359    with jumps of the form
1360    sethi %hi(addr),%g1
1361    jmp %g1+%lo(addr)
1362    and removes the corresponding jump table relocation entry in the
1363    dynamic relocations.
1364    find_solib_trampoline_target relies on the presence of the jump
1365    table relocation entry, so we have to detect these jump instructions
1366    by hand.  */
1367
1368 CORE_ADDR
1369 sunos4_skip_trampoline_code (pc)
1370      CORE_ADDR pc;
1371 {
1372   unsigned long insn1;
1373   char buf[4];
1374   int err;
1375
1376   err = target_read_memory (pc, buf, 4);
1377   insn1 = extract_unsigned_integer (buf, 4);
1378   if (err == 0 && (insn1 & 0xffc00000) == 0x03000000)
1379     {
1380       unsigned long insn2;
1381
1382       err = target_read_memory (pc + 4, buf, 4);
1383       insn2 = extract_unsigned_integer (buf, 4);
1384       if (err == 0 && (insn2 & 0xffffe000) == 0x81c06000)
1385         {
1386           CORE_ADDR target_pc = (insn1 & 0x3fffff) << 10;
1387           int delta = insn2 & 0x1fff;
1388
1389           /* Sign extend the displacement.  */
1390           if (delta & 0x1000)
1391             delta |= ~0x1fff;
1392           return target_pc + delta;
1393         }
1394     }
1395   return find_solib_trampoline_target (pc);
1396 }
1397 \f
1398 #ifdef USE_PROC_FS              /* Target dependent support for /proc */
1399 /* *INDENT-OFF* */
1400 /*  The /proc interface divides the target machine's register set up into
1401     two different sets, the general register set (gregset) and the floating
1402     point register set (fpregset).  For each set, there is an ioctl to get
1403     the current register set and another ioctl to set the current values.
1404
1405     The actual structure passed through the ioctl interface is, of course,
1406     naturally machine dependent, and is different for each set of registers.
1407     For the sparc for example, the general register set is typically defined
1408     by:
1409
1410         typedef int gregset_t[38];
1411
1412         #define R_G0    0
1413         ...
1414         #define R_TBR   37
1415
1416     and the floating point set by:
1417
1418         typedef struct prfpregset {
1419                 union { 
1420                         u_long  pr_regs[32]; 
1421                         double  pr_dregs[16];
1422                 } pr_fr;
1423                 void *  pr_filler;
1424                 u_long  pr_fsr;
1425                 u_char  pr_qcnt;
1426                 u_char  pr_q_entrysize;
1427                 u_char  pr_en;
1428                 u_long  pr_q[64];
1429         } prfpregset_t;
1430
1431     These routines provide the packing and unpacking of gregset_t and
1432     fpregset_t formatted data.
1433
1434  */
1435 /* *INDENT-ON* */
1436
1437 /* Given a pointer to a general register set in /proc format (gregset_t *),
1438    unpack the register contents and supply them as gdb's idea of the current
1439    register values. */
1440
1441 void
1442 supply_gregset (gregsetp)
1443      gdb_gregset_t *gregsetp;
1444 {
1445   prgreg_t *regp = (prgreg_t *) gregsetp;
1446   int regi, offset = 0;
1447
1448   /* If the host is 64-bit sparc, but the target is 32-bit sparc, 
1449      then the gregset may contain 64-bit ints while supply_register
1450      is expecting 32-bit ints.  Compensate.  */
1451   if (sizeof (regp[0]) == 8 && SPARC_INTREG_SIZE == 4)
1452     offset = 4;
1453
1454   /* GDB register numbers for Gn, On, Ln, In all match /proc reg numbers.  */
1455   /* FIXME MVS: assumes the order of the first 32 elements... */
1456   for (regi = G0_REGNUM; regi <= I7_REGNUM; regi++)
1457     {
1458       supply_register (regi, ((char *) (regp + regi)) + offset);
1459     }
1460
1461   /* These require a bit more care.  */
1462   supply_register (PC_REGNUM, ((char *) (regp + R_PC)) + offset);
1463   supply_register (NPC_REGNUM, ((char *) (regp + R_nPC)) + offset);
1464   supply_register (Y_REGNUM, ((char *) (regp + R_Y)) + offset);
1465
1466   if (GDB_TARGET_IS_SPARC64)
1467     {
1468 #ifdef R_CCR
1469       supply_register (CCR_REGNUM, ((char *) (regp + R_CCR)) + offset);
1470 #else
1471       supply_register (CCR_REGNUM, NULL);
1472 #endif
1473 #ifdef R_FPRS
1474       supply_register (FPRS_REGNUM, ((char *) (regp + R_FPRS)) + offset);
1475 #else
1476       supply_register (FPRS_REGNUM, NULL);
1477 #endif
1478 #ifdef R_ASI
1479       supply_register (ASI_REGNUM, ((char *) (regp + R_ASI)) + offset);
1480 #else
1481       supply_register (ASI_REGNUM, NULL);
1482 #endif
1483     }
1484   else  /* sparc32 */
1485     {
1486 #ifdef R_PS
1487       supply_register (PS_REGNUM, ((char *) (regp + R_PS)) + offset);
1488 #else
1489       supply_register (PS_REGNUM, NULL);
1490 #endif
1491
1492       /* For 64-bit hosts, R_WIM and R_TBR may not be defined.
1493          Steal R_ASI and R_FPRS, and hope for the best!  */
1494
1495 #if !defined (R_WIM) && defined (R_ASI)
1496 #define R_WIM R_ASI
1497 #endif
1498
1499 #if !defined (R_TBR) && defined (R_FPRS)
1500 #define R_TBR R_FPRS
1501 #endif
1502
1503 #if defined (R_WIM)
1504       supply_register (WIM_REGNUM, ((char *) (regp + R_WIM)) + offset);
1505 #else
1506       supply_register (WIM_REGNUM, NULL);
1507 #endif
1508
1509 #if defined (R_TBR)
1510       supply_register (TBR_REGNUM, ((char *) (regp + R_TBR)) + offset);
1511 #else
1512       supply_register (TBR_REGNUM, NULL);
1513 #endif
1514     }
1515
1516   /* Fill inaccessible registers with zero.  */
1517   if (GDB_TARGET_IS_SPARC64)
1518     {
1519       /*
1520        * don't know how to get value of any of the following:
1521        */
1522       supply_register (VER_REGNUM, NULL);
1523       supply_register (TICK_REGNUM, NULL);
1524       supply_register (PIL_REGNUM, NULL);
1525       supply_register (PSTATE_REGNUM, NULL);
1526       supply_register (TSTATE_REGNUM, NULL);
1527       supply_register (TBA_REGNUM, NULL);
1528       supply_register (TL_REGNUM, NULL);
1529       supply_register (TT_REGNUM, NULL);
1530       supply_register (TPC_REGNUM, NULL);
1531       supply_register (TNPC_REGNUM, NULL);
1532       supply_register (WSTATE_REGNUM, NULL);
1533       supply_register (CWP_REGNUM, NULL);
1534       supply_register (CANSAVE_REGNUM, NULL);
1535       supply_register (CANRESTORE_REGNUM, NULL);
1536       supply_register (CLEANWIN_REGNUM, NULL);
1537       supply_register (OTHERWIN_REGNUM, NULL);
1538       supply_register (ASR16_REGNUM, NULL);
1539       supply_register (ASR17_REGNUM, NULL);
1540       supply_register (ASR18_REGNUM, NULL);
1541       supply_register (ASR19_REGNUM, NULL);
1542       supply_register (ASR20_REGNUM, NULL);
1543       supply_register (ASR21_REGNUM, NULL);
1544       supply_register (ASR22_REGNUM, NULL);
1545       supply_register (ASR23_REGNUM, NULL);
1546       supply_register (ASR24_REGNUM, NULL);
1547       supply_register (ASR25_REGNUM, NULL);
1548       supply_register (ASR26_REGNUM, NULL);
1549       supply_register (ASR27_REGNUM, NULL);
1550       supply_register (ASR28_REGNUM, NULL);
1551       supply_register (ASR29_REGNUM, NULL);
1552       supply_register (ASR30_REGNUM, NULL);
1553       supply_register (ASR31_REGNUM, NULL);
1554       supply_register (ICC_REGNUM, NULL);
1555       supply_register (XCC_REGNUM, NULL);
1556     }
1557   else
1558     {
1559       supply_register (CPS_REGNUM, NULL);
1560     }
1561 }
1562
1563 void
1564 fill_gregset (gregsetp, regno)
1565      gdb_gregset_t *gregsetp;
1566      int regno;
1567 {
1568   prgreg_t *regp = (prgreg_t *) gregsetp;
1569   int regi, offset = 0;
1570
1571   /* If the host is 64-bit sparc, but the target is 32-bit sparc, 
1572      then the gregset may contain 64-bit ints while supply_register
1573      is expecting 32-bit ints.  Compensate.  */
1574   if (sizeof (regp[0]) == 8 && SPARC_INTREG_SIZE == 4)
1575     offset = 4;
1576
1577   for (regi = 0; regi <= R_I7; regi++)
1578     if ((regno == -1) || (regno == regi))
1579       read_register_gen (regi, (char *) (regp + regi) + offset);
1580
1581   if ((regno == -1) || (regno == PC_REGNUM))
1582     read_register_gen (PC_REGNUM, (char *) (regp + R_PC) + offset);
1583
1584   if ((regno == -1) || (regno == NPC_REGNUM))
1585     read_register_gen (NPC_REGNUM, (char *) (regp + R_nPC) + offset);
1586
1587   if ((regno == -1) || (regno == Y_REGNUM))
1588     read_register_gen (Y_REGNUM, (char *) (regp + R_Y) + offset);
1589
1590   if (GDB_TARGET_IS_SPARC64)
1591     {
1592 #ifdef R_CCR
1593       if (regno == -1 || regno == CCR_REGNUM)
1594         read_register_gen (CCR_REGNUM, ((char *) (regp + R_CCR)) + offset);
1595 #endif
1596 #ifdef R_FPRS
1597       if (regno == -1 || regno == FPRS_REGNUM)
1598         read_register_gen (FPRS_REGNUM, ((char *) (regp + R_FPRS)) + offset);
1599 #endif
1600 #ifdef R_ASI
1601       if (regno == -1 || regno == ASI_REGNUM)
1602         read_register_gen (ASI_REGNUM, ((char *) (regp + R_ASI)) + offset);
1603 #endif
1604     }
1605   else /* sparc32 */
1606     {
1607 #ifdef R_PS
1608       if (regno == -1 || regno == PS_REGNUM)
1609         read_register_gen (PS_REGNUM, ((char *) (regp + R_PS)) + offset);
1610 #endif
1611
1612       /* For 64-bit hosts, R_WIM and R_TBR may not be defined.
1613          Steal R_ASI and R_FPRS, and hope for the best!  */
1614
1615 #if !defined (R_WIM) && defined (R_ASI)
1616 #define R_WIM R_ASI
1617 #endif
1618
1619 #if !defined (R_TBR) && defined (R_FPRS)
1620 #define R_TBR R_FPRS
1621 #endif
1622
1623 #if defined (R_WIM)
1624       if (regno == -1 || regno == WIM_REGNUM)
1625         read_register_gen (WIM_REGNUM, ((char *) (regp + R_WIM)) + offset);
1626 #else
1627       if (regno == -1 || regno == WIM_REGNUM)
1628         read_register_gen (WIM_REGNUM, NULL);
1629 #endif
1630
1631 #if defined (R_TBR)
1632       if (regno == -1 || regno == TBR_REGNUM)
1633         read_register_gen (TBR_REGNUM, ((char *) (regp + R_TBR)) + offset);
1634 #else
1635       if (regno == -1 || regno == TBR_REGNUM)
1636         read_register_gen (TBR_REGNUM, NULL);
1637 #endif
1638     }
1639 }
1640
1641 /*  Given a pointer to a floating point register set in /proc format
1642    (fpregset_t *), unpack the register contents and supply them as gdb's
1643    idea of the current floating point register values. */
1644
1645 void
1646 supply_fpregset (fpregsetp)
1647      gdb_fpregset_t *fpregsetp;
1648 {
1649   register int regi;
1650   char *from;
1651
1652   if (!SPARC_HAS_FPU)
1653     return;
1654
1655   for (regi = FP0_REGNUM; regi < FP_MAX_REGNUM; regi++)
1656     {
1657       from = (char *) &fpregsetp->pr_fr.pr_regs[regi - FP0_REGNUM];
1658       supply_register (regi, from);
1659     }
1660
1661   if (GDB_TARGET_IS_SPARC64)
1662     {
1663       /*
1664        * don't know how to get value of the following.  
1665        */
1666       supply_register (FSR_REGNUM, NULL);       /* zero it out for now */
1667       supply_register (FCC0_REGNUM, NULL);
1668       supply_register (FCC1_REGNUM, NULL); /* don't know how to get value */
1669       supply_register (FCC2_REGNUM, NULL); /* don't know how to get value */
1670       supply_register (FCC3_REGNUM, NULL); /* don't know how to get value */
1671     }
1672   else
1673     {
1674       supply_register (FPS_REGNUM, (char *) &(fpregsetp->pr_fsr));
1675     }
1676 }
1677
1678 /*  Given a pointer to a floating point register set in /proc format
1679    (fpregset_t *), update the register specified by REGNO from gdb's idea
1680    of the current floating point register set.  If REGNO is -1, update
1681    them all. */
1682 /* This will probably need some changes for sparc64.  */
1683
1684 void
1685 fill_fpregset (fpregsetp, regno)
1686      gdb_fpregset_t *fpregsetp;
1687      int regno;
1688 {
1689   int regi;
1690   char *to;
1691   char *from;
1692
1693   if (!SPARC_HAS_FPU)
1694     return;
1695
1696   for (regi = FP0_REGNUM; regi < FP_MAX_REGNUM; regi++)
1697     {
1698       if ((regno == -1) || (regno == regi))
1699         {
1700           from = (char *) &registers[REGISTER_BYTE (regi)];
1701           to = (char *) &fpregsetp->pr_fr.pr_regs[regi - FP0_REGNUM];
1702           memcpy (to, from, REGISTER_RAW_SIZE (regi));
1703         }
1704     }
1705
1706   if (!(GDB_TARGET_IS_SPARC64)) /* FIXME: does Sparc64 have this register? */
1707     if ((regno == -1) || (regno == FPS_REGNUM))
1708       {
1709         from = (char *)&registers[REGISTER_BYTE (FPS_REGNUM)];
1710         to = (char *) &fpregsetp->pr_fsr;
1711         memcpy (to, from, REGISTER_RAW_SIZE (FPS_REGNUM));
1712       }
1713 }
1714
1715 #endif /* USE_PROC_FS */
1716
1717
1718 #ifdef GET_LONGJMP_TARGET
1719
1720 /* Figure out where the longjmp will land.  We expect that we have just entered
1721    longjmp and haven't yet setup the stack frame, so the args are still in the
1722    output regs.  %o0 (O0_REGNUM) points at the jmp_buf structure from which we
1723    extract the pc (JB_PC) that we will land at.  The pc is copied into ADDR.
1724    This routine returns true on success */
1725
1726 int
1727 get_longjmp_target (pc)
1728      CORE_ADDR *pc;
1729 {
1730   CORE_ADDR jb_addr;
1731 #define LONGJMP_TARGET_SIZE 4
1732   char buf[LONGJMP_TARGET_SIZE];
1733
1734   jb_addr = read_register (O0_REGNUM);
1735
1736   if (target_read_memory (jb_addr + JB_PC * JB_ELEMENT_SIZE, buf,
1737                           LONGJMP_TARGET_SIZE))
1738     return 0;
1739
1740   *pc = extract_address (buf, LONGJMP_TARGET_SIZE);
1741
1742   return 1;
1743 }
1744 #endif /* GET_LONGJMP_TARGET */
1745 \f
1746 #ifdef STATIC_TRANSFORM_NAME
1747 /* SunPRO (3.0 at least), encodes the static variables.  This is not
1748    related to C++ mangling, it is done for C too.  */
1749
1750 char *
1751 sunpro_static_transform_name (name)
1752      char *name;
1753 {
1754   char *p;
1755   if (name[0] == '$')
1756     {
1757       /* For file-local statics there will be a dollar sign, a bunch
1758          of junk (the contents of which match a string given in the
1759          N_OPT), a period and the name.  For function-local statics
1760          there will be a bunch of junk (which seems to change the
1761          second character from 'A' to 'B'), a period, the name of the
1762          function, and the name.  So just skip everything before the
1763          last period.  */
1764       p = strrchr (name, '.');
1765       if (p != NULL)
1766         name = p + 1;
1767     }
1768   return name;
1769 }
1770 #endif /* STATIC_TRANSFORM_NAME */
1771 \f
1772
1773 /* Utilities for printing registers.
1774    Page numbers refer to the SPARC Architecture Manual.  */
1775
1776 static void dump_ccreg (char *, int);
1777
1778 static void
1779 dump_ccreg (reg, val)
1780      char *reg;
1781      int val;
1782 {
1783   /* page 41 */
1784   printf_unfiltered ("%s:%s,%s,%s,%s", reg,
1785                      val & 8 ? "N" : "NN",
1786                      val & 4 ? "Z" : "NZ",
1787                      val & 2 ? "O" : "NO",
1788                      val & 1 ? "C" : "NC");
1789 }
1790
1791 static char *
1792 decode_asi (val)
1793      int val;
1794 {
1795   /* page 72 */
1796   switch (val)
1797     {
1798     case 4:
1799       return "ASI_NUCLEUS";
1800     case 0x0c:
1801       return "ASI_NUCLEUS_LITTLE";
1802     case 0x10:
1803       return "ASI_AS_IF_USER_PRIMARY";
1804     case 0x11:
1805       return "ASI_AS_IF_USER_SECONDARY";
1806     case 0x18:
1807       return "ASI_AS_IF_USER_PRIMARY_LITTLE";
1808     case 0x19:
1809       return "ASI_AS_IF_USER_SECONDARY_LITTLE";
1810     case 0x80:
1811       return "ASI_PRIMARY";
1812     case 0x81:
1813       return "ASI_SECONDARY";
1814     case 0x82:
1815       return "ASI_PRIMARY_NOFAULT";
1816     case 0x83:
1817       return "ASI_SECONDARY_NOFAULT";
1818     case 0x88:
1819       return "ASI_PRIMARY_LITTLE";
1820     case 0x89:
1821       return "ASI_SECONDARY_LITTLE";
1822     case 0x8a:
1823       return "ASI_PRIMARY_NOFAULT_LITTLE";
1824     case 0x8b:
1825       return "ASI_SECONDARY_NOFAULT_LITTLE";
1826     default:
1827       return NULL;
1828     }
1829 }
1830
1831 /* PRINT_REGISTER_HOOK routine.
1832    Pretty print various registers.  */
1833 /* FIXME: Would be nice if this did some fancy things for 32 bit sparc.  */
1834
1835 void
1836 sparc_print_register_hook (regno)
1837      int regno;
1838 {
1839   ULONGEST val;
1840
1841   /* Handle double/quad versions of lower 32 fp regs.  */
1842   if (regno >= FP0_REGNUM && regno < FP0_REGNUM + 32
1843       && (regno & 1) == 0)
1844     {
1845       char value[16];
1846
1847       if (!read_relative_register_raw_bytes (regno, value)
1848           && !read_relative_register_raw_bytes (regno + 1, value + 4))
1849         {
1850           printf_unfiltered ("\t");
1851           print_floating (value, builtin_type_double, gdb_stdout);
1852         }
1853 #if 0                           /* FIXME: gdb doesn't handle long doubles */
1854       if ((regno & 3) == 0)
1855         {
1856           if (!read_relative_register_raw_bytes (regno + 2, value + 8)
1857               && !read_relative_register_raw_bytes (regno + 3, value + 12))
1858             {
1859               printf_unfiltered ("\t");
1860               print_floating (value, builtin_type_long_double, gdb_stdout);
1861             }
1862         }
1863 #endif
1864       return;
1865     }
1866
1867 #if 0                           /* FIXME: gdb doesn't handle long doubles */
1868   /* Print upper fp regs as long double if appropriate.  */
1869   if (regno >= FP0_REGNUM + 32 && regno < FP_MAX_REGNUM
1870   /* We test for even numbered regs and not a multiple of 4 because
1871      the upper fp regs are recorded as doubles.  */
1872       && (regno & 1) == 0)
1873     {
1874       char value[16];
1875
1876       if (!read_relative_register_raw_bytes (regno, value)
1877           && !read_relative_register_raw_bytes (regno + 1, value + 8))
1878         {
1879           printf_unfiltered ("\t");
1880           print_floating (value, builtin_type_long_double, gdb_stdout);
1881         }
1882       return;
1883     }
1884 #endif
1885
1886   /* FIXME: Some of these are priviledged registers.
1887      Not sure how they should be handled.  */
1888
1889 #define BITS(n, mask) ((int) (((val) >> (n)) & (mask)))
1890
1891   val = read_register (regno);
1892
1893   /* pages 40 - 60 */
1894   if (GDB_TARGET_IS_SPARC64)
1895     switch (regno)
1896       {
1897       case CCR_REGNUM:
1898         printf_unfiltered ("\t");
1899         dump_ccreg ("xcc", val >> 4);
1900         printf_unfiltered (", ");
1901         dump_ccreg ("icc", val & 15);
1902         break;
1903       case FPRS_REGNUM:
1904         printf ("\tfef:%d, du:%d, dl:%d",
1905                 BITS (2, 1), BITS (1, 1), BITS (0, 1));
1906         break;
1907       case FSR_REGNUM:
1908         {
1909           static char *fcc[4] =
1910           {"=", "<", ">", "?"};
1911           static char *rd[4] =
1912           {"N", "0", "+", "-"};
1913           /* Long, but I'd rather leave it as is and use a wide screen.  */
1914           printf_filtered ("\t0:%s, 1:%s, 2:%s, 3:%s, rd:%s, tem:%d, ",
1915                            fcc[BITS (10, 3)], fcc[BITS (32, 3)],
1916                            fcc[BITS (34, 3)], fcc[BITS (36, 3)],
1917                            rd[BITS (30, 3)], BITS (23, 31));
1918           printf_filtered ("ns:%d, ver:%d, ftt:%d, qne:%d, aexc:%d, cexc:%d",
1919                            BITS (22, 1), BITS (17, 7), BITS (14, 7), 
1920                            BITS (13, 1), BITS (5, 31), BITS (0, 31));
1921           break;
1922         }
1923       case ASI_REGNUM:
1924         {
1925           char *asi = decode_asi (val);
1926           if (asi != NULL)
1927             printf ("\t%s", asi);
1928           break;
1929         }
1930       case VER_REGNUM:
1931         printf ("\tmanuf:%d, impl:%d, mask:%d, maxtl:%d, maxwin:%d",
1932                 BITS (48, 0xffff), BITS (32, 0xffff),
1933                 BITS (24, 0xff), BITS (8, 0xff), BITS (0, 31));
1934         break;
1935       case PSTATE_REGNUM:
1936         {
1937           static char *mm[4] =
1938           {"tso", "pso", "rso", "?"};
1939           printf_filtered ("\tcle:%d, tle:%d, mm:%s, red:%d, ",
1940                            BITS (9, 1), BITS (8, 1), 
1941                            mm[BITS (6, 3)], BITS (5, 1));
1942           printf_filtered ("pef:%d, am:%d, priv:%d, ie:%d, ag:%d",
1943                            BITS (4, 1), BITS (3, 1), BITS (2, 1), 
1944                            BITS (1, 1), BITS (0, 1));
1945           break;
1946         }
1947       case TSTATE_REGNUM:
1948         /* FIXME: print all 4? */
1949         break;
1950       case TT_REGNUM:
1951         /* FIXME: print all 4? */
1952         break;
1953       case TPC_REGNUM:
1954         /* FIXME: print all 4? */
1955         break;
1956       case TNPC_REGNUM:
1957         /* FIXME: print all 4? */
1958         break;
1959       case WSTATE_REGNUM:
1960         printf ("\tother:%d, normal:%d", BITS (3, 7), BITS (0, 7));
1961         break;
1962       case CWP_REGNUM:
1963         printf ("\t%d", BITS (0, 31));
1964         break;
1965       case CANSAVE_REGNUM:
1966         printf ("\t%-2d before spill", BITS (0, 31));
1967         break;
1968       case CANRESTORE_REGNUM:
1969         printf ("\t%-2d before fill", BITS (0, 31));
1970         break;
1971       case CLEANWIN_REGNUM:
1972         printf ("\t%-2d before clean", BITS (0, 31));
1973         break;
1974       case OTHERWIN_REGNUM:
1975         printf ("\t%d", BITS (0, 31));
1976         break;
1977       }
1978   else  /* Sparc32 */
1979     switch (regno) 
1980       {
1981       case PS_REGNUM:
1982         printf ("\ticc:%c%c%c%c, pil:%d, s:%d, ps:%d, et:%d, cwp:%d",
1983                 BITS (23, 1) ? 'N' : '-', BITS (22, 1) ? 'Z' : '-',
1984                 BITS (21, 1) ? 'V' : '-', BITS (20, 1) ? 'C' : '-',
1985                 BITS (8, 15), BITS (7, 1), BITS (6, 1), BITS (5, 1),
1986                 BITS (0, 31));
1987         break;
1988       case FPS_REGNUM:
1989         {
1990           static char *fcc[4] =
1991           {"=", "<", ">", "?"};
1992           static char *rd[4] =
1993           {"N", "0", "+", "-"};
1994           /* Long, but I'd rather leave it as is and use a wide screen.  */
1995           printf ("\trd:%s, tem:%d, ns:%d, ver:%d, ftt:%d, qne:%d, "
1996                   "fcc:%s, aexc:%d, cexc:%d",
1997                   rd[BITS (30, 3)], BITS (23, 31), BITS (22, 1), BITS (17, 7),
1998                   BITS (14, 7), BITS (13, 1), fcc[BITS (10, 3)], BITS (5, 31),
1999                   BITS (0, 31));
2000           break;
2001         }
2002       }
2003
2004 #undef BITS
2005 }
2006 \f
2007 int
2008 gdb_print_insn_sparc (memaddr, info)
2009      bfd_vma memaddr;
2010      disassemble_info *info;
2011 {
2012   /* It's necessary to override mach again because print_insn messes it up. */
2013   info->mach = TARGET_ARCHITECTURE->mach;
2014   return print_insn_sparc (memaddr, info);
2015 }
2016 \f
2017 /* The SPARC passes the arguments on the stack; arguments smaller
2018    than an int are promoted to an int.  The first 6 words worth of 
2019    args are also passed in registers o0 - o5.  */
2020
2021 CORE_ADDR
2022 sparc32_push_arguments (nargs, args, sp, struct_return, struct_addr)
2023      int nargs;
2024      value_ptr *args;
2025      CORE_ADDR sp;
2026      int struct_return;
2027      CORE_ADDR struct_addr;
2028 {
2029   int i, j, oregnum;
2030   int accumulate_size = 0;
2031   struct sparc_arg
2032     {
2033       char *contents;
2034       int len;
2035       int offset;
2036     };
2037   struct sparc_arg *sparc_args =
2038     (struct sparc_arg *) alloca (nargs * sizeof (struct sparc_arg));
2039   struct sparc_arg *m_arg;
2040
2041   /* Promote arguments if necessary, and calculate their stack offsets
2042      and sizes. */
2043   for (i = 0, m_arg = sparc_args; i < nargs; i++, m_arg++)
2044     {
2045       value_ptr arg = args[i];
2046       struct type *arg_type = check_typedef (VALUE_TYPE (arg));
2047       /* Cast argument to long if necessary as the compiler does it too.  */
2048       switch (TYPE_CODE (arg_type))
2049         {
2050         case TYPE_CODE_INT:
2051         case TYPE_CODE_BOOL:
2052         case TYPE_CODE_CHAR:
2053         case TYPE_CODE_RANGE:
2054         case TYPE_CODE_ENUM:
2055           if (TYPE_LENGTH (arg_type) < TYPE_LENGTH (builtin_type_long))
2056             {
2057               arg_type = builtin_type_long;
2058               arg = value_cast (arg_type, arg);
2059             }
2060           break;
2061         default:
2062           break;
2063         }
2064       m_arg->len = TYPE_LENGTH (arg_type);
2065       m_arg->offset = accumulate_size;
2066       accumulate_size = (accumulate_size + m_arg->len + 3) & ~3;
2067       m_arg->contents = VALUE_CONTENTS (arg);
2068     }
2069
2070   /* Make room for the arguments on the stack.  */
2071   accumulate_size += CALL_DUMMY_STACK_ADJUST;
2072   sp = ((sp - accumulate_size) & ~7) + CALL_DUMMY_STACK_ADJUST;
2073
2074   /* `Push' arguments on the stack.  */
2075   for (i = 0, oregnum = 0, m_arg = sparc_args; 
2076        i < nargs;
2077        i++, m_arg++)
2078     {
2079       write_memory (sp + m_arg->offset, m_arg->contents, m_arg->len);
2080       for (j = 0; 
2081            j < m_arg->len && oregnum < 6; 
2082            j += SPARC_INTREG_SIZE, oregnum++)
2083         write_register_gen (O0_REGNUM + oregnum, m_arg->contents + j);
2084     }
2085
2086   return sp;
2087 }
2088
2089
2090 /* Extract from an array REGBUF containing the (raw) register state
2091    a function return value of type TYPE, and copy that, in virtual format,
2092    into VALBUF.  */
2093
2094 void
2095 sparc32_extract_return_value (type, regbuf, valbuf)
2096      struct type *type;
2097      char *regbuf;
2098      char *valbuf;
2099 {
2100   int typelen = TYPE_LENGTH (type);
2101   int regsize = REGISTER_RAW_SIZE (O0_REGNUM);
2102
2103   if (TYPE_CODE (type) == TYPE_CODE_FLT && SPARC_HAS_FPU)
2104     memcpy (valbuf, &regbuf[REGISTER_BYTE (FP0_REGNUM)], typelen);
2105   else
2106     memcpy (valbuf,
2107             &regbuf[O0_REGNUM * regsize +
2108                     (typelen >= regsize
2109                      || TARGET_BYTE_ORDER == LITTLE_ENDIAN ? 0
2110                      : regsize - typelen)],
2111             typelen);
2112 }
2113
2114
2115 /* Write into appropriate registers a function return value
2116    of type TYPE, given in virtual format.  On SPARCs with FPUs,
2117    float values are returned in %f0 (and %f1).  In all other cases,
2118    values are returned in register %o0.  */
2119
2120 void
2121 sparc_store_return_value (type, valbuf)
2122      struct type *type;
2123      char *valbuf;
2124 {
2125   int regno;
2126   char *buffer;
2127
2128   buffer = alloca(MAX_REGISTER_RAW_SIZE);
2129
2130   if (TYPE_CODE (type) == TYPE_CODE_FLT && SPARC_HAS_FPU)
2131     /* Floating-point values are returned in the register pair */
2132     /* formed by %f0 and %f1 (doubles are, anyway).  */
2133     regno = FP0_REGNUM;
2134   else
2135     /* Other values are returned in register %o0.  */
2136     regno = O0_REGNUM;
2137
2138   /* Add leading zeros to the value. */
2139   if (TYPE_LENGTH (type) < REGISTER_RAW_SIZE (regno))
2140     {
2141       memset (buffer, 0, REGISTER_RAW_SIZE (regno));
2142       memcpy (buffer + REGISTER_RAW_SIZE (regno) - TYPE_LENGTH (type), valbuf,
2143               TYPE_LENGTH (type));
2144       write_register_gen (regno, buffer);
2145     }
2146   else
2147     write_register_bytes (REGISTER_BYTE (regno), valbuf, TYPE_LENGTH (type));
2148 }
2149
2150 extern void
2151 sparclet_store_return_value (struct type *type, char *valbuf)
2152 {
2153   /* Other values are returned in register %o0.  */
2154   write_register_bytes (REGISTER_BYTE (O0_REGNUM), valbuf,
2155                         TYPE_LENGTH (type));
2156 }
2157
2158
2159 #ifndef CALL_DUMMY_CALL_OFFSET
2160 #define CALL_DUMMY_CALL_OFFSET \
2161      (gdbarch_tdep (current_gdbarch)->call_dummy_call_offset)
2162 #endif /* CALL_DUMMY_CALL_OFFSET */
2163
2164 /* Insert the function address into a call dummy instruction sequence
2165    stored at DUMMY.
2166
2167    For structs and unions, if the function was compiled with Sun cc,
2168    it expects 'unimp' after the call.  But gcc doesn't use that
2169    (twisted) convention.  So leave a nop there for gcc (FIX_CALL_DUMMY
2170    can assume it is operating on a pristine CALL_DUMMY, not one that
2171    has already been customized for a different function).  */
2172
2173 void
2174 sparc_fix_call_dummy (dummy, pc, fun, value_type, using_gcc)
2175      char *dummy;
2176      CORE_ADDR pc;
2177      CORE_ADDR fun;
2178      struct type *value_type;
2179      int using_gcc;
2180 {
2181   int i;
2182
2183   /* Store the relative adddress of the target function into the
2184      'call' instruction. */
2185   store_unsigned_integer (dummy + CALL_DUMMY_CALL_OFFSET, 4,
2186                           (0x40000000
2187                            | (((fun - (pc + CALL_DUMMY_CALL_OFFSET)) >> 2)
2188                               & 0x3fffffff)));
2189
2190   /* Comply with strange Sun cc calling convention for struct-returning
2191      functions.  */
2192   if (!using_gcc
2193       && (TYPE_CODE (value_type) == TYPE_CODE_STRUCT
2194           || TYPE_CODE (value_type) == TYPE_CODE_UNION))
2195     store_unsigned_integer (dummy + CALL_DUMMY_CALL_OFFSET + 8, 4,
2196                             TYPE_LENGTH (value_type) & 0x1fff);
2197
2198   if (!(GDB_TARGET_IS_SPARC64))
2199     {
2200       /* If this is not a simulator target, change the first four
2201          instructions of the call dummy to NOPs.  Those instructions
2202          include a 'save' instruction and are designed to work around
2203          problems with register window flushing in the simulator. */
2204       
2205       if (strcmp (target_shortname, "sim") != 0)
2206         {
2207           for (i = 0; i < 4; i++)
2208             store_unsigned_integer (dummy + (i * 4), 4, 0x01000000);
2209         }
2210     }
2211
2212   /* If this is a bi-endian target, GDB has written the call dummy
2213      in little-endian order.  We must byte-swap it back to big-endian. */
2214   if (bi_endian)
2215     {
2216       for (i = 0; i < CALL_DUMMY_LENGTH; i += 4)
2217         {
2218           char tmp = dummy[i];
2219           dummy[i] = dummy[i + 3];
2220           dummy[i + 3] = tmp;
2221           tmp = dummy[i + 1];
2222           dummy[i + 1] = dummy[i + 2];
2223           dummy[i + 2] = tmp;
2224         }
2225     }
2226 }
2227
2228
2229 /* Set target byte order based on machine type. */
2230
2231 static int
2232 sparc_target_architecture_hook (ap)
2233      const bfd_arch_info_type *ap;
2234 {
2235   int i, j;
2236
2237   if (ap->mach == bfd_mach_sparc_sparclite_le)
2238     {
2239       if (TARGET_BYTE_ORDER_SELECTABLE_P)
2240         {
2241           target_byte_order = LITTLE_ENDIAN;
2242           bi_endian = 1;
2243         }
2244       else
2245         {
2246           warning ("This GDB does not support little endian sparclite.");
2247         }
2248     }
2249   else
2250     bi_endian = 0;
2251   return 1;
2252 }
2253 \f
2254
2255 /*
2256  * Module "constructor" function. 
2257  */
2258
2259 static struct gdbarch * sparc_gdbarch_init (struct gdbarch_info info,
2260                                             struct gdbarch_list *arches);
2261
2262 void
2263 _initialize_sparc_tdep ()
2264 {
2265   /* Hook us into the gdbarch mechanism.  */
2266   register_gdbarch_init (bfd_arch_sparc, sparc_gdbarch_init);
2267
2268   tm_print_insn = gdb_print_insn_sparc;
2269   tm_print_insn_info.mach = TM_PRINT_INSN_MACH;         /* Selects sparc/sparclite */
2270   target_architecture_hook = sparc_target_architecture_hook;
2271 }
2272
2273 /* Compensate for stack bias. Note that we currently don't handle
2274    mixed 32/64 bit code. */
2275
2276 CORE_ADDR
2277 sparc64_read_sp (void)
2278 {
2279   CORE_ADDR sp = read_register (SP_REGNUM);
2280
2281   if (sp & 1)
2282     sp += 2047;
2283   return sp;
2284 }
2285
2286 CORE_ADDR
2287 sparc64_read_fp (void)
2288 {
2289   CORE_ADDR fp = read_register (FP_REGNUM);
2290
2291   if (fp & 1)
2292     fp += 2047;
2293   return fp;
2294 }
2295
2296 void
2297 sparc64_write_sp (val)
2298      CORE_ADDR val;
2299 {
2300   CORE_ADDR oldsp = read_register (SP_REGNUM);
2301   if (oldsp & 1)
2302     write_register (SP_REGNUM, val - 2047);
2303   else
2304     write_register (SP_REGNUM, val);
2305 }
2306
2307 void
2308 sparc64_write_fp (val)
2309      CORE_ADDR val;
2310 {
2311   CORE_ADDR oldfp = read_register (FP_REGNUM);
2312   if (oldfp & 1)
2313     write_register (FP_REGNUM, val - 2047);
2314   else
2315     write_register (FP_REGNUM, val);
2316 }
2317
2318 /* The SPARC 64 ABI passes floating-point arguments in FP0 to FP31,
2319    and all other arguments in O0 to O5.  They are also copied onto
2320    the stack in the correct places.  Apparently (empirically), 
2321    structs of less than 16 bytes are passed member-by-member in
2322    separate registers, but I am unable to figure out the algorithm.
2323    Some members go in floating point regs, but I don't know which.
2324
2325    FIXME: Handle small structs (less than 16 bytes containing floats).
2326
2327    The counting regimen for using both integer and FP registers
2328    for argument passing is rather odd -- a single counter is used
2329    for both; this means that if the arguments alternate between
2330    int and float, we will waste every other register of both types.  */
2331
2332 CORE_ADDR
2333 sparc64_push_arguments (nargs, args, sp, struct_return, struct_retaddr)
2334      int nargs;
2335      value_ptr *args;
2336      CORE_ADDR sp;
2337      int struct_return;
2338      CORE_ADDR struct_retaddr;
2339 {
2340   int i, j, register_counter = 0;
2341   CORE_ADDR tempsp;
2342   struct type *sparc_intreg_type = 
2343     TYPE_LENGTH (builtin_type_long) == SPARC_INTREG_SIZE ?
2344     builtin_type_long : builtin_type_long_long;
2345
2346   sp = (sp & ~(((unsigned long) SPARC_INTREG_SIZE) - 1UL));
2347
2348   /* Figure out how much space we'll need. */
2349   for (i = nargs - 1; i >= 0; i--)
2350     {
2351       int len = TYPE_LENGTH (check_typedef (VALUE_TYPE (args[i])));
2352       value_ptr copyarg = args[i];
2353       int copylen = len;
2354
2355       if (copylen < SPARC_INTREG_SIZE)
2356         {
2357           copyarg = value_cast (sparc_intreg_type, copyarg);
2358           copylen = SPARC_INTREG_SIZE;
2359         }
2360       sp -= copylen;
2361     }
2362
2363   /* Round down. */
2364   sp = sp & ~7;
2365   tempsp = sp;
2366
2367   /* if STRUCT_RETURN, then first argument is the struct return location. */
2368   if (struct_return)
2369     write_register (O0_REGNUM + register_counter++, struct_retaddr);
2370
2371   /* Now write the arguments onto the stack, while writing FP
2372      arguments into the FP registers, and other arguments into the
2373      first six 'O' registers.  */
2374
2375   for (i = 0; i < nargs; i++)
2376     {
2377       int len = TYPE_LENGTH (check_typedef (VALUE_TYPE (args[i])));
2378       value_ptr copyarg = args[i];
2379       enum type_code typecode = TYPE_CODE (VALUE_TYPE (args[i]));
2380       int copylen = len;
2381
2382       if (typecode == TYPE_CODE_INT   ||
2383           typecode == TYPE_CODE_BOOL  ||
2384           typecode == TYPE_CODE_CHAR  ||
2385           typecode == TYPE_CODE_RANGE ||
2386           typecode == TYPE_CODE_ENUM)
2387         if (len < SPARC_INTREG_SIZE)
2388           {
2389             /* Small ints will all take up the size of one intreg on
2390                the stack.  */
2391             copyarg = value_cast (sparc_intreg_type, copyarg);
2392             copylen = SPARC_INTREG_SIZE;
2393           }
2394
2395       write_memory (tempsp, VALUE_CONTENTS (copyarg), copylen);
2396       tempsp += copylen;
2397
2398       /* Corner case: Structs consisting of a single float member are floats.
2399        * FIXME!  I don't know about structs containing multiple floats!
2400        * Structs containing mixed floats and ints are even more weird.
2401        */
2402
2403
2404
2405       /* Separate float args from all other args.  */
2406       if (typecode == TYPE_CODE_FLT && SPARC_HAS_FPU)
2407         {
2408           if (register_counter < 16)
2409             {
2410               /* This arg gets copied into a FP register. */
2411               int fpreg;
2412
2413               switch (len) {
2414               case 4:   /* Single-precision (float) */
2415                 fpreg = FP0_REGNUM + 2 * register_counter + 1;
2416                 register_counter += 1;
2417                 break;
2418               case 8:   /* Double-precision (double) */
2419                 fpreg = FP0_REGNUM + 2 * register_counter;
2420                 register_counter += 1;
2421                 break;
2422               case 16:  /* Quad-precision (long double) */
2423                 fpreg = FP0_REGNUM + 2 * register_counter;
2424                 register_counter += 2;
2425                 break;
2426               }
2427               write_register_bytes (REGISTER_BYTE (fpreg),
2428                                     VALUE_CONTENTS (args[i]),
2429                                     len);
2430             }
2431         }
2432       else /* all other args go into the first six 'o' registers */
2433         {
2434           for (j = 0; 
2435                j < len && register_counter < 6; 
2436                j += SPARC_INTREG_SIZE)
2437             {
2438               int oreg = O0_REGNUM + register_counter;
2439
2440               write_register_gen (oreg, VALUE_CONTENTS (copyarg) + j);
2441               register_counter += 1;
2442             }
2443         }
2444     }
2445   return sp;
2446 }
2447
2448 /* Values <= 32 bytes are returned in o0-o3 (floating-point values are
2449    returned in f0-f3). */
2450
2451 void
2452 sp64_extract_return_value (type, regbuf, valbuf, bitoffset)
2453      struct type *type;
2454      char *regbuf;
2455      char *valbuf;
2456      int bitoffset;
2457 {
2458   int typelen = TYPE_LENGTH (type);
2459   int regsize = REGISTER_RAW_SIZE (O0_REGNUM);
2460
2461   if (TYPE_CODE (type) == TYPE_CODE_FLT && SPARC_HAS_FPU)
2462     {
2463       memcpy (valbuf, &regbuf[REGISTER_BYTE (FP0_REGNUM)], typelen);
2464       return;
2465     }
2466
2467   if (TYPE_CODE (type) != TYPE_CODE_STRUCT
2468       || (TYPE_LENGTH (type) > 32))
2469     {
2470       memcpy (valbuf,
2471               &regbuf[O0_REGNUM * regsize +
2472                       (typelen >= regsize ? 0 : regsize - typelen)],
2473               typelen);
2474       return;
2475     }
2476   else
2477     {
2478       char *o0 = &regbuf[O0_REGNUM * regsize];
2479       char *f0 = &regbuf[FP0_REGNUM * regsize];
2480       int x;
2481
2482       for (x = 0; x < TYPE_NFIELDS (type); x++)
2483         {
2484           struct field *f = &TYPE_FIELDS (type)[x];
2485           /* FIXME: We may need to handle static fields here. */
2486           int whichreg = (f->loc.bitpos + bitoffset) / 32;
2487           int remainder = ((f->loc.bitpos + bitoffset) % 32) / 8;
2488           int where = (f->loc.bitpos + bitoffset) / 8;
2489           int size = TYPE_LENGTH (f->type);
2490           int typecode = TYPE_CODE (f->type);
2491
2492           if (typecode == TYPE_CODE_STRUCT)
2493             {
2494               sp64_extract_return_value (f->type,
2495                                          regbuf,
2496                                          valbuf,
2497                                          bitoffset + f->loc.bitpos);
2498             }
2499           else if (typecode == TYPE_CODE_FLT && SPARC_HAS_FPU)
2500             {
2501               memcpy (valbuf + where, &f0[whichreg * 4] + remainder, size);
2502             }
2503           else
2504             {
2505               memcpy (valbuf + where, &o0[whichreg * 4] + remainder, size);
2506             }
2507         }
2508     }
2509 }
2510
2511 extern void
2512 sparc64_extract_return_value (struct type *type, char *regbuf, char *valbuf)
2513 {
2514   sp64_extract_return_value (type, regbuf, valbuf, 0);
2515 }
2516
2517 extern void 
2518 sparclet_extract_return_value (struct type *type,
2519                                char *regbuf, 
2520                                char *valbuf)
2521 {
2522   regbuf += REGISTER_RAW_SIZE (O0_REGNUM) * 8;
2523   if (TYPE_LENGTH (type) < REGISTER_RAW_SIZE (O0_REGNUM))
2524     regbuf += REGISTER_RAW_SIZE (O0_REGNUM) - TYPE_LENGTH (type);
2525
2526   memcpy ((void *) valbuf, regbuf, TYPE_LENGTH (type));
2527 }
2528
2529
2530 extern CORE_ADDR
2531 sparc32_stack_align (CORE_ADDR addr)
2532 {
2533   return ((addr + 7) & -8);
2534 }
2535
2536 extern CORE_ADDR
2537 sparc64_stack_align (CORE_ADDR addr)
2538 {
2539   return ((addr + 15) & -16);
2540 }
2541
2542 extern void
2543 sparc_print_extra_frame_info (struct frame_info *fi)
2544 {
2545   if (fi && fi->extra_info && fi->extra_info->flat)
2546     printf_filtered (" flat, pc saved at 0x%s, fp saved at 0x%s\n",
2547                      paddr_nz (fi->extra_info->pc_addr), 
2548                      paddr_nz (fi->extra_info->fp_addr));
2549 }
2550
2551 /* MULTI_ARCH support */
2552
2553 static char *
2554 sparc32_register_name (int regno)
2555 {
2556   static char *register_names[] = 
2557   { "g0", "g1", "g2", "g3", "g4", "g5", "g6", "g7",
2558     "o0", "o1", "o2", "o3", "o4", "o5", "sp", "o7",
2559     "l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7",
2560     "i0", "i1", "i2", "i3", "i4", "i5", "fp", "i7",
2561
2562     "f0",  "f1",  "f2",  "f3",  "f4",  "f5",  "f6",  "f7",
2563     "f8",  "f9",  "f10", "f11", "f12", "f13", "f14", "f15",
2564     "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
2565     "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
2566
2567     "y", "psr", "wim", "tbr", "pc", "npc", "fpsr", "cpsr"
2568   };
2569
2570   if (regno < 0 ||
2571       regno >= (sizeof (register_names) / sizeof (register_names[0])))
2572     return NULL;
2573   else
2574     return register_names[regno];
2575 }
2576
2577 static char *
2578 sparc64_register_name (int regno)
2579 {
2580   static char *register_names[] = 
2581   { "g0", "g1", "g2", "g3", "g4", "g5", "g6", "g7",
2582     "o0", "o1", "o2", "o3", "o4", "o5", "sp", "o7",
2583     "l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7",
2584     "i0", "i1", "i2", "i3", "i4", "i5", "fp", "i7",
2585
2586     "f0",  "f1",  "f2",  "f3",  "f4",  "f5",  "f6",  "f7",
2587     "f8",  "f9",  "f10", "f11", "f12", "f13", "f14", "f15",
2588     "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
2589     "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
2590     "f32", "f34", "f36", "f38", "f40", "f42", "f44", "f46",
2591     "f48", "f50", "f52", "f54", "f56", "f58", "f60", "f62",
2592
2593     "pc", "npc", "ccr", "fsr", "fprs", "y", "asi", "ver", 
2594     "tick", "pil", "pstate", "tstate", "tba", "tl", "tt", "tpc", 
2595     "tnpc", "wstate", "cwp", "cansave", "canrestore", "cleanwin", "otherwin",
2596     "asr16", "asr17", "asr18", "asr19", "asr20", "asr21", "asr22", "asr23", 
2597     "asr24", "asr25", "asr26", "asr27", "asr28", "asr29", "asr30", "asr31",
2598     /* These are here at the end to simplify removing them if we have to.  */
2599     "icc", "xcc", "fcc0", "fcc1", "fcc2", "fcc3"
2600   };
2601
2602   if (regno < 0 ||
2603       regno >= (sizeof (register_names) / sizeof (register_names[0])))
2604     return NULL;
2605   else
2606     return register_names[regno];
2607 }
2608
2609 static char *
2610 sparclite_register_name (int regno)
2611 {
2612   static char *register_names[] = 
2613   { "g0", "g1", "g2", "g3", "g4", "g5", "g6", "g7",
2614     "o0", "o1", "o2", "o3", "o4", "o5", "sp", "o7",
2615     "l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7",
2616     "i0", "i1", "i2", "i3", "i4", "i5", "fp", "i7",
2617
2618     "f0",  "f1",  "f2",  "f3",  "f4",  "f5",  "f6",  "f7",
2619     "f8",  "f9",  "f10", "f11", "f12", "f13", "f14", "f15",
2620     "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
2621     "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
2622
2623     "y", "psr", "wim", "tbr", "pc", "npc", "fpsr", "cpsr",
2624     "dia1", "dia2", "dda1", "dda2", "ddv1", "ddv2", "dcr", "dsr" 
2625   };
2626
2627   if (regno < 0 ||
2628       regno >= (sizeof (register_names) / sizeof (register_names[0])))
2629     return NULL;
2630   else
2631     return register_names[regno];
2632 }
2633
2634 static char *
2635 sparclet_register_name (int regno)
2636 {
2637   static char *register_names[] = 
2638   { "g0", "g1", "g2", "g3", "g4", "g5", "g6", "g7",
2639     "o0", "o1", "o2", "o3", "o4", "o5", "sp", "o7",
2640     "l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7",
2641     "i0", "i1", "i2", "i3", "i4", "i5", "fp", "i7",
2642
2643     "", "", "", "", "", "", "", "", /* no floating point registers */
2644     "", "", "", "", "", "", "", "",
2645     "", "", "", "", "", "", "", "",
2646     "", "", "", "", "", "", "", "",
2647
2648     "y", "psr", "wim", "tbr", "pc", "npc", "", "", /* no FPSR or CPSR */
2649     "ccsr", "ccpr", "cccrcr", "ccor", "ccobr", "ccibr", "ccir", "", 
2650
2651     /*       ASR15                 ASR19 (don't display them) */    
2652     "asr1",  "", "asr17", "asr18", "", "asr20", "asr21", "asr22"
2653     /* None of the rest get displayed */
2654 #if 0
2655     "awr0",  "awr1",  "awr2",  "awr3",  "awr4",  "awr5",  "awr6",  "awr7",  
2656     "awr8",  "awr9",  "awr10", "awr11", "awr12", "awr13", "awr14", "awr15", 
2657     "awr16", "awr17", "awr18", "awr19", "awr20", "awr21", "awr22", "awr23", 
2658     "awr24", "awr25", "awr26", "awr27", "awr28", "awr29", "awr30", "awr31", 
2659     "apsr"
2660 #endif /* 0 */
2661   };
2662
2663   if (regno < 0 ||
2664       regno >= (sizeof (register_names) / sizeof (register_names[0])))
2665     return NULL;
2666   else
2667     return register_names[regno];
2668 }
2669
2670 CORE_ADDR
2671 sparc_push_return_address (CORE_ADDR pc_unused, CORE_ADDR sp)
2672 {
2673   if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT)
2674     {
2675       /* The return PC of the dummy_frame is the former 'current' PC
2676          (where we were before we made the target function call).
2677          This is saved in %i7 by push_dummy_frame.
2678
2679          We will save the 'call dummy location' (ie. the address
2680          to which the target function will return) in %o7.  
2681          This address will actually be the program's entry point.  
2682          There will be a special call_dummy breakpoint there.  */
2683
2684       write_register (O7_REGNUM, 
2685                       CALL_DUMMY_ADDRESS () - 8);
2686     }
2687
2688   return sp;
2689 }
2690
2691 /* Should call_function allocate stack space for a struct return?  */
2692
2693 static int
2694 sparc64_use_struct_convention (int gcc_p, struct type *type)
2695 {
2696   return (TYPE_LENGTH (type) > 32);
2697 }
2698
2699 /* Store the address of the place in which to copy the structure the
2700    subroutine will return.  This is called from call_function_by_hand.
2701    The ultimate mystery is, tho, what is the value "16"?
2702
2703    MVS: That's the offset from where the sp is now, to where the
2704    subroutine is gonna expect to find the struct return address.  */
2705
2706 static void
2707 sparc32_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
2708 {
2709   char *val;
2710   CORE_ADDR o7;
2711
2712   val = alloca (SPARC_INTREG_SIZE); 
2713   store_unsigned_integer (val, SPARC_INTREG_SIZE, addr);
2714   write_memory (sp + (16 * SPARC_INTREG_SIZE), val, SPARC_INTREG_SIZE); 
2715
2716   if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT)
2717     {
2718       /* Now adjust the value of the link register, which was previously
2719          stored by push_return_address.  Functions that return structs are
2720          peculiar in that they return to link register + 12, rather than
2721          link register + 8.  */
2722
2723       o7 = read_register (O7_REGNUM);
2724       write_register (O7_REGNUM, o7 - 4);
2725     }
2726 }
2727
2728 static void
2729 sparc64_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
2730 {
2731   /* FIXME: V9 uses %o0 for this.  */
2732   /* FIXME MVS: Only for small enough structs!!! */
2733
2734   target_write_memory (sp + (16 * SPARC_INTREG_SIZE), 
2735                        (char *) &addr, SPARC_INTREG_SIZE); 
2736 #if 0
2737   if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT)
2738     {
2739       /* Now adjust the value of the link register, which was previously
2740          stored by push_return_address.  Functions that return structs are
2741          peculiar in that they return to link register + 12, rather than
2742          link register + 8.  */
2743
2744       write_register (O7_REGNUM, read_register (O7_REGNUM) - 4);
2745     }
2746 #endif
2747 }
2748
2749 /* Default target data type for register REGNO.  */
2750
2751 static struct type *
2752 sparc32_register_virtual_type (int regno)
2753 {
2754   if (regno == PC_REGNUM ||
2755       regno == FP_REGNUM ||
2756       regno == SP_REGNUM)
2757     return builtin_type_unsigned_int;
2758   if (regno < 32)
2759     return builtin_type_int;
2760   if (regno < 64)
2761     return builtin_type_float;
2762   return builtin_type_int;
2763 }
2764
2765 static struct type *
2766 sparc64_register_virtual_type (int regno)
2767 {
2768   if (regno == PC_REGNUM ||
2769       regno == FP_REGNUM ||
2770       regno == SP_REGNUM)
2771     return builtin_type_unsigned_long_long;
2772   if (regno < 32)
2773     return builtin_type_long_long;
2774   if (regno < 64)
2775     return builtin_type_float;
2776   if (regno < 80)
2777     return builtin_type_double;
2778   return builtin_type_long_long;
2779 }
2780
2781 /* Number of bytes of storage in the actual machine representation for
2782    register REGNO.  */
2783
2784 static int
2785 sparc32_register_size (int regno)
2786 {
2787   return 4;
2788 }
2789
2790 static int
2791 sparc64_register_size (int regno)
2792 {
2793   return (regno < 32 ? 8 : regno < 64 ? 4 : 8);
2794 }
2795
2796 /* Index within the `registers' buffer of the first byte of the space
2797    for register REGNO.  */
2798
2799 static int
2800 sparc32_register_byte (int regno)
2801 {
2802   return (regno * 4);
2803 }
2804
2805 static int
2806 sparc64_register_byte (int regno)
2807 {
2808   if (regno < 32)
2809     return regno * 8;
2810   else if (regno < 64)
2811     return 32 * 8 + (regno - 32) * 4;
2812   else if (regno < 80)
2813     return 32 * 8 + 32 * 4 + (regno - 64) * 8;
2814   else
2815     return 64 * 8 + (regno - 80) * 8;
2816 }
2817
2818 /* Advance PC across any function entry prologue instructions to reach
2819    some "real" code.  SKIP_PROLOGUE_FRAMELESS_P advances the PC past
2820    some of the prologue, but stops as soon as it knows that the
2821    function has a frame.  Its result is equal to its input PC if the
2822    function is frameless, unequal otherwise.  */
2823
2824 static CORE_ADDR
2825 sparc_gdbarch_skip_prologue (CORE_ADDR ip)
2826 {
2827   return examine_prologue (ip, 0, NULL, NULL);
2828 }
2829
2830 /* Immediately after a function call, return the saved pc.
2831    Can't go through the frames for this because on some machines
2832    the new frame is not set up until the new function executes
2833    some instructions.  */
2834
2835 static CORE_ADDR
2836 sparc_saved_pc_after_call (struct frame_info *fi)
2837 {
2838   return sparc_pc_adjust (read_register (RP_REGNUM));
2839 }
2840
2841 /* Convert registers between 'raw' and 'virtual' formats.
2842    They are the same on sparc, so there's nothing to do.  */
2843
2844 static void
2845 sparc_convert_to_virtual (int regnum, struct type *type, char *from, char *to)
2846 {       /* do nothing (should never be called) */
2847 }
2848
2849 static void
2850 sparc_convert_to_raw (struct type *type, int regnum, char *from, char *to)
2851 {       /* do nothing (should never be called) */
2852 }
2853
2854 /* Init saved regs: nothing to do, just a place-holder function.  */
2855
2856 static void
2857 sparc_frame_init_saved_regs (struct frame_info *fi_ignored)
2858 {       /* no-op */
2859 }
2860
2861 /* The frame address: stored in the 'frame' field of the frame_info.  */
2862
2863 static CORE_ADDR
2864 sparc_frame_address (struct frame_info *fi)
2865 {
2866   return fi->frame;
2867 }
2868
2869 /* gdbarch fix call dummy:
2870    All this function does is rearrange the arguments before calling
2871    sparc_fix_call_dummy (which does the real work).  */
2872
2873 static void
2874 sparc_gdbarch_fix_call_dummy (char *dummy, 
2875                               CORE_ADDR pc, 
2876                               CORE_ADDR fun, 
2877                               int nargs, 
2878                               struct value **args, 
2879                               struct type *type, 
2880                               int gcc_p)
2881 {
2882   if (CALL_DUMMY_LOCATION == ON_STACK)
2883     sparc_fix_call_dummy (dummy, pc, fun, type, gcc_p);
2884 }
2885
2886 /* Coerce float to double: a no-op.  */
2887
2888 static int
2889 sparc_coerce_float_to_double (struct type *formal, struct type *actual)
2890 {
2891   return 1;
2892 }
2893
2894 /* CALL_DUMMY_ADDRESS: fetch the breakpoint address for a call dummy.  */
2895
2896 static CORE_ADDR
2897 sparc_call_dummy_address (void)
2898 {
2899   return (CALL_DUMMY_START_OFFSET) + CALL_DUMMY_BREAKPOINT_OFFSET;
2900 }
2901
2902 /* Supply the Y register number to those that need it.  */
2903
2904 int
2905 sparc_y_regnum (void)
2906 {
2907   return gdbarch_tdep (current_gdbarch)->y_regnum;
2908 }
2909
2910 int
2911 sparc_reg_struct_has_addr (int gcc_p, struct type *type)
2912 {
2913   if (GDB_TARGET_IS_SPARC64)
2914     return (TYPE_LENGTH (type) > 32);
2915   else
2916     return (gcc_p != 1);
2917 }
2918
2919 int
2920 sparc_intreg_size (void)
2921 {
2922   return SPARC_INTREG_SIZE;
2923 }
2924
2925 static int
2926 sparc_return_value_on_stack (struct type *type)
2927 {
2928   if (TYPE_CODE (type) == TYPE_CODE_FLT &&
2929       TYPE_LENGTH (type) > 8)
2930     return 1;
2931   else
2932     return 0;
2933 }
2934
2935 /*
2936  * Gdbarch "constructor" function.
2937  */
2938
2939 #define SPARC32_CALL_DUMMY_ON_STACK
2940
2941 #define SPARC_SP_REGNUM    14
2942 #define SPARC_FP_REGNUM    30
2943 #define SPARC_FP0_REGNUM   32
2944 #define SPARC32_NPC_REGNUM 69
2945 #define SPARC32_PC_REGNUM  68
2946 #define SPARC32_Y_REGNUM   64
2947 #define SPARC64_PC_REGNUM  80
2948 #define SPARC64_NPC_REGNUM 81
2949 #define SPARC64_Y_REGNUM   85
2950
2951 static struct gdbarch *
2952 sparc_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
2953 {
2954   struct gdbarch *gdbarch;
2955   struct gdbarch_tdep *tdep;
2956
2957   static LONGEST call_dummy_32[] = 
2958     { 0xbc100001, 0x9de38000, 0xbc100002, 0xbe100003,
2959       0xda03a058, 0xd803a054, 0xd603a050, 0xd403a04c,
2960       0xd203a048, 0x40000000, 0xd003a044, 0x01000000,
2961       0x91d02001, 0x01000000
2962     };
2963   static LONGEST call_dummy_64[] = 
2964     { 0x9de3bec0fd3fa7f7LL, 0xf93fa7eff53fa7e7LL,
2965       0xf13fa7dfed3fa7d7LL, 0xe93fa7cfe53fa7c7LL,
2966       0xe13fa7bfdd3fa7b7LL, 0xd93fa7afd53fa7a7LL,
2967       0xd13fa79fcd3fa797LL, 0xc93fa78fc53fa787LL,
2968       0xc13fa77fcc3fa777LL, 0xc83fa76fc43fa767LL,
2969       0xc03fa75ffc3fa757LL, 0xf83fa74ff43fa747LL,
2970       0xf03fa73f01000000LL, 0x0100000001000000LL,
2971       0x0100000091580000LL, 0xd027a72b93500000LL,
2972       0xd027a72791480000LL, 0xd027a72391400000LL,
2973       0xd027a71fda5ba8a7LL, 0xd85ba89fd65ba897LL,
2974       0xd45ba88fd25ba887LL, 0x9fc02000d05ba87fLL,
2975       0x0100000091d02001LL, 0x0100000001000000LL 
2976     };
2977   static LONGEST call_dummy_nil[] = {0};
2978
2979   /* First see if there is already a gdbarch that can satisfy the request.  */
2980   arches = gdbarch_list_lookup_by_info (arches, &info);
2981   if (arches != NULL)
2982     return arches->gdbarch;
2983
2984   /* None found: is the request for a sparc architecture? */
2985   if (info.bfd_architecture != bfd_arch_sparc)
2986     return NULL;        /* No; then it's not for us.  */
2987
2988   /* Yes: create a new gdbarch for the specified machine type.  */
2989   tdep = (struct gdbarch_tdep *) xmalloc (sizeof (struct gdbarch_tdep));
2990   gdbarch = gdbarch_alloc (&info, tdep);
2991
2992   /* First set settings that are common for all sparc architectures.  */
2993   set_gdbarch_believe_pcc_promotion (gdbarch, 1);
2994   set_gdbarch_breakpoint_from_pc (gdbarch, memory_breakpoint_from_pc);
2995   set_gdbarch_coerce_float_to_double (gdbarch, 
2996                                       sparc_coerce_float_to_double);
2997   set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 1);
2998   set_gdbarch_call_dummy_p (gdbarch, 1);
2999   set_gdbarch_call_dummy_stack_adjust_p (gdbarch, 1);
3000   set_gdbarch_decr_pc_after_break (gdbarch, 0);
3001   set_gdbarch_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
3002   set_gdbarch_extract_struct_value_address (gdbarch, 
3003                                             sparc_extract_struct_value_address);
3004   set_gdbarch_fix_call_dummy (gdbarch, sparc_gdbarch_fix_call_dummy);
3005   set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
3006   set_gdbarch_fp_regnum (gdbarch, SPARC_FP_REGNUM);
3007   set_gdbarch_fp0_regnum (gdbarch, SPARC_FP0_REGNUM);
3008   set_gdbarch_frame_args_address (gdbarch, sparc_frame_address);
3009   set_gdbarch_frame_chain (gdbarch, sparc_frame_chain);
3010   set_gdbarch_frame_init_saved_regs (gdbarch, sparc_frame_init_saved_regs);
3011   set_gdbarch_frame_locals_address (gdbarch, sparc_frame_address);
3012   set_gdbarch_frame_num_args (gdbarch, frame_num_args_unknown);
3013   set_gdbarch_frame_saved_pc (gdbarch, sparc_frame_saved_pc);
3014   set_gdbarch_frameless_function_invocation (gdbarch, 
3015                                              frameless_look_for_prologue);
3016   set_gdbarch_get_saved_register (gdbarch, sparc_get_saved_register);
3017   set_gdbarch_ieee_float (gdbarch, 1);
3018   set_gdbarch_init_extra_frame_info (gdbarch, sparc_init_extra_frame_info);
3019   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
3020   set_gdbarch_int_bit (gdbarch, 4 * TARGET_CHAR_BIT);
3021   set_gdbarch_long_double_bit (gdbarch, 16 * TARGET_CHAR_BIT);
3022   set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
3023   set_gdbarch_max_register_raw_size (gdbarch, 8);
3024   set_gdbarch_max_register_virtual_size (gdbarch, 8);
3025 #ifdef DO_CALL_DUMMY_ON_STACK
3026   set_gdbarch_pc_in_call_dummy (gdbarch, pc_in_call_dummy_on_stack);
3027 #else
3028   set_gdbarch_pc_in_call_dummy (gdbarch, pc_in_call_dummy_at_entry_point);
3029 #endif
3030   set_gdbarch_pop_frame (gdbarch, sparc_pop_frame);
3031   set_gdbarch_push_return_address (gdbarch, sparc_push_return_address);
3032   set_gdbarch_push_dummy_frame (gdbarch, sparc_push_dummy_frame);
3033   set_gdbarch_read_pc (gdbarch, generic_target_read_pc);
3034   set_gdbarch_register_convert_to_raw (gdbarch, sparc_convert_to_raw);
3035   set_gdbarch_register_convert_to_virtual (gdbarch, 
3036                                            sparc_convert_to_virtual);
3037   set_gdbarch_register_convertible (gdbarch, 
3038                                     generic_register_convertible_not);
3039   set_gdbarch_reg_struct_has_addr (gdbarch, sparc_reg_struct_has_addr);
3040   set_gdbarch_return_value_on_stack (gdbarch, sparc_return_value_on_stack);
3041   set_gdbarch_saved_pc_after_call (gdbarch, sparc_saved_pc_after_call);
3042   set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
3043   set_gdbarch_skip_prologue (gdbarch, sparc_gdbarch_skip_prologue);
3044   set_gdbarch_sp_regnum (gdbarch, SPARC_SP_REGNUM);
3045   set_gdbarch_use_generic_dummy_frames (gdbarch, 0);
3046   set_gdbarch_write_pc (gdbarch, generic_target_write_pc);
3047
3048   /*
3049    * Settings that depend only on 32/64 bit word size 
3050    */
3051
3052   switch (info.bfd_arch_info->mach)
3053     {
3054     case bfd_mach_sparc:
3055     case bfd_mach_sparc_sparclet:
3056     case bfd_mach_sparc_sparclite:
3057     case bfd_mach_sparc_v8plus:
3058     case bfd_mach_sparc_v8plusa:
3059     case bfd_mach_sparc_sparclite_le:
3060       /* 32-bit machine types: */
3061
3062 #ifdef SPARC32_CALL_DUMMY_ON_STACK
3063       set_gdbarch_call_dummy_address (gdbarch, sparc_call_dummy_address);
3064       set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 0x30);
3065       set_gdbarch_call_dummy_length (gdbarch, 0x38);
3066       set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
3067       set_gdbarch_call_dummy_words (gdbarch, call_dummy_32);
3068 #else
3069       set_gdbarch_call_dummy_address (gdbarch, entry_point_address);
3070       set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 0);
3071       set_gdbarch_call_dummy_length (gdbarch, 0);
3072       set_gdbarch_call_dummy_location (gdbarch, AT_ENTRY_POINT);
3073       set_gdbarch_call_dummy_words (gdbarch, call_dummy_nil);
3074 #endif
3075       set_gdbarch_call_dummy_stack_adjust (gdbarch, 68);
3076       set_gdbarch_call_dummy_start_offset (gdbarch, 0);
3077       set_gdbarch_frame_args_skip (gdbarch, 68);
3078       set_gdbarch_function_start_offset (gdbarch, 0);
3079       set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
3080       set_gdbarch_npc_regnum (gdbarch, SPARC32_NPC_REGNUM);
3081       set_gdbarch_pc_regnum (gdbarch, SPARC32_PC_REGNUM);
3082       set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
3083       set_gdbarch_push_arguments (gdbarch, sparc32_push_arguments);
3084       set_gdbarch_read_fp (gdbarch, generic_target_read_fp);
3085       set_gdbarch_read_sp (gdbarch, generic_target_read_sp);
3086
3087       set_gdbarch_register_byte (gdbarch, sparc32_register_byte);
3088       set_gdbarch_register_raw_size (gdbarch, sparc32_register_size);
3089       set_gdbarch_register_size (gdbarch, 4);
3090       set_gdbarch_register_virtual_size (gdbarch, sparc32_register_size);
3091       set_gdbarch_register_virtual_type (gdbarch, 
3092                                          sparc32_register_virtual_type);
3093 #ifdef SPARC32_CALL_DUMMY_ON_STACK
3094       set_gdbarch_sizeof_call_dummy_words (gdbarch, sizeof (call_dummy_32));
3095 #else
3096       set_gdbarch_sizeof_call_dummy_words (gdbarch, 0);
3097 #endif
3098       set_gdbarch_stack_align (gdbarch, sparc32_stack_align);
3099       set_gdbarch_store_struct_return (gdbarch, sparc32_store_struct_return);
3100       set_gdbarch_use_struct_convention (gdbarch, 
3101                                          generic_use_struct_convention);
3102       set_gdbarch_write_fp (gdbarch, generic_target_write_fp);
3103       set_gdbarch_write_sp (gdbarch, generic_target_write_sp);
3104       tdep->y_regnum = SPARC32_Y_REGNUM;
3105       tdep->fp_max_regnum = SPARC_FP0_REGNUM + 32;
3106       tdep->intreg_size = 4;
3107       tdep->reg_save_offset = 0x60;
3108       tdep->call_dummy_call_offset = 0x24;
3109       break;
3110
3111     case bfd_mach_sparc_v9:
3112     case bfd_mach_sparc_v9a:
3113       /* 64-bit machine types: */
3114     default:    /* Any new machine type is likely to be 64-bit.  */
3115
3116 #ifdef SPARC64_CALL_DUMMY_ON_STACK
3117       set_gdbarch_call_dummy_address (gdbarch, sparc_call_dummy_address);
3118       set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 8 * 4);
3119       set_gdbarch_call_dummy_length (gdbarch, 192);
3120       set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
3121       set_gdbarch_call_dummy_start_offset (gdbarch, 148);
3122       set_gdbarch_call_dummy_words (gdbarch, call_dummy_64);
3123 #else
3124       set_gdbarch_call_dummy_address (gdbarch, entry_point_address);
3125       set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 0);
3126       set_gdbarch_call_dummy_length (gdbarch, 0);
3127       set_gdbarch_call_dummy_location (gdbarch, AT_ENTRY_POINT);
3128       set_gdbarch_call_dummy_start_offset (gdbarch, 0);
3129       set_gdbarch_call_dummy_words (gdbarch, call_dummy_nil);
3130 #endif
3131       set_gdbarch_call_dummy_stack_adjust (gdbarch, 128);
3132       set_gdbarch_frame_args_skip (gdbarch, 136);
3133       set_gdbarch_function_start_offset (gdbarch, 0);
3134       set_gdbarch_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
3135       set_gdbarch_npc_regnum (gdbarch, SPARC64_NPC_REGNUM);
3136       set_gdbarch_pc_regnum (gdbarch, SPARC64_PC_REGNUM);
3137       set_gdbarch_ptr_bit (gdbarch, 8 * TARGET_CHAR_BIT);
3138       set_gdbarch_push_arguments (gdbarch, sparc64_push_arguments);
3139       /* NOTE different for at_entry */
3140       set_gdbarch_read_fp (gdbarch, sparc64_read_fp);
3141       set_gdbarch_read_sp (gdbarch, sparc64_read_sp);
3142       /* Some of the registers aren't 64 bits, but it's a lot simpler just
3143          to assume they all are (since most of them are).  */
3144       set_gdbarch_register_byte (gdbarch, sparc64_register_byte);
3145       set_gdbarch_register_raw_size (gdbarch, sparc64_register_size);
3146       set_gdbarch_register_size (gdbarch, 8);
3147       set_gdbarch_register_virtual_size (gdbarch, sparc64_register_size);
3148       set_gdbarch_register_virtual_type (gdbarch, 
3149                                          sparc64_register_virtual_type);
3150 #ifdef SPARC64_CALL_DUMMY_ON_STACK
3151       set_gdbarch_sizeof_call_dummy_words (gdbarch, sizeof (call_dummy_64));
3152 #else
3153       set_gdbarch_sizeof_call_dummy_words (gdbarch, 0);
3154 #endif
3155       set_gdbarch_stack_align (gdbarch, sparc64_stack_align);
3156       set_gdbarch_store_struct_return (gdbarch, sparc64_store_struct_return);
3157       set_gdbarch_use_struct_convention (gdbarch, 
3158                                          sparc64_use_struct_convention);
3159       set_gdbarch_write_fp (gdbarch, sparc64_write_fp);
3160       set_gdbarch_write_sp (gdbarch, sparc64_write_sp);
3161       tdep->y_regnum = SPARC64_Y_REGNUM;
3162       tdep->fp_max_regnum = SPARC_FP0_REGNUM + 48;
3163       tdep->intreg_size = 8;
3164       tdep->reg_save_offset = 0x90;
3165       tdep->call_dummy_call_offset = 148 + 4 * 5;
3166       break;
3167     }
3168
3169   /* 
3170    * Settings that vary per-architecture:
3171    */
3172
3173   switch (info.bfd_arch_info->mach)
3174     {
3175     case bfd_mach_sparc:
3176       set_gdbarch_extract_return_value (gdbarch, sparc32_extract_return_value);
3177       set_gdbarch_frame_chain_valid (gdbarch, file_frame_chain_valid);
3178       set_gdbarch_num_regs (gdbarch, 72);
3179       set_gdbarch_register_bytes (gdbarch, 32*4 + 32*4 + 8*4);
3180       set_gdbarch_register_name (gdbarch, sparc32_register_name);
3181       set_gdbarch_store_return_value (gdbarch, sparc_store_return_value);
3182       tdep->has_fpu = 1;        /* (all but sparclet and sparclite) */
3183       tdep->fp_register_bytes = 32 * 4;
3184       tdep->print_insn_mach = bfd_mach_sparc;
3185       break;
3186     case bfd_mach_sparc_sparclet:
3187       set_gdbarch_extract_return_value (gdbarch, 
3188                                         sparclet_extract_return_value);
3189       set_gdbarch_frame_chain_valid (gdbarch, file_frame_chain_valid);
3190       set_gdbarch_num_regs (gdbarch, 32 + 32 + 8 + 8 + 8);
3191       set_gdbarch_register_bytes (gdbarch, 32*4 + 32*4 + 8*4 + 8*4 + 8*4);
3192       set_gdbarch_register_name (gdbarch, sparclet_register_name);
3193       set_gdbarch_store_return_value (gdbarch, sparclet_store_return_value);
3194       tdep->has_fpu = 0;        /* (all but sparclet and sparclite) */
3195       tdep->fp_register_bytes = 0;
3196       tdep->print_insn_mach = bfd_mach_sparc_sparclet;
3197       break;
3198     case bfd_mach_sparc_sparclite:
3199       set_gdbarch_extract_return_value (gdbarch, sparc32_extract_return_value);
3200       set_gdbarch_frame_chain_valid (gdbarch, func_frame_chain_valid);
3201       set_gdbarch_num_regs (gdbarch, 80);
3202       set_gdbarch_register_bytes (gdbarch, 32*4 + 32*4 + 8*4 + 8*4);
3203       set_gdbarch_register_name (gdbarch, sparclite_register_name);
3204       set_gdbarch_store_return_value (gdbarch, sparc_store_return_value);
3205       tdep->has_fpu = 0;        /* (all but sparclet and sparclite) */
3206       tdep->fp_register_bytes = 0;
3207       tdep->print_insn_mach = bfd_mach_sparc_sparclite;
3208       break;
3209     case bfd_mach_sparc_v8plus:
3210       set_gdbarch_extract_return_value (gdbarch, sparc32_extract_return_value);
3211       set_gdbarch_frame_chain_valid (gdbarch, file_frame_chain_valid);
3212       set_gdbarch_num_regs (gdbarch, 72);
3213       set_gdbarch_register_bytes (gdbarch, 32*4 + 32*4 + 8*4);
3214       set_gdbarch_register_name (gdbarch, sparc32_register_name);
3215       set_gdbarch_store_return_value (gdbarch, sparc_store_return_value);
3216       tdep->print_insn_mach = bfd_mach_sparc;
3217       tdep->fp_register_bytes = 32 * 4;
3218       tdep->has_fpu = 1;        /* (all but sparclet and sparclite) */
3219       break;
3220     case bfd_mach_sparc_v8plusa:
3221       set_gdbarch_extract_return_value (gdbarch, sparc32_extract_return_value);
3222       set_gdbarch_frame_chain_valid (gdbarch, file_frame_chain_valid);
3223       set_gdbarch_num_regs (gdbarch, 72);
3224       set_gdbarch_register_bytes (gdbarch, 32*4 + 32*4 + 8*4);
3225       set_gdbarch_register_name (gdbarch, sparc32_register_name);
3226       set_gdbarch_store_return_value (gdbarch, sparc_store_return_value);
3227       tdep->has_fpu = 1;        /* (all but sparclet and sparclite) */
3228       tdep->fp_register_bytes = 32 * 4;
3229       tdep->print_insn_mach = bfd_mach_sparc;
3230       break;
3231     case bfd_mach_sparc_sparclite_le:
3232       set_gdbarch_extract_return_value (gdbarch, sparc32_extract_return_value);
3233       set_gdbarch_frame_chain_valid (gdbarch, func_frame_chain_valid);
3234       set_gdbarch_num_regs (gdbarch, 80);
3235       set_gdbarch_register_bytes (gdbarch, 32*4 + 32*4 + 8*4 + 8*4);
3236       set_gdbarch_register_name (gdbarch, sparclite_register_name);
3237       set_gdbarch_store_return_value (gdbarch, sparc_store_return_value);
3238       tdep->has_fpu = 0;        /* (all but sparclet and sparclite) */
3239       tdep->fp_register_bytes = 0;
3240       tdep->print_insn_mach = bfd_mach_sparc_sparclite;
3241       break;
3242     case bfd_mach_sparc_v9:
3243       set_gdbarch_extract_return_value (gdbarch, sparc64_extract_return_value);
3244       set_gdbarch_frame_chain_valid (gdbarch, file_frame_chain_valid);
3245       set_gdbarch_num_regs (gdbarch, 125);
3246       set_gdbarch_register_bytes (gdbarch, 32*8 + 32*8 + 45*8);
3247       set_gdbarch_register_name (gdbarch, sparc64_register_name);
3248       set_gdbarch_store_return_value (gdbarch, sparc_store_return_value);
3249       tdep->has_fpu = 1;        /* (all but sparclet and sparclite) */
3250       tdep->fp_register_bytes = 64 * 4;
3251       tdep->print_insn_mach = bfd_mach_sparc_v9a;
3252       break;
3253     case bfd_mach_sparc_v9a:
3254       set_gdbarch_extract_return_value (gdbarch, sparc64_extract_return_value);
3255       set_gdbarch_frame_chain_valid (gdbarch, file_frame_chain_valid);
3256       set_gdbarch_num_regs (gdbarch, 125);
3257       set_gdbarch_register_bytes (gdbarch, 32*8 + 32*8 + 45*8);
3258       set_gdbarch_register_name (gdbarch, sparc64_register_name);
3259       set_gdbarch_store_return_value (gdbarch, sparc_store_return_value);
3260       tdep->has_fpu = 1;        /* (all but sparclet and sparclite) */
3261       tdep->fp_register_bytes = 64 * 4;
3262       tdep->print_insn_mach = bfd_mach_sparc_v9a;
3263       break;
3264     }
3265
3266   return gdbarch;
3267 }
3268
This page took 0.209138 seconds and 2 git commands to generate.