gdb/
[deliverable/binutils-gdb.git] / gdb / sparc64-tdep.c
1 /* Target-dependent code for UltraSPARC.
2
3 Copyright (C) 2003, 2004, 2005 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., 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
21
22 #include "defs.h"
23 #include "arch-utils.h"
24 #include "dwarf2-frame.h"
25 #include "floatformat.h"
26 #include "frame.h"
27 #include "frame-base.h"
28 #include "frame-unwind.h"
29 #include "gdbcore.h"
30 #include "gdbtypes.h"
31 #include "inferior.h"
32 #include "symtab.h"
33 #include "objfiles.h"
34 #include "osabi.h"
35 #include "regcache.h"
36 #include "target.h"
37 #include "value.h"
38
39 #include "gdb_assert.h"
40 #include "gdb_string.h"
41
42 #include "sparc64-tdep.h"
43
44 /* This file implements the The SPARC 64-bit ABI as defined by the
45 section "Low-Level System Information" of the SPARC Compliance
46 Definition (SCD) 2.4.1, which is the 64-bit System V psABI for
47 SPARC. */
48
49 /* Please use the sparc32_-prefix for 32-bit specific code, the
50 sparc64_-prefix for 64-bit specific code and the sparc_-prefix for
51 code can handle both. */
52 \f
53 /* The functions on this page are intended to be used to classify
54 function arguments. */
55
56 /* Check whether TYPE is "Integral or Pointer". */
57
58 static int
59 sparc64_integral_or_pointer_p (const struct type *type)
60 {
61 switch (TYPE_CODE (type))
62 {
63 case TYPE_CODE_INT:
64 case TYPE_CODE_BOOL:
65 case TYPE_CODE_CHAR:
66 case TYPE_CODE_ENUM:
67 case TYPE_CODE_RANGE:
68 {
69 int len = TYPE_LENGTH (type);
70 gdb_assert (len == 1 || len == 2 || len == 4 || len == 8);
71 }
72 return 1;
73 case TYPE_CODE_PTR:
74 case TYPE_CODE_REF:
75 {
76 int len = TYPE_LENGTH (type);
77 gdb_assert (len == 8);
78 }
79 return 1;
80 default:
81 break;
82 }
83
84 return 0;
85 }
86
87 /* Check whether TYPE is "Floating". */
88
89 static int
90 sparc64_floating_p (const struct type *type)
91 {
92 switch (TYPE_CODE (type))
93 {
94 case TYPE_CODE_FLT:
95 {
96 int len = TYPE_LENGTH (type);
97 gdb_assert (len == 4 || len == 8 || len == 16);
98 }
99 return 1;
100 default:
101 break;
102 }
103
104 return 0;
105 }
106
107 /* Check whether TYPE is "Structure or Union". */
108
109 static int
110 sparc64_structure_or_union_p (const struct type *type)
111 {
112 switch (TYPE_CODE (type))
113 {
114 case TYPE_CODE_STRUCT:
115 case TYPE_CODE_UNION:
116 return 1;
117 default:
118 break;
119 }
120
121 return 0;
122 }
123
124 /* Register information. */
125
126 struct sparc64_register_info
127 {
128 char *name;
129 struct type **type;
130 };
131
132 static struct sparc64_register_info sparc64_register_info[] =
133 {
134 { "g0", &builtin_type_int64 },
135 { "g1", &builtin_type_int64 },
136 { "g2", &builtin_type_int64 },
137 { "g3", &builtin_type_int64 },
138 { "g4", &builtin_type_int64 },
139 { "g5", &builtin_type_int64 },
140 { "g6", &builtin_type_int64 },
141 { "g7", &builtin_type_int64 },
142
143 { "o0", &builtin_type_int64 },
144 { "o1", &builtin_type_int64 },
145 { "o2", &builtin_type_int64 },
146 { "o3", &builtin_type_int64 },
147 { "o4", &builtin_type_int64 },
148 { "o5", &builtin_type_int64 },
149 { "sp", &builtin_type_void_data_ptr },
150 { "o7", &builtin_type_int64 },
151
152 { "l0", &builtin_type_int64 },
153 { "l1", &builtin_type_int64 },
154 { "l2", &builtin_type_int64 },
155 { "l3", &builtin_type_int64 },
156 { "l4", &builtin_type_int64 },
157 { "l5", &builtin_type_int64 },
158 { "l6", &builtin_type_int64 },
159 { "l7", &builtin_type_int64 },
160
161 { "i0", &builtin_type_int64 },
162 { "i1", &builtin_type_int64 },
163 { "i2", &builtin_type_int64 },
164 { "i3", &builtin_type_int64 },
165 { "i4", &builtin_type_int64 },
166 { "i5", &builtin_type_int64 },
167 { "fp", &builtin_type_void_data_ptr },
168 { "i7", &builtin_type_int64 },
169
170 { "f0", &builtin_type_float },
171 { "f1", &builtin_type_float },
172 { "f2", &builtin_type_float },
173 { "f3", &builtin_type_float },
174 { "f4", &builtin_type_float },
175 { "f5", &builtin_type_float },
176 { "f6", &builtin_type_float },
177 { "f7", &builtin_type_float },
178 { "f8", &builtin_type_float },
179 { "f9", &builtin_type_float },
180 { "f10", &builtin_type_float },
181 { "f11", &builtin_type_float },
182 { "f12", &builtin_type_float },
183 { "f13", &builtin_type_float },
184 { "f14", &builtin_type_float },
185 { "f15", &builtin_type_float },
186 { "f16", &builtin_type_float },
187 { "f17", &builtin_type_float },
188 { "f18", &builtin_type_float },
189 { "f19", &builtin_type_float },
190 { "f20", &builtin_type_float },
191 { "f21", &builtin_type_float },
192 { "f22", &builtin_type_float },
193 { "f23", &builtin_type_float },
194 { "f24", &builtin_type_float },
195 { "f25", &builtin_type_float },
196 { "f26", &builtin_type_float },
197 { "f27", &builtin_type_float },
198 { "f28", &builtin_type_float },
199 { "f29", &builtin_type_float },
200 { "f30", &builtin_type_float },
201 { "f31", &builtin_type_float },
202 { "f32", &builtin_type_double },
203 { "f34", &builtin_type_double },
204 { "f36", &builtin_type_double },
205 { "f38", &builtin_type_double },
206 { "f40", &builtin_type_double },
207 { "f42", &builtin_type_double },
208 { "f44", &builtin_type_double },
209 { "f46", &builtin_type_double },
210 { "f48", &builtin_type_double },
211 { "f50", &builtin_type_double },
212 { "f52", &builtin_type_double },
213 { "f54", &builtin_type_double },
214 { "f56", &builtin_type_double },
215 { "f58", &builtin_type_double },
216 { "f60", &builtin_type_double },
217 { "f62", &builtin_type_double },
218
219 { "pc", &builtin_type_void_func_ptr },
220 { "npc", &builtin_type_void_func_ptr },
221
222 /* This raw register contains the contents of %cwp, %pstate, %asi
223 and %ccr as laid out in a %tstate register. */
224 /* FIXME: Give it a name until we start using register groups. */
225 { "state", &builtin_type_int64 },
226
227 { "fsr", &builtin_type_int64 },
228 { "fprs", &builtin_type_int64 },
229
230 /* "Although Y is a 64-bit register, its high-order 32 bits are
231 reserved and always read as 0." */
232 { "y", &builtin_type_int64 }
233 };
234
235 /* Total number of registers. */
236 #define SPARC64_NUM_REGS ARRAY_SIZE (sparc64_register_info)
237
238 /* We provide the aliases %d0..%d62 and %q0..%q60 for the floating
239 registers as "psuedo" registers. */
240
241 static struct sparc64_register_info sparc64_pseudo_register_info[] =
242 {
243 { "cwp", &builtin_type_int64 },
244 { "pstate", &builtin_type_int64 },
245 { "asi", &builtin_type_int64 },
246 { "ccr", &builtin_type_int64 },
247
248 { "d0", &builtin_type_double },
249 { "d2", &builtin_type_double },
250 { "d4", &builtin_type_double },
251 { "d6", &builtin_type_double },
252 { "d8", &builtin_type_double },
253 { "d10", &builtin_type_double },
254 { "d12", &builtin_type_double },
255 { "d14", &builtin_type_double },
256 { "d16", &builtin_type_double },
257 { "d18", &builtin_type_double },
258 { "d20", &builtin_type_double },
259 { "d22", &builtin_type_double },
260 { "d24", &builtin_type_double },
261 { "d26", &builtin_type_double },
262 { "d28", &builtin_type_double },
263 { "d30", &builtin_type_double },
264 { "d32", &builtin_type_double },
265 { "d34", &builtin_type_double },
266 { "d36", &builtin_type_double },
267 { "d38", &builtin_type_double },
268 { "d40", &builtin_type_double },
269 { "d42", &builtin_type_double },
270 { "d44", &builtin_type_double },
271 { "d46", &builtin_type_double },
272 { "d48", &builtin_type_double },
273 { "d50", &builtin_type_double },
274 { "d52", &builtin_type_double },
275 { "d54", &builtin_type_double },
276 { "d56", &builtin_type_double },
277 { "d58", &builtin_type_double },
278 { "d60", &builtin_type_double },
279 { "d62", &builtin_type_double },
280
281 { "q0", &builtin_type_long_double },
282 { "q4", &builtin_type_long_double },
283 { "q8", &builtin_type_long_double },
284 { "q12", &builtin_type_long_double },
285 { "q16", &builtin_type_long_double },
286 { "q20", &builtin_type_long_double },
287 { "q24", &builtin_type_long_double },
288 { "q28", &builtin_type_long_double },
289 { "q32", &builtin_type_long_double },
290 { "q36", &builtin_type_long_double },
291 { "q40", &builtin_type_long_double },
292 { "q44", &builtin_type_long_double },
293 { "q48", &builtin_type_long_double },
294 { "q52", &builtin_type_long_double },
295 { "q56", &builtin_type_long_double },
296 { "q60", &builtin_type_long_double }
297 };
298
299 /* Total number of pseudo registers. */
300 #define SPARC64_NUM_PSEUDO_REGS ARRAY_SIZE (sparc64_pseudo_register_info)
301
302 /* Return the name of register REGNUM. */
303
304 static const char *
305 sparc64_register_name (int regnum)
306 {
307 if (regnum >= 0 && regnum < SPARC64_NUM_REGS)
308 return sparc64_register_info[regnum].name;
309
310 if (regnum >= SPARC64_NUM_REGS
311 && regnum < SPARC64_NUM_REGS + SPARC64_NUM_PSEUDO_REGS)
312 return sparc64_pseudo_register_info[regnum - SPARC64_NUM_REGS].name;
313
314 return NULL;
315 }
316
317 /* Return the GDB type object for the "standard" data type of data in
318 register REGNUM. */
319
320 static struct type *
321 sparc64_register_type (struct gdbarch *gdbarch, int regnum)
322 {
323 if (regnum >= SPARC64_NUM_REGS
324 && regnum < SPARC64_NUM_REGS + SPARC64_NUM_PSEUDO_REGS)
325 return *sparc64_pseudo_register_info[regnum - SPARC64_NUM_REGS].type;
326
327 gdb_assert (regnum >= 0 && regnum < SPARC64_NUM_REGS);
328 return *sparc64_register_info[regnum].type;
329 }
330
331 static void
332 sparc64_pseudo_register_read (struct gdbarch *gdbarch,
333 struct regcache *regcache,
334 int regnum, gdb_byte *buf)
335 {
336 gdb_assert (regnum >= SPARC64_NUM_REGS);
337
338 if (regnum >= SPARC64_D0_REGNUM && regnum <= SPARC64_D30_REGNUM)
339 {
340 regnum = SPARC_F0_REGNUM + 2 * (regnum - SPARC64_D0_REGNUM);
341 regcache_raw_read (regcache, regnum, buf);
342 regcache_raw_read (regcache, regnum + 1, buf + 4);
343 }
344 else if (regnum >= SPARC64_D32_REGNUM && regnum <= SPARC64_D62_REGNUM)
345 {
346 regnum = SPARC64_F32_REGNUM + (regnum - SPARC64_D32_REGNUM);
347 regcache_raw_read (regcache, regnum, buf);
348 }
349 else if (regnum >= SPARC64_Q0_REGNUM && regnum <= SPARC64_Q28_REGNUM)
350 {
351 regnum = SPARC_F0_REGNUM + 4 * (regnum - SPARC64_Q0_REGNUM);
352 regcache_raw_read (regcache, regnum, buf);
353 regcache_raw_read (regcache, regnum + 1, buf + 4);
354 regcache_raw_read (regcache, regnum + 2, buf + 8);
355 regcache_raw_read (regcache, regnum + 3, buf + 12);
356 }
357 else if (regnum >= SPARC64_Q32_REGNUM && regnum <= SPARC64_Q60_REGNUM)
358 {
359 regnum = SPARC64_F32_REGNUM + 2 * (regnum - SPARC64_Q32_REGNUM);
360 regcache_raw_read (regcache, regnum, buf);
361 regcache_raw_read (regcache, regnum + 1, buf + 8);
362 }
363 else if (regnum == SPARC64_CWP_REGNUM
364 || regnum == SPARC64_PSTATE_REGNUM
365 || regnum == SPARC64_ASI_REGNUM
366 || regnum == SPARC64_CCR_REGNUM)
367 {
368 ULONGEST state;
369
370 regcache_raw_read_unsigned (regcache, SPARC64_STATE_REGNUM, &state);
371 switch (regnum)
372 {
373 case SPARC64_CWP_REGNUM:
374 state = (state >> 0) & ((1 << 5) - 1);
375 break;
376 case SPARC64_PSTATE_REGNUM:
377 state = (state >> 8) & ((1 << 12) - 1);
378 break;
379 case SPARC64_ASI_REGNUM:
380 state = (state >> 24) & ((1 << 8) - 1);
381 break;
382 case SPARC64_CCR_REGNUM:
383 state = (state >> 32) & ((1 << 8) - 1);
384 break;
385 }
386 store_unsigned_integer (buf, 8, state);
387 }
388 }
389
390 static void
391 sparc64_pseudo_register_write (struct gdbarch *gdbarch,
392 struct regcache *regcache,
393 int regnum, const gdb_byte *buf)
394 {
395 gdb_assert (regnum >= SPARC64_NUM_REGS);
396
397 if (regnum >= SPARC64_D0_REGNUM && regnum <= SPARC64_D30_REGNUM)
398 {
399 regnum = SPARC_F0_REGNUM + 2 * (regnum - SPARC64_D0_REGNUM);
400 regcache_raw_write (regcache, regnum, buf);
401 regcache_raw_write (regcache, regnum + 1, buf + 4);
402 }
403 else if (regnum >= SPARC64_D32_REGNUM && regnum <= SPARC64_D62_REGNUM)
404 {
405 regnum = SPARC64_F32_REGNUM + (regnum - SPARC64_D32_REGNUM);
406 regcache_raw_write (regcache, regnum, buf);
407 }
408 else if (regnum >= SPARC64_Q0_REGNUM && regnum <= SPARC64_Q28_REGNUM)
409 {
410 regnum = SPARC_F0_REGNUM + 4 * (regnum - SPARC64_Q0_REGNUM);
411 regcache_raw_write (regcache, regnum, buf);
412 regcache_raw_write (regcache, regnum + 1, buf + 4);
413 regcache_raw_write (regcache, regnum + 2, buf + 8);
414 regcache_raw_write (regcache, regnum + 3, buf + 12);
415 }
416 else if (regnum >= SPARC64_Q32_REGNUM && regnum <= SPARC64_Q60_REGNUM)
417 {
418 regnum = SPARC64_F32_REGNUM + 2 * (regnum - SPARC64_Q32_REGNUM);
419 regcache_raw_write (regcache, regnum, buf);
420 regcache_raw_write (regcache, regnum + 1, buf + 8);
421 }
422 else if (regnum == SPARC64_CWP_REGNUM
423 || regnum == SPARC64_PSTATE_REGNUM
424 || regnum == SPARC64_ASI_REGNUM
425 || regnum == SPARC64_CCR_REGNUM)
426 {
427 ULONGEST state, bits;
428
429 regcache_raw_read_unsigned (regcache, SPARC64_STATE_REGNUM, &state);
430 bits = extract_unsigned_integer (buf, 8);
431 switch (regnum)
432 {
433 case SPARC64_CWP_REGNUM:
434 state |= ((bits & ((1 << 5) - 1)) << 0);
435 break;
436 case SPARC64_PSTATE_REGNUM:
437 state |= ((bits & ((1 << 12) - 1)) << 8);
438 break;
439 case SPARC64_ASI_REGNUM:
440 state |= ((bits & ((1 << 8) - 1)) << 24);
441 break;
442 case SPARC64_CCR_REGNUM:
443 state |= ((bits & ((1 << 8) - 1)) << 32);
444 break;
445 }
446 regcache_raw_write_unsigned (regcache, SPARC64_STATE_REGNUM, state);
447 }
448 }
449 \f
450
451 /* Return PC of first real instruction of the function starting at
452 START_PC. */
453
454 static CORE_ADDR
455 sparc64_skip_prologue (CORE_ADDR start_pc)
456 {
457 struct symtab_and_line sal;
458 CORE_ADDR func_start, func_end;
459 struct sparc_frame_cache cache;
460
461 /* This is the preferred method, find the end of the prologue by
462 using the debugging information. */
463 if (find_pc_partial_function (start_pc, NULL, &func_start, &func_end))
464 {
465 sal = find_pc_line (func_start, 0);
466
467 if (sal.end < func_end
468 && start_pc <= sal.end)
469 return sal.end;
470 }
471
472 return sparc_analyze_prologue (start_pc, 0xffffffffffffffffULL, &cache);
473 }
474
475 /* Normal frames. */
476
477 static struct sparc_frame_cache *
478 sparc64_frame_cache (struct frame_info *next_frame, void **this_cache)
479 {
480 return sparc_frame_cache (next_frame, this_cache);
481 }
482
483 static void
484 sparc64_frame_this_id (struct frame_info *next_frame, void **this_cache,
485 struct frame_id *this_id)
486 {
487 struct sparc_frame_cache *cache =
488 sparc64_frame_cache (next_frame, this_cache);
489
490 /* This marks the outermost frame. */
491 if (cache->base == 0)
492 return;
493
494 (*this_id) = frame_id_build (cache->base, cache->pc);
495 }
496
497 static void
498 sparc64_frame_prev_register (struct frame_info *next_frame, void **this_cache,
499 int regnum, int *optimizedp,
500 enum lval_type *lvalp, CORE_ADDR *addrp,
501 int *realnump, gdb_byte *valuep)
502 {
503 struct sparc_frame_cache *cache =
504 sparc64_frame_cache (next_frame, this_cache);
505
506 if (regnum == SPARC64_PC_REGNUM || regnum == SPARC64_NPC_REGNUM)
507 {
508 *optimizedp = 0;
509 *lvalp = not_lval;
510 *addrp = 0;
511 *realnump = -1;
512 if (valuep)
513 {
514 CORE_ADDR pc = (regnum == SPARC64_NPC_REGNUM) ? 4 : 0;
515
516 regnum = cache->frameless_p ? SPARC_O7_REGNUM : SPARC_I7_REGNUM;
517 pc += frame_unwind_register_unsigned (next_frame, regnum) + 8;
518 store_unsigned_integer (valuep, 8, pc);
519 }
520 return;
521 }
522
523 /* Handle StackGhost. */
524 {
525 ULONGEST wcookie = sparc_fetch_wcookie ();
526
527 if (wcookie != 0 && !cache->frameless_p && regnum == SPARC_I7_REGNUM)
528 {
529 *optimizedp = 0;
530 *lvalp = not_lval;
531 *addrp = 0;
532 *realnump = -1;
533 if (valuep)
534 {
535 CORE_ADDR addr = cache->base + (regnum - SPARC_L0_REGNUM) * 8;
536 ULONGEST i7;
537
538 /* Read the value in from memory. */
539 i7 = get_frame_memory_unsigned (next_frame, addr, 8);
540 store_unsigned_integer (valuep, 8, i7 ^ wcookie);
541 }
542 return;
543 }
544 }
545
546 /* The previous frame's `local' and `in' registers have been saved
547 in the register save area. */
548 if (!cache->frameless_p
549 && regnum >= SPARC_L0_REGNUM && regnum <= SPARC_I7_REGNUM)
550 {
551 *optimizedp = 0;
552 *lvalp = lval_memory;
553 *addrp = cache->base + (regnum - SPARC_L0_REGNUM) * 8;
554 *realnump = -1;
555 if (valuep)
556 {
557 struct gdbarch *gdbarch = get_frame_arch (next_frame);
558
559 /* Read the value in from memory. */
560 read_memory (*addrp, valuep, register_size (gdbarch, regnum));
561 }
562 return;
563 }
564
565 /* The previous frame's `out' registers are accessable as the
566 current frame's `in' registers. */
567 if (!cache->frameless_p
568 && regnum >= SPARC_O0_REGNUM && regnum <= SPARC_O7_REGNUM)
569 regnum += (SPARC_I0_REGNUM - SPARC_O0_REGNUM);
570
571 *optimizedp = 0;
572 *lvalp = lval_register;
573 *addrp = 0;
574 *realnump = regnum;
575 if (valuep)
576 frame_unwind_register (next_frame, regnum, valuep);
577 }
578
579 static const struct frame_unwind sparc64_frame_unwind =
580 {
581 NORMAL_FRAME,
582 sparc64_frame_this_id,
583 sparc64_frame_prev_register
584 };
585
586 static const struct frame_unwind *
587 sparc64_frame_sniffer (struct frame_info *next_frame)
588 {
589 return &sparc64_frame_unwind;
590 }
591 \f
592
593 static CORE_ADDR
594 sparc64_frame_base_address (struct frame_info *next_frame, void **this_cache)
595 {
596 struct sparc_frame_cache *cache =
597 sparc64_frame_cache (next_frame, this_cache);
598
599 return cache->base;
600 }
601
602 static const struct frame_base sparc64_frame_base =
603 {
604 &sparc64_frame_unwind,
605 sparc64_frame_base_address,
606 sparc64_frame_base_address,
607 sparc64_frame_base_address
608 };
609 \f
610 /* Check whether TYPE must be 16-byte aligned. */
611
612 static int
613 sparc64_16_byte_align_p (struct type *type)
614 {
615 if (sparc64_floating_p (type) && TYPE_LENGTH (type) == 16)
616 return 1;
617
618 if (sparc64_structure_or_union_p (type))
619 {
620 int i;
621
622 for (i = 0; i < TYPE_NFIELDS (type); i++)
623 {
624 struct type *subtype = check_typedef (TYPE_FIELD_TYPE (type, i));
625
626 if (sparc64_16_byte_align_p (subtype))
627 return 1;
628 }
629 }
630
631 return 0;
632 }
633
634 /* Store floating fields of element ELEMENT of an "parameter array"
635 that has type TYPE and is stored at BITPOS in VALBUF in the
636 apropriate registers of REGCACHE. This function can be called
637 recursively and therefore handles floating types in addition to
638 structures. */
639
640 static void
641 sparc64_store_floating_fields (struct regcache *regcache, struct type *type,
642 const gdb_byte *valbuf, int element, int bitpos)
643 {
644 gdb_assert (element < 16);
645
646 if (sparc64_floating_p (type))
647 {
648 int len = TYPE_LENGTH (type);
649 int regnum;
650
651 if (len == 16)
652 {
653 gdb_assert (bitpos == 0);
654 gdb_assert ((element % 2) == 0);
655
656 regnum = SPARC64_Q0_REGNUM + element / 2;
657 regcache_cooked_write (regcache, regnum, valbuf);
658 }
659 else if (len == 8)
660 {
661 gdb_assert (bitpos == 0 || bitpos == 64);
662
663 regnum = SPARC64_D0_REGNUM + element + bitpos / 64;
664 regcache_cooked_write (regcache, regnum, valbuf + (bitpos / 8));
665 }
666 else
667 {
668 gdb_assert (len == 4);
669 gdb_assert (bitpos % 32 == 0 && bitpos >= 0 && bitpos < 128);
670
671 regnum = SPARC_F0_REGNUM + element * 2 + bitpos / 32;
672 regcache_cooked_write (regcache, regnum, valbuf + (bitpos / 8));
673 }
674 }
675 else if (sparc64_structure_or_union_p (type))
676 {
677 int i;
678
679 for (i = 0; i < TYPE_NFIELDS (type); i++)
680 {
681 struct type *subtype = check_typedef (TYPE_FIELD_TYPE (type, i));
682 int subpos = bitpos + TYPE_FIELD_BITPOS (type, i);
683
684 sparc64_store_floating_fields (regcache, subtype, valbuf,
685 element, subpos);
686 }
687
688 /* GCC has an interesting bug. If TYPE is a structure that has
689 a single `float' member, GCC doesn't treat it as a structure
690 at all, but rather as an ordinary `float' argument. This
691 argument will be stored in %f1, as required by the psABI.
692 However, as a member of a structure the psABI requires it to
693 be stored in %f0. This bug is present in GCC 3.3.2, but
694 probably in older releases to. To appease GCC, if a
695 structure has only a single `float' member, we store its
696 value in %f1 too (we already have stored in %f0). */
697 if (TYPE_NFIELDS (type) == 1)
698 {
699 struct type *subtype = check_typedef (TYPE_FIELD_TYPE (type, 0));
700
701 if (sparc64_floating_p (subtype) && TYPE_LENGTH (subtype) == 4)
702 regcache_cooked_write (regcache, SPARC_F1_REGNUM, valbuf);
703 }
704 }
705 }
706
707 /* Fetch floating fields from a variable of type TYPE from the
708 appropriate registers for BITPOS in REGCACHE and store it at BITPOS
709 in VALBUF. This function can be called recursively and therefore
710 handles floating types in addition to structures. */
711
712 static void
713 sparc64_extract_floating_fields (struct regcache *regcache, struct type *type,
714 gdb_byte *valbuf, int bitpos)
715 {
716 if (sparc64_floating_p (type))
717 {
718 int len = TYPE_LENGTH (type);
719 int regnum;
720
721 if (len == 16)
722 {
723 gdb_assert (bitpos == 0 || bitpos == 128);
724
725 regnum = SPARC64_Q0_REGNUM + bitpos / 128;
726 regcache_cooked_read (regcache, regnum, valbuf + (bitpos / 8));
727 }
728 else if (len == 8)
729 {
730 gdb_assert (bitpos % 64 == 0 && bitpos >= 0 && bitpos < 256);
731
732 regnum = SPARC64_D0_REGNUM + bitpos / 64;
733 regcache_cooked_read (regcache, regnum, valbuf + (bitpos / 8));
734 }
735 else
736 {
737 gdb_assert (len == 4);
738 gdb_assert (bitpos % 32 == 0 && bitpos >= 0 && bitpos < 256);
739
740 regnum = SPARC_F0_REGNUM + bitpos / 32;
741 regcache_cooked_read (regcache, regnum, valbuf + (bitpos / 8));
742 }
743 }
744 else if (sparc64_structure_or_union_p (type))
745 {
746 int i;
747
748 for (i = 0; i < TYPE_NFIELDS (type); i++)
749 {
750 struct type *subtype = check_typedef (TYPE_FIELD_TYPE (type, i));
751 int subpos = bitpos + TYPE_FIELD_BITPOS (type, i);
752
753 sparc64_extract_floating_fields (regcache, subtype, valbuf, subpos);
754 }
755 }
756 }
757
758 /* Store the NARGS arguments ARGS and STRUCT_ADDR (if STRUCT_RETURN is
759 non-zero) in REGCACHE and on the stack (starting from address SP). */
760
761 static CORE_ADDR
762 sparc64_store_arguments (struct regcache *regcache, int nargs,
763 struct value **args, CORE_ADDR sp,
764 int struct_return, CORE_ADDR struct_addr)
765 {
766 /* Number of extended words in the "parameter array". */
767 int num_elements = 0;
768 int element = 0;
769 int i;
770
771 /* Take BIAS into account. */
772 sp += BIAS;
773
774 /* First we calculate the number of extended words in the "parameter
775 array". While doing so we also convert some of the arguments. */
776
777 if (struct_return)
778 num_elements++;
779
780 for (i = 0; i < nargs; i++)
781 {
782 struct type *type = value_type (args[i]);
783 int len = TYPE_LENGTH (type);
784
785 if (sparc64_structure_or_union_p (type))
786 {
787 /* Structure or Union arguments. */
788 if (len <= 16)
789 {
790 if (num_elements % 2 && sparc64_16_byte_align_p (type))
791 num_elements++;
792 num_elements += ((len + 7) / 8);
793 }
794 else
795 {
796 /* The psABI says that "Structures or unions larger than
797 sixteen bytes are copied by the caller and passed
798 indirectly; the caller will pass the address of a
799 correctly aligned structure value. This sixty-four
800 bit address will occupy one word in the parameter
801 array, and may be promoted to an %o register like any
802 other pointer value." Allocate memory for these
803 values on the stack. */
804 sp -= len;
805
806 /* Use 16-byte alignment for these values. That's
807 always correct, and wasting a few bytes shouldn't be
808 a problem. */
809 sp &= ~0xf;
810
811 write_memory (sp, value_contents (args[i]), len);
812 args[i] = value_from_pointer (lookup_pointer_type (type), sp);
813 num_elements++;
814 }
815 }
816 else if (sparc64_floating_p (type))
817 {
818 /* Floating arguments. */
819
820 if (len == 16)
821 {
822 /* The psABI says that "Each quad-precision parameter
823 value will be assigned to two extended words in the
824 parameter array. */
825 num_elements += 2;
826
827 /* The psABI says that "Long doubles must be
828 quad-aligned, and thus a hole might be introduced
829 into the parameter array to force alignment." Skip
830 an element if necessary. */
831 if (num_elements % 2)
832 num_elements++;
833 }
834 else
835 num_elements++;
836 }
837 else
838 {
839 /* Integral and pointer arguments. */
840 gdb_assert (sparc64_integral_or_pointer_p (type));
841
842 /* The psABI says that "Each argument value of integral type
843 smaller than an extended word will be widened by the
844 caller to an extended word according to the signed-ness
845 of the argument type." */
846 if (len < 8)
847 args[i] = value_cast (builtin_type_int64, args[i]);
848 num_elements++;
849 }
850 }
851
852 /* Allocate the "parameter array". */
853 sp -= num_elements * 8;
854
855 /* The psABI says that "Every stack frame must be 16-byte aligned." */
856 sp &= ~0xf;
857
858 /* Now we store the arguments in to the "paramater array". Some
859 Integer or Pointer arguments and Structure or Union arguments
860 will be passed in %o registers. Some Floating arguments and
861 floating members of structures are passed in floating-point
862 registers. However, for functions with variable arguments,
863 floating arguments are stored in an %0 register, and for
864 functions without a prototype floating arguments are stored in
865 both a floating-point and an %o registers, or a floating-point
866 register and memory. To simplify the logic here we always pass
867 arguments in memory, an %o register, and a floating-point
868 register if appropriate. This should be no problem since the
869 contents of any unused memory or registers in the "parameter
870 array" are undefined. */
871
872 if (struct_return)
873 {
874 regcache_cooked_write_unsigned (regcache, SPARC_O0_REGNUM, struct_addr);
875 element++;
876 }
877
878 for (i = 0; i < nargs; i++)
879 {
880 const gdb_byte *valbuf = value_contents (args[i]);
881 struct type *type = value_type (args[i]);
882 int len = TYPE_LENGTH (type);
883 int regnum = -1;
884 gdb_byte buf[16];
885
886 if (sparc64_structure_or_union_p (type))
887 {
888 /* Structure or Union arguments. */
889 gdb_assert (len <= 16);
890 memset (buf, 0, sizeof (buf));
891 valbuf = memcpy (buf, valbuf, len);
892
893 if (element % 2 && sparc64_16_byte_align_p (type))
894 element++;
895
896 if (element < 6)
897 {
898 regnum = SPARC_O0_REGNUM + element;
899 if (len > 8 && element < 5)
900 regcache_cooked_write (regcache, regnum + 1, valbuf + 8);
901 }
902
903 if (element < 16)
904 sparc64_store_floating_fields (regcache, type, valbuf, element, 0);
905 }
906 else if (sparc64_floating_p (type))
907 {
908 /* Floating arguments. */
909 if (len == 16)
910 {
911 if (element % 2)
912 element++;
913 if (element < 16)
914 regnum = SPARC64_Q0_REGNUM + element / 2;
915 }
916 else if (len == 8)
917 {
918 if (element < 16)
919 regnum = SPARC64_D0_REGNUM + element;
920 }
921 else
922 {
923 /* The psABI says "Each single-precision parameter value
924 will be assigned to one extended word in the
925 parameter array, and right-justified within that
926 word; the left half (even floatregister) is
927 undefined." Even though the psABI says that "the
928 left half is undefined", set it to zero here. */
929 memset (buf, 0, 4);
930 memcpy (buf + 4, valbuf, 4);
931 valbuf = buf;
932 len = 8;
933 if (element < 16)
934 regnum = SPARC64_D0_REGNUM + element;
935 }
936 }
937 else
938 {
939 /* Integral and pointer arguments. */
940 gdb_assert (len == 8);
941 if (element < 6)
942 regnum = SPARC_O0_REGNUM + element;
943 }
944
945 if (regnum != -1)
946 {
947 regcache_cooked_write (regcache, regnum, valbuf);
948
949 /* If we're storing the value in a floating-point register,
950 also store it in the corresponding %0 register(s). */
951 if (regnum >= SPARC64_D0_REGNUM && regnum <= SPARC64_D10_REGNUM)
952 {
953 gdb_assert (element < 6);
954 regnum = SPARC_O0_REGNUM + element;
955 regcache_cooked_write (regcache, regnum, valbuf);
956 }
957 else if (regnum >= SPARC64_Q0_REGNUM && regnum <= SPARC64_Q8_REGNUM)
958 {
959 gdb_assert (element < 6);
960 regnum = SPARC_O0_REGNUM + element;
961 regcache_cooked_write (regcache, regnum, valbuf);
962 regcache_cooked_write (regcache, regnum + 1, valbuf + 8);
963 }
964 }
965
966 /* Always store the argument in memory. */
967 write_memory (sp + element * 8, valbuf, len);
968 element += ((len + 7) / 8);
969 }
970
971 gdb_assert (element == num_elements);
972
973 /* Take BIAS into account. */
974 sp -= BIAS;
975 return sp;
976 }
977
978 static CORE_ADDR
979 sparc64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
980 struct regcache *regcache, CORE_ADDR bp_addr,
981 int nargs, struct value **args, CORE_ADDR sp,
982 int struct_return, CORE_ADDR struct_addr)
983 {
984 /* Set return address. */
985 regcache_cooked_write_unsigned (regcache, SPARC_O7_REGNUM, bp_addr - 8);
986
987 /* Set up function arguments. */
988 sp = sparc64_store_arguments (regcache, nargs, args, sp,
989 struct_return, struct_addr);
990
991 /* Allocate the register save area. */
992 sp -= 16 * 8;
993
994 /* Stack should be 16-byte aligned at this point. */
995 gdb_assert ((sp + BIAS) % 16 == 0);
996
997 /* Finally, update the stack pointer. */
998 regcache_cooked_write_unsigned (regcache, SPARC_SP_REGNUM, sp);
999
1000 return sp + BIAS;
1001 }
1002 \f
1003
1004 /* Extract from an array REGBUF containing the (raw) register state, a
1005 function return value of TYPE, and copy that into VALBUF. */
1006
1007 static void
1008 sparc64_extract_return_value (struct type *type, struct regcache *regcache,
1009 gdb_byte *valbuf)
1010 {
1011 int len = TYPE_LENGTH (type);
1012 gdb_byte buf[32];
1013 int i;
1014
1015 if (sparc64_structure_or_union_p (type))
1016 {
1017 /* Structure or Union return values. */
1018 gdb_assert (len <= 32);
1019
1020 for (i = 0; i < ((len + 7) / 8); i++)
1021 regcache_cooked_read (regcache, SPARC_O0_REGNUM + i, buf + i * 8);
1022 if (TYPE_CODE (type) != TYPE_CODE_UNION)
1023 sparc64_extract_floating_fields (regcache, type, buf, 0);
1024 memcpy (valbuf, buf, len);
1025 }
1026 else if (sparc64_floating_p (type))
1027 {
1028 /* Floating return values. */
1029 for (i = 0; i < len / 4; i++)
1030 regcache_cooked_read (regcache, SPARC_F0_REGNUM + i, buf + i * 4);
1031 memcpy (valbuf, buf, len);
1032 }
1033 else
1034 {
1035 /* Integral and pointer return values. */
1036 gdb_assert (sparc64_integral_or_pointer_p (type));
1037
1038 /* Just stripping off any unused bytes should preserve the
1039 signed-ness just fine. */
1040 regcache_cooked_read (regcache, SPARC_O0_REGNUM, buf);
1041 memcpy (valbuf, buf + 8 - len, len);
1042 }
1043 }
1044
1045 /* Write into the appropriate registers a function return value stored
1046 in VALBUF of type TYPE. */
1047
1048 static void
1049 sparc64_store_return_value (struct type *type, struct regcache *regcache,
1050 const gdb_byte *valbuf)
1051 {
1052 int len = TYPE_LENGTH (type);
1053 gdb_byte buf[16];
1054 int i;
1055
1056 if (sparc64_structure_or_union_p (type))
1057 {
1058 /* Structure or Union return values. */
1059 gdb_assert (len <= 32);
1060
1061 /* Simplify matters by storing the complete value (including
1062 floating members) into %o0 and %o1. Floating members are
1063 also store in the appropriate floating-point registers. */
1064 memset (buf, 0, sizeof (buf));
1065 memcpy (buf, valbuf, len);
1066 for (i = 0; i < ((len + 7) / 8); i++)
1067 regcache_cooked_write (regcache, SPARC_O0_REGNUM + i, buf + i * 8);
1068 if (TYPE_CODE (type) != TYPE_CODE_UNION)
1069 sparc64_store_floating_fields (regcache, type, buf, 0, 0);
1070 }
1071 else if (sparc64_floating_p (type))
1072 {
1073 /* Floating return values. */
1074 memcpy (buf, valbuf, len);
1075 for (i = 0; i < len / 4; i++)
1076 regcache_cooked_write (regcache, SPARC_F0_REGNUM + i, buf + i * 4);
1077 }
1078 else
1079 {
1080 /* Integral and pointer return values. */
1081 gdb_assert (sparc64_integral_or_pointer_p (type));
1082
1083 /* ??? Do we need to do any sign-extension here? */
1084 memset (buf, 0, 8);
1085 memcpy (buf + 8 - len, valbuf, len);
1086 regcache_cooked_write (regcache, SPARC_O0_REGNUM, buf);
1087 }
1088 }
1089
1090 static enum return_value_convention
1091 sparc64_return_value (struct gdbarch *gdbarch, struct type *type,
1092 struct regcache *regcache, gdb_byte *readbuf,
1093 const gdb_byte *writebuf)
1094 {
1095 if (TYPE_LENGTH (type) > 32)
1096 return RETURN_VALUE_STRUCT_CONVENTION;
1097
1098 if (readbuf)
1099 sparc64_extract_return_value (type, regcache, readbuf);
1100 if (writebuf)
1101 sparc64_store_return_value (type, regcache, writebuf);
1102
1103 return RETURN_VALUE_REGISTER_CONVENTION;
1104 }
1105 \f
1106
1107 static void
1108 sparc64_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
1109 struct dwarf2_frame_state_reg *reg,
1110 struct frame_info *next_frame)
1111 {
1112 switch (regnum)
1113 {
1114 case SPARC_G0_REGNUM:
1115 /* Since %g0 is always zero, there is no point in saving it, and
1116 people will be inclined omit it from the CFI. Make sure we
1117 don't warn about that. */
1118 reg->how = DWARF2_FRAME_REG_SAME_VALUE;
1119 break;
1120 case SPARC_SP_REGNUM:
1121 reg->how = DWARF2_FRAME_REG_CFA;
1122 break;
1123 case SPARC64_PC_REGNUM:
1124 reg->how = DWARF2_FRAME_REG_RA_OFFSET;
1125 reg->loc.offset = 8;
1126 break;
1127 case SPARC64_NPC_REGNUM:
1128 reg->how = DWARF2_FRAME_REG_RA_OFFSET;
1129 reg->loc.offset = 12;
1130 break;
1131 }
1132 }
1133
1134 void
1135 sparc64_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
1136 {
1137 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1138
1139 tdep->pc_regnum = SPARC64_PC_REGNUM;
1140 tdep->npc_regnum = SPARC64_NPC_REGNUM;
1141
1142 /* This is what all the fuss is about. */
1143 set_gdbarch_long_bit (gdbarch, 64);
1144 set_gdbarch_long_long_bit (gdbarch, 64);
1145 set_gdbarch_ptr_bit (gdbarch, 64);
1146
1147 set_gdbarch_num_regs (gdbarch, SPARC64_NUM_REGS);
1148 set_gdbarch_register_name (gdbarch, sparc64_register_name);
1149 set_gdbarch_register_type (gdbarch, sparc64_register_type);
1150 set_gdbarch_num_pseudo_regs (gdbarch, SPARC64_NUM_PSEUDO_REGS);
1151 set_gdbarch_pseudo_register_read (gdbarch, sparc64_pseudo_register_read);
1152 set_gdbarch_pseudo_register_write (gdbarch, sparc64_pseudo_register_write);
1153
1154 /* Register numbers of various important registers. */
1155 set_gdbarch_pc_regnum (gdbarch, SPARC64_PC_REGNUM); /* %pc */
1156
1157 /* Call dummy code. */
1158 set_gdbarch_call_dummy_location (gdbarch, AT_ENTRY_POINT);
1159 set_gdbarch_push_dummy_code (gdbarch, NULL);
1160 set_gdbarch_push_dummy_call (gdbarch, sparc64_push_dummy_call);
1161
1162 set_gdbarch_return_value (gdbarch, sparc64_return_value);
1163 set_gdbarch_stabs_argument_has_addr
1164 (gdbarch, default_stabs_argument_has_addr);
1165
1166 set_gdbarch_skip_prologue (gdbarch, sparc64_skip_prologue);
1167
1168 /* Hook in the DWARF CFI frame unwinder. */
1169 dwarf2_frame_set_init_reg (gdbarch, sparc64_dwarf2_frame_init_reg);
1170 /* FIXME: kettenis/20050423: Don't enable the unwinder until the
1171 StackGhost issues have been resolved. */
1172
1173 frame_unwind_append_sniffer (gdbarch, sparc64_frame_sniffer);
1174 frame_base_set_default (gdbarch, &sparc64_frame_base);
1175 }
1176 \f
1177
1178 /* Helper functions for dealing with register sets. */
1179
1180 #define TSTATE_CWP 0x000000000000001fULL
1181 #define TSTATE_ICC 0x0000000f00000000ULL
1182 #define TSTATE_XCC 0x000000f000000000ULL
1183
1184 #define PSR_S 0x00000080
1185 #define PSR_ICC 0x00f00000
1186 #define PSR_VERS 0x0f000000
1187 #define PSR_IMPL 0xf0000000
1188 #define PSR_V8PLUS 0xff000000
1189 #define PSR_XCC 0x000f0000
1190
1191 void
1192 sparc64_supply_gregset (const struct sparc_gregset *gregset,
1193 struct regcache *regcache,
1194 int regnum, const void *gregs)
1195 {
1196 int sparc32 = (gdbarch_ptr_bit (current_gdbarch) == 32);
1197 const gdb_byte *regs = gregs;
1198 int i;
1199
1200 if (sparc32)
1201 {
1202 if (regnum == SPARC32_PSR_REGNUM || regnum == -1)
1203 {
1204 int offset = gregset->r_tstate_offset;
1205 ULONGEST tstate, psr;
1206 gdb_byte buf[4];
1207
1208 tstate = extract_unsigned_integer (regs + offset, 8);
1209 psr = ((tstate & TSTATE_CWP) | PSR_S | ((tstate & TSTATE_ICC) >> 12)
1210 | ((tstate & TSTATE_XCC) >> 20) | PSR_V8PLUS);
1211 store_unsigned_integer (buf, 4, psr);
1212 regcache_raw_supply (regcache, SPARC32_PSR_REGNUM, buf);
1213 }
1214
1215 if (regnum == SPARC32_PC_REGNUM || regnum == -1)
1216 regcache_raw_supply (regcache, SPARC32_PC_REGNUM,
1217 regs + gregset->r_pc_offset + 4);
1218
1219 if (regnum == SPARC32_NPC_REGNUM || regnum == -1)
1220 regcache_raw_supply (regcache, SPARC32_NPC_REGNUM,
1221 regs + gregset->r_npc_offset + 4);
1222
1223 if (regnum == SPARC32_Y_REGNUM || regnum == -1)
1224 {
1225 int offset = gregset->r_y_offset + 8 - gregset->r_y_size;
1226 regcache_raw_supply (regcache, SPARC32_Y_REGNUM, regs + offset);
1227 }
1228 }
1229 else
1230 {
1231 if (regnum == SPARC64_STATE_REGNUM || regnum == -1)
1232 regcache_raw_supply (regcache, SPARC64_STATE_REGNUM,
1233 regs + gregset->r_tstate_offset);
1234
1235 if (regnum == SPARC64_PC_REGNUM || regnum == -1)
1236 regcache_raw_supply (regcache, SPARC64_PC_REGNUM,
1237 regs + gregset->r_pc_offset);
1238
1239 if (regnum == SPARC64_NPC_REGNUM || regnum == -1)
1240 regcache_raw_supply (regcache, SPARC64_NPC_REGNUM,
1241 regs + gregset->r_npc_offset);
1242
1243 if (regnum == SPARC64_Y_REGNUM || regnum == -1)
1244 {
1245 gdb_byte buf[8];
1246
1247 memset (buf, 0, 8);
1248 memcpy (buf + 8 - gregset->r_y_size,
1249 regs + gregset->r_y_offset, gregset->r_y_size);
1250 regcache_raw_supply (regcache, SPARC64_Y_REGNUM, buf);
1251 }
1252
1253 if ((regnum == SPARC64_FPRS_REGNUM || regnum == -1)
1254 && gregset->r_fprs_offset != -1)
1255 regcache_raw_supply (regcache, SPARC64_FPRS_REGNUM,
1256 regs + gregset->r_fprs_offset);
1257 }
1258
1259 if (regnum == SPARC_G0_REGNUM || regnum == -1)
1260 regcache_raw_supply (regcache, SPARC_G0_REGNUM, NULL);
1261
1262 if ((regnum >= SPARC_G1_REGNUM && regnum <= SPARC_O7_REGNUM) || regnum == -1)
1263 {
1264 int offset = gregset->r_g1_offset;
1265
1266 if (sparc32)
1267 offset += 4;
1268
1269 for (i = SPARC_G1_REGNUM; i <= SPARC_O7_REGNUM; i++)
1270 {
1271 if (regnum == i || regnum == -1)
1272 regcache_raw_supply (regcache, i, regs + offset);
1273 offset += 8;
1274 }
1275 }
1276
1277 if ((regnum >= SPARC_L0_REGNUM && regnum <= SPARC_I7_REGNUM) || regnum == -1)
1278 {
1279 /* Not all of the register set variants include Locals and
1280 Inputs. For those that don't, we read them off the stack. */
1281 if (gregset->r_l0_offset == -1)
1282 {
1283 ULONGEST sp;
1284
1285 regcache_cooked_read_unsigned (regcache, SPARC_SP_REGNUM, &sp);
1286 sparc_supply_rwindow (regcache, sp, regnum);
1287 }
1288 else
1289 {
1290 int offset = gregset->r_l0_offset;
1291
1292 if (sparc32)
1293 offset += 4;
1294
1295 for (i = SPARC_L0_REGNUM; i <= SPARC_I7_REGNUM; i++)
1296 {
1297 if (regnum == i || regnum == -1)
1298 regcache_raw_supply (regcache, i, regs + offset);
1299 offset += 8;
1300 }
1301 }
1302 }
1303 }
1304
1305 void
1306 sparc64_collect_gregset (const struct sparc_gregset *gregset,
1307 const struct regcache *regcache,
1308 int regnum, void *gregs)
1309 {
1310 int sparc32 = (gdbarch_ptr_bit (current_gdbarch) == 32);
1311 gdb_byte *regs = gregs;
1312 int i;
1313
1314 if (sparc32)
1315 {
1316 if (regnum == SPARC32_PSR_REGNUM || regnum == -1)
1317 {
1318 int offset = gregset->r_tstate_offset;
1319 ULONGEST tstate, psr;
1320 gdb_byte buf[8];
1321
1322 tstate = extract_unsigned_integer (regs + offset, 8);
1323 regcache_raw_collect (regcache, SPARC32_PSR_REGNUM, buf);
1324 psr = extract_unsigned_integer (buf, 4);
1325 tstate |= (psr & PSR_ICC) << 12;
1326 if ((psr & (PSR_VERS | PSR_IMPL)) == PSR_V8PLUS)
1327 tstate |= (psr & PSR_XCC) << 20;
1328 store_unsigned_integer (buf, 8, tstate);
1329 memcpy (regs + offset, buf, 8);
1330 }
1331
1332 if (regnum == SPARC32_PC_REGNUM || regnum == -1)
1333 regcache_raw_collect (regcache, SPARC32_PC_REGNUM,
1334 regs + gregset->r_pc_offset + 4);
1335
1336 if (regnum == SPARC32_NPC_REGNUM || regnum == -1)
1337 regcache_raw_collect (regcache, SPARC32_NPC_REGNUM,
1338 regs + gregset->r_npc_offset + 4);
1339
1340 if (regnum == SPARC32_Y_REGNUM || regnum == -1)
1341 {
1342 int offset = gregset->r_y_offset + 8 - gregset->r_y_size;
1343 regcache_raw_collect (regcache, SPARC32_Y_REGNUM, regs + offset);
1344 }
1345 }
1346 else
1347 {
1348 if (regnum == SPARC64_STATE_REGNUM || regnum == -1)
1349 regcache_raw_collect (regcache, SPARC64_STATE_REGNUM,
1350 regs + gregset->r_tstate_offset);
1351
1352 if (regnum == SPARC64_PC_REGNUM || regnum == -1)
1353 regcache_raw_collect (regcache, SPARC64_PC_REGNUM,
1354 regs + gregset->r_pc_offset);
1355
1356 if (regnum == SPARC64_NPC_REGNUM || regnum == -1)
1357 regcache_raw_collect (regcache, SPARC64_NPC_REGNUM,
1358 regs + gregset->r_npc_offset);
1359
1360 if (regnum == SPARC64_Y_REGNUM || regnum == -1)
1361 {
1362 gdb_byte buf[8];
1363
1364 regcache_raw_collect (regcache, SPARC64_Y_REGNUM, buf);
1365 memcpy (regs + gregset->r_y_offset,
1366 buf + 8 - gregset->r_y_size, gregset->r_y_size);
1367 }
1368
1369 if ((regnum == SPARC64_FPRS_REGNUM || regnum == -1)
1370 && gregset->r_fprs_offset != -1)
1371 regcache_raw_collect (regcache, SPARC64_FPRS_REGNUM,
1372 regs + gregset->r_fprs_offset);
1373
1374 }
1375
1376 if ((regnum >= SPARC_G1_REGNUM && regnum <= SPARC_O7_REGNUM) || regnum == -1)
1377 {
1378 int offset = gregset->r_g1_offset;
1379
1380 if (sparc32)
1381 offset += 4;
1382
1383 /* %g0 is always zero. */
1384 for (i = SPARC_G1_REGNUM; i <= SPARC_O7_REGNUM; i++)
1385 {
1386 if (regnum == i || regnum == -1)
1387 regcache_raw_collect (regcache, i, regs + offset);
1388 offset += 8;
1389 }
1390 }
1391
1392 if ((regnum >= SPARC_L0_REGNUM && regnum <= SPARC_I7_REGNUM) || regnum == -1)
1393 {
1394 /* Not all of the register set variants include Locals and
1395 Inputs. For those that don't, we read them off the stack. */
1396 if (gregset->r_l0_offset != -1)
1397 {
1398 int offset = gregset->r_l0_offset;
1399
1400 if (sparc32)
1401 offset += 4;
1402
1403 for (i = SPARC_L0_REGNUM; i <= SPARC_I7_REGNUM; i++)
1404 {
1405 if (regnum == i || regnum == -1)
1406 regcache_raw_collect (regcache, i, regs + offset);
1407 offset += 8;
1408 }
1409 }
1410 }
1411 }
1412
1413 void
1414 sparc64_supply_fpregset (struct regcache *regcache,
1415 int regnum, const void *fpregs)
1416 {
1417 int sparc32 = (gdbarch_ptr_bit (current_gdbarch) == 32);
1418 const gdb_byte *regs = fpregs;
1419 int i;
1420
1421 for (i = 0; i < 32; i++)
1422 {
1423 if (regnum == (SPARC_F0_REGNUM + i) || regnum == -1)
1424 regcache_raw_supply (regcache, SPARC_F0_REGNUM + i, regs + (i * 4));
1425 }
1426
1427 if (sparc32)
1428 {
1429 if (regnum == SPARC32_FSR_REGNUM || regnum == -1)
1430 regcache_raw_supply (regcache, SPARC32_FSR_REGNUM,
1431 regs + (32 * 4) + (16 * 8) + 4);
1432 }
1433 else
1434 {
1435 for (i = 0; i < 16; i++)
1436 {
1437 if (regnum == (SPARC64_F32_REGNUM + i) || regnum == -1)
1438 regcache_raw_supply (regcache, SPARC64_F32_REGNUM + i,
1439 regs + (32 * 4) + (i * 8));
1440 }
1441
1442 if (regnum == SPARC64_FSR_REGNUM || regnum == -1)
1443 regcache_raw_supply (regcache, SPARC64_FSR_REGNUM,
1444 regs + (32 * 4) + (16 * 8));
1445 }
1446 }
1447
1448 void
1449 sparc64_collect_fpregset (const struct regcache *regcache,
1450 int regnum, void *fpregs)
1451 {
1452 int sparc32 = (gdbarch_ptr_bit (current_gdbarch) == 32);
1453 gdb_byte *regs = fpregs;
1454 int i;
1455
1456 for (i = 0; i < 32; i++)
1457 {
1458 if (regnum == (SPARC_F0_REGNUM + i) || regnum == -1)
1459 regcache_raw_collect (regcache, SPARC_F0_REGNUM + i, regs + (i * 4));
1460 }
1461
1462 if (sparc32)
1463 {
1464 if (regnum == SPARC32_FSR_REGNUM || regnum == -1)
1465 regcache_raw_collect (regcache, SPARC32_FSR_REGNUM,
1466 regs + (32 * 4) + (16 * 8) + 4);
1467 }
1468 else
1469 {
1470 for (i = 0; i < 16; i++)
1471 {
1472 if (regnum == (SPARC64_F32_REGNUM + i) || regnum == -1)
1473 regcache_raw_collect (regcache, SPARC64_F32_REGNUM + i,
1474 regs + (32 * 4) + (i * 8));
1475 }
1476
1477 if (regnum == SPARC64_FSR_REGNUM || regnum == -1)
1478 regcache_raw_collect (regcache, SPARC64_FSR_REGNUM,
1479 regs + (32 * 4) + (16 * 8));
1480 }
1481 }
This page took 0.060944 seconds and 4 git commands to generate.