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