Include gdb_assert.h in common-defs.h
[external/binutils.git] / gdb / sparc-tdep.c
1 /* Target-dependent code for SPARC.
2
3    Copyright (C) 2003-2014 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 3 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, see <http://www.gnu.org/licenses/>.  */
19
20 #include "defs.h"
21 #include "arch-utils.h"
22 #include "dis-asm.h"
23 #include "dwarf2-frame.h"
24 #include "floatformat.h"
25 #include "frame.h"
26 #include "frame-base.h"
27 #include "frame-unwind.h"
28 #include "gdbcore.h"
29 #include "gdbtypes.h"
30 #include "inferior.h"
31 #include "symtab.h"
32 #include "objfiles.h"
33 #include "osabi.h"
34 #include "regcache.h"
35 #include "target.h"
36 #include "value.h"
37
38 #include <string.h>
39
40 #include "sparc-tdep.h"
41 #include "sparc-ravenscar-thread.h"
42
43 struct regset;
44
45 /* This file implements the SPARC 32-bit ABI as defined by the section
46    "Low-Level System Information" of the SPARC Compliance Definition
47    (SCD) 2.4.1, which is the 32-bit System V psABI for SPARC.  The SCD
48    lists changes with respect to the original 32-bit psABI as defined
49    in the "System V ABI, SPARC Processor Supplement".
50
51    Note that if we talk about SunOS, we mean SunOS 4.x, which was
52    BSD-based, which is sometimes (retroactively?) referred to as
53    Solaris 1.x.  If we talk about Solaris we mean Solaris 2.x and
54    above (Solaris 7, 8 and 9 are nothing but Solaris 2.7, 2.8 and 2.9
55    suffering from severe version number inflation).  Solaris 2.x is
56    also known as SunOS 5.x, since that's what uname(1) says.  Solaris
57    2.x is SVR4-based.  */
58
59 /* Please use the sparc32_-prefix for 32-bit specific code, the
60    sparc64_-prefix for 64-bit specific code and the sparc_-prefix for
61    code that can handle both.  The 64-bit specific code lives in
62    sparc64-tdep.c; don't add any here.  */
63
64 /* The SPARC Floating-Point Quad-Precision format is similar to
65    big-endian IA-64 Quad-Precision format.  */
66 #define floatformats_sparc_quad floatformats_ia64_quad
67
68 /* The stack pointer is offset from the stack frame by a BIAS of 2047
69    (0x7ff) for 64-bit code.  BIAS is likely to be defined on SPARC
70    hosts, so undefine it first.  */
71 #undef BIAS
72 #define BIAS 2047
73
74 /* Macros to extract fields from SPARC instructions.  */
75 #define X_OP(i) (((i) >> 30) & 0x3)
76 #define X_RD(i) (((i) >> 25) & 0x1f)
77 #define X_A(i) (((i) >> 29) & 1)
78 #define X_COND(i) (((i) >> 25) & 0xf)
79 #define X_OP2(i) (((i) >> 22) & 0x7)
80 #define X_IMM22(i) ((i) & 0x3fffff)
81 #define X_OP3(i) (((i) >> 19) & 0x3f)
82 #define X_RS1(i) (((i) >> 14) & 0x1f)
83 #define X_RS2(i) ((i) & 0x1f)
84 #define X_I(i) (((i) >> 13) & 1)
85 /* Sign extension macros.  */
86 #define X_DISP22(i) ((X_IMM22 (i) ^ 0x200000) - 0x200000)
87 #define X_DISP19(i) ((((i) & 0x7ffff) ^ 0x40000) - 0x40000)
88 #define X_DISP10(i) ((((((i) >> 11) && 0x300) | (((i) >> 5) & 0xff)) ^ 0x200) - 0x200)
89 #define X_SIMM13(i) ((((i) & 0x1fff) ^ 0x1000) - 0x1000)
90 /* Macros to identify some instructions.  */
91 /* RETURN (RETT in V8) */
92 #define X_RETTURN(i) ((X_OP (i) == 0x2) && (X_OP3 (i) == 0x39))
93
94 /* Fetch the instruction at PC.  Instructions are always big-endian
95    even if the processor operates in little-endian mode.  */
96
97 unsigned long
98 sparc_fetch_instruction (CORE_ADDR pc)
99 {
100   gdb_byte buf[4];
101   unsigned long insn;
102   int i;
103
104   /* If we can't read the instruction at PC, return zero.  */
105   if (target_read_memory (pc, buf, sizeof (buf)))
106     return 0;
107
108   insn = 0;
109   for (i = 0; i < sizeof (buf); i++)
110     insn = (insn << 8) | buf[i];
111   return insn;
112 }
113 \f
114
115 /* Return non-zero if the instruction corresponding to PC is an "unimp"
116    instruction.  */
117
118 static int
119 sparc_is_unimp_insn (CORE_ADDR pc)
120 {
121   const unsigned long insn = sparc_fetch_instruction (pc);
122   
123   return ((insn & 0xc1c00000) == 0);
124 }
125
126 /* Return non-zero if the instruction corresponding to PC is an
127    "annulled" branch, i.e. the annul bit is set.  */
128
129 int
130 sparc_is_annulled_branch_insn (CORE_ADDR pc)
131 {
132   /* The branch instructions featuring an annul bit can be identified
133      by the following bit patterns:
134
135      OP=0
136       OP2=1: Branch on Integer Condition Codes with Prediction (BPcc).
137       OP2=2: Branch on Integer Condition Codes (Bcc).
138       OP2=5: Branch on FP Condition Codes with Prediction (FBfcc).
139       OP2=6: Branch on FP Condition Codes (FBcc).
140       OP2=3 && Bit28=0:
141              Branch on Integer Register with Prediction (BPr).
142
143      This leaves out ILLTRAP (OP2=0), SETHI/NOP (OP2=4) and the V8
144      coprocessor branch instructions (Op2=7).  */
145
146   const unsigned long insn = sparc_fetch_instruction (pc);
147   const unsigned op2 = X_OP2 (insn);
148
149   if ((X_OP (insn) == 0)
150       && ((op2 == 1) || (op2 == 2) || (op2 == 5) || (op2 == 6)
151           || ((op2 == 3) && ((insn & 0x10000000) == 0))))
152     return X_A (insn);
153   else
154     return 0;
155 }
156
157 /* OpenBSD/sparc includes StackGhost, which according to the author's
158    website http://stackghost.cerias.purdue.edu "... transparently and
159    automatically protects applications' stack frames; more
160    specifically, it guards the return pointers.  The protection
161    mechanisms require no application source or binary modification and
162    imposes only a negligible performance penalty."
163
164    The same website provides the following description of how
165    StackGhost works:
166
167    "StackGhost interfaces with the kernel trap handler that would
168    normally write out registers to the stack and the handler that
169    would read them back in.  By XORing a cookie into the
170    return-address saved in the user stack when it is actually written
171    to the stack, and then XOR it out when the return-address is pulled
172    from the stack, StackGhost can cause attacker corrupted return
173    pointers to behave in a manner the attacker cannot predict.
174    StackGhost can also use several unused bits in the return pointer
175    to detect a smashed return pointer and abort the process."
176
177    For GDB this means that whenever we're reading %i7 from a stack
178    frame's window save area, we'll have to XOR the cookie.
179
180    More information on StackGuard can be found on in:
181
182    Mike Frantzen and Mike Shuey.  "StackGhost: Hardware Facilitated
183    Stack Protection."  2001.  Published in USENIX Security Symposium
184    '01.  */
185
186 /* Fetch StackGhost Per-Process XOR cookie.  */
187
188 ULONGEST
189 sparc_fetch_wcookie (struct gdbarch *gdbarch)
190 {
191   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
192   struct target_ops *ops = &current_target;
193   gdb_byte buf[8];
194   int len;
195
196   len = target_read (ops, TARGET_OBJECT_WCOOKIE, NULL, buf, 0, 8);
197   if (len == -1)
198     return 0;
199
200   /* We should have either an 32-bit or an 64-bit cookie.  */
201   gdb_assert (len == 4 || len == 8);
202
203   return extract_unsigned_integer (buf, len, byte_order);
204 }
205 \f
206
207 /* The functions on this page are intended to be used to classify
208    function arguments.  */
209
210 /* Check whether TYPE is "Integral or Pointer".  */
211
212 static int
213 sparc_integral_or_pointer_p (const struct type *type)
214 {
215   int len = TYPE_LENGTH (type);
216
217   switch (TYPE_CODE (type))
218     {
219     case TYPE_CODE_INT:
220     case TYPE_CODE_BOOL:
221     case TYPE_CODE_CHAR:
222     case TYPE_CODE_ENUM:
223     case TYPE_CODE_RANGE:
224       /* We have byte, half-word, word and extended-word/doubleword
225          integral types.  The doubleword is an extension to the
226          original 32-bit ABI by the SCD 2.4.x.  */
227       return (len == 1 || len == 2 || len == 4 || len == 8);
228     case TYPE_CODE_PTR:
229     case TYPE_CODE_REF:
230       /* Allow either 32-bit or 64-bit pointers.  */
231       return (len == 4 || len == 8);
232     default:
233       break;
234     }
235
236   return 0;
237 }
238
239 /* Check whether TYPE is "Floating".  */
240
241 static int
242 sparc_floating_p (const struct type *type)
243 {
244   switch (TYPE_CODE (type))
245     {
246     case TYPE_CODE_FLT:
247       {
248         int len = TYPE_LENGTH (type);
249         return (len == 4 || len == 8 || len == 16);
250       }
251     default:
252       break;
253     }
254
255   return 0;
256 }
257
258 /* Check whether TYPE is "Complex Floating".  */
259
260 static int
261 sparc_complex_floating_p (const struct type *type)
262 {
263   switch (TYPE_CODE (type))
264     {
265     case TYPE_CODE_COMPLEX:
266       {
267         int len = TYPE_LENGTH (type);
268         return (len == 8 || len == 16 || len == 32);
269       }
270     default:
271       break;
272     }
273
274   return 0;
275 }
276
277 /* Check whether TYPE is "Structure or Union".
278
279    In terms of Ada subprogram calls, arrays are treated the same as
280    struct and union types.  So this function also returns non-zero
281    for array types.  */
282
283 static int
284 sparc_structure_or_union_p (const struct type *type)
285 {
286   switch (TYPE_CODE (type))
287     {
288     case TYPE_CODE_STRUCT:
289     case TYPE_CODE_UNION:
290     case TYPE_CODE_ARRAY:
291       return 1;
292     default:
293       break;
294     }
295
296   return 0;
297 }
298
299 /* Register information.  */
300
301 static const char *sparc32_register_names[] =
302 {
303   "g0", "g1", "g2", "g3", "g4", "g5", "g6", "g7",
304   "o0", "o1", "o2", "o3", "o4", "o5", "sp", "o7",
305   "l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7",
306   "i0", "i1", "i2", "i3", "i4", "i5", "fp", "i7",
307
308   "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
309   "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
310   "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
311   "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
312
313   "y", "psr", "wim", "tbr", "pc", "npc", "fsr", "csr"
314 };
315
316 /* Total number of registers.  */
317 #define SPARC32_NUM_REGS ARRAY_SIZE (sparc32_register_names)
318
319 /* We provide the aliases %d0..%d30 for the floating registers as
320    "psuedo" registers.  */
321
322 static const char *sparc32_pseudo_register_names[] =
323 {
324   "d0", "d2", "d4", "d6", "d8", "d10", "d12", "d14",
325   "d16", "d18", "d20", "d22", "d24", "d26", "d28", "d30"
326 };
327
328 /* Total number of pseudo registers.  */
329 #define SPARC32_NUM_PSEUDO_REGS ARRAY_SIZE (sparc32_pseudo_register_names)
330
331 /* Return the name of register REGNUM.  */
332
333 static const char *
334 sparc32_register_name (struct gdbarch *gdbarch, int regnum)
335 {
336   if (regnum >= 0 && regnum < SPARC32_NUM_REGS)
337     return sparc32_register_names[regnum];
338
339   if (regnum < SPARC32_NUM_REGS + SPARC32_NUM_PSEUDO_REGS)
340     return sparc32_pseudo_register_names[regnum - SPARC32_NUM_REGS];
341
342   return NULL;
343 }
344 \f
345 /* Construct types for ISA-specific registers.  */
346
347 static struct type *
348 sparc_psr_type (struct gdbarch *gdbarch)
349 {
350   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
351
352   if (!tdep->sparc_psr_type)
353     {
354       struct type *type;
355
356       type = arch_flags_type (gdbarch, "builtin_type_sparc_psr", 4);
357       append_flags_type_flag (type, 5, "ET");
358       append_flags_type_flag (type, 6, "PS");
359       append_flags_type_flag (type, 7, "S");
360       append_flags_type_flag (type, 12, "EF");
361       append_flags_type_flag (type, 13, "EC");
362
363       tdep->sparc_psr_type = type;
364     }
365
366   return tdep->sparc_psr_type;
367 }
368
369 static struct type *
370 sparc_fsr_type (struct gdbarch *gdbarch)
371 {
372   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
373
374   if (!tdep->sparc_fsr_type)
375     {
376       struct type *type;
377
378       type = arch_flags_type (gdbarch, "builtin_type_sparc_fsr", 4);
379       append_flags_type_flag (type, 0, "NXA");
380       append_flags_type_flag (type, 1, "DZA");
381       append_flags_type_flag (type, 2, "UFA");
382       append_flags_type_flag (type, 3, "OFA");
383       append_flags_type_flag (type, 4, "NVA");
384       append_flags_type_flag (type, 5, "NXC");
385       append_flags_type_flag (type, 6, "DZC");
386       append_flags_type_flag (type, 7, "UFC");
387       append_flags_type_flag (type, 8, "OFC");
388       append_flags_type_flag (type, 9, "NVC");
389       append_flags_type_flag (type, 22, "NS");
390       append_flags_type_flag (type, 23, "NXM");
391       append_flags_type_flag (type, 24, "DZM");
392       append_flags_type_flag (type, 25, "UFM");
393       append_flags_type_flag (type, 26, "OFM");
394       append_flags_type_flag (type, 27, "NVM");
395
396       tdep->sparc_fsr_type = type;
397     }
398
399   return tdep->sparc_fsr_type;
400 }
401
402 /* Return the GDB type object for the "standard" data type of data in
403    register REGNUM.  */
404
405 static struct type *
406 sparc32_register_type (struct gdbarch *gdbarch, int regnum)
407 {
408   if (regnum >= SPARC_F0_REGNUM && regnum <= SPARC_F31_REGNUM)
409     return builtin_type (gdbarch)->builtin_float;
410
411   if (regnum >= SPARC32_D0_REGNUM && regnum <= SPARC32_D30_REGNUM)
412     return builtin_type (gdbarch)->builtin_double;
413
414   if (regnum == SPARC_SP_REGNUM || regnum == SPARC_FP_REGNUM)
415     return builtin_type (gdbarch)->builtin_data_ptr;
416
417   if (regnum == SPARC32_PC_REGNUM || regnum == SPARC32_NPC_REGNUM)
418     return builtin_type (gdbarch)->builtin_func_ptr;
419
420   if (regnum == SPARC32_PSR_REGNUM)
421     return sparc_psr_type (gdbarch);
422
423   if (regnum == SPARC32_FSR_REGNUM)
424     return sparc_fsr_type (gdbarch);
425
426   return builtin_type (gdbarch)->builtin_int32;
427 }
428
429 static enum register_status
430 sparc32_pseudo_register_read (struct gdbarch *gdbarch,
431                               struct regcache *regcache,
432                               int regnum, gdb_byte *buf)
433 {
434   enum register_status status;
435
436   gdb_assert (regnum >= SPARC32_D0_REGNUM && regnum <= SPARC32_D30_REGNUM);
437
438   regnum = SPARC_F0_REGNUM + 2 * (regnum - SPARC32_D0_REGNUM);
439   status = regcache_raw_read (regcache, regnum, buf);
440   if (status == REG_VALID)
441     status = regcache_raw_read (regcache, regnum + 1, buf + 4);
442   return status;
443 }
444
445 static void
446 sparc32_pseudo_register_write (struct gdbarch *gdbarch,
447                                struct regcache *regcache,
448                                int regnum, const gdb_byte *buf)
449 {
450   gdb_assert (regnum >= SPARC32_D0_REGNUM && regnum <= SPARC32_D30_REGNUM);
451
452   regnum = SPARC_F0_REGNUM + 2 * (regnum - SPARC32_D0_REGNUM);
453   regcache_raw_write (regcache, regnum, buf);
454   regcache_raw_write (regcache, regnum + 1, buf + 4);
455 }
456 \f
457 /* Implement "in_function_epilogue_p".  */
458
459 int
460 sparc_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
461 {
462   /* This function must return true if we are one instruction after an
463      instruction that destroyed the stack frame of the current
464      function.  The SPARC instructions used to restore the callers
465      stack frame are RESTORE and RETURN/RETT.
466
467      Of these RETURN/RETT is a branch instruction and thus we return
468      true if we are in its delay slot.
469
470      RESTORE is almost always found in the delay slot of a branch
471      instruction that transfers control to the caller, such as JMPL.
472      Thus the next instruction is in the caller frame and we don't
473      need to do anything about it.  */
474
475   unsigned int insn = sparc_fetch_instruction (pc - 4);
476
477   return X_RETTURN (insn);
478 }
479 \f
480
481 static CORE_ADDR
482 sparc32_frame_align (struct gdbarch *gdbarch, CORE_ADDR address)
483 {
484   /* The ABI requires double-word alignment.  */
485   return address & ~0x7;
486 }
487
488 static CORE_ADDR
489 sparc32_push_dummy_code (struct gdbarch *gdbarch, CORE_ADDR sp,
490                          CORE_ADDR funcaddr,
491                          struct value **args, int nargs,
492                          struct type *value_type,
493                          CORE_ADDR *real_pc, CORE_ADDR *bp_addr,
494                          struct regcache *regcache)
495 {
496   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
497
498   *bp_addr = sp - 4;
499   *real_pc = funcaddr;
500
501   if (using_struct_return (gdbarch, NULL, value_type))
502     {
503       gdb_byte buf[4];
504
505       /* This is an UNIMP instruction.  */
506       store_unsigned_integer (buf, 4, byte_order,
507                               TYPE_LENGTH (value_type) & 0x1fff);
508       write_memory (sp - 8, buf, 4);
509       return sp - 8;
510     }
511
512   return sp - 4;
513 }
514
515 static CORE_ADDR
516 sparc32_store_arguments (struct regcache *regcache, int nargs,
517                          struct value **args, CORE_ADDR sp,
518                          int struct_return, CORE_ADDR struct_addr)
519 {
520   struct gdbarch *gdbarch = get_regcache_arch (regcache);
521   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
522   /* Number of words in the "parameter array".  */
523   int num_elements = 0;
524   int element = 0;
525   int i;
526
527   for (i = 0; i < nargs; i++)
528     {
529       struct type *type = value_type (args[i]);
530       int len = TYPE_LENGTH (type);
531
532       if (sparc_structure_or_union_p (type)
533           || (sparc_floating_p (type) && len == 16)
534           || sparc_complex_floating_p (type))
535         {
536           /* Structure, Union and Quad-Precision Arguments.  */
537           sp -= len;
538
539           /* Use doubleword alignment for these values.  That's always
540              correct, and wasting a few bytes shouldn't be a problem.  */
541           sp &= ~0x7;
542
543           write_memory (sp, value_contents (args[i]), len);
544           args[i] = value_from_pointer (lookup_pointer_type (type), sp);
545           num_elements++;
546         }
547       else if (sparc_floating_p (type))
548         {
549           /* Floating arguments.  */
550           gdb_assert (len == 4 || len == 8);
551           num_elements += (len / 4);
552         }
553       else
554         {
555           /* Integral and pointer arguments.  */
556           gdb_assert (sparc_integral_or_pointer_p (type));
557
558           if (len < 4)
559             args[i] = value_cast (builtin_type (gdbarch)->builtin_int32,
560                                   args[i]);
561           num_elements += ((len + 3) / 4);
562         }
563     }
564
565   /* Always allocate at least six words.  */
566   sp -= max (6, num_elements) * 4;
567
568   /* The psABI says that "Software convention requires space for the
569      struct/union return value pointer, even if the word is unused."  */
570   sp -= 4;
571
572   /* The psABI says that "Although software convention and the
573      operating system require every stack frame to be doubleword
574      aligned."  */
575   sp &= ~0x7;
576
577   for (i = 0; i < nargs; i++)
578     {
579       const bfd_byte *valbuf = value_contents (args[i]);
580       struct type *type = value_type (args[i]);
581       int len = TYPE_LENGTH (type);
582
583       gdb_assert (len == 4 || len == 8);
584
585       if (element < 6)
586         {
587           int regnum = SPARC_O0_REGNUM + element;
588
589           regcache_cooked_write (regcache, regnum, valbuf);
590           if (len > 4 && element < 5)
591             regcache_cooked_write (regcache, regnum + 1, valbuf + 4);
592         }
593
594       /* Always store the argument in memory.  */
595       write_memory (sp + 4 + element * 4, valbuf, len);
596       element += len / 4;
597     }
598
599   gdb_assert (element == num_elements);
600
601   if (struct_return)
602     {
603       gdb_byte buf[4];
604
605       store_unsigned_integer (buf, 4, byte_order, struct_addr);
606       write_memory (sp, buf, 4);
607     }
608
609   return sp;
610 }
611
612 static CORE_ADDR
613 sparc32_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
614                          struct regcache *regcache, CORE_ADDR bp_addr,
615                          int nargs, struct value **args, CORE_ADDR sp,
616                          int struct_return, CORE_ADDR struct_addr)
617 {
618   CORE_ADDR call_pc = (struct_return ? (bp_addr - 12) : (bp_addr - 8));
619
620   /* Set return address.  */
621   regcache_cooked_write_unsigned (regcache, SPARC_O7_REGNUM, call_pc);
622
623   /* Set up function arguments.  */
624   sp = sparc32_store_arguments (regcache, nargs, args, sp,
625                                 struct_return, struct_addr);
626
627   /* Allocate the 16-word window save area.  */
628   sp -= 16 * 4;
629
630   /* Stack should be doubleword aligned at this point.  */
631   gdb_assert (sp % 8 == 0);
632
633   /* Finally, update the stack pointer.  */
634   regcache_cooked_write_unsigned (regcache, SPARC_SP_REGNUM, sp);
635
636   return sp;
637 }
638 \f
639
640 /* Use the program counter to determine the contents and size of a
641    breakpoint instruction.  Return a pointer to a string of bytes that
642    encode a breakpoint instruction, store the length of the string in
643    *LEN and optionally adjust *PC to point to the correct memory
644    location for inserting the breakpoint.  */
645    
646 static const gdb_byte *
647 sparc_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pc, int *len)
648 {
649   static const gdb_byte break_insn[] = { 0x91, 0xd0, 0x20, 0x01 };
650
651   *len = sizeof (break_insn);
652   return break_insn;
653 }
654 \f
655
656 /* Allocate and initialize a frame cache.  */
657
658 static struct sparc_frame_cache *
659 sparc_alloc_frame_cache (void)
660 {
661   struct sparc_frame_cache *cache;
662
663   cache = FRAME_OBSTACK_ZALLOC (struct sparc_frame_cache);
664
665   /* Base address.  */
666   cache->base = 0;
667   cache->pc = 0;
668
669   /* Frameless until proven otherwise.  */
670   cache->frameless_p = 1;
671   cache->frame_offset = 0;
672   cache->saved_regs_mask = 0;
673   cache->copied_regs_mask = 0;
674   cache->struct_return_p = 0;
675
676   return cache;
677 }
678
679 /* GCC generates several well-known sequences of instructions at the begining
680    of each function prologue when compiling with -fstack-check.  If one of
681    such sequences starts at START_PC, then return the address of the
682    instruction immediately past this sequence.  Otherwise, return START_PC.  */
683    
684 static CORE_ADDR
685 sparc_skip_stack_check (const CORE_ADDR start_pc)
686 {
687   CORE_ADDR pc = start_pc;
688   unsigned long insn;
689   int offset_stack_checking_sequence = 0;
690   int probing_loop = 0;
691
692   /* With GCC, all stack checking sequences begin with the same two
693      instructions, plus an optional one in the case of a probing loop:
694
695          sethi <some immediate>, %g1
696          sub %sp, %g1, %g1
697
698      or:
699
700          sethi <some immediate>, %g1
701          sethi <some immediate>, %g4
702          sub %sp, %g1, %g1
703
704      or:
705
706          sethi <some immediate>, %g1
707          sub %sp, %g1, %g1
708          sethi <some immediate>, %g4
709
710      If the optional instruction is found (setting g4), assume that a
711      probing loop will follow.  */
712
713   /* sethi <some immediate>, %g1 */
714   insn = sparc_fetch_instruction (pc);
715   pc = pc + 4;
716   if (!(X_OP (insn) == 0 && X_OP2 (insn) == 0x4 && X_RD (insn) == 1))
717     return start_pc;
718
719   /* optional: sethi <some immediate>, %g4 */
720   insn = sparc_fetch_instruction (pc);
721   pc = pc + 4;
722   if (X_OP (insn) == 0 && X_OP2 (insn) == 0x4 && X_RD (insn) == 4)
723     {
724       probing_loop = 1;
725       insn = sparc_fetch_instruction (pc);
726       pc = pc + 4;
727     }
728
729   /* sub %sp, %g1, %g1 */
730   if (!(X_OP (insn) == 2 && X_OP3 (insn) == 0x4 && !X_I(insn)
731         && X_RD (insn) == 1 && X_RS1 (insn) == 14 && X_RS2 (insn) == 1))
732     return start_pc;
733
734   insn = sparc_fetch_instruction (pc);
735   pc = pc + 4;
736
737   /* optional: sethi <some immediate>, %g4 */
738   if (X_OP (insn) == 0 && X_OP2 (insn) == 0x4 && X_RD (insn) == 4)
739     {
740       probing_loop = 1;
741       insn = sparc_fetch_instruction (pc);
742       pc = pc + 4;
743     }
744
745   /* First possible sequence:
746          [first two instructions above]
747          clr [%g1 - some immediate]  */
748
749   /* clr [%g1 - some immediate]  */
750   if (X_OP (insn) == 3 && X_OP3(insn) == 0x4 && X_I(insn)
751       && X_RS1 (insn) == 1 && X_RD (insn) == 0)
752     {
753       /* Valid stack-check sequence, return the new PC.  */
754       return pc;
755     }
756
757   /* Second possible sequence: A small number of probes.
758          [first two instructions above]
759          clr [%g1]
760          add   %g1, -<some immediate>, %g1
761          clr [%g1]
762          [repeat the two instructions above any (small) number of times]
763          clr [%g1 - some immediate]  */
764
765   /* clr [%g1] */
766   else if (X_OP (insn) == 3 && X_OP3(insn) == 0x4 && !X_I(insn)
767       && X_RS1 (insn) == 1 && X_RD (insn) == 0)
768     {
769       while (1)
770         {
771           /* add %g1, -<some immediate>, %g1 */
772           insn = sparc_fetch_instruction (pc);
773           pc = pc + 4;
774           if (!(X_OP (insn) == 2  && X_OP3(insn) == 0 && X_I(insn)
775                 && X_RS1 (insn) == 1 && X_RD (insn) == 1))
776             break;
777
778           /* clr [%g1] */
779           insn = sparc_fetch_instruction (pc);
780           pc = pc + 4;
781           if (!(X_OP (insn) == 3 && X_OP3(insn) == 0x4 && !X_I(insn)
782                 && X_RD (insn) == 0 && X_RS1 (insn) == 1))
783             return start_pc;
784         }
785
786       /* clr [%g1 - some immediate] */
787       if (!(X_OP (insn) == 3 && X_OP3(insn) == 0x4 && X_I(insn)
788             && X_RS1 (insn) == 1 && X_RD (insn) == 0))
789         return start_pc;
790
791       /* We found a valid stack-check sequence, return the new PC.  */
792       return pc;
793     }
794   
795   /* Third sequence: A probing loop.
796          [first three instructions above]
797          sub  %g1, %g4, %g4
798          cmp  %g1, %g4
799          be  <disp>
800          add  %g1, -<some immediate>, %g1
801          ba  <disp>
802          clr  [%g1]
803
804      And an optional last probe for the remainder:
805
806          clr [%g4 - some immediate]  */
807
808   if (probing_loop)
809     {
810       /* sub  %g1, %g4, %g4 */
811       if (!(X_OP (insn) == 2 && X_OP3 (insn) == 0x4 && !X_I(insn)
812             && X_RD (insn) == 4 && X_RS1 (insn) == 1 && X_RS2 (insn) == 4))
813         return start_pc;
814
815       /* cmp  %g1, %g4 */
816       insn = sparc_fetch_instruction (pc);
817       pc = pc + 4;
818       if (!(X_OP (insn) == 2 && X_OP3 (insn) == 0x14 && !X_I(insn)
819             && X_RD (insn) == 0 && X_RS1 (insn) == 1 && X_RS2 (insn) == 4))
820         return start_pc;
821
822       /* be  <disp> */
823       insn = sparc_fetch_instruction (pc);
824       pc = pc + 4;
825       if (!(X_OP (insn) == 0 && X_COND (insn) == 0x1))
826         return start_pc;
827
828       /* add  %g1, -<some immediate>, %g1 */
829       insn = sparc_fetch_instruction (pc);
830       pc = pc + 4;
831       if (!(X_OP (insn) == 2  && X_OP3(insn) == 0 && X_I(insn)
832             && X_RS1 (insn) == 1 && X_RD (insn) == 1))
833         return start_pc;
834
835       /* ba  <disp> */
836       insn = sparc_fetch_instruction (pc);
837       pc = pc + 4;
838       if (!(X_OP (insn) == 0 && X_COND (insn) == 0x8))
839         return start_pc;
840
841       /* clr  [%g1] (st %g0, [%g1] or st %g0, [%g1+0]) */
842       insn = sparc_fetch_instruction (pc);
843       pc = pc + 4;
844       if (!(X_OP (insn) == 3 && X_OP3(insn) == 0x4
845             && X_RD (insn) == 0 && X_RS1 (insn) == 1
846             && (!X_I(insn) || X_SIMM13 (insn) == 0)))
847         return start_pc;
848
849       /* We found a valid stack-check sequence, return the new PC.  */
850
851       /* optional: clr [%g4 - some immediate]  */
852       insn = sparc_fetch_instruction (pc);
853       pc = pc + 4;
854       if (!(X_OP (insn) == 3 && X_OP3(insn) == 0x4 && X_I(insn)
855             && X_RS1 (insn) == 4 && X_RD (insn) == 0))
856         return pc - 4;
857       else
858         return pc;
859     }
860
861   /* No stack check code in our prologue, return the start_pc.  */
862   return start_pc;
863 }
864
865 /* Record the effect of a SAVE instruction on CACHE.  */
866
867 void
868 sparc_record_save_insn (struct sparc_frame_cache *cache)
869 {
870   /* The frame is set up.  */
871   cache->frameless_p = 0;
872
873   /* The frame pointer contains the CFA.  */
874   cache->frame_offset = 0;
875
876   /* The `local' and `in' registers are all saved.  */
877   cache->saved_regs_mask = 0xffff;
878
879   /* The `out' registers are all renamed.  */
880   cache->copied_regs_mask = 0xff;
881 }
882
883 /* Do a full analysis of the prologue at PC and update CACHE accordingly.
884    Bail out early if CURRENT_PC is reached.  Return the address where
885    the analysis stopped.
886
887    We handle both the traditional register window model and the single
888    register window (aka flat) model.  */
889
890 CORE_ADDR
891 sparc_analyze_prologue (struct gdbarch *gdbarch, CORE_ADDR pc,
892                         CORE_ADDR current_pc, struct sparc_frame_cache *cache)
893 {
894   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
895   unsigned long insn;
896   int offset = 0;
897   int dest = -1;
898
899   pc = sparc_skip_stack_check (pc);
900
901   if (current_pc <= pc)
902     return current_pc;
903
904   /* We have to handle to "Procedure Linkage Table" (PLT) special.  On
905      SPARC the linker usually defines a symbol (typically
906      _PROCEDURE_LINKAGE_TABLE_) at the start of the .plt section.
907      This symbol makes us end up here with PC pointing at the start of
908      the PLT and CURRENT_PC probably pointing at a PLT entry.  If we
909      would do our normal prologue analysis, we would probably conclude
910      that we've got a frame when in reality we don't, since the
911      dynamic linker patches up the first PLT with some code that
912      starts with a SAVE instruction.  Patch up PC such that it points
913      at the start of our PLT entry.  */
914   if (tdep->plt_entry_size > 0 && in_plt_section (current_pc))
915     pc = current_pc - ((current_pc - pc) % tdep->plt_entry_size);
916
917   insn = sparc_fetch_instruction (pc);
918
919   /* Recognize store insns and record their sources.  */
920   while (X_OP (insn) == 3
921          && (X_OP3 (insn) == 0x4     /* stw */
922              || X_OP3 (insn) == 0x7  /* std */
923              || X_OP3 (insn) == 0xe) /* stx */
924          && X_RS1 (insn) == SPARC_SP_REGNUM)
925     {
926       int regnum = X_RD (insn);
927
928       /* Recognize stores into the corresponding stack slots.  */
929       if (regnum >= SPARC_L0_REGNUM && regnum <= SPARC_I7_REGNUM
930           && ((X_I (insn)
931                && X_SIMM13 (insn) == (X_OP3 (insn) == 0xe
932                                       ? (regnum - SPARC_L0_REGNUM) * 8 + BIAS
933                                       : (regnum - SPARC_L0_REGNUM) * 4))
934               || (!X_I (insn) && regnum == SPARC_L0_REGNUM)))
935         {
936           cache->saved_regs_mask |= (1 << (regnum - SPARC_L0_REGNUM));
937           if (X_OP3 (insn) == 0x7)
938             cache->saved_regs_mask |= (1 << (regnum + 1 - SPARC_L0_REGNUM));
939         }
940
941       offset += 4;
942
943       insn = sparc_fetch_instruction (pc + offset);
944     }
945
946   /* Recognize a SETHI insn and record its destination.  */
947   if (X_OP (insn) == 0 && X_OP2 (insn) == 0x04)
948     {
949       dest = X_RD (insn);
950       offset += 4;
951
952       insn = sparc_fetch_instruction (pc + offset);
953     }
954
955   /* Allow for an arithmetic operation on DEST or %g1.  */
956   if (X_OP (insn) == 2 && X_I (insn)
957       && (X_RD (insn) == 1 || X_RD (insn) == dest))
958     {
959       offset += 4;
960
961       insn = sparc_fetch_instruction (pc + offset);
962     }
963
964   /* Check for the SAVE instruction that sets up the frame.  */
965   if (X_OP (insn) == 2 && X_OP3 (insn) == 0x3c)
966     {
967       sparc_record_save_insn (cache);
968       offset += 4;
969       return pc + offset;
970     }
971
972   /* Check for an arithmetic operation on %sp.  */
973   if (X_OP (insn) == 2
974       && (X_OP3 (insn) == 0 || X_OP3 (insn) == 0x4)
975       && X_RS1 (insn) == SPARC_SP_REGNUM
976       && X_RD (insn) == SPARC_SP_REGNUM)
977     {
978       if (X_I (insn))
979         {
980           cache->frame_offset = X_SIMM13 (insn);
981           if (X_OP3 (insn) == 0)
982             cache->frame_offset = -cache->frame_offset;
983         }
984       offset += 4;
985
986       insn = sparc_fetch_instruction (pc + offset);
987
988       /* Check for an arithmetic operation that sets up the frame.  */
989       if (X_OP (insn) == 2
990           && (X_OP3 (insn) == 0 || X_OP3 (insn) == 0x4)
991           && X_RS1 (insn) == SPARC_SP_REGNUM
992           && X_RD (insn) == SPARC_FP_REGNUM)
993         {
994           cache->frameless_p = 0;
995           cache->frame_offset = 0;
996           /* We could check that the amount subtracted to %sp above is the
997              same as the one added here, but this seems superfluous.  */
998           cache->copied_regs_mask |= 0x40;
999           offset += 4;
1000
1001           insn = sparc_fetch_instruction (pc + offset);
1002         }
1003
1004       /* Check for a move (or) operation that copies the return register.  */
1005       if (X_OP (insn) == 2
1006           && X_OP3 (insn) == 0x2
1007           && !X_I (insn)
1008           && X_RS1 (insn) == SPARC_G0_REGNUM
1009           && X_RS2 (insn) == SPARC_O7_REGNUM
1010           && X_RD (insn) == SPARC_I7_REGNUM)
1011         {
1012            cache->copied_regs_mask |= 0x80;
1013            offset += 4;
1014         }
1015
1016       return pc + offset;
1017     }
1018
1019   return pc;
1020 }
1021
1022 static CORE_ADDR
1023 sparc_unwind_pc (struct gdbarch *gdbarch, struct frame_info *this_frame)
1024 {
1025   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1026   return frame_unwind_register_unsigned (this_frame, tdep->pc_regnum);
1027 }
1028
1029 /* Return PC of first real instruction of the function starting at
1030    START_PC.  */
1031
1032 static CORE_ADDR
1033 sparc32_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR start_pc)
1034 {
1035   struct symtab_and_line sal;
1036   CORE_ADDR func_start, func_end;
1037   struct sparc_frame_cache cache;
1038
1039   /* This is the preferred method, find the end of the prologue by
1040      using the debugging information.  */
1041   if (find_pc_partial_function (start_pc, NULL, &func_start, &func_end))
1042     {
1043       sal = find_pc_line (func_start, 0);
1044
1045       if (sal.end < func_end
1046           && start_pc <= sal.end)
1047         return sal.end;
1048     }
1049
1050   start_pc = sparc_analyze_prologue (gdbarch, start_pc, 0xffffffffUL, &cache);
1051
1052   /* The psABI says that "Although the first 6 words of arguments
1053      reside in registers, the standard stack frame reserves space for
1054      them.".  It also suggests that a function may use that space to
1055      "write incoming arguments 0 to 5" into that space, and that's
1056      indeed what GCC seems to be doing.  In that case GCC will
1057      generate debug information that points to the stack slots instead
1058      of the registers, so we should consider the instructions that
1059      write out these incoming arguments onto the stack.  */
1060
1061   while (1)
1062     {
1063       unsigned long insn = sparc_fetch_instruction (start_pc);
1064
1065       /* Recognize instructions that store incoming arguments into the
1066          corresponding stack slots.  */
1067       if (X_OP (insn) == 3 && (X_OP3 (insn) & 0x3c) == 0x04
1068           && X_I (insn) && X_RS1 (insn) == SPARC_FP_REGNUM)
1069         {
1070           int regnum = X_RD (insn);
1071
1072           /* Case of arguments still in %o[0..5].  */
1073           if (regnum >= SPARC_O0_REGNUM && regnum <= SPARC_O5_REGNUM
1074               && !(cache.copied_regs_mask & (1 << (regnum - SPARC_O0_REGNUM)))
1075               && X_SIMM13 (insn) == 68 + (regnum - SPARC_O0_REGNUM) * 4)
1076             {
1077               start_pc += 4;
1078               continue;
1079             }
1080
1081           /* Case of arguments copied into %i[0..5].  */
1082           if (regnum >= SPARC_I0_REGNUM && regnum <= SPARC_I5_REGNUM
1083               && (cache.copied_regs_mask & (1 << (regnum - SPARC_I0_REGNUM)))
1084               && X_SIMM13 (insn) == 68 + (regnum - SPARC_I0_REGNUM) * 4)
1085             {
1086               start_pc += 4;
1087               continue;
1088             }
1089         }
1090
1091       break;
1092     }
1093
1094   return start_pc;
1095 }
1096
1097 /* Normal frames.  */
1098
1099 struct sparc_frame_cache *
1100 sparc_frame_cache (struct frame_info *this_frame, void **this_cache)
1101 {
1102   struct sparc_frame_cache *cache;
1103
1104   if (*this_cache)
1105     return *this_cache;
1106
1107   cache = sparc_alloc_frame_cache ();
1108   *this_cache = cache;
1109
1110   cache->pc = get_frame_func (this_frame);
1111   if (cache->pc != 0)
1112     sparc_analyze_prologue (get_frame_arch (this_frame), cache->pc,
1113                             get_frame_pc (this_frame), cache);
1114
1115   if (cache->frameless_p)
1116     {
1117       /* This function is frameless, so %fp (%i6) holds the frame
1118          pointer for our calling frame.  Use %sp (%o6) as this frame's
1119          base address.  */
1120       cache->base =
1121         get_frame_register_unsigned (this_frame, SPARC_SP_REGNUM);
1122     }
1123   else
1124     {
1125       /* For normal frames, %fp (%i6) holds the frame pointer, the
1126          base address for the current stack frame.  */
1127       cache->base =
1128         get_frame_register_unsigned (this_frame, SPARC_FP_REGNUM);
1129     }
1130
1131   cache->base += cache->frame_offset;
1132
1133   if (cache->base & 1)
1134     cache->base += BIAS;
1135
1136   return cache;
1137 }
1138
1139 static int
1140 sparc32_struct_return_from_sym (struct symbol *sym)
1141 {
1142   struct type *type = check_typedef (SYMBOL_TYPE (sym));
1143   enum type_code code = TYPE_CODE (type);
1144
1145   if (code == TYPE_CODE_FUNC || code == TYPE_CODE_METHOD)
1146     {
1147       type = check_typedef (TYPE_TARGET_TYPE (type));
1148       if (sparc_structure_or_union_p (type)
1149           || (sparc_floating_p (type) && TYPE_LENGTH (type) == 16))
1150         return 1;
1151     }
1152
1153   return 0;
1154 }
1155
1156 struct sparc_frame_cache *
1157 sparc32_frame_cache (struct frame_info *this_frame, void **this_cache)
1158 {
1159   struct sparc_frame_cache *cache;
1160   struct symbol *sym;
1161
1162   if (*this_cache)
1163     return *this_cache;
1164
1165   cache = sparc_frame_cache (this_frame, this_cache);
1166
1167   sym = find_pc_function (cache->pc);
1168   if (sym)
1169     {
1170       cache->struct_return_p = sparc32_struct_return_from_sym (sym);
1171     }
1172   else
1173     {
1174       /* There is no debugging information for this function to
1175          help us determine whether this function returns a struct
1176          or not.  So we rely on another heuristic which is to check
1177          the instruction at the return address and see if this is
1178          an "unimp" instruction.  If it is, then it is a struct-return
1179          function.  */
1180       CORE_ADDR pc;
1181       int regnum =
1182         (cache->copied_regs_mask & 0x80) ? SPARC_I7_REGNUM : SPARC_O7_REGNUM;
1183
1184       pc = get_frame_register_unsigned (this_frame, regnum) + 8;
1185       if (sparc_is_unimp_insn (pc))
1186         cache->struct_return_p = 1;
1187     }
1188
1189   return cache;
1190 }
1191
1192 static void
1193 sparc32_frame_this_id (struct frame_info *this_frame, void **this_cache,
1194                        struct frame_id *this_id)
1195 {
1196   struct sparc_frame_cache *cache =
1197     sparc32_frame_cache (this_frame, this_cache);
1198
1199   /* This marks the outermost frame.  */
1200   if (cache->base == 0)
1201     return;
1202
1203   (*this_id) = frame_id_build (cache->base, cache->pc);
1204 }
1205
1206 static struct value *
1207 sparc32_frame_prev_register (struct frame_info *this_frame,
1208                              void **this_cache, int regnum)
1209 {
1210   struct gdbarch *gdbarch = get_frame_arch (this_frame);
1211   struct sparc_frame_cache *cache =
1212     sparc32_frame_cache (this_frame, this_cache);
1213
1214   if (regnum == SPARC32_PC_REGNUM || regnum == SPARC32_NPC_REGNUM)
1215     {
1216       CORE_ADDR pc = (regnum == SPARC32_NPC_REGNUM) ? 4 : 0;
1217
1218       /* If this functions has a Structure, Union or Quad-Precision
1219          return value, we have to skip the UNIMP instruction that encodes
1220          the size of the structure.  */
1221       if (cache->struct_return_p)
1222         pc += 4;
1223
1224       regnum =
1225         (cache->copied_regs_mask & 0x80) ? SPARC_I7_REGNUM : SPARC_O7_REGNUM;
1226       pc += get_frame_register_unsigned (this_frame, regnum) + 8;
1227       return frame_unwind_got_constant (this_frame, regnum, pc);
1228     }
1229
1230   /* Handle StackGhost.  */
1231   {
1232     ULONGEST wcookie = sparc_fetch_wcookie (gdbarch);
1233
1234     if (wcookie != 0 && !cache->frameless_p && regnum == SPARC_I7_REGNUM)
1235       {
1236         CORE_ADDR addr = cache->base + (regnum - SPARC_L0_REGNUM) * 4;
1237         ULONGEST i7;
1238
1239         /* Read the value in from memory.  */
1240         i7 = get_frame_memory_unsigned (this_frame, addr, 4);
1241         return frame_unwind_got_constant (this_frame, regnum, i7 ^ wcookie);
1242       }
1243   }
1244
1245   /* The previous frame's `local' and `in' registers may have been saved
1246      in the register save area.  */
1247   if (regnum >= SPARC_L0_REGNUM && regnum <= SPARC_I7_REGNUM
1248       && (cache->saved_regs_mask & (1 << (regnum - SPARC_L0_REGNUM))))
1249     {
1250       CORE_ADDR addr = cache->base + (regnum - SPARC_L0_REGNUM) * 4;
1251
1252       return frame_unwind_got_memory (this_frame, regnum, addr);
1253     }
1254
1255   /* The previous frame's `out' registers may be accessible as the current
1256      frame's `in' registers.  */
1257   if (regnum >= SPARC_O0_REGNUM && regnum <= SPARC_O7_REGNUM
1258       && (cache->copied_regs_mask & (1 << (regnum - SPARC_O0_REGNUM))))
1259     regnum += (SPARC_I0_REGNUM - SPARC_O0_REGNUM);
1260
1261   return frame_unwind_got_register (this_frame, regnum, regnum);
1262 }
1263
1264 static const struct frame_unwind sparc32_frame_unwind =
1265 {
1266   NORMAL_FRAME,
1267   default_frame_unwind_stop_reason,
1268   sparc32_frame_this_id,
1269   sparc32_frame_prev_register,
1270   NULL,
1271   default_frame_sniffer
1272 };
1273 \f
1274
1275 static CORE_ADDR
1276 sparc32_frame_base_address (struct frame_info *this_frame, void **this_cache)
1277 {
1278   struct sparc_frame_cache *cache =
1279     sparc32_frame_cache (this_frame, this_cache);
1280
1281   return cache->base;
1282 }
1283
1284 static const struct frame_base sparc32_frame_base =
1285 {
1286   &sparc32_frame_unwind,
1287   sparc32_frame_base_address,
1288   sparc32_frame_base_address,
1289   sparc32_frame_base_address
1290 };
1291
1292 static struct frame_id
1293 sparc_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
1294 {
1295   CORE_ADDR sp;
1296
1297   sp = get_frame_register_unsigned (this_frame, SPARC_SP_REGNUM);
1298   if (sp & 1)
1299     sp += BIAS;
1300   return frame_id_build (sp, get_frame_pc (this_frame));
1301 }
1302 \f
1303
1304 /* Extract a function return value of TYPE from REGCACHE, and copy
1305    that into VALBUF.  */
1306
1307 static void
1308 sparc32_extract_return_value (struct type *type, struct regcache *regcache,
1309                               gdb_byte *valbuf)
1310 {
1311   int len = TYPE_LENGTH (type);
1312   gdb_byte buf[32];
1313
1314   gdb_assert (!sparc_structure_or_union_p (type));
1315   gdb_assert (!(sparc_floating_p (type) && len == 16));
1316
1317   if (sparc_floating_p (type) || sparc_complex_floating_p (type))
1318     {
1319       /* Floating return values.  */
1320       regcache_cooked_read (regcache, SPARC_F0_REGNUM, buf);
1321       if (len > 4)
1322         regcache_cooked_read (regcache, SPARC_F1_REGNUM, buf + 4);
1323       if (len > 8)
1324         {
1325           regcache_cooked_read (regcache, SPARC_F2_REGNUM, buf + 8);
1326           regcache_cooked_read (regcache, SPARC_F3_REGNUM, buf + 12);
1327         }
1328       if (len > 16)
1329         {
1330           regcache_cooked_read (regcache, SPARC_F4_REGNUM, buf + 16);
1331           regcache_cooked_read (regcache, SPARC_F5_REGNUM, buf + 20);
1332           regcache_cooked_read (regcache, SPARC_F6_REGNUM, buf + 24);
1333           regcache_cooked_read (regcache, SPARC_F7_REGNUM, buf + 28);
1334         }
1335       memcpy (valbuf, buf, len);
1336     }
1337   else
1338     {
1339       /* Integral and pointer return values.  */
1340       gdb_assert (sparc_integral_or_pointer_p (type));
1341
1342       regcache_cooked_read (regcache, SPARC_O0_REGNUM, buf);
1343       if (len > 4)
1344         {
1345           regcache_cooked_read (regcache, SPARC_O1_REGNUM, buf + 4);
1346           gdb_assert (len == 8);
1347           memcpy (valbuf, buf, 8);
1348         }
1349       else
1350         {
1351           /* Just stripping off any unused bytes should preserve the
1352              signed-ness just fine.  */
1353           memcpy (valbuf, buf + 4 - len, len);
1354         }
1355     }
1356 }
1357
1358 /* Store the function return value of type TYPE from VALBUF into
1359    REGCACHE.  */
1360
1361 static void
1362 sparc32_store_return_value (struct type *type, struct regcache *regcache,
1363                             const gdb_byte *valbuf)
1364 {
1365   int len = TYPE_LENGTH (type);
1366   gdb_byte buf[8];
1367
1368   gdb_assert (!sparc_structure_or_union_p (type));
1369   gdb_assert (!(sparc_floating_p (type) && len == 16));
1370   gdb_assert (len <= 8);
1371
1372   if (sparc_floating_p (type) || sparc_complex_floating_p (type))
1373     {
1374       /* Floating return values.  */
1375       memcpy (buf, valbuf, len);
1376       regcache_cooked_write (regcache, SPARC_F0_REGNUM, buf);
1377       if (len > 4)
1378         regcache_cooked_write (regcache, SPARC_F1_REGNUM, buf + 4);
1379       if (len > 8)
1380         {
1381           regcache_cooked_write (regcache, SPARC_F2_REGNUM, buf + 8);
1382           regcache_cooked_write (regcache, SPARC_F3_REGNUM, buf + 12);
1383         }
1384       if (len > 16)
1385         {
1386           regcache_cooked_write (regcache, SPARC_F4_REGNUM, buf + 16);
1387           regcache_cooked_write (regcache, SPARC_F5_REGNUM, buf + 20);
1388           regcache_cooked_write (regcache, SPARC_F6_REGNUM, buf + 24);
1389           regcache_cooked_write (regcache, SPARC_F7_REGNUM, buf + 28);
1390         }
1391     }
1392   else
1393     {
1394       /* Integral and pointer return values.  */
1395       gdb_assert (sparc_integral_or_pointer_p (type));
1396
1397       if (len > 4)
1398         {
1399           gdb_assert (len == 8);
1400           memcpy (buf, valbuf, 8);
1401           regcache_cooked_write (regcache, SPARC_O1_REGNUM, buf + 4);
1402         }
1403       else
1404         {
1405           /* ??? Do we need to do any sign-extension here?  */
1406           memcpy (buf + 4 - len, valbuf, len);
1407         }
1408       regcache_cooked_write (regcache, SPARC_O0_REGNUM, buf);
1409     }
1410 }
1411
1412 static enum return_value_convention
1413 sparc32_return_value (struct gdbarch *gdbarch, struct value *function,
1414                       struct type *type, struct regcache *regcache,
1415                       gdb_byte *readbuf, const gdb_byte *writebuf)
1416 {
1417   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1418
1419   /* The psABI says that "...every stack frame reserves the word at
1420      %fp+64.  If a function returns a structure, union, or
1421      quad-precision value, this word should hold the address of the
1422      object into which the return value should be copied."  This
1423      guarantees that we can always find the return value, not just
1424      before the function returns.  */
1425
1426   if (sparc_structure_or_union_p (type)
1427       || (sparc_floating_p (type) && TYPE_LENGTH (type) == 16))
1428     {
1429       ULONGEST sp;
1430       CORE_ADDR addr;
1431
1432       if (readbuf)
1433         {
1434           regcache_cooked_read_unsigned (regcache, SPARC_SP_REGNUM, &sp);
1435           addr = read_memory_unsigned_integer (sp + 64, 4, byte_order);
1436           read_memory (addr, readbuf, TYPE_LENGTH (type));
1437         }
1438       if (writebuf)
1439         {
1440           regcache_cooked_read_unsigned (regcache, SPARC_SP_REGNUM, &sp);
1441           addr = read_memory_unsigned_integer (sp + 64, 4, byte_order);
1442           write_memory (addr, writebuf, TYPE_LENGTH (type));
1443         }
1444
1445       return RETURN_VALUE_ABI_PRESERVES_ADDRESS;
1446     }
1447
1448   if (readbuf)
1449     sparc32_extract_return_value (type, regcache, readbuf);
1450   if (writebuf)
1451     sparc32_store_return_value (type, regcache, writebuf);
1452
1453   return RETURN_VALUE_REGISTER_CONVENTION;
1454 }
1455
1456 static int
1457 sparc32_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type)
1458 {
1459   return (sparc_structure_or_union_p (type)
1460           || (sparc_floating_p (type) && TYPE_LENGTH (type) == 16)
1461           || sparc_complex_floating_p (type));
1462 }
1463
1464 static int
1465 sparc32_dwarf2_struct_return_p (struct frame_info *this_frame)
1466 {
1467   CORE_ADDR pc = get_frame_address_in_block (this_frame);
1468   struct symbol *sym = find_pc_function (pc);
1469
1470   if (sym)
1471     return sparc32_struct_return_from_sym (sym);
1472   return 0;
1473 }
1474
1475 static void
1476 sparc32_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
1477                                struct dwarf2_frame_state_reg *reg,
1478                                struct frame_info *this_frame)
1479 {
1480   int off;
1481
1482   switch (regnum)
1483     {
1484     case SPARC_G0_REGNUM:
1485       /* Since %g0 is always zero, there is no point in saving it, and
1486          people will be inclined omit it from the CFI.  Make sure we
1487          don't warn about that.  */
1488       reg->how = DWARF2_FRAME_REG_SAME_VALUE;
1489       break;
1490     case SPARC_SP_REGNUM:
1491       reg->how = DWARF2_FRAME_REG_CFA;
1492       break;
1493     case SPARC32_PC_REGNUM:
1494     case SPARC32_NPC_REGNUM:
1495       reg->how = DWARF2_FRAME_REG_RA_OFFSET;
1496       off = 8;
1497       if (sparc32_dwarf2_struct_return_p (this_frame))
1498         off += 4;
1499       if (regnum == SPARC32_NPC_REGNUM)
1500         off += 4;
1501       reg->loc.offset = off;
1502       break;
1503     }
1504 }
1505
1506 \f
1507 /* The SPARC Architecture doesn't have hardware single-step support,
1508    and most operating systems don't implement it either, so we provide
1509    software single-step mechanism.  */
1510
1511 static CORE_ADDR
1512 sparc_analyze_control_transfer (struct frame_info *frame,
1513                                 CORE_ADDR pc, CORE_ADDR *npc)
1514 {
1515   unsigned long insn = sparc_fetch_instruction (pc);
1516   int conditional_p = X_COND (insn) & 0x7;
1517   int branch_p = 0, fused_p = 0;
1518   long offset = 0;                      /* Must be signed for sign-extend.  */
1519
1520   if (X_OP (insn) == 0 && X_OP2 (insn) == 3)
1521     {
1522       if ((insn & 0x10000000) == 0)
1523         {
1524           /* Branch on Integer Register with Prediction (BPr).  */
1525           branch_p = 1;
1526           conditional_p = 1;
1527         }
1528       else
1529         {
1530           /* Compare and Branch  */
1531           branch_p = 1;
1532           fused_p = 1;
1533           offset = 4 * X_DISP10 (insn);
1534         }
1535     }
1536   else if (X_OP (insn) == 0 && X_OP2 (insn) == 6)
1537     {
1538       /* Branch on Floating-Point Condition Codes (FBfcc).  */
1539       branch_p = 1;
1540       offset = 4 * X_DISP22 (insn);
1541     }
1542   else if (X_OP (insn) == 0 && X_OP2 (insn) == 5)
1543     {
1544       /* Branch on Floating-Point Condition Codes with Prediction
1545          (FBPfcc).  */
1546       branch_p = 1;
1547       offset = 4 * X_DISP19 (insn);
1548     }
1549   else if (X_OP (insn) == 0 && X_OP2 (insn) == 2)
1550     {
1551       /* Branch on Integer Condition Codes (Bicc).  */
1552       branch_p = 1;
1553       offset = 4 * X_DISP22 (insn);
1554     }
1555   else if (X_OP (insn) == 0 && X_OP2 (insn) == 1)
1556     {
1557       /* Branch on Integer Condition Codes with Prediction (BPcc).  */
1558       branch_p = 1;
1559       offset = 4 * X_DISP19 (insn);
1560     }
1561   else if (X_OP (insn) == 2 && X_OP3 (insn) == 0x3a)
1562     {
1563       /* Trap instruction (TRAP).  */
1564       return gdbarch_tdep (get_frame_arch (frame))->step_trap (frame, insn);
1565     }
1566
1567   /* FIXME: Handle DONE and RETRY instructions.  */
1568
1569   if (branch_p)
1570     {
1571       if (fused_p)
1572         {
1573           /* Fused compare-and-branch instructions are non-delayed,
1574              and do not have an annuling capability.  So we need to
1575              always set a breakpoint on both the NPC and the branch
1576              target address.  */
1577           gdb_assert (offset != 0);
1578           return pc + offset;
1579         }
1580       else if (conditional_p)
1581         {
1582           /* For conditional branches, return nPC + 4 iff the annul
1583              bit is 1.  */
1584           return (X_A (insn) ? *npc + 4 : 0);
1585         }
1586       else
1587         {
1588           /* For unconditional branches, return the target if its
1589              specified condition is "always" and return nPC + 4 if the
1590              condition is "never".  If the annul bit is 1, set *NPC to
1591              zero.  */
1592           if (X_COND (insn) == 0x0)
1593             pc = *npc, offset = 4;
1594           if (X_A (insn))
1595             *npc = 0;
1596
1597           return pc + offset;
1598         }
1599     }
1600
1601   return 0;
1602 }
1603
1604 static CORE_ADDR
1605 sparc_step_trap (struct frame_info *frame, unsigned long insn)
1606 {
1607   return 0;
1608 }
1609
1610 int
1611 sparc_software_single_step (struct frame_info *frame)
1612 {
1613   struct gdbarch *arch = get_frame_arch (frame);
1614   struct gdbarch_tdep *tdep = gdbarch_tdep (arch);
1615   struct address_space *aspace = get_frame_address_space (frame);
1616   CORE_ADDR npc, nnpc;
1617
1618   CORE_ADDR pc, orig_npc;
1619
1620   pc = get_frame_register_unsigned (frame, tdep->pc_regnum);
1621   orig_npc = npc = get_frame_register_unsigned (frame, tdep->npc_regnum);
1622
1623   /* Analyze the instruction at PC.  */
1624   nnpc = sparc_analyze_control_transfer (frame, pc, &npc);
1625   if (npc != 0)
1626     insert_single_step_breakpoint (arch, aspace, npc);
1627
1628   if (nnpc != 0)
1629     insert_single_step_breakpoint (arch, aspace, nnpc);
1630
1631   /* Assert that we have set at least one breakpoint, and that
1632      they're not set at the same spot - unless we're going
1633      from here straight to NULL, i.e. a call or jump to 0.  */
1634   gdb_assert (npc != 0 || nnpc != 0 || orig_npc == 0);
1635   gdb_assert (nnpc != npc || orig_npc == 0);
1636
1637   return 1;
1638 }
1639
1640 static void
1641 sparc_write_pc (struct regcache *regcache, CORE_ADDR pc)
1642 {
1643   struct gdbarch_tdep *tdep = gdbarch_tdep (get_regcache_arch (regcache));
1644
1645   regcache_cooked_write_unsigned (regcache, tdep->pc_regnum, pc);
1646   regcache_cooked_write_unsigned (regcache, tdep->npc_regnum, pc + 4);
1647 }
1648 \f
1649
1650 /* Return the appropriate register set for the core section identified
1651    by SECT_NAME and SECT_SIZE.  */
1652
1653 static const struct regset *
1654 sparc_regset_from_core_section (struct gdbarch *gdbarch,
1655                                 const char *sect_name, size_t sect_size)
1656 {
1657   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1658
1659   if (strcmp (sect_name, ".reg") == 0 && sect_size >= tdep->sizeof_gregset)
1660     return tdep->gregset;
1661
1662   if (strcmp (sect_name, ".reg2") == 0 && sect_size >= tdep->sizeof_fpregset)
1663     return tdep->fpregset;
1664
1665   return NULL;
1666 }
1667 \f
1668
1669 static struct gdbarch *
1670 sparc32_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1671 {
1672   struct gdbarch_tdep *tdep;
1673   struct gdbarch *gdbarch;
1674
1675   /* If there is already a candidate, use it.  */
1676   arches = gdbarch_list_lookup_by_info (arches, &info);
1677   if (arches != NULL)
1678     return arches->gdbarch;
1679
1680   /* Allocate space for the new architecture.  */
1681   tdep = XCNEW (struct gdbarch_tdep);
1682   gdbarch = gdbarch_alloc (&info, tdep);
1683
1684   tdep->pc_regnum = SPARC32_PC_REGNUM;
1685   tdep->npc_regnum = SPARC32_NPC_REGNUM;
1686   tdep->step_trap = sparc_step_trap;
1687
1688   set_gdbarch_long_double_bit (gdbarch, 128);
1689   set_gdbarch_long_double_format (gdbarch, floatformats_sparc_quad);
1690
1691   set_gdbarch_num_regs (gdbarch, SPARC32_NUM_REGS);
1692   set_gdbarch_register_name (gdbarch, sparc32_register_name);
1693   set_gdbarch_register_type (gdbarch, sparc32_register_type);
1694   set_gdbarch_num_pseudo_regs (gdbarch, SPARC32_NUM_PSEUDO_REGS);
1695   set_gdbarch_pseudo_register_read (gdbarch, sparc32_pseudo_register_read);
1696   set_gdbarch_pseudo_register_write (gdbarch, sparc32_pseudo_register_write);
1697
1698   /* Register numbers of various important registers.  */
1699   set_gdbarch_sp_regnum (gdbarch, SPARC_SP_REGNUM); /* %sp */
1700   set_gdbarch_pc_regnum (gdbarch, SPARC32_PC_REGNUM); /* %pc */
1701   set_gdbarch_fp0_regnum (gdbarch, SPARC_F0_REGNUM); /* %f0 */
1702
1703   /* Call dummy code.  */
1704   set_gdbarch_frame_align (gdbarch, sparc32_frame_align);
1705   set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
1706   set_gdbarch_push_dummy_code (gdbarch, sparc32_push_dummy_code);
1707   set_gdbarch_push_dummy_call (gdbarch, sparc32_push_dummy_call);
1708
1709   set_gdbarch_return_value (gdbarch, sparc32_return_value);
1710   set_gdbarch_stabs_argument_has_addr
1711     (gdbarch, sparc32_stabs_argument_has_addr);
1712
1713   set_gdbarch_skip_prologue (gdbarch, sparc32_skip_prologue);
1714
1715   /* Stack grows downward.  */
1716   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1717
1718   set_gdbarch_breakpoint_from_pc (gdbarch, sparc_breakpoint_from_pc);
1719
1720   set_gdbarch_frame_args_skip (gdbarch, 8);
1721
1722   set_gdbarch_print_insn (gdbarch, print_insn_sparc);
1723
1724   set_gdbarch_software_single_step (gdbarch, sparc_software_single_step);
1725   set_gdbarch_write_pc (gdbarch, sparc_write_pc);
1726
1727   set_gdbarch_dummy_id (gdbarch, sparc_dummy_id);
1728
1729   set_gdbarch_unwind_pc (gdbarch, sparc_unwind_pc);
1730
1731   frame_base_set_default (gdbarch, &sparc32_frame_base);
1732
1733   /* Hook in the DWARF CFI frame unwinder.  */
1734   dwarf2_frame_set_init_reg (gdbarch, sparc32_dwarf2_frame_init_reg);
1735   /* FIXME: kettenis/20050423: Don't enable the unwinder until the
1736      StackGhost issues have been resolved.  */
1737
1738   /* Hook in ABI-specific overrides, if they have been registered.  */
1739   gdbarch_init_osabi (info, gdbarch);
1740
1741   frame_unwind_append_unwinder (gdbarch, &sparc32_frame_unwind);
1742
1743   /* If we have register sets, enable the generic core file support.  */
1744   if (tdep->gregset)
1745     set_gdbarch_regset_from_core_section (gdbarch,
1746                                           sparc_regset_from_core_section);
1747
1748   register_sparc_ravenscar_ops (gdbarch);
1749
1750   return gdbarch;
1751 }
1752 \f
1753 /* Helper functions for dealing with register windows.  */
1754
1755 void
1756 sparc_supply_rwindow (struct regcache *regcache, CORE_ADDR sp, int regnum)
1757 {
1758   struct gdbarch *gdbarch = get_regcache_arch (regcache);
1759   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1760   int offset = 0;
1761   gdb_byte buf[8];
1762   int i;
1763
1764   if (sp & 1)
1765     {
1766       /* Registers are 64-bit.  */
1767       sp += BIAS;
1768
1769       for (i = SPARC_L0_REGNUM; i <= SPARC_I7_REGNUM; i++)
1770         {
1771           if (regnum == i || regnum == -1)
1772             {
1773               target_read_memory (sp + ((i - SPARC_L0_REGNUM) * 8), buf, 8);
1774
1775               /* Handle StackGhost.  */
1776               if (i == SPARC_I7_REGNUM)
1777                 {
1778                   ULONGEST wcookie = sparc_fetch_wcookie (gdbarch);
1779                   ULONGEST i7;
1780
1781                   i7 = extract_unsigned_integer (buf + offset, 8, byte_order);
1782                   store_unsigned_integer (buf + offset, 8, byte_order,
1783                                           i7 ^ wcookie);
1784                 }
1785
1786               regcache_raw_supply (regcache, i, buf);
1787             }
1788         }
1789     }
1790   else
1791     {
1792       /* Registers are 32-bit.  Toss any sign-extension of the stack
1793          pointer.  */
1794       sp &= 0xffffffffUL;
1795
1796       /* Clear out the top half of the temporary buffer, and put the
1797          register value in the bottom half if we're in 64-bit mode.  */
1798       if (gdbarch_ptr_bit (get_regcache_arch (regcache)) == 64)
1799         {
1800           memset (buf, 0, 4);
1801           offset = 4;
1802         }
1803
1804       for (i = SPARC_L0_REGNUM; i <= SPARC_I7_REGNUM; i++)
1805         {
1806           if (regnum == i || regnum == -1)
1807             {
1808               target_read_memory (sp + ((i - SPARC_L0_REGNUM) * 4),
1809                                   buf + offset, 4);
1810
1811               /* Handle StackGhost.  */
1812               if (i == SPARC_I7_REGNUM)
1813                 {
1814                   ULONGEST wcookie = sparc_fetch_wcookie (gdbarch);
1815                   ULONGEST i7;
1816
1817                   i7 = extract_unsigned_integer (buf + offset, 4, byte_order);
1818                   store_unsigned_integer (buf + offset, 4, byte_order,
1819                                           i7 ^ wcookie);
1820                 }
1821
1822               regcache_raw_supply (regcache, i, buf);
1823             }
1824         }
1825     }
1826 }
1827
1828 void
1829 sparc_collect_rwindow (const struct regcache *regcache,
1830                        CORE_ADDR sp, int regnum)
1831 {
1832   struct gdbarch *gdbarch = get_regcache_arch (regcache);
1833   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1834   int offset = 0;
1835   gdb_byte buf[8];
1836   int i;
1837
1838   if (sp & 1)
1839     {
1840       /* Registers are 64-bit.  */
1841       sp += BIAS;
1842
1843       for (i = SPARC_L0_REGNUM; i <= SPARC_I7_REGNUM; i++)
1844         {
1845           if (regnum == -1 || regnum == SPARC_SP_REGNUM || regnum == i)
1846             {
1847               regcache_raw_collect (regcache, i, buf);
1848
1849               /* Handle StackGhost.  */
1850               if (i == SPARC_I7_REGNUM)
1851                 {
1852                   ULONGEST wcookie = sparc_fetch_wcookie (gdbarch);
1853                   ULONGEST i7;
1854
1855                   i7 = extract_unsigned_integer (buf + offset, 8, byte_order);
1856                   store_unsigned_integer (buf, 8, byte_order, i7 ^ wcookie);
1857                 }
1858
1859               target_write_memory (sp + ((i - SPARC_L0_REGNUM) * 8), buf, 8);
1860             }
1861         }
1862     }
1863   else
1864     {
1865       /* Registers are 32-bit.  Toss any sign-extension of the stack
1866          pointer.  */
1867       sp &= 0xffffffffUL;
1868
1869       /* Only use the bottom half if we're in 64-bit mode.  */
1870       if (gdbarch_ptr_bit (get_regcache_arch (regcache)) == 64)
1871         offset = 4;
1872
1873       for (i = SPARC_L0_REGNUM; i <= SPARC_I7_REGNUM; i++)
1874         {
1875           if (regnum == -1 || regnum == SPARC_SP_REGNUM || regnum == i)
1876             {
1877               regcache_raw_collect (regcache, i, buf);
1878
1879               /* Handle StackGhost.  */
1880               if (i == SPARC_I7_REGNUM)
1881                 {
1882                   ULONGEST wcookie = sparc_fetch_wcookie (gdbarch);
1883                   ULONGEST i7;
1884
1885                   i7 = extract_unsigned_integer (buf + offset, 4, byte_order);
1886                   store_unsigned_integer (buf + offset, 4, byte_order,
1887                                           i7 ^ wcookie);
1888                 }
1889
1890               target_write_memory (sp + ((i - SPARC_L0_REGNUM) * 4),
1891                                    buf + offset, 4);
1892             }
1893         }
1894     }
1895 }
1896
1897 /* Helper functions for dealing with register sets.  */
1898
1899 void
1900 sparc32_supply_gregset (const struct sparc_gregmap *gregmap,
1901                         struct regcache *regcache,
1902                         int regnum, const void *gregs)
1903 {
1904   const gdb_byte *regs = gregs;
1905   gdb_byte zero[4] = { 0 };
1906   int i;
1907
1908   if (regnum == SPARC32_PSR_REGNUM || regnum == -1)
1909     regcache_raw_supply (regcache, SPARC32_PSR_REGNUM,
1910                          regs + gregmap->r_psr_offset);
1911
1912   if (regnum == SPARC32_PC_REGNUM || regnum == -1)
1913     regcache_raw_supply (regcache, SPARC32_PC_REGNUM,
1914                          regs + gregmap->r_pc_offset);
1915
1916   if (regnum == SPARC32_NPC_REGNUM || regnum == -1)
1917     regcache_raw_supply (regcache, SPARC32_NPC_REGNUM,
1918                          regs + gregmap->r_npc_offset);
1919
1920   if (regnum == SPARC32_Y_REGNUM || regnum == -1)
1921     regcache_raw_supply (regcache, SPARC32_Y_REGNUM,
1922                          regs + gregmap->r_y_offset);
1923
1924   if (regnum == SPARC_G0_REGNUM || regnum == -1)
1925     regcache_raw_supply (regcache, SPARC_G0_REGNUM, &zero);
1926
1927   if ((regnum >= SPARC_G1_REGNUM && regnum <= SPARC_O7_REGNUM) || regnum == -1)
1928     {
1929       int offset = gregmap->r_g1_offset;
1930
1931       for (i = SPARC_G1_REGNUM; i <= SPARC_O7_REGNUM; i++)
1932         {
1933           if (regnum == i || regnum == -1)
1934             regcache_raw_supply (regcache, i, regs + offset);
1935           offset += 4;
1936         }
1937     }
1938
1939   if ((regnum >= SPARC_L0_REGNUM && regnum <= SPARC_I7_REGNUM) || regnum == -1)
1940     {
1941       /* Not all of the register set variants include Locals and
1942          Inputs.  For those that don't, we read them off the stack.  */
1943       if (gregmap->r_l0_offset == -1)
1944         {
1945           ULONGEST sp;
1946
1947           regcache_cooked_read_unsigned (regcache, SPARC_SP_REGNUM, &sp);
1948           sparc_supply_rwindow (regcache, sp, regnum);
1949         }
1950       else
1951         {
1952           int offset = gregmap->r_l0_offset;
1953
1954           for (i = SPARC_L0_REGNUM; i <= SPARC_I7_REGNUM; i++)
1955             {
1956               if (regnum == i || regnum == -1)
1957                 regcache_raw_supply (regcache, i, regs + offset);
1958               offset += 4;
1959             }
1960         }
1961     }
1962 }
1963
1964 void
1965 sparc32_collect_gregset (const struct sparc_gregmap *gregmap,
1966                          const struct regcache *regcache,
1967                          int regnum, void *gregs)
1968 {
1969   gdb_byte *regs = gregs;
1970   int i;
1971
1972   if (regnum == SPARC32_PSR_REGNUM || regnum == -1)
1973     regcache_raw_collect (regcache, SPARC32_PSR_REGNUM,
1974                           regs + gregmap->r_psr_offset);
1975
1976   if (regnum == SPARC32_PC_REGNUM || regnum == -1)
1977     regcache_raw_collect (regcache, SPARC32_PC_REGNUM,
1978                           regs + gregmap->r_pc_offset);
1979
1980   if (regnum == SPARC32_NPC_REGNUM || regnum == -1)
1981     regcache_raw_collect (regcache, SPARC32_NPC_REGNUM,
1982                           regs + gregmap->r_npc_offset);
1983
1984   if (regnum == SPARC32_Y_REGNUM || regnum == -1)
1985     regcache_raw_collect (regcache, SPARC32_Y_REGNUM,
1986                           regs + gregmap->r_y_offset);
1987
1988   if ((regnum >= SPARC_G1_REGNUM && regnum <= SPARC_O7_REGNUM) || regnum == -1)
1989     {
1990       int offset = gregmap->r_g1_offset;
1991
1992       /* %g0 is always zero.  */
1993       for (i = SPARC_G1_REGNUM; i <= SPARC_O7_REGNUM; i++)
1994         {
1995           if (regnum == i || regnum == -1)
1996             regcache_raw_collect (regcache, i, regs + offset);
1997           offset += 4;
1998         }
1999     }
2000
2001   if ((regnum >= SPARC_L0_REGNUM && regnum <= SPARC_I7_REGNUM) || regnum == -1)
2002     {
2003       /* Not all of the register set variants include Locals and
2004          Inputs.  For those that don't, we read them off the stack.  */
2005       if (gregmap->r_l0_offset != -1)
2006         {
2007           int offset = gregmap->r_l0_offset;
2008
2009           for (i = SPARC_L0_REGNUM; i <= SPARC_I7_REGNUM; i++)
2010             {
2011               if (regnum == i || regnum == -1)
2012                 regcache_raw_collect (regcache, i, regs + offset);
2013               offset += 4;
2014             }
2015         }
2016     }
2017 }
2018
2019 void
2020 sparc32_supply_fpregset (const struct sparc_fpregmap *fpregmap,
2021                          struct regcache *regcache,
2022                          int regnum, const void *fpregs)
2023 {
2024   const gdb_byte *regs = fpregs;
2025   int i;
2026
2027   for (i = 0; i < 32; i++)
2028     {
2029       if (regnum == (SPARC_F0_REGNUM + i) || regnum == -1)
2030         regcache_raw_supply (regcache, SPARC_F0_REGNUM + i,
2031                              regs + fpregmap->r_f0_offset + (i * 4));
2032     }
2033
2034   if (regnum == SPARC32_FSR_REGNUM || regnum == -1)
2035     regcache_raw_supply (regcache, SPARC32_FSR_REGNUM,
2036                          regs + fpregmap->r_fsr_offset);
2037 }
2038
2039 void
2040 sparc32_collect_fpregset (const struct sparc_fpregmap *fpregmap,
2041                           const struct regcache *regcache,
2042                           int regnum, void *fpregs)
2043 {
2044   gdb_byte *regs = fpregs;
2045   int i;
2046
2047   for (i = 0; i < 32; i++)
2048     {
2049       if (regnum == (SPARC_F0_REGNUM + i) || regnum == -1)
2050         regcache_raw_collect (regcache, SPARC_F0_REGNUM + i,
2051                               regs + fpregmap->r_f0_offset + (i * 4));
2052     }
2053
2054   if (regnum == SPARC32_FSR_REGNUM || regnum == -1)
2055     regcache_raw_collect (regcache, SPARC32_FSR_REGNUM,
2056                           regs + fpregmap->r_fsr_offset);
2057 }
2058 \f
2059
2060 /* SunOS 4.  */
2061
2062 /* From <machine/reg.h>.  */
2063 const struct sparc_gregmap sparc32_sunos4_gregmap =
2064 {
2065   0 * 4,                        /* %psr */
2066   1 * 4,                        /* %pc */
2067   2 * 4,                        /* %npc */
2068   3 * 4,                        /* %y */
2069   -1,                           /* %wim */
2070   -1,                           /* %tbr */
2071   4 * 4,                        /* %g1 */
2072   -1                            /* %l0 */
2073 };
2074
2075 const struct sparc_fpregmap sparc32_sunos4_fpregmap =
2076 {
2077   0 * 4,                        /* %f0 */
2078   33 * 4,                       /* %fsr */
2079 };
2080
2081 const struct sparc_fpregmap sparc32_bsd_fpregmap =
2082 {
2083   0 * 4,                        /* %f0 */
2084   32 * 4,                       /* %fsr */
2085 };
2086 \f
2087
2088 /* Provide a prototype to silence -Wmissing-prototypes.  */
2089 void _initialize_sparc_tdep (void);
2090
2091 void
2092 _initialize_sparc_tdep (void)
2093 {
2094   register_gdbarch_init (bfd_arch_sparc, sparc32_gdbarch_init);
2095 }