projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* gdbtypes.h (builtin_type_int0, builtin_type_int8, builtin_type_uint8,
[deliverable/binutils-gdb.git] / gdb / rs6000-tdep.c
CommitLineData
c906108c 1/* Target-dependent code for GDB, the GNU debugger.
7aea86e6 2
6aba47ca 3 Copyright (C) 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
0fb0cc75 4 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
721d14ba 5 Free Software Foundation, Inc.
c906108c 6
c5aa993b 7 This file is part of GDB.
c906108c 8
c5aa993b
JM		 9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
a9762ec7 11 the Free Software Foundation; either version 3 of the License, or
c5aa993b 12 (at your option) any later version.
c906108c 13
c5aa993b
JM		 14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
c906108c 18
c5aa993b 19 You should have received a copy of the GNU General Public License
a9762ec7 20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
c906108c
SS		 21
22#include "defs.h"
23#include "frame.h"
24#include "inferior.h"
25#include "symtab.h"
26#include "target.h"
27#include "gdbcore.h"
28#include "gdbcmd.h"
c906108c 29#include "objfiles.h"
7a78ae4e 30#include "arch-utils.h"
4e052eda 31#include "regcache.h"
d195bc9f 32#include "regset.h"
d16aafd8 33#include "doublest.h"
fd0407d6 34#include "value.h"
1fcc0bb8 35#include "parser-defs.h"
4be87837 36#include "osabi.h"
7d9b040b 37#include "infcall.h"
9f643768
JB		 38#include "sim-regno.h"
39#include "gdb/sim-ppc.h"
6ced10dd 40#include "reggroups.h"
4fc771b8 41#include "dwarf2-frame.h"
7cc46491
DJ		 42#include "target-descriptions.h"
43#include "user-regs.h"
7a78ae4e 44
2fccf04a 45#include "libbfd.h" /* for bfd_default_set_arch_mach */
7a78ae4e 46#include "coff/internal.h" /* for libcoff.h */
2fccf04a 47#include "libcoff.h" /* for xcoff_data */
11ed25ac
KB		 48#include "coff/xcoff.h"
49#include "libxcoff.h"
7a78ae4e 50
9aa1e687 51#include "elf-bfd.h"
55eddb0f 52#include "elf/ppc.h"
7a78ae4e 53
6ded7999 54#include "solib-svr4.h"
9aa1e687 55#include "ppc-tdep.h"
7a78ae4e 56
338ef23d 57#include "gdb_assert.h"
a89aa300 58#include "dis-asm.h"
338ef23d 59
61a65099
KB		 60#include "trad-frame.h"
61#include "frame-unwind.h"
62#include "frame-base.h"
63
7cc46491 64#include "features/rs6000/powerpc-32.c"
7284e1be 65#include "features/rs6000/powerpc-altivec32.c"
604c2f83 66#include "features/rs6000/powerpc-vsx32.c"
7cc46491
DJ		 67#include "features/rs6000/powerpc-403.c"
68#include "features/rs6000/powerpc-403gc.c"
69#include "features/rs6000/powerpc-505.c"
70#include "features/rs6000/powerpc-601.c"
71#include "features/rs6000/powerpc-602.c"
72#include "features/rs6000/powerpc-603.c"
73#include "features/rs6000/powerpc-604.c"
74#include "features/rs6000/powerpc-64.c"
7284e1be 75#include "features/rs6000/powerpc-altivec64.c"
604c2f83 76#include "features/rs6000/powerpc-vsx64.c"
7cc46491
DJ		 77#include "features/rs6000/powerpc-7400.c"
78#include "features/rs6000/powerpc-750.c"
79#include "features/rs6000/powerpc-860.c"
80#include "features/rs6000/powerpc-e500.c"
81#include "features/rs6000/rs6000.c"
82
5a9e69ba
TJB		 83/* Determine if regnum is an SPE pseudo-register. */
84#define IS_SPE_PSEUDOREG(tdep, regnum) ((tdep)->ppc_ev0_regnum >= 0 \
85 && (regnum) >= (tdep)->ppc_ev0_regnum \
86 && (regnum) < (tdep)->ppc_ev0_regnum + 32)
87
f949c649
TJB		 88/* Determine if regnum is a decimal float pseudo-register. */
89#define IS_DFP_PSEUDOREG(tdep, regnum) ((tdep)->ppc_dl0_regnum >= 0 \
90 && (regnum) >= (tdep)->ppc_dl0_regnum \
91 && (regnum) < (tdep)->ppc_dl0_regnum + 16)
92
604c2f83
LM		 93/* Determine if regnum is a POWER7 VSX register. */
94#define IS_VSX_PSEUDOREG(tdep, regnum) ((tdep)->ppc_vsr0_regnum >= 0 \
95 && (regnum) >= (tdep)->ppc_vsr0_regnum \
96 && (regnum) < (tdep)->ppc_vsr0_regnum + ppc_num_vsrs)
97
98/* Determine if regnum is a POWER7 Extended FP register. */
99#define IS_EFP_PSEUDOREG(tdep, regnum) ((tdep)->ppc_efpr0_regnum >= 0 \
100 && (regnum) >= (tdep)->ppc_efpr0_regnum \
101 && (regnum) < (tdep)->ppc_efpr0_regnum + ppc_num_fprs)
102
55eddb0f
DJ		 103/* The list of available "set powerpc ..." and "show powerpc ..."
104 commands. */
105static struct cmd_list_element *setpowerpccmdlist = NULL;
106static struct cmd_list_element *showpowerpccmdlist = NULL;
107
108static enum auto_boolean powerpc_soft_float_global = AUTO_BOOLEAN_AUTO;
109
110/* The vector ABI to use. Keep this in sync with powerpc_vector_abi. */
111static const char *powerpc_vector_strings[] =
112{
113 "auto",
114 "generic",
115 "altivec",
116 "spe",
117 NULL
118};
119
120/* A variable that can be configured by the user. */
121static enum powerpc_vector_abi powerpc_vector_abi_global = POWERPC_VEC_AUTO;
122static const char *powerpc_vector_abi_string = "auto";
123
7a78ae4e
ND		 124/* To be used by skip_prologue. */
125
126struct rs6000_framedata
127 {
128 int offset; /* total size of frame --- the distance
129 by which we decrement sp to allocate
130 the frame */
131 int saved_gpr; /* smallest # of saved gpr */
46a9b8ed 132 unsigned int gpr_mask; /* Each bit is an individual saved GPR. */
7a78ae4e 133 int saved_fpr; /* smallest # of saved fpr */
6be8bc0c 134 int saved_vr; /* smallest # of saved vr */
96ff0de4 135 int saved_ev; /* smallest # of saved ev */
7a78ae4e
ND		 136 int alloca_reg; /* alloca register number (frame ptr) */
137 char frameless; /* true if frameless functions. */
138 char nosavedpc; /* true if pc not saved. */
46a9b8ed 139 char used_bl; /* true if link register clobbered */
7a78ae4e
ND		 140 int gpr_offset; /* offset of saved gprs from prev sp */
141 int fpr_offset; /* offset of saved fprs from prev sp */
6be8bc0c 142 int vr_offset; /* offset of saved vrs from prev sp */
96ff0de4 143 int ev_offset; /* offset of saved evs from prev sp */
7a78ae4e 144 int lr_offset; /* offset of saved lr */
46a9b8ed 145 int lr_register; /* register of saved lr, if trustworthy */
7a78ae4e 146 int cr_offset; /* offset of saved cr */
6be8bc0c 147 int vrsave_offset; /* offset of saved vrsave register */
7a78ae4e
ND		 148 };
149
c906108c 150
604c2f83
LM		 151/* Is REGNO a VSX register? Return 1 if so, 0 otherwise. */
152int
153vsx_register_p (struct gdbarch *gdbarch, int regno)
154{
155 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
156 if (tdep->ppc_vsr0_regnum < 0)
157 return 0;
158 else
159 return (regno >= tdep->ppc_vsr0_upper_regnum && regno
160 <= tdep->ppc_vsr0_upper_regnum + 31);
161}
162
64b84175
KB		 163/* Is REGNO an AltiVec register? Return 1 if so, 0 otherwise. */
164int
be8626e0 165altivec_register_p (struct gdbarch *gdbarch, int regno)
64b84175 166{
be8626e0 167 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
64b84175
KB		 168 if (tdep->ppc_vr0_regnum < 0 || tdep->ppc_vrsave_regnum < 0)
169 return 0;
170 else
171 return (regno >= tdep->ppc_vr0_regnum && regno <= tdep->ppc_vrsave_regnum);
172}
173
383f0f5b 174
867e2dc5
JB		 175/* Return true if REGNO is an SPE register, false otherwise. */
176int
be8626e0 177spe_register_p (struct gdbarch *gdbarch, int regno)
867e2dc5 178{
be8626e0 179 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
867e2dc5
JB		 180
181 /* Is it a reference to EV0 -- EV31, and do we have those? */
5a9e69ba 182 if (IS_SPE_PSEUDOREG (tdep, regno))
867e2dc5
JB		 183 return 1;
184
6ced10dd
JB		 185 /* Is it a reference to one of the raw upper GPR halves? */
186 if (tdep->ppc_ev0_upper_regnum >= 0
187 && tdep->ppc_ev0_upper_regnum <= regno
188 && regno < tdep->ppc_ev0_upper_regnum + ppc_num_gprs)
189 return 1;
190
867e2dc5
JB		 191 /* Is it a reference to the 64-bit accumulator, and do we have that? */
192 if (tdep->ppc_acc_regnum >= 0
193 && tdep->ppc_acc_regnum == regno)
194 return 1;
195
196 /* Is it a reference to the SPE floating-point status and control register,
197 and do we have that? */
198 if (tdep->ppc_spefscr_regnum >= 0
199 && tdep->ppc_spefscr_regnum == regno)
200 return 1;
201
202 return 0;
203}
204
205
383f0f5b
JB		 206/* Return non-zero if the architecture described by GDBARCH has
207 floating-point registers (f0 --- f31 and fpscr). */
0a613259
AC		 208int
209ppc_floating_point_unit_p (struct gdbarch *gdbarch)
210{
383f0f5b
JB		 211 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
212
213 return (tdep->ppc_fp0_regnum >= 0
214 && tdep->ppc_fpscr_regnum >= 0);
0a613259 215}
9f643768 216
604c2f83
LM		 217/* Return non-zero if the architecture described by GDBARCH has
218 VSX registers (vsr0 --- vsr63). */
63807e1d 219static int
604c2f83
LM		 220ppc_vsx_support_p (struct gdbarch *gdbarch)
221{
222 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
223
224 return tdep->ppc_vsr0_regnum >= 0;
225}
226
06caf7d2
CES		 227/* Return non-zero if the architecture described by GDBARCH has
228 Altivec registers (vr0 --- vr31, vrsave and vscr). */
229int
230ppc_altivec_support_p (struct gdbarch *gdbarch)
231{
232 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
233
234 return (tdep->ppc_vr0_regnum >= 0
235 && tdep->ppc_vrsave_regnum >= 0);
236}
09991fa0
JB		 237
238/* Check that TABLE[GDB_REGNO] is not already initialized, and then
239 set it to SIM_REGNO.
240
241 This is a helper function for init_sim_regno_table, constructing
242 the table mapping GDB register numbers to sim register numbers; we
243 initialize every element in that table to -1 before we start
244 filling it in. */
9f643768
JB		 245static void
246set_sim_regno (int *table, int gdb_regno, int sim_regno)
247{
248 /* Make sure we don't try to assign any given GDB register a sim
249 register number more than once. */
250 gdb_assert (table[gdb_regno] == -1);
251 table[gdb_regno] = sim_regno;
252}
253
09991fa0
JB		 254
255/* Initialize ARCH->tdep->sim_regno, the table mapping GDB register
256 numbers to simulator register numbers, based on the values placed
257 in the ARCH->tdep->ppc_foo_regnum members. */
9f643768
JB		 258static void
259init_sim_regno_table (struct gdbarch *arch)
260{
261 struct gdbarch_tdep *tdep = gdbarch_tdep (arch);
7cc46491 262 int total_regs = gdbarch_num_regs (arch);
9f643768
JB		 263 int *sim_regno = GDBARCH_OBSTACK_CALLOC (arch, total_regs, int);
264 int i;
7cc46491
DJ		 265 static const char *const segment_regs[] = {
266 "sr0", "sr1", "sr2", "sr3", "sr4", "sr5", "sr6", "sr7",
267 "sr8", "sr9", "sr10", "sr11", "sr12", "sr13", "sr14", "sr15"
268 };
9f643768
JB		 269
270 /* Presume that all registers not explicitly mentioned below are
271 unavailable from the sim. */
272 for (i = 0; i < total_regs; i++)
273 sim_regno[i] = -1;
274
275 /* General-purpose registers. */
276 for (i = 0; i < ppc_num_gprs; i++)
277 set_sim_regno (sim_regno, tdep->ppc_gp0_regnum + i, sim_ppc_r0_regnum + i);
278
279 /* Floating-point registers. */
280 if (tdep->ppc_fp0_regnum >= 0)
281 for (i = 0; i < ppc_num_fprs; i++)
282 set_sim_regno (sim_regno,
283 tdep->ppc_fp0_regnum + i,
284 sim_ppc_f0_regnum + i);
285 if (tdep->ppc_fpscr_regnum >= 0)
286 set_sim_regno (sim_regno, tdep->ppc_fpscr_regnum, sim_ppc_fpscr_regnum);
287
288 set_sim_regno (sim_regno, gdbarch_pc_regnum (arch), sim_ppc_pc_regnum);
289 set_sim_regno (sim_regno, tdep->ppc_ps_regnum, sim_ppc_ps_regnum);
290 set_sim_regno (sim_regno, tdep->ppc_cr_regnum, sim_ppc_cr_regnum);
291
292 /* Segment registers. */
7cc46491
DJ		 293 for (i = 0; i < ppc_num_srs; i++)
294 {
295 int gdb_regno;
296
297 gdb_regno = user_reg_map_name_to_regnum (arch, segment_regs[i], -1);
298 if (gdb_regno >= 0)
299 set_sim_regno (sim_regno, gdb_regno, sim_ppc_sr0_regnum + i);
300 }
9f643768
JB		 301
302 /* Altivec registers. */
303 if (tdep->ppc_vr0_regnum >= 0)
304 {
305 for (i = 0; i < ppc_num_vrs; i++)
306 set_sim_regno (sim_regno,
307 tdep->ppc_vr0_regnum + i,
308 sim_ppc_vr0_regnum + i);
309
310 /* FIXME: jimb/2004-07-15: when we have tdep->ppc_vscr_regnum,
311 we can treat this more like the other cases. */
312 set_sim_regno (sim_regno,
313 tdep->ppc_vr0_regnum + ppc_num_vrs,
314 sim_ppc_vscr_regnum);
315 }
316 /* vsave is a special-purpose register, so the code below handles it. */
317
318 /* SPE APU (E500) registers. */
6ced10dd
JB		 319 if (tdep->ppc_ev0_upper_regnum >= 0)
320 for (i = 0; i < ppc_num_gprs; i++)
321 set_sim_regno (sim_regno,
322 tdep->ppc_ev0_upper_regnum + i,
323 sim_ppc_rh0_regnum + i);
9f643768
JB		 324 if (tdep->ppc_acc_regnum >= 0)
325 set_sim_regno (sim_regno, tdep->ppc_acc_regnum, sim_ppc_acc_regnum);
326 /* spefscr is a special-purpose register, so the code below handles it. */
327
7cc46491 328#ifdef WITH_SIM
9f643768
JB		 329 /* Now handle all special-purpose registers. Verify that they
330 haven't mistakenly been assigned numbers by any of the above
7cc46491
DJ		 331 code. */
332 for (i = 0; i < sim_ppc_num_sprs; i++)
333 {
334 const char *spr_name = sim_spr_register_name (i);
335 int gdb_regno = -1;
336
337 if (spr_name != NULL)
338 gdb_regno = user_reg_map_name_to_regnum (arch, spr_name, -1);
339
340 if (gdb_regno != -1)
341 set_sim_regno (sim_regno, gdb_regno, sim_ppc_spr0_regnum + i);
342 }
343#endif
9f643768
JB		 344
345 /* Drop the initialized array into place. */
346 tdep->sim_regno = sim_regno;
347}
348
09991fa0
JB		 349
350/* Given a GDB register number REG, return the corresponding SIM
351 register number. */
9f643768 352static int
e7faf938 353rs6000_register_sim_regno (struct gdbarch *gdbarch, int reg)
9f643768 354{
e7faf938 355 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
9f643768
JB		 356 int sim_regno;
357
7cc46491 358 if (tdep->sim_regno == NULL)
e7faf938 359 init_sim_regno_table (gdbarch);
7cc46491 360
f57d151a 361 gdb_assert (0 <= reg
e7faf938
MD		 362 && reg <= gdbarch_num_regs (gdbarch)
363 + gdbarch_num_pseudo_regs (gdbarch));
9f643768
JB		 364 sim_regno = tdep->sim_regno[reg];
365
366 if (sim_regno >= 0)
367 return sim_regno;
368 else
369 return LEGACY_SIM_REGNO_IGNORE;
370}
371
d195bc9f
MK		 372\f
373
374/* Register set support functions. */
375
f2db237a
AM		 376/* REGS + OFFSET contains register REGNUM in a field REGSIZE wide.
377 Write the register to REGCACHE. */
378
7284e1be 379void
d195bc9f 380ppc_supply_reg (struct regcache *regcache, int regnum,
f2db237a 381 const gdb_byte *regs, size_t offset, int regsize)
d195bc9f
MK		 382{
383 if (regnum != -1 && offset != -1)
f2db237a
AM		 384 {
385 if (regsize > 4)
386 {
387 struct gdbarch *gdbarch = get_regcache_arch (regcache);
388 int gdb_regsize = register_size (gdbarch, regnum);
389 if (gdb_regsize < regsize
390 && gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
391 offset += regsize - gdb_regsize;
392 }
393 regcache_raw_supply (regcache, regnum, regs + offset);
394 }
d195bc9f
MK		 395}
396
f2db237a
AM		 397/* Read register REGNUM from REGCACHE and store to REGS + OFFSET
398 in a field REGSIZE wide. Zero pad as necessary. */
399
7284e1be 400void
d195bc9f 401ppc_collect_reg (const struct regcache *regcache, int regnum,
f2db237a 402 gdb_byte *regs, size_t offset, int regsize)
d195bc9f
MK		 403{
404 if (regnum != -1 && offset != -1)
f2db237a
AM		 405 {
406 if (regsize > 4)
407 {
408 struct gdbarch *gdbarch = get_regcache_arch (regcache);
409 int gdb_regsize = register_size (gdbarch, regnum);
410 if (gdb_regsize < regsize)
411 {
412 if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
413 {
414 memset (regs + offset, 0, regsize - gdb_regsize);
415 offset += regsize - gdb_regsize;
416 }
417 else
418 memset (regs + offset + regsize - gdb_regsize, 0,
419 regsize - gdb_regsize);
420 }
421 }
422 regcache_raw_collect (regcache, regnum, regs + offset);
423 }
d195bc9f
MK		 424}
425
f2db237a
AM		 426static int
427ppc_greg_offset (struct gdbarch *gdbarch,
428 struct gdbarch_tdep *tdep,
429 const struct ppc_reg_offsets *offsets,
430 int regnum,
431 int *regsize)
432{
433 *regsize = offsets->gpr_size;
434 if (regnum >= tdep->ppc_gp0_regnum
435 && regnum < tdep->ppc_gp0_regnum + ppc_num_gprs)
436 return (offsets->r0_offset
437 + (regnum - tdep->ppc_gp0_regnum) * offsets->gpr_size);
438
439 if (regnum == gdbarch_pc_regnum (gdbarch))
440 return offsets->pc_offset;
441
442 if (regnum == tdep->ppc_ps_regnum)
443 return offsets->ps_offset;
444
445 if (regnum == tdep->ppc_lr_regnum)
446 return offsets->lr_offset;
447
448 if (regnum == tdep->ppc_ctr_regnum)
449 return offsets->ctr_offset;
450
451 *regsize = offsets->xr_size;
452 if (regnum == tdep->ppc_cr_regnum)
453 return offsets->cr_offset;
454
455 if (regnum == tdep->ppc_xer_regnum)
456 return offsets->xer_offset;
457
458 if (regnum == tdep->ppc_mq_regnum)
459 return offsets->mq_offset;
460
461 return -1;
462}
463
464static int
465ppc_fpreg_offset (struct gdbarch_tdep *tdep,
466 const struct ppc_reg_offsets *offsets,
467 int regnum)
468{
469 if (regnum >= tdep->ppc_fp0_regnum
470 && regnum < tdep->ppc_fp0_regnum + ppc_num_fprs)
471 return offsets->f0_offset + (regnum - tdep->ppc_fp0_regnum) * 8;
472
473 if (regnum == tdep->ppc_fpscr_regnum)
474 return offsets->fpscr_offset;
475
476 return -1;
477}
478
06caf7d2
CES		 479static int
480ppc_vrreg_offset (struct gdbarch_tdep *tdep,
481 const struct ppc_reg_offsets *offsets,
482 int regnum)
483{
484 if (regnum >= tdep->ppc_vr0_regnum
485 && regnum < tdep->ppc_vr0_regnum + ppc_num_vrs)
486 return offsets->vr0_offset + (regnum - tdep->ppc_vr0_regnum) * 16;
487
488 if (regnum == tdep->ppc_vrsave_regnum - 1)
489 return offsets->vscr_offset;
490
491 if (regnum == tdep->ppc_vrsave_regnum)
492 return offsets->vrsave_offset;
493
494 return -1;
495}
496
d195bc9f
MK		 497/* Supply register REGNUM in the general-purpose register set REGSET
498 from the buffer specified by GREGS and LEN to register cache
499 REGCACHE. If REGNUM is -1, do this for all registers in REGSET. */
500
501void
502ppc_supply_gregset (const struct regset *regset, struct regcache *regcache,
503 int regnum, const void *gregs, size_t len)
504{
505 struct gdbarch *gdbarch = get_regcache_arch (regcache);
506 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
507 const struct ppc_reg_offsets *offsets = regset->descr;
508 size_t offset;
f2db237a 509 int regsize;
d195bc9f 510
f2db237a 511 if (regnum == -1)
d195bc9f 512 {
f2db237a
AM		 513 int i;
514 int gpr_size = offsets->gpr_size;
515
516 for (i = tdep->ppc_gp0_regnum, offset = offsets->r0_offset;
517 i < tdep->ppc_gp0_regnum + ppc_num_gprs;
518 i++, offset += gpr_size)
519 ppc_supply_reg (regcache, i, gregs, offset, gpr_size);
520
521 ppc_supply_reg (regcache, gdbarch_pc_regnum (gdbarch),
522 gregs, offsets->pc_offset, gpr_size);
523 ppc_supply_reg (regcache, tdep->ppc_ps_regnum,
524 gregs, offsets->ps_offset, gpr_size);
525 ppc_supply_reg (regcache, tdep->ppc_lr_regnum,
526 gregs, offsets->lr_offset, gpr_size);
527 ppc_supply_reg (regcache, tdep->ppc_ctr_regnum,
528 gregs, offsets->ctr_offset, gpr_size);
529 ppc_supply_reg (regcache, tdep->ppc_cr_regnum,
530 gregs, offsets->cr_offset, offsets->xr_size);
531 ppc_supply_reg (regcache, tdep->ppc_xer_regnum,
532 gregs, offsets->xer_offset, offsets->xr_size);
533 ppc_supply_reg (regcache, tdep->ppc_mq_regnum,
534 gregs, offsets->mq_offset, offsets->xr_size);
535 return;
d195bc9f
MK		 536 }
537
f2db237a
AM		 538 offset = ppc_greg_offset (gdbarch, tdep, offsets, regnum, &regsize);
539 ppc_supply_reg (regcache, regnum, gregs, offset, regsize);
d195bc9f
MK		 540}
541
542/* Supply register REGNUM in the floating-point register set REGSET
543 from the buffer specified by FPREGS and LEN to register cache
544 REGCACHE. If REGNUM is -1, do this for all registers in REGSET. */
545
546void
547ppc_supply_fpregset (const struct regset *regset, struct regcache *regcache,
548 int regnum, const void *fpregs, size_t len)
549{
550 struct gdbarch *gdbarch = get_regcache_arch (regcache);
f2db237a
AM		 551 struct gdbarch_tdep *tdep;
552 const struct ppc_reg_offsets *offsets;
d195bc9f 553 size_t offset;
d195bc9f 554
f2db237a
AM		 555 if (!ppc_floating_point_unit_p (gdbarch))
556 return;
383f0f5b 557
f2db237a
AM		 558 tdep = gdbarch_tdep (gdbarch);
559 offsets = regset->descr;
560 if (regnum == -1)
d195bc9f 561 {
f2db237a
AM		 562 int i;
563
564 for (i = tdep->ppc_fp0_regnum, offset = offsets->f0_offset;
565 i < tdep->ppc_fp0_regnum + ppc_num_fprs;
566 i++, offset += 8)
567 ppc_supply_reg (regcache, i, fpregs, offset, 8);
568
569 ppc_supply_reg (regcache, tdep->ppc_fpscr_regnum,
570 fpregs, offsets->fpscr_offset, offsets->fpscr_size);
571 return;
d195bc9f
MK		 572 }
573
f2db237a
AM		 574 offset = ppc_fpreg_offset (tdep, offsets, regnum);
575 ppc_supply_reg (regcache, regnum, fpregs, offset,
576 regnum == tdep->ppc_fpscr_regnum ? offsets->fpscr_size : 8);
d195bc9f
MK		 577}
578
604c2f83
LM		 579/* Supply register REGNUM in the VSX register set REGSET
580 from the buffer specified by VSXREGS and LEN to register cache
581 REGCACHE. If REGNUM is -1, do this for all registers in REGSET. */
582
583void
584ppc_supply_vsxregset (const struct regset *regset, struct regcache *regcache,
585 int regnum, const void *vsxregs, size_t len)
586{
587 struct gdbarch *gdbarch = get_regcache_arch (regcache);
588 struct gdbarch_tdep *tdep;
589
590 if (!ppc_vsx_support_p (gdbarch))
591 return;
592
593 tdep = gdbarch_tdep (gdbarch);
594
595 if (regnum == -1)
596 {
597 int i;
598
599 for (i = tdep->ppc_vsr0_upper_regnum;
600 i < tdep->ppc_vsr0_upper_regnum + 32;
601 i++)
602 ppc_supply_reg (regcache, i, vsxregs, 0, 8);
603
604 return;
605 }
606 else
607 ppc_supply_reg (regcache, regnum, vsxregs, 0, 8);
608}
609
06caf7d2
CES		 610/* Supply register REGNUM in the Altivec register set REGSET
611 from the buffer specified by VRREGS and LEN to register cache
612 REGCACHE. If REGNUM is -1, do this for all registers in REGSET. */
613
614void
615ppc_supply_vrregset (const struct regset *regset, struct regcache *regcache,
616 int regnum, const void *vrregs, size_t len)
617{
618 struct gdbarch *gdbarch = get_regcache_arch (regcache);
619 struct gdbarch_tdep *tdep;
620 const struct ppc_reg_offsets *offsets;
621 size_t offset;
622
623 if (!ppc_altivec_support_p (gdbarch))
624 return;
625
626 tdep = gdbarch_tdep (gdbarch);
627 offsets = regset->descr;
628 if (regnum == -1)
629 {
630 int i;
631
632 for (i = tdep->ppc_vr0_regnum, offset = offsets->vr0_offset;
633 i < tdep->ppc_vr0_regnum + ppc_num_vrs;
634 i++, offset += 16)
635 ppc_supply_reg (regcache, i, vrregs, offset, 16);
636
637 ppc_supply_reg (regcache, (tdep->ppc_vrsave_regnum - 1),
638 vrregs, offsets->vscr_offset, 4);
639
640 ppc_supply_reg (regcache, tdep->ppc_vrsave_regnum,
641 vrregs, offsets->vrsave_offset, 4);
642 return;
643 }
644
645 offset = ppc_vrreg_offset (tdep, offsets, regnum);
646 if (regnum != tdep->ppc_vrsave_regnum
647 && regnum != tdep->ppc_vrsave_regnum - 1)
648 ppc_supply_reg (regcache, regnum, vrregs, offset, 16);
649 else
650 ppc_supply_reg (regcache, regnum,
651 vrregs, offset, 4);
652}
653
d195bc9f 654/* Collect register REGNUM in the general-purpose register set
f2db237a 655 REGSET from register cache REGCACHE into the buffer specified by
d195bc9f
MK		 656 GREGS and LEN. If REGNUM is -1, do this for all registers in
657 REGSET. */
658
659void
660ppc_collect_gregset (const struct regset *regset,
661 const struct regcache *regcache,
662 int regnum, void *gregs, size_t len)
663{
664 struct gdbarch *gdbarch = get_regcache_arch (regcache);
665 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
666 const struct ppc_reg_offsets *offsets = regset->descr;
667 size_t offset;
f2db237a 668 int regsize;
d195bc9f 669
f2db237a 670 if (regnum == -1)
d195bc9f 671 {
f2db237a
AM		 672 int i;
673 int gpr_size = offsets->gpr_size;
674
675 for (i = tdep->ppc_gp0_regnum, offset = offsets->r0_offset;
676 i < tdep->ppc_gp0_regnum + ppc_num_gprs;
677 i++, offset += gpr_size)
678 ppc_collect_reg (regcache, i, gregs, offset, gpr_size);
679
680 ppc_collect_reg (regcache, gdbarch_pc_regnum (gdbarch),
681 gregs, offsets->pc_offset, gpr_size);
682 ppc_collect_reg (regcache, tdep->ppc_ps_regnum,
683 gregs, offsets->ps_offset, gpr_size);
684 ppc_collect_reg (regcache, tdep->ppc_lr_regnum,
685 gregs, offsets->lr_offset, gpr_size);
686 ppc_collect_reg (regcache, tdep->ppc_ctr_regnum,
687 gregs, offsets->ctr_offset, gpr_size);
688 ppc_collect_reg (regcache, tdep->ppc_cr_regnum,
689 gregs, offsets->cr_offset, offsets->xr_size);
690 ppc_collect_reg (regcache, tdep->ppc_xer_regnum,
691 gregs, offsets->xer_offset, offsets->xr_size);
692 ppc_collect_reg (regcache, tdep->ppc_mq_regnum,
693 gregs, offsets->mq_offset, offsets->xr_size);
694 return;
d195bc9f
MK		 695 }
696
f2db237a
AM		 697 offset = ppc_greg_offset (gdbarch, tdep, offsets, regnum, &regsize);
698 ppc_collect_reg (regcache, regnum, gregs, offset, regsize);
d195bc9f
MK		 699}
700
701/* Collect register REGNUM in the floating-point register set
f2db237a 702 REGSET from register cache REGCACHE into the buffer specified by
d195bc9f
MK		 703 FPREGS and LEN. If REGNUM is -1, do this for all registers in
704 REGSET. */
705
706void
707ppc_collect_fpregset (const struct regset *regset,
708 const struct regcache *regcache,
709 int regnum, void *fpregs, size_t len)
710{
711 struct gdbarch *gdbarch = get_regcache_arch (regcache);
f2db237a
AM		 712 struct gdbarch_tdep *tdep;
713 const struct ppc_reg_offsets *offsets;
d195bc9f 714 size_t offset;
d195bc9f 715
f2db237a
AM		 716 if (!ppc_floating_point_unit_p (gdbarch))
717 return;
383f0f5b 718
f2db237a
AM		 719 tdep = gdbarch_tdep (gdbarch);
720 offsets = regset->descr;
721 if (regnum == -1)
d195bc9f 722 {
f2db237a
AM		 723 int i;
724
725 for (i = tdep->ppc_fp0_regnum, offset = offsets->f0_offset;
726 i < tdep->ppc_fp0_regnum + ppc_num_fprs;
727 i++, offset += 8)
728 ppc_collect_reg (regcache, i, fpregs, offset, 8);
729
730 ppc_collect_reg (regcache, tdep->ppc_fpscr_regnum,
731 fpregs, offsets->fpscr_offset, offsets->fpscr_size);
732 return;
d195bc9f
MK		 733 }
734
f2db237a
AM		 735 offset = ppc_fpreg_offset (tdep, offsets, regnum);
736 ppc_collect_reg (regcache, regnum, fpregs, offset,
737 regnum == tdep->ppc_fpscr_regnum ? offsets->fpscr_size : 8);
d195bc9f 738}
06caf7d2 739
604c2f83
LM		 740/* Collect register REGNUM in the VSX register set
741 REGSET from register cache REGCACHE into the buffer specified by
742 VSXREGS and LEN. If REGNUM is -1, do this for all registers in
743 REGSET. */
744
745void
746ppc_collect_vsxregset (const struct regset *regset,
747 const struct regcache *regcache,
748 int regnum, void *vsxregs, size_t len)
749{
750 struct gdbarch *gdbarch = get_regcache_arch (regcache);
751 struct gdbarch_tdep *tdep;
752
753 if (!ppc_vsx_support_p (gdbarch))
754 return;
755
756 tdep = gdbarch_tdep (gdbarch);
757
758 if (regnum == -1)
759 {
760 int i;
761
762 for (i = tdep->ppc_vsr0_upper_regnum;
763 i < tdep->ppc_vsr0_upper_regnum + 32;
764 i++)
765 ppc_collect_reg (regcache, i, vsxregs, 0, 8);
766
767 return;
768 }
769 else
770 ppc_collect_reg (regcache, regnum, vsxregs, 0, 8);
771}
772
773
06caf7d2
CES		 774/* Collect register REGNUM in the Altivec register set
775 REGSET from register cache REGCACHE into the buffer specified by
776 VRREGS and LEN. If REGNUM is -1, do this for all registers in
777 REGSET. */
778
779void
780ppc_collect_vrregset (const struct regset *regset,
781 const struct regcache *regcache,
782 int regnum, void *vrregs, size_t len)
783{
784 struct gdbarch *gdbarch = get_regcache_arch (regcache);
785 struct gdbarch_tdep *tdep;
786 const struct ppc_reg_offsets *offsets;
787 size_t offset;
788
789 if (!ppc_altivec_support_p (gdbarch))
790 return;
791
792 tdep = gdbarch_tdep (gdbarch);
793 offsets = regset->descr;
794 if (regnum == -1)
795 {
796 int i;
797
798 for (i = tdep->ppc_vr0_regnum, offset = offsets->vr0_offset;
799 i < tdep->ppc_vr0_regnum + ppc_num_vrs;
800 i++, offset += 16)
801 ppc_collect_reg (regcache, i, vrregs, offset, 16);
802
803 ppc_collect_reg (regcache, (tdep->ppc_vrsave_regnum - 1),
804 vrregs, offsets->vscr_offset, 4);
805
806 ppc_collect_reg (regcache, tdep->ppc_vrsave_regnum,
807 vrregs, offsets->vrsave_offset, 4);
808 return;
809 }
810
811 offset = ppc_vrreg_offset (tdep, offsets, regnum);
812 if (regnum != tdep->ppc_vrsave_regnum
813 && regnum != tdep->ppc_vrsave_regnum - 1)
814 ppc_collect_reg (regcache, regnum, vrregs, offset, 16);
815 else
816 ppc_collect_reg (regcache, regnum,
817 vrregs, offset, 4);
818}
d195bc9f 819\f
0a613259 820
0d1243d9
PG		 821static int
822insn_changes_sp_or_jumps (unsigned long insn)
823{
824 int opcode = (insn >> 26) & 0x03f;
825 int sd = (insn >> 21) & 0x01f;
826 int a = (insn >> 16) & 0x01f;
827 int subcode = (insn >> 1) & 0x3ff;
828
829 /* Changes the stack pointer. */
830
831 /* NOTE: There are many ways to change the value of a given register.
832 The ways below are those used when the register is R1, the SP,
833 in a funtion's epilogue. */
834
835 if (opcode == 31 && subcode == 444 && a == 1)
836 return 1; /* mr R1,Rn */
837 if (opcode == 14 && sd == 1)
838 return 1; /* addi R1,Rn,simm */
839 if (opcode == 58 && sd == 1)
840 return 1; /* ld R1,ds(Rn) */
841
842 /* Transfers control. */
843
844 if (opcode == 18)
845 return 1; /* b */
846 if (opcode == 16)
847 return 1; /* bc */
848 if (opcode == 19 && subcode == 16)
849 return 1; /* bclr */
850 if (opcode == 19 && subcode == 528)
851 return 1; /* bcctr */
852
853 return 0;
854}
855
856/* Return true if we are in the function's epilogue, i.e. after the
857 instruction that destroyed the function's stack frame.
858
859 1) scan forward from the point of execution:
860 a) If you find an instruction that modifies the stack pointer
861 or transfers control (except a return), execution is not in
862 an epilogue, return.
863 b) Stop scanning if you find a return instruction or reach the
864 end of the function or reach the hard limit for the size of
865 an epilogue.
866 2) scan backward from the point of execution:
867 a) If you find an instruction that modifies the stack pointer,
868 execution *is* in an epilogue, return.
869 b) Stop scanning if you reach an instruction that transfers
870 control or the beginning of the function or reach the hard
871 limit for the size of an epilogue. */
872
873static int
874rs6000_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
875{
46a9b8ed 876 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
0d1243d9
PG		 877 bfd_byte insn_buf[PPC_INSN_SIZE];
878 CORE_ADDR scan_pc, func_start, func_end, epilogue_start, epilogue_end;
879 unsigned long insn;
880 struct frame_info *curfrm;
881
882 /* Find the search limits based on function boundaries and hard limit. */
883
884 if (!find_pc_partial_function (pc, NULL, &func_start, &func_end))
885 return 0;
886
887 epilogue_start = pc - PPC_MAX_EPILOGUE_INSTRUCTIONS * PPC_INSN_SIZE;
888 if (epilogue_start < func_start) epilogue_start = func_start;
889
890 epilogue_end = pc + PPC_MAX_EPILOGUE_INSTRUCTIONS * PPC_INSN_SIZE;
891 if (epilogue_end > func_end) epilogue_end = func_end;
892
893 curfrm = get_current_frame ();
894
895 /* Scan forward until next 'blr'. */
896
897 for (scan_pc = pc; scan_pc < epilogue_end; scan_pc += PPC_INSN_SIZE)
898 {
899 if (!safe_frame_unwind_memory (curfrm, scan_pc, insn_buf, PPC_INSN_SIZE))
900 return 0;
4e463ff5 901 insn = extract_unsigned_integer (insn_buf, PPC_INSN_SIZE);
0d1243d9
PG		 902 if (insn == 0x4e800020)
903 break;
46a9b8ed
DJ		 904 /* Assume a bctr is a tail call unless it points strictly within
905 this function. */
906 if (insn == 0x4e800420)
907 {
908 CORE_ADDR ctr = get_frame_register_unsigned (curfrm,
909 tdep->ppc_ctr_regnum);
910 if (ctr > func_start && ctr < func_end)
911 return 0;
912 else
913 break;
914 }
0d1243d9
PG		 915 if (insn_changes_sp_or_jumps (insn))
916 return 0;
917 }
918
919 /* Scan backward until adjustment to stack pointer (R1). */
920
921 for (scan_pc = pc - PPC_INSN_SIZE;
922 scan_pc >= epilogue_start;
923 scan_pc -= PPC_INSN_SIZE)
924 {
925 if (!safe_frame_unwind_memory (curfrm, scan_pc, insn_buf, PPC_INSN_SIZE))
926 return 0;
4e463ff5 927 insn = extract_unsigned_integer (insn_buf, PPC_INSN_SIZE);
0d1243d9
PG		 928 if (insn_changes_sp_or_jumps (insn))
929 return 1;
930 }
931
932 return 0;
933}
934
143985b7 935/* Get the ith function argument for the current function. */
b9362cc7 936static CORE_ADDR
143985b7
AF		 937rs6000_fetch_pointer_argument (struct frame_info *frame, int argi,
938 struct type *type)
939{
50fd1280 940 return get_frame_register_unsigned (frame, 3 + argi);
143985b7
AF		 941}
942
c906108c
SS		 943/* Sequence of bytes for breakpoint instruction. */
944
f4f9705a 945const static unsigned char *
67d57894
MD		 946rs6000_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *bp_addr,
947 int *bp_size)
c906108c 948{
aaab4dba
AC		 949 static unsigned char big_breakpoint[] = { 0x7d, 0x82, 0x10, 0x08 };
950 static unsigned char little_breakpoint[] = { 0x08, 0x10, 0x82, 0x7d };
c906108c 951 *bp_size = 4;
67d57894 952 if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
c906108c
SS		 953 return big_breakpoint;
954 else
955 return little_breakpoint;
956}
957
f74c6cad
LM		 958/* Instruction masks for displaced stepping. */
959#define BRANCH_MASK 0xfc000000
960#define BP_MASK 0xFC0007FE
961#define B_INSN 0x48000000
962#define BC_INSN 0x40000000
963#define BXL_INSN 0x4c000000
964#define BP_INSN 0x7C000008
965
966/* Fix up the state of registers and memory after having single-stepped
967 a displaced instruction. */
63807e1d 968static void
f74c6cad 969ppc_displaced_step_fixup (struct gdbarch *gdbarch,
63807e1d
PA		 970 struct displaced_step_closure *closure,
971 CORE_ADDR from, CORE_ADDR to,
972 struct regcache *regs)
f74c6cad
LM		 973{
974 /* Since we use simple_displaced_step_copy_insn, our closure is a
975 copy of the instruction. */
976 ULONGEST insn = extract_unsigned_integer ((gdb_byte *) closure,
977 PPC_INSN_SIZE);
978 ULONGEST opcode = 0;
979 /* Offset for non PC-relative instructions. */
980 LONGEST offset = PPC_INSN_SIZE;
981
982 opcode = insn & BRANCH_MASK;
983
984 if (debug_displaced)
985 fprintf_unfiltered (gdb_stdlog,
986 "displaced: (ppc) fixup (0x%s, 0x%s)\n",
987 paddr_nz (from), paddr_nz (to));
988
989
990 /* Handle PC-relative branch instructions. */
991 if (opcode == B_INSN || opcode == BC_INSN || opcode == BXL_INSN)
992 {
a4fafde3 993 ULONGEST current_pc;
f74c6cad
LM		 994
995 /* Read the current PC value after the instruction has been executed
996 in a displaced location. Calculate the offset to be applied to the
997 original PC value before the displaced stepping. */
998 regcache_cooked_read_unsigned (regs, gdbarch_pc_regnum (gdbarch),
999 &current_pc);
1000 offset = current_pc - to;
1001
1002 if (opcode != BXL_INSN)
1003 {
1004 /* Check for AA bit indicating whether this is an absolute
1005 addressing or PC-relative (1: absolute, 0: relative). */
1006 if (!(insn & 0x2))
1007 {
1008 /* PC-relative addressing is being used in the branch. */
1009 if (debug_displaced)
1010 fprintf_unfiltered
1011 (gdb_stdlog,
1012 "displaced: (ppc) branch instruction: 0x%s\n"
1013 "displaced: (ppc) adjusted PC from 0x%s to 0x%s\n",
1014 paddr_nz (insn), paddr_nz (current_pc),
1015 paddr_nz (from + offset));
1016
1017 regcache_cooked_write_unsigned (regs, gdbarch_pc_regnum (gdbarch),
1018 from + offset);
1019 }
1020 }
1021 else
1022 {
1023 /* If we're here, it means we have a branch to LR or CTR. If the
1024 branch was taken, the offset is probably greater than 4 (the next
1025 instruction), so it's safe to assume that an offset of 4 means we
1026 did not take the branch. */
1027 if (offset == PPC_INSN_SIZE)
1028 regcache_cooked_write_unsigned (regs, gdbarch_pc_regnum (gdbarch),
1029 from + PPC_INSN_SIZE);
1030 }
1031
1032 /* Check for LK bit indicating whether we should set the link
1033 register to point to the next instruction
1034 (1: Set, 0: Don't set). */
1035 if (insn & 0x1)
1036 {
1037 /* Link register needs to be set to the next instruction's PC. */
1038 regcache_cooked_write_unsigned (regs,
1039 gdbarch_tdep (gdbarch)->ppc_lr_regnum,
1040 from + PPC_INSN_SIZE);
1041 if (debug_displaced)
1042 fprintf_unfiltered (gdb_stdlog,
1043 "displaced: (ppc) adjusted LR to 0x%s\n",
1044 paddr_nz (from + PPC_INSN_SIZE));
1045
1046 }
1047 }
1048 /* Check for breakpoints in the inferior. If we've found one, place the PC
1049 right at the breakpoint instruction. */
1050 else if ((insn & BP_MASK) == BP_INSN)
1051 regcache_cooked_write_unsigned (regs, gdbarch_pc_regnum (gdbarch), from);
1052 else
1053 /* Handle any other instructions that do not fit in the categories above. */
1054 regcache_cooked_write_unsigned (regs, gdbarch_pc_regnum (gdbarch),
1055 from + offset);
1056}
c906108c 1057
ce5eab59
UW		 1058/* Instruction masks used during single-stepping of atomic sequences. */
1059#define LWARX_MASK 0xfc0007fe
1060#define LWARX_INSTRUCTION 0x7c000028
1061#define LDARX_INSTRUCTION 0x7c0000A8
1062#define STWCX_MASK 0xfc0007ff
1063#define STWCX_INSTRUCTION 0x7c00012d
1064#define STDCX_INSTRUCTION 0x7c0001ad
ce5eab59
UW		 1065
1066/* Checks for an atomic sequence of instructions beginning with a LWARX/LDARX
1067 instruction and ending with a STWCX/STDCX instruction. If such a sequence
1068 is found, attempt to step through it. A breakpoint is placed at the end of
1069 the sequence. */
1070
4a7622d1
UW		 1071int
1072ppc_deal_with_atomic_sequence (struct frame_info *frame)
ce5eab59 1073{
0b1b3e42 1074 CORE_ADDR pc = get_frame_pc (frame);
ce5eab59
UW		 1075 CORE_ADDR breaks[2] = {-1, -1};
1076 CORE_ADDR loc = pc;
24d45690 1077 CORE_ADDR closing_insn; /* Instruction that closes the atomic sequence. */
ce5eab59
UW		 1078 int insn = read_memory_integer (loc, PPC_INSN_SIZE);
1079 int insn_count;
1080 int index;
1081 int last_breakpoint = 0; /* Defaults to 0 (no breakpoints placed). */
1082 const int atomic_sequence_length = 16; /* Instruction sequence length. */
24d45690 1083 int opcode; /* Branch instruction's OPcode. */
ce5eab59
UW		 1084 int bc_insn_count = 0; /* Conditional branch instruction count. */
1085
1086 /* Assume all atomic sequences start with a lwarx/ldarx instruction. */
1087 if ((insn & LWARX_MASK) != LWARX_INSTRUCTION
1088 && (insn & LWARX_MASK) != LDARX_INSTRUCTION)
1089 return 0;
1090
1091 /* Assume that no atomic sequence is longer than "atomic_sequence_length"
1092 instructions. */
1093 for (insn_count = 0; insn_count < atomic_sequence_length; ++insn_count)
1094 {
1095 loc += PPC_INSN_SIZE;
1096 insn = read_memory_integer (loc, PPC_INSN_SIZE);
1097
1098 /* Assume that there is at most one conditional branch in the atomic
1099 sequence. If a conditional branch is found, put a breakpoint in
1100 its destination address. */
f74c6cad 1101 if ((insn & BRANCH_MASK) == BC_INSN)
ce5eab59 1102 {
4a7622d1
UW		 1103 int immediate = ((insn & ~3) << 16) >> 16;
1104 int absolute = ((insn >> 1) & 1);
1105
ce5eab59
UW		 1106 if (bc_insn_count >= 1)
1107 return 0; /* More than one conditional branch found, fallback
1108 to the standard single-step code. */
4a7622d1
UW		 1109
1110 if (absolute)
1111 breaks[1] = immediate;
1112 else
1113 breaks[1] = pc + immediate;
1114
1115 bc_insn_count++;
1116 last_breakpoint++;
ce5eab59
UW		 1117 }
1118
1119 if ((insn & STWCX_MASK) == STWCX_INSTRUCTION
1120 || (insn & STWCX_MASK) == STDCX_INSTRUCTION)
1121 break;
1122 }
1123
1124 /* Assume that the atomic sequence ends with a stwcx/stdcx instruction. */
1125 if ((insn & STWCX_MASK) != STWCX_INSTRUCTION
1126 && (insn & STWCX_MASK) != STDCX_INSTRUCTION)
1127 return 0;
1128
24d45690 1129 closing_insn = loc;
ce5eab59
UW		 1130 loc += PPC_INSN_SIZE;
1131 insn = read_memory_integer (loc, PPC_INSN_SIZE);
1132
1133 /* Insert a breakpoint right after the end of the atomic sequence. */
1134 breaks[0] = loc;
1135
24d45690
UW		 1136 /* Check for duplicated breakpoints. Check also for a breakpoint
1137 placed (branch instruction's destination) at the stwcx/stdcx
1138 instruction, this resets the reservation and take us back to the
1139 lwarx/ldarx instruction at the beginning of the atomic sequence. */
1140 if (last_breakpoint && ((breaks[1] == breaks[0])
1141 || (breaks[1] == closing_insn)))
ce5eab59
UW		 1142 last_breakpoint = 0;
1143
1144 /* Effectively inserts the breakpoints. */
1145 for (index = 0; index <= last_breakpoint; index++)
1146 insert_single_step_breakpoint (breaks[index]);
1147
1148 return 1;
1149}
1150
c906108c 1151
c906108c
SS		 1152#define SIGNED_SHORT(x) \
1153 ((sizeof (short) == 2) \
1154 ? ((int)(short)(x)) \
1155 : ((int)((((x) & 0xffff) ^ 0x8000) - 0x8000)))
1156
1157#define GET_SRC_REG(x) (((x) >> 21) & 0x1f)
1158
55d05f3b
KB		 1159/* Limit the number of skipped non-prologue instructions, as the examining
1160 of the prologue is expensive. */
1161static int max_skip_non_prologue_insns = 10;
1162
773df3e5
JB		 1163/* Return nonzero if the given instruction OP can be part of the prologue
1164 of a function and saves a parameter on the stack. FRAMEP should be
1165 set if one of the previous instructions in the function has set the
1166 Frame Pointer. */
1167
1168static int
1169store_param_on_stack_p (unsigned long op, int framep, int *r0_contains_arg)
1170{
1171 /* Move parameters from argument registers to temporary register. */
1172 if ((op & 0xfc0007fe) == 0x7c000378) /* mr(.) Rx,Ry */
1173 {
1174 /* Rx must be scratch register r0. */
1175 const int rx_regno = (op >> 16) & 31;
1176 /* Ry: Only r3 - r10 are used for parameter passing. */
1177 const int ry_regno = GET_SRC_REG (op);
1178
1179 if (rx_regno == 0 && ry_regno >= 3 && ry_regno <= 10)
1180 {
1181 *r0_contains_arg = 1;
1182 return 1;
1183 }
1184 else
1185 return 0;
1186 }
1187
1188 /* Save a General Purpose Register on stack. */
1189
1190 if ((op & 0xfc1f0003) == 0xf8010000 || /* std Rx,NUM(r1) */
1191 (op & 0xfc1f0000) == 0xd8010000) /* stfd Rx,NUM(r1) */
1192 {
1193 /* Rx: Only r3 - r10 are used for parameter passing. */
1194 const int rx_regno = GET_SRC_REG (op);
1195
1196 return (rx_regno >= 3 && rx_regno <= 10);
1197 }
1198
1199 /* Save a General Purpose Register on stack via the Frame Pointer. */
1200
1201 if (framep &&
1202 ((op & 0xfc1f0000) == 0x901f0000 || /* st rx,NUM(r31) */
1203 (op & 0xfc1f0000) == 0x981f0000 || /* stb Rx,NUM(r31) */
1204 (op & 0xfc1f0000) == 0xd81f0000)) /* stfd Rx,NUM(r31) */
1205 {
1206 /* Rx: Usually, only r3 - r10 are used for parameter passing.
1207 However, the compiler sometimes uses r0 to hold an argument. */
1208 const int rx_regno = GET_SRC_REG (op);
1209
1210 return ((rx_regno >= 3 && rx_regno <= 10)
1211 || (rx_regno == 0 && *r0_contains_arg));
1212 }
1213
1214 if ((op & 0xfc1f0000) == 0xfc010000) /* frsp, fp?,NUM(r1) */
1215 {
1216 /* Only f2 - f8 are used for parameter passing. */
1217 const int src_regno = GET_SRC_REG (op);
1218
1219 return (src_regno >= 2 && src_regno <= 8);
1220 }
1221
1222 if (framep && ((op & 0xfc1f0000) == 0xfc1f0000)) /* frsp, fp?,NUM(r31) */
1223 {
1224 /* Only f2 - f8 are used for parameter passing. */
1225 const int src_regno = GET_SRC_REG (op);
1226
1227 return (src_regno >= 2 && src_regno <= 8);
1228 }
1229
1230 /* Not an insn that saves a parameter on stack. */
1231 return 0;
1232}
55d05f3b 1233
3c77c82a
DJ		 1234/* Assuming that INSN is a "bl" instruction located at PC, return
1235 nonzero if the destination of the branch is a "blrl" instruction.
1236
1237 This sequence is sometimes found in certain function prologues.
1238 It allows the function to load the LR register with a value that
1239 they can use to access PIC data using PC-relative offsets. */
1240
1241static int
1242bl_to_blrl_insn_p (CORE_ADDR pc, int insn)
1243{
0b1b3e42
UW		 1244 CORE_ADDR dest;
1245 int immediate;
1246 int absolute;
3c77c82a
DJ		 1247 int dest_insn;
1248
0b1b3e42
UW		 1249 absolute = (int) ((insn >> 1) & 1);
1250 immediate = ((insn & ~3) << 6) >> 6;
1251 if (absolute)
1252 dest = immediate;
1253 else
1254 dest = pc + immediate;
1255
3c77c82a
DJ		 1256 dest_insn = read_memory_integer (dest, 4);
1257 if ((dest_insn & 0xfc00ffff) == 0x4c000021) /* blrl */
1258 return 1;
1259
1260 return 0;
1261}
1262
8ab3d180
KB		 1263/* Masks for decoding a branch-and-link (bl) instruction.
1264
1265 BL_MASK and BL_INSTRUCTION are used in combination with each other.
1266 The former is anded with the opcode in question; if the result of
1267 this masking operation is equal to BL_INSTRUCTION, then the opcode in
1268 question is a ``bl'' instruction.
1269
1270 BL_DISPLACMENT_MASK is anded with the opcode in order to extract
1271 the branch displacement. */
1272
1273#define BL_MASK 0xfc000001
1274#define BL_INSTRUCTION 0x48000001
1275#define BL_DISPLACEMENT_MASK 0x03fffffc
1276
de9f48f0
JG		 1277static unsigned long
1278rs6000_fetch_instruction (const CORE_ADDR pc)
1279{
1280 gdb_byte buf[4];
1281 unsigned long op;
1282
1283 /* Fetch the instruction and convert it to an integer. */
1284 if (target_read_memory (pc, buf, 4))
1285 return 0;
1286 op = extract_unsigned_integer (buf, 4);
1287
1288 return op;
1289}
1290
1291/* GCC generates several well-known sequences of instructions at the begining
1292 of each function prologue when compiling with -fstack-check. If one of
1293 such sequences starts at START_PC, then return the address of the
1294 instruction immediately past this sequence. Otherwise, return START_PC. */
1295
1296static CORE_ADDR
1297rs6000_skip_stack_check (const CORE_ADDR start_pc)
1298{
1299 CORE_ADDR pc = start_pc;
1300 unsigned long op = rs6000_fetch_instruction (pc);
1301
1302 /* First possible sequence: A small number of probes.
1303 stw 0, -<some immediate>(1)
1304 [repeat this instruction any (small) number of times]
1305 */
1306
1307 if ((op & 0xffff0000) == 0x90010000)
1308 {
1309 while ((op & 0xffff0000) == 0x90010000)
1310 {
1311 pc = pc + 4;
1312 op = rs6000_fetch_instruction (pc);
1313 }
1314 return pc;
1315 }
1316
1317 /* Second sequence: A probing loop.
1318 addi 12,1,-<some immediate>
1319 lis 0,-<some immediate>
1320 [possibly ori 0,0,<some immediate>]
1321 add 0,12,0
1322 cmpw 0,12,0
1323 beq 0,<disp>
1324 addi 12,12,-<some immediate>
1325 stw 0,0(12)
1326 b <disp>
1327 [possibly one last probe: stw 0,<some immediate>(12)]
1328 */
1329
1330 while (1)
1331 {
1332 /* addi 12,1,-<some immediate> */
1333 if ((op & 0xffff0000) != 0x39810000)
1334 break;
1335
1336 /* lis 0,-<some immediate> */
1337 pc = pc + 4;
1338 op = rs6000_fetch_instruction (pc);
1339 if ((op & 0xffff0000) != 0x3c000000)
1340 break;
1341
1342 pc = pc + 4;
1343 op = rs6000_fetch_instruction (pc);
1344 /* [possibly ori 0,0,<some immediate>] */
1345 if ((op & 0xffff0000) == 0x60000000)
1346 {
1347 pc = pc + 4;
1348 op = rs6000_fetch_instruction (pc);
1349 }
1350 /* add 0,12,0 */
1351 if (op != 0x7c0c0214)
1352 break;
1353
1354 /* cmpw 0,12,0 */
1355 pc = pc + 4;
1356 op = rs6000_fetch_instruction (pc);
1357 if (op != 0x7c0c0000)
1358 break;
1359
1360 /* beq 0,<disp> */
1361 pc = pc + 4;
1362 op = rs6000_fetch_instruction (pc);
1363 if ((op & 0xff9f0001) != 0x41820000)
1364 break;
1365
1366 /* addi 12,12,-<some immediate> */
1367 pc = pc + 4;
1368 op = rs6000_fetch_instruction (pc);
1369 if ((op & 0xffff0000) != 0x398c0000)
1370 break;
1371
1372 /* stw 0,0(12) */
1373 pc = pc + 4;
1374 op = rs6000_fetch_instruction (pc);
1375 if (op != 0x900c0000)
1376 break;
1377
1378 /* b <disp> */
1379 pc = pc + 4;
1380 op = rs6000_fetch_instruction (pc);
1381 if ((op & 0xfc000001) != 0x48000000)
1382 break;
1383
1384 /* [possibly one last probe: stw 0,<some immediate>(12)] */
1385 pc = pc + 4;
1386 op = rs6000_fetch_instruction (pc);
1387 if ((op & 0xffff0000) == 0x900c0000)
1388 {
1389 pc = pc + 4;
1390 op = rs6000_fetch_instruction (pc);
1391 }
1392
1393 /* We found a valid stack-check sequence, return the new PC. */
1394 return pc;
1395 }
1396
1397 /* Third sequence: No probe; instead, a comparizon between the stack size
1398 limit (saved in a run-time global variable) and the current stack
1399 pointer:
1400
1401 addi 0,1,-<some immediate>
1402 lis 12,__gnat_stack_limit@ha
1403 lwz 12,__gnat_stack_limit@l(12)
1404 twllt 0,12
1405
1406 or, with a small variant in the case of a bigger stack frame:
1407 addis 0,1,<some immediate>
1408 addic 0,0,-<some immediate>
1409 lis 12,__gnat_stack_limit@ha
1410 lwz 12,__gnat_stack_limit@l(12)
1411 twllt 0,12
1412 */
1413 while (1)
1414 {
1415 /* addi 0,1,-<some immediate> */
1416 if ((op & 0xffff0000) != 0x38010000)
1417 {
1418 /* small stack frame variant not recognized; try the
1419 big stack frame variant: */
1420
1421 /* addis 0,1,<some immediate> */
1422 if ((op & 0xffff0000) != 0x3c010000)
1423 break;
1424
1425 /* addic 0,0,-<some immediate> */
1426 pc = pc + 4;
1427 op = rs6000_fetch_instruction (pc);
1428 if ((op & 0xffff0000) != 0x30000000)
1429 break;
1430 }
1431
1432 /* lis 12,<some immediate> */
1433 pc = pc + 4;
1434 op = rs6000_fetch_instruction (pc);
1435 if ((op & 0xffff0000) != 0x3d800000)
1436 break;
1437
1438 /* lwz 12,<some immediate>(12) */
1439 pc = pc + 4;
1440 op = rs6000_fetch_instruction (pc);
1441 if ((op & 0xffff0000) != 0x818c0000)
1442 break;
1443
1444 /* twllt 0,12 */
1445 pc = pc + 4;
1446 op = rs6000_fetch_instruction (pc);
1447 if ((op & 0xfffffffe) != 0x7c406008)
1448 break;
1449
1450 /* We found a valid stack-check sequence, return the new PC. */
1451 return pc;
1452 }
1453
1454 /* No stack check code in our prologue, return the start_pc. */
1455 return start_pc;
1456}
1457
6a16c029
TJB		 1458/* return pc value after skipping a function prologue and also return
1459 information about a function frame.
1460
1461 in struct rs6000_framedata fdata:
1462 - frameless is TRUE, if function does not have a frame.
1463 - nosavedpc is TRUE, if function does not save %pc value in its frame.
1464 - offset is the initial size of this stack frame --- the amount by
1465 which we decrement the sp to allocate the frame.
1466 - saved_gpr is the number of the first saved gpr.
1467 - saved_fpr is the number of the first saved fpr.
1468 - saved_vr is the number of the first saved vr.
1469 - saved_ev is the number of the first saved ev.
1470 - alloca_reg is the number of the register used for alloca() handling.
1471 Otherwise -1.
1472 - gpr_offset is the offset of the first saved gpr from the previous frame.
1473 - fpr_offset is the offset of the first saved fpr from the previous frame.
1474 - vr_offset is the offset of the first saved vr from the previous frame.
1475 - ev_offset is the offset of the first saved ev from the previous frame.
1476 - lr_offset is the offset of the saved lr
1477 - cr_offset is the offset of the saved cr
1478 - vrsave_offset is the offset of the saved vrsave register
1479 */
1480
7a78ae4e 1481static CORE_ADDR
be8626e0
MD		 1482skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR lim_pc,
1483 struct rs6000_framedata *fdata)
c906108c
SS		 1484{
1485 CORE_ADDR orig_pc = pc;
55d05f3b 1486 CORE_ADDR last_prologue_pc = pc;
6be8bc0c 1487 CORE_ADDR li_found_pc = 0;
50fd1280 1488 gdb_byte buf[4];
c906108c
SS		 1489 unsigned long op;
1490 long offset = 0;
6be8bc0c 1491 long vr_saved_offset = 0;
482ca3f5
KB		 1492 int lr_reg = -1;
1493 int cr_reg = -1;
6be8bc0c 1494 int vr_reg = -1;
96ff0de4
EZ		 1495 int ev_reg = -1;
1496 long ev_offset = 0;
6be8bc0c 1497 int vrsave_reg = -1;
c906108c
SS		 1498 int reg;
1499 int framep = 0;
1500 int minimal_toc_loaded = 0;
ddb20c56 1501 int prev_insn_was_prologue_insn = 1;
55d05f3b 1502 int num_skip_non_prologue_insns = 0;
773df3e5 1503 int r0_contains_arg = 0;
be8626e0
MD		 1504 const struct bfd_arch_info *arch_info = gdbarch_bfd_arch_info (gdbarch);
1505 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
c906108c 1506
ddb20c56 1507 memset (fdata, 0, sizeof (struct rs6000_framedata));
c906108c
SS		 1508 fdata->saved_gpr = -1;
1509 fdata->saved_fpr = -1;
6be8bc0c 1510 fdata->saved_vr = -1;
96ff0de4 1511 fdata->saved_ev = -1;
c906108c
SS		 1512 fdata->alloca_reg = -1;
1513 fdata->frameless = 1;
1514 fdata->nosavedpc = 1;
46a9b8ed 1515 fdata->lr_register = -1;
c906108c 1516
de9f48f0
JG		 1517 pc = rs6000_skip_stack_check (pc);
1518 if (pc >= lim_pc)
1519 pc = lim_pc;
1520
55d05f3b 1521 for (;; pc += 4)
c906108c 1522 {
ddb20c56
KB		 1523 /* Sometimes it isn't clear if an instruction is a prologue
1524 instruction or not. When we encounter one of these ambiguous
1525 cases, we'll set prev_insn_was_prologue_insn to 0 (false).
1526 Otherwise, we'll assume that it really is a prologue instruction. */
1527 if (prev_insn_was_prologue_insn)
1528 last_prologue_pc = pc;
55d05f3b
KB		 1529
1530 /* Stop scanning if we've hit the limit. */
4e463ff5 1531 if (pc >= lim_pc)
55d05f3b
KB		 1532 break;
1533
ddb20c56
KB		 1534 prev_insn_was_prologue_insn = 1;
1535
55d05f3b 1536 /* Fetch the instruction and convert it to an integer. */
ddb20c56
KB		 1537 if (target_read_memory (pc, buf, 4))
1538 break;
4e463ff5 1539 op = extract_unsigned_integer (buf, 4);
c906108c 1540
c5aa993b
JM		 1541 if ((op & 0xfc1fffff) == 0x7c0802a6)
1542 { /* mflr Rx */
43b1ab88
AC		 1543 /* Since shared library / PIC code, which needs to get its
1544 address at runtime, can appear to save more than one link
1545 register vis:
1546
1547 *INDENT-OFF*
1548 stwu r1,-304(r1)
1549 mflr r3
1550 bl 0xff570d0 (blrl)
1551 stw r30,296(r1)
1552 mflr r30
1553 stw r31,300(r1)
1554 stw r3,308(r1);
1555 ...
1556 *INDENT-ON*
1557
1558 remember just the first one, but skip over additional
1559 ones. */
721d14ba 1560 if (lr_reg == -1)
46a9b8ed 1561 lr_reg = (op & 0x03e00000) >> 21;
773df3e5
JB		 1562 if (lr_reg == 0)
1563 r0_contains_arg = 0;
c5aa993b 1564 continue;
c5aa993b
JM		 1565 }
1566 else if ((op & 0xfc1fffff) == 0x7c000026)
1567 { /* mfcr Rx */
98f08d3d 1568 cr_reg = (op & 0x03e00000);
773df3e5
JB		 1569 if (cr_reg == 0)
1570 r0_contains_arg = 0;
c5aa993b 1571 continue;
c906108c 1572
c906108c 1573 }
c5aa993b
JM		 1574 else if ((op & 0xfc1f0000) == 0xd8010000)
1575 { /* stfd Rx,NUM(r1) */
1576 reg = GET_SRC_REG (op);
1577 if (fdata->saved_fpr == -1 || fdata->saved_fpr > reg)
1578 {
1579 fdata->saved_fpr = reg;
1580 fdata->fpr_offset = SIGNED_SHORT (op) + offset;
1581 }
1582 continue;
c906108c 1583
c5aa993b
JM		 1584 }
1585 else if (((op & 0xfc1f0000) == 0xbc010000) || /* stm Rx, NUM(r1) */
7a78ae4e
ND		 1586 (((op & 0xfc1f0000) == 0x90010000 || /* st rx,NUM(r1) */
1587 (op & 0xfc1f0003) == 0xf8010000) && /* std rx,NUM(r1) */
1588 (op & 0x03e00000) >= 0x01a00000)) /* rx >= r13 */
c5aa993b
JM		 1589 {
1590
1591 reg = GET_SRC_REG (op);
46a9b8ed
DJ		 1592 if ((op & 0xfc1f0000) == 0xbc010000)
1593 fdata->gpr_mask |= ~((1U << reg) - 1);
1594 else
1595 fdata->gpr_mask |= 1U << reg;
c5aa993b
JM		 1596 if (fdata->saved_gpr == -1 || fdata->saved_gpr > reg)
1597 {
1598 fdata->saved_gpr = reg;
7a78ae4e 1599 if ((op & 0xfc1f0003) == 0xf8010000)
98f08d3d 1600 op &= ~3UL;
c5aa993b
JM		 1601 fdata->gpr_offset = SIGNED_SHORT (op) + offset;
1602 }
1603 continue;
c906108c 1604
ddb20c56
KB		 1605 }
1606 else if ((op & 0xffff0000) == 0x60000000)
1607 {
96ff0de4 1608 /* nop */
ddb20c56
KB		 1609 /* Allow nops in the prologue, but do not consider them to
1610 be part of the prologue unless followed by other prologue
1611 instructions. */
1612 prev_insn_was_prologue_insn = 0;
1613 continue;
1614
c906108c 1615 }
c5aa993b
JM		 1616 else if ((op & 0xffff0000) == 0x3c000000)
1617 { /* addis 0,0,NUM, used
1618 for >= 32k frames */
1619 fdata->offset = (op & 0x0000ffff) << 16;
1620 fdata->frameless = 0;
773df3e5 1621 r0_contains_arg = 0;
c5aa993b
JM		 1622 continue;
1623
1624 }
1625 else if ((op & 0xffff0000) == 0x60000000)
1626 { /* ori 0,0,NUM, 2nd ha
1627 lf of >= 32k frames */
1628 fdata->offset |= (op & 0x0000ffff);
1629 fdata->frameless = 0;
773df3e5 1630 r0_contains_arg = 0;
c5aa993b
JM		 1631 continue;
1632
1633 }
be723e22 1634 else if (lr_reg >= 0 &&
98f08d3d
KB		 1635 /* std Rx, NUM(r1) || stdu Rx, NUM(r1) */
1636 (((op & 0xffff0000) == (lr_reg | 0xf8010000)) ||
1637 /* stw Rx, NUM(r1) */
1638 ((op & 0xffff0000) == (lr_reg | 0x90010000)) ||
1639 /* stwu Rx, NUM(r1) */
1640 ((op & 0xffff0000) == (lr_reg | 0x94010000))))
1641 { /* where Rx == lr */
1642 fdata->lr_offset = offset;
c5aa993b 1643 fdata->nosavedpc = 0;
be723e22
MS		 1644 /* Invalidate lr_reg, but don't set it to -1.
1645 That would mean that it had never been set. */
1646 lr_reg = -2;
98f08d3d
KB		 1647 if ((op & 0xfc000003) == 0xf8000000 || /* std */
1648 (op & 0xfc000000) == 0x90000000) /* stw */
1649 {
1650 /* Does not update r1, so add displacement to lr_offset. */
1651 fdata->lr_offset += SIGNED_SHORT (op);
1652 }
c5aa993b
JM		 1653 continue;
1654
1655 }
be723e22 1656 else if (cr_reg >= 0 &&
98f08d3d
KB		 1657 /* std Rx, NUM(r1) || stdu Rx, NUM(r1) */
1658 (((op & 0xffff0000) == (cr_reg | 0xf8010000)) ||
1659 /* stw Rx, NUM(r1) */
1660 ((op & 0xffff0000) == (cr_reg | 0x90010000)) ||
1661 /* stwu Rx, NUM(r1) */
1662 ((op & 0xffff0000) == (cr_reg | 0x94010000))))
1663 { /* where Rx == cr */
1664 fdata->cr_offset = offset;
be723e22
MS		 1665 /* Invalidate cr_reg, but don't set it to -1.
1666 That would mean that it had never been set. */
1667 cr_reg = -2;
98f08d3d
KB		 1668 if ((op & 0xfc000003) == 0xf8000000 ||
1669 (op & 0xfc000000) == 0x90000000)
1670 {
1671 /* Does not update r1, so add displacement to cr_offset. */
1672 fdata->cr_offset += SIGNED_SHORT (op);
1673 }
c5aa993b
JM		 1674 continue;
1675
1676 }
721d14ba
DJ		 1677 else if ((op & 0xfe80ffff) == 0x42800005 && lr_reg != -1)
1678 {
1679 /* bcl 20,xx,.+4 is used to get the current PC, with or without
1680 prediction bits. If the LR has already been saved, we can
1681 skip it. */
1682 continue;
1683 }
c5aa993b
JM		 1684 else if (op == 0x48000005)
1685 { /* bl .+4 used in
1686 -mrelocatable */
46a9b8ed 1687 fdata->used_bl = 1;
c5aa993b
JM		 1688 continue;
1689
1690 }
1691 else if (op == 0x48000004)
1692 { /* b .+4 (xlc) */
1693 break;
1694
c5aa993b 1695 }
6be8bc0c
EZ		 1696 else if ((op & 0xffff0000) == 0x3fc00000 || /* addis 30,0,foo@ha, used
1697 in V.4 -mminimal-toc */
c5aa993b
JM		 1698 (op & 0xffff0000) == 0x3bde0000)
1699 { /* addi 30,30,foo@l */
1700 continue;
c906108c 1701
c5aa993b
JM		 1702 }
1703 else if ((op & 0xfc000001) == 0x48000001)
1704 { /* bl foo,
1705 to save fprs??? */
c906108c 1706
c5aa993b 1707 fdata->frameless = 0;
3c77c82a
DJ		 1708
1709 /* If the return address has already been saved, we can skip
1710 calls to blrl (for PIC). */
1711 if (lr_reg != -1 && bl_to_blrl_insn_p (pc, op))
46a9b8ed
DJ		 1712 {
1713 fdata->used_bl = 1;
1714 continue;
1715 }
3c77c82a 1716
6be8bc0c 1717 /* Don't skip over the subroutine call if it is not within
ebd98106
FF		 1718 the first three instructions of the prologue and either
1719 we have no line table information or the line info tells
1720 us that the subroutine call is not part of the line
1721 associated with the prologue. */
c5aa993b 1722 if ((pc - orig_pc) > 8)
ebd98106
FF		 1723 {
1724 struct symtab_and_line prologue_sal = find_pc_line (orig_pc, 0);
1725 struct symtab_and_line this_sal = find_pc_line (pc, 0);
1726
1727 if ((prologue_sal.line == 0) || (prologue_sal.line != this_sal.line))
1728 break;
1729 }
c5aa993b
JM		 1730
1731 op = read_memory_integer (pc + 4, 4);
1732
6be8bc0c
EZ		 1733 /* At this point, make sure this is not a trampoline
1734 function (a function that simply calls another functions,
1735 and nothing else). If the next is not a nop, this branch
1736 was part of the function prologue. */
c5aa993b
JM		 1737
1738 if (op == 0x4def7b82 || op == 0) /* crorc 15, 15, 15 */
1739 break; /* don't skip over
1740 this branch */
c5aa993b 1741
46a9b8ed
DJ		 1742 fdata->used_bl = 1;
1743 continue;
c5aa993b 1744 }
98f08d3d
KB		 1745 /* update stack pointer */
1746 else if ((op & 0xfc1f0000) == 0x94010000)
1747 { /* stu rX,NUM(r1) || stwu rX,NUM(r1) */
c5aa993b
JM		 1748 fdata->frameless = 0;
1749 fdata->offset = SIGNED_SHORT (op);
1750 offset = fdata->offset;
1751 continue;
c5aa993b 1752 }
98f08d3d
KB		 1753 else if ((op & 0xfc1f016a) == 0x7c01016e)
1754 { /* stwux rX,r1,rY */
1755 /* no way to figure out what r1 is going to be */
1756 fdata->frameless = 0;
1757 offset = fdata->offset;
1758 continue;
1759 }
1760 else if ((op & 0xfc1f0003) == 0xf8010001)
1761 { /* stdu rX,NUM(r1) */
1762 fdata->frameless = 0;
1763 fdata->offset = SIGNED_SHORT (op & ~3UL);
1764 offset = fdata->offset;
1765 continue;
1766 }
1767 else if ((op & 0xfc1f016a) == 0x7c01016a)
1768 { /* stdux rX,r1,rY */
1769 /* no way to figure out what r1 is going to be */
c5aa993b
JM		 1770 fdata->frameless = 0;
1771 offset = fdata->offset;
1772 continue;
c5aa993b 1773 }
7313566f
FF		 1774 else if ((op & 0xffff0000) == 0x38210000)
1775 { /* addi r1,r1,SIMM */
1776 fdata->frameless = 0;
1777 fdata->offset += SIGNED_SHORT (op);
1778 offset = fdata->offset;
1779 continue;
1780 }
4e463ff5
DJ		 1781 /* Load up minimal toc pointer. Do not treat an epilogue restore
1782 of r31 as a minimal TOC load. */
98f08d3d
KB		 1783 else if (((op >> 22) == 0x20f || /* l r31,... or l r30,... */
1784 (op >> 22) == 0x3af) /* ld r31,... or ld r30,... */
4e463ff5 1785 && !framep
c5aa993b 1786 && !minimal_toc_loaded)
98f08d3d 1787 {
c5aa993b
JM		 1788 minimal_toc_loaded = 1;
1789 continue;
1790
f6077098
KB		 1791 /* move parameters from argument registers to local variable
1792 registers */
1793 }
1794 else if ((op & 0xfc0007fe) == 0x7c000378 && /* mr(.) Rx,Ry */
1795 (((op >> 21) & 31) >= 3) && /* R3 >= Ry >= R10 */
1796 (((op >> 21) & 31) <= 10) &&
96ff0de4 1797 ((long) ((op >> 16) & 31) >= fdata->saved_gpr)) /* Rx: local var reg */
f6077098
KB		 1798 {
1799 continue;
1800
c5aa993b
JM		 1801 /* store parameters in stack */
1802 }
e802b915 1803 /* Move parameters from argument registers to temporary register. */
773df3e5 1804 else if (store_param_on_stack_p (op, framep, &r0_contains_arg))
e802b915 1805 {
c5aa993b
JM		 1806 continue;
1807
1808 /* Set up frame pointer */
1809 }
1810 else if (op == 0x603f0000 /* oril r31, r1, 0x0 */
1811 || op == 0x7c3f0b78)
1812 { /* mr r31, r1 */
1813 fdata->frameless = 0;
1814 framep = 1;
6f99cb26 1815 fdata->alloca_reg = (tdep->ppc_gp0_regnum + 31);
c5aa993b
JM		 1816 continue;
1817
1818 /* Another way to set up the frame pointer. */
1819 }
1820 else if ((op & 0xfc1fffff) == 0x38010000)
1821 { /* addi rX, r1, 0x0 */
1822 fdata->frameless = 0;
1823 framep = 1;
6f99cb26
AC		 1824 fdata->alloca_reg = (tdep->ppc_gp0_regnum
1825 + ((op & ~0x38010000) >> 21));
c5aa993b 1826 continue;
c5aa993b 1827 }
6be8bc0c
EZ		 1828 /* AltiVec related instructions. */
1829 /* Store the vrsave register (spr 256) in another register for
1830 later manipulation, or load a register into the vrsave
1831 register. 2 instructions are used: mfvrsave and
1832 mtvrsave. They are shorthand notation for mfspr Rn, SPR256
1833 and mtspr SPR256, Rn. */
1834 /* mfspr Rn SPR256 == 011111 nnnnn 0000001000 01010100110
1835 mtspr SPR256 Rn == 011111 nnnnn 0000001000 01110100110 */
1836 else if ((op & 0xfc1fffff) == 0x7c0042a6) /* mfvrsave Rn */
1837 {
1838 vrsave_reg = GET_SRC_REG (op);
1839 continue;
1840 }
1841 else if ((op & 0xfc1fffff) == 0x7c0043a6) /* mtvrsave Rn */
1842 {
1843 continue;
1844 }
1845 /* Store the register where vrsave was saved to onto the stack:
1846 rS is the register where vrsave was stored in a previous
1847 instruction. */
1848 /* 100100 sssss 00001 dddddddd dddddddd */
1849 else if ((op & 0xfc1f0000) == 0x90010000) /* stw rS, d(r1) */
1850 {
1851 if (vrsave_reg == GET_SRC_REG (op))
1852 {
1853 fdata->vrsave_offset = SIGNED_SHORT (op) + offset;
1854 vrsave_reg = -1;
1855 }
1856 continue;
1857 }
1858 /* Compute the new value of vrsave, by modifying the register
1859 where vrsave was saved to. */
1860 else if (((op & 0xfc000000) == 0x64000000) /* oris Ra, Rs, UIMM */
1861 || ((op & 0xfc000000) == 0x60000000))/* ori Ra, Rs, UIMM */
1862 {
1863 continue;
1864 }
1865 /* li r0, SIMM (short for addi r0, 0, SIMM). This is the first
1866 in a pair of insns to save the vector registers on the
1867 stack. */
1868 /* 001110 00000 00000 iiii iiii iiii iiii */
96ff0de4
EZ		 1869 /* 001110 01110 00000 iiii iiii iiii iiii */
1870 else if ((op & 0xffff0000) == 0x38000000 /* li r0, SIMM */
1871 || (op & 0xffff0000) == 0x39c00000) /* li r14, SIMM */
6be8bc0c 1872 {
773df3e5
JB		 1873 if ((op & 0xffff0000) == 0x38000000)
1874 r0_contains_arg = 0;
6be8bc0c
EZ		 1875 li_found_pc = pc;
1876 vr_saved_offset = SIGNED_SHORT (op);
773df3e5
JB		 1877
1878 /* This insn by itself is not part of the prologue, unless
1879 if part of the pair of insns mentioned above. So do not
1880 record this insn as part of the prologue yet. */
1881 prev_insn_was_prologue_insn = 0;
6be8bc0c
EZ		 1882 }
1883 /* Store vector register S at (r31+r0) aligned to 16 bytes. */
1884 /* 011111 sssss 11111 00000 00111001110 */
1885 else if ((op & 0xfc1fffff) == 0x7c1f01ce) /* stvx Vs, R31, R0 */
1886 {
1887 if (pc == (li_found_pc + 4))
1888 {
1889 vr_reg = GET_SRC_REG (op);
1890 /* If this is the first vector reg to be saved, or if
1891 it has a lower number than others previously seen,
1892 reupdate the frame info. */
1893 if (fdata->saved_vr == -1 || fdata->saved_vr > vr_reg)
1894 {
1895 fdata->saved_vr = vr_reg;
1896 fdata->vr_offset = vr_saved_offset + offset;
1897 }
1898 vr_saved_offset = -1;
1899 vr_reg = -1;
1900 li_found_pc = 0;
1901 }
1902 }
1903 /* End AltiVec related instructions. */
96ff0de4
EZ		 1904
1905 /* Start BookE related instructions. */
1906 /* Store gen register S at (r31+uimm).
1907 Any register less than r13 is volatile, so we don't care. */
1908 /* 000100 sssss 11111 iiiii 01100100001 */
1909 else if (arch_info->mach == bfd_mach_ppc_e500
1910 && (op & 0xfc1f07ff) == 0x101f0321) /* evstdd Rs,uimm(R31) */
1911 {
1912 if ((op & 0x03e00000) >= 0x01a00000) /* Rs >= r13 */
1913 {
1914 unsigned int imm;
1915 ev_reg = GET_SRC_REG (op);
1916 imm = (op >> 11) & 0x1f;
1917 ev_offset = imm * 8;
1918 /* If this is the first vector reg to be saved, or if
1919 it has a lower number than others previously seen,
1920 reupdate the frame info. */
1921 if (fdata->saved_ev == -1 || fdata->saved_ev > ev_reg)
1922 {
1923 fdata->saved_ev = ev_reg;
1924 fdata->ev_offset = ev_offset + offset;
1925 }
1926 }
1927 continue;
1928 }
1929 /* Store gen register rS at (r1+rB). */
1930 /* 000100 sssss 00001 bbbbb 01100100000 */
1931 else if (arch_info->mach == bfd_mach_ppc_e500
1932 && (op & 0xffe007ff) == 0x13e00320) /* evstddx RS,R1,Rb */
1933 {
1934 if (pc == (li_found_pc + 4))
1935 {
1936 ev_reg = GET_SRC_REG (op);
1937 /* If this is the first vector reg to be saved, or if
1938 it has a lower number than others previously seen,
1939 reupdate the frame info. */
1940 /* We know the contents of rB from the previous instruction. */
1941 if (fdata->saved_ev == -1 || fdata->saved_ev > ev_reg)
1942 {
1943 fdata->saved_ev = ev_reg;
1944 fdata->ev_offset = vr_saved_offset + offset;
1945 }
1946 vr_saved_offset = -1;
1947 ev_reg = -1;
1948 li_found_pc = 0;
1949 }
1950 continue;
1951 }
1952 /* Store gen register r31 at (rA+uimm). */
1953 /* 000100 11111 aaaaa iiiii 01100100001 */
1954 else if (arch_info->mach == bfd_mach_ppc_e500
1955 && (op & 0xffe007ff) == 0x13e00321) /* evstdd R31,Ra,UIMM */
1956 {
1957 /* Wwe know that the source register is 31 already, but
1958 it can't hurt to compute it. */
1959 ev_reg = GET_SRC_REG (op);
1960 ev_offset = ((op >> 11) & 0x1f) * 8;
1961 /* If this is the first vector reg to be saved, or if
1962 it has a lower number than others previously seen,
1963 reupdate the frame info. */
1964 if (fdata->saved_ev == -1 || fdata->saved_ev > ev_reg)
1965 {
1966 fdata->saved_ev = ev_reg;
1967 fdata->ev_offset = ev_offset + offset;
1968 }
1969
1970 continue;
1971 }
1972 /* Store gen register S at (r31+r0).
1973 Store param on stack when offset from SP bigger than 4 bytes. */
1974 /* 000100 sssss 11111 00000 01100100000 */
1975 else if (arch_info->mach == bfd_mach_ppc_e500
1976 && (op & 0xfc1fffff) == 0x101f0320) /* evstddx Rs,R31,R0 */
1977 {
1978 if (pc == (li_found_pc + 4))
1979 {
1980 if ((op & 0x03e00000) >= 0x01a00000)
1981 {
1982 ev_reg = GET_SRC_REG (op);
1983 /* If this is the first vector reg to be saved, or if
1984 it has a lower number than others previously seen,
1985 reupdate the frame info. */
1986 /* We know the contents of r0 from the previous
1987 instruction. */
1988 if (fdata->saved_ev == -1 || fdata->saved_ev > ev_reg)
1989 {
1990 fdata->saved_ev = ev_reg;
1991 fdata->ev_offset = vr_saved_offset + offset;
1992 }
1993 ev_reg = -1;
1994 }
1995 vr_saved_offset = -1;
1996 li_found_pc = 0;
1997 continue;
1998 }
1999 }
2000 /* End BookE related instructions. */
2001
c5aa993b
JM		 2002 else
2003 {
46a9b8ed
DJ		 2004 unsigned int all_mask = ~((1U << fdata->saved_gpr) - 1);
2005
55d05f3b
KB		 2006 /* Not a recognized prologue instruction.
2007 Handle optimizer code motions into the prologue by continuing
2008 the search if we have no valid frame yet or if the return
46a9b8ed
DJ		 2009 address is not yet saved in the frame. Also skip instructions
2010 if some of the GPRs expected to be saved are not yet saved. */
2011 if (fdata->frameless == 0 && fdata->nosavedpc == 0
2012 && (fdata->gpr_mask & all_mask) == all_mask)
55d05f3b
KB		 2013 break;
2014
2015 if (op == 0x4e800020 /* blr */
2016 || op == 0x4e800420) /* bctr */
2017 /* Do not scan past epilogue in frameless functions or
2018 trampolines. */
2019 break;
2020 if ((op & 0xf4000000) == 0x40000000) /* bxx */
64366f1c 2021 /* Never skip branches. */
55d05f3b
KB		 2022 break;
2023
2024 if (num_skip_non_prologue_insns++ > max_skip_non_prologue_insns)
2025 /* Do not scan too many insns, scanning insns is expensive with
2026 remote targets. */
2027 break;
2028
2029 /* Continue scanning. */
2030 prev_insn_was_prologue_insn = 0;
2031 continue;
c5aa993b 2032 }
c906108c
SS		 2033 }
2034
2035#if 0
2036/* I have problems with skipping over __main() that I need to address
2037 * sometime. Previously, I used to use misc_function_vector which
2038 * didn't work as well as I wanted to be. -MGO */
2039
2040 /* If the first thing after skipping a prolog is a branch to a function,
2041 this might be a call to an initializer in main(), introduced by gcc2.
64366f1c 2042 We'd like to skip over it as well. Fortunately, xlc does some extra
c906108c 2043 work before calling a function right after a prologue, thus we can
64366f1c 2044 single out such gcc2 behaviour. */
c906108c 2045
c906108c 2046
c5aa993b
JM		 2047 if ((op & 0xfc000001) == 0x48000001)
2048 { /* bl foo, an initializer function? */
2049 op = read_memory_integer (pc + 4, 4);
2050
2051 if (op == 0x4def7b82)
2052 { /* cror 0xf, 0xf, 0xf (nop) */
c906108c 2053
64366f1c
EZ		 2054 /* Check and see if we are in main. If so, skip over this
2055 initializer function as well. */
c906108c 2056
c5aa993b 2057 tmp = find_pc_misc_function (pc);
6314a349
AC		 2058 if (tmp >= 0
2059 && strcmp (misc_function_vector[tmp].name, main_name ()) == 0)
c5aa993b
JM		 2060 return pc + 8;
2061 }
c906108c 2062 }
c906108c 2063#endif /* 0 */
c5aa993b 2064
46a9b8ed
DJ		 2065 if (pc == lim_pc && lr_reg >= 0)
2066 fdata->lr_register = lr_reg;
2067
c5aa993b 2068 fdata->offset = -fdata->offset;
ddb20c56 2069 return last_prologue_pc;
c906108c
SS		 2070}
2071
7a78ae4e 2072static CORE_ADDR
4a7622d1 2073rs6000_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
c906108c 2074{
4a7622d1
UW		 2075 struct rs6000_framedata frame;
2076 CORE_ADDR limit_pc, func_addr;
c906108c 2077
4a7622d1
UW		 2078 /* See if we can determine the end of the prologue via the symbol table.
2079 If so, then return either PC, or the PC after the prologue, whichever
2080 is greater. */
2081 if (find_pc_partial_function (pc, NULL, &func_addr, NULL))
c5aa993b 2082 {
d80b854b
UW		 2083 CORE_ADDR post_prologue_pc
2084 = skip_prologue_using_sal (gdbarch, func_addr);
4a7622d1
UW		 2085 if (post_prologue_pc != 0)
2086 return max (pc, post_prologue_pc);
c906108c 2087 }
c906108c 2088
4a7622d1
UW		 2089 /* Can't determine prologue from the symbol table, need to examine
2090 instructions. */
c906108c 2091
4a7622d1
UW		 2092 /* Find an upper limit on the function prologue using the debug
2093 information. If the debug information could not be used to provide
2094 that bound, then use an arbitrary large number as the upper bound. */
d80b854b 2095 limit_pc = skip_prologue_using_sal (gdbarch, pc);
4a7622d1
UW		 2096 if (limit_pc == 0)
2097 limit_pc = pc + 100; /* Magic. */
794a477a 2098
4a7622d1
UW		 2099 pc = skip_prologue (gdbarch, pc, limit_pc, &frame);
2100 return pc;
c906108c 2101}
c906108c 2102
8ab3d180
KB		 2103/* When compiling for EABI, some versions of GCC emit a call to __eabi
2104 in the prologue of main().
2105
2106 The function below examines the code pointed at by PC and checks to
2107 see if it corresponds to a call to __eabi. If so, it returns the
2108 address of the instruction following that call. Otherwise, it simply
2109 returns PC. */
2110
63807e1d 2111static CORE_ADDR
8ab3d180
KB		 2112rs6000_skip_main_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
2113{
2114 gdb_byte buf[4];
2115 unsigned long op;
2116
2117 if (target_read_memory (pc, buf, 4))
2118 return pc;
2119 op = extract_unsigned_integer (buf, 4);
2120
2121 if ((op & BL_MASK) == BL_INSTRUCTION)
2122 {
2123 CORE_ADDR displ = op & BL_DISPLACEMENT_MASK;
2124 CORE_ADDR call_dest = pc + 4 + displ;
2125 struct minimal_symbol *s = lookup_minimal_symbol_by_pc (call_dest);
2126
2127 /* We check for ___eabi (three leading underscores) in addition
2128 to __eabi in case the GCC option "-fleading-underscore" was
2129 used to compile the program. */
2130 if (s != NULL
2131 && SYMBOL_LINKAGE_NAME (s) != NULL
2132 && (strcmp (SYMBOL_LINKAGE_NAME (s), "__eabi") == 0
2133 || strcmp (SYMBOL_LINKAGE_NAME (s), "___eabi") == 0))
2134 pc += 4;
2135 }
2136 return pc;
2137}
383f0f5b 2138
4a7622d1
UW		 2139/* All the ABI's require 16 byte alignment. */
2140static CORE_ADDR
2141rs6000_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
2142{
2143 return (addr & -16);
c906108c
SS		 2144}
2145
977adac5
ND		 2146/* Return whether handle_inferior_event() should proceed through code
2147 starting at PC in function NAME when stepping.
2148
2149 The AIX -bbigtoc linker option generates functions @FIX0, @FIX1, etc. to
2150 handle memory references that are too distant to fit in instructions
2151 generated by the compiler. For example, if 'foo' in the following
2152 instruction:
2153
2154 lwz r9,foo(r2)
2155
2156 is greater than 32767, the linker might replace the lwz with a branch to
2157 somewhere in @FIX1 that does the load in 2 instructions and then branches
2158 back to where execution should continue.
2159
2160 GDB should silently step over @FIX code, just like AIX dbx does.
2ec664f5
MS		 2161 Unfortunately, the linker uses the "b" instruction for the
2162 branches, meaning that the link register doesn't get set.
2163 Therefore, GDB's usual step_over_function () mechanism won't work.
977adac5 2164
e76f05fa
UW		 2165 Instead, use the gdbarch_skip_trampoline_code and
2166 gdbarch_skip_trampoline_code hooks in handle_inferior_event() to skip past
2ec664f5 2167 @FIX code. */
977adac5 2168
63807e1d 2169static int
977adac5
ND		 2170rs6000_in_solib_return_trampoline (CORE_ADDR pc, char *name)
2171{
2172 return name && !strncmp (name, "@FIX", 4);
2173}
2174
2175/* Skip code that the user doesn't want to see when stepping:
2176
2177 1. Indirect function calls use a piece of trampoline code to do context
2178 switching, i.e. to set the new TOC table. Skip such code if we are on
2179 its first instruction (as when we have single-stepped to here).
2180
2181 2. Skip shared library trampoline code (which is different from
c906108c 2182 indirect function call trampolines).
977adac5
ND		 2183
2184 3. Skip bigtoc fixup code.
2185
c906108c 2186 Result is desired PC to step until, or NULL if we are not in
977adac5 2187 code that should be skipped. */
c906108c 2188
63807e1d 2189static CORE_ADDR
52f729a7 2190rs6000_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
c906108c 2191{
4a7622d1 2192 struct gdbarch_tdep *tdep = gdbarch_tdep (get_frame_arch (frame));
52f0bd74 2193 unsigned int ii, op;
977adac5 2194 int rel;
c906108c 2195 CORE_ADDR solib_target_pc;
977adac5 2196 struct minimal_symbol *msymbol;
c906108c 2197
c5aa993b
JM		 2198 static unsigned trampoline_code[] =
2199 {
2200 0x800b0000, /* l r0,0x0(r11) */
2201 0x90410014, /* st r2,0x14(r1) */
2202 0x7c0903a6, /* mtctr r0 */
2203 0x804b0004, /* l r2,0x4(r11) */
2204 0x816b0008, /* l r11,0x8(r11) */
2205 0x4e800420, /* bctr */
2206 0x4e800020, /* br */
2207 0
c906108c
SS		 2208 };
2209
977adac5
ND		 2210 /* Check for bigtoc fixup code. */
2211 msymbol = lookup_minimal_symbol_by_pc (pc);
2ec664f5 2212 if (msymbol
4a7622d1 2213 && rs6000_in_solib_return_trampoline (pc, SYMBOL_LINKAGE_NAME (msymbol)))
977adac5
ND		 2214 {
2215 /* Double-check that the third instruction from PC is relative "b". */
2216 op = read_memory_integer (pc + 8, 4);
2217 if ((op & 0xfc000003) == 0x48000000)
2218 {
2219 /* Extract bits 6-29 as a signed 24-bit relative word address and
2220 add it to the containing PC. */
2221 rel = ((int)(op << 6) >> 6);
2222 return pc + 8 + rel;
2223 }
2224 }
2225
c906108c 2226 /* If pc is in a shared library trampoline, return its target. */
52f729a7 2227 solib_target_pc = find_solib_trampoline_target (frame, pc);
c906108c
SS		 2228 if (solib_target_pc)
2229 return solib_target_pc;
2230
c5aa993b
JM		 2231 for (ii = 0; trampoline_code[ii]; ++ii)
2232 {
2233 op = read_memory_integer (pc + (ii * 4), 4);
2234 if (op != trampoline_code[ii])
2235 return 0;
2236 }
52f729a7 2237 ii = get_frame_register_unsigned (frame, 11); /* r11 holds destination addr */
4a7622d1 2238 pc = read_memory_unsigned_integer (ii, tdep->wordsize); /* (r11) value */
c906108c
SS		 2239 return pc;
2240}
2241
794ac428
UW		 2242/* ISA-specific vector types. */
2243
2244static struct type *
2245rs6000_builtin_type_vec64 (struct gdbarch *gdbarch)
2246{
2247 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2248
2249 if (!tdep->ppc_builtin_type_vec64)
2250 {
df4df182
UW		 2251 const struct builtin_type *bt = builtin_type (gdbarch);
2252
794ac428
UW		 2253 /* The type we're building is this: */
2254#if 0
2255 union __gdb_builtin_type_vec64
2256 {
2257 int64_t uint64;
2258 float v2_float[2];
2259 int32_t v2_int32[2];
2260 int16_t v4_int16[4];
2261 int8_t v8_int8[8];
2262 };
2263#endif
2264
2265 struct type *t;
2266
2267 t = init_composite_type ("__ppc_builtin_type_vec64", TYPE_CODE_UNION);
df4df182 2268 append_composite_type_field (t, "uint64", bt->builtin_int64);
794ac428 2269 append_composite_type_field (t, "v2_float",
df4df182 2270 init_vector_type (bt->builtin_float, 2));
794ac428 2271 append_composite_type_field (t, "v2_int32",
df4df182 2272 init_vector_type (bt->builtin_int32, 2));
794ac428 2273 append_composite_type_field (t, "v4_int16",
df4df182 2274 init_vector_type (bt->builtin_int16, 4));
794ac428 2275 append_composite_type_field (t, "v8_int8",
df4df182 2276 init_vector_type (bt->builtin_int8, 8));
794ac428 2277
876cecd0 2278 TYPE_VECTOR (t) = 1;
794ac428
UW		 2279 TYPE_NAME (t) = "ppc_builtin_type_vec64";
2280 tdep->ppc_builtin_type_vec64 = t;
2281 }
2282
2283 return tdep->ppc_builtin_type_vec64;
2284}
2285
604c2f83
LM		 2286/* Vector 128 type. */
2287
2288static struct type *
2289rs6000_builtin_type_vec128 (struct gdbarch *gdbarch)
2290{
2291 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2292
2293 if (!tdep->ppc_builtin_type_vec128)
2294 {
df4df182
UW		 2295 const struct builtin_type *bt = builtin_type (gdbarch);
2296
604c2f83
LM		 2297 /* The type we're building is this
2298
2299 type = union __ppc_builtin_type_vec128 {
2300 uint128_t uint128;
2301 float v4_float[4];
2302 int32_t v4_int32[4];
2303 int16_t v8_int16[8];
2304 int8_t v16_int8[16];
2305 }
2306 */
2307
2308 struct type *t;
2309
2310 t = init_composite_type ("__ppc_builtin_type_vec128", TYPE_CODE_UNION);
df4df182 2311 append_composite_type_field (t, "uint128", bt->builtin_uint128);
604c2f83 2312 append_composite_type_field (t, "v4_float",
df4df182 2313 init_vector_type (bt->builtin_float, 4));
604c2f83 2314 append_composite_type_field (t, "v4_int32",
df4df182 2315 init_vector_type (bt->builtin_int32, 4));
604c2f83 2316 append_composite_type_field (t, "v8_int16",
df4df182 2317 init_vector_type (bt->builtin_int16, 8));
604c2f83 2318 append_composite_type_field (t, "v16_int8",
df4df182 2319 init_vector_type (bt->builtin_int8, 16));
604c2f83 2320
803e1097 2321 TYPE_VECTOR (t) = 1;
604c2f83
LM		 2322 TYPE_NAME (t) = "ppc_builtin_type_vec128";
2323 tdep->ppc_builtin_type_vec128 = t;
2324 }
2325
2326 return tdep->ppc_builtin_type_vec128;
2327}
2328
7cc46491
DJ		 2329/* Return the name of register number REGNO, or the empty string if it
2330 is an anonymous register. */
7a78ae4e 2331
fa88f677 2332static const char *
d93859e2 2333rs6000_register_name (struct gdbarch *gdbarch, int regno)
7a78ae4e 2334{
d93859e2 2335 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
7a78ae4e 2336
7cc46491
DJ		 2337 /* The upper half "registers" have names in the XML description,
2338 but we present only the low GPRs and the full 64-bit registers
2339 to the user. */
2340 if (tdep->ppc_ev0_upper_regnum >= 0
2341 && tdep->ppc_ev0_upper_regnum <= regno
2342 && regno < tdep->ppc_ev0_upper_regnum + ppc_num_gprs)
2343 return "";
2344
604c2f83
LM		 2345 /* Hide the upper halves of the vs0~vs31 registers. */
2346 if (tdep->ppc_vsr0_regnum >= 0
2347 && tdep->ppc_vsr0_upper_regnum <= regno
2348 && regno < tdep->ppc_vsr0_upper_regnum + ppc_num_gprs)
2349 return "";
2350
7cc46491 2351 /* Check if the SPE pseudo registers are available. */
5a9e69ba 2352 if (IS_SPE_PSEUDOREG (tdep, regno))
7cc46491
DJ		 2353 {
2354 static const char *const spe_regnames[] = {
2355 "ev0", "ev1", "ev2", "ev3", "ev4", "ev5", "ev6", "ev7",
2356 "ev8", "ev9", "ev10", "ev11", "ev12", "ev13", "ev14", "ev15",
2357 "ev16", "ev17", "ev18", "ev19", "ev20", "ev21", "ev22", "ev23",
2358 "ev24", "ev25", "ev26", "ev27", "ev28", "ev29", "ev30", "ev31",
2359 };
2360 return spe_regnames[regno - tdep->ppc_ev0_regnum];
2361 }
2362
f949c649
TJB		 2363 /* Check if the decimal128 pseudo-registers are available. */
2364 if (IS_DFP_PSEUDOREG (tdep, regno))
2365 {
2366 static const char *const dfp128_regnames[] = {
2367 "dl0", "dl1", "dl2", "dl3",
2368 "dl4", "dl5", "dl6", "dl7",
2369 "dl8", "dl9", "dl10", "dl11",
2370 "dl12", "dl13", "dl14", "dl15"
2371 };
2372 return dfp128_regnames[regno - tdep->ppc_dl0_regnum];
2373 }
2374
604c2f83
LM		 2375 /* Check if this is a VSX pseudo-register. */
2376 if (IS_VSX_PSEUDOREG (tdep, regno))
2377 {
2378 static const char *const vsx_regnames[] = {
2379 "vs0", "vs1", "vs2", "vs3", "vs4", "vs5", "vs6", "vs7",
2380 "vs8", "vs9", "vs10", "vs11", "vs12", "vs13", "vs14",
2381 "vs15", "vs16", "vs17", "vs18", "vs19", "vs20", "vs21",
2382 "vs22", "vs23", "vs24", "vs25", "vs26", "vs27", "vs28",
2383 "vs29", "vs30", "vs31", "vs32", "vs33", "vs34", "vs35",
2384 "vs36", "vs37", "vs38", "vs39", "vs40", "vs41", "vs42",
2385 "vs43", "vs44", "vs45", "vs46", "vs47", "vs48", "vs49",
2386 "vs50", "vs51", "vs52", "vs53", "vs54", "vs55", "vs56",
2387 "vs57", "vs58", "vs59", "vs60", "vs61", "vs62", "vs63"
2388 };
2389 return vsx_regnames[regno - tdep->ppc_vsr0_regnum];
2390 }
2391
2392 /* Check if the this is a Extended FP pseudo-register. */
2393 if (IS_EFP_PSEUDOREG (tdep, regno))
2394 {
2395 static const char *const efpr_regnames[] = {
2396 "f32", "f33", "f34", "f35", "f36", "f37", "f38",
2397 "f39", "f40", "f41", "f42", "f43", "f44", "f45",
2398 "f46", "f47", "f48", "f49", "f50", "f51",
2399 "f52", "f53", "f54", "f55", "f56", "f57",
2400 "f58", "f59", "f60", "f61", "f62", "f63"
2401 };
2402 return efpr_regnames[regno - tdep->ppc_efpr0_regnum];
2403 }
2404
d93859e2 2405 return tdesc_register_name (gdbarch, regno);
7a78ae4e
ND		 2406}
2407
7cc46491
DJ		 2408/* Return the GDB type object for the "standard" data type of data in
2409 register N. */
7a78ae4e
ND		 2410
2411static struct type *
7cc46491 2412rs6000_pseudo_register_type (struct gdbarch *gdbarch, int regnum)
7a78ae4e 2413{
691d145a 2414 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
7a78ae4e 2415
7cc46491 2416 /* These are the only pseudo-registers we support. */
f949c649 2417 gdb_assert (IS_SPE_PSEUDOREG (tdep, regnum)
604c2f83
LM		 2418 || IS_DFP_PSEUDOREG (tdep, regnum)
2419 || IS_VSX_PSEUDOREG (tdep, regnum)
2420 || IS_EFP_PSEUDOREG (tdep, regnum));
7cc46491 2421
f949c649
TJB		 2422 /* These are the e500 pseudo-registers. */
2423 if (IS_SPE_PSEUDOREG (tdep, regnum))
2424 return rs6000_builtin_type_vec64 (gdbarch);
604c2f83
LM		 2425 else if (IS_DFP_PSEUDOREG (tdep, regnum))
2426 /* PPC decimal128 pseudo-registers. */
f949c649 2427 return builtin_type (gdbarch)->builtin_declong;
604c2f83
LM		 2428 else if (IS_VSX_PSEUDOREG (tdep, regnum))
2429 /* POWER7 VSX pseudo-registers. */
2430 return rs6000_builtin_type_vec128 (gdbarch);
2431 else
2432 /* POWER7 Extended FP pseudo-registers. */
2433 return builtin_type (gdbarch)->builtin_double;
7a78ae4e
ND		 2434}
2435
c44ca51c
AC		 2436/* Is REGNUM a member of REGGROUP? */
2437static int
7cc46491
DJ		 2438rs6000_pseudo_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
2439 struct reggroup *group)
c44ca51c
AC		 2440{
2441 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
c44ca51c 2442
7cc46491 2443 /* These are the only pseudo-registers we support. */
f949c649 2444 gdb_assert (IS_SPE_PSEUDOREG (tdep, regnum)
604c2f83
LM		 2445 || IS_DFP_PSEUDOREG (tdep, regnum)
2446 || IS_VSX_PSEUDOREG (tdep, regnum)
2447 || IS_EFP_PSEUDOREG (tdep, regnum));
c44ca51c 2448
604c2f83
LM		 2449 /* These are the e500 pseudo-registers or the POWER7 VSX registers. */
2450 if (IS_SPE_PSEUDOREG (tdep, regnum) || IS_VSX_PSEUDOREG (tdep, regnum))
f949c649 2451 return group == all_reggroup || group == vector_reggroup;
7cc46491 2452 else
604c2f83 2453 /* PPC decimal128 or Extended FP pseudo-registers. */
f949c649 2454 return group == all_reggroup || group == float_reggroup;
c44ca51c
AC		 2455}
2456
691d145a 2457/* The register format for RS/6000 floating point registers is always
64366f1c 2458 double, we need a conversion if the memory format is float. */
7a78ae4e
ND		 2459
2460static int
0abe36f5
MD		 2461rs6000_convert_register_p (struct gdbarch *gdbarch, int regnum,
2462 struct type *type)
7a78ae4e 2463{
0abe36f5 2464 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
7cc46491
DJ		 2465
2466 return (tdep->ppc_fp0_regnum >= 0
2467 && regnum >= tdep->ppc_fp0_regnum
2468 && regnum < tdep->ppc_fp0_regnum + ppc_num_fprs
2469 && TYPE_CODE (type) == TYPE_CODE_FLT
0dfff4cb
UW		 2470 && TYPE_LENGTH (type)
2471 != TYPE_LENGTH (builtin_type (gdbarch)->builtin_double));
7a78ae4e
ND		 2472}
2473
7a78ae4e 2474static void
691d145a
JB		 2475rs6000_register_to_value (struct frame_info *frame,
2476 int regnum,
2477 struct type *type,
50fd1280 2478 gdb_byte *to)
7a78ae4e 2479{
0dfff4cb 2480 struct gdbarch *gdbarch = get_frame_arch (frame);
50fd1280 2481 gdb_byte from[MAX_REGISTER_SIZE];
691d145a 2482
691d145a 2483 gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLT);
7a78ae4e 2484
691d145a 2485 get_frame_register (frame, regnum, from);
0dfff4cb
UW		 2486 convert_typed_floating (from, builtin_type (gdbarch)->builtin_double,
2487 to, type);
691d145a 2488}
7a292a7a 2489
7a78ae4e 2490static void
691d145a
JB		 2491rs6000_value_to_register (struct frame_info *frame,
2492 int regnum,
2493 struct type *type,
50fd1280 2494 const gdb_byte *from)
7a78ae4e 2495{
0dfff4cb 2496 struct gdbarch *gdbarch = get_frame_arch (frame);
50fd1280 2497 gdb_byte to[MAX_REGISTER_SIZE];
691d145a 2498
691d145a
JB		 2499 gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLT);
2500
0dfff4cb
UW		 2501 convert_typed_floating (from, type,
2502 to, builtin_type (gdbarch)->builtin_double);
691d145a 2503 put_frame_register (frame, regnum, to);
7a78ae4e 2504}
c906108c 2505
6ced10dd
JB		 2506/* Move SPE vector register values between a 64-bit buffer and the two
2507 32-bit raw register halves in a regcache. This function handles
2508 both splitting a 64-bit value into two 32-bit halves, and joining
2509 two halves into a whole 64-bit value, depending on the function
2510 passed as the MOVE argument.
2511
2512 EV_REG must be the number of an SPE evN vector register --- a
2513 pseudoregister. REGCACHE must be a regcache, and BUFFER must be a
2514 64-bit buffer.
2515
2516 Call MOVE once for each 32-bit half of that register, passing
2517 REGCACHE, the number of the raw register corresponding to that
2518 half, and the address of the appropriate half of BUFFER.
2519
2520 For example, passing 'regcache_raw_read' as the MOVE function will
2521 fill BUFFER with the full 64-bit contents of EV_REG. Or, passing
2522 'regcache_raw_supply' will supply the contents of BUFFER to the
2523 appropriate pair of raw registers in REGCACHE.
2524
2525 You may need to cast away some 'const' qualifiers when passing
2526 MOVE, since this function can't tell at compile-time which of
2527 REGCACHE or BUFFER is acting as the source of the data. If C had
2528 co-variant type qualifiers, ... */
2529static void
2530e500_move_ev_register (void (*move) (struct regcache *regcache,
50fd1280 2531 int regnum, gdb_byte *buf),
6ced10dd 2532 struct regcache *regcache, int ev_reg,
50fd1280 2533 gdb_byte *buffer)
6ced10dd
JB		 2534{
2535 struct gdbarch *arch = get_regcache_arch (regcache);
2536 struct gdbarch_tdep *tdep = gdbarch_tdep (arch);
2537 int reg_index;
50fd1280 2538 gdb_byte *byte_buffer = buffer;
6ced10dd 2539
5a9e69ba 2540 gdb_assert (IS_SPE_PSEUDOREG (tdep, ev_reg));
6ced10dd
JB		 2541
2542 reg_index = ev_reg - tdep->ppc_ev0_regnum;
2543
8b164abb 2544 if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG)
6ced10dd
JB		 2545 {
2546 move (regcache, tdep->ppc_ev0_upper_regnum + reg_index, byte_buffer);
2547 move (regcache, tdep->ppc_gp0_regnum + reg_index, byte_buffer + 4);
2548 }
2549 else
2550 {
2551 move (regcache, tdep->ppc_gp0_regnum + reg_index, byte_buffer);
2552 move (regcache, tdep->ppc_ev0_upper_regnum + reg_index, byte_buffer + 4);
2553 }
2554}
2555
c8001721
EZ		 2556static void
2557e500_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
50fd1280 2558 int reg_nr, gdb_byte *buffer)
f949c649
TJB		 2559{
2560 e500_move_ev_register (regcache_raw_read, regcache, reg_nr, buffer);
2561}
2562
2563static void
2564e500_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
2565 int reg_nr, const gdb_byte *buffer)
2566{
2567 e500_move_ev_register ((void (*) (struct regcache *, int, gdb_byte *))
2568 regcache_raw_write,
2569 regcache, reg_nr, (gdb_byte *) buffer);
2570}
2571
604c2f83 2572/* Read method for DFP pseudo-registers. */
f949c649 2573static void
604c2f83 2574dfp_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
f949c649
TJB		 2575 int reg_nr, gdb_byte *buffer)
2576{
2577 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2578 int reg_index = reg_nr - tdep->ppc_dl0_regnum;
2579
2580 if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
2581 {
2582 /* Read two FP registers to form a whole dl register. */
2583 regcache_raw_read (regcache, tdep->ppc_fp0_regnum +
2584 2 * reg_index, buffer);
2585 regcache_raw_read (regcache, tdep->ppc_fp0_regnum +
2586 2 * reg_index + 1, buffer + 8);
2587 }
2588 else
2589 {
2590 regcache_raw_read (regcache, tdep->ppc_fp0_regnum +
2591 2 * reg_index + 1, buffer + 8);
2592 regcache_raw_read (regcache, tdep->ppc_fp0_regnum +
2593 2 * reg_index, buffer);
2594 }
2595}
2596
604c2f83 2597/* Write method for DFP pseudo-registers. */
f949c649 2598static void
604c2f83 2599dfp_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
f949c649
TJB		 2600 int reg_nr, const gdb_byte *buffer)
2601{
2602 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2603 int reg_index = reg_nr - tdep->ppc_dl0_regnum;
2604
2605 if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
2606 {
2607 /* Write each half of the dl register into a separate
2608 FP register. */
2609 regcache_raw_write (regcache, tdep->ppc_fp0_regnum +
2610 2 * reg_index, buffer);
2611 regcache_raw_write (regcache, tdep->ppc_fp0_regnum +
2612 2 * reg_index + 1, buffer + 8);
2613 }
2614 else
2615 {
2616 regcache_raw_write (regcache, tdep->ppc_fp0_regnum +
2617 2 * reg_index + 1, buffer + 8);
2618 regcache_raw_write (regcache, tdep->ppc_fp0_regnum +
2619 2 * reg_index, buffer);
2620 }
2621}
2622
604c2f83
LM		 2623/* Read method for POWER7 VSX pseudo-registers. */
2624static void
2625vsx_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
2626 int reg_nr, gdb_byte *buffer)
2627{
2628 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2629 int reg_index = reg_nr - tdep->ppc_vsr0_regnum;
2630
2631 /* Read the portion that overlaps the VMX registers. */
2632 if (reg_index > 31)
2633 regcache_raw_read (regcache, tdep->ppc_vr0_regnum +
2634 reg_index - 32, buffer);
2635 else
2636 /* Read the portion that overlaps the FPR registers. */
2637 if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
2638 {
2639 regcache_raw_read (regcache, tdep->ppc_fp0_regnum +
2640 reg_index, buffer);
2641 regcache_raw_read (regcache, tdep->ppc_vsr0_upper_regnum +
2642 reg_index, buffer + 8);
2643 }
2644 else
2645 {
2646 regcache_raw_read (regcache, tdep->ppc_fp0_regnum +
2647 reg_index, buffer + 8);
2648 regcache_raw_read (regcache, tdep->ppc_vsr0_upper_regnum +
2649 reg_index, buffer);
2650 }
2651}
2652
2653/* Write method for POWER7 VSX pseudo-registers. */
2654static void
2655vsx_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
2656 int reg_nr, const gdb_byte *buffer)
2657{
2658 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2659 int reg_index = reg_nr - tdep->ppc_vsr0_regnum;
2660
2661 /* Write the portion that overlaps the VMX registers. */
2662 if (reg_index > 31)
2663 regcache_raw_write (regcache, tdep->ppc_vr0_regnum +
2664 reg_index - 32, buffer);
2665 else
2666 /* Write the portion that overlaps the FPR registers. */
2667 if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
2668 {
2669 regcache_raw_write (regcache, tdep->ppc_fp0_regnum +
2670 reg_index, buffer);
2671 regcache_raw_write (regcache, tdep->ppc_vsr0_upper_regnum +
2672 reg_index, buffer + 8);
2673 }
2674 else
2675 {
2676 regcache_raw_write (regcache, tdep->ppc_fp0_regnum +
2677 reg_index, buffer + 8);
2678 regcache_raw_write (regcache, tdep->ppc_vsr0_upper_regnum +
2679 reg_index, buffer);
2680 }
2681}
2682
2683/* Read method for POWER7 Extended FP pseudo-registers. */
2684static void
2685efpr_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
2686 int reg_nr, gdb_byte *buffer)
2687{
2688 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2689 int reg_index = reg_nr - tdep->ppc_efpr0_regnum;
2690
2691 /* Read the portion that overlaps the VMX registers. */
2692 regcache_raw_read (regcache, tdep->ppc_vr0_regnum +
2693 reg_index, buffer);
2694}
2695
2696/* Write method for POWER7 Extended FP pseudo-registers. */
2697static void
2698efpr_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
2699 int reg_nr, const gdb_byte *buffer)
2700{
2701 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2702 int reg_index = reg_nr - tdep->ppc_efpr0_regnum;
2703
2704 /* Write the portion that overlaps the VMX registers. */
2705 regcache_raw_write (regcache, tdep->ppc_vr0_regnum +
2706 reg_index, buffer);
2707}
2708
f949c649
TJB		 2709static void
2710rs6000_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
2711 int reg_nr, gdb_byte *buffer)
c8001721 2712{
6ced10dd 2713 struct gdbarch *regcache_arch = get_regcache_arch (regcache);
c8001721
EZ		 2714 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2715
6ced10dd 2716 gdb_assert (regcache_arch == gdbarch);
f949c649 2717
5a9e69ba 2718 if (IS_SPE_PSEUDOREG (tdep, reg_nr))
f949c649
TJB		 2719 e500_pseudo_register_read (gdbarch, regcache, reg_nr, buffer);
2720 else if (IS_DFP_PSEUDOREG (tdep, reg_nr))
604c2f83
LM		 2721 dfp_pseudo_register_read (gdbarch, regcache, reg_nr, buffer);
2722 else if (IS_VSX_PSEUDOREG (tdep, reg_nr))
2723 vsx_pseudo_register_read (gdbarch, regcache, reg_nr, buffer);
2724 else if (IS_EFP_PSEUDOREG (tdep, reg_nr))
2725 efpr_pseudo_register_read (gdbarch, regcache, reg_nr, buffer);
6ced10dd 2726 else
a44bddec 2727 internal_error (__FILE__, __LINE__,
f949c649
TJB		 2728 _("rs6000_pseudo_register_read: "
2729 "called on unexpected register '%s' (%d)"),
2730 gdbarch_register_name (gdbarch, reg_nr), reg_nr);
c8001721
EZ		 2731}
2732
2733static void
f949c649
TJB		 2734rs6000_pseudo_register_write (struct gdbarch *gdbarch,
2735 struct regcache *regcache,
2736 int reg_nr, const gdb_byte *buffer)
c8001721 2737{
6ced10dd 2738 struct gdbarch *regcache_arch = get_regcache_arch (regcache);
c8001721
EZ		 2739 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2740
6ced10dd 2741 gdb_assert (regcache_arch == gdbarch);
f949c649 2742
5a9e69ba 2743 if (IS_SPE_PSEUDOREG (tdep, reg_nr))
f949c649
TJB		 2744 e500_pseudo_register_write (gdbarch, regcache, reg_nr, buffer);
2745 else if (IS_DFP_PSEUDOREG (tdep, reg_nr))
604c2f83
LM		 2746 dfp_pseudo_register_write (gdbarch, regcache, reg_nr, buffer);
2747 else if (IS_VSX_PSEUDOREG (tdep, reg_nr))
2748 vsx_pseudo_register_write (gdbarch, regcache, reg_nr, buffer);
2749 else if (IS_EFP_PSEUDOREG (tdep, reg_nr))
2750 efpr_pseudo_register_write (gdbarch, regcache, reg_nr, buffer);
6ced10dd 2751 else
a44bddec 2752 internal_error (__FILE__, __LINE__,
f949c649
TJB		 2753 _("rs6000_pseudo_register_write: "
2754 "called on unexpected register '%s' (%d)"),
2755 gdbarch_register_name (gdbarch, reg_nr), reg_nr);
6ced10dd
JB		 2756}
2757
18ed0c4e 2758/* Convert a DBX STABS register number to a GDB register number. */
c8001721 2759static int
d3f73121 2760rs6000_stab_reg_to_regnum (struct gdbarch *gdbarch, int num)
c8001721 2761{
d3f73121 2762 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
c8001721 2763
9f744501
JB		 2764 if (0 <= num && num <= 31)
2765 return tdep->ppc_gp0_regnum + num;
2766 else if (32 <= num && num <= 63)
383f0f5b
JB		 2767 /* FIXME: jimb/2004-05-05: What should we do when the debug info
2768 specifies registers the architecture doesn't have? Our
2769 callers don't check the value we return. */
366f009f 2770 return tdep->ppc_fp0_regnum + (num - 32);
18ed0c4e
JB		 2771 else if (77 <= num && num <= 108)
2772 return tdep->ppc_vr0_regnum + (num - 77);
9f744501
JB		 2773 else if (1200 <= num && num < 1200 + 32)
2774 return tdep->ppc_ev0_regnum + (num - 1200);
2775 else
2776 switch (num)
2777 {
2778 case 64:
2779 return tdep->ppc_mq_regnum;
2780 case 65:
2781 return tdep->ppc_lr_regnum;
2782 case 66:
2783 return tdep->ppc_ctr_regnum;
2784 case 76:
2785 return tdep->ppc_xer_regnum;
2786 case 109:
2787 return tdep->ppc_vrsave_regnum;
18ed0c4e
JB		 2788 case 110:
2789 return tdep->ppc_vrsave_regnum - 1; /* vscr */
867e2dc5 2790 case 111:
18ed0c4e 2791 return tdep->ppc_acc_regnum;
867e2dc5 2792 case 112:
18ed0c4e 2793 return tdep->ppc_spefscr_regnum;
9f744501
JB		 2794 default:
2795 return num;
2796 }
18ed0c4e 2797}
9f744501 2798
9f744501 2799
18ed0c4e
JB		 2800/* Convert a Dwarf 2 register number to a GDB register number. */
2801static int
d3f73121 2802rs6000_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, int num)
18ed0c4e 2803{
d3f73121 2804 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
9f744501 2805
18ed0c4e
JB		 2806 if (0 <= num && num <= 31)
2807 return tdep->ppc_gp0_regnum + num;
2808 else if (32 <= num && num <= 63)
2809 /* FIXME: jimb/2004-05-05: What should we do when the debug info
2810 specifies registers the architecture doesn't have? Our
2811 callers don't check the value we return. */
2812 return tdep->ppc_fp0_regnum + (num - 32);
2813 else if (1124 <= num && num < 1124 + 32)
2814 return tdep->ppc_vr0_regnum + (num - 1124);
2815 else if (1200 <= num && num < 1200 + 32)
2816 return tdep->ppc_ev0_regnum + (num - 1200);
2817 else
2818 switch (num)
2819 {
a489f789
AS		 2820 case 64:
2821 return tdep->ppc_cr_regnum;
18ed0c4e
JB		 2822 case 67:
2823 return tdep->ppc_vrsave_regnum - 1; /* vscr */
2824 case 99:
2825 return tdep->ppc_acc_regnum;
2826 case 100:
2827 return tdep->ppc_mq_regnum;
2828 case 101:
2829 return tdep->ppc_xer_regnum;
2830 case 108:
2831 return tdep->ppc_lr_regnum;
2832 case 109:
2833 return tdep->ppc_ctr_regnum;
2834 case 356:
2835 return tdep->ppc_vrsave_regnum;
2836 case 612:
2837 return tdep->ppc_spefscr_regnum;
2838 default:
2839 return num;
2840 }
2188cbdd
EZ		 2841}
2842
4fc771b8
DJ		 2843/* Translate a .eh_frame register to DWARF register, or adjust a
2844 .debug_frame register. */
2845
2846static int
2847rs6000_adjust_frame_regnum (struct gdbarch *gdbarch, int num, int eh_frame_p)
2848{
2849 /* GCC releases before 3.4 use GCC internal register numbering in
2850 .debug_frame (and .debug_info, et cetera). The numbering is
2851 different from the standard SysV numbering for everything except
2852 for GPRs and FPRs. We can not detect this problem in most cases
2853 - to get accurate debug info for variables living in lr, ctr, v0,
2854 et cetera, use a newer version of GCC. But we must detect
2855 one important case - lr is in column 65 in .debug_frame output,
2856 instead of 108.
2857
2858 GCC 3.4, and the "hammer" branch, have a related problem. They
2859 record lr register saves in .debug_frame as 108, but still record
2860 the return column as 65. We fix that up too.
2861
2862 We can do this because 65 is assigned to fpsr, and GCC never
2863 generates debug info referring to it. To add support for
2864 handwritten debug info that restores fpsr, we would need to add a
2865 producer version check to this. */
2866 if (!eh_frame_p)
2867 {
2868 if (num == 65)
2869 return 108;
2870 else
2871 return num;
2872 }
2873
2874 /* .eh_frame is GCC specific. For binary compatibility, it uses GCC
2875 internal register numbering; translate that to the standard DWARF2
2876 register numbering. */
2877 if (0 <= num && num <= 63) /* r0-r31,fp0-fp31 */
2878 return num;
2879 else if (68 <= num && num <= 75) /* cr0-cr8 */
2880 return num - 68 + 86;
2881 else if (77 <= num && num <= 108) /* vr0-vr31 */
2882 return num - 77 + 1124;
2883 else
2884 switch (num)
2885 {
2886 case 64: /* mq */
2887 return 100;
2888 case 65: /* lr */
2889 return 108;
2890 case 66: /* ctr */
2891 return 109;
2892 case 76: /* xer */
2893 return 101;
2894 case 109: /* vrsave */
2895 return 356;
2896 case 110: /* vscr */
2897 return 67;
2898 case 111: /* spe_acc */
2899 return 99;
2900 case 112: /* spefscr */
2901 return 612;
2902 default:
2903 return num;
2904 }
2905}
c906108c 2906\f
c5aa993b 2907
7a78ae4e 2908/* Handling the various POWER/PowerPC variants. */
c906108c 2909
c906108c 2910/* Information about a particular processor variant. */
7a78ae4e 2911
c906108c 2912struct variant
c5aa993b
JM		 2913 {
2914 /* Name of this variant. */
2915 char *name;
c906108c 2916
c5aa993b
JM		 2917 /* English description of the variant. */
2918 char *description;
c906108c 2919
64366f1c 2920 /* bfd_arch_info.arch corresponding to variant. */
7a78ae4e
ND		 2921 enum bfd_architecture arch;
2922
64366f1c 2923 /* bfd_arch_info.mach corresponding to variant. */
7a78ae4e
ND		 2924 unsigned long mach;
2925
7cc46491
DJ		 2926 /* Target description for this variant. */
2927 struct target_desc **tdesc;
c5aa993b 2928 };
c906108c 2929
489461e2 2930static struct variant variants[] =
c906108c 2931{
7a78ae4e 2932 {"powerpc", "PowerPC user-level", bfd_arch_powerpc,
7284e1be 2933 bfd_mach_ppc, &tdesc_powerpc_altivec32},
7a78ae4e 2934 {"power", "POWER user-level", bfd_arch_rs6000,
7cc46491 2935 bfd_mach_rs6k, &tdesc_rs6000},
7a78ae4e 2936 {"403", "IBM PowerPC 403", bfd_arch_powerpc,
7cc46491 2937 bfd_mach_ppc_403, &tdesc_powerpc_403},
7a78ae4e 2938 {"601", "Motorola PowerPC 601", bfd_arch_powerpc,
7cc46491 2939 bfd_mach_ppc_601, &tdesc_powerpc_601},
7a78ae4e 2940 {"602", "Motorola PowerPC 602", bfd_arch_powerpc,
7cc46491 2941 bfd_mach_ppc_602, &tdesc_powerpc_602},
7a78ae4e 2942 {"603", "Motorola/IBM PowerPC 603 or 603e", bfd_arch_powerpc,
7cc46491 2943 bfd_mach_ppc_603, &tdesc_powerpc_603},
7a78ae4e 2944 {"604", "Motorola PowerPC 604 or 604e", bfd_arch_powerpc,
7cc46491 2945 604, &tdesc_powerpc_604},
7a78ae4e 2946 {"403GC", "IBM PowerPC 403GC", bfd_arch_powerpc,
7cc46491 2947 bfd_mach_ppc_403gc, &tdesc_powerpc_403gc},
7a78ae4e 2948 {"505", "Motorola PowerPC 505", bfd_arch_powerpc,
7cc46491 2949 bfd_mach_ppc_505, &tdesc_powerpc_505},
7a78ae4e 2950 {"860", "Motorola PowerPC 860 or 850", bfd_arch_powerpc,
7cc46491 2951 bfd_mach_ppc_860, &tdesc_powerpc_860},
7a78ae4e 2952 {"750", "Motorola/IBM PowerPC 750 or 740", bfd_arch_powerpc,
7cc46491 2953 bfd_mach_ppc_750, &tdesc_powerpc_750},
1fcc0bb8 2954 {"7400", "Motorola/IBM PowerPC 7400 (G4)", bfd_arch_powerpc,
7cc46491 2955 bfd_mach_ppc_7400, &tdesc_powerpc_7400},
c8001721 2956 {"e500", "Motorola PowerPC e500", bfd_arch_powerpc,
7cc46491 2957 bfd_mach_ppc_e500, &tdesc_powerpc_e500},
7a78ae4e 2958
5d57ee30
KB		 2959 /* 64-bit */
2960 {"powerpc64", "PowerPC 64-bit user-level", bfd_arch_powerpc,
7284e1be 2961 bfd_mach_ppc64, &tdesc_powerpc_altivec64},
7a78ae4e 2962 {"620", "Motorola PowerPC 620", bfd_arch_powerpc,
7cc46491 2963 bfd_mach_ppc_620, &tdesc_powerpc_64},
5d57ee30 2964 {"630", "Motorola PowerPC 630", bfd_arch_powerpc,
7cc46491 2965 bfd_mach_ppc_630, &tdesc_powerpc_64},
7a78ae4e 2966 {"a35", "PowerPC A35", bfd_arch_powerpc,
7cc46491 2967 bfd_mach_ppc_a35, &tdesc_powerpc_64},
5d57ee30 2968 {"rs64ii", "PowerPC rs64ii", bfd_arch_powerpc,
7cc46491 2969 bfd_mach_ppc_rs64ii, &tdesc_powerpc_64},
5d57ee30 2970 {"rs64iii", "PowerPC rs64iii", bfd_arch_powerpc,
7cc46491 2971 bfd_mach_ppc_rs64iii, &tdesc_powerpc_64},
5d57ee30 2972
64366f1c 2973 /* FIXME: I haven't checked the register sets of the following. */
7a78ae4e 2974 {"rs1", "IBM POWER RS1", bfd_arch_rs6000,
7cc46491 2975 bfd_mach_rs6k_rs1, &tdesc_rs6000},
7a78ae4e 2976 {"rsc", "IBM POWER RSC", bfd_arch_rs6000,
7cc46491 2977 bfd_mach_rs6k_rsc, &tdesc_rs6000},
7a78ae4e 2978 {"rs2", "IBM POWER RS2", bfd_arch_rs6000,
7cc46491 2979 bfd_mach_rs6k_rs2, &tdesc_rs6000},
7a78ae4e 2980
7cc46491 2981 {0, 0, 0, 0, 0}
c906108c
SS		 2982};
2983
7a78ae4e 2984/* Return the variant corresponding to architecture ARCH and machine number
64366f1c 2985 MACH. If no such variant exists, return null. */
c906108c 2986
7a78ae4e
ND		 2987static const struct variant *
2988find_variant_by_arch (enum bfd_architecture arch, unsigned long mach)
c906108c 2989{
7a78ae4e 2990 const struct variant *v;
c5aa993b 2991
7a78ae4e
ND		 2992 for (v = variants; v->name; v++)
2993 if (arch == v->arch && mach == v->mach)
2994 return v;
c906108c 2995
7a78ae4e 2996 return NULL;
c906108c 2997}
9364a0ef
EZ		 2998
2999static int
3000gdb_print_insn_powerpc (bfd_vma memaddr, disassemble_info *info)
3001{
ee4f0f76
DJ		 3002 if (!info->disassembler_options)
3003 info->disassembler_options = "any";
3004
40887e1a 3005 if (info->endian == BFD_ENDIAN_BIG)
9364a0ef
EZ		 3006 return print_insn_big_powerpc (memaddr, info);
3007 else
3008 return print_insn_little_powerpc (memaddr, info);
3009}
7a78ae4e 3010\f
61a65099
KB		 3011static CORE_ADDR
3012rs6000_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
3013{
3e8c568d 3014 return frame_unwind_register_unsigned (next_frame,
8b164abb 3015 gdbarch_pc_regnum (gdbarch));
61a65099
KB		 3016}
3017
3018static struct frame_id
1af5d7ce 3019rs6000_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
61a65099 3020{
1af5d7ce
UW		 3021 return frame_id_build (get_frame_register_unsigned
3022 (this_frame, gdbarch_sp_regnum (gdbarch)),
3023 get_frame_pc (this_frame));
61a65099
KB		 3024}
3025
3026struct rs6000_frame_cache
3027{
3028 CORE_ADDR base;
3029 CORE_ADDR initial_sp;
3030 struct trad_frame_saved_reg *saved_regs;
3031};
3032
3033static struct rs6000_frame_cache *
1af5d7ce 3034rs6000_frame_cache (struct frame_info *this_frame, void **this_cache)
61a65099
KB		 3035{
3036 struct rs6000_frame_cache *cache;
1af5d7ce 3037 struct gdbarch *gdbarch = get_frame_arch (this_frame);
61a65099
KB		 3038 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3039 struct rs6000_framedata fdata;
3040 int wordsize = tdep->wordsize;
e10b1c4c 3041 CORE_ADDR func, pc;
61a65099
KB		 3042
3043 if ((*this_cache) != NULL)
3044 return (*this_cache);
3045 cache = FRAME_OBSTACK_ZALLOC (struct rs6000_frame_cache);
3046 (*this_cache) = cache;
1af5d7ce 3047 cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
61a65099 3048
1af5d7ce
UW		 3049 func = get_frame_func (this_frame);
3050 pc = get_frame_pc (this_frame);
be8626e0 3051 skip_prologue (gdbarch, func, pc, &fdata);
e10b1c4c
DJ		 3052
3053 /* Figure out the parent's stack pointer. */
3054
3055 /* NOTE: cagney/2002-04-14: The ->frame points to the inner-most
3056 address of the current frame. Things might be easier if the
3057 ->frame pointed to the outer-most address of the frame. In
3058 the mean time, the address of the prev frame is used as the
3059 base address of this frame. */
1af5d7ce
UW		 3060 cache->base = get_frame_register_unsigned
3061 (this_frame, gdbarch_sp_regnum (gdbarch));
e10b1c4c
DJ		 3062
3063 /* If the function appears to be frameless, check a couple of likely
3064 indicators that we have simply failed to find the frame setup.
3065 Two common cases of this are missing symbols (i.e.
ef02daa9 3066 get_frame_func returns the wrong address or 0), and assembly
e10b1c4c
DJ		 3067 stubs which have a fast exit path but set up a frame on the slow
3068 path.
3069
3070 If the LR appears to return to this function, then presume that
3071 we have an ABI compliant frame that we failed to find. */
3072 if (fdata.frameless && fdata.lr_offset == 0)
61a65099 3073 {
e10b1c4c
DJ		 3074 CORE_ADDR saved_lr;
3075 int make_frame = 0;
3076
1af5d7ce 3077 saved_lr = get_frame_register_unsigned (this_frame, tdep->ppc_lr_regnum);
e10b1c4c
DJ		 3078 if (func == 0 && saved_lr == pc)
3079 make_frame = 1;
3080 else if (func != 0)
3081 {
3082 CORE_ADDR saved_func = get_pc_function_start (saved_lr);
3083 if (func == saved_func)
3084 make_frame = 1;
3085 }
3086
3087 if (make_frame)
3088 {
3089 fdata.frameless = 0;
de6a76fd 3090 fdata.lr_offset = tdep->lr_frame_offset;
e10b1c4c 3091 }
61a65099 3092 }
e10b1c4c
DJ		 3093
3094 if (!fdata.frameless)
3095 /* Frameless really means stackless. */
4a7622d1 3096 cache->base = read_memory_unsigned_integer (cache->base, wordsize);
e10b1c4c 3097
3e8c568d 3098 trad_frame_set_value (cache->saved_regs,
8b164abb 3099 gdbarch_sp_regnum (gdbarch), cache->base);
61a65099
KB		 3100
3101 /* if != -1, fdata.saved_fpr is the smallest number of saved_fpr.
3102 All fpr's from saved_fpr to fp31 are saved. */
3103
3104 if (fdata.saved_fpr >= 0)
3105 {
3106 int i;
3107 CORE_ADDR fpr_addr = cache->base + fdata.fpr_offset;
383f0f5b
JB		 3108
3109 /* If skip_prologue says floating-point registers were saved,
3110 but the current architecture has no floating-point registers,
3111 then that's strange. But we have no indices to even record
3112 the addresses under, so we just ignore it. */
3113 if (ppc_floating_point_unit_p (gdbarch))
063715bf 3114 for (i = fdata.saved_fpr; i < ppc_num_fprs; i++)
383f0f5b
JB		 3115 {
3116 cache->saved_regs[tdep->ppc_fp0_regnum + i].addr = fpr_addr;
3117 fpr_addr += 8;
3118 }
61a65099
KB		 3119 }
3120
3121 /* if != -1, fdata.saved_gpr is the smallest number of saved_gpr.
46a9b8ed
DJ		 3122 All gpr's from saved_gpr to gpr31 are saved (except during the
3123 prologue). */
61a65099
KB		 3124
3125 if (fdata.saved_gpr >= 0)
3126 {
3127 int i;
3128 CORE_ADDR gpr_addr = cache->base + fdata.gpr_offset;
063715bf 3129 for (i = fdata.saved_gpr; i < ppc_num_gprs; i++)
61a65099 3130 {
46a9b8ed
DJ		 3131 if (fdata.gpr_mask & (1U << i))
3132 cache->saved_regs[tdep->ppc_gp0_regnum + i].addr = gpr_addr;
61a65099
KB		 3133 gpr_addr += wordsize;
3134 }
3135 }
3136
3137 /* if != -1, fdata.saved_vr is the smallest number of saved_vr.
3138 All vr's from saved_vr to vr31 are saved. */
3139 if (tdep->ppc_vr0_regnum != -1 && tdep->ppc_vrsave_regnum != -1)
3140 {
3141 if (fdata.saved_vr >= 0)
3142 {
3143 int i;
3144 CORE_ADDR vr_addr = cache->base + fdata.vr_offset;
3145 for (i = fdata.saved_vr; i < 32; i++)
3146 {
3147 cache->saved_regs[tdep->ppc_vr0_regnum + i].addr = vr_addr;
3148 vr_addr += register_size (gdbarch, tdep->ppc_vr0_regnum);
3149 }
3150 }
3151 }
3152
3153 /* if != -1, fdata.saved_ev is the smallest number of saved_ev.
3154 All vr's from saved_ev to ev31 are saved. ????? */
5a9e69ba 3155 if (tdep->ppc_ev0_regnum != -1)
61a65099
KB		 3156 {
3157 if (fdata.saved_ev >= 0)
3158 {
3159 int i;
3160 CORE_ADDR ev_addr = cache->base + fdata.ev_offset;
063715bf 3161 for (i = fdata.saved_ev; i < ppc_num_gprs; i++)
61a65099
KB		 3162 {
3163 cache->saved_regs[tdep->ppc_ev0_regnum + i].addr = ev_addr;
3164 cache->saved_regs[tdep->ppc_gp0_regnum + i].addr = ev_addr + 4;
3165 ev_addr += register_size (gdbarch, tdep->ppc_ev0_regnum);
3166 }
3167 }
3168 }
3169
3170 /* If != 0, fdata.cr_offset is the offset from the frame that
3171 holds the CR. */
3172 if (fdata.cr_offset != 0)
3173 cache->saved_regs[tdep->ppc_cr_regnum].addr = cache->base + fdata.cr_offset;
3174
3175 /* If != 0, fdata.lr_offset is the offset from the frame that
3176 holds the LR. */
3177 if (fdata.lr_offset != 0)
3178 cache->saved_regs[tdep->ppc_lr_regnum].addr = cache->base + fdata.lr_offset;
46a9b8ed
DJ		 3179 else if (fdata.lr_register != -1)
3180 cache->saved_regs[tdep->ppc_lr_regnum].realreg = fdata.lr_register;
61a65099 3181 /* The PC is found in the link register. */
8b164abb 3182 cache->saved_regs[gdbarch_pc_regnum (gdbarch)] =
3e8c568d 3183 cache->saved_regs[tdep->ppc_lr_regnum];
61a65099
KB		 3184
3185 /* If != 0, fdata.vrsave_offset is the offset from the frame that
3186 holds the VRSAVE. */
3187 if (fdata.vrsave_offset != 0)
3188 cache->saved_regs[tdep->ppc_vrsave_regnum].addr = cache->base + fdata.vrsave_offset;
3189
3190 if (fdata.alloca_reg < 0)
3191 /* If no alloca register used, then fi->frame is the value of the
3192 %sp for this frame, and it is good enough. */
1af5d7ce
UW		 3193 cache->initial_sp
3194 = get_frame_register_unsigned (this_frame, gdbarch_sp_regnum (gdbarch));
61a65099 3195 else
1af5d7ce
UW		 3196 cache->initial_sp
3197 = get_frame_register_unsigned (this_frame, fdata.alloca_reg);
61a65099
KB		 3198
3199 return cache;
3200}
3201
3202static void
1af5d7ce 3203rs6000_frame_this_id (struct frame_info *this_frame, void **this_cache,
61a65099
KB		 3204 struct frame_id *this_id)
3205{
1af5d7ce 3206 struct rs6000_frame_cache *info = rs6000_frame_cache (this_frame,
61a65099 3207 this_cache);
5b197912
UW		 3208 /* This marks the outermost frame. */
3209 if (info->base == 0)
3210 return;
3211
1af5d7ce 3212 (*this_id) = frame_id_build (info->base, get_frame_func (this_frame));
61a65099
KB		 3213}
3214
1af5d7ce
UW		 3215static struct value *
3216rs6000_frame_prev_register (struct frame_info *this_frame,
3217 void **this_cache, int regnum)
61a65099 3218{
1af5d7ce 3219 struct rs6000_frame_cache *info = rs6000_frame_cache (this_frame,
61a65099 3220 this_cache);
1af5d7ce 3221 return trad_frame_get_prev_register (this_frame, info->saved_regs, regnum);
61a65099
KB		 3222}
3223
3224static const struct frame_unwind rs6000_frame_unwind =
3225{
3226 NORMAL_FRAME,
3227 rs6000_frame_this_id,
1af5d7ce
UW		 3228 rs6000_frame_prev_register,
3229 NULL,
3230 default_frame_sniffer
61a65099 3231};
61a65099
KB		 3232\f
3233
3234static CORE_ADDR
1af5d7ce 3235rs6000_frame_base_address (struct frame_info *this_frame, void **this_cache)
61a65099 3236{
1af5d7ce 3237 struct rs6000_frame_cache *info = rs6000_frame_cache (this_frame,
61a65099
KB		 3238 this_cache);
3239 return info->initial_sp;
3240}
3241
3242static const struct frame_base rs6000_frame_base = {
3243 &rs6000_frame_unwind,
3244 rs6000_frame_base_address,
3245 rs6000_frame_base_address,
3246 rs6000_frame_base_address
3247};
3248
3249static const struct frame_base *
1af5d7ce 3250rs6000_frame_base_sniffer (struct frame_info *this_frame)
61a65099
KB		 3251{
3252 return &rs6000_frame_base;
3253}
3254
9274a07c
LM		 3255/* DWARF-2 frame support. Used to handle the detection of
3256 clobbered registers during function calls. */
3257
3258static void
3259ppc_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
3260 struct dwarf2_frame_state_reg *reg,
4a4e5149 3261 struct frame_info *this_frame)
9274a07c
LM		 3262{
3263 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3264
3265 /* PPC32 and PPC64 ABI's are the same regarding volatile and
3266 non-volatile registers. We will use the same code for both. */
3267
3268 /* Call-saved GP registers. */
3269 if ((regnum >= tdep->ppc_gp0_regnum + 14
3270 && regnum <= tdep->ppc_gp0_regnum + 31)
3271 || (regnum == tdep->ppc_gp0_regnum + 1))
3272 reg->how = DWARF2_FRAME_REG_SAME_VALUE;
3273
3274 /* Call-clobbered GP registers. */
3275 if ((regnum >= tdep->ppc_gp0_regnum + 3
3276 && regnum <= tdep->ppc_gp0_regnum + 12)
3277 || (regnum == tdep->ppc_gp0_regnum))
3278 reg->how = DWARF2_FRAME_REG_UNDEFINED;
3279
3280 /* Deal with FP registers, if supported. */
3281 if (tdep->ppc_fp0_regnum >= 0)
3282 {
3283 /* Call-saved FP registers. */
3284 if ((regnum >= tdep->ppc_fp0_regnum + 14
3285 && regnum <= tdep->ppc_fp0_regnum + 31))
3286 reg->how = DWARF2_FRAME_REG_SAME_VALUE;
3287
3288 /* Call-clobbered FP registers. */
3289 if ((regnum >= tdep->ppc_fp0_regnum
3290 && regnum <= tdep->ppc_fp0_regnum + 13))
3291 reg->how = DWARF2_FRAME_REG_UNDEFINED;
3292 }
3293
3294 /* Deal with ALTIVEC registers, if supported. */
3295 if (tdep->ppc_vr0_regnum > 0 && tdep->ppc_vrsave_regnum > 0)
3296 {
3297 /* Call-saved Altivec registers. */
3298 if ((regnum >= tdep->ppc_vr0_regnum + 20
3299 && regnum <= tdep->ppc_vr0_regnum + 31)
3300 || regnum == tdep->ppc_vrsave_regnum)
3301 reg->how = DWARF2_FRAME_REG_SAME_VALUE;
3302
3303 /* Call-clobbered Altivec registers. */
3304 if ((regnum >= tdep->ppc_vr0_regnum
3305 && regnum <= tdep->ppc_vr0_regnum + 19))
3306 reg->how = DWARF2_FRAME_REG_UNDEFINED;
3307 }
3308
3309 /* Handle PC register and Stack Pointer correctly. */
40a6adc1 3310 if (regnum == gdbarch_pc_regnum (gdbarch))
9274a07c 3311 reg->how = DWARF2_FRAME_REG_RA;
40a6adc1 3312 else if (regnum == gdbarch_sp_regnum (gdbarch))
9274a07c
LM		 3313 reg->how = DWARF2_FRAME_REG_CFA;
3314}
3315
3316
7a78ae4e
ND		 3317/* Initialize the current architecture based on INFO. If possible, re-use an
3318 architecture from ARCHES, which is a list of architectures already created
3319 during this debugging session.
c906108c 3320
7a78ae4e 3321 Called e.g. at program startup, when reading a core file, and when reading
64366f1c 3322 a binary file. */
c906108c 3323
7a78ae4e
ND		 3324static struct gdbarch *
3325rs6000_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
3326{
3327 struct gdbarch *gdbarch;
3328 struct gdbarch_tdep *tdep;
7cc46491 3329 int wordsize, from_xcoff_exec, from_elf_exec;
7a78ae4e
ND		 3330 enum bfd_architecture arch;
3331 unsigned long mach;
3332 bfd abfd;
5bf1c677 3333 asection *sect;
55eddb0f
DJ		 3334 enum auto_boolean soft_float_flag = powerpc_soft_float_global;
3335 int soft_float;
3336 enum powerpc_vector_abi vector_abi = powerpc_vector_abi_global;
604c2f83
LM		 3337 int have_fpu = 1, have_spe = 0, have_mq = 0, have_altivec = 0, have_dfp = 0,
3338 have_vsx = 0;
7cc46491
DJ		 3339 int tdesc_wordsize = -1;
3340 const struct target_desc *tdesc = info.target_desc;
3341 struct tdesc_arch_data *tdesc_data = NULL;
f949c649 3342 int num_pseudoregs = 0;
604c2f83 3343 int cur_reg;
7a78ae4e 3344
9aa1e687 3345 from_xcoff_exec = info.abfd && info.abfd->format == bfd_object &&
7a78ae4e
ND		 3346 bfd_get_flavour (info.abfd) == bfd_target_xcoff_flavour;
3347
9aa1e687
KB		 3348 from_elf_exec = info.abfd && info.abfd->format == bfd_object &&
3349 bfd_get_flavour (info.abfd) == bfd_target_elf_flavour;
3350
e712c1cf 3351 /* Check word size. If INFO is from a binary file, infer it from
64366f1c 3352 that, else choose a likely default. */
9aa1e687 3353 if (from_xcoff_exec)
c906108c 3354 {
11ed25ac 3355 if (bfd_xcoff_is_xcoff64 (info.abfd))
7a78ae4e
ND		 3356 wordsize = 8;
3357 else
3358 wordsize = 4;
c906108c 3359 }
9aa1e687
KB		 3360 else if (from_elf_exec)
3361 {
3362 if (elf_elfheader (info.abfd)->e_ident[EI_CLASS] == ELFCLASS64)
3363 wordsize = 8;
3364 else
3365 wordsize = 4;
3366 }
7cc46491
DJ		 3367 else if (tdesc_has_registers (tdesc))
3368 wordsize = -1;
c906108c 3369 else
7a78ae4e 3370 {
27b15785
KB		 3371 if (info.bfd_arch_info != NULL && info.bfd_arch_info->bits_per_word != 0)
3372 wordsize = info.bfd_arch_info->bits_per_word /
3373 info.bfd_arch_info->bits_per_byte;
3374 else
3375 wordsize = 4;
7a78ae4e 3376 }
c906108c 3377
475bbd17
JB		 3378 /* Get the architecture and machine from the BFD. */
3379 arch = info.bfd_arch_info->arch;
3380 mach = info.bfd_arch_info->mach;
5bf1c677
EZ		 3381
3382 /* For e500 executables, the apuinfo section is of help here. Such
3383 section contains the identifier and revision number of each
3384 Application-specific Processing Unit that is present on the
3385 chip. The content of the section is determined by the assembler
3386 which looks at each instruction and determines which unit (and
3387 which version of it) can execute it. In our case we just look for
3388 the existance of the section. */
3389
3390 if (info.abfd)
3391 {
3392 sect = bfd_get_section_by_name (info.abfd, ".PPC.EMB.apuinfo");
3393 if (sect)
3394 {
3395 arch = info.bfd_arch_info->arch;
3396 mach = bfd_mach_ppc_e500;
3397 bfd_default_set_arch_mach (&abfd, arch, mach);
3398 info.bfd_arch_info = bfd_get_arch_info (&abfd);
3399 }
3400 }
3401
7cc46491
DJ		 3402 /* Find a default target description which describes our register
3403 layout, if we do not already have one. */
3404 if (! tdesc_has_registers (tdesc))
3405 {
3406 const struct variant *v;
3407
3408 /* Choose variant. */
3409 v = find_variant_by_arch (arch, mach);
3410 if (!v)
3411 return NULL;
3412
3413 tdesc = *v->tdesc;
3414 }
3415
3416 gdb_assert (tdesc_has_registers (tdesc));
3417
3418 /* Check any target description for validity. */
3419 if (tdesc_has_registers (tdesc))
3420 {
3421 static const char *const gprs[] = {
3422 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
3423 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
3424 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
3425 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
3426 };
3427 static const char *const segment_regs[] = {
3428 "sr0", "sr1", "sr2", "sr3", "sr4", "sr5", "sr6", "sr7",
3429 "sr8", "sr9", "sr10", "sr11", "sr12", "sr13", "sr14", "sr15"
3430 };
3431 const struct tdesc_feature *feature;
3432 int i, valid_p;
3433 static const char *const msr_names[] = { "msr", "ps" };
3434 static const char *const cr_names[] = { "cr", "cnd" };
3435 static const char *const ctr_names[] = { "ctr", "cnt" };
3436
3437 feature = tdesc_find_feature (tdesc,
3438 "org.gnu.gdb.power.core");
3439 if (feature == NULL)
3440 return NULL;
3441
3442 tdesc_data = tdesc_data_alloc ();
3443
3444 valid_p = 1;
3445 for (i = 0; i < ppc_num_gprs; i++)
3446 valid_p &= tdesc_numbered_register (feature, tdesc_data, i, gprs[i]);
3447 valid_p &= tdesc_numbered_register (feature, tdesc_data, PPC_PC_REGNUM,
3448 "pc");
3449 valid_p &= tdesc_numbered_register (feature, tdesc_data, PPC_LR_REGNUM,
3450 "lr");
3451 valid_p &= tdesc_numbered_register (feature, tdesc_data, PPC_XER_REGNUM,
3452 "xer");
3453
3454 /* Allow alternate names for these registers, to accomodate GDB's
3455 historic naming. */
3456 valid_p &= tdesc_numbered_register_choices (feature, tdesc_data,
3457 PPC_MSR_REGNUM, msr_names);
3458 valid_p &= tdesc_numbered_register_choices (feature, tdesc_data,
3459 PPC_CR_REGNUM, cr_names);
3460 valid_p &= tdesc_numbered_register_choices (feature, tdesc_data,
3461 PPC_CTR_REGNUM, ctr_names);
3462
3463 if (!valid_p)
3464 {
3465 tdesc_data_cleanup (tdesc_data);
3466 return NULL;
3467 }
3468
3469 have_mq = tdesc_numbered_register (feature, tdesc_data, PPC_MQ_REGNUM,
3470 "mq");
3471
3472 tdesc_wordsize = tdesc_register_size (feature, "pc") / 8;
3473 if (wordsize == -1)
3474 wordsize = tdesc_wordsize;
3475
3476 feature = tdesc_find_feature (tdesc,
3477 "org.gnu.gdb.power.fpu");
3478 if (feature != NULL)
3479 {
3480 static const char *const fprs[] = {
3481 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
3482 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
3483 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
3484 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31"
3485 };
3486 valid_p = 1;
3487 for (i = 0; i < ppc_num_fprs; i++)
3488 valid_p &= tdesc_numbered_register (feature, tdesc_data,
3489 PPC_F0_REGNUM + i, fprs[i]);
3490 valid_p &= tdesc_numbered_register (feature, tdesc_data,
3491 PPC_FPSCR_REGNUM, "fpscr");
3492
3493 if (!valid_p)
3494 {
3495 tdesc_data_cleanup (tdesc_data);
3496 return NULL;
3497 }
3498 have_fpu = 1;
3499 }
3500 else
3501 have_fpu = 0;
3502
f949c649
TJB		 3503 /* The DFP pseudo-registers will be available when there are floating
3504 point registers. */
3505 have_dfp = have_fpu;
3506
7cc46491
DJ		 3507 feature = tdesc_find_feature (tdesc,
3508 "org.gnu.gdb.power.altivec");
3509 if (feature != NULL)
3510 {
3511 static const char *const vector_regs[] = {
3512 "vr0", "vr1", "vr2", "vr3", "vr4", "vr5", "vr6", "vr7",
3513 "vr8", "vr9", "vr10", "vr11", "vr12", "vr13", "vr14", "vr15",
3514 "vr16", "vr17", "vr18", "vr19", "vr20", "vr21", "vr22", "vr23",
3515 "vr24", "vr25", "vr26", "vr27", "vr28", "vr29", "vr30", "vr31"
3516 };
3517
3518 valid_p = 1;
3519 for (i = 0; i < ppc_num_gprs; i++)
3520 valid_p &= tdesc_numbered_register (feature, tdesc_data,
3521 PPC_VR0_REGNUM + i,
3522 vector_regs[i]);
3523 valid_p &= tdesc_numbered_register (feature, tdesc_data,
3524 PPC_VSCR_REGNUM, "vscr");
3525 valid_p &= tdesc_numbered_register (feature, tdesc_data,
3526 PPC_VRSAVE_REGNUM, "vrsave");
3527
3528 if (have_spe || !valid_p)
3529 {
3530 tdesc_data_cleanup (tdesc_data);
3531 return NULL;
3532 }
3533 have_altivec = 1;
3534 }
3535 else
3536 have_altivec = 0;
3537
604c2f83
LM		 3538 /* Check for POWER7 VSX registers support. */
3539 feature = tdesc_find_feature (tdesc,
3540 "org.gnu.gdb.power.vsx");
3541
3542 if (feature != NULL)
3543 {
3544 static const char *const vsx_regs[] = {
3545 "vs0h", "vs1h", "vs2h", "vs3h", "vs4h", "vs5h",
3546 "vs6h", "vs7h", "vs8h", "vs9h", "vs10h", "vs11h",
3547 "vs12h", "vs13h", "vs14h", "vs15h", "vs16h", "vs17h",
3548 "vs18h", "vs19h", "vs20h", "vs21h", "vs22h", "vs23h",
3549 "vs24h", "vs25h", "vs26h", "vs27h", "vs28h", "vs29h",
3550 "vs30h", "vs31h"
3551 };
3552
3553 valid_p = 1;
3554
3555 for (i = 0; i < ppc_num_vshrs; i++)
3556 valid_p &= tdesc_numbered_register (feature, tdesc_data,
3557 PPC_VSR0_UPPER_REGNUM + i,
3558 vsx_regs[i]);
3559 if (!valid_p)
3560 {
3561 tdesc_data_cleanup (tdesc_data);
3562 return NULL;
3563 }
3564
3565 have_vsx = 1;
3566 }
3567 else
3568 have_vsx = 0;
3569
7cc46491
DJ		 3570 /* On machines supporting the SPE APU, the general-purpose registers
3571 are 64 bits long. There are SIMD vector instructions to treat them
3572 as pairs of floats, but the rest of the instruction set treats them
3573 as 32-bit registers, and only operates on their lower halves.
3574
3575 In the GDB regcache, we treat their high and low halves as separate
3576 registers. The low halves we present as the general-purpose
3577 registers, and then we have pseudo-registers that stitch together
3578 the upper and lower halves and present them as pseudo-registers.
3579
3580 Thus, the target description is expected to supply the upper
3581 halves separately. */
3582
3583 feature = tdesc_find_feature (tdesc,
3584 "org.gnu.gdb.power.spe");
3585 if (feature != NULL)
3586 {
3587 static const char *const upper_spe[] = {
3588 "ev0h", "ev1h", "ev2h", "ev3h",
3589 "ev4h", "ev5h", "ev6h", "ev7h",
3590 "ev8h", "ev9h", "ev10h", "ev11h",
3591 "ev12h", "ev13h", "ev14h", "ev15h",
3592 "ev16h", "ev17h", "ev18h", "ev19h",
3593 "ev20h", "ev21h", "ev22h", "ev23h",
3594 "ev24h", "ev25h", "ev26h", "ev27h",
3595 "ev28h", "ev29h", "ev30h", "ev31h"
3596 };
3597
3598 valid_p = 1;
3599 for (i = 0; i < ppc_num_gprs; i++)
3600 valid_p &= tdesc_numbered_register (feature, tdesc_data,
3601 PPC_SPE_UPPER_GP0_REGNUM + i,
3602 upper_spe[i]);
3603 valid_p &= tdesc_numbered_register (feature, tdesc_data,
3604 PPC_SPE_ACC_REGNUM, "acc");
3605 valid_p &= tdesc_numbered_register (feature, tdesc_data,
3606 PPC_SPE_FSCR_REGNUM, "spefscr");
3607
3608 if (have_mq || have_fpu || !valid_p)
3609 {
3610 tdesc_data_cleanup (tdesc_data);
3611 return NULL;
3612 }
3613 have_spe = 1;
3614 }
3615 else
3616 have_spe = 0;
3617 }
3618
3619 /* If we have a 64-bit binary on a 32-bit target, complain. Also
3620 complain for a 32-bit binary on a 64-bit target; we do not yet
3621 support that. For instance, the 32-bit ABI routines expect
3622 32-bit GPRs.
3623
3624 As long as there isn't an explicit target description, we'll
3625 choose one based on the BFD architecture and get a word size
3626 matching the binary (probably powerpc:common or
3627 powerpc:common64). So there is only trouble if a 64-bit target
3628 supplies a 64-bit description while debugging a 32-bit
3629 binary. */
3630 if (tdesc_wordsize != -1 && tdesc_wordsize != wordsize)
3631 {
3632 tdesc_data_cleanup (tdesc_data);
3633 return NULL;
3634 }
3635
55eddb0f
DJ		 3636#ifdef HAVE_ELF
3637 if (soft_float_flag == AUTO_BOOLEAN_AUTO && from_elf_exec)
3638 {
3639 switch (bfd_elf_get_obj_attr_int (info.abfd, OBJ_ATTR_GNU,
3640 Tag_GNU_Power_ABI_FP))
3641 {
3642 case 1:
3643 soft_float_flag = AUTO_BOOLEAN_FALSE;
3644 break;
3645 case 2:
3646 soft_float_flag = AUTO_BOOLEAN_TRUE;
3647 break;
3648 default:
3649 break;
3650 }
3651 }
3652
3653 if (vector_abi == POWERPC_VEC_AUTO && from_elf_exec)
3654 {
3655 switch (bfd_elf_get_obj_attr_int (info.abfd, OBJ_ATTR_GNU,
3656 Tag_GNU_Power_ABI_Vector))
3657 {
3658 case 1:
3659 vector_abi = POWERPC_VEC_GENERIC;
3660 break;
3661 case 2:
3662 vector_abi = POWERPC_VEC_ALTIVEC;
3663 break;
3664 case 3:
3665 vector_abi = POWERPC_VEC_SPE;
3666 break;
3667 default:
3668 break;
3669 }
3670 }
3671#endif
3672
3673 if (soft_float_flag == AUTO_BOOLEAN_TRUE)
3674 soft_float = 1;
3675 else if (soft_float_flag == AUTO_BOOLEAN_FALSE)
3676 soft_float = 0;
3677 else
3678 soft_float = !have_fpu;
3679
3680 /* If we have a hard float binary or setting but no floating point
3681 registers, downgrade to soft float anyway. We're still somewhat
3682 useful in this scenario. */
3683 if (!soft_float && !have_fpu)
3684 soft_float = 1;
3685
3686 /* Similarly for vector registers. */
3687 if (vector_abi == POWERPC_VEC_ALTIVEC && !have_altivec)
3688 vector_abi = POWERPC_VEC_GENERIC;
3689
3690 if (vector_abi == POWERPC_VEC_SPE && !have_spe)
3691 vector_abi = POWERPC_VEC_GENERIC;
3692
3693 if (vector_abi == POWERPC_VEC_AUTO)
3694 {
3695 if (have_altivec)
3696 vector_abi = POWERPC_VEC_ALTIVEC;
3697 else if (have_spe)
3698 vector_abi = POWERPC_VEC_SPE;
3699 else
3700 vector_abi = POWERPC_VEC_GENERIC;
3701 }
3702
3703 /* Do not limit the vector ABI based on available hardware, since we
3704 do not yet know what hardware we'll decide we have. Yuck! FIXME! */
3705
7cc46491
DJ		 3706 /* Find a candidate among extant architectures. */
3707 for (arches = gdbarch_list_lookup_by_info (arches, &info);
3708 arches != NULL;
3709 arches = gdbarch_list_lookup_by_info (arches->next, &info))
3710 {
3711 /* Word size in the various PowerPC bfd_arch_info structs isn't
3712 meaningful, because 64-bit CPUs can run in 32-bit mode. So, perform
3713 separate word size check. */
3714 tdep = gdbarch_tdep (arches->gdbarch);
55eddb0f
DJ		 3715 if (tdep && tdep->soft_float != soft_float)
3716 continue;
3717 if (tdep && tdep->vector_abi != vector_abi)
3718 continue;
7cc46491
DJ		 3719 if (tdep && tdep->wordsize == wordsize)
3720 {
3721 if (tdesc_data != NULL)
3722 tdesc_data_cleanup (tdesc_data);
3723 return arches->gdbarch;
3724 }
3725 }
3726
3727 /* None found, create a new architecture from INFO, whose bfd_arch_info
3728 validity depends on the source:
3729 - executable useless
3730 - rs6000_host_arch() good
3731 - core file good
3732 - "set arch" trust blindly
3733 - GDB startup useless but harmless */
3734
3735 tdep = XCALLOC (1, struct gdbarch_tdep);
3736 tdep->wordsize = wordsize;
55eddb0f
DJ		 3737 tdep->soft_float = soft_float;
3738 tdep->vector_abi = vector_abi;
7cc46491 3739
7a78ae4e 3740 gdbarch = gdbarch_alloc (&info, tdep);
7a78ae4e 3741
7cc46491
DJ		 3742 tdep->ppc_gp0_regnum = PPC_R0_REGNUM;
3743 tdep->ppc_toc_regnum = PPC_R0_REGNUM + 2;
3744 tdep->ppc_ps_regnum = PPC_MSR_REGNUM;
3745 tdep->ppc_cr_regnum = PPC_CR_REGNUM;
3746 tdep->ppc_lr_regnum = PPC_LR_REGNUM;
3747 tdep->ppc_ctr_regnum = PPC_CTR_REGNUM;
3748 tdep->ppc_xer_regnum = PPC_XER_REGNUM;
3749 tdep->ppc_mq_regnum = have_mq ? PPC_MQ_REGNUM : -1;
3750
3751 tdep->ppc_fp0_regnum = have_fpu ? PPC_F0_REGNUM : -1;
3752 tdep->ppc_fpscr_regnum = have_fpu ? PPC_FPSCR_REGNUM : -1;
604c2f83 3753 tdep->ppc_vsr0_upper_regnum = have_vsx ? PPC_VSR0_UPPER_REGNUM : -1;
7cc46491
DJ		 3754 tdep->ppc_vr0_regnum = have_altivec ? PPC_VR0_REGNUM : -1;
3755 tdep->ppc_vrsave_regnum = have_altivec ? PPC_VRSAVE_REGNUM : -1;
3756 tdep->ppc_ev0_upper_regnum = have_spe ? PPC_SPE_UPPER_GP0_REGNUM : -1;
3757 tdep->ppc_acc_regnum = have_spe ? PPC_SPE_ACC_REGNUM : -1;
3758 tdep->ppc_spefscr_regnum = have_spe ? PPC_SPE_FSCR_REGNUM : -1;
3759
3760 set_gdbarch_pc_regnum (gdbarch, PPC_PC_REGNUM);
3761 set_gdbarch_sp_regnum (gdbarch, PPC_R0_REGNUM + 1);
3762 set_gdbarch_deprecated_fp_regnum (gdbarch, PPC_R0_REGNUM + 1);
3763 set_gdbarch_fp0_regnum (gdbarch, tdep->ppc_fp0_regnum);
9f643768 3764 set_gdbarch_register_sim_regno (gdbarch, rs6000_register_sim_regno);
7cc46491
DJ		 3765
3766 /* The XML specification for PowerPC sensibly calls the MSR "msr".
3767 GDB traditionally called it "ps", though, so let GDB add an
3768 alias. */
3769 set_gdbarch_ps_regnum (gdbarch, tdep->ppc_ps_regnum);
3770
4a7622d1 3771 if (wordsize == 8)
05580c65 3772 set_gdbarch_return_value (gdbarch, ppc64_sysv_abi_return_value);
afd48b75 3773 else
4a7622d1 3774 set_gdbarch_return_value (gdbarch, ppc_sysv_abi_return_value);
c8001721 3775
baffbae0
JB		 3776 /* Set lr_frame_offset. */
3777 if (wordsize == 8)
3778 tdep->lr_frame_offset = 16;
baffbae0 3779 else
4a7622d1 3780 tdep->lr_frame_offset = 4;
baffbae0 3781
604c2f83 3782 if (have_spe || have_dfp || have_vsx)
7cc46491 3783 {
f949c649
TJB		 3784 set_gdbarch_pseudo_register_read (gdbarch, rs6000_pseudo_register_read);
3785 set_gdbarch_pseudo_register_write (gdbarch, rs6000_pseudo_register_write);
7cc46491 3786 }
1fcc0bb8 3787
e0d24f8d
WZ		 3788 set_gdbarch_have_nonsteppable_watchpoint (gdbarch, 1);
3789
56a6dfb9 3790 /* Select instruction printer. */
708ff411 3791 if (arch == bfd_arch_rs6000)
9364a0ef 3792 set_gdbarch_print_insn (gdbarch, print_insn_rs6000);
56a6dfb9 3793 else
9364a0ef 3794 set_gdbarch_print_insn (gdbarch, gdb_print_insn_powerpc);
7495d1dc 3795
5a9e69ba 3796 set_gdbarch_num_regs (gdbarch, PPC_NUM_REGS);
f949c649
TJB		 3797
3798 if (have_spe)
3799 num_pseudoregs += 32;
3800 if (have_dfp)
3801 num_pseudoregs += 16;
604c2f83
LM		 3802 if (have_vsx)
3803 /* Include both VSX and Extended FP registers. */
3804 num_pseudoregs += 96;
f949c649
TJB		 3805
3806 set_gdbarch_num_pseudo_regs (gdbarch, num_pseudoregs);
7a78ae4e
ND		 3807
3808 set_gdbarch_ptr_bit (gdbarch, wordsize * TARGET_CHAR_BIT);
3809 set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
3810 set_gdbarch_int_bit (gdbarch, 4 * TARGET_CHAR_BIT);
3811 set_gdbarch_long_bit (gdbarch, wordsize * TARGET_CHAR_BIT);
3812 set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
3813 set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
3814 set_gdbarch_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
4a7622d1 3815 set_gdbarch_long_double_bit (gdbarch, 16 * TARGET_CHAR_BIT);
4e409299 3816 set_gdbarch_char_signed (gdbarch, 0);
7a78ae4e 3817
11269d7e 3818 set_gdbarch_frame_align (gdbarch, rs6000_frame_align);
4a7622d1 3819 if (wordsize == 8)
8b148df9
AC		 3820 /* PPC64 SYSV. */
3821 set_gdbarch_frame_red_zone_size (gdbarch, 288);
7a78ae4e 3822
691d145a
JB		 3823 set_gdbarch_convert_register_p (gdbarch, rs6000_convert_register_p);
3824 set_gdbarch_register_to_value (gdbarch, rs6000_register_to_value);
3825 set_gdbarch_value_to_register (gdbarch, rs6000_value_to_register);
3826
18ed0c4e
JB		 3827 set_gdbarch_stab_reg_to_regnum (gdbarch, rs6000_stab_reg_to_regnum);
3828 set_gdbarch_dwarf2_reg_to_regnum (gdbarch, rs6000_dwarf2_reg_to_regnum);
d217aaed 3829
4a7622d1 3830 if (wordsize == 4)
77b2b6d4 3831 set_gdbarch_push_dummy_call (gdbarch, ppc_sysv_abi_push_dummy_call);
4a7622d1 3832 else if (wordsize == 8)
8be9034a 3833 set_gdbarch_push_dummy_call (gdbarch, ppc64_sysv_abi_push_dummy_call);
7a78ae4e 3834
7a78ae4e 3835 set_gdbarch_skip_prologue (gdbarch, rs6000_skip_prologue);
0d1243d9 3836 set_gdbarch_in_function_epilogue_p (gdbarch, rs6000_in_function_epilogue_p);
8ab3d180 3837 set_gdbarch_skip_main_prologue (gdbarch, rs6000_skip_main_prologue);
0d1243d9 3838
7a78ae4e 3839 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
7a78ae4e
ND		 3840 set_gdbarch_breakpoint_from_pc (gdbarch, rs6000_breakpoint_from_pc);
3841
203c3895
UW		 3842 /* The value of symbols of type N_SO and N_FUN maybe null when
3843 it shouldn't be. */
3844 set_gdbarch_sofun_address_maybe_missing (gdbarch, 1);
3845
ce5eab59 3846 /* Handles single stepping of atomic sequences. */
4a7622d1 3847 set_gdbarch_software_single_step (gdbarch, ppc_deal_with_atomic_sequence);
ce5eab59 3848
7a78ae4e
ND		 3849 /* Not sure on this. FIXMEmgo */
3850 set_gdbarch_frame_args_skip (gdbarch, 8);
3851
143985b7
AF		 3852 /* Helpers for function argument information. */
3853 set_gdbarch_fetch_pointer_argument (gdbarch, rs6000_fetch_pointer_argument);
3854
6f7f3f0d
UW		 3855 /* Trampoline. */
3856 set_gdbarch_in_solib_return_trampoline
3857 (gdbarch, rs6000_in_solib_return_trampoline);
3858 set_gdbarch_skip_trampoline_code (gdbarch, rs6000_skip_trampoline_code);
3859
4fc771b8 3860 /* Hook in the DWARF CFI frame unwinder. */
1af5d7ce 3861 dwarf2_append_unwinders (gdbarch);
4fc771b8
DJ		 3862 dwarf2_frame_set_adjust_regnum (gdbarch, rs6000_adjust_frame_regnum);
3863
9274a07c
LM		 3864 /* Frame handling. */
3865 dwarf2_frame_set_init_reg (gdbarch, ppc_dwarf2_frame_init_reg);
3866
2454a024
UW		 3867 /* Setup displaced stepping. */
3868 set_gdbarch_displaced_step_copy_insn (gdbarch,
3869 simple_displaced_step_copy_insn);
3870 set_gdbarch_displaced_step_fixup (gdbarch, ppc_displaced_step_fixup);
3871 set_gdbarch_displaced_step_free_closure (gdbarch,
3872 simple_displaced_step_free_closure);
3873 set_gdbarch_displaced_step_location (gdbarch,
3874 displaced_step_at_entry_point);
3875
3876 set_gdbarch_max_insn_length (gdbarch, PPC_INSN_SIZE);
3877
7b112f9c 3878 /* Hook in ABI-specific overrides, if they have been registered. */
8a4c2d24
UW		 3879 info.target_desc = tdesc;
3880 info.tdep_info = (void *) tdesc_data;
4be87837 3881 gdbarch_init_osabi (info, gdbarch);
7b112f9c 3882
61a65099
KB		 3883 switch (info.osabi)
3884 {
f5aecab8 3885 case GDB_OSABI_LINUX:
61a65099
KB		 3886 case GDB_OSABI_NETBSD_AOUT:
3887 case GDB_OSABI_NETBSD_ELF:
3888 case GDB_OSABI_UNKNOWN:
61a65099 3889 set_gdbarch_unwind_pc (gdbarch, rs6000_unwind_pc);
1af5d7ce
UW		 3890 frame_unwind_append_unwinder (gdbarch, &rs6000_frame_unwind);
3891 set_gdbarch_dummy_id (gdbarch, rs6000_dummy_id);
61a65099
KB		 3892 frame_base_append_sniffer (gdbarch, rs6000_frame_base_sniffer);
3893 break;
3894 default:
61a65099 3895 set_gdbarch_believe_pcc_promotion (gdbarch, 1);
81332287
KB		 3896
3897 set_gdbarch_unwind_pc (gdbarch, rs6000_unwind_pc);
1af5d7ce
UW		 3898 frame_unwind_append_unwinder (gdbarch, &rs6000_frame_unwind);
3899 set_gdbarch_dummy_id (gdbarch, rs6000_dummy_id);
81332287 3900 frame_base_append_sniffer (gdbarch, rs6000_frame_base_sniffer);
61a65099
KB		 3901 }
3902
7cc46491
DJ		 3903 set_tdesc_pseudo_register_type (gdbarch, rs6000_pseudo_register_type);
3904 set_tdesc_pseudo_register_reggroup_p (gdbarch,
3905 rs6000_pseudo_register_reggroup_p);
3906 tdesc_use_registers (gdbarch, tdesc, tdesc_data);
3907
3908 /* Override the normal target description method to make the SPE upper
3909 halves anonymous. */
3910 set_gdbarch_register_name (gdbarch, rs6000_register_name);
3911
604c2f83
LM		 3912 /* Choose register numbers for all supported pseudo-registers. */
3913 tdep->ppc_ev0_regnum = -1;
3914 tdep->ppc_dl0_regnum = -1;
3915 tdep->ppc_vsr0_regnum = -1;
3916 tdep->ppc_efpr0_regnum = -1;
9f643768 3917
604c2f83
LM		 3918 cur_reg = gdbarch_num_regs (gdbarch);
3919
3920 if (have_spe)
3921 {
3922 tdep->ppc_ev0_regnum = cur_reg;
3923 cur_reg += 32;
3924 }
3925 if (have_dfp)
3926 {
3927 tdep->ppc_dl0_regnum = cur_reg;
3928 cur_reg += 16;
3929 }
3930 if (have_vsx)
3931 {
3932 tdep->ppc_vsr0_regnum = cur_reg;
3933 cur_reg += 64;
3934 tdep->ppc_efpr0_regnum = cur_reg;
3935 cur_reg += 32;
3936 }
f949c649 3937
604c2f83
LM		 3938 gdb_assert (gdbarch_num_regs (gdbarch)
3939 + gdbarch_num_pseudo_regs (gdbarch) == cur_reg);
f949c649 3940
7a78ae4e 3941 return gdbarch;
c906108c
SS		 3942}
3943
7b112f9c 3944static void
8b164abb 3945rs6000_dump_tdep (struct gdbarch *gdbarch, struct ui_file *file)
7b112f9c 3946{
8b164abb 3947 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
7b112f9c
JT		 3948
3949 if (tdep == NULL)
3950 return;
3951
4be87837 3952 /* FIXME: Dump gdbarch_tdep. */
7b112f9c
JT		 3953}
3954
55eddb0f
DJ		 3955/* PowerPC-specific commands. */
3956
3957static void
3958set_powerpc_command (char *args, int from_tty)
3959{
3960 printf_unfiltered (_("\
3961\"set powerpc\" must be followed by an appropriate subcommand.\n"));
3962 help_list (setpowerpccmdlist, "set powerpc ", all_commands, gdb_stdout);
3963}
3964
3965static void
3966show_powerpc_command (char *args, int from_tty)
3967{
3968 cmd_show_list (showpowerpccmdlist, from_tty, "");
3969}
3970
3971static void
3972powerpc_set_soft_float (char *args, int from_tty,
3973 struct cmd_list_element *c)
3974{
3975 struct gdbarch_info info;
3976
3977 /* Update the architecture. */
3978 gdbarch_info_init (&info);
3979 if (!gdbarch_update_p (info))
3980 internal_error (__FILE__, __LINE__, "could not update architecture");
3981}
3982
3983static void
3984powerpc_set_vector_abi (char *args, int from_tty,
3985 struct cmd_list_element *c)
3986{
3987 struct gdbarch_info info;
3988 enum powerpc_vector_abi vector_abi;
3989
3990 for (vector_abi = POWERPC_VEC_AUTO;
3991 vector_abi != POWERPC_VEC_LAST;
3992 vector_abi++)
3993 if (strcmp (powerpc_vector_abi_string,
3994 powerpc_vector_strings[vector_abi]) == 0)
3995 {
3996 powerpc_vector_abi_global = vector_abi;
3997 break;
3998 }
3999
4000 if (vector_abi == POWERPC_VEC_LAST)
4001 internal_error (__FILE__, __LINE__, _("Invalid vector ABI accepted: %s."),
4002 powerpc_vector_abi_string);
4003
4004 /* Update the architecture. */
4005 gdbarch_info_init (&info);
4006 if (!gdbarch_update_p (info))
4007 internal_error (__FILE__, __LINE__, "could not update architecture");
4008}
4009
c906108c
SS		 4010/* Initialization code. */
4011
a78f21af 4012extern initialize_file_ftype _initialize_rs6000_tdep; /* -Wmissing-prototypes */
b9362cc7 4013
c906108c 4014void
fba45db2 4015_initialize_rs6000_tdep (void)
c906108c 4016{
7b112f9c
JT		 4017 gdbarch_register (bfd_arch_rs6000, rs6000_gdbarch_init, rs6000_dump_tdep);
4018 gdbarch_register (bfd_arch_powerpc, rs6000_gdbarch_init, rs6000_dump_tdep);
7cc46491
DJ		 4019
4020 /* Initialize the standard target descriptions. */
4021 initialize_tdesc_powerpc_32 ();
7284e1be 4022 initialize_tdesc_powerpc_altivec32 ();
604c2f83 4023 initialize_tdesc_powerpc_vsx32 ();
7cc46491
DJ		 4024 initialize_tdesc_powerpc_403 ();
4025 initialize_tdesc_powerpc_403gc ();
4026 initialize_tdesc_powerpc_505 ();
4027 initialize_tdesc_powerpc_601 ();
4028 initialize_tdesc_powerpc_602 ();
4029 initialize_tdesc_powerpc_603 ();
4030 initialize_tdesc_powerpc_604 ();
4031 initialize_tdesc_powerpc_64 ();
7284e1be 4032 initialize_tdesc_powerpc_altivec64 ();
604c2f83 4033 initialize_tdesc_powerpc_vsx64 ();
7cc46491
DJ		 4034 initialize_tdesc_powerpc_7400 ();
4035 initialize_tdesc_powerpc_750 ();
4036 initialize_tdesc_powerpc_860 ();
4037 initialize_tdesc_powerpc_e500 ();
4038 initialize_tdesc_rs6000 ();
55eddb0f
DJ		 4039
4040 /* Add root prefix command for all "set powerpc"/"show powerpc"
4041 commands. */
4042 add_prefix_cmd ("powerpc", no_class, set_powerpc_command,
4043 _("Various PowerPC-specific commands."),
4044 &setpowerpccmdlist, "set powerpc ", 0, &setlist);
4045
4046 add_prefix_cmd ("powerpc", no_class, show_powerpc_command,
4047 _("Various PowerPC-specific commands."),
4048 &showpowerpccmdlist, "show powerpc ", 0, &showlist);
4049
4050 /* Add a command to allow the user to force the ABI. */
4051 add_setshow_auto_boolean_cmd ("soft-float", class_support,
4052 &powerpc_soft_float_global,
4053 _("Set whether to use a soft-float ABI."),
4054 _("Show whether to use a soft-float ABI."),
4055 NULL,
4056 powerpc_set_soft_float, NULL,
4057 &setpowerpccmdlist, &showpowerpccmdlist);
4058
4059 add_setshow_enum_cmd ("vector-abi", class_support, powerpc_vector_strings,
4060 &powerpc_vector_abi_string,
4061 _("Set the vector ABI."),
4062 _("Show the vector ABI."),
4063 NULL, powerpc_set_vector_abi, NULL,
4064 &setpowerpccmdlist, &showpowerpccmdlist);
c906108c 4065}
GDB Binutils - Deliverables
This page took 1.430809 seconds and 4 git commands to generate.