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