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