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