146319Sdfr/* Target-dependent code for the ALPHA architecture, for GDB, the GNU Debugger. 2130809Smarcel Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003 398948Sobrien Free Software Foundation, Inc. 446319Sdfr 598948Sobrien This file is part of GDB. 646319Sdfr 798948Sobrien This program is free software; you can redistribute it and/or modify 898948Sobrien it under the terms of the GNU General Public License as published by 998948Sobrien the Free Software Foundation; either version 2 of the License, or 1098948Sobrien (at your option) any later version. 1146319Sdfr 1298948Sobrien This program is distributed in the hope that it will be useful, 1398948Sobrien but WITHOUT ANY WARRANTY; without even the implied warranty of 1498948Sobrien MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 1598948Sobrien GNU General Public License for more details. 1646319Sdfr 1798948Sobrien You should have received a copy of the GNU General Public License 1898948Sobrien along with this program; if not, write to the Free Software 1998948Sobrien Foundation, Inc., 59 Temple Place - Suite 330, 2098948Sobrien Boston, MA 02111-1307, USA. */ 2146319Sdfr 2246319Sdfr#include "defs.h" 23130809Smarcel#include "doublest.h" 2446319Sdfr#include "frame.h" 25130809Smarcel#include "frame-unwind.h" 26130809Smarcel#include "frame-base.h" 27130809Smarcel#include "dwarf2-frame.h" 2846319Sdfr#include "inferior.h" 2946319Sdfr#include "symtab.h" 3046319Sdfr#include "value.h" 3146319Sdfr#include "gdbcmd.h" 3246319Sdfr#include "gdbcore.h" 3346319Sdfr#include "dis-asm.h" 3446319Sdfr#include "symfile.h" 3546319Sdfr#include "objfiles.h" 3646319Sdfr#include "gdb_string.h" 3798948Sobrien#include "linespec.h" 3898948Sobrien#include "regcache.h" 39130809Smarcel#include "reggroups.h" 40130809Smarcel#include "arch-utils.h" 41130809Smarcel#include "osabi.h" 42130809Smarcel#include "block.h" 4346319Sdfr 44130809Smarcel#include "elf-bfd.h" 4598948Sobrien 46130809Smarcel#include "alpha-tdep.h" 4746319Sdfr 4898948Sobrien 49130809Smarcelstatic const char * 5098948Sobrienalpha_register_name (int regno) 5198948Sobrien{ 52130809Smarcel static const char * const register_names[] = 5398948Sobrien { 5498948Sobrien "v0", "t0", "t1", "t2", "t3", "t4", "t5", "t6", 5598948Sobrien "t7", "s0", "s1", "s2", "s3", "s4", "s5", "fp", 5698948Sobrien "a0", "a1", "a2", "a3", "a4", "a5", "t8", "t9", 5798948Sobrien "t10", "t11", "ra", "t12", "at", "gp", "sp", "zero", 5898948Sobrien "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", 5998948Sobrien "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15", 6098948Sobrien "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23", 6198948Sobrien "f24", "f25", "f26", "f27", "f28", "f29", "f30", "fpcr", 62130809Smarcel "pc", "", "unique" 6398948Sobrien }; 6498948Sobrien 6598948Sobrien if (regno < 0) 66130809Smarcel return NULL; 6798948Sobrien if (regno >= (sizeof(register_names) / sizeof(*register_names))) 68130809Smarcel return NULL; 69130809Smarcel return register_names[regno]; 7098948Sobrien} 7198948Sobrien 72130809Smarcelstatic int 7398948Sobrienalpha_cannot_fetch_register (int regno) 7498948Sobrien{ 75130809Smarcel return regno == ALPHA_ZERO_REGNUM; 7698948Sobrien} 7798948Sobrien 78130809Smarcelstatic int 7998948Sobrienalpha_cannot_store_register (int regno) 8098948Sobrien{ 81130809Smarcel return regno == ALPHA_ZERO_REGNUM; 8298948Sobrien} 8398948Sobrien 84130809Smarcelstatic struct type * 85130809Smarcelalpha_register_type (struct gdbarch *gdbarch, int regno) 8698948Sobrien{ 87130809Smarcel if (regno == ALPHA_SP_REGNUM || regno == ALPHA_GP_REGNUM) 88130809Smarcel return builtin_type_void_data_ptr; 89130809Smarcel if (regno == ALPHA_PC_REGNUM) 90130809Smarcel return builtin_type_void_func_ptr; 9198948Sobrien 92130809Smarcel /* Don't need to worry about little vs big endian until 93130809Smarcel some jerk tries to port to alpha-unicosmk. */ 94130809Smarcel if (regno >= ALPHA_FP0_REGNUM && regno < ALPHA_FP0_REGNUM + 31) 95130809Smarcel return builtin_type_ieee_double_little; 9698948Sobrien 97130809Smarcel return builtin_type_int64; 9898948Sobrien} 9998948Sobrien 100130809Smarcel/* Is REGNUM a member of REGGROUP? */ 10198948Sobrien 102130809Smarcelstatic int 103130809Smarcelalpha_register_reggroup_p (struct gdbarch *gdbarch, int regnum, 104130809Smarcel struct reggroup *group) 10598948Sobrien{ 106130809Smarcel /* Filter out any registers eliminated, but whose regnum is 107130809Smarcel reserved for backward compatibility, e.g. the vfp. */ 108130809Smarcel if (REGISTER_NAME (regnum) == NULL || *REGISTER_NAME (regnum) == '\0') 109130809Smarcel return 0; 11098948Sobrien 111130809Smarcel if (group == all_reggroup) 112130809Smarcel return 1; 11346319Sdfr 114130809Smarcel /* Zero should not be saved or restored. Technically it is a general 115130809Smarcel register (just as $f31 would be a float if we represented it), but 116130809Smarcel there's no point displaying it during "info regs", so leave it out 117130809Smarcel of all groups except for "all". */ 118130809Smarcel if (regnum == ALPHA_ZERO_REGNUM) 119130809Smarcel return 0; 12046319Sdfr 121130809Smarcel /* All other registers are saved and restored. */ 122130809Smarcel if (group == save_reggroup || group == restore_reggroup) 123130809Smarcel return 1; 12446319Sdfr 125130809Smarcel /* All other groups are non-overlapping. */ 12646319Sdfr 127130809Smarcel /* Since this is really a PALcode memory slot... */ 128130809Smarcel if (regnum == ALPHA_UNIQUE_REGNUM) 129130809Smarcel return group == system_reggroup; 13046319Sdfr 131130809Smarcel /* Force the FPCR to be considered part of the floating point state. */ 132130809Smarcel if (regnum == ALPHA_FPCR_REGNUM) 133130809Smarcel return group == float_reggroup; 13446319Sdfr 135130809Smarcel if (regnum >= ALPHA_FP0_REGNUM && regnum < ALPHA_FP0_REGNUM + 31) 136130809Smarcel return group == float_reggroup; 137130809Smarcel else 138130809Smarcel return group == general_reggroup; 13946319Sdfr} 14046319Sdfr 141130809Smarcelstatic int 142130809Smarcelalpha_register_byte (int regno) 14398948Sobrien{ 144130809Smarcel return (regno * 8); 14598948Sobrien} 14698948Sobrien 147130809Smarcelstatic int 148130809Smarcelalpha_register_raw_size (int regno) 14998948Sobrien{ 150130809Smarcel return 8; 15198948Sobrien} 15298948Sobrien 15346319Sdfrstatic int 154130809Smarcelalpha_register_virtual_size (int regno) 15546319Sdfr{ 156130809Smarcel return 8; 15746319Sdfr} 15846319Sdfr 159130809Smarcel/* The following represents exactly the conversion performed by 160130809Smarcel the LDS instruction. This applies to both single-precision 161130809Smarcel floating point and 32-bit integers. */ 16246319Sdfr 163130809Smarcelstatic void 164130809Smarcelalpha_lds (void *out, const void *in) 16546319Sdfr{ 166130809Smarcel ULONGEST mem = extract_unsigned_integer (in, 4); 167130809Smarcel ULONGEST frac = (mem >> 0) & 0x7fffff; 168130809Smarcel ULONGEST sign = (mem >> 31) & 1; 169130809Smarcel ULONGEST exp_msb = (mem >> 30) & 1; 170130809Smarcel ULONGEST exp_low = (mem >> 23) & 0x7f; 171130809Smarcel ULONGEST exp, reg; 17246319Sdfr 173130809Smarcel exp = (exp_msb << 10) | exp_low; 174130809Smarcel if (exp_msb) 17598948Sobrien { 176130809Smarcel if (exp_low == 0x7f) 177130809Smarcel exp = 0x7ff; 17898948Sobrien } 179130809Smarcel else 18098948Sobrien { 181130809Smarcel if (exp_low != 0x00) 182130809Smarcel exp |= 0x380; 18398948Sobrien } 18446319Sdfr 185130809Smarcel reg = (sign << 63) | (exp << 52) | (frac << 29); 186130809Smarcel store_unsigned_integer (out, 8, reg); 18746319Sdfr} 18846319Sdfr 189130809Smarcel/* Similarly, this represents exactly the conversion performed by 190130809Smarcel the STS instruction. */ 19146319Sdfr 192130809Smarcelstatic void 193130809Smarcelalpha_sts (void *out, const void *in) 19446319Sdfr{ 195130809Smarcel ULONGEST reg, mem; 19646319Sdfr 197130809Smarcel reg = extract_unsigned_integer (in, 8); 198130809Smarcel mem = ((reg >> 32) & 0xc0000000) | ((reg >> 29) & 0x3fffffff); 199130809Smarcel store_unsigned_integer (out, 4, mem); 20046319Sdfr} 20146319Sdfr 202130809Smarcel/* The alpha needs a conversion between register and memory format if the 203130809Smarcel register is a floating point register and memory format is float, as the 204130809Smarcel register format must be double or memory format is an integer with 4 205130809Smarcel bytes or less, as the representation of integers in floating point 206130809Smarcel registers is different. */ 20746319Sdfr 20846319Sdfrstatic int 209130809Smarcelalpha_convert_register_p (int regno, struct type *type) 21046319Sdfr{ 211130809Smarcel return (regno >= ALPHA_FP0_REGNUM && regno < ALPHA_FP0_REGNUM + 31); 21246319Sdfr} 21346319Sdfr 214130809Smarcelstatic void 215130809Smarcelalpha_register_to_value (struct frame_info *frame, int regnum, 216130809Smarcel struct type *valtype, void *out) 21746319Sdfr{ 218130809Smarcel char in[MAX_REGISTER_SIZE]; 219130809Smarcel frame_register_read (frame, regnum, in); 220130809Smarcel switch (TYPE_LENGTH (valtype)) 22146319Sdfr { 222130809Smarcel case 4: 223130809Smarcel alpha_sts (out, in); 224130809Smarcel break; 225130809Smarcel case 8: 226130809Smarcel memcpy (out, in, 8); 227130809Smarcel break; 228130809Smarcel default: 229130809Smarcel error ("Cannot retrieve value from floating point register"); 23046319Sdfr } 23146319Sdfr} 23246319Sdfr 233130809Smarcelstatic void 234130809Smarcelalpha_value_to_register (struct frame_info *frame, int regnum, 235130809Smarcel struct type *valtype, const void *in) 23646319Sdfr{ 237130809Smarcel char out[MAX_REGISTER_SIZE]; 238130809Smarcel switch (TYPE_LENGTH (valtype)) 23946319Sdfr { 240130809Smarcel case 4: 241130809Smarcel alpha_lds (out, in); 242130809Smarcel break; 243130809Smarcel case 8: 244130809Smarcel memcpy (out, in, 8); 245130809Smarcel break; 246130809Smarcel default: 247130809Smarcel error ("Cannot store value in floating point register"); 24846319Sdfr } 249130809Smarcel put_frame_register (frame, regnum, out); 25046319Sdfr} 25146319Sdfr 252130809Smarcel 253130809Smarcel/* The alpha passes the first six arguments in the registers, the rest on 254130809Smarcel the stack. The register arguments are stored in ARG_REG_BUFFER, and 255130809Smarcel then moved into the register file; this simplifies the passing of a 256130809Smarcel large struct which extends from the registers to the stack, plus avoids 257130809Smarcel three ptrace invocations per word. 25898948Sobrien 259130809Smarcel We don't bother tracking which register values should go in integer 260130809Smarcel regs or fp regs; we load the same values into both. 26198948Sobrien 26246319Sdfr If the called function is returning a structure, the address of the 26346319Sdfr structure to be returned is passed as a hidden first argument. */ 26446319Sdfr 265130809Smarcelstatic CORE_ADDR 266130809Smarcelalpha_push_dummy_call (struct gdbarch *gdbarch, CORE_ADDR func_addr, 267130809Smarcel struct regcache *regcache, CORE_ADDR bp_addr, 268130809Smarcel int nargs, struct value **args, CORE_ADDR sp, 269130809Smarcel int struct_return, CORE_ADDR struct_addr) 27046319Sdfr{ 27198948Sobrien int i; 27246319Sdfr int accumulate_size = struct_return ? 8 : 0; 27398948Sobrien struct alpha_arg 27498948Sobrien { 27598948Sobrien char *contents; 27698948Sobrien int len; 27798948Sobrien int offset; 27898948Sobrien }; 279130809Smarcel struct alpha_arg *alpha_args 280130809Smarcel = (struct alpha_arg *) alloca (nargs * sizeof (struct alpha_arg)); 281130809Smarcel struct alpha_arg *m_arg; 282130809Smarcel char arg_reg_buffer[ALPHA_REGISTER_SIZE * ALPHA_NUM_ARG_REGS]; 28346319Sdfr int required_arg_regs; 28446319Sdfr 285130809Smarcel /* The ABI places the address of the called function in T12. */ 286130809Smarcel regcache_cooked_write_signed (regcache, ALPHA_T12_REGNUM, func_addr); 287130809Smarcel 288130809Smarcel /* Set the return address register to point to the entry point 289130809Smarcel of the program, where a breakpoint lies in wait. */ 290130809Smarcel regcache_cooked_write_signed (regcache, ALPHA_RA_REGNUM, bp_addr); 291130809Smarcel 292130809Smarcel /* Lay out the arguments in memory. */ 29346319Sdfr for (i = 0, m_arg = alpha_args; i < nargs; i++, m_arg++) 29446319Sdfr { 29598948Sobrien struct value *arg = args[i]; 29646319Sdfr struct type *arg_type = check_typedef (VALUE_TYPE (arg)); 297130809Smarcel 29846319Sdfr /* Cast argument to long if necessary as the compiler does it too. */ 29946319Sdfr switch (TYPE_CODE (arg_type)) 30046319Sdfr { 30146319Sdfr case TYPE_CODE_INT: 30246319Sdfr case TYPE_CODE_BOOL: 30346319Sdfr case TYPE_CODE_CHAR: 30446319Sdfr case TYPE_CODE_RANGE: 30546319Sdfr case TYPE_CODE_ENUM: 306130809Smarcel if (TYPE_LENGTH (arg_type) == 4) 30746319Sdfr { 308130809Smarcel /* 32-bit values must be sign-extended to 64 bits 309130809Smarcel even if the base data type is unsigned. */ 310130809Smarcel arg_type = builtin_type_int32; 31146319Sdfr arg = value_cast (arg_type, arg); 31246319Sdfr } 313130809Smarcel if (TYPE_LENGTH (arg_type) < ALPHA_REGISTER_SIZE) 314130809Smarcel { 315130809Smarcel arg_type = builtin_type_int64; 316130809Smarcel arg = value_cast (arg_type, arg); 317130809Smarcel } 31846319Sdfr break; 319130809Smarcel 320130809Smarcel case TYPE_CODE_FLT: 321130809Smarcel /* "float" arguments loaded in registers must be passed in 322130809Smarcel register format, aka "double". */ 323130809Smarcel if (accumulate_size < sizeof (arg_reg_buffer) 324130809Smarcel && TYPE_LENGTH (arg_type) == 4) 325130809Smarcel { 326130809Smarcel arg_type = builtin_type_ieee_double_little; 327130809Smarcel arg = value_cast (arg_type, arg); 328130809Smarcel } 329130809Smarcel /* Tru64 5.1 has a 128-bit long double, and passes this by 330130809Smarcel invisible reference. No one else uses this data type. */ 331130809Smarcel else if (TYPE_LENGTH (arg_type) == 16) 332130809Smarcel { 333130809Smarcel /* Allocate aligned storage. */ 334130809Smarcel sp = (sp & -16) - 16; 335130809Smarcel 336130809Smarcel /* Write the real data into the stack. */ 337130809Smarcel write_memory (sp, VALUE_CONTENTS (arg), 16); 338130809Smarcel 339130809Smarcel /* Construct the indirection. */ 340130809Smarcel arg_type = lookup_pointer_type (arg_type); 341130809Smarcel arg = value_from_pointer (arg_type, sp); 342130809Smarcel } 343130809Smarcel break; 344130809Smarcel 345130809Smarcel case TYPE_CODE_COMPLEX: 346130809Smarcel /* ??? The ABI says that complex values are passed as two 347130809Smarcel separate scalar values. This distinction only matters 348130809Smarcel for complex float. However, GCC does not implement this. */ 349130809Smarcel 350130809Smarcel /* Tru64 5.1 has a 128-bit long double, and passes this by 351130809Smarcel invisible reference. */ 352130809Smarcel if (TYPE_LENGTH (arg_type) == 32) 353130809Smarcel { 354130809Smarcel /* Allocate aligned storage. */ 355130809Smarcel sp = (sp & -16) - 16; 356130809Smarcel 357130809Smarcel /* Write the real data into the stack. */ 358130809Smarcel write_memory (sp, VALUE_CONTENTS (arg), 32); 359130809Smarcel 360130809Smarcel /* Construct the indirection. */ 361130809Smarcel arg_type = lookup_pointer_type (arg_type); 362130809Smarcel arg = value_from_pointer (arg_type, sp); 363130809Smarcel } 364130809Smarcel break; 365130809Smarcel 36646319Sdfr default: 36746319Sdfr break; 36846319Sdfr } 36946319Sdfr m_arg->len = TYPE_LENGTH (arg_type); 37046319Sdfr m_arg->offset = accumulate_size; 37146319Sdfr accumulate_size = (accumulate_size + m_arg->len + 7) & ~7; 37298948Sobrien m_arg->contents = VALUE_CONTENTS (arg); 37346319Sdfr } 37446319Sdfr 37546319Sdfr /* Determine required argument register loads, loading an argument register 37646319Sdfr is expensive as it uses three ptrace calls. */ 37746319Sdfr required_arg_regs = accumulate_size / 8; 37846319Sdfr if (required_arg_regs > ALPHA_NUM_ARG_REGS) 37946319Sdfr required_arg_regs = ALPHA_NUM_ARG_REGS; 38046319Sdfr 38146319Sdfr /* Make room for the arguments on the stack. */ 382130809Smarcel if (accumulate_size < sizeof(arg_reg_buffer)) 383130809Smarcel accumulate_size = 0; 384130809Smarcel else 385130809Smarcel accumulate_size -= sizeof(arg_reg_buffer); 38646319Sdfr sp -= accumulate_size; 38746319Sdfr 388130809Smarcel /* Keep sp aligned to a multiple of 16 as the ABI requires. */ 38946319Sdfr sp &= ~15; 39046319Sdfr 39146319Sdfr /* `Push' arguments on the stack. */ 39298948Sobrien for (i = nargs; m_arg--, --i >= 0;) 39346319Sdfr { 394130809Smarcel char *contents = m_arg->contents; 395130809Smarcel int offset = m_arg->offset; 396130809Smarcel int len = m_arg->len; 397130809Smarcel 398130809Smarcel /* Copy the bytes destined for registers into arg_reg_buffer. */ 399130809Smarcel if (offset < sizeof(arg_reg_buffer)) 400130809Smarcel { 401130809Smarcel if (offset + len <= sizeof(arg_reg_buffer)) 402130809Smarcel { 403130809Smarcel memcpy (arg_reg_buffer + offset, contents, len); 404130809Smarcel continue; 405130809Smarcel } 406130809Smarcel else 407130809Smarcel { 408130809Smarcel int tlen = sizeof(arg_reg_buffer) - offset; 409130809Smarcel memcpy (arg_reg_buffer + offset, contents, tlen); 410130809Smarcel offset += tlen; 411130809Smarcel contents += tlen; 412130809Smarcel len -= tlen; 413130809Smarcel } 414130809Smarcel } 415130809Smarcel 416130809Smarcel /* Everything else goes to the stack. */ 417130809Smarcel write_memory (sp + offset - sizeof(arg_reg_buffer), contents, len); 41846319Sdfr } 419130809Smarcel if (struct_return) 420130809Smarcel store_unsigned_integer (arg_reg_buffer, ALPHA_REGISTER_SIZE, struct_addr); 42146319Sdfr 42246319Sdfr /* Load the argument registers. */ 42346319Sdfr for (i = 0; i < required_arg_regs; i++) 42446319Sdfr { 425130809Smarcel regcache_cooked_write (regcache, ALPHA_A0_REGNUM + i, 426130809Smarcel arg_reg_buffer + i*ALPHA_REGISTER_SIZE); 427130809Smarcel regcache_cooked_write (regcache, ALPHA_FPA0_REGNUM + i, 428130809Smarcel arg_reg_buffer + i*ALPHA_REGISTER_SIZE); 42946319Sdfr } 43046319Sdfr 431130809Smarcel /* Finally, update the stack pointer. */ 432130809Smarcel regcache_cooked_write_signed (regcache, ALPHA_SP_REGNUM, sp); 433130809Smarcel 434130809Smarcel return sp; 43546319Sdfr} 43646319Sdfr 437130809Smarcel/* Extract from REGCACHE the value about to be returned from a function 438130809Smarcel and copy it into VALBUF. */ 439130809Smarcel 440130809Smarcelstatic void 441130809Smarcelalpha_extract_return_value (struct type *valtype, struct regcache *regcache, 442130809Smarcel void *valbuf) 44346319Sdfr{ 444130809Smarcel int length = TYPE_LENGTH (valtype); 445130809Smarcel char raw_buffer[ALPHA_REGISTER_SIZE]; 446130809Smarcel ULONGEST l; 44746319Sdfr 448130809Smarcel switch (TYPE_CODE (valtype)) 449130809Smarcel { 450130809Smarcel case TYPE_CODE_FLT: 451130809Smarcel switch (length) 452130809Smarcel { 453130809Smarcel case 4: 454130809Smarcel regcache_cooked_read (regcache, ALPHA_FP0_REGNUM, raw_buffer); 455130809Smarcel alpha_sts (valbuf, raw_buffer); 456130809Smarcel break; 45798948Sobrien 458130809Smarcel case 8: 459130809Smarcel regcache_cooked_read (regcache, ALPHA_FP0_REGNUM, valbuf); 460130809Smarcel break; 46146319Sdfr 462130809Smarcel case 16: 463130809Smarcel regcache_cooked_read_unsigned (regcache, ALPHA_V0_REGNUM, &l); 464130809Smarcel read_memory (l, valbuf, 16); 465130809Smarcel break; 46646319Sdfr 467130809Smarcel default: 468130809Smarcel internal_error (__FILE__, __LINE__, "unknown floating point width"); 469130809Smarcel } 470130809Smarcel break; 47146319Sdfr 472130809Smarcel case TYPE_CODE_COMPLEX: 473130809Smarcel switch (length) 474130809Smarcel { 475130809Smarcel case 8: 476130809Smarcel /* ??? This isn't correct wrt the ABI, but it's what GCC does. */ 477130809Smarcel regcache_cooked_read (regcache, ALPHA_FP0_REGNUM, valbuf); 478130809Smarcel break; 47946319Sdfr 480130809Smarcel case 16: 481130809Smarcel regcache_cooked_read (regcache, ALPHA_FP0_REGNUM, valbuf); 482130809Smarcel regcache_cooked_read (regcache, ALPHA_FP0_REGNUM+1, 483130809Smarcel (char *)valbuf + 8); 484130809Smarcel break; 48546319Sdfr 486130809Smarcel case 32: 487130809Smarcel regcache_cooked_read_signed (regcache, ALPHA_V0_REGNUM, &l); 488130809Smarcel read_memory (l, valbuf, 32); 489130809Smarcel break; 49046319Sdfr 491130809Smarcel default: 492130809Smarcel internal_error (__FILE__, __LINE__, "unknown floating point width"); 493130809Smarcel } 494130809Smarcel break; 49546319Sdfr 496130809Smarcel default: 497130809Smarcel /* Assume everything else degenerates to an integer. */ 498130809Smarcel regcache_cooked_read_unsigned (regcache, ALPHA_V0_REGNUM, &l); 499130809Smarcel store_unsigned_integer (valbuf, length, l); 500130809Smarcel break; 501130809Smarcel } 502130809Smarcel} 50346319Sdfr 504130809Smarcel/* Extract from REGCACHE the address of a structure about to be returned 505130809Smarcel from a function. */ 50646319Sdfr 507130809Smarcelstatic CORE_ADDR 508130809Smarcelalpha_extract_struct_value_address (struct regcache *regcache) 509130809Smarcel{ 510130809Smarcel ULONGEST addr; 511130809Smarcel regcache_cooked_read_unsigned (regcache, ALPHA_V0_REGNUM, &addr); 512130809Smarcel return addr; 51346319Sdfr} 51446319Sdfr 515130809Smarcel/* Insert the given value into REGCACHE as if it was being 516130809Smarcel returned by a function. */ 517130809Smarcel 518130809Smarcelstatic void 519130809Smarcelalpha_store_return_value (struct type *valtype, struct regcache *regcache, 520130809Smarcel const void *valbuf) 52146319Sdfr{ 522130809Smarcel int length = TYPE_LENGTH (valtype); 523130809Smarcel char raw_buffer[ALPHA_REGISTER_SIZE]; 524130809Smarcel ULONGEST l; 52546319Sdfr 526130809Smarcel switch (TYPE_CODE (valtype)) 527130809Smarcel { 528130809Smarcel case TYPE_CODE_FLT: 529130809Smarcel switch (length) 530130809Smarcel { 531130809Smarcel case 4: 532130809Smarcel alpha_lds (raw_buffer, valbuf); 533130809Smarcel regcache_cooked_write (regcache, ALPHA_FP0_REGNUM, raw_buffer); 534130809Smarcel break; 53546319Sdfr 536130809Smarcel case 8: 537130809Smarcel regcache_cooked_write (regcache, ALPHA_FP0_REGNUM, valbuf); 538130809Smarcel break; 53998948Sobrien 540130809Smarcel case 16: 541130809Smarcel /* FIXME: 128-bit long doubles are returned like structures: 542130809Smarcel by writing into indirect storage provided by the caller 543130809Smarcel as the first argument. */ 544130809Smarcel error ("Cannot set a 128-bit long double return value."); 54598948Sobrien 546130809Smarcel default: 547130809Smarcel internal_error (__FILE__, __LINE__, "unknown floating point width"); 548130809Smarcel } 549130809Smarcel break; 55046319Sdfr 551130809Smarcel case TYPE_CODE_COMPLEX: 552130809Smarcel switch (length) 55346319Sdfr { 554130809Smarcel case 8: 555130809Smarcel /* ??? This isn't correct wrt the ABI, but it's what GCC does. */ 556130809Smarcel regcache_cooked_write (regcache, ALPHA_FP0_REGNUM, valbuf); 557130809Smarcel break; 55846319Sdfr 559130809Smarcel case 16: 560130809Smarcel regcache_cooked_write (regcache, ALPHA_FP0_REGNUM, valbuf); 561130809Smarcel regcache_cooked_write (regcache, ALPHA_FP0_REGNUM+1, 562130809Smarcel (const char *)valbuf + 8); 563130809Smarcel break; 56446319Sdfr 565130809Smarcel case 32: 566130809Smarcel /* FIXME: 128-bit long doubles are returned like structures: 567130809Smarcel by writing into indirect storage provided by the caller 568130809Smarcel as the first argument. */ 569130809Smarcel error ("Cannot set a 128-bit long double return value."); 57046319Sdfr 571130809Smarcel default: 572130809Smarcel internal_error (__FILE__, __LINE__, "unknown floating point width"); 573130809Smarcel } 574130809Smarcel break; 575130809Smarcel 576130809Smarcel default: 577130809Smarcel /* Assume everything else degenerates to an integer. */ 578130809Smarcel /* 32-bit values must be sign-extended to 64 bits 579130809Smarcel even if the base data type is unsigned. */ 580130809Smarcel if (length == 4) 581130809Smarcel valtype = builtin_type_int32; 582130809Smarcel l = unpack_long (valtype, valbuf); 583130809Smarcel regcache_cooked_write_unsigned (regcache, ALPHA_V0_REGNUM, l); 584130809Smarcel break; 58546319Sdfr } 58646319Sdfr} 587130809Smarcel 58846319Sdfr 589130809Smarcelstatic const unsigned char * 590130809Smarcelalpha_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr) 591130809Smarcel{ 592130809Smarcel static const unsigned char alpha_breakpoint[] = 593130809Smarcel { 0x80, 0, 0, 0 }; /* call_pal bpt */ 594130809Smarcel 595130809Smarcel *lenptr = sizeof(alpha_breakpoint); 596130809Smarcel return (alpha_breakpoint); 597130809Smarcel} 598130809Smarcel 599130809Smarcel 600130809Smarcel/* This returns the PC of the first insn after the prologue. 601130809Smarcel If we can't find the prologue, then return 0. */ 602130809Smarcel 603130809SmarcelCORE_ADDR 604130809Smarcelalpha_after_prologue (CORE_ADDR pc) 605130809Smarcel{ 606130809Smarcel struct symtab_and_line sal; 607130809Smarcel CORE_ADDR func_addr, func_end; 608130809Smarcel 609130809Smarcel if (!find_pc_partial_function (pc, NULL, &func_addr, &func_end)) 610130809Smarcel return 0; 611130809Smarcel 612130809Smarcel sal = find_pc_line (func_addr, 0); 613130809Smarcel if (sal.end < func_end) 614130809Smarcel return sal.end; 615130809Smarcel 616130809Smarcel /* The line after the prologue is after the end of the function. In this 617130809Smarcel case, tell the caller to find the prologue the hard way. */ 618130809Smarcel return 0; 619130809Smarcel} 620130809Smarcel 621130809Smarcel/* Read an instruction from memory at PC, looking through breakpoints. */ 622130809Smarcel 623130809Smarcelunsigned int 624130809Smarcelalpha_read_insn (CORE_ADDR pc) 625130809Smarcel{ 626130809Smarcel char buf[4]; 627130809Smarcel int status; 628130809Smarcel 629130809Smarcel status = read_memory_nobpt (pc, buf, 4); 630130809Smarcel if (status) 631130809Smarcel memory_error (status, pc); 632130809Smarcel return extract_unsigned_integer (buf, 4); 633130809Smarcel} 634130809Smarcel 63546319Sdfr/* To skip prologues, I use this predicate. Returns either PC itself 63646319Sdfr if the code at PC does not look like a function prologue; otherwise 63746319Sdfr returns an address that (if we're lucky) follows the prologue. If 63846319Sdfr LENIENT, then we must skip everything which is involved in setting 63946319Sdfr up the frame (it's OK to skip more, just so long as we don't skip 640130809Smarcel anything which might clobber the registers which are being saved. */ 64146319Sdfr 64298948Sobrienstatic CORE_ADDR 643130809Smarcelalpha_skip_prologue (CORE_ADDR pc) 64446319Sdfr{ 64598948Sobrien unsigned long inst; 64698948Sobrien int offset; 64798948Sobrien CORE_ADDR post_prologue_pc; 64898948Sobrien char buf[4]; 64946319Sdfr 65098948Sobrien /* Silently return the unaltered pc upon memory errors. 65198948Sobrien This could happen on OSF/1 if decode_line_1 tries to skip the 65298948Sobrien prologue for quickstarted shared library functions when the 65398948Sobrien shared library is not yet mapped in. 65498948Sobrien Reading target memory is slow over serial lines, so we perform 655130809Smarcel this check only if the target has shared libraries (which all 656130809Smarcel Alpha targets do). */ 65798948Sobrien if (target_read_memory (pc, buf, 4)) 65898948Sobrien return pc; 65946319Sdfr 66098948Sobrien /* See if we can determine the end of the prologue via the symbol table. 66198948Sobrien If so, then return either PC, or the PC after the prologue, whichever 66298948Sobrien is greater. */ 66346319Sdfr 664130809Smarcel post_prologue_pc = alpha_after_prologue (pc); 66598948Sobrien if (post_prologue_pc != 0) 66698948Sobrien return max (pc, post_prologue_pc); 66746319Sdfr 66898948Sobrien /* Can't determine prologue from the symbol table, need to examine 66998948Sobrien instructions. */ 67046319Sdfr 67198948Sobrien /* Skip the typical prologue instructions. These are the stack adjustment 67298948Sobrien instruction and the instructions that save registers on the stack 67398948Sobrien or in the gcc frame. */ 67498948Sobrien for (offset = 0; offset < 100; offset += 4) 67598948Sobrien { 676130809Smarcel inst = alpha_read_insn (pc + offset); 67746319Sdfr 67898948Sobrien if ((inst & 0xffff0000) == 0x27bb0000) /* ldah $gp,n($t12) */ 67998948Sobrien continue; 68098948Sobrien if ((inst & 0xffff0000) == 0x23bd0000) /* lda $gp,n($gp) */ 68198948Sobrien continue; 68298948Sobrien if ((inst & 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */ 68398948Sobrien continue; 68498948Sobrien if ((inst & 0xffe01fff) == 0x43c0153e) /* subq $sp,n,$sp */ 68598948Sobrien continue; 68698948Sobrien 687130809Smarcel if (((inst & 0xfc1f0000) == 0xb41e0000 /* stq reg,n($sp) */ 688130809Smarcel || (inst & 0xfc1f0000) == 0x9c1e0000) /* stt reg,n($sp) */ 689130809Smarcel && (inst & 0x03e00000) != 0x03e00000) /* reg != $zero */ 69098948Sobrien continue; 69198948Sobrien 692130809Smarcel if (inst == 0x47de040f) /* bis sp,sp,fp */ 693130809Smarcel continue; 694130809Smarcel if (inst == 0x47fe040f) /* bis zero,sp,fp */ 695130809Smarcel continue; 696130809Smarcel 69798948Sobrien break; 69846319Sdfr } 69998948Sobrien return pc + offset; 70046319Sdfr} 70146319Sdfr 702130809Smarcel 703130809Smarcel/* Figure out where the longjmp will land. 704130809Smarcel We expect the first arg to be a pointer to the jmp_buf structure from 705130809Smarcel which we extract the PC (JB_PC) that we will land at. The PC is copied 706130809Smarcel into the "pc". This routine returns true on success. */ 707130809Smarcel 708130809Smarcelstatic int 709130809Smarcelalpha_get_longjmp_target (CORE_ADDR *pc) 71098948Sobrien{ 711130809Smarcel struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); 712130809Smarcel CORE_ADDR jb_addr; 713130809Smarcel char raw_buffer[ALPHA_REGISTER_SIZE]; 714130809Smarcel 715130809Smarcel jb_addr = read_register (ALPHA_A0_REGNUM); 716130809Smarcel 717130809Smarcel if (target_read_memory (jb_addr + (tdep->jb_pc * tdep->jb_elt_size), 718130809Smarcel raw_buffer, tdep->jb_elt_size)) 719130809Smarcel return 0; 720130809Smarcel 721130809Smarcel *pc = extract_unsigned_integer (raw_buffer, tdep->jb_elt_size); 722130809Smarcel return 1; 72398948Sobrien} 72498948Sobrien 725130809Smarcel 726130809Smarcel/* Frame unwinder for signal trampolines. We use alpha tdep bits that 727130809Smarcel describe the location and shape of the sigcontext structure. After 728130809Smarcel that, all registers are in memory, so it's easy. */ 729130809Smarcel/* ??? Shouldn't we be able to do this generically, rather than with 730130809Smarcel OSABI data specific to Alpha? */ 73146319Sdfr 732130809Smarcelstruct alpha_sigtramp_unwind_cache 73346319Sdfr{ 734130809Smarcel CORE_ADDR sigcontext_addr; 735130809Smarcel}; 736130809Smarcel 737130809Smarcelstatic struct alpha_sigtramp_unwind_cache * 738130809Smarcelalpha_sigtramp_frame_unwind_cache (struct frame_info *next_frame, 739130809Smarcel void **this_prologue_cache) 740130809Smarcel{ 741130809Smarcel struct alpha_sigtramp_unwind_cache *info; 742130809Smarcel struct gdbarch_tdep *tdep; 743130809Smarcel 744130809Smarcel if (*this_prologue_cache) 745130809Smarcel return *this_prologue_cache; 746130809Smarcel 747130809Smarcel info = FRAME_OBSTACK_ZALLOC (struct alpha_sigtramp_unwind_cache); 748130809Smarcel *this_prologue_cache = info; 749130809Smarcel 750130809Smarcel tdep = gdbarch_tdep (current_gdbarch); 751130809Smarcel info->sigcontext_addr = tdep->sigcontext_addr (next_frame); 752130809Smarcel 753130809Smarcel return info; 75446319Sdfr} 75546319Sdfr 756130809Smarcel/* Return the address of REGNUM in a sigtramp frame. Since this is 757130809Smarcel all arithmetic, it doesn't seem worthwhile to cache it. */ 758130809Smarcel 759130809Smarcelstatic CORE_ADDR 760130809Smarcelalpha_sigtramp_register_address (CORE_ADDR sigcontext_addr, int regnum) 761130809Smarcel{ 762130809Smarcel struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); 763130809Smarcel 764130809Smarcel if (regnum >= 0 && regnum < 32) 765130809Smarcel return sigcontext_addr + tdep->sc_regs_offset + regnum * 8; 766130809Smarcel else if (regnum >= ALPHA_FP0_REGNUM && regnum < ALPHA_FP0_REGNUM + 32) 767130809Smarcel return sigcontext_addr + tdep->sc_fpregs_offset + regnum * 8; 768130809Smarcel else if (regnum == ALPHA_PC_REGNUM) 769130809Smarcel return sigcontext_addr + tdep->sc_pc_offset; 770130809Smarcel 771130809Smarcel return 0; 772130809Smarcel} 773130809Smarcel 774130809Smarcel/* Given a GDB frame, determine the address of the calling function's 775130809Smarcel frame. This will be used to create a new GDB frame struct. */ 776130809Smarcel 777130809Smarcelstatic void 778130809Smarcelalpha_sigtramp_frame_this_id (struct frame_info *next_frame, 779130809Smarcel void **this_prologue_cache, 780130809Smarcel struct frame_id *this_id) 78146319Sdfr{ 782130809Smarcel struct alpha_sigtramp_unwind_cache *info 783130809Smarcel = alpha_sigtramp_frame_unwind_cache (next_frame, this_prologue_cache); 784130809Smarcel struct gdbarch_tdep *tdep; 785130809Smarcel CORE_ADDR stack_addr, code_addr; 78646319Sdfr 787130809Smarcel /* If the OSABI couldn't locate the sigcontext, give up. */ 788130809Smarcel if (info->sigcontext_addr == 0) 789130809Smarcel return; 790130809Smarcel 791130809Smarcel /* If we have dynamic signal trampolines, find their start. 792130809Smarcel If we do not, then we must assume there is a symbol record 793130809Smarcel that can provide the start address. */ 794130809Smarcel tdep = gdbarch_tdep (current_gdbarch); 795130809Smarcel if (tdep->dynamic_sigtramp_offset) 79646319Sdfr { 797130809Smarcel int offset; 798130809Smarcel code_addr = frame_pc_unwind (next_frame); 799130809Smarcel offset = tdep->dynamic_sigtramp_offset (code_addr); 800130809Smarcel if (offset >= 0) 801130809Smarcel code_addr -= offset; 802130809Smarcel else 803130809Smarcel code_addr = 0; 80446319Sdfr } 80546319Sdfr else 806130809Smarcel code_addr = frame_func_unwind (next_frame); 807130809Smarcel 808130809Smarcel /* The stack address is trivially read from the sigcontext. */ 809130809Smarcel stack_addr = alpha_sigtramp_register_address (info->sigcontext_addr, 810130809Smarcel ALPHA_SP_REGNUM); 811130809Smarcel stack_addr = get_frame_memory_unsigned (next_frame, stack_addr, 812130809Smarcel ALPHA_REGISTER_SIZE); 813130809Smarcel 814130809Smarcel *this_id = frame_id_build (stack_addr, code_addr); 81546319Sdfr} 81646319Sdfr 817130809Smarcel/* Retrieve the value of REGNUM in FRAME. Don't give up! */ 818130809Smarcel 819130809Smarcelstatic void 820130809Smarcelalpha_sigtramp_frame_prev_register (struct frame_info *next_frame, 821130809Smarcel void **this_prologue_cache, 822130809Smarcel int regnum, int *optimizedp, 823130809Smarcel enum lval_type *lvalp, CORE_ADDR *addrp, 824130809Smarcel int *realnump, void *bufferp) 82546319Sdfr{ 826130809Smarcel struct alpha_sigtramp_unwind_cache *info 827130809Smarcel = alpha_sigtramp_frame_unwind_cache (next_frame, this_prologue_cache); 828130809Smarcel CORE_ADDR addr; 829130809Smarcel 830130809Smarcel if (info->sigcontext_addr != 0) 83146319Sdfr { 832130809Smarcel /* All integer and fp registers are stored in memory. */ 833130809Smarcel addr = alpha_sigtramp_register_address (info->sigcontext_addr, regnum); 834130809Smarcel if (addr != 0) 835130809Smarcel { 836130809Smarcel *optimizedp = 0; 837130809Smarcel *lvalp = lval_memory; 838130809Smarcel *addrp = addr; 839130809Smarcel *realnump = -1; 840130809Smarcel if (bufferp != NULL) 841130809Smarcel get_frame_memory (next_frame, addr, bufferp, ALPHA_REGISTER_SIZE); 842130809Smarcel return; 843130809Smarcel } 84446319Sdfr } 84546319Sdfr 846130809Smarcel /* This extra register may actually be in the sigcontext, but our 847130809Smarcel current description of it in alpha_sigtramp_frame_unwind_cache 848130809Smarcel doesn't include it. Too bad. Fall back on whatever's in the 849130809Smarcel outer frame. */ 850130809Smarcel frame_register (next_frame, regnum, optimizedp, lvalp, addrp, 851130809Smarcel realnump, bufferp); 852130809Smarcel} 853130809Smarcel 854130809Smarcelstatic const struct frame_unwind alpha_sigtramp_frame_unwind = { 855130809Smarcel SIGTRAMP_FRAME, 856130809Smarcel alpha_sigtramp_frame_this_id, 857130809Smarcel alpha_sigtramp_frame_prev_register 858130809Smarcel}; 859130809Smarcel 860130809Smarcelstatic const struct frame_unwind * 861130809Smarcelalpha_sigtramp_frame_sniffer (struct frame_info *next_frame) 862130809Smarcel{ 863130809Smarcel CORE_ADDR pc = frame_pc_unwind (next_frame); 864130809Smarcel char *name; 865130809Smarcel 866130809Smarcel /* We shouldn't even bother to try if the OSABI didn't register 867130809Smarcel a sigcontext_addr handler. */ 868130809Smarcel if (!gdbarch_tdep (current_gdbarch)->sigcontext_addr) 869130809Smarcel return NULL; 870130809Smarcel 871130809Smarcel /* Otherwise we should be in a signal frame. */ 872130809Smarcel find_pc_partial_function (pc, &name, NULL, NULL); 873130809Smarcel if (PC_IN_SIGTRAMP (pc, name)) 874130809Smarcel return &alpha_sigtramp_frame_unwind; 875130809Smarcel 876130809Smarcel return NULL; 877130809Smarcel} 878130809Smarcel 879130809Smarcel/* Fallback alpha frame unwinder. Uses instruction scanning and knows 880130809Smarcel something about the traditional layout of alpha stack frames. */ 881130809Smarcel 882130809Smarcelstruct alpha_heuristic_unwind_cache 883130809Smarcel{ 884130809Smarcel CORE_ADDR *saved_regs; 885130809Smarcel CORE_ADDR vfp; 886130809Smarcel CORE_ADDR start_pc; 887130809Smarcel int return_reg; 888130809Smarcel}; 889130809Smarcel 890130809Smarcel/* Heuristic_proc_start may hunt through the text section for a long 891130809Smarcel time across a 2400 baud serial line. Allows the user to limit this 892130809Smarcel search. */ 893130809Smarcelstatic unsigned int heuristic_fence_post = 0; 894130809Smarcel 895130809Smarcel/* Attempt to locate the start of the function containing PC. We assume that 896130809Smarcel the previous function ends with an about_to_return insn. Not foolproof by 897130809Smarcel any means, since gcc is happy to put the epilogue in the middle of a 898130809Smarcel function. But we're guessing anyway... */ 899130809Smarcel 900130809Smarcelstatic CORE_ADDR 901130809Smarcelalpha_heuristic_proc_start (CORE_ADDR pc) 902130809Smarcel{ 903130809Smarcel struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); 904130809Smarcel CORE_ADDR last_non_nop = pc; 905130809Smarcel CORE_ADDR fence = pc - heuristic_fence_post; 906130809Smarcel CORE_ADDR orig_pc = pc; 907130809Smarcel CORE_ADDR func; 908130809Smarcel 909130809Smarcel if (pc == 0) 910130809Smarcel return 0; 911130809Smarcel 912130809Smarcel /* First see if we can find the start of the function from minimal 913130809Smarcel symbol information. This can succeed with a binary that doesn't 914130809Smarcel have debug info, but hasn't been stripped. */ 915130809Smarcel func = get_pc_function_start (pc); 916130809Smarcel if (func) 917130809Smarcel return func; 918130809Smarcel 919130809Smarcel if (heuristic_fence_post == UINT_MAX 920130809Smarcel || fence < tdep->vm_min_address) 921130809Smarcel fence = tdep->vm_min_address; 922130809Smarcel 923130809Smarcel /* Search back for previous return; also stop at a 0, which might be 924130809Smarcel seen for instance before the start of a code section. Don't include 925130809Smarcel nops, since this usually indicates padding between functions. */ 926130809Smarcel for (pc -= 4; pc >= fence; pc -= 4) 92746319Sdfr { 928130809Smarcel unsigned int insn = alpha_read_insn (pc); 929130809Smarcel switch (insn) 930130809Smarcel { 931130809Smarcel case 0: /* invalid insn */ 932130809Smarcel case 0x6bfa8001: /* ret $31,($26),1 */ 933130809Smarcel return last_non_nop; 934130809Smarcel 935130809Smarcel case 0x2ffe0000: /* unop: ldq_u $31,0($30) */ 936130809Smarcel case 0x47ff041f: /* nop: bis $31,$31,$31 */ 937130809Smarcel break; 938130809Smarcel 939130809Smarcel default: 940130809Smarcel last_non_nop = pc; 941130809Smarcel break; 942130809Smarcel } 94346319Sdfr } 944130809Smarcel 945130809Smarcel /* It's not clear to me why we reach this point when stopping quietly, 946130809Smarcel but with this test, at least we don't print out warnings for every 947130809Smarcel child forked (eg, on decstation). 22apr93 rich@cygnus.com. */ 948130809Smarcel if (stop_soon == NO_STOP_QUIETLY) 94946319Sdfr { 950130809Smarcel static int blurb_printed = 0; 951130809Smarcel 952130809Smarcel if (fence == tdep->vm_min_address) 953130809Smarcel warning ("Hit beginning of text section without finding"); 95446319Sdfr else 955130809Smarcel warning ("Hit heuristic-fence-post without finding"); 956130809Smarcel warning ("enclosing function for address 0x%s", paddr_nz (orig_pc)); 957130809Smarcel 958130809Smarcel if (!blurb_printed) 959130809Smarcel { 960130809Smarcel printf_filtered ("\ 961130809SmarcelThis warning occurs if you are debugging a function without any symbols\n\ 962130809Smarcel(for example, in a stripped executable). In that case, you may wish to\n\ 963130809Smarcelincrease the size of the search with the `set heuristic-fence-post' command.\n\ 964130809Smarcel\n\ 965130809SmarcelOtherwise, you told GDB there was a function where there isn't one, or\n\ 966130809Smarcel(more likely) you have encountered a bug in GDB.\n"); 967130809Smarcel blurb_printed = 1; 968130809Smarcel } 96946319Sdfr } 970130809Smarcel 971130809Smarcel return 0; 97246319Sdfr} 97346319Sdfr 974130809Smarcelstatic struct alpha_heuristic_unwind_cache * 975130809Smarcelalpha_heuristic_frame_unwind_cache (struct frame_info *next_frame, 976130809Smarcel void **this_prologue_cache, 977130809Smarcel CORE_ADDR start_pc) 978130809Smarcel{ 979130809Smarcel struct alpha_heuristic_unwind_cache *info; 980130809Smarcel ULONGEST val; 981130809Smarcel CORE_ADDR limit_pc, cur_pc; 982130809Smarcel int frame_reg, frame_size, return_reg, reg; 98346319Sdfr 984130809Smarcel if (*this_prologue_cache) 985130809Smarcel return *this_prologue_cache; 986130809Smarcel 987130809Smarcel info = FRAME_OBSTACK_ZALLOC (struct alpha_heuristic_unwind_cache); 988130809Smarcel *this_prologue_cache = info; 989130809Smarcel info->saved_regs = frame_obstack_zalloc (SIZEOF_FRAME_SAVED_REGS); 990130809Smarcel 991130809Smarcel limit_pc = frame_pc_unwind (next_frame); 992130809Smarcel if (start_pc == 0) 993130809Smarcel start_pc = alpha_heuristic_proc_start (limit_pc); 994130809Smarcel info->start_pc = start_pc; 995130809Smarcel 996130809Smarcel frame_reg = ALPHA_SP_REGNUM; 997130809Smarcel frame_size = 0; 998130809Smarcel return_reg = -1; 999130809Smarcel 1000130809Smarcel /* If we've identified a likely place to start, do code scanning. */ 1001130809Smarcel if (start_pc != 0) 1002130809Smarcel { 1003130809Smarcel /* Limit the forward search to 50 instructions. */ 1004130809Smarcel if (start_pc + 200 < limit_pc) 1005130809Smarcel limit_pc = start_pc + 200; 1006130809Smarcel 1007130809Smarcel for (cur_pc = start_pc; cur_pc < limit_pc; cur_pc += 4) 1008130809Smarcel { 1009130809Smarcel unsigned int word = alpha_read_insn (cur_pc); 1010130809Smarcel 1011130809Smarcel if ((word & 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */ 1012130809Smarcel { 1013130809Smarcel if (word & 0x8000) 1014130809Smarcel { 1015130809Smarcel /* Consider only the first stack allocation instruction 1016130809Smarcel to contain the static size of the frame. */ 1017130809Smarcel if (frame_size == 0) 1018130809Smarcel frame_size = (-word) & 0xffff; 1019130809Smarcel } 1020130809Smarcel else 1021130809Smarcel { 1022130809Smarcel /* Exit loop if a positive stack adjustment is found, which 1023130809Smarcel usually means that the stack cleanup code in the function 1024130809Smarcel epilogue is reached. */ 1025130809Smarcel break; 1026130809Smarcel } 1027130809Smarcel } 1028130809Smarcel else if ((word & 0xfc1f0000) == 0xb41e0000) /* stq reg,n($sp) */ 1029130809Smarcel { 1030130809Smarcel reg = (word & 0x03e00000) >> 21; 1031130809Smarcel 1032130809Smarcel /* Ignore this instruction if we have already encountered 1033130809Smarcel an instruction saving the same register earlier in the 1034130809Smarcel function code. The current instruction does not tell 1035130809Smarcel us where the original value upon function entry is saved. 1036130809Smarcel All it says is that the function we are scanning reused 1037130809Smarcel that register for some computation of its own, and is now 1038130809Smarcel saving its result. */ 1039130809Smarcel if (info->saved_regs[reg]) 1040130809Smarcel continue; 1041130809Smarcel 1042130809Smarcel if (reg == 31) 1043130809Smarcel continue; 1044130809Smarcel 1045130809Smarcel /* Do not compute the address where the register was saved yet, 1046130809Smarcel because we don't know yet if the offset will need to be 1047130809Smarcel relative to $sp or $fp (we can not compute the address 1048130809Smarcel relative to $sp if $sp is updated during the execution of 1049130809Smarcel the current subroutine, for instance when doing some alloca). 1050130809Smarcel So just store the offset for the moment, and compute the 1051130809Smarcel address later when we know whether this frame has a frame 1052130809Smarcel pointer or not. */ 1053130809Smarcel /* Hack: temporarily add one, so that the offset is non-zero 1054130809Smarcel and we can tell which registers have save offsets below. */ 1055130809Smarcel info->saved_regs[reg] = (word & 0xffff) + 1; 1056130809Smarcel 1057130809Smarcel /* Starting with OSF/1-3.2C, the system libraries are shipped 1058130809Smarcel without local symbols, but they still contain procedure 1059130809Smarcel descriptors without a symbol reference. GDB is currently 1060130809Smarcel unable to find these procedure descriptors and uses 1061130809Smarcel heuristic_proc_desc instead. 1062130809Smarcel As some low level compiler support routines (__div*, __add*) 1063130809Smarcel use a non-standard return address register, we have to 1064130809Smarcel add some heuristics to determine the return address register, 1065130809Smarcel or stepping over these routines will fail. 1066130809Smarcel Usually the return address register is the first register 1067130809Smarcel saved on the stack, but assembler optimization might 1068130809Smarcel rearrange the register saves. 1069130809Smarcel So we recognize only a few registers (t7, t9, ra) within 1070130809Smarcel the procedure prologue as valid return address registers. 1071130809Smarcel If we encounter a return instruction, we extract the 1072130809Smarcel the return address register from it. 1073130809Smarcel 1074130809Smarcel FIXME: Rewriting GDB to access the procedure descriptors, 1075130809Smarcel e.g. via the minimal symbol table, might obviate this hack. */ 1076130809Smarcel if (return_reg == -1 1077130809Smarcel && cur_pc < (start_pc + 80) 1078130809Smarcel && (reg == ALPHA_T7_REGNUM 1079130809Smarcel || reg == ALPHA_T9_REGNUM 1080130809Smarcel || reg == ALPHA_RA_REGNUM)) 1081130809Smarcel return_reg = reg; 1082130809Smarcel } 1083130809Smarcel else if ((word & 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */ 1084130809Smarcel return_reg = (word >> 16) & 0x1f; 1085130809Smarcel else if (word == 0x47de040f) /* bis sp,sp,fp */ 1086130809Smarcel frame_reg = ALPHA_GCC_FP_REGNUM; 1087130809Smarcel else if (word == 0x47fe040f) /* bis zero,sp,fp */ 1088130809Smarcel frame_reg = ALPHA_GCC_FP_REGNUM; 1089130809Smarcel } 1090130809Smarcel 1091130809Smarcel /* If we haven't found a valid return address register yet, keep 1092130809Smarcel searching in the procedure prologue. */ 1093130809Smarcel if (return_reg == -1) 1094130809Smarcel { 1095130809Smarcel while (cur_pc < (limit_pc + 80) && cur_pc < (start_pc + 80)) 1096130809Smarcel { 1097130809Smarcel unsigned int word = alpha_read_insn (cur_pc); 1098130809Smarcel 1099130809Smarcel if ((word & 0xfc1f0000) == 0xb41e0000) /* stq reg,n($sp) */ 1100130809Smarcel { 1101130809Smarcel reg = (word & 0x03e00000) >> 21; 1102130809Smarcel if (reg == ALPHA_T7_REGNUM 1103130809Smarcel || reg == ALPHA_T9_REGNUM 1104130809Smarcel || reg == ALPHA_RA_REGNUM) 1105130809Smarcel { 1106130809Smarcel return_reg = reg; 1107130809Smarcel break; 1108130809Smarcel } 1109130809Smarcel } 1110130809Smarcel else if ((word & 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */ 1111130809Smarcel { 1112130809Smarcel return_reg = (word >> 16) & 0x1f; 1113130809Smarcel break; 1114130809Smarcel } 1115130809Smarcel 1116130809Smarcel cur_pc += 4; 1117130809Smarcel } 1118130809Smarcel } 1119130809Smarcel } 1120130809Smarcel 1121130809Smarcel /* Failing that, do default to the customary RA. */ 1122130809Smarcel if (return_reg == -1) 1123130809Smarcel return_reg = ALPHA_RA_REGNUM; 1124130809Smarcel info->return_reg = return_reg; 1125130809Smarcel 1126130809Smarcel frame_unwind_unsigned_register (next_frame, frame_reg, &val); 1127130809Smarcel info->vfp = val + frame_size; 1128130809Smarcel 1129130809Smarcel /* Convert offsets to absolute addresses. See above about adding 1130130809Smarcel one to the offsets to make all detected offsets non-zero. */ 1131130809Smarcel for (reg = 0; reg < ALPHA_NUM_REGS; ++reg) 1132130809Smarcel if (info->saved_regs[reg]) 1133130809Smarcel info->saved_regs[reg] += val - 1; 1134130809Smarcel 1135130809Smarcel return info; 1136130809Smarcel} 1137130809Smarcel 1138130809Smarcel/* Given a GDB frame, determine the address of the calling function's 1139130809Smarcel frame. This will be used to create a new GDB frame struct. */ 1140130809Smarcel 1141130809Smarcelstatic void 1142130809Smarcelalpha_heuristic_frame_this_id (struct frame_info *next_frame, 1143130809Smarcel void **this_prologue_cache, 1144130809Smarcel struct frame_id *this_id) 114546319Sdfr{ 1146130809Smarcel struct alpha_heuristic_unwind_cache *info 1147130809Smarcel = alpha_heuristic_frame_unwind_cache (next_frame, this_prologue_cache, 0); 1148130809Smarcel 1149130809Smarcel *this_id = frame_id_build (info->vfp, info->start_pc); 115046319Sdfr} 115146319Sdfr 1152130809Smarcel/* Retrieve the value of REGNUM in FRAME. Don't give up! */ 115346319Sdfr 1154130809Smarcelstatic void 1155130809Smarcelalpha_heuristic_frame_prev_register (struct frame_info *next_frame, 1156130809Smarcel void **this_prologue_cache, 1157130809Smarcel int regnum, int *optimizedp, 1158130809Smarcel enum lval_type *lvalp, CORE_ADDR *addrp, 1159130809Smarcel int *realnump, void *bufferp) 116046319Sdfr{ 1161130809Smarcel struct alpha_heuristic_unwind_cache *info 1162130809Smarcel = alpha_heuristic_frame_unwind_cache (next_frame, this_prologue_cache, 0); 116398948Sobrien 1164130809Smarcel /* The PC of the previous frame is stored in the link register of 1165130809Smarcel the current frame. Frob regnum so that we pull the value from 1166130809Smarcel the correct place. */ 1167130809Smarcel if (regnum == ALPHA_PC_REGNUM) 1168130809Smarcel regnum = info->return_reg; 1169130809Smarcel 1170130809Smarcel /* For all registers known to be saved in the current frame, 1171130809Smarcel do the obvious and pull the value out. */ 1172130809Smarcel if (info->saved_regs[regnum]) 117346319Sdfr { 1174130809Smarcel *optimizedp = 0; 1175130809Smarcel *lvalp = lval_memory; 1176130809Smarcel *addrp = info->saved_regs[regnum]; 1177130809Smarcel *realnump = -1; 1178130809Smarcel if (bufferp != NULL) 1179130809Smarcel get_frame_memory (next_frame, *addrp, bufferp, ALPHA_REGISTER_SIZE); 1180130809Smarcel return; 118146319Sdfr } 118246319Sdfr 1183130809Smarcel /* The stack pointer of the previous frame is computed by popping 1184130809Smarcel the current stack frame. */ 1185130809Smarcel if (regnum == ALPHA_SP_REGNUM) 1186130809Smarcel { 1187130809Smarcel *optimizedp = 0; 1188130809Smarcel *lvalp = not_lval; 1189130809Smarcel *addrp = 0; 1190130809Smarcel *realnump = -1; 1191130809Smarcel if (bufferp != NULL) 1192130809Smarcel store_unsigned_integer (bufferp, ALPHA_REGISTER_SIZE, info->vfp); 1193130809Smarcel return; 1194130809Smarcel } 1195130809Smarcel 1196130809Smarcel /* Otherwise assume the next frame has the same register value. */ 1197130809Smarcel frame_register (next_frame, regnum, optimizedp, lvalp, addrp, 1198130809Smarcel realnump, bufferp); 119946319Sdfr} 120046319Sdfr 1201130809Smarcelstatic const struct frame_unwind alpha_heuristic_frame_unwind = { 1202130809Smarcel NORMAL_FRAME, 1203130809Smarcel alpha_heuristic_frame_this_id, 1204130809Smarcel alpha_heuristic_frame_prev_register 1205130809Smarcel}; 1206130809Smarcel 1207130809Smarcelstatic const struct frame_unwind * 1208130809Smarcelalpha_heuristic_frame_sniffer (struct frame_info *next_frame) 1209130809Smarcel{ 1210130809Smarcel return &alpha_heuristic_frame_unwind; 1211130809Smarcel} 1212130809Smarcel 1213130809Smarcelstatic CORE_ADDR 1214130809Smarcelalpha_heuristic_frame_base_address (struct frame_info *next_frame, 1215130809Smarcel void **this_prologue_cache) 1216130809Smarcel{ 1217130809Smarcel struct alpha_heuristic_unwind_cache *info 1218130809Smarcel = alpha_heuristic_frame_unwind_cache (next_frame, this_prologue_cache, 0); 1219130809Smarcel 1220130809Smarcel return info->vfp; 1221130809Smarcel} 1222130809Smarcel 1223130809Smarcelstatic const struct frame_base alpha_heuristic_frame_base = { 1224130809Smarcel &alpha_heuristic_frame_unwind, 1225130809Smarcel alpha_heuristic_frame_base_address, 1226130809Smarcel alpha_heuristic_frame_base_address, 1227130809Smarcel alpha_heuristic_frame_base_address 1228130809Smarcel}; 1229130809Smarcel 123046319Sdfr/* Just like reinit_frame_cache, but with the right arguments to be 1231130809Smarcel callable as an sfunc. Used by the "set heuristic-fence-post" command. */ 123246319Sdfr 123346319Sdfrstatic void 123498948Sobrienreinit_frame_cache_sfunc (char *args, int from_tty, struct cmd_list_element *c) 123546319Sdfr{ 123646319Sdfr reinit_frame_cache (); 123746319Sdfr} 123846319Sdfr 1239130809Smarcel 1240130809Smarcel/* ALPHA stack frames are almost impenetrable. When execution stops, 1241130809Smarcel we basically have to look at symbol information for the function 1242130809Smarcel that we stopped in, which tells us *which* register (if any) is 1243130809Smarcel the base of the frame pointer, and what offset from that register 1244130809Smarcel the frame itself is at. 124546319Sdfr 1246130809Smarcel This presents a problem when trying to examine a stack in memory 1247130809Smarcel (that isn't executing at the moment), using the "frame" command. We 1248130809Smarcel don't have a PC, nor do we have any registers except SP. 1249130809Smarcel 1250130809Smarcel This routine takes two arguments, SP and PC, and tries to make the 1251130809Smarcel cached frames look as if these two arguments defined a frame on the 1252130809Smarcel cache. This allows the rest of info frame to extract the important 1253130809Smarcel arguments without difficulty. */ 1254130809Smarcel 1255130809Smarcelstruct frame_info * 1256130809Smarcelalpha_setup_arbitrary_frame (int argc, CORE_ADDR *argv) 125746319Sdfr{ 1258130809Smarcel if (argc != 2) 1259130809Smarcel error ("ALPHA frame specifications require two arguments: sp and pc"); 126046319Sdfr 1261130809Smarcel return create_new_frame (argv[0], argv[1]); 1262130809Smarcel} 126346319Sdfr 1264130809Smarcel/* Assuming NEXT_FRAME->prev is a dummy, return the frame ID of that 1265130809Smarcel dummy frame. The frame ID's base needs to match the TOS value 1266130809Smarcel saved by save_dummy_frame_tos(), and the PC match the dummy frame's 1267130809Smarcel breakpoint. */ 126846319Sdfr 1269130809Smarcelstatic struct frame_id 1270130809Smarcelalpha_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame) 1271130809Smarcel{ 1272130809Smarcel ULONGEST base; 1273130809Smarcel frame_unwind_unsigned_register (next_frame, ALPHA_SP_REGNUM, &base); 1274130809Smarcel return frame_id_build (base, frame_pc_unwind (next_frame)); 1275130809Smarcel} 127646319Sdfr 1277130809Smarcelstatic CORE_ADDR 1278130809Smarcelalpha_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame) 1279130809Smarcel{ 1280130809Smarcel ULONGEST pc; 1281130809Smarcel frame_unwind_unsigned_register (next_frame, ALPHA_PC_REGNUM, &pc); 1282130809Smarcel return pc; 128346319Sdfr} 128446319Sdfr 1285130809Smarcel 1286130809Smarcel/* Helper routines for alpha*-nat.c files to move register sets to and 1287130809Smarcel from core files. The UNIQUE pointer is allowed to be NULL, as most 1288130809Smarcel targets don't supply this value in their core files. */ 1289130809Smarcel 129046319Sdfrvoid 1291130809Smarcelalpha_supply_int_regs (int regno, const void *r0_r30, 1292130809Smarcel const void *pc, const void *unique) 129346319Sdfr{ 1294130809Smarcel int i; 129598948Sobrien 1296130809Smarcel for (i = 0; i < 31; ++i) 1297130809Smarcel if (regno == i || regno == -1) 1298130809Smarcel supply_register (i, (const char *)r0_r30 + i*8); 1299130809Smarcel 1300130809Smarcel if (regno == ALPHA_ZERO_REGNUM || regno == -1) 1301130809Smarcel supply_register (ALPHA_ZERO_REGNUM, NULL); 1302130809Smarcel 1303130809Smarcel if (regno == ALPHA_PC_REGNUM || regno == -1) 1304130809Smarcel supply_register (ALPHA_PC_REGNUM, pc); 1305130809Smarcel 1306130809Smarcel if (regno == ALPHA_UNIQUE_REGNUM || regno == -1) 1307130809Smarcel supply_register (ALPHA_UNIQUE_REGNUM, unique); 130898948Sobrien} 130998948Sobrien 1310130809Smarcelvoid 1311130809Smarcelalpha_fill_int_regs (int regno, void *r0_r30, void *pc, void *unique) 1312130809Smarcel{ 1313130809Smarcel int i; 131498948Sobrien 1315130809Smarcel for (i = 0; i < 31; ++i) 1316130809Smarcel if (regno == i || regno == -1) 1317130809Smarcel regcache_collect (i, (char *)r0_r30 + i*8); 1318130809Smarcel 1319130809Smarcel if (regno == ALPHA_PC_REGNUM || regno == -1) 1320130809Smarcel regcache_collect (ALPHA_PC_REGNUM, pc); 1321130809Smarcel 1322130809Smarcel if (unique && (regno == ALPHA_UNIQUE_REGNUM || regno == -1)) 1323130809Smarcel regcache_collect (ALPHA_UNIQUE_REGNUM, unique); 132498948Sobrien} 132598948Sobrien 132698948Sobrienvoid 1327130809Smarcelalpha_supply_fp_regs (int regno, const void *f0_f30, const void *fpcr) 132898948Sobrien{ 1329130809Smarcel int i; 1330130809Smarcel 1331130809Smarcel for (i = ALPHA_FP0_REGNUM; i < ALPHA_FP0_REGNUM + 31; ++i) 1332130809Smarcel if (regno == i || regno == -1) 1333130809Smarcel supply_register (i, (const char *)f0_f30 + (i - ALPHA_FP0_REGNUM) * 8); 1334130809Smarcel 1335130809Smarcel if (regno == ALPHA_FPCR_REGNUM || regno == -1) 1336130809Smarcel supply_register (ALPHA_FPCR_REGNUM, fpcr); 133798948Sobrien} 133898948Sobrien 1339130809Smarcelvoid 1340130809Smarcelalpha_fill_fp_regs (int regno, void *f0_f30, void *fpcr) 134198948Sobrien{ 1342130809Smarcel int i; 1343130809Smarcel 1344130809Smarcel for (i = ALPHA_FP0_REGNUM; i < ALPHA_FP0_REGNUM + 31; ++i) 1345130809Smarcel if (regno == i || regno == -1) 1346130809Smarcel regcache_collect (i, (char *)f0_f30 + (i - ALPHA_FP0_REGNUM) * 8); 1347130809Smarcel 1348130809Smarcel if (regno == ALPHA_FPCR_REGNUM || regno == -1) 1349130809Smarcel regcache_collect (ALPHA_FPCR_REGNUM, fpcr); 135098948Sobrien} 135198948Sobrien 1352130809Smarcel 135398948Sobrien/* alpha_software_single_step() is called just before we want to resume 135498948Sobrien the inferior, if we want to single-step it but there is no hardware 135598948Sobrien or kernel single-step support (NetBSD on Alpha, for example). We find 135698948Sobrien the target of the coming instruction and breakpoint it. 135798948Sobrien 135898948Sobrien single_step is also called just after the inferior stops. If we had 135998948Sobrien set up a simulated single-step, we undo our damage. */ 136098948Sobrien 136198948Sobrienstatic CORE_ADDR 136298948Sobrienalpha_next_pc (CORE_ADDR pc) 136398948Sobrien{ 136498948Sobrien unsigned int insn; 136598948Sobrien unsigned int op; 136698948Sobrien int offset; 136798948Sobrien LONGEST rav; 136898948Sobrien 1369130809Smarcel insn = alpha_read_insn (pc); 137098948Sobrien 137198948Sobrien /* Opcode is top 6 bits. */ 137298948Sobrien op = (insn >> 26) & 0x3f; 137398948Sobrien 137498948Sobrien if (op == 0x1a) 137598948Sobrien { 137698948Sobrien /* Jump format: target PC is: 137798948Sobrien RB & ~3 */ 137898948Sobrien return (read_register ((insn >> 16) & 0x1f) & ~3); 137998948Sobrien } 138098948Sobrien 138198948Sobrien if ((op & 0x30) == 0x30) 138298948Sobrien { 138398948Sobrien /* Branch format: target PC is: 138498948Sobrien (new PC) + (4 * sext(displacement)) */ 138598948Sobrien if (op == 0x30 || /* BR */ 138698948Sobrien op == 0x34) /* BSR */ 138798948Sobrien { 138898948Sobrien branch_taken: 138998948Sobrien offset = (insn & 0x001fffff); 139098948Sobrien if (offset & 0x00100000) 139198948Sobrien offset |= 0xffe00000; 139298948Sobrien offset *= 4; 139398948Sobrien return (pc + 4 + offset); 139498948Sobrien } 139598948Sobrien 139698948Sobrien /* Need to determine if branch is taken; read RA. */ 139798948Sobrien rav = (LONGEST) read_register ((insn >> 21) & 0x1f); 139898948Sobrien switch (op) 139998948Sobrien { 140098948Sobrien case 0x38: /* BLBC */ 140198948Sobrien if ((rav & 1) == 0) 140298948Sobrien goto branch_taken; 140398948Sobrien break; 140498948Sobrien case 0x3c: /* BLBS */ 140598948Sobrien if (rav & 1) 140698948Sobrien goto branch_taken; 140798948Sobrien break; 140898948Sobrien case 0x39: /* BEQ */ 140998948Sobrien if (rav == 0) 141098948Sobrien goto branch_taken; 141198948Sobrien break; 141298948Sobrien case 0x3d: /* BNE */ 141398948Sobrien if (rav != 0) 141498948Sobrien goto branch_taken; 141598948Sobrien break; 141698948Sobrien case 0x3a: /* BLT */ 141798948Sobrien if (rav < 0) 141898948Sobrien goto branch_taken; 141998948Sobrien break; 142098948Sobrien case 0x3b: /* BLE */ 142198948Sobrien if (rav <= 0) 142298948Sobrien goto branch_taken; 142398948Sobrien break; 142498948Sobrien case 0x3f: /* BGT */ 142598948Sobrien if (rav > 0) 142698948Sobrien goto branch_taken; 142798948Sobrien break; 142898948Sobrien case 0x3e: /* BGE */ 142998948Sobrien if (rav >= 0) 143098948Sobrien goto branch_taken; 143198948Sobrien break; 1432130809Smarcel 1433130809Smarcel /* ??? Missing floating-point branches. */ 143498948Sobrien } 143598948Sobrien } 143698948Sobrien 143798948Sobrien /* Not a branch or branch not taken; target PC is: 143898948Sobrien pc + 4 */ 143998948Sobrien return (pc + 4); 144098948Sobrien} 144198948Sobrien 144298948Sobrienvoid 144398948Sobrienalpha_software_single_step (enum target_signal sig, int insert_breakpoints_p) 144498948Sobrien{ 144598948Sobrien static CORE_ADDR next_pc; 144698948Sobrien typedef char binsn_quantum[BREAKPOINT_MAX]; 144798948Sobrien static binsn_quantum break_mem; 144898948Sobrien CORE_ADDR pc; 144998948Sobrien 145098948Sobrien if (insert_breakpoints_p) 145198948Sobrien { 145298948Sobrien pc = read_pc (); 145398948Sobrien next_pc = alpha_next_pc (pc); 145498948Sobrien 145598948Sobrien target_insert_breakpoint (next_pc, break_mem); 145698948Sobrien } 145798948Sobrien else 145898948Sobrien { 145998948Sobrien target_remove_breakpoint (next_pc, break_mem); 146098948Sobrien write_pc (next_pc); 146198948Sobrien } 146298948Sobrien} 146398948Sobrien 1464130809Smarcel 1465130809Smarcel/* Initialize the current architecture based on INFO. If possible, re-use an 1466130809Smarcel architecture from ARCHES, which is a list of architectures already created 1467130809Smarcel during this debugging session. 1468130809Smarcel 1469130809Smarcel Called e.g. at program startup, when reading a core file, and when reading 1470130809Smarcel a binary file. */ 1471130809Smarcel 1472130809Smarcelstatic struct gdbarch * 1473130809Smarcelalpha_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) 1474130809Smarcel{ 1475130809Smarcel struct gdbarch_tdep *tdep; 1476130809Smarcel struct gdbarch *gdbarch; 1477130809Smarcel 1478130809Smarcel /* Try to determine the ABI of the object we are loading. */ 1479130809Smarcel if (info.abfd != NULL && info.osabi == GDB_OSABI_UNKNOWN) 1480130809Smarcel { 1481130809Smarcel /* If it's an ECOFF file, assume it's OSF/1. */ 1482130809Smarcel if (bfd_get_flavour (info.abfd) == bfd_target_ecoff_flavour) 1483130809Smarcel info.osabi = GDB_OSABI_OSF1; 1484130809Smarcel } 1485130809Smarcel 1486130809Smarcel /* Find a candidate among extant architectures. */ 1487130809Smarcel arches = gdbarch_list_lookup_by_info (arches, &info); 1488130809Smarcel if (arches != NULL) 1489130809Smarcel return arches->gdbarch; 1490130809Smarcel 1491130809Smarcel tdep = xmalloc (sizeof (struct gdbarch_tdep)); 1492130809Smarcel gdbarch = gdbarch_alloc (&info, tdep); 1493130809Smarcel 1494130809Smarcel /* Lowest text address. This is used by heuristic_proc_start() 1495130809Smarcel to decide when to stop looking. */ 1496130809Smarcel tdep->vm_min_address = (CORE_ADDR) 0x120000000; 1497130809Smarcel 1498130809Smarcel tdep->dynamic_sigtramp_offset = NULL; 1499130809Smarcel tdep->sigcontext_addr = NULL; 1500130809Smarcel tdep->sc_pc_offset = 2 * 8; 1501130809Smarcel tdep->sc_regs_offset = 4 * 8; 1502130809Smarcel tdep->sc_fpregs_offset = tdep->sc_regs_offset + 32 * 8 + 8; 1503130809Smarcel 1504130809Smarcel tdep->jb_pc = -1; /* longjmp support not enabled by default */ 1505130809Smarcel 1506130809Smarcel /* Type sizes */ 1507130809Smarcel set_gdbarch_short_bit (gdbarch, 16); 1508130809Smarcel set_gdbarch_int_bit (gdbarch, 32); 1509130809Smarcel set_gdbarch_long_bit (gdbarch, 64); 1510130809Smarcel set_gdbarch_long_long_bit (gdbarch, 64); 1511130809Smarcel set_gdbarch_float_bit (gdbarch, 32); 1512130809Smarcel set_gdbarch_double_bit (gdbarch, 64); 1513130809Smarcel set_gdbarch_long_double_bit (gdbarch, 64); 1514130809Smarcel set_gdbarch_ptr_bit (gdbarch, 64); 1515130809Smarcel 1516130809Smarcel /* Register info */ 1517130809Smarcel set_gdbarch_num_regs (gdbarch, ALPHA_NUM_REGS); 1518130809Smarcel set_gdbarch_sp_regnum (gdbarch, ALPHA_SP_REGNUM); 1519130809Smarcel set_gdbarch_pc_regnum (gdbarch, ALPHA_PC_REGNUM); 1520130809Smarcel set_gdbarch_fp0_regnum (gdbarch, ALPHA_FP0_REGNUM); 1521130809Smarcel 1522130809Smarcel set_gdbarch_register_name (gdbarch, alpha_register_name); 1523130809Smarcel set_gdbarch_deprecated_register_byte (gdbarch, alpha_register_byte); 1524130809Smarcel set_gdbarch_deprecated_register_raw_size (gdbarch, alpha_register_raw_size); 1525130809Smarcel set_gdbarch_deprecated_register_virtual_size (gdbarch, alpha_register_virtual_size); 1526130809Smarcel set_gdbarch_register_type (gdbarch, alpha_register_type); 1527130809Smarcel 1528130809Smarcel set_gdbarch_cannot_fetch_register (gdbarch, alpha_cannot_fetch_register); 1529130809Smarcel set_gdbarch_cannot_store_register (gdbarch, alpha_cannot_store_register); 1530130809Smarcel 1531130809Smarcel set_gdbarch_convert_register_p (gdbarch, alpha_convert_register_p); 1532130809Smarcel set_gdbarch_register_to_value (gdbarch, alpha_register_to_value); 1533130809Smarcel set_gdbarch_value_to_register (gdbarch, alpha_value_to_register); 1534130809Smarcel 1535130809Smarcel set_gdbarch_register_reggroup_p (gdbarch, alpha_register_reggroup_p); 1536130809Smarcel 1537130809Smarcel /* Prologue heuristics. */ 1538130809Smarcel set_gdbarch_skip_prologue (gdbarch, alpha_skip_prologue); 1539130809Smarcel 1540130809Smarcel /* Disassembler. */ 1541130809Smarcel set_gdbarch_print_insn (gdbarch, print_insn_alpha); 1542130809Smarcel 1543130809Smarcel /* Call info. */ 1544130809Smarcel 1545130809Smarcel set_gdbarch_use_struct_convention (gdbarch, always_use_struct_convention); 1546130809Smarcel set_gdbarch_extract_return_value (gdbarch, alpha_extract_return_value); 1547130809Smarcel set_gdbarch_store_return_value (gdbarch, alpha_store_return_value); 1548130809Smarcel set_gdbarch_deprecated_extract_struct_value_address (gdbarch, alpha_extract_struct_value_address); 1549130809Smarcel 1550130809Smarcel /* Settings for calling functions in the inferior. */ 1551130809Smarcel set_gdbarch_push_dummy_call (gdbarch, alpha_push_dummy_call); 1552130809Smarcel 1553130809Smarcel /* Methods for saving / extracting a dummy frame's ID. */ 1554130809Smarcel set_gdbarch_unwind_dummy_id (gdbarch, alpha_unwind_dummy_id); 1555130809Smarcel 1556130809Smarcel /* Return the unwound PC value. */ 1557130809Smarcel set_gdbarch_unwind_pc (gdbarch, alpha_unwind_pc); 1558130809Smarcel 1559130809Smarcel set_gdbarch_inner_than (gdbarch, core_addr_lessthan); 1560130809Smarcel set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target); 1561130809Smarcel 1562130809Smarcel set_gdbarch_breakpoint_from_pc (gdbarch, alpha_breakpoint_from_pc); 1563130809Smarcel set_gdbarch_decr_pc_after_break (gdbarch, 4); 1564130809Smarcel 1565130809Smarcel /* Hook in ABI-specific overrides, if they have been registered. */ 1566130809Smarcel gdbarch_init_osabi (info, gdbarch); 1567130809Smarcel 1568130809Smarcel /* Now that we have tuned the configuration, set a few final things 1569130809Smarcel based on what the OS ABI has told us. */ 1570130809Smarcel 1571130809Smarcel if (tdep->jb_pc >= 0) 1572130809Smarcel set_gdbarch_get_longjmp_target (gdbarch, alpha_get_longjmp_target); 1573130809Smarcel 1574130809Smarcel frame_unwind_append_sniffer (gdbarch, alpha_sigtramp_frame_sniffer); 1575130809Smarcel frame_unwind_append_sniffer (gdbarch, alpha_heuristic_frame_sniffer); 1576130809Smarcel 1577130809Smarcel frame_base_set_default (gdbarch, &alpha_heuristic_frame_base); 1578130809Smarcel 1579130809Smarcel return gdbarch; 1580130809Smarcel} 1581130809Smarcel 158298948Sobrienvoid 1583130809Smarcelalpha_dwarf2_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) 1584130809Smarcel{ 1585130809Smarcel frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer); 1586130809Smarcel frame_base_append_sniffer (gdbarch, dwarf2_frame_base_sniffer); 1587130809Smarcel} 1588130809Smarcel 1589130809Smarcelextern initialize_file_ftype _initialize_alpha_tdep; /* -Wmissing-prototypes */ 1590130809Smarcel 1591130809Smarcelvoid 159298948Sobrien_initialize_alpha_tdep (void) 159398948Sobrien{ 159446319Sdfr struct cmd_list_element *c; 159546319Sdfr 1596130809Smarcel gdbarch_register (bfd_arch_alpha, alpha_gdbarch_init, NULL); 159746319Sdfr 159846319Sdfr /* Let the user set the fence post for heuristic_proc_start. */ 159946319Sdfr 160046319Sdfr /* We really would like to have both "0" and "unlimited" work, but 160146319Sdfr command.c doesn't deal with that. So make it a var_zinteger 160246319Sdfr because the user can always use "999999" or some such for unlimited. */ 160346319Sdfr c = add_set_cmd ("heuristic-fence-post", class_support, var_zinteger, 160446319Sdfr (char *) &heuristic_fence_post, 160546319Sdfr "\ 160646319SdfrSet the distance searched for the start of a function.\n\ 160746319SdfrIf you are debugging a stripped executable, GDB needs to search through the\n\ 160846319Sdfrprogram for the start of a function. This command sets the distance of the\n\ 160946319Sdfrsearch. The only need to set it is when debugging a stripped executable.", 161046319Sdfr &setlist); 161146319Sdfr /* We need to throw away the frame cache when we set this, since it 161246319Sdfr might change our ability to get backtraces. */ 161398948Sobrien set_cmd_sfunc (c, reinit_frame_cache_sfunc); 161446319Sdfr add_show_from_set (c, &showlist); 161546319Sdfr} 1616