1161537Smarcel/* Target-dependent code for GDB, the GNU debugger. 2161537Smarcel 3161537Smarcel Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 4161537Smarcel 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software 5161537Smarcel Foundation, Inc. 6161537Smarcel 7161537Smarcel This file is part of GDB. 8161537Smarcel 9161537Smarcel This program is free software; you can redistribute it and/or modify 10161537Smarcel it under the terms of the GNU General Public License as published by 11161537Smarcel the Free Software Foundation; either version 2 of the License, or 12161537Smarcel (at your option) any later version. 13161537Smarcel 14161537Smarcel This program is distributed in the hope that it will be useful, 15161537Smarcel but WITHOUT ANY WARRANTY; without even the implied warranty of 16161537Smarcel MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17161537Smarcel GNU General Public License for more details. 18161537Smarcel 19161537Smarcel You should have received a copy of the GNU General Public License 20161537Smarcel along with this program; if not, write to the Free Software 21161537Smarcel Foundation, Inc., 59 Temple Place - Suite 330, 22161537Smarcel Boston, MA 02111-1307, USA. */ 23161537Smarcel 24161537Smarcel#include "defs.h" 25161537Smarcel#include "frame.h" 26161537Smarcel#include "inferior.h" 27161537Smarcel#include "symtab.h" 28161537Smarcel#include "target.h" 29161537Smarcel#include "gdbcore.h" 30161537Smarcel#include "gdbcmd.h" 31161537Smarcel#include "objfiles.h" 32161537Smarcel#include "arch-utils.h" 33161537Smarcel#include "regcache.h" 34161537Smarcel#include "doublest.h" 35161537Smarcel#include "value.h" 36161537Smarcel#include "parser-defs.h" 37161537Smarcel#include "osabi.h" 38161537Smarcel 39161537Smarcel#include "libbfd.h" /* for bfd_default_set_arch_mach */ 40161537Smarcel#include "coff/internal.h" /* for libcoff.h */ 41161537Smarcel#include "libcoff.h" /* for xcoff_data */ 42161537Smarcel#include "coff/xcoff.h" 43161537Smarcel#include "libxcoff.h" 44161537Smarcel 45161537Smarcel#include "elf-bfd.h" 46161537Smarcel 47161537Smarcel#include "solib-svr4.h" 48161537Smarcel#include "ppc-tdep.h" 49161537Smarcel 50161537Smarcel#include "gdb_assert.h" 51161537Smarcel#include "dis-asm.h" 52161537Smarcel 53161537Smarcel/* If the kernel has to deliver a signal, it pushes a sigcontext 54161537Smarcel structure on the stack and then calls the signal handler, passing 55161537Smarcel the address of the sigcontext in an argument register. Usually 56161537Smarcel the signal handler doesn't save this register, so we have to 57161537Smarcel access the sigcontext structure via an offset from the signal handler 58161537Smarcel frame. 59161537Smarcel The following constants were determined by experimentation on AIX 3.2. */ 60161537Smarcel#define SIG_FRAME_PC_OFFSET 96 61161537Smarcel#define SIG_FRAME_LR_OFFSET 108 62161537Smarcel#define SIG_FRAME_FP_OFFSET 284 63161537Smarcel 64161537Smarcel/* To be used by skip_prologue. */ 65161537Smarcel 66161537Smarcelstruct rs6000_framedata 67161537Smarcel { 68161537Smarcel int offset; /* total size of frame --- the distance 69161537Smarcel by which we decrement sp to allocate 70161537Smarcel the frame */ 71161537Smarcel int saved_gpr; /* smallest # of saved gpr */ 72161537Smarcel int saved_fpr; /* smallest # of saved fpr */ 73161537Smarcel int saved_vr; /* smallest # of saved vr */ 74161537Smarcel int saved_ev; /* smallest # of saved ev */ 75161537Smarcel int alloca_reg; /* alloca register number (frame ptr) */ 76161537Smarcel char frameless; /* true if frameless functions. */ 77161537Smarcel char nosavedpc; /* true if pc not saved. */ 78161537Smarcel int gpr_offset; /* offset of saved gprs from prev sp */ 79161537Smarcel int fpr_offset; /* offset of saved fprs from prev sp */ 80161537Smarcel int vr_offset; /* offset of saved vrs from prev sp */ 81161537Smarcel int ev_offset; /* offset of saved evs from prev sp */ 82161537Smarcel int lr_offset; /* offset of saved lr */ 83161537Smarcel int cr_offset; /* offset of saved cr */ 84161537Smarcel int vrsave_offset; /* offset of saved vrsave register */ 85161537Smarcel }; 86161537Smarcel 87161537Smarcel/* Description of a single register. */ 88161537Smarcel 89161537Smarcelstruct reg 90161537Smarcel { 91161537Smarcel char *name; /* name of register */ 92161537Smarcel unsigned char sz32; /* size on 32-bit arch, 0 if nonextant */ 93161537Smarcel unsigned char sz64; /* size on 64-bit arch, 0 if nonextant */ 94161537Smarcel unsigned char fpr; /* whether register is floating-point */ 95161537Smarcel unsigned char pseudo; /* whether register is pseudo */ 96161537Smarcel }; 97161537Smarcel 98161537Smarcel/* Breakpoint shadows for the single step instructions will be kept here. */ 99161537Smarcel 100161537Smarcelstatic struct sstep_breaks 101161537Smarcel { 102161537Smarcel /* Address, or 0 if this is not in use. */ 103161537Smarcel CORE_ADDR address; 104161537Smarcel /* Shadow contents. */ 105161537Smarcel char data[4]; 106161537Smarcel } 107161537SmarcelstepBreaks[2]; 108161537Smarcel 109161537Smarcel/* Hook for determining the TOC address when calling functions in the 110161537Smarcel inferior under AIX. The initialization code in rs6000-nat.c sets 111161537Smarcel this hook to point to find_toc_address. */ 112161537Smarcel 113161537SmarcelCORE_ADDR (*rs6000_find_toc_address_hook) (CORE_ADDR) = NULL; 114161537Smarcel 115161537Smarcel/* Hook to set the current architecture when starting a child process. 116161537Smarcel rs6000-nat.c sets this. */ 117161537Smarcel 118161537Smarcelvoid (*rs6000_set_host_arch_hook) (int) = NULL; 119161537Smarcel 120161537Smarcel/* Static function prototypes */ 121161537Smarcel 122161537Smarcelstatic CORE_ADDR branch_dest (int opcode, int instr, CORE_ADDR pc, 123161537Smarcel CORE_ADDR safety); 124161537Smarcelstatic CORE_ADDR skip_prologue (CORE_ADDR, CORE_ADDR, 125161537Smarcel struct rs6000_framedata *); 126161537Smarcelstatic void frame_get_saved_regs (struct frame_info * fi, 127161537Smarcel struct rs6000_framedata * fdatap); 128161537Smarcelstatic CORE_ADDR frame_initial_stack_address (struct frame_info *); 129161537Smarcel 130161537Smarcel/* Is REGNO an AltiVec register? Return 1 if so, 0 otherwise. */ 131161537Smarcelint 132161537Smarcelaltivec_register_p (int regno) 133161537Smarcel{ 134161537Smarcel struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); 135161537Smarcel if (tdep->ppc_vr0_regnum < 0 || tdep->ppc_vrsave_regnum < 0) 136161537Smarcel return 0; 137161537Smarcel else 138161537Smarcel return (regno >= tdep->ppc_vr0_regnum && regno <= tdep->ppc_vrsave_regnum); 139161537Smarcel} 140161537Smarcel 141161537Smarcel/* Use the architectures FP registers? */ 142161537Smarcelint 143161537Smarcelppc_floating_point_unit_p (struct gdbarch *gdbarch) 144161537Smarcel{ 145161537Smarcel const struct bfd_arch_info *info = gdbarch_bfd_arch_info (gdbarch); 146161537Smarcel if (info->arch == bfd_arch_powerpc) 147161537Smarcel return (info->mach != bfd_mach_ppc_e500); 148161537Smarcel if (info->arch == bfd_arch_rs6000) 149161537Smarcel return 1; 150161537Smarcel return 0; 151161537Smarcel} 152161537Smarcel 153161537Smarcel/* Read a LEN-byte address from debugged memory address MEMADDR. */ 154161537Smarcel 155161537Smarcelstatic CORE_ADDR 156161537Smarcelread_memory_addr (CORE_ADDR memaddr, int len) 157161537Smarcel{ 158161537Smarcel return read_memory_unsigned_integer (memaddr, len); 159161537Smarcel} 160161537Smarcel 161161537Smarcelstatic CORE_ADDR 162161537Smarcelrs6000_skip_prologue (CORE_ADDR pc) 163161537Smarcel{ 164161537Smarcel struct rs6000_framedata frame; 165161537Smarcel pc = skip_prologue (pc, 0, &frame); 166161537Smarcel return pc; 167161537Smarcel} 168161537Smarcel 169161537Smarcel 170161537Smarcel/* Fill in fi->saved_regs */ 171161537Smarcel 172161537Smarcelstruct frame_extra_info 173161537Smarcel{ 174161537Smarcel /* Functions calling alloca() change the value of the stack 175161537Smarcel pointer. We need to use initial stack pointer (which is saved in 176161537Smarcel r31 by gcc) in such cases. If a compiler emits traceback table, 177161537Smarcel then we should use the alloca register specified in traceback 178161537Smarcel table. FIXME. */ 179161537Smarcel CORE_ADDR initial_sp; /* initial stack pointer. */ 180161537Smarcel}; 181161537Smarcel 182161537Smarcelvoid 183161537Smarcelrs6000_init_extra_frame_info (int fromleaf, struct frame_info *fi) 184161537Smarcel{ 185161537Smarcel struct frame_extra_info *extra_info = 186161537Smarcel frame_extra_info_zalloc (fi, sizeof (struct frame_extra_info)); 187161537Smarcel extra_info->initial_sp = 0; 188161537Smarcel if (get_next_frame (fi) != NULL 189161537Smarcel && get_frame_pc (fi) < TEXT_SEGMENT_BASE) 190161537Smarcel /* We're in get_prev_frame */ 191161537Smarcel /* and this is a special signal frame. */ 192161537Smarcel /* (fi->pc will be some low address in the kernel, */ 193161537Smarcel /* to which the signal handler returns). */ 194161537Smarcel deprecated_set_frame_type (fi, SIGTRAMP_FRAME); 195161537Smarcel} 196161537Smarcel 197161537Smarcel/* Put here the code to store, into a struct frame_saved_regs, 198161537Smarcel the addresses of the saved registers of frame described by FRAME_INFO. 199161537Smarcel This includes special registers such as pc and fp saved in special 200161537Smarcel ways in the stack frame. sp is even more special: 201161537Smarcel the address we return for it IS the sp for the next frame. */ 202161537Smarcel 203161537Smarcel/* In this implementation for RS/6000, we do *not* save sp. I am 204161537Smarcel not sure if it will be needed. The following function takes care of gpr's 205161537Smarcel and fpr's only. */ 206161537Smarcel 207161537Smarcelvoid 208161537Smarcelrs6000_frame_init_saved_regs (struct frame_info *fi) 209161537Smarcel{ 210161537Smarcel frame_get_saved_regs (fi, NULL); 211161537Smarcel} 212161537Smarcel 213161537Smarcelstatic CORE_ADDR 214161537Smarcelrs6000_frame_args_address (struct frame_info *fi) 215161537Smarcel{ 216161537Smarcel struct frame_extra_info *extra_info = get_frame_extra_info (fi); 217161537Smarcel if (extra_info->initial_sp != 0) 218161537Smarcel return extra_info->initial_sp; 219161537Smarcel else 220161537Smarcel return frame_initial_stack_address (fi); 221161537Smarcel} 222161537Smarcel 223161537Smarcel/* Immediately after a function call, return the saved pc. 224161537Smarcel Can't go through the frames for this because on some machines 225161537Smarcel the new frame is not set up until the new function executes 226161537Smarcel some instructions. */ 227161537Smarcel 228161537Smarcelstatic CORE_ADDR 229161537Smarcelrs6000_saved_pc_after_call (struct frame_info *fi) 230161537Smarcel{ 231161537Smarcel return read_register (gdbarch_tdep (current_gdbarch)->ppc_lr_regnum); 232161537Smarcel} 233161537Smarcel 234161537Smarcel/* Get the ith function argument for the current function. */ 235161537Smarcelstatic CORE_ADDR 236161537Smarcelrs6000_fetch_pointer_argument (struct frame_info *frame, int argi, 237161537Smarcel struct type *type) 238161537Smarcel{ 239161537Smarcel CORE_ADDR addr; 240161537Smarcel get_frame_register (frame, 3 + argi, &addr); 241161537Smarcel return addr; 242161537Smarcel} 243161537Smarcel 244161537Smarcel/* Calculate the destination of a branch/jump. Return -1 if not a branch. */ 245161537Smarcel 246161537Smarcelstatic CORE_ADDR 247161537Smarcelbranch_dest (int opcode, int instr, CORE_ADDR pc, CORE_ADDR safety) 248161537Smarcel{ 249161537Smarcel CORE_ADDR dest; 250161537Smarcel int immediate; 251161537Smarcel int absolute; 252161537Smarcel int ext_op; 253161537Smarcel 254161537Smarcel absolute = (int) ((instr >> 1) & 1); 255161537Smarcel 256161537Smarcel switch (opcode) 257161537Smarcel { 258161537Smarcel case 18: 259161537Smarcel immediate = ((instr & ~3) << 6) >> 6; /* br unconditional */ 260161537Smarcel if (absolute) 261161537Smarcel dest = immediate; 262161537Smarcel else 263161537Smarcel dest = pc + immediate; 264161537Smarcel break; 265161537Smarcel 266161537Smarcel case 16: 267161537Smarcel immediate = ((instr & ~3) << 16) >> 16; /* br conditional */ 268161537Smarcel if (absolute) 269161537Smarcel dest = immediate; 270161537Smarcel else 271161537Smarcel dest = pc + immediate; 272161537Smarcel break; 273161537Smarcel 274161537Smarcel case 19: 275161537Smarcel ext_op = (instr >> 1) & 0x3ff; 276161537Smarcel 277161537Smarcel if (ext_op == 16) /* br conditional register */ 278161537Smarcel { 279161537Smarcel dest = read_register (gdbarch_tdep (current_gdbarch)->ppc_lr_regnum) & ~3; 280161537Smarcel 281161537Smarcel /* If we are about to return from a signal handler, dest is 282161537Smarcel something like 0x3c90. The current frame is a signal handler 283161537Smarcel caller frame, upon completion of the sigreturn system call 284161537Smarcel execution will return to the saved PC in the frame. */ 285161537Smarcel if (dest < TEXT_SEGMENT_BASE) 286161537Smarcel { 287161537Smarcel struct frame_info *fi; 288161537Smarcel 289161537Smarcel fi = get_current_frame (); 290161537Smarcel if (fi != NULL) 291161537Smarcel dest = read_memory_addr (get_frame_base (fi) + SIG_FRAME_PC_OFFSET, 292161537Smarcel gdbarch_tdep (current_gdbarch)->wordsize); 293161537Smarcel } 294161537Smarcel } 295161537Smarcel 296161537Smarcel else if (ext_op == 528) /* br cond to count reg */ 297161537Smarcel { 298161537Smarcel dest = read_register (gdbarch_tdep (current_gdbarch)->ppc_ctr_regnum) & ~3; 299161537Smarcel 300161537Smarcel /* If we are about to execute a system call, dest is something 301161537Smarcel like 0x22fc or 0x3b00. Upon completion the system call 302161537Smarcel will return to the address in the link register. */ 303161537Smarcel if (dest < TEXT_SEGMENT_BASE) 304161537Smarcel dest = read_register (gdbarch_tdep (current_gdbarch)->ppc_lr_regnum) & ~3; 305161537Smarcel } 306161537Smarcel else 307161537Smarcel return -1; 308161537Smarcel break; 309161537Smarcel 310161537Smarcel default: 311161537Smarcel return -1; 312161537Smarcel } 313161537Smarcel return (dest < TEXT_SEGMENT_BASE) ? safety : dest; 314161537Smarcel} 315161537Smarcel 316161537Smarcel 317161537Smarcel/* Sequence of bytes for breakpoint instruction. */ 318161537Smarcel 319161537Smarcelconst static unsigned char * 320161537Smarcelrs6000_breakpoint_from_pc (CORE_ADDR *bp_addr, int *bp_size) 321161537Smarcel{ 322161537Smarcel static unsigned char big_breakpoint[] = { 0x7d, 0x82, 0x10, 0x08 }; 323161537Smarcel static unsigned char little_breakpoint[] = { 0x08, 0x10, 0x82, 0x7d }; 324161537Smarcel *bp_size = 4; 325161537Smarcel if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) 326161537Smarcel return big_breakpoint; 327161537Smarcel else 328161537Smarcel return little_breakpoint; 329161537Smarcel} 330161537Smarcel 331161537Smarcel 332161537Smarcel/* AIX does not support PT_STEP. Simulate it. */ 333161537Smarcel 334161537Smarcelvoid 335161537Smarcelrs6000_software_single_step (enum target_signal signal, 336161537Smarcel int insert_breakpoints_p) 337161537Smarcel{ 338161537Smarcel CORE_ADDR dummy; 339161537Smarcel int breakp_sz; 340161537Smarcel const char *breakp = rs6000_breakpoint_from_pc (&dummy, &breakp_sz); 341161537Smarcel int ii, insn; 342161537Smarcel CORE_ADDR loc; 343161537Smarcel CORE_ADDR breaks[2]; 344161537Smarcel int opcode; 345161537Smarcel 346161537Smarcel if (insert_breakpoints_p) 347161537Smarcel { 348161537Smarcel 349161537Smarcel loc = read_pc (); 350161537Smarcel 351161537Smarcel insn = read_memory_integer (loc, 4); 352161537Smarcel 353161537Smarcel breaks[0] = loc + breakp_sz; 354161537Smarcel opcode = insn >> 26; 355161537Smarcel breaks[1] = branch_dest (opcode, insn, loc, breaks[0]); 356161537Smarcel 357161537Smarcel /* Don't put two breakpoints on the same address. */ 358161537Smarcel if (breaks[1] == breaks[0]) 359161537Smarcel breaks[1] = -1; 360161537Smarcel 361161537Smarcel stepBreaks[1].address = 0; 362161537Smarcel 363161537Smarcel for (ii = 0; ii < 2; ++ii) 364161537Smarcel { 365161537Smarcel 366161537Smarcel /* ignore invalid breakpoint. */ 367161537Smarcel if (breaks[ii] == -1) 368161537Smarcel continue; 369161537Smarcel target_insert_breakpoint (breaks[ii], stepBreaks[ii].data); 370161537Smarcel stepBreaks[ii].address = breaks[ii]; 371161537Smarcel } 372161537Smarcel 373161537Smarcel } 374161537Smarcel else 375161537Smarcel { 376161537Smarcel 377161537Smarcel /* remove step breakpoints. */ 378161537Smarcel for (ii = 0; ii < 2; ++ii) 379161537Smarcel if (stepBreaks[ii].address != 0) 380161537Smarcel target_remove_breakpoint (stepBreaks[ii].address, 381161537Smarcel stepBreaks[ii].data); 382161537Smarcel } 383161537Smarcel errno = 0; /* FIXME, don't ignore errors! */ 384161537Smarcel /* What errors? {read,write}_memory call error(). */ 385161537Smarcel} 386161537Smarcel 387161537Smarcel 388161537Smarcel/* return pc value after skipping a function prologue and also return 389161537Smarcel information about a function frame. 390161537Smarcel 391161537Smarcel in struct rs6000_framedata fdata: 392161537Smarcel - frameless is TRUE, if function does not have a frame. 393161537Smarcel - nosavedpc is TRUE, if function does not save %pc value in its frame. 394161537Smarcel - offset is the initial size of this stack frame --- the amount by 395161537Smarcel which we decrement the sp to allocate the frame. 396161537Smarcel - saved_gpr is the number of the first saved gpr. 397161537Smarcel - saved_fpr is the number of the first saved fpr. 398161537Smarcel - saved_vr is the number of the first saved vr. 399161537Smarcel - saved_ev is the number of the first saved ev. 400161537Smarcel - alloca_reg is the number of the register used for alloca() handling. 401161537Smarcel Otherwise -1. 402161537Smarcel - gpr_offset is the offset of the first saved gpr from the previous frame. 403161537Smarcel - fpr_offset is the offset of the first saved fpr from the previous frame. 404161537Smarcel - vr_offset is the offset of the first saved vr from the previous frame. 405161537Smarcel - ev_offset is the offset of the first saved ev from the previous frame. 406161537Smarcel - lr_offset is the offset of the saved lr 407161537Smarcel - cr_offset is the offset of the saved cr 408161537Smarcel - vrsave_offset is the offset of the saved vrsave register 409161537Smarcel */ 410161537Smarcel 411161537Smarcel#define SIGNED_SHORT(x) \ 412161537Smarcel ((sizeof (short) == 2) \ 413161537Smarcel ? ((int)(short)(x)) \ 414161537Smarcel : ((int)((((x) & 0xffff) ^ 0x8000) - 0x8000))) 415161537Smarcel 416161537Smarcel#define GET_SRC_REG(x) (((x) >> 21) & 0x1f) 417161537Smarcel 418161537Smarcel/* Limit the number of skipped non-prologue instructions, as the examining 419161537Smarcel of the prologue is expensive. */ 420161537Smarcelstatic int max_skip_non_prologue_insns = 10; 421161537Smarcel 422161537Smarcel/* Given PC representing the starting address of a function, and 423161537Smarcel LIM_PC which is the (sloppy) limit to which to scan when looking 424161537Smarcel for a prologue, attempt to further refine this limit by using 425161537Smarcel the line data in the symbol table. If successful, a better guess 426161537Smarcel on where the prologue ends is returned, otherwise the previous 427161537Smarcel value of lim_pc is returned. */ 428161537Smarcel 429161537Smarcel/* FIXME: cagney/2004-02-14: This function and logic have largely been 430161537Smarcel superseded by skip_prologue_using_sal. */ 431161537Smarcel 432161537Smarcelstatic CORE_ADDR 433161537Smarcelrefine_prologue_limit (CORE_ADDR pc, CORE_ADDR lim_pc) 434161537Smarcel{ 435161537Smarcel struct symtab_and_line prologue_sal; 436161537Smarcel 437161537Smarcel prologue_sal = find_pc_line (pc, 0); 438161537Smarcel if (prologue_sal.line != 0) 439161537Smarcel { 440161537Smarcel int i; 441161537Smarcel CORE_ADDR addr = prologue_sal.end; 442161537Smarcel 443161537Smarcel /* Handle the case in which compiler's optimizer/scheduler 444161537Smarcel has moved instructions into the prologue. We scan ahead 445161537Smarcel in the function looking for address ranges whose corresponding 446161537Smarcel line number is less than or equal to the first one that we 447161537Smarcel found for the function. (It can be less than when the 448161537Smarcel scheduler puts a body instruction before the first prologue 449161537Smarcel instruction.) */ 450161537Smarcel for (i = 2 * max_skip_non_prologue_insns; 451161537Smarcel i > 0 && (lim_pc == 0 || addr < lim_pc); 452161537Smarcel i--) 453161537Smarcel { 454161537Smarcel struct symtab_and_line sal; 455161537Smarcel 456161537Smarcel sal = find_pc_line (addr, 0); 457161537Smarcel if (sal.line == 0) 458161537Smarcel break; 459161537Smarcel if (sal.line <= prologue_sal.line 460161537Smarcel && sal.symtab == prologue_sal.symtab) 461161537Smarcel { 462161537Smarcel prologue_sal = sal; 463161537Smarcel } 464161537Smarcel addr = sal.end; 465161537Smarcel } 466161537Smarcel 467161537Smarcel if (lim_pc == 0 || prologue_sal.end < lim_pc) 468161537Smarcel lim_pc = prologue_sal.end; 469161537Smarcel } 470161537Smarcel return lim_pc; 471161537Smarcel} 472161537Smarcel 473161537Smarcel 474161537Smarcelstatic CORE_ADDR 475161537Smarcelskip_prologue (CORE_ADDR pc, CORE_ADDR lim_pc, struct rs6000_framedata *fdata) 476161537Smarcel{ 477161537Smarcel CORE_ADDR orig_pc = pc; 478161537Smarcel CORE_ADDR last_prologue_pc = pc; 479161537Smarcel CORE_ADDR li_found_pc = 0; 480161537Smarcel char buf[4]; 481161537Smarcel unsigned long op; 482161537Smarcel long offset = 0; 483161537Smarcel long vr_saved_offset = 0; 484161537Smarcel int lr_reg = -1; 485161537Smarcel int cr_reg = -1; 486161537Smarcel int vr_reg = -1; 487161537Smarcel int ev_reg = -1; 488161537Smarcel long ev_offset = 0; 489161537Smarcel int vrsave_reg = -1; 490161537Smarcel int reg; 491161537Smarcel int framep = 0; 492161537Smarcel int minimal_toc_loaded = 0; 493161537Smarcel int prev_insn_was_prologue_insn = 1; 494161537Smarcel int num_skip_non_prologue_insns = 0; 495161537Smarcel const struct bfd_arch_info *arch_info = gdbarch_bfd_arch_info (current_gdbarch); 496161537Smarcel struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); 497161537Smarcel 498161537Smarcel /* Attempt to find the end of the prologue when no limit is specified. 499161537Smarcel Note that refine_prologue_limit() has been written so that it may 500161537Smarcel be used to "refine" the limits of non-zero PC values too, but this 501161537Smarcel is only safe if we 1) trust the line information provided by the 502161537Smarcel compiler and 2) iterate enough to actually find the end of the 503161537Smarcel prologue. 504161537Smarcel 505161537Smarcel It may become a good idea at some point (for both performance and 506161537Smarcel accuracy) to unconditionally call refine_prologue_limit(). But, 507161537Smarcel until we can make a clear determination that this is beneficial, 508161537Smarcel we'll play it safe and only use it to obtain a limit when none 509161537Smarcel has been specified. */ 510161537Smarcel if (lim_pc == 0) 511161537Smarcel lim_pc = refine_prologue_limit (pc, lim_pc); 512161537Smarcel 513161537Smarcel memset (fdata, 0, sizeof (struct rs6000_framedata)); 514161537Smarcel fdata->saved_gpr = -1; 515161537Smarcel fdata->saved_fpr = -1; 516161537Smarcel fdata->saved_vr = -1; 517161537Smarcel fdata->saved_ev = -1; 518161537Smarcel fdata->alloca_reg = -1; 519161537Smarcel fdata->frameless = 1; 520161537Smarcel fdata->nosavedpc = 1; 521161537Smarcel 522161537Smarcel for (;; pc += 4) 523161537Smarcel { 524161537Smarcel /* Sometimes it isn't clear if an instruction is a prologue 525161537Smarcel instruction or not. When we encounter one of these ambiguous 526161537Smarcel cases, we'll set prev_insn_was_prologue_insn to 0 (false). 527161537Smarcel Otherwise, we'll assume that it really is a prologue instruction. */ 528161537Smarcel if (prev_insn_was_prologue_insn) 529161537Smarcel last_prologue_pc = pc; 530161537Smarcel 531161537Smarcel /* Stop scanning if we've hit the limit. */ 532161537Smarcel if (lim_pc != 0 && pc >= lim_pc) 533161537Smarcel break; 534161537Smarcel 535161537Smarcel prev_insn_was_prologue_insn = 1; 536161537Smarcel 537161537Smarcel /* Fetch the instruction and convert it to an integer. */ 538161537Smarcel if (target_read_memory (pc, buf, 4)) 539161537Smarcel break; 540161537Smarcel op = extract_signed_integer (buf, 4); 541161537Smarcel 542161537Smarcel if ((op & 0xfc1fffff) == 0x7c0802a6) 543161537Smarcel { /* mflr Rx */ 544161537Smarcel lr_reg = (op & 0x03e00000); 545161537Smarcel continue; 546161537Smarcel 547161537Smarcel } 548161537Smarcel else if ((op & 0xfc1fffff) == 0x7c000026) 549161537Smarcel { /* mfcr Rx */ 550161537Smarcel cr_reg = (op & 0x03e00000); 551161537Smarcel continue; 552161537Smarcel 553161537Smarcel } 554161537Smarcel else if ((op & 0xfc1f0000) == 0xd8010000) 555161537Smarcel { /* stfd Rx,NUM(r1) */ 556161537Smarcel reg = GET_SRC_REG (op); 557161537Smarcel if (fdata->saved_fpr == -1 || fdata->saved_fpr > reg) 558161537Smarcel { 559161537Smarcel fdata->saved_fpr = reg; 560161537Smarcel fdata->fpr_offset = SIGNED_SHORT (op) + offset; 561161537Smarcel } 562161537Smarcel continue; 563161537Smarcel 564161537Smarcel } 565161537Smarcel else if (((op & 0xfc1f0000) == 0xbc010000) || /* stm Rx, NUM(r1) */ 566161537Smarcel (((op & 0xfc1f0000) == 0x90010000 || /* st rx,NUM(r1) */ 567161537Smarcel (op & 0xfc1f0003) == 0xf8010000) && /* std rx,NUM(r1) */ 568161537Smarcel (op & 0x03e00000) >= 0x01a00000)) /* rx >= r13 */ 569161537Smarcel { 570161537Smarcel 571161537Smarcel reg = GET_SRC_REG (op); 572161537Smarcel if (fdata->saved_gpr == -1 || fdata->saved_gpr > reg) 573161537Smarcel { 574161537Smarcel fdata->saved_gpr = reg; 575161537Smarcel if ((op & 0xfc1f0003) == 0xf8010000) 576161537Smarcel op &= ~3UL; 577161537Smarcel fdata->gpr_offset = SIGNED_SHORT (op) + offset; 578161537Smarcel } 579161537Smarcel continue; 580161537Smarcel 581161537Smarcel } 582161537Smarcel else if ((op & 0xffff0000) == 0x60000000) 583161537Smarcel { 584161537Smarcel /* nop */ 585161537Smarcel /* Allow nops in the prologue, but do not consider them to 586161537Smarcel be part of the prologue unless followed by other prologue 587161537Smarcel instructions. */ 588161537Smarcel prev_insn_was_prologue_insn = 0; 589161537Smarcel continue; 590161537Smarcel 591161537Smarcel } 592161537Smarcel else if ((op & 0xffff0000) == 0x3c000000) 593161537Smarcel { /* addis 0,0,NUM, used 594161537Smarcel for >= 32k frames */ 595161537Smarcel fdata->offset = (op & 0x0000ffff) << 16; 596161537Smarcel fdata->frameless = 0; 597161537Smarcel continue; 598161537Smarcel 599161537Smarcel } 600161537Smarcel else if ((op & 0xffff0000) == 0x60000000) 601161537Smarcel { /* ori 0,0,NUM, 2nd ha 602161537Smarcel lf of >= 32k frames */ 603161537Smarcel fdata->offset |= (op & 0x0000ffff); 604161537Smarcel fdata->frameless = 0; 605161537Smarcel continue; 606161537Smarcel 607161537Smarcel } 608161537Smarcel else if (lr_reg != -1 && 609161537Smarcel /* std Rx, NUM(r1) || stdu Rx, NUM(r1) */ 610161537Smarcel (((op & 0xffff0000) == (lr_reg | 0xf8010000)) || 611161537Smarcel /* stw Rx, NUM(r1) */ 612161537Smarcel ((op & 0xffff0000) == (lr_reg | 0x90010000)) || 613161537Smarcel /* stwu Rx, NUM(r1) */ 614161537Smarcel ((op & 0xffff0000) == (lr_reg | 0x94010000)))) 615161537Smarcel { /* where Rx == lr */ 616161537Smarcel fdata->lr_offset = offset; 617161537Smarcel fdata->nosavedpc = 0; 618161537Smarcel lr_reg = 0; 619161537Smarcel if ((op & 0xfc000003) == 0xf8000000 || /* std */ 620161537Smarcel (op & 0xfc000000) == 0x90000000) /* stw */ 621161537Smarcel { 622161537Smarcel /* Does not update r1, so add displacement to lr_offset. */ 623161537Smarcel fdata->lr_offset += SIGNED_SHORT (op); 624161537Smarcel } 625161537Smarcel continue; 626161537Smarcel 627161537Smarcel } 628161537Smarcel else if (cr_reg != -1 && 629161537Smarcel /* std Rx, NUM(r1) || stdu Rx, NUM(r1) */ 630161537Smarcel (((op & 0xffff0000) == (cr_reg | 0xf8010000)) || 631161537Smarcel /* stw Rx, NUM(r1) */ 632161537Smarcel ((op & 0xffff0000) == (cr_reg | 0x90010000)) || 633161537Smarcel /* stwu Rx, NUM(r1) */ 634161537Smarcel ((op & 0xffff0000) == (cr_reg | 0x94010000)))) 635161537Smarcel { /* where Rx == cr */ 636161537Smarcel fdata->cr_offset = offset; 637161537Smarcel cr_reg = 0; 638161537Smarcel if ((op & 0xfc000003) == 0xf8000000 || 639161537Smarcel (op & 0xfc000000) == 0x90000000) 640161537Smarcel { 641161537Smarcel /* Does not update r1, so add displacement to cr_offset. */ 642161537Smarcel fdata->cr_offset += SIGNED_SHORT (op); 643161537Smarcel } 644161537Smarcel continue; 645161537Smarcel 646161537Smarcel } 647161537Smarcel else if (op == 0x48000005) 648161537Smarcel { /* bl .+4 used in 649161537Smarcel -mrelocatable */ 650161537Smarcel continue; 651161537Smarcel 652161537Smarcel } 653161537Smarcel else if (op == 0x48000004) 654161537Smarcel { /* b .+4 (xlc) */ 655161537Smarcel break; 656161537Smarcel 657161537Smarcel } 658161537Smarcel else if ((op & 0xffff0000) == 0x3fc00000 || /* addis 30,0,foo@ha, used 659161537Smarcel in V.4 -mminimal-toc */ 660161537Smarcel (op & 0xffff0000) == 0x3bde0000) 661161537Smarcel { /* addi 30,30,foo@l */ 662161537Smarcel continue; 663161537Smarcel 664161537Smarcel } 665161537Smarcel else if ((op & 0xfc000001) == 0x48000001) 666161537Smarcel { /* bl foo, 667161537Smarcel to save fprs??? */ 668161537Smarcel 669161537Smarcel fdata->frameless = 0; 670161537Smarcel /* Don't skip over the subroutine call if it is not within 671161537Smarcel the first three instructions of the prologue. */ 672161537Smarcel if ((pc - orig_pc) > 8) 673161537Smarcel break; 674161537Smarcel 675161537Smarcel op = read_memory_integer (pc + 4, 4); 676161537Smarcel 677161537Smarcel /* At this point, make sure this is not a trampoline 678161537Smarcel function (a function that simply calls another functions, 679161537Smarcel and nothing else). If the next is not a nop, this branch 680161537Smarcel was part of the function prologue. */ 681161537Smarcel 682161537Smarcel if (op == 0x4def7b82 || op == 0) /* crorc 15, 15, 15 */ 683161537Smarcel break; /* don't skip over 684161537Smarcel this branch */ 685161537Smarcel continue; 686161537Smarcel 687161537Smarcel } 688161537Smarcel /* update stack pointer */ 689161537Smarcel else if ((op & 0xfc1f0000) == 0x94010000) 690161537Smarcel { /* stu rX,NUM(r1) || stwu rX,NUM(r1) */ 691161537Smarcel fdata->frameless = 0; 692161537Smarcel fdata->offset = SIGNED_SHORT (op); 693161537Smarcel offset = fdata->offset; 694161537Smarcel continue; 695161537Smarcel } 696161537Smarcel else if ((op & 0xfc1f016a) == 0x7c01016e) 697161537Smarcel { /* stwux rX,r1,rY */ 698161537Smarcel /* no way to figure out what r1 is going to be */ 699161537Smarcel fdata->frameless = 0; 700161537Smarcel offset = fdata->offset; 701161537Smarcel continue; 702161537Smarcel } 703161537Smarcel else if ((op & 0xfc1f0003) == 0xf8010001) 704161537Smarcel { /* stdu rX,NUM(r1) */ 705161537Smarcel fdata->frameless = 0; 706161537Smarcel fdata->offset = SIGNED_SHORT (op & ~3UL); 707161537Smarcel offset = fdata->offset; 708161537Smarcel continue; 709161537Smarcel } 710161537Smarcel else if ((op & 0xfc1f016a) == 0x7c01016a) 711161537Smarcel { /* stdux rX,r1,rY */ 712161537Smarcel /* no way to figure out what r1 is going to be */ 713161537Smarcel fdata->frameless = 0; 714161537Smarcel offset = fdata->offset; 715161537Smarcel continue; 716161537Smarcel } 717161537Smarcel /* Load up minimal toc pointer */ 718161537Smarcel else if (((op >> 22) == 0x20f || /* l r31,... or l r30,... */ 719161537Smarcel (op >> 22) == 0x3af) /* ld r31,... or ld r30,... */ 720161537Smarcel && !minimal_toc_loaded) 721161537Smarcel { 722161537Smarcel minimal_toc_loaded = 1; 723161537Smarcel continue; 724161537Smarcel 725161537Smarcel /* move parameters from argument registers to local variable 726161537Smarcel registers */ 727161537Smarcel } 728161537Smarcel else if ((op & 0xfc0007fe) == 0x7c000378 && /* mr(.) Rx,Ry */ 729161537Smarcel (((op >> 21) & 31) >= 3) && /* R3 >= Ry >= R10 */ 730161537Smarcel (((op >> 21) & 31) <= 10) && 731161537Smarcel ((long) ((op >> 16) & 31) >= fdata->saved_gpr)) /* Rx: local var reg */ 732161537Smarcel { 733161537Smarcel continue; 734161537Smarcel 735161537Smarcel /* store parameters in stack */ 736161537Smarcel } 737161537Smarcel else if ((op & 0xfc1f0003) == 0xf8010000 || /* std rx,NUM(r1) */ 738161537Smarcel (op & 0xfc1f0000) == 0xd8010000 || /* stfd Rx,NUM(r1) */ 739161537Smarcel (op & 0xfc1f0000) == 0xfc010000) /* frsp, fp?,NUM(r1) */ 740161537Smarcel { 741161537Smarcel continue; 742161537Smarcel 743161537Smarcel /* store parameters in stack via frame pointer */ 744161537Smarcel } 745161537Smarcel else if (framep && 746161537Smarcel ((op & 0xfc1f0000) == 0x901f0000 || /* st rx,NUM(r1) */ 747161537Smarcel (op & 0xfc1f0000) == 0xd81f0000 || /* stfd Rx,NUM(r1) */ 748161537Smarcel (op & 0xfc1f0000) == 0xfc1f0000)) 749161537Smarcel { /* frsp, fp?,NUM(r1) */ 750161537Smarcel continue; 751161537Smarcel 752161537Smarcel /* Set up frame pointer */ 753161537Smarcel } 754161537Smarcel else if (op == 0x603f0000 /* oril r31, r1, 0x0 */ 755161537Smarcel || op == 0x7c3f0b78) 756161537Smarcel { /* mr r31, r1 */ 757161537Smarcel fdata->frameless = 0; 758161537Smarcel framep = 1; 759161537Smarcel fdata->alloca_reg = (tdep->ppc_gp0_regnum + 31); 760161537Smarcel continue; 761161537Smarcel 762161537Smarcel /* Another way to set up the frame pointer. */ 763161537Smarcel } 764161537Smarcel else if ((op & 0xfc1fffff) == 0x38010000) 765161537Smarcel { /* addi rX, r1, 0x0 */ 766161537Smarcel fdata->frameless = 0; 767161537Smarcel framep = 1; 768161537Smarcel fdata->alloca_reg = (tdep->ppc_gp0_regnum 769161537Smarcel + ((op & ~0x38010000) >> 21)); 770161537Smarcel continue; 771161537Smarcel } 772161537Smarcel /* AltiVec related instructions. */ 773161537Smarcel /* Store the vrsave register (spr 256) in another register for 774161537Smarcel later manipulation, or load a register into the vrsave 775161537Smarcel register. 2 instructions are used: mfvrsave and 776161537Smarcel mtvrsave. They are shorthand notation for mfspr Rn, SPR256 777161537Smarcel and mtspr SPR256, Rn. */ 778161537Smarcel /* mfspr Rn SPR256 == 011111 nnnnn 0000001000 01010100110 779161537Smarcel mtspr SPR256 Rn == 011111 nnnnn 0000001000 01110100110 */ 780161537Smarcel else if ((op & 0xfc1fffff) == 0x7c0042a6) /* mfvrsave Rn */ 781161537Smarcel { 782161537Smarcel vrsave_reg = GET_SRC_REG (op); 783161537Smarcel continue; 784161537Smarcel } 785161537Smarcel else if ((op & 0xfc1fffff) == 0x7c0043a6) /* mtvrsave Rn */ 786161537Smarcel { 787161537Smarcel continue; 788161537Smarcel } 789161537Smarcel /* Store the register where vrsave was saved to onto the stack: 790161537Smarcel rS is the register where vrsave was stored in a previous 791161537Smarcel instruction. */ 792161537Smarcel /* 100100 sssss 00001 dddddddd dddddddd */ 793161537Smarcel else if ((op & 0xfc1f0000) == 0x90010000) /* stw rS, d(r1) */ 794161537Smarcel { 795161537Smarcel if (vrsave_reg == GET_SRC_REG (op)) 796161537Smarcel { 797161537Smarcel fdata->vrsave_offset = SIGNED_SHORT (op) + offset; 798161537Smarcel vrsave_reg = -1; 799161537Smarcel } 800161537Smarcel continue; 801161537Smarcel } 802161537Smarcel /* Compute the new value of vrsave, by modifying the register 803161537Smarcel where vrsave was saved to. */ 804161537Smarcel else if (((op & 0xfc000000) == 0x64000000) /* oris Ra, Rs, UIMM */ 805161537Smarcel || ((op & 0xfc000000) == 0x60000000))/* ori Ra, Rs, UIMM */ 806161537Smarcel { 807161537Smarcel continue; 808161537Smarcel } 809161537Smarcel /* li r0, SIMM (short for addi r0, 0, SIMM). This is the first 810161537Smarcel in a pair of insns to save the vector registers on the 811161537Smarcel stack. */ 812161537Smarcel /* 001110 00000 00000 iiii iiii iiii iiii */ 813161537Smarcel /* 001110 01110 00000 iiii iiii iiii iiii */ 814161537Smarcel else if ((op & 0xffff0000) == 0x38000000 /* li r0, SIMM */ 815161537Smarcel || (op & 0xffff0000) == 0x39c00000) /* li r14, SIMM */ 816161537Smarcel { 817161537Smarcel li_found_pc = pc; 818161537Smarcel vr_saved_offset = SIGNED_SHORT (op); 819161537Smarcel } 820161537Smarcel /* Store vector register S at (r31+r0) aligned to 16 bytes. */ 821161537Smarcel /* 011111 sssss 11111 00000 00111001110 */ 822161537Smarcel else if ((op & 0xfc1fffff) == 0x7c1f01ce) /* stvx Vs, R31, R0 */ 823161537Smarcel { 824161537Smarcel if (pc == (li_found_pc + 4)) 825161537Smarcel { 826161537Smarcel vr_reg = GET_SRC_REG (op); 827161537Smarcel /* If this is the first vector reg to be saved, or if 828161537Smarcel it has a lower number than others previously seen, 829161537Smarcel reupdate the frame info. */ 830161537Smarcel if (fdata->saved_vr == -1 || fdata->saved_vr > vr_reg) 831161537Smarcel { 832161537Smarcel fdata->saved_vr = vr_reg; 833161537Smarcel fdata->vr_offset = vr_saved_offset + offset; 834161537Smarcel } 835161537Smarcel vr_saved_offset = -1; 836161537Smarcel vr_reg = -1; 837161537Smarcel li_found_pc = 0; 838161537Smarcel } 839161537Smarcel } 840161537Smarcel /* End AltiVec related instructions. */ 841161537Smarcel 842161537Smarcel /* Start BookE related instructions. */ 843161537Smarcel /* Store gen register S at (r31+uimm). 844161537Smarcel Any register less than r13 is volatile, so we don't care. */ 845161537Smarcel /* 000100 sssss 11111 iiiii 01100100001 */ 846161537Smarcel else if (arch_info->mach == bfd_mach_ppc_e500 847161537Smarcel && (op & 0xfc1f07ff) == 0x101f0321) /* evstdd Rs,uimm(R31) */ 848161537Smarcel { 849161537Smarcel if ((op & 0x03e00000) >= 0x01a00000) /* Rs >= r13 */ 850161537Smarcel { 851161537Smarcel unsigned int imm; 852161537Smarcel ev_reg = GET_SRC_REG (op); 853161537Smarcel imm = (op >> 11) & 0x1f; 854161537Smarcel ev_offset = imm * 8; 855161537Smarcel /* If this is the first vector reg to be saved, or if 856161537Smarcel it has a lower number than others previously seen, 857161537Smarcel reupdate the frame info. */ 858161537Smarcel if (fdata->saved_ev == -1 || fdata->saved_ev > ev_reg) 859161537Smarcel { 860161537Smarcel fdata->saved_ev = ev_reg; 861161537Smarcel fdata->ev_offset = ev_offset + offset; 862161537Smarcel } 863161537Smarcel } 864161537Smarcel continue; 865161537Smarcel } 866161537Smarcel /* Store gen register rS at (r1+rB). */ 867161537Smarcel /* 000100 sssss 00001 bbbbb 01100100000 */ 868161537Smarcel else if (arch_info->mach == bfd_mach_ppc_e500 869161537Smarcel && (op & 0xffe007ff) == 0x13e00320) /* evstddx RS,R1,Rb */ 870161537Smarcel { 871161537Smarcel if (pc == (li_found_pc + 4)) 872161537Smarcel { 873161537Smarcel ev_reg = GET_SRC_REG (op); 874161537Smarcel /* If this is the first vector reg to be saved, or if 875161537Smarcel it has a lower number than others previously seen, 876161537Smarcel reupdate the frame info. */ 877161537Smarcel /* We know the contents of rB from the previous instruction. */ 878161537Smarcel if (fdata->saved_ev == -1 || fdata->saved_ev > ev_reg) 879161537Smarcel { 880161537Smarcel fdata->saved_ev = ev_reg; 881161537Smarcel fdata->ev_offset = vr_saved_offset + offset; 882161537Smarcel } 883161537Smarcel vr_saved_offset = -1; 884161537Smarcel ev_reg = -1; 885161537Smarcel li_found_pc = 0; 886161537Smarcel } 887161537Smarcel continue; 888161537Smarcel } 889161537Smarcel /* Store gen register r31 at (rA+uimm). */ 890161537Smarcel /* 000100 11111 aaaaa iiiii 01100100001 */ 891161537Smarcel else if (arch_info->mach == bfd_mach_ppc_e500 892161537Smarcel && (op & 0xffe007ff) == 0x13e00321) /* evstdd R31,Ra,UIMM */ 893161537Smarcel { 894161537Smarcel /* Wwe know that the source register is 31 already, but 895161537Smarcel it can't hurt to compute it. */ 896161537Smarcel ev_reg = GET_SRC_REG (op); 897161537Smarcel ev_offset = ((op >> 11) & 0x1f) * 8; 898161537Smarcel /* If this is the first vector reg to be saved, or if 899161537Smarcel it has a lower number than others previously seen, 900161537Smarcel reupdate the frame info. */ 901161537Smarcel if (fdata->saved_ev == -1 || fdata->saved_ev > ev_reg) 902161537Smarcel { 903161537Smarcel fdata->saved_ev = ev_reg; 904161537Smarcel fdata->ev_offset = ev_offset + offset; 905161537Smarcel } 906161537Smarcel 907161537Smarcel continue; 908161537Smarcel } 909161537Smarcel /* Store gen register S at (r31+r0). 910161537Smarcel Store param on stack when offset from SP bigger than 4 bytes. */ 911161537Smarcel /* 000100 sssss 11111 00000 01100100000 */ 912161537Smarcel else if (arch_info->mach == bfd_mach_ppc_e500 913161537Smarcel && (op & 0xfc1fffff) == 0x101f0320) /* evstddx Rs,R31,R0 */ 914161537Smarcel { 915161537Smarcel if (pc == (li_found_pc + 4)) 916161537Smarcel { 917161537Smarcel if ((op & 0x03e00000) >= 0x01a00000) 918161537Smarcel { 919161537Smarcel ev_reg = GET_SRC_REG (op); 920161537Smarcel /* If this is the first vector reg to be saved, or if 921161537Smarcel it has a lower number than others previously seen, 922161537Smarcel reupdate the frame info. */ 923161537Smarcel /* We know the contents of r0 from the previous 924161537Smarcel instruction. */ 925161537Smarcel if (fdata->saved_ev == -1 || fdata->saved_ev > ev_reg) 926161537Smarcel { 927161537Smarcel fdata->saved_ev = ev_reg; 928161537Smarcel fdata->ev_offset = vr_saved_offset + offset; 929161537Smarcel } 930161537Smarcel ev_reg = -1; 931161537Smarcel } 932161537Smarcel vr_saved_offset = -1; 933161537Smarcel li_found_pc = 0; 934161537Smarcel continue; 935161537Smarcel } 936161537Smarcel } 937161537Smarcel /* End BookE related instructions. */ 938161537Smarcel 939161537Smarcel else 940161537Smarcel { 941161537Smarcel /* Not a recognized prologue instruction. 942161537Smarcel Handle optimizer code motions into the prologue by continuing 943161537Smarcel the search if we have no valid frame yet or if the return 944161537Smarcel address is not yet saved in the frame. */ 945161537Smarcel if (fdata->frameless == 0 946161537Smarcel && (lr_reg == -1 || fdata->nosavedpc == 0)) 947161537Smarcel break; 948161537Smarcel 949161537Smarcel if (op == 0x4e800020 /* blr */ 950161537Smarcel || op == 0x4e800420) /* bctr */ 951161537Smarcel /* Do not scan past epilogue in frameless functions or 952161537Smarcel trampolines. */ 953161537Smarcel break; 954161537Smarcel if ((op & 0xf4000000) == 0x40000000) /* bxx */ 955161537Smarcel /* Never skip branches. */ 956161537Smarcel break; 957161537Smarcel 958161537Smarcel if (num_skip_non_prologue_insns++ > max_skip_non_prologue_insns) 959161537Smarcel /* Do not scan too many insns, scanning insns is expensive with 960161537Smarcel remote targets. */ 961161537Smarcel break; 962161537Smarcel 963161537Smarcel /* Continue scanning. */ 964161537Smarcel prev_insn_was_prologue_insn = 0; 965161537Smarcel continue; 966161537Smarcel } 967161537Smarcel } 968161537Smarcel 969161537Smarcel#if 0 970161537Smarcel/* I have problems with skipping over __main() that I need to address 971161537Smarcel * sometime. Previously, I used to use misc_function_vector which 972161537Smarcel * didn't work as well as I wanted to be. -MGO */ 973161537Smarcel 974161537Smarcel /* If the first thing after skipping a prolog is a branch to a function, 975161537Smarcel this might be a call to an initializer in main(), introduced by gcc2. 976161537Smarcel We'd like to skip over it as well. Fortunately, xlc does some extra 977161537Smarcel work before calling a function right after a prologue, thus we can 978161537Smarcel single out such gcc2 behaviour. */ 979161537Smarcel 980161537Smarcel 981161537Smarcel if ((op & 0xfc000001) == 0x48000001) 982161537Smarcel { /* bl foo, an initializer function? */ 983161537Smarcel op = read_memory_integer (pc + 4, 4); 984161537Smarcel 985161537Smarcel if (op == 0x4def7b82) 986161537Smarcel { /* cror 0xf, 0xf, 0xf (nop) */ 987161537Smarcel 988161537Smarcel /* Check and see if we are in main. If so, skip over this 989161537Smarcel initializer function as well. */ 990161537Smarcel 991161537Smarcel tmp = find_pc_misc_function (pc); 992161537Smarcel if (tmp >= 0 993161537Smarcel && strcmp (misc_function_vector[tmp].name, main_name ()) == 0) 994161537Smarcel return pc + 8; 995161537Smarcel } 996161537Smarcel } 997161537Smarcel#endif /* 0 */ 998161537Smarcel 999161537Smarcel fdata->offset = -fdata->offset; 1000161537Smarcel return last_prologue_pc; 1001161537Smarcel} 1002161537Smarcel 1003161537Smarcel 1004161537Smarcel/************************************************************************* 1005161537Smarcel Support for creating pushing a dummy frame into the stack, and popping 1006161537Smarcel frames, etc. 1007161537Smarcel*************************************************************************/ 1008161537Smarcel 1009161537Smarcel 1010161537Smarcel/* Pop the innermost frame, go back to the caller. */ 1011161537Smarcel 1012161537Smarcelstatic void 1013161537Smarcelrs6000_pop_frame (void) 1014161537Smarcel{ 1015161537Smarcel CORE_ADDR pc, lr, sp, prev_sp, addr; /* %pc, %lr, %sp */ 1016161537Smarcel struct rs6000_framedata fdata; 1017161537Smarcel struct frame_info *frame = get_current_frame (); 1018161537Smarcel int ii, wordsize; 1019161537Smarcel 1020161537Smarcel pc = read_pc (); 1021161537Smarcel sp = get_frame_base (frame); 1022161537Smarcel 1023161537Smarcel if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame), 1024161537Smarcel get_frame_base (frame), 1025161537Smarcel get_frame_base (frame))) 1026161537Smarcel { 1027161537Smarcel generic_pop_dummy_frame (); 1028161537Smarcel flush_cached_frames (); 1029161537Smarcel return; 1030161537Smarcel } 1031161537Smarcel 1032161537Smarcel /* Make sure that all registers are valid. */ 1033161537Smarcel deprecated_read_register_bytes (0, NULL, DEPRECATED_REGISTER_BYTES); 1034161537Smarcel 1035161537Smarcel /* Figure out previous %pc value. If the function is frameless, it is 1036161537Smarcel still in the link register, otherwise walk the frames and retrieve the 1037161537Smarcel saved %pc value in the previous frame. */ 1038161537Smarcel 1039161537Smarcel addr = get_frame_func (frame); 1040161537Smarcel (void) skip_prologue (addr, get_frame_pc (frame), &fdata); 1041161537Smarcel 1042161537Smarcel wordsize = gdbarch_tdep (current_gdbarch)->wordsize; 1043161537Smarcel if (fdata.frameless) 1044161537Smarcel prev_sp = sp; 1045161537Smarcel else 1046161537Smarcel prev_sp = read_memory_addr (sp, wordsize); 1047161537Smarcel if (fdata.lr_offset == 0) 1048161537Smarcel lr = read_register (gdbarch_tdep (current_gdbarch)->ppc_lr_regnum); 1049161537Smarcel else 1050161537Smarcel lr = read_memory_addr (prev_sp + fdata.lr_offset, wordsize); 1051161537Smarcel 1052161537Smarcel /* reset %pc value. */ 1053161537Smarcel write_register (PC_REGNUM, lr); 1054161537Smarcel 1055161537Smarcel /* reset register values if any was saved earlier. */ 1056161537Smarcel 1057161537Smarcel if (fdata.saved_gpr != -1) 1058161537Smarcel { 1059161537Smarcel addr = prev_sp + fdata.gpr_offset; 1060161537Smarcel for (ii = fdata.saved_gpr; ii <= 31; ++ii) 1061161537Smarcel { 1062161537Smarcel read_memory (addr, &deprecated_registers[DEPRECATED_REGISTER_BYTE (ii)], 1063161537Smarcel wordsize); 1064161537Smarcel addr += wordsize; 1065161537Smarcel } 1066161537Smarcel } 1067161537Smarcel 1068161537Smarcel if (fdata.saved_fpr != -1) 1069161537Smarcel { 1070161537Smarcel addr = prev_sp + fdata.fpr_offset; 1071161537Smarcel for (ii = fdata.saved_fpr; ii <= 31; ++ii) 1072161537Smarcel { 1073161537Smarcel read_memory (addr, &deprecated_registers[DEPRECATED_REGISTER_BYTE (ii + FP0_REGNUM)], 8); 1074161537Smarcel addr += 8; 1075161537Smarcel } 1076161537Smarcel } 1077161537Smarcel 1078161537Smarcel write_register (SP_REGNUM, prev_sp); 1079161537Smarcel target_store_registers (-1); 1080161537Smarcel flush_cached_frames (); 1081161537Smarcel} 1082161537Smarcel 1083161537Smarcel/* All the ABI's require 16 byte alignment. */ 1084161537Smarcelstatic CORE_ADDR 1085161537Smarcelrs6000_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr) 1086161537Smarcel{ 1087161537Smarcel return (addr & -16); 1088161537Smarcel} 1089161537Smarcel 1090161537Smarcel/* Pass the arguments in either registers, or in the stack. In RS/6000, 1091161537Smarcel the first eight words of the argument list (that might be less than 1092161537Smarcel eight parameters if some parameters occupy more than one word) are 1093161537Smarcel passed in r3..r10 registers. float and double parameters are 1094161537Smarcel passed in fpr's, in addition to that. Rest of the parameters if any 1095161537Smarcel are passed in user stack. There might be cases in which half of the 1096161537Smarcel parameter is copied into registers, the other half is pushed into 1097161537Smarcel stack. 1098161537Smarcel 1099161537Smarcel Stack must be aligned on 64-bit boundaries when synthesizing 1100161537Smarcel function calls. 1101161537Smarcel 1102161537Smarcel If the function is returning a structure, then the return address is passed 1103161537Smarcel in r3, then the first 7 words of the parameters can be passed in registers, 1104161537Smarcel starting from r4. */ 1105161537Smarcel 1106161537Smarcelstatic CORE_ADDR 1107161537Smarcelrs6000_push_dummy_call (struct gdbarch *gdbarch, CORE_ADDR func_addr, 1108161537Smarcel struct regcache *regcache, CORE_ADDR bp_addr, 1109161537Smarcel int nargs, struct value **args, CORE_ADDR sp, 1110161537Smarcel int struct_return, CORE_ADDR struct_addr) 1111161537Smarcel{ 1112161537Smarcel struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); 1113161537Smarcel int ii; 1114161537Smarcel int len = 0; 1115161537Smarcel int argno; /* current argument number */ 1116161537Smarcel int argbytes; /* current argument byte */ 1117161537Smarcel char tmp_buffer[50]; 1118161537Smarcel int f_argno = 0; /* current floating point argno */ 1119161537Smarcel int wordsize = gdbarch_tdep (current_gdbarch)->wordsize; 1120161537Smarcel 1121161537Smarcel struct value *arg = 0; 1122161537Smarcel struct type *type; 1123161537Smarcel 1124161537Smarcel CORE_ADDR saved_sp; 1125161537Smarcel 1126161537Smarcel /* The first eight words of ther arguments are passed in registers. 1127161537Smarcel Copy them appropriately. */ 1128161537Smarcel ii = 0; 1129161537Smarcel 1130161537Smarcel /* If the function is returning a `struct', then the first word 1131161537Smarcel (which will be passed in r3) is used for struct return address. 1132161537Smarcel In that case we should advance one word and start from r4 1133161537Smarcel register to copy parameters. */ 1134161537Smarcel if (struct_return) 1135161537Smarcel { 1136161537Smarcel regcache_raw_write_unsigned (regcache, tdep->ppc_gp0_regnum + 3, 1137161537Smarcel struct_addr); 1138161537Smarcel ii++; 1139161537Smarcel } 1140161537Smarcel 1141161537Smarcel/* 1142161537Smarcel effectively indirect call... gcc does... 1143161537Smarcel 1144161537Smarcel return_val example( float, int); 1145161537Smarcel 1146161537Smarcel eabi: 1147161537Smarcel float in fp0, int in r3 1148161537Smarcel offset of stack on overflow 8/16 1149161537Smarcel for varargs, must go by type. 1150161537Smarcel power open: 1151161537Smarcel float in r3&r4, int in r5 1152161537Smarcel offset of stack on overflow different 1153161537Smarcel both: 1154161537Smarcel return in r3 or f0. If no float, must study how gcc emulates floats; 1155161537Smarcel pay attention to arg promotion. 1156161537Smarcel User may have to cast\args to handle promotion correctly 1157161537Smarcel since gdb won't know if prototype supplied or not. 1158161537Smarcel */ 1159161537Smarcel 1160161537Smarcel for (argno = 0, argbytes = 0; argno < nargs && ii < 8; ++ii) 1161161537Smarcel { 1162161537Smarcel int reg_size = DEPRECATED_REGISTER_RAW_SIZE (ii + 3); 1163161537Smarcel 1164161537Smarcel arg = args[argno]; 1165161537Smarcel type = check_typedef (VALUE_TYPE (arg)); 1166161537Smarcel len = TYPE_LENGTH (type); 1167161537Smarcel 1168161537Smarcel if (TYPE_CODE (type) == TYPE_CODE_FLT) 1169161537Smarcel { 1170161537Smarcel 1171161537Smarcel /* Floating point arguments are passed in fpr's, as well as gpr's. 1172161537Smarcel There are 13 fpr's reserved for passing parameters. At this point 1173161537Smarcel there is no way we would run out of them. */ 1174161537Smarcel 1175161537Smarcel if (len > 8) 1176161537Smarcel printf_unfiltered ( 1177161537Smarcel "Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno); 1178161537Smarcel 1179161537Smarcel memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (FP0_REGNUM + 1 + f_argno)], 1180161537Smarcel VALUE_CONTENTS (arg), 1181161537Smarcel len); 1182161537Smarcel ++f_argno; 1183161537Smarcel } 1184161537Smarcel 1185161537Smarcel if (len > reg_size) 1186161537Smarcel { 1187161537Smarcel 1188161537Smarcel /* Argument takes more than one register. */ 1189161537Smarcel while (argbytes < len) 1190161537Smarcel { 1191161537Smarcel memset (&deprecated_registers[DEPRECATED_REGISTER_BYTE (ii + 3)], 0, 1192161537Smarcel reg_size); 1193161537Smarcel memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (ii + 3)], 1194161537Smarcel ((char *) VALUE_CONTENTS (arg)) + argbytes, 1195161537Smarcel (len - argbytes) > reg_size 1196161537Smarcel ? reg_size : len - argbytes); 1197161537Smarcel ++ii, argbytes += reg_size; 1198161537Smarcel 1199161537Smarcel if (ii >= 8) 1200161537Smarcel goto ran_out_of_registers_for_arguments; 1201161537Smarcel } 1202161537Smarcel argbytes = 0; 1203161537Smarcel --ii; 1204161537Smarcel } 1205161537Smarcel else 1206161537Smarcel { 1207161537Smarcel /* Argument can fit in one register. No problem. */ 1208161537Smarcel int adj = TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? reg_size - len : 0; 1209161537Smarcel memset (&deprecated_registers[DEPRECATED_REGISTER_BYTE (ii + 3)], 0, reg_size); 1210161537Smarcel memcpy ((char *)&deprecated_registers[DEPRECATED_REGISTER_BYTE (ii + 3)] + adj, 1211161537Smarcel VALUE_CONTENTS (arg), len); 1212161537Smarcel } 1213161537Smarcel ++argno; 1214161537Smarcel } 1215161537Smarcel 1216161537Smarcelran_out_of_registers_for_arguments: 1217161537Smarcel 1218161537Smarcel saved_sp = read_sp (); 1219161537Smarcel 1220161537Smarcel /* Location for 8 parameters are always reserved. */ 1221161537Smarcel sp -= wordsize * 8; 1222161537Smarcel 1223161537Smarcel /* Another six words for back chain, TOC register, link register, etc. */ 1224161537Smarcel sp -= wordsize * 6; 1225161537Smarcel 1226161537Smarcel /* Stack pointer must be quadword aligned. */ 1227161537Smarcel sp &= -16; 1228161537Smarcel 1229161537Smarcel /* If there are more arguments, allocate space for them in 1230161537Smarcel the stack, then push them starting from the ninth one. */ 1231161537Smarcel 1232161537Smarcel if ((argno < nargs) || argbytes) 1233161537Smarcel { 1234161537Smarcel int space = 0, jj; 1235161537Smarcel 1236161537Smarcel if (argbytes) 1237161537Smarcel { 1238161537Smarcel space += ((len - argbytes + 3) & -4); 1239161537Smarcel jj = argno + 1; 1240161537Smarcel } 1241161537Smarcel else 1242161537Smarcel jj = argno; 1243161537Smarcel 1244161537Smarcel for (; jj < nargs; ++jj) 1245161537Smarcel { 1246161537Smarcel struct value *val = args[jj]; 1247161537Smarcel space += ((TYPE_LENGTH (VALUE_TYPE (val))) + 3) & -4; 1248161537Smarcel } 1249161537Smarcel 1250161537Smarcel /* Add location required for the rest of the parameters. */ 1251161537Smarcel space = (space + 15) & -16; 1252161537Smarcel sp -= space; 1253161537Smarcel 1254161537Smarcel /* This is another instance we need to be concerned about 1255161537Smarcel securing our stack space. If we write anything underneath %sp 1256161537Smarcel (r1), we might conflict with the kernel who thinks he is free 1257161537Smarcel to use this area. So, update %sp first before doing anything 1258161537Smarcel else. */ 1259161537Smarcel 1260161537Smarcel regcache_raw_write_signed (regcache, SP_REGNUM, sp); 1261161537Smarcel 1262161537Smarcel /* If the last argument copied into the registers didn't fit there 1263161537Smarcel completely, push the rest of it into stack. */ 1264161537Smarcel 1265161537Smarcel if (argbytes) 1266161537Smarcel { 1267161537Smarcel write_memory (sp + 24 + (ii * 4), 1268161537Smarcel ((char *) VALUE_CONTENTS (arg)) + argbytes, 1269161537Smarcel len - argbytes); 1270161537Smarcel ++argno; 1271161537Smarcel ii += ((len - argbytes + 3) & -4) / 4; 1272161537Smarcel } 1273161537Smarcel 1274161537Smarcel /* Push the rest of the arguments into stack. */ 1275161537Smarcel for (; argno < nargs; ++argno) 1276161537Smarcel { 1277161537Smarcel 1278161537Smarcel arg = args[argno]; 1279161537Smarcel type = check_typedef (VALUE_TYPE (arg)); 1280161537Smarcel len = TYPE_LENGTH (type); 1281161537Smarcel 1282161537Smarcel 1283161537Smarcel /* Float types should be passed in fpr's, as well as in the 1284161537Smarcel stack. */ 1285161537Smarcel if (TYPE_CODE (type) == TYPE_CODE_FLT && f_argno < 13) 1286161537Smarcel { 1287161537Smarcel 1288161537Smarcel if (len > 8) 1289161537Smarcel printf_unfiltered ( 1290161537Smarcel "Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno); 1291161537Smarcel 1292161537Smarcel memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (FP0_REGNUM + 1 + f_argno)], 1293161537Smarcel VALUE_CONTENTS (arg), 1294161537Smarcel len); 1295161537Smarcel ++f_argno; 1296161537Smarcel } 1297161537Smarcel 1298161537Smarcel write_memory (sp + 24 + (ii * 4), (char *) VALUE_CONTENTS (arg), len); 1299161537Smarcel ii += ((len + 3) & -4) / 4; 1300161537Smarcel } 1301161537Smarcel } 1302161537Smarcel 1303161537Smarcel /* Set the stack pointer. According to the ABI, the SP is meant to 1304161537Smarcel be set _before_ the corresponding stack space is used. On AIX, 1305161537Smarcel this even applies when the target has been completely stopped! 1306161537Smarcel Not doing this can lead to conflicts with the kernel which thinks 1307161537Smarcel that it still has control over this not-yet-allocated stack 1308161537Smarcel region. */ 1309161537Smarcel regcache_raw_write_signed (regcache, SP_REGNUM, sp); 1310161537Smarcel 1311161537Smarcel /* Set back chain properly. */ 1312161537Smarcel store_unsigned_integer (tmp_buffer, 4, saved_sp); 1313161537Smarcel write_memory (sp, tmp_buffer, 4); 1314161537Smarcel 1315161537Smarcel /* Point the inferior function call's return address at the dummy's 1316161537Smarcel breakpoint. */ 1317161537Smarcel regcache_raw_write_signed (regcache, tdep->ppc_lr_regnum, bp_addr); 1318161537Smarcel 1319161537Smarcel /* Set the TOC register, get the value from the objfile reader 1320161537Smarcel which, in turn, gets it from the VMAP table. */ 1321161537Smarcel if (rs6000_find_toc_address_hook != NULL) 1322161537Smarcel { 1323161537Smarcel CORE_ADDR tocvalue = (*rs6000_find_toc_address_hook) (func_addr); 1324161537Smarcel regcache_raw_write_signed (regcache, tdep->ppc_toc_regnum, tocvalue); 1325161537Smarcel } 1326161537Smarcel 1327161537Smarcel target_store_registers (-1); 1328161537Smarcel return sp; 1329161537Smarcel} 1330161537Smarcel 1331161537Smarcel/* PowerOpen always puts structures in memory. Vectors, which were 1332161537Smarcel added later, do get returned in a register though. */ 1333161537Smarcel 1334161537Smarcelstatic int 1335161537Smarcelrs6000_use_struct_convention (int gcc_p, struct type *value_type) 1336161537Smarcel{ 1337161537Smarcel if ((TYPE_LENGTH (value_type) == 16 || TYPE_LENGTH (value_type) == 8) 1338161537Smarcel && TYPE_VECTOR (value_type)) 1339161537Smarcel return 0; 1340161537Smarcel return 1; 1341161537Smarcel} 1342161537Smarcel 1343161537Smarcelstatic void 1344161537Smarcelrs6000_extract_return_value (struct type *valtype, char *regbuf, char *valbuf) 1345161537Smarcel{ 1346161537Smarcel int offset = 0; 1347161537Smarcel struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); 1348161537Smarcel 1349161537Smarcel if (TYPE_CODE (valtype) == TYPE_CODE_FLT) 1350161537Smarcel { 1351161537Smarcel 1352161537Smarcel double dd; 1353161537Smarcel float ff; 1354161537Smarcel /* floats and doubles are returned in fpr1. fpr's have a size of 8 bytes. 1355161537Smarcel We need to truncate the return value into float size (4 byte) if 1356161537Smarcel necessary. */ 1357161537Smarcel 1358161537Smarcel if (TYPE_LENGTH (valtype) > 4) /* this is a double */ 1359161537Smarcel memcpy (valbuf, 1360161537Smarcel ®buf[DEPRECATED_REGISTER_BYTE (FP0_REGNUM + 1)], 1361161537Smarcel TYPE_LENGTH (valtype)); 1362161537Smarcel else 1363161537Smarcel { /* float */ 1364161537Smarcel memcpy (&dd, ®buf[DEPRECATED_REGISTER_BYTE (FP0_REGNUM + 1)], 8); 1365161537Smarcel ff = (float) dd; 1366161537Smarcel memcpy (valbuf, &ff, sizeof (float)); 1367161537Smarcel } 1368161537Smarcel } 1369161537Smarcel else if (TYPE_CODE (valtype) == TYPE_CODE_ARRAY 1370161537Smarcel && TYPE_LENGTH (valtype) == 16 1371161537Smarcel && TYPE_VECTOR (valtype)) 1372161537Smarcel { 1373161537Smarcel memcpy (valbuf, regbuf + DEPRECATED_REGISTER_BYTE (tdep->ppc_vr0_regnum + 2), 1374161537Smarcel TYPE_LENGTH (valtype)); 1375161537Smarcel } 1376161537Smarcel else 1377161537Smarcel { 1378161537Smarcel /* return value is copied starting from r3. */ 1379161537Smarcel if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG 1380161537Smarcel && TYPE_LENGTH (valtype) < DEPRECATED_REGISTER_RAW_SIZE (3)) 1381161537Smarcel offset = DEPRECATED_REGISTER_RAW_SIZE (3) - TYPE_LENGTH (valtype); 1382161537Smarcel 1383161537Smarcel memcpy (valbuf, 1384161537Smarcel regbuf + DEPRECATED_REGISTER_BYTE (3) + offset, 1385161537Smarcel TYPE_LENGTH (valtype)); 1386161537Smarcel } 1387161537Smarcel} 1388161537Smarcel 1389161537Smarcel/* Return whether handle_inferior_event() should proceed through code 1390161537Smarcel starting at PC in function NAME when stepping. 1391161537Smarcel 1392161537Smarcel The AIX -bbigtoc linker option generates functions @FIX0, @FIX1, etc. to 1393161537Smarcel handle memory references that are too distant to fit in instructions 1394161537Smarcel generated by the compiler. For example, if 'foo' in the following 1395161537Smarcel instruction: 1396161537Smarcel 1397161537Smarcel lwz r9,foo(r2) 1398161537Smarcel 1399161537Smarcel is greater than 32767, the linker might replace the lwz with a branch to 1400161537Smarcel somewhere in @FIX1 that does the load in 2 instructions and then branches 1401161537Smarcel back to where execution should continue. 1402161537Smarcel 1403161537Smarcel GDB should silently step over @FIX code, just like AIX dbx does. 1404161537Smarcel Unfortunately, the linker uses the "b" instruction for the branches, 1405161537Smarcel meaning that the link register doesn't get set. Therefore, GDB's usual 1406161537Smarcel step_over_function() mechanism won't work. 1407161537Smarcel 1408161537Smarcel Instead, use the IN_SOLIB_RETURN_TRAMPOLINE and SKIP_TRAMPOLINE_CODE hooks 1409161537Smarcel in handle_inferior_event() to skip past @FIX code. */ 1410161537Smarcel 1411161537Smarcelint 1412161537Smarcelrs6000_in_solib_return_trampoline (CORE_ADDR pc, char *name) 1413161537Smarcel{ 1414161537Smarcel return name && !strncmp (name, "@FIX", 4); 1415161537Smarcel} 1416161537Smarcel 1417161537Smarcel/* Skip code that the user doesn't want to see when stepping: 1418161537Smarcel 1419161537Smarcel 1. Indirect function calls use a piece of trampoline code to do context 1420161537Smarcel switching, i.e. to set the new TOC table. Skip such code if we are on 1421161537Smarcel its first instruction (as when we have single-stepped to here). 1422161537Smarcel 1423161537Smarcel 2. Skip shared library trampoline code (which is different from 1424161537Smarcel indirect function call trampolines). 1425161537Smarcel 1426161537Smarcel 3. Skip bigtoc fixup code. 1427161537Smarcel 1428161537Smarcel Result is desired PC to step until, or NULL if we are not in 1429161537Smarcel code that should be skipped. */ 1430161537Smarcel 1431161537SmarcelCORE_ADDR 1432161537Smarcelrs6000_skip_trampoline_code (CORE_ADDR pc) 1433161537Smarcel{ 1434161537Smarcel unsigned int ii, op; 1435161537Smarcel int rel; 1436161537Smarcel CORE_ADDR solib_target_pc; 1437161537Smarcel struct minimal_symbol *msymbol; 1438161537Smarcel 1439161537Smarcel static unsigned trampoline_code[] = 1440161537Smarcel { 1441161537Smarcel 0x800b0000, /* l r0,0x0(r11) */ 1442161537Smarcel 0x90410014, /* st r2,0x14(r1) */ 1443161537Smarcel 0x7c0903a6, /* mtctr r0 */ 1444161537Smarcel 0x804b0004, /* l r2,0x4(r11) */ 1445161537Smarcel 0x816b0008, /* l r11,0x8(r11) */ 1446161537Smarcel 0x4e800420, /* bctr */ 1447161537Smarcel 0x4e800020, /* br */ 1448161537Smarcel 0 1449161537Smarcel }; 1450161537Smarcel 1451161537Smarcel /* Check for bigtoc fixup code. */ 1452161537Smarcel msymbol = lookup_minimal_symbol_by_pc (pc); 1453161537Smarcel if (msymbol && rs6000_in_solib_return_trampoline (pc, DEPRECATED_SYMBOL_NAME (msymbol))) 1454161537Smarcel { 1455161537Smarcel /* Double-check that the third instruction from PC is relative "b". */ 1456161537Smarcel op = read_memory_integer (pc + 8, 4); 1457161537Smarcel if ((op & 0xfc000003) == 0x48000000) 1458161537Smarcel { 1459161537Smarcel /* Extract bits 6-29 as a signed 24-bit relative word address and 1460161537Smarcel add it to the containing PC. */ 1461161537Smarcel rel = ((int)(op << 6) >> 6); 1462161537Smarcel return pc + 8 + rel; 1463161537Smarcel } 1464161537Smarcel } 1465161537Smarcel 1466161537Smarcel /* If pc is in a shared library trampoline, return its target. */ 1467161537Smarcel solib_target_pc = find_solib_trampoline_target (pc); 1468161537Smarcel if (solib_target_pc) 1469161537Smarcel return solib_target_pc; 1470161537Smarcel 1471161537Smarcel for (ii = 0; trampoline_code[ii]; ++ii) 1472161537Smarcel { 1473161537Smarcel op = read_memory_integer (pc + (ii * 4), 4); 1474161537Smarcel if (op != trampoline_code[ii]) 1475161537Smarcel return 0; 1476161537Smarcel } 1477161537Smarcel ii = read_register (11); /* r11 holds destination addr */ 1478161537Smarcel pc = read_memory_addr (ii, gdbarch_tdep (current_gdbarch)->wordsize); /* (r11) value */ 1479161537Smarcel return pc; 1480161537Smarcel} 1481161537Smarcel 1482161537Smarcel/* Determines whether the function FI has a frame on the stack or not. */ 1483161537Smarcel 1484161537Smarcelint 1485161537Smarcelrs6000_frameless_function_invocation (struct frame_info *fi) 1486161537Smarcel{ 1487161537Smarcel CORE_ADDR func_start; 1488161537Smarcel struct rs6000_framedata fdata; 1489161537Smarcel 1490161537Smarcel /* Don't even think about framelessness except on the innermost frame 1491161537Smarcel or if the function was interrupted by a signal. */ 1492161537Smarcel if (get_next_frame (fi) != NULL 1493161537Smarcel && !(get_frame_type (get_next_frame (fi)) == SIGTRAMP_FRAME)) 1494161537Smarcel return 0; 1495161537Smarcel 1496161537Smarcel func_start = get_frame_func (fi); 1497161537Smarcel 1498161537Smarcel /* If we failed to find the start of the function, it is a mistake 1499161537Smarcel to inspect the instructions. */ 1500161537Smarcel 1501161537Smarcel if (!func_start) 1502161537Smarcel { 1503161537Smarcel /* A frame with a zero PC is usually created by dereferencing a NULL 1504161537Smarcel function pointer, normally causing an immediate core dump of the 1505161537Smarcel inferior. Mark function as frameless, as the inferior has no chance 1506161537Smarcel of setting up a stack frame. */ 1507161537Smarcel if (get_frame_pc (fi) == 0) 1508161537Smarcel return 1; 1509161537Smarcel else 1510161537Smarcel return 0; 1511161537Smarcel } 1512161537Smarcel 1513161537Smarcel (void) skip_prologue (func_start, get_frame_pc (fi), &fdata); 1514161537Smarcel return fdata.frameless; 1515161537Smarcel} 1516161537Smarcel 1517161537Smarcel/* Return the PC saved in a frame. */ 1518161537Smarcel 1519161537SmarcelCORE_ADDR 1520161537Smarcelrs6000_frame_saved_pc (struct frame_info *fi) 1521161537Smarcel{ 1522161537Smarcel CORE_ADDR func_start; 1523161537Smarcel struct rs6000_framedata fdata; 1524161537Smarcel struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); 1525161537Smarcel int wordsize = tdep->wordsize; 1526161537Smarcel 1527161537Smarcel if ((get_frame_type (fi) == SIGTRAMP_FRAME)) 1528161537Smarcel return read_memory_addr (get_frame_base (fi) + SIG_FRAME_PC_OFFSET, 1529161537Smarcel wordsize); 1530161537Smarcel 1531161537Smarcel if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), 1532161537Smarcel get_frame_base (fi), 1533161537Smarcel get_frame_base (fi))) 1534161537Smarcel return deprecated_read_register_dummy (get_frame_pc (fi), 1535161537Smarcel get_frame_base (fi), PC_REGNUM); 1536161537Smarcel 1537161537Smarcel func_start = get_frame_func (fi); 1538161537Smarcel 1539161537Smarcel /* If we failed to find the start of the function, it is a mistake 1540161537Smarcel to inspect the instructions. */ 1541161537Smarcel if (!func_start) 1542161537Smarcel return 0; 1543161537Smarcel 1544161537Smarcel (void) skip_prologue (func_start, get_frame_pc (fi), &fdata); 1545161537Smarcel 1546161537Smarcel if (fdata.lr_offset == 0 && get_next_frame (fi) != NULL) 1547161537Smarcel { 1548161537Smarcel if ((get_frame_type (get_next_frame (fi)) == SIGTRAMP_FRAME)) 1549161537Smarcel return read_memory_addr ((get_frame_base (get_next_frame (fi)) 1550161537Smarcel + SIG_FRAME_LR_OFFSET), 1551161537Smarcel wordsize); 1552161537Smarcel else if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (get_next_frame (fi)), 0, 0)) 1553161537Smarcel /* The link register wasn't saved by this frame and the next 1554161537Smarcel (inner, newer) frame is a dummy. Get the link register 1555161537Smarcel value by unwinding it from that [dummy] frame. */ 1556161537Smarcel { 1557161537Smarcel ULONGEST lr; 1558161537Smarcel frame_unwind_unsigned_register (get_next_frame (fi), 1559161537Smarcel tdep->ppc_lr_regnum, &lr); 1560161537Smarcel return lr; 1561161537Smarcel } 1562161537Smarcel else 1563161537Smarcel return read_memory_addr (DEPRECATED_FRAME_CHAIN (fi) 1564161537Smarcel + tdep->lr_frame_offset, 1565161537Smarcel wordsize); 1566161537Smarcel } 1567161537Smarcel 1568161537Smarcel if (fdata.lr_offset == 0) 1569161537Smarcel return read_register (gdbarch_tdep (current_gdbarch)->ppc_lr_regnum); 1570161537Smarcel 1571161537Smarcel return read_memory_addr (DEPRECATED_FRAME_CHAIN (fi) + fdata.lr_offset, 1572161537Smarcel wordsize); 1573161537Smarcel} 1574161537Smarcel 1575161537Smarcel/* If saved registers of frame FI are not known yet, read and cache them. 1576161537Smarcel &FDATAP contains rs6000_framedata; TDATAP can be NULL, 1577161537Smarcel in which case the framedata are read. */ 1578161537Smarcel 1579161537Smarcelstatic void 1580161537Smarcelframe_get_saved_regs (struct frame_info *fi, struct rs6000_framedata *fdatap) 1581161537Smarcel{ 1582161537Smarcel CORE_ADDR frame_addr; 1583161537Smarcel struct rs6000_framedata work_fdata; 1584161537Smarcel struct gdbarch_tdep * tdep = gdbarch_tdep (current_gdbarch); 1585161537Smarcel int wordsize = tdep->wordsize; 1586161537Smarcel 1587161537Smarcel if (deprecated_get_frame_saved_regs (fi)) 1588161537Smarcel return; 1589161537Smarcel 1590161537Smarcel if (fdatap == NULL) 1591161537Smarcel { 1592161537Smarcel fdatap = &work_fdata; 1593161537Smarcel (void) skip_prologue (get_frame_func (fi), get_frame_pc (fi), fdatap); 1594161537Smarcel } 1595161537Smarcel 1596161537Smarcel frame_saved_regs_zalloc (fi); 1597161537Smarcel 1598161537Smarcel /* If there were any saved registers, figure out parent's stack 1599161537Smarcel pointer. */ 1600161537Smarcel /* The following is true only if the frame doesn't have a call to 1601161537Smarcel alloca(), FIXME. */ 1602161537Smarcel 1603161537Smarcel if (fdatap->saved_fpr == 0 1604161537Smarcel && fdatap->saved_gpr == 0 1605161537Smarcel && fdatap->saved_vr == 0 1606161537Smarcel && fdatap->saved_ev == 0 1607161537Smarcel && fdatap->lr_offset == 0 1608161537Smarcel && fdatap->cr_offset == 0 1609161537Smarcel && fdatap->vr_offset == 0 1610161537Smarcel && fdatap->ev_offset == 0) 1611161537Smarcel frame_addr = 0; 1612161537Smarcel else 1613161537Smarcel /* NOTE: cagney/2002-04-14: The ->frame points to the inner-most 1614161537Smarcel address of the current frame. Things might be easier if the 1615161537Smarcel ->frame pointed to the outer-most address of the frame. In the 1616161537Smarcel mean time, the address of the prev frame is used as the base 1617161537Smarcel address of this frame. */ 1618161537Smarcel frame_addr = DEPRECATED_FRAME_CHAIN (fi); 1619161537Smarcel 1620161537Smarcel /* if != -1, fdatap->saved_fpr is the smallest number of saved_fpr. 1621161537Smarcel All fpr's from saved_fpr to fp31 are saved. */ 1622161537Smarcel 1623161537Smarcel if (fdatap->saved_fpr >= 0) 1624161537Smarcel { 1625161537Smarcel int i; 1626161537Smarcel CORE_ADDR fpr_addr = frame_addr + fdatap->fpr_offset; 1627161537Smarcel for (i = fdatap->saved_fpr; i < 32; i++) 1628161537Smarcel { 1629161537Smarcel deprecated_get_frame_saved_regs (fi)[FP0_REGNUM + i] = fpr_addr; 1630161537Smarcel fpr_addr += 8; 1631161537Smarcel } 1632161537Smarcel } 1633161537Smarcel 1634161537Smarcel /* if != -1, fdatap->saved_gpr is the smallest number of saved_gpr. 1635161537Smarcel All gpr's from saved_gpr to gpr31 are saved. */ 1636161537Smarcel 1637161537Smarcel if (fdatap->saved_gpr >= 0) 1638161537Smarcel { 1639161537Smarcel int i; 1640161537Smarcel CORE_ADDR gpr_addr = frame_addr + fdatap->gpr_offset; 1641161537Smarcel for (i = fdatap->saved_gpr; i < 32; i++) 1642161537Smarcel { 1643161537Smarcel deprecated_get_frame_saved_regs (fi)[tdep->ppc_gp0_regnum + i] = gpr_addr; 1644161537Smarcel gpr_addr += wordsize; 1645161537Smarcel } 1646161537Smarcel } 1647161537Smarcel 1648161537Smarcel /* if != -1, fdatap->saved_vr is the smallest number of saved_vr. 1649161537Smarcel All vr's from saved_vr to vr31 are saved. */ 1650161537Smarcel if (tdep->ppc_vr0_regnum != -1 && tdep->ppc_vrsave_regnum != -1) 1651161537Smarcel { 1652161537Smarcel if (fdatap->saved_vr >= 0) 1653161537Smarcel { 1654161537Smarcel int i; 1655161537Smarcel CORE_ADDR vr_addr = frame_addr + fdatap->vr_offset; 1656161537Smarcel for (i = fdatap->saved_vr; i < 32; i++) 1657161537Smarcel { 1658161537Smarcel deprecated_get_frame_saved_regs (fi)[tdep->ppc_vr0_regnum + i] = vr_addr; 1659161537Smarcel vr_addr += DEPRECATED_REGISTER_RAW_SIZE (tdep->ppc_vr0_regnum); 1660161537Smarcel } 1661161537Smarcel } 1662161537Smarcel } 1663161537Smarcel 1664161537Smarcel /* if != -1, fdatap->saved_ev is the smallest number of saved_ev. 1665161537Smarcel All vr's from saved_ev to ev31 are saved. ????? */ 1666161537Smarcel if (tdep->ppc_ev0_regnum != -1 && tdep->ppc_ev31_regnum != -1) 1667161537Smarcel { 1668161537Smarcel if (fdatap->saved_ev >= 0) 1669161537Smarcel { 1670161537Smarcel int i; 1671161537Smarcel CORE_ADDR ev_addr = frame_addr + fdatap->ev_offset; 1672161537Smarcel for (i = fdatap->saved_ev; i < 32; i++) 1673161537Smarcel { 1674161537Smarcel deprecated_get_frame_saved_regs (fi)[tdep->ppc_ev0_regnum + i] = ev_addr; 1675161537Smarcel deprecated_get_frame_saved_regs (fi)[tdep->ppc_gp0_regnum + i] = ev_addr + 4; 1676161537Smarcel ev_addr += DEPRECATED_REGISTER_RAW_SIZE (tdep->ppc_ev0_regnum); 1677161537Smarcel } 1678161537Smarcel } 1679161537Smarcel } 1680161537Smarcel 1681161537Smarcel /* If != 0, fdatap->cr_offset is the offset from the frame that holds 1682161537Smarcel the CR. */ 1683161537Smarcel if (fdatap->cr_offset != 0) 1684161537Smarcel deprecated_get_frame_saved_regs (fi)[tdep->ppc_cr_regnum] = frame_addr + fdatap->cr_offset; 1685161537Smarcel 1686161537Smarcel /* If != 0, fdatap->lr_offset is the offset from the frame that holds 1687161537Smarcel the LR. */ 1688161537Smarcel if (fdatap->lr_offset != 0) 1689161537Smarcel deprecated_get_frame_saved_regs (fi)[tdep->ppc_lr_regnum] = frame_addr + fdatap->lr_offset; 1690161537Smarcel 1691161537Smarcel /* If != 0, fdatap->vrsave_offset is the offset from the frame that holds 1692161537Smarcel the VRSAVE. */ 1693161537Smarcel if (fdatap->vrsave_offset != 0) 1694161537Smarcel deprecated_get_frame_saved_regs (fi)[tdep->ppc_vrsave_regnum] = frame_addr + fdatap->vrsave_offset; 1695161537Smarcel} 1696161537Smarcel 1697161537Smarcel/* Return the address of a frame. This is the inital %sp value when the frame 1698161537Smarcel was first allocated. For functions calling alloca(), it might be saved in 1699161537Smarcel an alloca register. */ 1700161537Smarcel 1701161537Smarcelstatic CORE_ADDR 1702161537Smarcelframe_initial_stack_address (struct frame_info *fi) 1703161537Smarcel{ 1704161537Smarcel CORE_ADDR tmpaddr; 1705161537Smarcel struct rs6000_framedata fdata; 1706161537Smarcel struct frame_info *callee_fi; 1707161537Smarcel 1708161537Smarcel /* If the initial stack pointer (frame address) of this frame is known, 1709161537Smarcel just return it. */ 1710161537Smarcel 1711161537Smarcel if (get_frame_extra_info (fi)->initial_sp) 1712161537Smarcel return get_frame_extra_info (fi)->initial_sp; 1713161537Smarcel 1714161537Smarcel /* Find out if this function is using an alloca register. */ 1715161537Smarcel 1716161537Smarcel (void) skip_prologue (get_frame_func (fi), get_frame_pc (fi), &fdata); 1717161537Smarcel 1718161537Smarcel /* If saved registers of this frame are not known yet, read and 1719161537Smarcel cache them. */ 1720161537Smarcel 1721161537Smarcel if (!deprecated_get_frame_saved_regs (fi)) 1722161537Smarcel frame_get_saved_regs (fi, &fdata); 1723161537Smarcel 1724161537Smarcel /* If no alloca register used, then fi->frame is the value of the %sp for 1725161537Smarcel this frame, and it is good enough. */ 1726161537Smarcel 1727161537Smarcel if (fdata.alloca_reg < 0) 1728161537Smarcel { 1729161537Smarcel get_frame_extra_info (fi)->initial_sp = get_frame_base (fi); 1730161537Smarcel return get_frame_extra_info (fi)->initial_sp; 1731161537Smarcel } 1732161537Smarcel 1733161537Smarcel /* There is an alloca register, use its value, in the current frame, 1734161537Smarcel as the initial stack pointer. */ 1735161537Smarcel { 1736161537Smarcel char tmpbuf[MAX_REGISTER_SIZE]; 1737161537Smarcel if (frame_register_read (fi, fdata.alloca_reg, tmpbuf)) 1738161537Smarcel { 1739161537Smarcel get_frame_extra_info (fi)->initial_sp 1740161537Smarcel = extract_unsigned_integer (tmpbuf, 1741161537Smarcel DEPRECATED_REGISTER_RAW_SIZE (fdata.alloca_reg)); 1742161537Smarcel } 1743161537Smarcel else 1744161537Smarcel /* NOTE: cagney/2002-04-17: At present the only time 1745161537Smarcel frame_register_read will fail is when the register isn't 1746161537Smarcel available. If that does happen, use the frame. */ 1747161537Smarcel get_frame_extra_info (fi)->initial_sp = get_frame_base (fi); 1748161537Smarcel } 1749161537Smarcel return get_frame_extra_info (fi)->initial_sp; 1750161537Smarcel} 1751161537Smarcel 1752161537Smarcel/* Describe the pointer in each stack frame to the previous stack frame 1753161537Smarcel (its caller). */ 1754161537Smarcel 1755161537Smarcel/* DEPRECATED_FRAME_CHAIN takes a frame's nominal address and produces 1756161537Smarcel the frame's chain-pointer. */ 1757161537Smarcel 1758161537Smarcel/* In the case of the RS/6000, the frame's nominal address 1759161537Smarcel is the address of a 4-byte word containing the calling frame's address. */ 1760161537Smarcel 1761161537SmarcelCORE_ADDR 1762161537Smarcelrs6000_frame_chain (struct frame_info *thisframe) 1763161537Smarcel{ 1764161537Smarcel CORE_ADDR fp, fpp, lr; 1765161537Smarcel int wordsize = gdbarch_tdep (current_gdbarch)->wordsize; 1766161537Smarcel 1767161537Smarcel if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (thisframe), 1768161537Smarcel get_frame_base (thisframe), 1769161537Smarcel get_frame_base (thisframe))) 1770161537Smarcel /* A dummy frame always correctly chains back to the previous 1771161537Smarcel frame. */ 1772161537Smarcel return read_memory_addr (get_frame_base (thisframe), wordsize); 1773161537Smarcel 1774161537Smarcel if (deprecated_inside_entry_file (get_frame_pc (thisframe)) 1775161537Smarcel || get_frame_pc (thisframe) == entry_point_address ()) 1776161537Smarcel return 0; 1777161537Smarcel 1778161537Smarcel if ((get_frame_type (thisframe) == SIGTRAMP_FRAME)) 1779161537Smarcel fp = read_memory_addr (get_frame_base (thisframe) + SIG_FRAME_FP_OFFSET, 1780161537Smarcel wordsize); 1781161537Smarcel else if (get_next_frame (thisframe) != NULL 1782161537Smarcel && (get_frame_type (get_next_frame (thisframe)) == SIGTRAMP_FRAME) 1783161537Smarcel && (DEPRECATED_FRAMELESS_FUNCTION_INVOCATION_P () 1784161537Smarcel && DEPRECATED_FRAMELESS_FUNCTION_INVOCATION (thisframe))) 1785161537Smarcel /* A frameless function interrupted by a signal did not change the 1786161537Smarcel frame pointer. */ 1787161537Smarcel fp = get_frame_base (thisframe); 1788161537Smarcel else 1789161537Smarcel fp = read_memory_addr (get_frame_base (thisframe), wordsize); 1790161537Smarcel return fp; 1791161537Smarcel} 1792161537Smarcel 1793161537Smarcel/* Return the size of register REG when words are WORDSIZE bytes long. If REG 1794161537Smarcel isn't available with that word size, return 0. */ 1795161537Smarcel 1796161537Smarcelstatic int 1797161537Smarcelregsize (const struct reg *reg, int wordsize) 1798161537Smarcel{ 1799161537Smarcel return wordsize == 8 ? reg->sz64 : reg->sz32; 1800161537Smarcel} 1801161537Smarcel 1802161537Smarcel/* Return the name of register number N, or null if no such register exists 1803161537Smarcel in the current architecture. */ 1804161537Smarcel 1805161537Smarcelstatic const char * 1806161537Smarcelrs6000_register_name (int n) 1807161537Smarcel{ 1808161537Smarcel struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); 1809161537Smarcel const struct reg *reg = tdep->regs + n; 1810161537Smarcel 1811161537Smarcel if (!regsize (reg, tdep->wordsize)) 1812161537Smarcel return NULL; 1813161537Smarcel return reg->name; 1814161537Smarcel} 1815161537Smarcel 1816161537Smarcel/* Index within `registers' of the first byte of the space for 1817161537Smarcel register N. */ 1818161537Smarcel 1819161537Smarcelstatic int 1820161537Smarcelrs6000_register_byte (int n) 1821161537Smarcel{ 1822161537Smarcel return gdbarch_tdep (current_gdbarch)->regoff[n]; 1823161537Smarcel} 1824161537Smarcel 1825161537Smarcel/* Return the number of bytes of storage in the actual machine representation 1826161537Smarcel for register N if that register is available, else return 0. */ 1827161537Smarcel 1828161537Smarcelstatic int 1829161537Smarcelrs6000_register_raw_size (int n) 1830161537Smarcel{ 1831161537Smarcel struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); 1832161537Smarcel const struct reg *reg = tdep->regs + n; 1833161537Smarcel return regsize (reg, tdep->wordsize); 1834161537Smarcel} 1835161537Smarcel 1836161537Smarcel/* Return the GDB type object for the "standard" data type 1837161537Smarcel of data in register N. */ 1838161537Smarcel 1839161537Smarcelstatic struct type * 1840161537Smarcelrs6000_register_virtual_type (int n) 1841161537Smarcel{ 1842161537Smarcel struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); 1843161537Smarcel const struct reg *reg = tdep->regs + n; 1844161537Smarcel 1845161537Smarcel if (reg->fpr) 1846161537Smarcel return builtin_type_double; 1847161537Smarcel else 1848161537Smarcel { 1849161537Smarcel int size = regsize (reg, tdep->wordsize); 1850161537Smarcel switch (size) 1851161537Smarcel { 1852161537Smarcel case 0: 1853161537Smarcel return builtin_type_int0; 1854161537Smarcel case 4: 1855161537Smarcel return builtin_type_int32; 1856161537Smarcel case 8: 1857161537Smarcel if (tdep->ppc_ev0_regnum <= n && n <= tdep->ppc_ev31_regnum) 1858161537Smarcel return builtin_type_vec64; 1859161537Smarcel else 1860161537Smarcel return builtin_type_int64; 1861161537Smarcel break; 1862161537Smarcel case 16: 1863161537Smarcel return builtin_type_vec128; 1864161537Smarcel break; 1865161537Smarcel default: 1866161537Smarcel internal_error (__FILE__, __LINE__, "Register %d size %d unknown", 1867161537Smarcel n, size); 1868161537Smarcel } 1869161537Smarcel } 1870161537Smarcel} 1871161537Smarcel 1872161537Smarcel/* Return whether register N requires conversion when moving from raw format 1873161537Smarcel to virtual format. 1874161537Smarcel 1875161537Smarcel The register format for RS/6000 floating point registers is always 1876161537Smarcel double, we need a conversion if the memory format is float. */ 1877161537Smarcel 1878161537Smarcelstatic int 1879161537Smarcelrs6000_register_convertible (int n) 1880161537Smarcel{ 1881161537Smarcel const struct reg *reg = gdbarch_tdep (current_gdbarch)->regs + n; 1882161537Smarcel return reg->fpr; 1883161537Smarcel} 1884161537Smarcel 1885161537Smarcel/* Convert data from raw format for register N in buffer FROM 1886161537Smarcel to virtual format with type TYPE in buffer TO. */ 1887161537Smarcel 1888161537Smarcelstatic void 1889161537Smarcelrs6000_register_convert_to_virtual (int n, struct type *type, 1890161537Smarcel char *from, char *to) 1891161537Smarcel{ 1892161537Smarcel if (TYPE_LENGTH (type) != DEPRECATED_REGISTER_RAW_SIZE (n)) 1893161537Smarcel { 1894161537Smarcel double val = deprecated_extract_floating (from, DEPRECATED_REGISTER_RAW_SIZE (n)); 1895161537Smarcel deprecated_store_floating (to, TYPE_LENGTH (type), val); 1896161537Smarcel } 1897161537Smarcel else 1898161537Smarcel memcpy (to, from, DEPRECATED_REGISTER_RAW_SIZE (n)); 1899161537Smarcel} 1900161537Smarcel 1901161537Smarcel/* Convert data from virtual format with type TYPE in buffer FROM 1902161537Smarcel to raw format for register N in buffer TO. */ 1903161537Smarcel 1904161537Smarcelstatic void 1905161537Smarcelrs6000_register_convert_to_raw (struct type *type, int n, 1906161537Smarcel const char *from, char *to) 1907161537Smarcel{ 1908161537Smarcel if (TYPE_LENGTH (type) != DEPRECATED_REGISTER_RAW_SIZE (n)) 1909161537Smarcel { 1910161537Smarcel double val = deprecated_extract_floating (from, TYPE_LENGTH (type)); 1911161537Smarcel deprecated_store_floating (to, DEPRECATED_REGISTER_RAW_SIZE (n), val); 1912161537Smarcel } 1913161537Smarcel else 1914161537Smarcel memcpy (to, from, DEPRECATED_REGISTER_RAW_SIZE (n)); 1915161537Smarcel} 1916161537Smarcel 1917161537Smarcelstatic void 1918161537Smarcele500_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, 1919161537Smarcel int reg_nr, void *buffer) 1920161537Smarcel{ 1921161537Smarcel int base_regnum; 1922161537Smarcel int offset = 0; 1923161537Smarcel char temp_buffer[MAX_REGISTER_SIZE]; 1924161537Smarcel struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); 1925161537Smarcel 1926161537Smarcel if (reg_nr >= tdep->ppc_gp0_regnum 1927161537Smarcel && reg_nr <= tdep->ppc_gplast_regnum) 1928161537Smarcel { 1929161537Smarcel base_regnum = reg_nr - tdep->ppc_gp0_regnum + tdep->ppc_ev0_regnum; 1930161537Smarcel 1931161537Smarcel /* Build the value in the provided buffer. */ 1932161537Smarcel /* Read the raw register of which this one is the lower portion. */ 1933161537Smarcel regcache_raw_read (regcache, base_regnum, temp_buffer); 1934161537Smarcel if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) 1935161537Smarcel offset = 4; 1936161537Smarcel memcpy ((char *) buffer, temp_buffer + offset, 4); 1937161537Smarcel } 1938161537Smarcel} 1939161537Smarcel 1940161537Smarcelstatic void 1941161537Smarcele500_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, 1942161537Smarcel int reg_nr, const void *buffer) 1943161537Smarcel{ 1944161537Smarcel int base_regnum; 1945161537Smarcel int offset = 0; 1946161537Smarcel char temp_buffer[MAX_REGISTER_SIZE]; 1947161537Smarcel struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); 1948161537Smarcel 1949161537Smarcel if (reg_nr >= tdep->ppc_gp0_regnum 1950161537Smarcel && reg_nr <= tdep->ppc_gplast_regnum) 1951161537Smarcel { 1952161537Smarcel base_regnum = reg_nr - tdep->ppc_gp0_regnum + tdep->ppc_ev0_regnum; 1953161537Smarcel /* reg_nr is 32 bit here, and base_regnum is 64 bits. */ 1954161537Smarcel if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) 1955161537Smarcel offset = 4; 1956161537Smarcel 1957161537Smarcel /* Let's read the value of the base register into a temporary 1958161537Smarcel buffer, so that overwriting the last four bytes with the new 1959161537Smarcel value of the pseudo will leave the upper 4 bytes unchanged. */ 1960161537Smarcel regcache_raw_read (regcache, base_regnum, temp_buffer); 1961161537Smarcel 1962161537Smarcel /* Write as an 8 byte quantity. */ 1963161537Smarcel memcpy (temp_buffer + offset, (char *) buffer, 4); 1964161537Smarcel regcache_raw_write (regcache, base_regnum, temp_buffer); 1965161537Smarcel } 1966161537Smarcel} 1967161537Smarcel 1968161537Smarcel/* Convert a dwarf2 register number to a gdb REGNUM. */ 1969161537Smarcelstatic int 1970161537Smarcele500_dwarf2_reg_to_regnum (int num) 1971161537Smarcel{ 1972161537Smarcel int regnum; 1973161537Smarcel if (0 <= num && num <= 31) 1974161537Smarcel return num + gdbarch_tdep (current_gdbarch)->ppc_gp0_regnum; 1975161537Smarcel else 1976161537Smarcel return num; 1977161537Smarcel} 1978161537Smarcel 1979161537Smarcel/* Convert a dbx stab register number (from `r' declaration) to a gdb 1980161537Smarcel REGNUM. */ 1981161537Smarcelstatic int 1982161537Smarcelrs6000_stab_reg_to_regnum (int num) 1983161537Smarcel{ 1984161537Smarcel int regnum; 1985161537Smarcel switch (num) 1986161537Smarcel { 1987161537Smarcel case 64: 1988161537Smarcel regnum = gdbarch_tdep (current_gdbarch)->ppc_mq_regnum; 1989161537Smarcel break; 1990161537Smarcel case 65: 1991161537Smarcel regnum = gdbarch_tdep (current_gdbarch)->ppc_lr_regnum; 1992161537Smarcel break; 1993161537Smarcel case 66: 1994161537Smarcel regnum = gdbarch_tdep (current_gdbarch)->ppc_ctr_regnum; 1995161537Smarcel break; 1996161537Smarcel case 76: 1997161537Smarcel regnum = gdbarch_tdep (current_gdbarch)->ppc_xer_regnum; 1998161537Smarcel break; 1999161537Smarcel default: 2000161537Smarcel regnum = num; 2001161537Smarcel break; 2002161537Smarcel } 2003161537Smarcel return regnum; 2004161537Smarcel} 2005161537Smarcel 2006161537Smarcelstatic void 2007161537Smarcelrs6000_store_return_value (struct type *type, char *valbuf) 2008161537Smarcel{ 2009161537Smarcel struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); 2010161537Smarcel 2011161537Smarcel if (TYPE_CODE (type) == TYPE_CODE_FLT) 2012161537Smarcel 2013161537Smarcel /* Floating point values are returned starting from FPR1 and up. 2014161537Smarcel Say a double_double_double type could be returned in 2015161537Smarcel FPR1/FPR2/FPR3 triple. */ 2016161537Smarcel 2017161537Smarcel deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (FP0_REGNUM + 1), valbuf, 2018161537Smarcel TYPE_LENGTH (type)); 2019161537Smarcel else if (TYPE_CODE (type) == TYPE_CODE_ARRAY) 2020161537Smarcel { 2021161537Smarcel if (TYPE_LENGTH (type) == 16 2022161537Smarcel && TYPE_VECTOR (type)) 2023161537Smarcel deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (tdep->ppc_vr0_regnum + 2), 2024161537Smarcel valbuf, TYPE_LENGTH (type)); 2025161537Smarcel } 2026161537Smarcel else 2027161537Smarcel /* Everything else is returned in GPR3 and up. */ 2028161537Smarcel deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (gdbarch_tdep (current_gdbarch)->ppc_gp0_regnum + 3), 2029161537Smarcel valbuf, TYPE_LENGTH (type)); 2030161537Smarcel} 2031161537Smarcel 2032161537Smarcel/* Extract from an array REGBUF containing the (raw) register state 2033161537Smarcel the address in which a function should return its structure value, 2034161537Smarcel as a CORE_ADDR (or an expression that can be used as one). */ 2035161537Smarcel 2036161537Smarcelstatic CORE_ADDR 2037161537Smarcelrs6000_extract_struct_value_address (struct regcache *regcache) 2038161537Smarcel{ 2039161537Smarcel /* FIXME: cagney/2002-09-26: PR gdb/724: When making an inferior 2040161537Smarcel function call GDB knows the address of the struct return value 2041161537Smarcel and hence, should not need to call this function. Unfortunately, 2042161537Smarcel the current call_function_by_hand() code only saves the most 2043161537Smarcel recent struct address leading to occasional calls. The code 2044161537Smarcel should instead maintain a stack of such addresses (in the dummy 2045161537Smarcel frame object). */ 2046161537Smarcel /* NOTE: cagney/2002-09-26: Return 0 which indicates that we've 2047161537Smarcel really got no idea where the return value is being stored. While 2048161537Smarcel r3, on function entry, contained the address it will have since 2049161537Smarcel been reused (scratch) and hence wouldn't be valid */ 2050161537Smarcel return 0; 2051161537Smarcel} 2052161537Smarcel 2053161537Smarcel/* Hook called when a new child process is started. */ 2054161537Smarcel 2055161537Smarcelvoid 2056161537Smarcelrs6000_create_inferior (int pid) 2057161537Smarcel{ 2058161537Smarcel if (rs6000_set_host_arch_hook) 2059161537Smarcel rs6000_set_host_arch_hook (pid); 2060161537Smarcel} 2061161537Smarcel 2062161537Smarcel/* Support for CONVERT_FROM_FUNC_PTR_ADDR (ARCH, ADDR, TARG). 2063161537Smarcel 2064161537Smarcel Usually a function pointer's representation is simply the address 2065161537Smarcel of the function. On the RS/6000 however, a function pointer is 2066161537Smarcel represented by a pointer to a TOC entry. This TOC entry contains 2067161537Smarcel three words, the first word is the address of the function, the 2068161537Smarcel second word is the TOC pointer (r2), and the third word is the 2069161537Smarcel static chain value. Throughout GDB it is currently assumed that a 2070161537Smarcel function pointer contains the address of the function, which is not 2071161537Smarcel easy to fix. In addition, the conversion of a function address to 2072161537Smarcel a function pointer would require allocation of a TOC entry in the 2073161537Smarcel inferior's memory space, with all its drawbacks. To be able to 2074161537Smarcel call C++ virtual methods in the inferior (which are called via 2075161537Smarcel function pointers), find_function_addr uses this function to get the 2076161537Smarcel function address from a function pointer. */ 2077161537Smarcel 2078161537Smarcel/* Return real function address if ADDR (a function pointer) is in the data 2079161537Smarcel space and is therefore a special function pointer. */ 2080161537Smarcel 2081161537Smarcelstatic CORE_ADDR 2082161537Smarcelrs6000_convert_from_func_ptr_addr (struct gdbarch *gdbarch, 2083161537Smarcel CORE_ADDR addr, 2084161537Smarcel struct target_ops *targ) 2085161537Smarcel{ 2086161537Smarcel struct obj_section *s; 2087161537Smarcel 2088161537Smarcel s = find_pc_section (addr); 2089161537Smarcel if (s && s->the_bfd_section->flags & SEC_CODE) 2090161537Smarcel return addr; 2091161537Smarcel 2092161537Smarcel /* ADDR is in the data space, so it's a special function pointer. */ 2093161537Smarcel return read_memory_addr (addr, gdbarch_tdep (current_gdbarch)->wordsize); 2094161537Smarcel} 2095161537Smarcel 2096161537Smarcel 2097161537Smarcel/* Handling the various POWER/PowerPC variants. */ 2098161537Smarcel 2099161537Smarcel 2100161537Smarcel/* The arrays here called registers_MUMBLE hold information about available 2101161537Smarcel registers. 2102161537Smarcel 2103161537Smarcel For each family of PPC variants, I've tried to isolate out the 2104161537Smarcel common registers and put them up front, so that as long as you get 2105161537Smarcel the general family right, GDB will correctly identify the registers 2106161537Smarcel common to that family. The common register sets are: 2107161537Smarcel 2108161537Smarcel For the 60x family: hid0 hid1 iabr dabr pir 2109161537Smarcel 2110161537Smarcel For the 505 and 860 family: eie eid nri 2111161537Smarcel 2112161537Smarcel For the 403 and 403GC: icdbdr esr dear evpr cdbcr tsr tcr pit tbhi 2113161537Smarcel tblo srr2 srr3 dbsr dbcr iac1 iac2 dac1 dac2 dccr iccr pbl1 2114161537Smarcel pbu1 pbl2 pbu2 2115161537Smarcel 2116161537Smarcel Most of these register groups aren't anything formal. I arrived at 2117161537Smarcel them by looking at the registers that occurred in more than one 2118161537Smarcel processor. 2119161537Smarcel 2120161537Smarcel Note: kevinb/2002-04-30: Support for the fpscr register was added 2121161537Smarcel during April, 2002. Slot 70 is being used for PowerPC and slot 71 2122161537Smarcel for Power. For PowerPC, slot 70 was unused and was already in the 2123161537Smarcel PPC_UISA_SPRS which is ideally where fpscr should go. For Power, 2124161537Smarcel slot 70 was being used for "mq", so the next available slot (71) 2125161537Smarcel was chosen. It would have been nice to be able to make the 2126161537Smarcel register numbers the same across processor cores, but this wasn't 2127161537Smarcel possible without either 1) renumbering some registers for some 2128161537Smarcel processors or 2) assigning fpscr to a really high slot that's 2129161537Smarcel larger than any current register number. Doing (1) is bad because 2130161537Smarcel existing stubs would break. Doing (2) is undesirable because it 2131161537Smarcel would introduce a really large gap between fpscr and the rest of 2132161537Smarcel the registers for most processors. */ 2133161537Smarcel 2134161537Smarcel/* Convenience macros for populating register arrays. */ 2135161537Smarcel 2136161537Smarcel/* Within another macro, convert S to a string. */ 2137161537Smarcel 2138161537Smarcel#define STR(s) #s 2139161537Smarcel 2140161537Smarcel/* Return a struct reg defining register NAME that's 32 bits on 32-bit systems 2141161537Smarcel and 64 bits on 64-bit systems. */ 2142161537Smarcel#define R(name) { STR(name), 4, 8, 0, 0 } 2143161537Smarcel 2144161537Smarcel/* Return a struct reg defining register NAME that's 32 bits on all 2145161537Smarcel systems. */ 2146161537Smarcel#define R4(name) { STR(name), 4, 4, 0, 0 } 2147161537Smarcel 2148161537Smarcel/* Return a struct reg defining register NAME that's 64 bits on all 2149161537Smarcel systems. */ 2150161537Smarcel#define R8(name) { STR(name), 8, 8, 0, 0 } 2151161537Smarcel 2152161537Smarcel/* Return a struct reg defining register NAME that's 128 bits on all 2153161537Smarcel systems. */ 2154161537Smarcel#define R16(name) { STR(name), 16, 16, 0, 0 } 2155161537Smarcel 2156161537Smarcel/* Return a struct reg defining floating-point register NAME. */ 2157161537Smarcel#define F(name) { STR(name), 8, 8, 1, 0 } 2158161537Smarcel 2159161537Smarcel/* Return a struct reg defining a pseudo register NAME. */ 2160161537Smarcel#define P(name) { STR(name), 4, 8, 0, 1} 2161161537Smarcel 2162161537Smarcel/* Return a struct reg defining register NAME that's 32 bits on 32-bit 2163161537Smarcel systems and that doesn't exist on 64-bit systems. */ 2164161537Smarcel#define R32(name) { STR(name), 4, 0, 0, 0 } 2165161537Smarcel 2166161537Smarcel/* Return a struct reg defining register NAME that's 64 bits on 64-bit 2167161537Smarcel systems and that doesn't exist on 32-bit systems. */ 2168161537Smarcel#define R64(name) { STR(name), 0, 8, 0, 0 } 2169161537Smarcel 2170161537Smarcel/* Return a struct reg placeholder for a register that doesn't exist. */ 2171161537Smarcel#define R0 { 0, 0, 0, 0, 0 } 2172161537Smarcel 2173161537Smarcel/* UISA registers common across all architectures, including POWER. */ 2174161537Smarcel 2175161537Smarcel#define COMMON_UISA_REGS \ 2176161537Smarcel /* 0 */ R(r0), R(r1), R(r2), R(r3), R(r4), R(r5), R(r6), R(r7), \ 2177161537Smarcel /* 8 */ R(r8), R(r9), R(r10),R(r11),R(r12),R(r13),R(r14),R(r15), \ 2178161537Smarcel /* 16 */ R(r16),R(r17),R(r18),R(r19),R(r20),R(r21),R(r22),R(r23), \ 2179161537Smarcel /* 24 */ R(r24),R(r25),R(r26),R(r27),R(r28),R(r29),R(r30),R(r31), \ 2180161537Smarcel /* 32 */ F(f0), F(f1), F(f2), F(f3), F(f4), F(f5), F(f6), F(f7), \ 2181161537Smarcel /* 40 */ F(f8), F(f9), F(f10),F(f11),F(f12),F(f13),F(f14),F(f15), \ 2182161537Smarcel /* 48 */ F(f16),F(f17),F(f18),F(f19),F(f20),F(f21),F(f22),F(f23), \ 2183161537Smarcel /* 56 */ F(f24),F(f25),F(f26),F(f27),F(f28),F(f29),F(f30),F(f31), \ 2184161537Smarcel /* 64 */ R(pc), R(ps) 2185161537Smarcel 2186161537Smarcel#define COMMON_UISA_NOFP_REGS \ 2187161537Smarcel /* 0 */ R(r0), R(r1), R(r2), R(r3), R(r4), R(r5), R(r6), R(r7), \ 2188161537Smarcel /* 8 */ R(r8), R(r9), R(r10),R(r11),R(r12),R(r13),R(r14),R(r15), \ 2189161537Smarcel /* 16 */ R(r16),R(r17),R(r18),R(r19),R(r20),R(r21),R(r22),R(r23), \ 2190161537Smarcel /* 24 */ R(r24),R(r25),R(r26),R(r27),R(r28),R(r29),R(r30),R(r31), \ 2191161537Smarcel /* 32 */ R0, R0, R0, R0, R0, R0, R0, R0, \ 2192161537Smarcel /* 40 */ R0, R0, R0, R0, R0, R0, R0, R0, \ 2193161537Smarcel /* 48 */ R0, R0, R0, R0, R0, R0, R0, R0, \ 2194161537Smarcel /* 56 */ R0, R0, R0, R0, R0, R0, R0, R0, \ 2195161537Smarcel /* 64 */ R(pc), R(ps) 2196161537Smarcel 2197161537Smarcel/* UISA-level SPRs for PowerPC. */ 2198161537Smarcel#define PPC_UISA_SPRS \ 2199161537Smarcel /* 66 */ R4(cr), R(lr), R(ctr), R4(xer), R4(fpscr) 2200161537Smarcel 2201161537Smarcel/* UISA-level SPRs for PowerPC without floating point support. */ 2202161537Smarcel#define PPC_UISA_NOFP_SPRS \ 2203161537Smarcel /* 66 */ R4(cr), R(lr), R(ctr), R4(xer), R0 2204161537Smarcel 2205161537Smarcel/* Segment registers, for PowerPC. */ 2206161537Smarcel#define PPC_SEGMENT_REGS \ 2207161537Smarcel /* 71 */ R32(sr0), R32(sr1), R32(sr2), R32(sr3), \ 2208161537Smarcel /* 75 */ R32(sr4), R32(sr5), R32(sr6), R32(sr7), \ 2209161537Smarcel /* 79 */ R32(sr8), R32(sr9), R32(sr10), R32(sr11), \ 2210161537Smarcel /* 83 */ R32(sr12), R32(sr13), R32(sr14), R32(sr15) 2211161537Smarcel 2212161537Smarcel/* OEA SPRs for PowerPC. */ 2213161537Smarcel#define PPC_OEA_SPRS \ 2214161537Smarcel /* 87 */ R4(pvr), \ 2215161537Smarcel /* 88 */ R(ibat0u), R(ibat0l), R(ibat1u), R(ibat1l), \ 2216161537Smarcel /* 92 */ R(ibat2u), R(ibat2l), R(ibat3u), R(ibat3l), \ 2217161537Smarcel /* 96 */ R(dbat0u), R(dbat0l), R(dbat1u), R(dbat1l), \ 2218161537Smarcel /* 100 */ R(dbat2u), R(dbat2l), R(dbat3u), R(dbat3l), \ 2219161537Smarcel /* 104 */ R(sdr1), R64(asr), R(dar), R4(dsisr), \ 2220161537Smarcel /* 108 */ R(sprg0), R(sprg1), R(sprg2), R(sprg3), \ 2221161537Smarcel /* 112 */ R(srr0), R(srr1), R(tbl), R(tbu), \ 2222161537Smarcel /* 116 */ R4(dec), R(dabr), R4(ear) 2223161537Smarcel 2224161537Smarcel/* AltiVec registers. */ 2225161537Smarcel#define PPC_ALTIVEC_REGS \ 2226161537Smarcel /*119*/R16(vr0), R16(vr1), R16(vr2), R16(vr3), R16(vr4), R16(vr5), R16(vr6), R16(vr7), \ 2227161537Smarcel /*127*/R16(vr8), R16(vr9), R16(vr10),R16(vr11),R16(vr12),R16(vr13),R16(vr14),R16(vr15), \ 2228161537Smarcel /*135*/R16(vr16),R16(vr17),R16(vr18),R16(vr19),R16(vr20),R16(vr21),R16(vr22),R16(vr23), \ 2229161537Smarcel /*143*/R16(vr24),R16(vr25),R16(vr26),R16(vr27),R16(vr28),R16(vr29),R16(vr30),R16(vr31), \ 2230161537Smarcel /*151*/R4(vscr), R4(vrsave) 2231161537Smarcel 2232161537Smarcel/* Vectors of hi-lo general purpose registers. */ 2233161537Smarcel#define PPC_EV_REGS \ 2234161537Smarcel /* 0*/R8(ev0), R8(ev1), R8(ev2), R8(ev3), R8(ev4), R8(ev5), R8(ev6), R8(ev7), \ 2235161537Smarcel /* 8*/R8(ev8), R8(ev9), R8(ev10),R8(ev11),R8(ev12),R8(ev13),R8(ev14),R8(ev15), \ 2236161537Smarcel /*16*/R8(ev16),R8(ev17),R8(ev18),R8(ev19),R8(ev20),R8(ev21),R8(ev22),R8(ev23), \ 2237161537Smarcel /*24*/R8(ev24),R8(ev25),R8(ev26),R8(ev27),R8(ev28),R8(ev29),R8(ev30),R8(ev31) 2238161537Smarcel 2239161537Smarcel/* Lower half of the EV registers. */ 2240161537Smarcel#define PPC_GPRS_PSEUDO_REGS \ 2241161537Smarcel /* 0 */ P(r0), P(r1), P(r2), P(r3), P(r4), P(r5), P(r6), P(r7), \ 2242161537Smarcel /* 8 */ P(r8), P(r9), P(r10),P(r11),P(r12),P(r13),P(r14),P(r15), \ 2243161537Smarcel /* 16 */ P(r16),P(r17),P(r18),P(r19),P(r20),P(r21),P(r22),P(r23), \ 2244161537Smarcel /* 24 */ P(r24),P(r25),P(r26),P(r27),P(r28),P(r29),P(r30),P(r31) 2245161537Smarcel 2246161537Smarcel/* IBM POWER (pre-PowerPC) architecture, user-level view. We only cover 2247161537Smarcel user-level SPR's. */ 2248161537Smarcelstatic const struct reg registers_power[] = 2249161537Smarcel{ 2250161537Smarcel COMMON_UISA_REGS, 2251161537Smarcel /* 66 */ R4(cnd), R(lr), R(cnt), R4(xer), R4(mq), 2252161537Smarcel /* 71 */ R4(fpscr) 2253161537Smarcel}; 2254161537Smarcel 2255161537Smarcel/* PowerPC UISA - a PPC processor as viewed by user-level code. A UISA-only 2256161537Smarcel view of the PowerPC. */ 2257161537Smarcelstatic const struct reg registers_powerpc[] = 2258161537Smarcel{ 2259161537Smarcel COMMON_UISA_REGS, 2260161537Smarcel PPC_UISA_SPRS, 2261161537Smarcel PPC_ALTIVEC_REGS 2262161537Smarcel}; 2263161537Smarcel 2264161537Smarcel/* PowerPC UISA - a PPC processor as viewed by user-level 2265161537Smarcel code, but without floating point registers. */ 2266161537Smarcelstatic const struct reg registers_powerpc_nofp[] = 2267161537Smarcel{ 2268161537Smarcel COMMON_UISA_NOFP_REGS, 2269161537Smarcel PPC_UISA_SPRS 2270161537Smarcel}; 2271161537Smarcel 2272161537Smarcel/* IBM PowerPC 403. */ 2273161537Smarcelstatic const struct reg registers_403[] = 2274161537Smarcel{ 2275161537Smarcel COMMON_UISA_REGS, 2276161537Smarcel PPC_UISA_SPRS, 2277161537Smarcel PPC_SEGMENT_REGS, 2278161537Smarcel PPC_OEA_SPRS, 2279161537Smarcel /* 119 */ R(icdbdr), R(esr), R(dear), R(evpr), 2280161537Smarcel /* 123 */ R(cdbcr), R(tsr), R(tcr), R(pit), 2281161537Smarcel /* 127 */ R(tbhi), R(tblo), R(srr2), R(srr3), 2282161537Smarcel /* 131 */ R(dbsr), R(dbcr), R(iac1), R(iac2), 2283161537Smarcel /* 135 */ R(dac1), R(dac2), R(dccr), R(iccr), 2284161537Smarcel /* 139 */ R(pbl1), R(pbu1), R(pbl2), R(pbu2) 2285161537Smarcel}; 2286161537Smarcel 2287161537Smarcel/* IBM PowerPC 403GC. */ 2288161537Smarcelstatic const struct reg registers_403GC[] = 2289161537Smarcel{ 2290161537Smarcel COMMON_UISA_REGS, 2291161537Smarcel PPC_UISA_SPRS, 2292161537Smarcel PPC_SEGMENT_REGS, 2293161537Smarcel PPC_OEA_SPRS, 2294161537Smarcel /* 119 */ R(icdbdr), R(esr), R(dear), R(evpr), 2295161537Smarcel /* 123 */ R(cdbcr), R(tsr), R(tcr), R(pit), 2296161537Smarcel /* 127 */ R(tbhi), R(tblo), R(srr2), R(srr3), 2297161537Smarcel /* 131 */ R(dbsr), R(dbcr), R(iac1), R(iac2), 2298161537Smarcel /* 135 */ R(dac1), R(dac2), R(dccr), R(iccr), 2299161537Smarcel /* 139 */ R(pbl1), R(pbu1), R(pbl2), R(pbu2), 2300161537Smarcel /* 143 */ R(zpr), R(pid), R(sgr), R(dcwr), 2301161537Smarcel /* 147 */ R(tbhu), R(tblu) 2302161537Smarcel}; 2303161537Smarcel 2304161537Smarcel/* Motorola PowerPC 505. */ 2305161537Smarcelstatic const struct reg registers_505[] = 2306161537Smarcel{ 2307161537Smarcel COMMON_UISA_REGS, 2308161537Smarcel PPC_UISA_SPRS, 2309161537Smarcel PPC_SEGMENT_REGS, 2310161537Smarcel PPC_OEA_SPRS, 2311161537Smarcel /* 119 */ R(eie), R(eid), R(nri) 2312161537Smarcel}; 2313161537Smarcel 2314161537Smarcel/* Motorola PowerPC 860 or 850. */ 2315161537Smarcelstatic const struct reg registers_860[] = 2316161537Smarcel{ 2317161537Smarcel COMMON_UISA_REGS, 2318161537Smarcel PPC_UISA_SPRS, 2319161537Smarcel PPC_SEGMENT_REGS, 2320161537Smarcel PPC_OEA_SPRS, 2321161537Smarcel /* 119 */ R(eie), R(eid), R(nri), R(cmpa), 2322161537Smarcel /* 123 */ R(cmpb), R(cmpc), R(cmpd), R(icr), 2323161537Smarcel /* 127 */ R(der), R(counta), R(countb), R(cmpe), 2324161537Smarcel /* 131 */ R(cmpf), R(cmpg), R(cmph), R(lctrl1), 2325161537Smarcel /* 135 */ R(lctrl2), R(ictrl), R(bar), R(ic_cst), 2326161537Smarcel /* 139 */ R(ic_adr), R(ic_dat), R(dc_cst), R(dc_adr), 2327161537Smarcel /* 143 */ R(dc_dat), R(dpdr), R(dpir), R(immr), 2328161537Smarcel /* 147 */ R(mi_ctr), R(mi_ap), R(mi_epn), R(mi_twc), 2329161537Smarcel /* 151 */ R(mi_rpn), R(md_ctr), R(m_casid), R(md_ap), 2330161537Smarcel /* 155 */ R(md_epn), R(md_twb), R(md_twc), R(md_rpn), 2331161537Smarcel /* 159 */ R(m_tw), R(mi_dbcam), R(mi_dbram0), R(mi_dbram1), 2332161537Smarcel /* 163 */ R(md_dbcam), R(md_dbram0), R(md_dbram1) 2333161537Smarcel}; 2334161537Smarcel 2335161537Smarcel/* Motorola PowerPC 601. Note that the 601 has different register numbers 2336161537Smarcel for reading and writing RTCU and RTCL. However, how one reads and writes a 2337161537Smarcel register is the stub's problem. */ 2338161537Smarcelstatic const struct reg registers_601[] = 2339161537Smarcel{ 2340161537Smarcel COMMON_UISA_REGS, 2341161537Smarcel PPC_UISA_SPRS, 2342161537Smarcel PPC_SEGMENT_REGS, 2343161537Smarcel PPC_OEA_SPRS, 2344161537Smarcel /* 119 */ R(hid0), R(hid1), R(iabr), R(dabr), 2345161537Smarcel /* 123 */ R(pir), R(mq), R(rtcu), R(rtcl) 2346161537Smarcel}; 2347161537Smarcel 2348161537Smarcel/* Motorola PowerPC 602. */ 2349161537Smarcelstatic const struct reg registers_602[] = 2350161537Smarcel{ 2351161537Smarcel COMMON_UISA_REGS, 2352161537Smarcel PPC_UISA_SPRS, 2353161537Smarcel PPC_SEGMENT_REGS, 2354161537Smarcel PPC_OEA_SPRS, 2355161537Smarcel /* 119 */ R(hid0), R(hid1), R(iabr), R0, 2356161537Smarcel /* 123 */ R0, R(tcr), R(ibr), R(esassr), 2357161537Smarcel /* 127 */ R(sebr), R(ser), R(sp), R(lt) 2358161537Smarcel}; 2359161537Smarcel 2360161537Smarcel/* Motorola/IBM PowerPC 603 or 603e. */ 2361161537Smarcelstatic const struct reg registers_603[] = 2362161537Smarcel{ 2363161537Smarcel COMMON_UISA_REGS, 2364161537Smarcel PPC_UISA_SPRS, 2365161537Smarcel PPC_SEGMENT_REGS, 2366161537Smarcel PPC_OEA_SPRS, 2367161537Smarcel /* 119 */ R(hid0), R(hid1), R(iabr), R0, 2368161537Smarcel /* 123 */ R0, R(dmiss), R(dcmp), R(hash1), 2369161537Smarcel /* 127 */ R(hash2), R(imiss), R(icmp), R(rpa) 2370161537Smarcel}; 2371161537Smarcel 2372161537Smarcel/* Motorola PowerPC 604 or 604e. */ 2373161537Smarcelstatic const struct reg registers_604[] = 2374161537Smarcel{ 2375161537Smarcel COMMON_UISA_REGS, 2376161537Smarcel PPC_UISA_SPRS, 2377161537Smarcel PPC_SEGMENT_REGS, 2378161537Smarcel PPC_OEA_SPRS, 2379161537Smarcel /* 119 */ R(hid0), R(hid1), R(iabr), R(dabr), 2380161537Smarcel /* 123 */ R(pir), R(mmcr0), R(pmc1), R(pmc2), 2381161537Smarcel /* 127 */ R(sia), R(sda) 2382161537Smarcel}; 2383161537Smarcel 2384161537Smarcel/* Motorola/IBM PowerPC 750 or 740. */ 2385161537Smarcelstatic const struct reg registers_750[] = 2386161537Smarcel{ 2387161537Smarcel COMMON_UISA_REGS, 2388161537Smarcel PPC_UISA_SPRS, 2389161537Smarcel PPC_SEGMENT_REGS, 2390161537Smarcel PPC_OEA_SPRS, 2391161537Smarcel /* 119 */ R(hid0), R(hid1), R(iabr), R(dabr), 2392161537Smarcel /* 123 */ R0, R(ummcr0), R(upmc1), R(upmc2), 2393161537Smarcel /* 127 */ R(usia), R(ummcr1), R(upmc3), R(upmc4), 2394161537Smarcel /* 131 */ R(mmcr0), R(pmc1), R(pmc2), R(sia), 2395161537Smarcel /* 135 */ R(mmcr1), R(pmc3), R(pmc4), R(l2cr), 2396161537Smarcel /* 139 */ R(ictc), R(thrm1), R(thrm2), R(thrm3) 2397161537Smarcel}; 2398161537Smarcel 2399161537Smarcel 2400161537Smarcel/* Motorola PowerPC 7400. */ 2401161537Smarcelstatic const struct reg registers_7400[] = 2402161537Smarcel{ 2403161537Smarcel /* gpr0-gpr31, fpr0-fpr31 */ 2404161537Smarcel COMMON_UISA_REGS, 2405161537Smarcel /* ctr, xre, lr, cr */ 2406161537Smarcel PPC_UISA_SPRS, 2407161537Smarcel /* sr0-sr15 */ 2408161537Smarcel PPC_SEGMENT_REGS, 2409161537Smarcel PPC_OEA_SPRS, 2410161537Smarcel /* vr0-vr31, vrsave, vscr */ 2411161537Smarcel PPC_ALTIVEC_REGS 2412161537Smarcel /* FIXME? Add more registers? */ 2413161537Smarcel}; 2414161537Smarcel 2415161537Smarcel/* Motorola e500. */ 2416161537Smarcelstatic const struct reg registers_e500[] = 2417161537Smarcel{ 2418161537Smarcel R(pc), R(ps), 2419161537Smarcel /* cr, lr, ctr, xer, "" */ 2420161537Smarcel PPC_UISA_NOFP_SPRS, 2421161537Smarcel /* 7...38 */ 2422161537Smarcel PPC_EV_REGS, 2423161537Smarcel R8(acc), R(spefscr), 2424161537Smarcel /* NOTE: Add new registers here the end of the raw register 2425161537Smarcel list and just before the first pseudo register. */ 2426161537Smarcel /* 39...70 */ 2427161537Smarcel PPC_GPRS_PSEUDO_REGS 2428161537Smarcel}; 2429161537Smarcel 2430161537Smarcel/* Information about a particular processor variant. */ 2431161537Smarcel 2432161537Smarcelstruct variant 2433161537Smarcel { 2434161537Smarcel /* Name of this variant. */ 2435161537Smarcel char *name; 2436161537Smarcel 2437161537Smarcel /* English description of the variant. */ 2438161537Smarcel char *description; 2439161537Smarcel 2440161537Smarcel /* bfd_arch_info.arch corresponding to variant. */ 2441161537Smarcel enum bfd_architecture arch; 2442161537Smarcel 2443161537Smarcel /* bfd_arch_info.mach corresponding to variant. */ 2444161537Smarcel unsigned long mach; 2445161537Smarcel 2446161537Smarcel /* Number of real registers. */ 2447161537Smarcel int nregs; 2448161537Smarcel 2449161537Smarcel /* Number of pseudo registers. */ 2450161537Smarcel int npregs; 2451161537Smarcel 2452161537Smarcel /* Number of total registers (the sum of nregs and npregs). */ 2453161537Smarcel int num_tot_regs; 2454161537Smarcel 2455161537Smarcel /* Table of register names; registers[R] is the name of the register 2456161537Smarcel number R. */ 2457161537Smarcel const struct reg *regs; 2458161537Smarcel }; 2459161537Smarcel 2460161537Smarcel#define tot_num_registers(list) (sizeof (list) / sizeof((list)[0])) 2461161537Smarcel 2462161537Smarcelstatic int 2463161537Smarcelnum_registers (const struct reg *reg_list, int num_tot_regs) 2464161537Smarcel{ 2465161537Smarcel int i; 2466161537Smarcel int nregs = 0; 2467161537Smarcel 2468161537Smarcel for (i = 0; i < num_tot_regs; i++) 2469161537Smarcel if (!reg_list[i].pseudo) 2470161537Smarcel nregs++; 2471161537Smarcel 2472161537Smarcel return nregs; 2473161537Smarcel} 2474161537Smarcel 2475161537Smarcelstatic int 2476161537Smarcelnum_pseudo_registers (const struct reg *reg_list, int num_tot_regs) 2477161537Smarcel{ 2478161537Smarcel int i; 2479161537Smarcel int npregs = 0; 2480161537Smarcel 2481161537Smarcel for (i = 0; i < num_tot_regs; i++) 2482161537Smarcel if (reg_list[i].pseudo) 2483161537Smarcel npregs ++; 2484161537Smarcel 2485161537Smarcel return npregs; 2486161537Smarcel} 2487161537Smarcel 2488161537Smarcel/* Information in this table comes from the following web sites: 2489161537Smarcel IBM: http://www.chips.ibm.com:80/products/embedded/ 2490161537Smarcel Motorola: http://www.mot.com/SPS/PowerPC/ 2491161537Smarcel 2492161537Smarcel I'm sure I've got some of the variant descriptions not quite right. 2493161537Smarcel Please report any inaccuracies you find to GDB's maintainer. 2494161537Smarcel 2495161537Smarcel If you add entries to this table, please be sure to allow the new 2496161537Smarcel value as an argument to the --with-cpu flag, in configure.in. */ 2497161537Smarcel 2498161537Smarcelstatic struct variant variants[] = 2499161537Smarcel{ 2500161537Smarcel 2501161537Smarcel {"powerpc", "PowerPC user-level", bfd_arch_powerpc, 2502161537Smarcel bfd_mach_ppc, -1, -1, tot_num_registers (registers_powerpc), 2503161537Smarcel registers_powerpc}, 2504161537Smarcel {"power", "POWER user-level", bfd_arch_rs6000, 2505161537Smarcel bfd_mach_rs6k, -1, -1, tot_num_registers (registers_power), 2506161537Smarcel registers_power}, 2507161537Smarcel {"403", "IBM PowerPC 403", bfd_arch_powerpc, 2508161537Smarcel bfd_mach_ppc_403, -1, -1, tot_num_registers (registers_403), 2509161537Smarcel registers_403}, 2510161537Smarcel {"601", "Motorola PowerPC 601", bfd_arch_powerpc, 2511161537Smarcel bfd_mach_ppc_601, -1, -1, tot_num_registers (registers_601), 2512161537Smarcel registers_601}, 2513161537Smarcel {"602", "Motorola PowerPC 602", bfd_arch_powerpc, 2514161537Smarcel bfd_mach_ppc_602, -1, -1, tot_num_registers (registers_602), 2515161537Smarcel registers_602}, 2516161537Smarcel {"603", "Motorola/IBM PowerPC 603 or 603e", bfd_arch_powerpc, 2517161537Smarcel bfd_mach_ppc_603, -1, -1, tot_num_registers (registers_603), 2518161537Smarcel registers_603}, 2519161537Smarcel {"604", "Motorola PowerPC 604 or 604e", bfd_arch_powerpc, 2520161537Smarcel 604, -1, -1, tot_num_registers (registers_604), 2521161537Smarcel registers_604}, 2522161537Smarcel {"403GC", "IBM PowerPC 403GC", bfd_arch_powerpc, 2523161537Smarcel bfd_mach_ppc_403gc, -1, -1, tot_num_registers (registers_403GC), 2524161537Smarcel registers_403GC}, 2525161537Smarcel {"505", "Motorola PowerPC 505", bfd_arch_powerpc, 2526161537Smarcel bfd_mach_ppc_505, -1, -1, tot_num_registers (registers_505), 2527161537Smarcel registers_505}, 2528161537Smarcel {"860", "Motorola PowerPC 860 or 850", bfd_arch_powerpc, 2529161537Smarcel bfd_mach_ppc_860, -1, -1, tot_num_registers (registers_860), 2530161537Smarcel registers_860}, 2531161537Smarcel {"750", "Motorola/IBM PowerPC 750 or 740", bfd_arch_powerpc, 2532161537Smarcel bfd_mach_ppc_750, -1, -1, tot_num_registers (registers_750), 2533161537Smarcel registers_750}, 2534161537Smarcel {"7400", "Motorola/IBM PowerPC 7400 (G4)", bfd_arch_powerpc, 2535161537Smarcel bfd_mach_ppc_7400, -1, -1, tot_num_registers (registers_7400), 2536161537Smarcel registers_7400}, 2537161537Smarcel {"e500", "Motorola PowerPC e500", bfd_arch_powerpc, 2538161537Smarcel bfd_mach_ppc_e500, -1, -1, tot_num_registers (registers_e500), 2539161537Smarcel registers_e500}, 2540161537Smarcel 2541161537Smarcel /* 64-bit */ 2542161537Smarcel {"powerpc64", "PowerPC 64-bit user-level", bfd_arch_powerpc, 2543161537Smarcel bfd_mach_ppc64, -1, -1, tot_num_registers (registers_powerpc), 2544161537Smarcel registers_powerpc}, 2545161537Smarcel {"620", "Motorola PowerPC 620", bfd_arch_powerpc, 2546161537Smarcel bfd_mach_ppc_620, -1, -1, tot_num_registers (registers_powerpc), 2547161537Smarcel registers_powerpc}, 2548161537Smarcel {"630", "Motorola PowerPC 630", bfd_arch_powerpc, 2549161537Smarcel bfd_mach_ppc_630, -1, -1, tot_num_registers (registers_powerpc), 2550161537Smarcel registers_powerpc}, 2551161537Smarcel {"a35", "PowerPC A35", bfd_arch_powerpc, 2552161537Smarcel bfd_mach_ppc_a35, -1, -1, tot_num_registers (registers_powerpc), 2553161537Smarcel registers_powerpc}, 2554161537Smarcel {"rs64ii", "PowerPC rs64ii", bfd_arch_powerpc, 2555161537Smarcel bfd_mach_ppc_rs64ii, -1, -1, tot_num_registers (registers_powerpc), 2556161537Smarcel registers_powerpc}, 2557161537Smarcel {"rs64iii", "PowerPC rs64iii", bfd_arch_powerpc, 2558161537Smarcel bfd_mach_ppc_rs64iii, -1, -1, tot_num_registers (registers_powerpc), 2559161537Smarcel registers_powerpc}, 2560161537Smarcel 2561161537Smarcel /* FIXME: I haven't checked the register sets of the following. */ 2562161537Smarcel {"rs1", "IBM POWER RS1", bfd_arch_rs6000, 2563161537Smarcel bfd_mach_rs6k_rs1, -1, -1, tot_num_registers (registers_power), 2564161537Smarcel registers_power}, 2565161537Smarcel {"rsc", "IBM POWER RSC", bfd_arch_rs6000, 2566161537Smarcel bfd_mach_rs6k_rsc, -1, -1, tot_num_registers (registers_power), 2567161537Smarcel registers_power}, 2568161537Smarcel {"rs2", "IBM POWER RS2", bfd_arch_rs6000, 2569161537Smarcel bfd_mach_rs6k_rs2, -1, -1, tot_num_registers (registers_power), 2570161537Smarcel registers_power}, 2571161537Smarcel 2572161537Smarcel {0, 0, 0, 0, 0, 0, 0, 0} 2573161537Smarcel}; 2574161537Smarcel 2575161537Smarcel/* Initialize the number of registers and pseudo registers in each variant. */ 2576161537Smarcel 2577161537Smarcelstatic void 2578161537Smarcelinit_variants (void) 2579161537Smarcel{ 2580161537Smarcel struct variant *v; 2581161537Smarcel 2582161537Smarcel for (v = variants; v->name; v++) 2583161537Smarcel { 2584161537Smarcel if (v->nregs == -1) 2585161537Smarcel v->nregs = num_registers (v->regs, v->num_tot_regs); 2586161537Smarcel if (v->npregs == -1) 2587161537Smarcel v->npregs = num_pseudo_registers (v->regs, v->num_tot_regs); 2588161537Smarcel } 2589161537Smarcel} 2590161537Smarcel 2591161537Smarcel/* Return the variant corresponding to architecture ARCH and machine number 2592161537Smarcel MACH. If no such variant exists, return null. */ 2593161537Smarcel 2594161537Smarcelstatic const struct variant * 2595161537Smarcelfind_variant_by_arch (enum bfd_architecture arch, unsigned long mach) 2596161537Smarcel{ 2597161537Smarcel const struct variant *v; 2598161537Smarcel 2599161537Smarcel for (v = variants; v->name; v++) 2600161537Smarcel if (arch == v->arch && mach == v->mach) 2601161537Smarcel return v; 2602161537Smarcel 2603161537Smarcel return NULL; 2604161537Smarcel} 2605161537Smarcel 2606161537Smarcelstatic int 2607161537Smarcelgdb_print_insn_powerpc (bfd_vma memaddr, disassemble_info *info) 2608161537Smarcel{ 2609161537Smarcel if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) 2610161537Smarcel return print_insn_big_powerpc (memaddr, info); 2611161537Smarcel else 2612161537Smarcel return print_insn_little_powerpc (memaddr, info); 2613161537Smarcel} 2614161537Smarcel 2615161537Smarcel/* Initialize the current architecture based on INFO. If possible, re-use an 2616161537Smarcel architecture from ARCHES, which is a list of architectures already created 2617161537Smarcel during this debugging session. 2618161537Smarcel 2619161537Smarcel Called e.g. at program startup, when reading a core file, and when reading 2620161537Smarcel a binary file. */ 2621161537Smarcel 2622161537Smarcelstatic struct gdbarch * 2623161537Smarcelrs6000_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) 2624161537Smarcel{ 2625161537Smarcel struct gdbarch *gdbarch; 2626161537Smarcel struct gdbarch_tdep *tdep; 2627161537Smarcel int wordsize, from_xcoff_exec, from_elf_exec, power, i, off; 2628161537Smarcel struct reg *regs; 2629161537Smarcel const struct variant *v; 2630161537Smarcel enum bfd_architecture arch; 2631161537Smarcel unsigned long mach; 2632161537Smarcel bfd abfd; 2633161537Smarcel int sysv_abi; 2634161537Smarcel asection *sect; 2635161537Smarcel 2636161537Smarcel from_xcoff_exec = info.abfd && info.abfd->format == bfd_object && 2637161537Smarcel bfd_get_flavour (info.abfd) == bfd_target_xcoff_flavour; 2638161537Smarcel 2639161537Smarcel from_elf_exec = info.abfd && info.abfd->format == bfd_object && 2640161537Smarcel bfd_get_flavour (info.abfd) == bfd_target_elf_flavour; 2641161537Smarcel 2642161537Smarcel sysv_abi = info.abfd && bfd_get_flavour (info.abfd) == bfd_target_elf_flavour; 2643161537Smarcel 2644161537Smarcel /* Check word size. If INFO is from a binary file, infer it from 2645161537Smarcel that, else choose a likely default. */ 2646161537Smarcel if (from_xcoff_exec) 2647161537Smarcel { 2648161537Smarcel if (bfd_xcoff_is_xcoff64 (info.abfd)) 2649161537Smarcel wordsize = 8; 2650161537Smarcel else 2651161537Smarcel wordsize = 4; 2652161537Smarcel } 2653161537Smarcel else if (from_elf_exec) 2654161537Smarcel { 2655161537Smarcel if (elf_elfheader (info.abfd)->e_ident[EI_CLASS] == ELFCLASS64) 2656161537Smarcel wordsize = 8; 2657161537Smarcel else 2658161537Smarcel wordsize = 4; 2659161537Smarcel } 2660161537Smarcel else 2661161537Smarcel { 2662161537Smarcel if (info.bfd_arch_info != NULL && info.bfd_arch_info->bits_per_word != 0) 2663161537Smarcel wordsize = info.bfd_arch_info->bits_per_word / 2664161537Smarcel info.bfd_arch_info->bits_per_byte; 2665161537Smarcel else 2666161537Smarcel wordsize = 4; 2667161537Smarcel } 2668161537Smarcel 2669161537Smarcel /* Find a candidate among extant architectures. */ 2670161537Smarcel for (arches = gdbarch_list_lookup_by_info (arches, &info); 2671161537Smarcel arches != NULL; 2672161537Smarcel arches = gdbarch_list_lookup_by_info (arches->next, &info)) 2673161537Smarcel { 2674161537Smarcel /* Word size in the various PowerPC bfd_arch_info structs isn't 2675161537Smarcel meaningful, because 64-bit CPUs can run in 32-bit mode. So, perform 2676161537Smarcel separate word size check. */ 2677161537Smarcel tdep = gdbarch_tdep (arches->gdbarch); 2678161537Smarcel if (tdep && tdep->wordsize == wordsize) 2679161537Smarcel return arches->gdbarch; 2680161537Smarcel } 2681161537Smarcel 2682161537Smarcel /* None found, create a new architecture from INFO, whose bfd_arch_info 2683161537Smarcel validity depends on the source: 2684161537Smarcel - executable useless 2685161537Smarcel - rs6000_host_arch() good 2686161537Smarcel - core file good 2687161537Smarcel - "set arch" trust blindly 2688161537Smarcel - GDB startup useless but harmless */ 2689161537Smarcel 2690161537Smarcel if (!from_xcoff_exec) 2691161537Smarcel { 2692161537Smarcel arch = info.bfd_arch_info->arch; 2693161537Smarcel mach = info.bfd_arch_info->mach; 2694161537Smarcel } 2695161537Smarcel else 2696161537Smarcel { 2697161537Smarcel arch = bfd_arch_powerpc; 2698161537Smarcel bfd_default_set_arch_mach (&abfd, arch, 0); 2699161537Smarcel info.bfd_arch_info = bfd_get_arch_info (&abfd); 2700161537Smarcel mach = info.bfd_arch_info->mach; 2701161537Smarcel } 2702161537Smarcel tdep = xmalloc (sizeof (struct gdbarch_tdep)); 2703161537Smarcel tdep->wordsize = wordsize; 2704161537Smarcel 2705161537Smarcel /* For e500 executables, the apuinfo section is of help here. Such 2706161537Smarcel section contains the identifier and revision number of each 2707161537Smarcel Application-specific Processing Unit that is present on the 2708161537Smarcel chip. The content of the section is determined by the assembler 2709161537Smarcel which looks at each instruction and determines which unit (and 2710161537Smarcel which version of it) can execute it. In our case we just look for 2711161537Smarcel the existance of the section. */ 2712161537Smarcel 2713161537Smarcel if (info.abfd) 2714161537Smarcel { 2715161537Smarcel sect = bfd_get_section_by_name (info.abfd, ".PPC.EMB.apuinfo"); 2716161537Smarcel if (sect) 2717161537Smarcel { 2718161537Smarcel arch = info.bfd_arch_info->arch; 2719161537Smarcel mach = bfd_mach_ppc_e500; 2720161537Smarcel bfd_default_set_arch_mach (&abfd, arch, mach); 2721161537Smarcel info.bfd_arch_info = bfd_get_arch_info (&abfd); 2722161537Smarcel } 2723161537Smarcel } 2724161537Smarcel 2725161537Smarcel gdbarch = gdbarch_alloc (&info, tdep); 2726161537Smarcel power = arch == bfd_arch_rs6000; 2727161537Smarcel 2728161537Smarcel /* Initialize the number of real and pseudo registers in each variant. */ 2729161537Smarcel init_variants (); 2730161537Smarcel 2731161537Smarcel /* Choose variant. */ 2732161537Smarcel v = find_variant_by_arch (arch, mach); 2733161537Smarcel if (!v) 2734161537Smarcel return NULL; 2735161537Smarcel 2736161537Smarcel tdep->regs = v->regs; 2737161537Smarcel 2738161537Smarcel tdep->ppc_gp0_regnum = 0; 2739161537Smarcel tdep->ppc_gplast_regnum = 31; 2740161537Smarcel tdep->ppc_toc_regnum = 2; 2741161537Smarcel tdep->ppc_ps_regnum = 65; 2742161537Smarcel tdep->ppc_cr_regnum = 66; 2743161537Smarcel tdep->ppc_lr_regnum = 67; 2744161537Smarcel tdep->ppc_ctr_regnum = 68; 2745161537Smarcel tdep->ppc_xer_regnum = 69; 2746161537Smarcel if (v->mach == bfd_mach_ppc_601) 2747161537Smarcel tdep->ppc_mq_regnum = 124; 2748161537Smarcel else if (power) 2749161537Smarcel tdep->ppc_mq_regnum = 70; 2750161537Smarcel else 2751161537Smarcel tdep->ppc_mq_regnum = -1; 2752161537Smarcel tdep->ppc_fpscr_regnum = power ? 71 : 70; 2753161537Smarcel 2754161537Smarcel set_gdbarch_pc_regnum (gdbarch, 64); 2755161537Smarcel set_gdbarch_sp_regnum (gdbarch, 1); 2756161537Smarcel set_gdbarch_deprecated_fp_regnum (gdbarch, 1); 2757161537Smarcel if (sysv_abi && wordsize == 8) 2758161537Smarcel set_gdbarch_return_value (gdbarch, ppc64_sysv_abi_return_value); 2759161537Smarcel else if (sysv_abi && wordsize == 4) 2760161537Smarcel set_gdbarch_return_value (gdbarch, ppc_sysv_abi_return_value); 2761161537Smarcel else 2762161537Smarcel { 2763161537Smarcel set_gdbarch_deprecated_extract_return_value (gdbarch, rs6000_extract_return_value); 2764161537Smarcel set_gdbarch_deprecated_store_return_value (gdbarch, rs6000_store_return_value); 2765161537Smarcel } 2766161537Smarcel 2767161537Smarcel if (v->arch == bfd_arch_powerpc) 2768161537Smarcel switch (v->mach) 2769161537Smarcel { 2770161537Smarcel case bfd_mach_ppc: 2771161537Smarcel tdep->ppc_vr0_regnum = 71; 2772161537Smarcel tdep->ppc_vrsave_regnum = 104; 2773161537Smarcel tdep->ppc_ev0_regnum = -1; 2774161537Smarcel tdep->ppc_ev31_regnum = -1; 2775161537Smarcel break; 2776161537Smarcel case bfd_mach_ppc_7400: 2777161537Smarcel tdep->ppc_vr0_regnum = 119; 2778161537Smarcel tdep->ppc_vrsave_regnum = 152; 2779161537Smarcel tdep->ppc_ev0_regnum = -1; 2780161537Smarcel tdep->ppc_ev31_regnum = -1; 2781161537Smarcel break; 2782161537Smarcel case bfd_mach_ppc_e500: 2783161537Smarcel tdep->ppc_gp0_regnum = 41; 2784161537Smarcel tdep->ppc_gplast_regnum = tdep->ppc_gp0_regnum + 32 - 1; 2785161537Smarcel tdep->ppc_toc_regnum = -1; 2786161537Smarcel tdep->ppc_ps_regnum = 1; 2787161537Smarcel tdep->ppc_cr_regnum = 2; 2788161537Smarcel tdep->ppc_lr_regnum = 3; 2789161537Smarcel tdep->ppc_ctr_regnum = 4; 2790161537Smarcel tdep->ppc_xer_regnum = 5; 2791161537Smarcel tdep->ppc_ev0_regnum = 7; 2792161537Smarcel tdep->ppc_ev31_regnum = 38; 2793161537Smarcel set_gdbarch_pc_regnum (gdbarch, 0); 2794161537Smarcel set_gdbarch_sp_regnum (gdbarch, tdep->ppc_gp0_regnum + 1); 2795161537Smarcel set_gdbarch_deprecated_fp_regnum (gdbarch, tdep->ppc_gp0_regnum + 1); 2796161537Smarcel set_gdbarch_dwarf2_reg_to_regnum (gdbarch, e500_dwarf2_reg_to_regnum); 2797161537Smarcel set_gdbarch_pseudo_register_read (gdbarch, e500_pseudo_register_read); 2798161537Smarcel set_gdbarch_pseudo_register_write (gdbarch, e500_pseudo_register_write); 2799161537Smarcel break; 2800161537Smarcel default: 2801161537Smarcel tdep->ppc_vr0_regnum = -1; 2802161537Smarcel tdep->ppc_vrsave_regnum = -1; 2803161537Smarcel tdep->ppc_ev0_regnum = -1; 2804161537Smarcel tdep->ppc_ev31_regnum = -1; 2805161537Smarcel break; 2806161537Smarcel } 2807161537Smarcel 2808161537Smarcel /* Sanity check on registers. */ 2809161537Smarcel gdb_assert (strcmp (tdep->regs[tdep->ppc_gp0_regnum].name, "r0") == 0); 2810161537Smarcel 2811161537Smarcel /* Set lr_frame_offset. */ 2812161537Smarcel if (wordsize == 8) 2813161537Smarcel tdep->lr_frame_offset = 16; 2814161537Smarcel else if (sysv_abi) 2815161537Smarcel tdep->lr_frame_offset = 4; 2816161537Smarcel else 2817161537Smarcel tdep->lr_frame_offset = 8; 2818161537Smarcel 2819161537Smarcel /* Calculate byte offsets in raw register array. */ 2820161537Smarcel tdep->regoff = xmalloc (v->num_tot_regs * sizeof (int)); 2821161537Smarcel for (i = off = 0; i < v->num_tot_regs; i++) 2822161537Smarcel { 2823161537Smarcel tdep->regoff[i] = off; 2824161537Smarcel off += regsize (v->regs + i, wordsize); 2825161537Smarcel } 2826161537Smarcel 2827161537Smarcel /* Select instruction printer. */ 2828161537Smarcel if (arch == power) 2829161537Smarcel set_gdbarch_print_insn (gdbarch, print_insn_rs6000); 2830161537Smarcel else 2831161537Smarcel set_gdbarch_print_insn (gdbarch, gdb_print_insn_powerpc); 2832161537Smarcel 2833161537Smarcel set_gdbarch_write_pc (gdbarch, generic_target_write_pc); 2834161537Smarcel 2835161537Smarcel set_gdbarch_num_regs (gdbarch, v->nregs); 2836161537Smarcel set_gdbarch_num_pseudo_regs (gdbarch, v->npregs); 2837161537Smarcel set_gdbarch_register_name (gdbarch, rs6000_register_name); 2838161537Smarcel set_gdbarch_deprecated_register_size (gdbarch, wordsize); 2839161537Smarcel set_gdbarch_deprecated_register_bytes (gdbarch, off); 2840161537Smarcel set_gdbarch_deprecated_register_byte (gdbarch, rs6000_register_byte); 2841161537Smarcel set_gdbarch_deprecated_register_raw_size (gdbarch, rs6000_register_raw_size); 2842161537Smarcel set_gdbarch_deprecated_register_virtual_type (gdbarch, rs6000_register_virtual_type); 2843161537Smarcel 2844161537Smarcel set_gdbarch_ptr_bit (gdbarch, wordsize * TARGET_CHAR_BIT); 2845161537Smarcel set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT); 2846161537Smarcel set_gdbarch_int_bit (gdbarch, 4 * TARGET_CHAR_BIT); 2847161537Smarcel set_gdbarch_long_bit (gdbarch, wordsize * TARGET_CHAR_BIT); 2848161537Smarcel set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT); 2849161537Smarcel set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT); 2850161537Smarcel set_gdbarch_double_bit (gdbarch, 8 * TARGET_CHAR_BIT); 2851161537Smarcel if (sysv_abi) 2852161537Smarcel set_gdbarch_long_double_bit (gdbarch, 16 * TARGET_CHAR_BIT); 2853161537Smarcel else 2854161537Smarcel set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT); 2855161537Smarcel set_gdbarch_char_signed (gdbarch, 0); 2856161537Smarcel 2857161537Smarcel set_gdbarch_frame_align (gdbarch, rs6000_frame_align); 2858161537Smarcel if (sysv_abi && wordsize == 8) 2859161537Smarcel /* PPC64 SYSV. */ 2860161537Smarcel set_gdbarch_frame_red_zone_size (gdbarch, 288); 2861161537Smarcel else if (!sysv_abi && wordsize == 4) 2862161537Smarcel /* PowerOpen / AIX 32 bit. The saved area or red zone consists of 2863161537Smarcel 19 4 byte GPRS + 18 8 byte FPRs giving a total of 220 bytes. 2864161537Smarcel Problem is, 220 isn't frame (16 byte) aligned. Round it up to 2865161537Smarcel 224. */ 2866161537Smarcel set_gdbarch_frame_red_zone_size (gdbarch, 224); 2867161537Smarcel set_gdbarch_deprecated_save_dummy_frame_tos (gdbarch, generic_save_dummy_frame_tos); 2868161537Smarcel set_gdbarch_believe_pcc_promotion (gdbarch, 1); 2869161537Smarcel 2870161537Smarcel set_gdbarch_deprecated_register_convertible (gdbarch, rs6000_register_convertible); 2871161537Smarcel set_gdbarch_deprecated_register_convert_to_virtual (gdbarch, rs6000_register_convert_to_virtual); 2872161537Smarcel set_gdbarch_deprecated_register_convert_to_raw (gdbarch, rs6000_register_convert_to_raw); 2873161537Smarcel set_gdbarch_stab_reg_to_regnum (gdbarch, rs6000_stab_reg_to_regnum); 2874161537Smarcel /* Note: kevinb/2002-04-12: I'm not convinced that rs6000_push_arguments() 2875161537Smarcel is correct for the SysV ABI when the wordsize is 8, but I'm also 2876161537Smarcel fairly certain that ppc_sysv_abi_push_arguments() will give even 2877161537Smarcel worse results since it only works for 32-bit code. So, for the moment, 2878161537Smarcel we're better off calling rs6000_push_arguments() since it works for 2879161537Smarcel 64-bit code. At some point in the future, this matter needs to be 2880161537Smarcel revisited. */ 2881161537Smarcel if (sysv_abi && wordsize == 4) 2882161537Smarcel set_gdbarch_push_dummy_call (gdbarch, ppc_sysv_abi_push_dummy_call); 2883161537Smarcel else if (sysv_abi && wordsize == 8) 2884161537Smarcel set_gdbarch_push_dummy_call (gdbarch, ppc64_sysv_abi_push_dummy_call); 2885161537Smarcel else 2886161537Smarcel set_gdbarch_push_dummy_call (gdbarch, rs6000_push_dummy_call); 2887161537Smarcel 2888161537Smarcel set_gdbarch_deprecated_extract_struct_value_address (gdbarch, rs6000_extract_struct_value_address); 2889161537Smarcel set_gdbarch_deprecated_pop_frame (gdbarch, rs6000_pop_frame); 2890161537Smarcel 2891161537Smarcel set_gdbarch_skip_prologue (gdbarch, rs6000_skip_prologue); 2892161537Smarcel set_gdbarch_inner_than (gdbarch, core_addr_lessthan); 2893161537Smarcel set_gdbarch_breakpoint_from_pc (gdbarch, rs6000_breakpoint_from_pc); 2894161537Smarcel 2895161537Smarcel /* Handle the 64-bit SVR4 minimal-symbol convention of using "FN" 2896161537Smarcel for the descriptor and ".FN" for the entry-point -- a user 2897161537Smarcel specifying "break FN" will unexpectedly end up with a breakpoint 2898161537Smarcel on the descriptor and not the function. This architecture method 2899161537Smarcel transforms any breakpoints on descriptors into breakpoints on the 2900161537Smarcel corresponding entry point. */ 2901161537Smarcel if (sysv_abi && wordsize == 8) 2902161537Smarcel set_gdbarch_adjust_breakpoint_address (gdbarch, ppc64_sysv_abi_adjust_breakpoint_address); 2903161537Smarcel 2904161537Smarcel /* Not sure on this. FIXMEmgo */ 2905161537Smarcel set_gdbarch_frame_args_skip (gdbarch, 8); 2906161537Smarcel 2907161537Smarcel if (!sysv_abi) 2908161537Smarcel set_gdbarch_use_struct_convention (gdbarch, 2909161537Smarcel rs6000_use_struct_convention); 2910161537Smarcel 2911161537Smarcel set_gdbarch_deprecated_frameless_function_invocation (gdbarch, rs6000_frameless_function_invocation); 2912161537Smarcel set_gdbarch_deprecated_frame_chain (gdbarch, rs6000_frame_chain); 2913161537Smarcel set_gdbarch_deprecated_frame_saved_pc (gdbarch, rs6000_frame_saved_pc); 2914161537Smarcel 2915161537Smarcel set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, rs6000_frame_init_saved_regs); 2916161537Smarcel set_gdbarch_deprecated_init_extra_frame_info (gdbarch, rs6000_init_extra_frame_info); 2917161537Smarcel 2918161537Smarcel if (!sysv_abi) 2919161537Smarcel { 2920161537Smarcel /* Handle RS/6000 function pointers (which are really function 2921161537Smarcel descriptors). */ 2922161537Smarcel set_gdbarch_convert_from_func_ptr_addr (gdbarch, 2923161537Smarcel rs6000_convert_from_func_ptr_addr); 2924161537Smarcel } 2925161537Smarcel set_gdbarch_deprecated_frame_args_address (gdbarch, rs6000_frame_args_address); 2926161537Smarcel set_gdbarch_deprecated_frame_locals_address (gdbarch, rs6000_frame_args_address); 2927161537Smarcel set_gdbarch_deprecated_saved_pc_after_call (gdbarch, rs6000_saved_pc_after_call); 2928161537Smarcel 2929161537Smarcel /* Helpers for function argument information. */ 2930161537Smarcel set_gdbarch_fetch_pointer_argument (gdbarch, rs6000_fetch_pointer_argument); 2931161537Smarcel 2932161537Smarcel /* Hook in ABI-specific overrides, if they have been registered. */ 2933161537Smarcel gdbarch_init_osabi (info, gdbarch); 2934161537Smarcel 2935161537Smarcel if (from_xcoff_exec) 2936161537Smarcel { 2937161537Smarcel /* NOTE: jimix/2003-06-09: This test should really check for 2938161537Smarcel GDB_OSABI_AIX when that is defined and becomes 2939161537Smarcel available. (Actually, once things are properly split apart, 2940161537Smarcel the test goes away.) */ 2941161537Smarcel /* RS6000/AIX does not support PT_STEP. Has to be simulated. */ 2942161537Smarcel set_gdbarch_software_single_step (gdbarch, rs6000_software_single_step); 2943161537Smarcel } 2944161537Smarcel 2945161537Smarcel return gdbarch; 2946161537Smarcel} 2947161537Smarcel 2948161537Smarcelstatic void 2949161537Smarcelrs6000_dump_tdep (struct gdbarch *current_gdbarch, struct ui_file *file) 2950161537Smarcel{ 2951161537Smarcel struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); 2952161537Smarcel 2953161537Smarcel if (tdep == NULL) 2954161537Smarcel return; 2955161537Smarcel 2956161537Smarcel /* FIXME: Dump gdbarch_tdep. */ 2957161537Smarcel} 2958161537Smarcel 2959161537Smarcelstatic struct cmd_list_element *info_powerpc_cmdlist = NULL; 2960161537Smarcel 2961161537Smarcelstatic void 2962161537Smarcelrs6000_info_powerpc_command (char *args, int from_tty) 2963161537Smarcel{ 2964161537Smarcel help_list (info_powerpc_cmdlist, "info powerpc ", class_info, gdb_stdout); 2965161537Smarcel} 2966161537Smarcel 2967161537Smarcel/* Initialization code. */ 2968161537Smarcel 2969161537Smarcelextern initialize_file_ftype _initialize_rs6000_tdep; /* -Wmissing-prototypes */ 2970161537Smarcel 2971161537Smarcelvoid 2972161537Smarcel_initialize_rs6000_tdep (void) 2973161537Smarcel{ 2974161537Smarcel gdbarch_register (bfd_arch_rs6000, rs6000_gdbarch_init, rs6000_dump_tdep); 2975161537Smarcel gdbarch_register (bfd_arch_powerpc, rs6000_gdbarch_init, rs6000_dump_tdep); 2976161537Smarcel 2977161537Smarcel /* Add root prefix command for "info powerpc" commands */ 2978161537Smarcel add_prefix_cmd ("powerpc", class_info, rs6000_info_powerpc_command, 2979161537Smarcel "Various POWERPC info specific commands.", 2980161537Smarcel &info_powerpc_cmdlist, "info powerpc ", 0, &infolist); 2981161537Smarcel} 2982