OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gdb-7.2/] [gdb/] [sparc64-tdep.c] - Blame information for rev 841

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.