1122702Sandre/* Target-dependent code for Renesas D10V, for GDB. 2122702Sandre 3122702Sandre Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003 Free Software 4122702Sandre Foundation, Inc. 5122702Sandre 6122702Sandre This file is part of GDB. 7122702Sandre 8122702Sandre This program is free software; you can redistribute it and/or modify 9122702Sandre it under the terms of the GNU General Public License as published by 10122702Sandre the Free Software Foundation; either version 2 of the License, or 11122702Sandre (at your option) any later version. 12122702Sandre 13122702Sandre This program is distributed in the hope that it will be useful, 14122702Sandre but WITHOUT ANY WARRANTY; without even the implied warranty of 15122702Sandre MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16122702Sandre GNU General Public License for more details. 17122702Sandre 18122702Sandre You should have received a copy of the GNU General Public License 19122702Sandre along with this program; if not, write to the Free Software 20122702Sandre Foundation, Inc., 59 Temple Place - Suite 330, 21122702Sandre Boston, MA 02111-1307, USA. */ 22122702Sandre 23122702Sandre/* Contributed by Martin Hunt, hunt@cygnus.com */ 24122702Sandre 25122702Sandre#include "defs.h" 26122702Sandre#include "frame.h" 27122702Sandre#include "frame-unwind.h" 28122702Sandre#include "frame-base.h" 29122702Sandre#include "symtab.h" 30122702Sandre#include "gdbtypes.h" 31122702Sandre#include "gdbcmd.h" 32122702Sandre#include "gdbcore.h" 33122702Sandre#include "gdb_string.h" 34122702Sandre#include "value.h" 35122702Sandre#include "inferior.h" 36122702Sandre#include "dis-asm.h" 37122702Sandre#include "symfile.h" 38122702Sandre#include "objfiles.h" 39122759Sandre#include "language.h" 40122759Sandre#include "arch-utils.h" 41122759Sandre#include "regcache.h" 42122759Sandre#include "remote.h" 43122702Sandre#include "floatformat.h" 44122702Sandre#include "gdb/sim-d10v.h" 45122702Sandre#include "sim-regno.h" 46122702Sandre#include "disasm.h" 47122702Sandre#include "trad-frame.h" 48122702Sandre 49122702Sandre#include "gdb_assert.h" 50122702Sandre 51122702Sandrestruct gdbarch_tdep 52122702Sandre { 53122702Sandre int a0_regnum; 54122702Sandre int nr_dmap_regs; 55122702Sandre unsigned long (*dmap_register) (void *regcache, int nr); 56122702Sandre unsigned long (*imap_register) (void *regcache, int nr); 57122702Sandre }; 58122702Sandre 59122702Sandre/* These are the addresses the D10V-EVA board maps data and 60122702Sandre instruction memory to. */ 61122702Sandre 62122702Sandreenum memspace { 63122702Sandre DMEM_START = 0x2000000, 64122702Sandre IMEM_START = 0x1000000, 65122702Sandre STACK_START = 0x200bffe 66122702Sandre}; 67122702Sandre 68122702Sandre/* d10v register names. */ 69122702Sandre 70122702Sandreenum 71122702Sandre { 72122702Sandre R0_REGNUM = 0, 73122702Sandre R3_REGNUM = 3, 74122702Sandre D10V_FP_REGNUM = 11, 75122702Sandre LR_REGNUM = 13, 76122702Sandre D10V_SP_REGNUM = 15, 77122702Sandre PSW_REGNUM = 16, 78122702Sandre D10V_PC_REGNUM = 18, 79122702Sandre NR_IMAP_REGS = 2, 80122702Sandre NR_A_REGS = 2, 81122702Sandre TS2_NUM_REGS = 37, 82122702Sandre TS3_NUM_REGS = 42, 83122702Sandre /* d10v calling convention. */ 84122702Sandre ARG1_REGNUM = R0_REGNUM, 85122702Sandre ARGN_REGNUM = R3_REGNUM 86122702Sandre }; 87122702Sandre 88122702Sandrestatic int 89122702Sandrenr_dmap_regs (struct gdbarch *gdbarch) 90122702Sandre{ 91122702Sandre return gdbarch_tdep (gdbarch)->nr_dmap_regs; 92122702Sandre} 93122702Sandre 94122702Sandrestatic int 95122702Sandrea0_regnum (struct gdbarch *gdbarch) 96122702Sandre{ 97122702Sandre return gdbarch_tdep (gdbarch)->a0_regnum; 98122702Sandre} 99122702Sandre 100122702Sandre/* Local functions */ 101122702Sandre 102122702Sandreextern void _initialize_d10v_tdep (void); 103122702Sandre 104122702Sandrestatic void d10v_eva_prepare_to_trace (void); 105122702Sandre 106122702Sandrestatic void d10v_eva_get_trace_data (void); 107122702Sandre 108122702Sandrestatic CORE_ADDR 109122702Sandred10v_frame_align (struct gdbarch *gdbarch, CORE_ADDR sp) 110122702Sandre{ 111122702Sandre /* Align to the size of an instruction (so that they can safely be 112122702Sandre pushed onto the stack. */ 113126239Smlaier return sp & ~3; 114122702Sandre} 115122702Sandre 116122702Sandrestatic const unsigned char * 117122702Sandred10v_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr) 118122702Sandre{ 119122702Sandre static unsigned char breakpoint[] = 120128872Sandre {0x2f, 0x90, 0x5e, 0x00}; 121128872Sandre *lenptr = sizeof (breakpoint); 122128872Sandre return breakpoint; 123128872Sandre} 124128872Sandre 125128872Sandre/* Map the REG_NR onto an ascii name. Return NULL or an empty string 126128872Sandre when the reg_nr isn't valid. */ 127128872Sandre 128128872Sandreenum ts2_regnums 129128872Sandre { 130128872Sandre TS2_IMAP0_REGNUM = 32, 131128872Sandre TS2_DMAP_REGNUM = 34, 132128872Sandre TS2_NR_DMAP_REGS = 1, 133128872Sandre TS2_A0_REGNUM = 35 134128872Sandre }; 135128872Sandre 136128872Sandrestatic const char * 137128872Sandred10v_ts2_register_name (int reg_nr) 138128872Sandre{ 139128872Sandre static char *register_names[] = 140128872Sandre { 141128872Sandre "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", 142128872Sandre "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", 143128872Sandre "psw", "bpsw", "pc", "bpc", "cr4", "cr5", "cr6", "rpt_c", 144128872Sandre "rpt_s", "rpt_e", "mod_s", "mod_e", "cr12", "cr13", "iba", "cr15", 145128872Sandre "imap0", "imap1", "dmap", "a0", "a1" 146128872Sandre }; 147128872Sandre if (reg_nr < 0) 148128872Sandre return NULL; 149128872Sandre if (reg_nr >= (sizeof (register_names) / sizeof (*register_names))) 150128872Sandre return NULL; 151128872Sandre return register_names[reg_nr]; 152128872Sandre} 153128872Sandre 154128872Sandreenum ts3_regnums 155128872Sandre { 156122702Sandre TS3_IMAP0_REGNUM = 36, 157122702Sandre TS3_DMAP0_REGNUM = 38, 158122702Sandre TS3_NR_DMAP_REGS = 4, 159122702Sandre TS3_A0_REGNUM = 32 160122702Sandre }; 161122702Sandre 162122702Sandrestatic const char * 163122702Sandred10v_ts3_register_name (int reg_nr) 164122702Sandre{ 165122702Sandre static char *register_names[] = 166122702Sandre { 167122702Sandre "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", 168122702Sandre "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", 169122702Sandre "psw", "bpsw", "pc", "bpc", "cr4", "cr5", "cr6", "rpt_c", 170126239Smlaier "rpt_s", "rpt_e", "mod_s", "mod_e", "cr12", "cr13", "iba", "cr15", 171122702Sandre "a0", "a1", 172122702Sandre "spi", "spu", 173122702Sandre "imap0", "imap1", 174122702Sandre "dmap0", "dmap1", "dmap2", "dmap3" 175122702Sandre }; 176128872Sandre if (reg_nr < 0) 177122702Sandre return NULL; 178122702Sandre if (reg_nr >= (sizeof (register_names) / sizeof (*register_names))) 179128872Sandre return NULL; 180122702Sandre return register_names[reg_nr]; 181122702Sandre} 182122702Sandre 183122702Sandre/* Access the DMAP/IMAP registers in a target independent way. 184122702Sandre 185122702Sandre Divide the D10V's 64k data space into four 16k segments: 186122702Sandre 0x0000 -- 0x3fff, 0x4000 -- 0x7fff, 0x8000 -- 0xbfff, and 187122702Sandre 0xc000 -- 0xffff. 188122702Sandre 189122702Sandre On the TS2, the first two segments (0x0000 -- 0x3fff, 0x4000 -- 190122702Sandre 0x7fff) always map to the on-chip data RAM, and the fourth always 191122702Sandre maps to I/O space. The third (0x8000 - 0xbfff) can be mapped into 192128872Sandre unified memory or instruction memory, under the control of the 193128872Sandre single DMAP register. 194122702Sandre 195122702Sandre On the TS3, there are four DMAP registers, each of which controls 196122702Sandre one of the segments. */ 197122702Sandre 198122702Sandrestatic unsigned long 199122702Sandred10v_ts2_dmap_register (void *regcache, int reg_nr) 200122702Sandre{ 201122702Sandre switch (reg_nr) 202122702Sandre { 203122702Sandre case 0: 204122702Sandre case 1: 205122702Sandre return 0x2000; 206122702Sandre case 2: 207122702Sandre { 208122702Sandre ULONGEST reg; 209122702Sandre regcache_cooked_read_unsigned (regcache, TS2_DMAP_REGNUM, ®); 210122702Sandre return reg; 211122702Sandre } 212122702Sandre default: 213122702Sandre return 0; 214122702Sandre } 215122702Sandre} 216122702Sandre 217122702Sandrestatic unsigned long 218122702Sandred10v_ts3_dmap_register (void *regcache, int reg_nr) 219122702Sandre{ 220122702Sandre ULONGEST reg; 221122702Sandre regcache_cooked_read_unsigned (regcache, TS3_DMAP0_REGNUM + reg_nr, ®); 222122702Sandre return reg; 223122702Sandre} 224122702Sandre 225122702Sandrestatic unsigned long 226122702Sandred10v_ts2_imap_register (void *regcache, int reg_nr) 227122702Sandre{ 228122702Sandre ULONGEST reg; 229122702Sandre regcache_cooked_read_unsigned (regcache, TS2_IMAP0_REGNUM + reg_nr, ®); 230122702Sandre return reg; 231122702Sandre} 232122702Sandre 233122702Sandrestatic unsigned long 234122702Sandred10v_ts3_imap_register (void *regcache, int reg_nr) 235122702Sandre{ 236122702Sandre ULONGEST reg; 237122702Sandre regcache_cooked_read_unsigned (regcache, TS3_IMAP0_REGNUM + reg_nr, ®); 238122702Sandre return reg; 239122702Sandre} 240122702Sandre 241122702Sandre/* MAP GDB's internal register numbering (determined by the layout 242122702Sandre from the DEPRECATED_REGISTER_BYTE array) onto the simulator's 243122702Sandre register numbering. */ 244122702Sandre 245122702Sandrestatic int 246122702Sandred10v_ts2_register_sim_regno (int nr) 247122702Sandre{ 248122702Sandre /* Only makes sense to supply raw registers. */ 249122702Sandre gdb_assert (nr >= 0 && nr < NUM_REGS); 250122702Sandre if (nr >= TS2_IMAP0_REGNUM 251122702Sandre && nr < TS2_IMAP0_REGNUM + NR_IMAP_REGS) 252122702Sandre return nr - TS2_IMAP0_REGNUM + SIM_D10V_IMAP0_REGNUM; 253122702Sandre if (nr == TS2_DMAP_REGNUM) 254122702Sandre return nr - TS2_DMAP_REGNUM + SIM_D10V_TS2_DMAP_REGNUM; 255122702Sandre if (nr >= TS2_A0_REGNUM 256122702Sandre && nr < TS2_A0_REGNUM + NR_A_REGS) 257122702Sandre return nr - TS2_A0_REGNUM + SIM_D10V_A0_REGNUM; 258128872Sandre return nr; 259122702Sandre} 260122702Sandre 261122702Sandrestatic int 262122702Sandred10v_ts3_register_sim_regno (int nr) 263128872Sandre{ 264122702Sandre /* Only makes sense to supply raw registers. */ 265122702Sandre gdb_assert (nr >= 0 && nr < NUM_REGS); 266122702Sandre if (nr >= TS3_IMAP0_REGNUM 267122702Sandre && nr < TS3_IMAP0_REGNUM + NR_IMAP_REGS) 268122702Sandre return nr - TS3_IMAP0_REGNUM + SIM_D10V_IMAP0_REGNUM; 269122702Sandre if (nr >= TS3_DMAP0_REGNUM 270122702Sandre && nr < TS3_DMAP0_REGNUM + TS3_NR_DMAP_REGS) 271128872Sandre return nr - TS3_DMAP0_REGNUM + SIM_D10V_DMAP0_REGNUM; 272122702Sandre if (nr >= TS3_A0_REGNUM 273128872Sandre && nr < TS3_A0_REGNUM + NR_A_REGS) 274128872Sandre return nr - TS3_A0_REGNUM + SIM_D10V_A0_REGNUM; 275122702Sandre return nr; 276128872Sandre} 277122702Sandre 278122702Sandre/* Return the GDB type object for the "standard" data type 279122702Sandre of data in register N. */ 280122702Sandre 281122702Sandrestatic struct type * 282122702Sandred10v_register_type (struct gdbarch *gdbarch, int reg_nr) 283122702Sandre{ 284122702Sandre if (reg_nr == D10V_PC_REGNUM) 285122702Sandre return builtin_type (gdbarch)->builtin_func_ptr; 286122702Sandre if (reg_nr == D10V_SP_REGNUM || reg_nr == D10V_FP_REGNUM) 287122702Sandre return builtin_type (gdbarch)->builtin_data_ptr; 288122702Sandre else if (reg_nr >= a0_regnum (gdbarch) 289122702Sandre && reg_nr < (a0_regnum (gdbarch) + NR_A_REGS)) 290122702Sandre return builtin_type_int64; 291122702Sandre else 292122702Sandre return builtin_type_int16; 293122702Sandre} 294122702Sandre 295129017Sandrestatic int 296129017Sandred10v_iaddr_p (CORE_ADDR x) 297129017Sandre{ 298129017Sandre return (((x) & 0x3000000) == IMEM_START); 299129017Sandre} 300129017Sandre 301129017Sandrestatic CORE_ADDR 302129017Sandred10v_make_daddr (CORE_ADDR x) 303129017Sandre{ 304129017Sandre return ((x) | DMEM_START); 305122702Sandre} 306122702Sandre 307122702Sandrestatic CORE_ADDR 308122702Sandred10v_make_iaddr (CORE_ADDR x) 309122702Sandre{ 310122702Sandre if (d10v_iaddr_p (x)) 311122702Sandre return x; /* Idempotency -- x is already in the IMEM space. */ 312122702Sandre else 313122702Sandre return (((x) << 2) | IMEM_START); 314122702Sandre} 315122702Sandre 316122702Sandrestatic CORE_ADDR 317122702Sandred10v_convert_iaddr_to_raw (CORE_ADDR x) 318122702Sandre{ 319122702Sandre return (((x) >> 2) & 0xffff); 320122702Sandre} 321122702Sandre 322128872Sandrestatic CORE_ADDR 323122702Sandred10v_convert_daddr_to_raw (CORE_ADDR x) 324122702Sandre{ 325122702Sandre return ((x) & 0xffff); 326122702Sandre} 327122702Sandre 328122702Sandrestatic void 329128872Sandred10v_address_to_pointer (struct type *type, void *buf, CORE_ADDR addr) 330122702Sandre{ 331122702Sandre /* Is it a code address? */ 332122702Sandre if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC 333122702Sandre || TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_METHOD) 334122702Sandre { 335122702Sandre store_unsigned_integer (buf, TYPE_LENGTH (type), 336122702Sandre d10v_convert_iaddr_to_raw (addr)); 337122702Sandre } 338122702Sandre else 339122702Sandre { 340122702Sandre /* Strip off any upper segment bits. */ 341128872Sandre store_unsigned_integer (buf, TYPE_LENGTH (type), 342122702Sandre d10v_convert_daddr_to_raw (addr)); 343122702Sandre } 344128872Sandre} 345122702Sandre 346122702Sandrestatic CORE_ADDR 347122702Sandred10v_pointer_to_address (struct type *type, const void *buf) 348122702Sandre{ 349122702Sandre CORE_ADDR addr = extract_unsigned_integer (buf, TYPE_LENGTH (type)); 350122702Sandre /* Is it a code address? */ 351122702Sandre if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC 352122702Sandre || TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_METHOD 353128872Sandre || TYPE_CODE_SPACE (TYPE_TARGET_TYPE (type))) 354128872Sandre return d10v_make_iaddr (addr); 355128872Sandre else 356128872Sandre return d10v_make_daddr (addr); 357128872Sandre} 358128872Sandre 359122702Sandre/* Don't do anything if we have an integer, this way users can type 'x 360122702Sandre <addr>' w/o having gdb outsmart them. The internal gdb conversions 361122702Sandre to the correct space are taken care of in the pointer_to_address 362122702Sandre function. If we don't do this, 'x $fp' wouldn't work. */ 363122702Sandrestatic CORE_ADDR 364122702Sandred10v_integer_to_address (struct type *type, void *buf) 365122702Sandre{ 366122702Sandre LONGEST val; 367122702Sandre val = unpack_long (type, buf); 368122702Sandre return val; 369122702Sandre} 370122702Sandre 371122702Sandre/* Handle the d10v's return_value convention. */ 372122702Sandre 373122702Sandrestatic enum return_value_convention 374122702Sandred10v_return_value (struct gdbarch *gdbarch, struct type *valtype, 375122702Sandre struct regcache *regcache, void *readbuf, 376122702Sandre const void *writebuf) 377122702Sandre{ 378122702Sandre if (TYPE_LENGTH (valtype) > 8) 379122702Sandre /* Anything larger than 8 bytes (4 registers) goes on the stack. */ 380122702Sandre return RETURN_VALUE_STRUCT_CONVENTION; 381122702Sandre if (TYPE_LENGTH (valtype) == 5 382122702Sandre || TYPE_LENGTH (valtype) == 6) 383122702Sandre /* Anything 5 or 6 bytes in size goes in memory. Contents don't 384122702Sandre appear to matter. Note that 7 and 8 byte objects do end up in 385122702Sandre registers! */ 386122702Sandre return RETURN_VALUE_STRUCT_CONVENTION; 387122702Sandre if (TYPE_LENGTH (valtype) == 1) 388122702Sandre { 389122702Sandre /* All single byte values go in a register stored right-aligned. 390122702Sandre Note: 2 byte integer values are handled further down. */ 391122702Sandre if (readbuf) 392122702Sandre { 393122702Sandre /* Since TYPE is smaller than the register, there isn't a 394122702Sandre sign extension problem. Let the extraction truncate the 395122702Sandre register value. */ 396122702Sandre ULONGEST regval; 397122702Sandre regcache_cooked_read_unsigned (regcache, R0_REGNUM, 398122702Sandre ®val); 399122702Sandre store_unsigned_integer (readbuf, TYPE_LENGTH (valtype), regval); 400122702Sandre 401122702Sandre } 402122702Sandre if (writebuf) 403122702Sandre { 404122702Sandre ULONGEST regval; 405122702Sandre if (TYPE_CODE (valtype) == TYPE_CODE_INT) 406122702Sandre /* Some sort of integer value stored in R0. Use 407122702Sandre unpack_long since that should handle any required sign 408126239Smlaier extension. */ 409122702Sandre regval = unpack_long (valtype, writebuf); 410122702Sandre else 411122702Sandre /* Some other type. Don't sign-extend the value when 412122702Sandre storing it in the register. */ 413122702Sandre regval = extract_unsigned_integer (writebuf, 1); 414126239Smlaier regcache_cooked_write_unsigned (regcache, R0_REGNUM, regval); 415122702Sandre } 416126239Smlaier return RETURN_VALUE_REGISTER_CONVENTION; 417126239Smlaier } 418122702Sandre if ((TYPE_CODE (valtype) == TYPE_CODE_STRUCT 419122702Sandre || TYPE_CODE (valtype) == TYPE_CODE_UNION) 420122702Sandre && TYPE_NFIELDS (valtype) > 1 421122702Sandre && TYPE_FIELD_BITPOS (valtype, 1) == 8) 422122702Sandre /* If a composite is 8 bit aligned (determined by looking at the 423126239Smlaier start address of the second field), put it in memory. */ 424126239Smlaier return RETURN_VALUE_STRUCT_CONVENTION; 425126239Smlaier /* Assume it is in registers. */ 426122702Sandre if (writebuf || readbuf) 427122702Sandre { 428122702Sandre int reg; 429122702Sandre /* Per above, the value is never more than 8 bytes long. */ 430126239Smlaier gdb_assert (TYPE_LENGTH (valtype) <= 8); 431122702Sandre /* Xfer 2 bytes at a time. */ 432122702Sandre for (reg = 0; (reg * 2) + 1 < TYPE_LENGTH (valtype); reg++) 433122702Sandre { 434122702Sandre if (readbuf) 435122702Sandre regcache_cooked_read (regcache, R0_REGNUM + reg, 436126239Smlaier (bfd_byte *) readbuf + reg * 2); 437122702Sandre if (writebuf) 438122702Sandre regcache_cooked_write (regcache, R0_REGNUM + reg, 439122702Sandre (bfd_byte *) writebuf + reg * 2); 440126239Smlaier } 441122702Sandre /* Any trailing byte ends up _left_ aligned. */ 442122702Sandre if ((reg * 2) < TYPE_LENGTH (valtype)) 443122702Sandre { 444122702Sandre if (readbuf) 445122702Sandre regcache_cooked_read_part (regcache, R0_REGNUM + reg, 446122702Sandre 0, 1, (bfd_byte *) readbuf + reg * 2); 447122702Sandre if (writebuf) 448122702Sandre regcache_cooked_write_part (regcache, R0_REGNUM + reg, 449122702Sandre 0, 1, (bfd_byte *) writebuf + reg * 2); 450122702Sandre } 451122702Sandre } 452122702Sandre return RETURN_VALUE_REGISTER_CONVENTION; 453122702Sandre} 454122702Sandre 455122702Sandrestatic int 456122702Sandrecheck_prologue (unsigned short op) 457122702Sandre{ 458122702Sandre /* st rn, @-sp */ 459122702Sandre if ((op & 0x7E1F) == 0x6C1F) 460122702Sandre return 1; 461122702Sandre 462122702Sandre /* st2w rn, @-sp */ 463122702Sandre if ((op & 0x7E3F) == 0x6E1F) 464122702Sandre return 1; 465122702Sandre 466122702Sandre /* subi sp, n */ 467122702Sandre if ((op & 0x7FE1) == 0x01E1) 468122702Sandre return 1; 469122702Sandre 470122702Sandre /* mv r11, sp */ 471122702Sandre if (op == 0x417E) 472122702Sandre return 1; 473122702Sandre 474122702Sandre /* nop */ 475122702Sandre if (op == 0x5E00) 476122702Sandre return 1; 477122702Sandre 478122702Sandre /* st rn, @sp */ 479122702Sandre if ((op & 0x7E1F) == 0x681E) 480122702Sandre return 1; 481122702Sandre 482122702Sandre /* st2w rn, @sp */ 483122702Sandre if ((op & 0x7E3F) == 0x3A1E) 484122702Sandre return 1; 485122702Sandre 486122702Sandre return 0; 487123740Speter} 488122702Sandre 489122702Sandrestatic CORE_ADDR 490122702Sandred10v_skip_prologue (CORE_ADDR pc) 491122702Sandre{ 492122702Sandre unsigned long op; 493122702Sandre unsigned short op1, op2; 494122702Sandre CORE_ADDR func_addr, func_end; 495122702Sandre struct symtab_and_line sal; 496122702Sandre 497122702Sandre /* If we have line debugging information, then the end of the prologue 498122702Sandre should be the first assembly instruction of the first source line. */ 499122702Sandre if (find_pc_partial_function (pc, NULL, &func_addr, &func_end)) 500122702Sandre { 501122702Sandre sal = find_pc_line (func_addr, 0); 502122702Sandre if (sal.end && sal.end < func_end) 503122702Sandre return sal.end; 504122702Sandre } 505122702Sandre 506122702Sandre if (target_read_memory (pc, (char *) &op, 4)) 507128872Sandre return pc; /* Can't access it -- assume no prologue. */ 508128872Sandre 509128872Sandre while (1) 510122702Sandre { 511122702Sandre op = (unsigned long) read_memory_integer (pc, 4); 512122702Sandre if ((op & 0xC0000000) == 0xC0000000) 513122702Sandre { 514122702Sandre /* long instruction */ 515122702Sandre if (((op & 0x3FFF0000) != 0x01FF0000) && /* add3 sp,sp,n */ 516122702Sandre ((op & 0x3F0F0000) != 0x340F0000) && /* st rn, @(offset,sp) */ 517122702Sandre ((op & 0x3F1F0000) != 0x350F0000)) /* st2w rn, @(offset,sp) */ 518122702Sandre break; 519122702Sandre } 520128872Sandre else 521122702Sandre { 522122702Sandre /* short instructions */ 523122702Sandre if ((op & 0xC0000000) == 0x80000000) 524122702Sandre { 525122702Sandre op2 = (op & 0x3FFF8000) >> 15; 526122702Sandre op1 = op & 0x7FFF; 527122702Sandre } 528122702Sandre else 529122702Sandre { 530122759Sandre op1 = (op & 0x3FFF8000) >> 15; 531122702Sandre op2 = op & 0x7FFF; 532122702Sandre } 533122702Sandre if (check_prologue (op1)) 534122702Sandre { 535122702Sandre if (!check_prologue (op2)) 536122702Sandre { 537122702Sandre /* If the previous opcode was really part of the 538122702Sandre prologue and not just a NOP, then we want to 539122702Sandre break after both instructions. */ 540128872Sandre if (op1 != 0x5E00) 541122702Sandre pc += 4; 542128872Sandre break; 543122702Sandre } 544122702Sandre } 545122702Sandre else 546122702Sandre break; 547122702Sandre } 548122702Sandre pc += 4; 549122702Sandre } 550122702Sandre return pc; 551122702Sandre} 552128872Sandre 553122702Sandrestruct d10v_unwind_cache 554122702Sandre{ 555122702Sandre /* The previous frame's inner most stack address. Used as this 556122702Sandre frame ID's stack_addr. */ 557122702Sandre CORE_ADDR prev_sp; 558122702Sandre /* The frame's base, optionally used by the high-level debug info. */ 559126239Smlaier CORE_ADDR base; 560122702Sandre int size; 561122702Sandre /* How far the SP and r11 (FP) have been offset from the start of 562122702Sandre the stack frame (as defined by the previous frame's stack 563122702Sandre pointer). */ 564122702Sandre LONGEST sp_offset; 565126239Smlaier LONGEST r11_offset; 566122702Sandre int uses_frame; 567126239Smlaier /* Table indicating the location of each and every register. */ 568126239Smlaier struct trad_frame_saved_reg *saved_regs; 569122702Sandre}; 570122702Sandre 571122702Sandrestatic int 572122702Sandreprologue_find_regs (struct d10v_unwind_cache *info, unsigned short op, 573122702Sandre CORE_ADDR addr) 574126239Smlaier{ 575126239Smlaier int n; 576126239Smlaier 577122702Sandre /* st rn, @-sp */ 578122702Sandre if ((op & 0x7E1F) == 0x6C1F) 579122702Sandre { 580122702Sandre n = (op & 0x1E0) >> 5; 581126239Smlaier info->sp_offset -= 2; 582122702Sandre info->saved_regs[n].addr = info->sp_offset; 583122702Sandre return 1; 584122702Sandre } 585122702Sandre 586122702Sandre /* st2w rn, @-sp */ 587126239Smlaier else if ((op & 0x7E3F) == 0x6E1F) 588122702Sandre { 589122702Sandre n = (op & 0x1E0) >> 5; 590122702Sandre info->sp_offset -= 4; 591126239Smlaier info->saved_regs[n + 0].addr = info->sp_offset + 0; 592122702Sandre info->saved_regs[n + 1].addr = info->sp_offset + 2; 593128872Sandre return 1; 594122702Sandre } 595122702Sandre 596122702Sandre /* subi sp, n */ 597122702Sandre if ((op & 0x7FE1) == 0x01E1) 598122702Sandre { 599122702Sandre n = (op & 0x1E) >> 1; 600122702Sandre if (n == 0) 601122702Sandre n = 16; 602122702Sandre info->sp_offset -= n; 603122702Sandre return 1; 604122702Sandre } 605122702Sandre 606122702Sandre /* mv r11, sp */ 607122702Sandre if (op == 0x417E) 608122702Sandre { 609122702Sandre info->uses_frame = 1; 610122702Sandre info->r11_offset = info->sp_offset; 611122702Sandre return 1; 612122702Sandre } 613122702Sandre 614122702Sandre /* st rn, @r11 */ 615122702Sandre if ((op & 0x7E1F) == 0x6816) 616122702Sandre { 617122702Sandre n = (op & 0x1E0) >> 5; 618122702Sandre info->saved_regs[n].addr = info->r11_offset; 619122702Sandre return 1; 620122702Sandre } 621122702Sandre 622122702Sandre /* nop */ 623126239Smlaier if (op == 0x5E00) 624126239Smlaier return 1; 625126239Smlaier 626126239Smlaier /* st rn, @sp */ 627126239Smlaier if ((op & 0x7E1F) == 0x681E) 628122702Sandre { 629122702Sandre n = (op & 0x1E0) >> 5; 630126239Smlaier info->saved_regs[n].addr = info->sp_offset; 631126239Smlaier return 1; 632126239Smlaier } 633122702Sandre 634122702Sandre /* st2w rn, @sp */ 635122702Sandre if ((op & 0x7E3F) == 0x3A1E) 636122702Sandre { 637126239Smlaier n = (op & 0x1E0) >> 5; 638126239Smlaier info->saved_regs[n + 0].addr = info->sp_offset + 0; 639122702Sandre info->saved_regs[n + 1].addr = info->sp_offset + 2; 640122702Sandre return 1; 641122702Sandre } 642122702Sandre 643122702Sandre return 0; 644122702Sandre} 645122702Sandre 646122702Sandre/* Put here the code to store, into fi->saved_regs, the addresses of 647122702Sandre the saved registers of frame described by FRAME_INFO. This 648122702Sandre includes special registers such as pc and fp saved in special ways 649122702Sandre in the stack frame. sp is even more special: the address we return 650122702Sandre for it IS the sp for the next frame. */ 651122702Sandre 652122702Sandrestatic struct d10v_unwind_cache * 653122702Sandred10v_frame_unwind_cache (struct frame_info *next_frame, 654122702Sandre void **this_prologue_cache) 655122702Sandre{ 656128872Sandre struct gdbarch *gdbarch = get_frame_arch (next_frame); 657128872Sandre CORE_ADDR pc; 658128872Sandre ULONGEST prev_sp; 659122702Sandre ULONGEST this_base; 660122702Sandre unsigned long op; 661122702Sandre unsigned short op1, op2; 662122702Sandre int i; 663122702Sandre struct d10v_unwind_cache *info; 664122702Sandre 665122702Sandre if ((*this_prologue_cache)) 666128872Sandre return (*this_prologue_cache); 667128872Sandre 668128872Sandre info = FRAME_OBSTACK_ZALLOC (struct d10v_unwind_cache); 669128872Sandre (*this_prologue_cache) = info; 670128872Sandre info->saved_regs = trad_frame_alloc_saved_regs (next_frame); 671128872Sandre 672128872Sandre info->size = 0; 673128872Sandre info->sp_offset = 0; 674128872Sandre 675128872Sandre info->uses_frame = 0; 676128872Sandre for (pc = frame_func_unwind (next_frame); 677128872Sandre pc > 0 && pc < frame_pc_unwind (next_frame); 678128872Sandre pc += 4) 679128872Sandre { 680128872Sandre op = get_frame_memory_unsigned (next_frame, pc, 4); 681128872Sandre if ((op & 0xC0000000) == 0xC0000000) 682128872Sandre { 683128872Sandre /* long instruction */ 684128872Sandre if ((op & 0x3FFF0000) == 0x01FF0000) 685128872Sandre { 686128872Sandre /* add3 sp,sp,n */ 687128872Sandre short n = op & 0xFFFF; 688128872Sandre info->sp_offset += n; 689128872Sandre } 690128872Sandre else if ((op & 0x3F0F0000) == 0x340F0000) 691128872Sandre { 692128872Sandre /* st rn, @(offset,sp) */ 693122702Sandre short offset = op & 0xFFFF; 694122702Sandre short n = (op >> 20) & 0xF; 695122702Sandre info->saved_regs[n].addr = info->sp_offset + offset; 696122702Sandre } 697122702Sandre else if ((op & 0x3F1F0000) == 0x350F0000) 698122702Sandre { 699122702Sandre /* st2w rn, @(offset,sp) */ 700122702Sandre short offset = op & 0xFFFF; 701122702Sandre short n = (op >> 20) & 0xF; 702122702Sandre info->saved_regs[n + 0].addr = info->sp_offset + offset + 0; 703122702Sandre info->saved_regs[n + 1].addr = info->sp_offset + offset + 2; 704122702Sandre } 705122702Sandre else 706122702Sandre break; 707122702Sandre } 708122702Sandre else 709122702Sandre { 710122702Sandre /* short instructions */ 711122702Sandre if ((op & 0xC0000000) == 0x80000000) 712122702Sandre { 713122702Sandre op2 = (op & 0x3FFF8000) >> 15; 714128872Sandre op1 = op & 0x7FFF; 715122702Sandre } 716122702Sandre else 717128872Sandre { 718122702Sandre op1 = (op & 0x3FFF8000) >> 15; 719123740Speter op2 = op & 0x7FFF; 720128872Sandre } 721122702Sandre if (!prologue_find_regs (info, op1, pc) 722122702Sandre || !prologue_find_regs (info, op2, pc)) 723122702Sandre break; 724122702Sandre } 725122702Sandre } 726128872Sandre 727128872Sandre info->size = -info->sp_offset; 728128872Sandre 729128872Sandre /* Compute the previous frame's stack pointer (which is also the 730122702Sandre frame's ID's stack address), and this frame's base pointer. */ 731122702Sandre if (info->uses_frame) 732122702Sandre { 733122702Sandre /* The SP was moved to the FP. This indicates that a new frame 734122702Sandre was created. Get THIS frame's FP value by unwinding it from 735122702Sandre the next frame. */ 736122702Sandre frame_unwind_unsigned_register (next_frame, D10V_FP_REGNUM, &this_base); 737122702Sandre /* The FP points at the last saved register. Adjust the FP back 738122702Sandre to before the first saved register giving the SP. */ 739122702Sandre prev_sp = this_base + info->size; 740122702Sandre } 741122702Sandre else 742122702Sandre { 743122702Sandre /* Assume that the FP is this frame's SP but with that pushed 744122702Sandre stack space added back. */ 745122702Sandre frame_unwind_unsigned_register (next_frame, D10V_SP_REGNUM, &this_base); 746122702Sandre prev_sp = this_base + info->size; 747122702Sandre } 748122702Sandre 749122702Sandre /* Convert that SP/BASE into real addresses. */ 750122702Sandre info->prev_sp = d10v_make_daddr (prev_sp); 751122702Sandre info->base = d10v_make_daddr (this_base); 752122702Sandre 753122702Sandre /* Adjust all the saved registers so that they contain addresses and 754122702Sandre not offsets. */ 755122702Sandre for (i = 0; i < NUM_REGS - 1; i++) 756122702Sandre if (trad_frame_addr_p (info->saved_regs, i)) 757122702Sandre { 758122702Sandre info->saved_regs[i].addr = (info->prev_sp + info->saved_regs[i].addr); 759122702Sandre } 760122702Sandre 761122702Sandre /* The call instruction moves the caller's PC in the callee's LR. 762122702Sandre Since this is an unwind, do the reverse. Copy the location of LR 763122702Sandre into PC (the address / regnum) so that a request for PC will be 764122702Sandre converted into a request for the LR. */ 765122702Sandre info->saved_regs[D10V_PC_REGNUM] = info->saved_regs[LR_REGNUM]; 766122702Sandre 767128872Sandre /* The previous frame's SP needed to be computed. Save the computed 768122702Sandre value. */ 769122702Sandre trad_frame_set_value (info->saved_regs, D10V_SP_REGNUM, 770122702Sandre d10v_make_daddr (prev_sp)); 771122702Sandre 772122702Sandre return info; 773128872Sandre} 774128872Sandre 775122702Sandrestatic void 776122702Sandred10v_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file, 777 struct frame_info *frame, int regnum, int all) 778{ 779 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); 780 if (regnum >= 0) 781 { 782 default_print_registers_info (gdbarch, file, frame, regnum, all); 783 return; 784 } 785 786 { 787 ULONGEST pc, psw, rpt_s, rpt_e, rpt_c; 788 pc = get_frame_register_unsigned (frame, D10V_PC_REGNUM); 789 psw = get_frame_register_unsigned (frame, PSW_REGNUM); 790 rpt_s = get_frame_register_unsigned (frame, frame_map_name_to_regnum (frame, "rpt_s", -1)); 791 rpt_e = get_frame_register_unsigned (frame, frame_map_name_to_regnum (frame, "rpt_e", -1)); 792 rpt_c = get_frame_register_unsigned (frame, frame_map_name_to_regnum (frame, "rpt_c", -1)); 793 fprintf_filtered (file, "PC=%04lx (0x%lx) PSW=%04lx RPT_S=%04lx RPT_E=%04lx RPT_C=%04lx\n", 794 (long) pc, (long) d10v_make_iaddr (pc), (long) psw, 795 (long) rpt_s, (long) rpt_e, (long) rpt_c); 796 } 797 798 { 799 int group; 800 for (group = 0; group < 16; group += 8) 801 { 802 int r; 803 fprintf_filtered (file, "R%d-R%-2d", group, group + 7); 804 for (r = group; r < group + 8; r++) 805 { 806 ULONGEST tmp; 807 tmp = get_frame_register_unsigned (frame, r); 808 fprintf_filtered (file, " %04lx", (long) tmp); 809 } 810 fprintf_filtered (file, "\n"); 811 } 812 } 813 814 /* Note: The IMAP/DMAP registers don't participate in function 815 calls. Don't bother trying to unwind them. */ 816 817 { 818 int a; 819 for (a = 0; a < NR_IMAP_REGS; a++) 820 { 821 if (a > 0) 822 fprintf_filtered (file, " "); 823 fprintf_filtered (file, "IMAP%d %04lx", a, 824 tdep->imap_register (current_regcache, a)); 825 } 826 if (nr_dmap_regs (gdbarch) == 1) 827 /* Registers DMAP0 and DMAP1 are constant. Just return dmap2. */ 828 fprintf_filtered (file, " DMAP %04lx\n", 829 tdep->dmap_register (current_regcache, 2)); 830 else 831 { 832 for (a = 0; a < nr_dmap_regs (gdbarch); a++) 833 { 834 fprintf_filtered (file, " DMAP%d %04lx", a, 835 tdep->dmap_register (current_regcache, a)); 836 } 837 fprintf_filtered (file, "\n"); 838 } 839 } 840 841 { 842 char num[MAX_REGISTER_SIZE]; 843 int a; 844 fprintf_filtered (file, "A0-A%d", NR_A_REGS - 1); 845 for (a = a0_regnum (gdbarch); a < a0_regnum (gdbarch) + NR_A_REGS; a++) 846 { 847 int i; 848 fprintf_filtered (file, " "); 849 get_frame_register (frame, a, num); 850 for (i = 0; i < register_size (gdbarch, a); i++) 851 { 852 fprintf_filtered (file, "%02x", (num[i] & 0xff)); 853 } 854 } 855 } 856 fprintf_filtered (file, "\n"); 857} 858 859static void 860show_regs (char *args, int from_tty) 861{ 862 d10v_print_registers_info (current_gdbarch, gdb_stdout, 863 get_current_frame (), -1, 1); 864} 865 866static CORE_ADDR 867d10v_read_pc (ptid_t ptid) 868{ 869 ptid_t save_ptid; 870 CORE_ADDR pc; 871 CORE_ADDR retval; 872 873 save_ptid = inferior_ptid; 874 inferior_ptid = ptid; 875 pc = (int) read_register (D10V_PC_REGNUM); 876 inferior_ptid = save_ptid; 877 retval = d10v_make_iaddr (pc); 878 return retval; 879} 880 881static void 882d10v_write_pc (CORE_ADDR val, ptid_t ptid) 883{ 884 ptid_t save_ptid; 885 886 save_ptid = inferior_ptid; 887 inferior_ptid = ptid; 888 write_register (D10V_PC_REGNUM, d10v_convert_iaddr_to_raw (val)); 889 inferior_ptid = save_ptid; 890} 891 892static CORE_ADDR 893d10v_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame) 894{ 895 ULONGEST sp; 896 frame_unwind_unsigned_register (next_frame, D10V_SP_REGNUM, &sp); 897 return d10v_make_daddr (sp); 898} 899 900/* When arguments must be pushed onto the stack, they go on in reverse 901 order. The below implements a FILO (stack) to do this. */ 902 903struct stack_item 904{ 905 int len; 906 struct stack_item *prev; 907 void *data; 908}; 909 910static struct stack_item *push_stack_item (struct stack_item *prev, 911 void *contents, int len); 912static struct stack_item * 913push_stack_item (struct stack_item *prev, void *contents, int len) 914{ 915 struct stack_item *si; 916 si = xmalloc (sizeof (struct stack_item)); 917 si->data = xmalloc (len); 918 si->len = len; 919 si->prev = prev; 920 memcpy (si->data, contents, len); 921 return si; 922} 923 924static struct stack_item *pop_stack_item (struct stack_item *si); 925static struct stack_item * 926pop_stack_item (struct stack_item *si) 927{ 928 struct stack_item *dead = si; 929 si = si->prev; 930 xfree (dead->data); 931 xfree (dead); 932 return si; 933} 934 935 936static CORE_ADDR 937d10v_push_dummy_code (struct gdbarch *gdbarch, 938 CORE_ADDR sp, CORE_ADDR funaddr, int using_gcc, 939 struct value **args, int nargs, 940 struct type *value_type, 941 CORE_ADDR *real_pc, CORE_ADDR *bp_addr) 942{ 943 /* Allocate space sufficient for a breakpoint. */ 944 sp = (sp - 4) & ~3; 945 /* Store the address of that breakpoint taking care to first convert 946 it into a code (IADDR) address from a stack (DADDR) address. 947 This of course assumes that the two virtual addresses map onto 948 the same real address. */ 949 (*bp_addr) = d10v_make_iaddr (d10v_convert_iaddr_to_raw (sp)); 950 /* d10v always starts the call at the callee's entry point. */ 951 (*real_pc) = funaddr; 952 return sp; 953} 954 955static CORE_ADDR 956d10v_push_dummy_call (struct gdbarch *gdbarch, struct value *function, 957 struct regcache *regcache, CORE_ADDR bp_addr, 958 int nargs, struct value **args, CORE_ADDR sp, 959 int struct_return, CORE_ADDR struct_addr) 960{ 961 int i; 962 int regnum = ARG1_REGNUM; 963 struct stack_item *si = NULL; 964 long val; 965 966 /* Set the return address. For the d10v, the return breakpoint is 967 always at BP_ADDR. */ 968 regcache_cooked_write_unsigned (regcache, LR_REGNUM, 969 d10v_convert_iaddr_to_raw (bp_addr)); 970 971 /* If STRUCT_RETURN is true, then the struct return address (in 972 STRUCT_ADDR) will consume the first argument-passing register. 973 Both adjust the register count and store that value. */ 974 if (struct_return) 975 { 976 regcache_cooked_write_unsigned (regcache, regnum, struct_addr); 977 regnum++; 978 } 979 980 /* Fill in registers and arg lists */ 981 for (i = 0; i < nargs; i++) 982 { 983 struct value *arg = args[i]; 984 struct type *type = check_typedef (VALUE_TYPE (arg)); 985 char *contents = VALUE_CONTENTS (arg); 986 int len = TYPE_LENGTH (type); 987 int aligned_regnum = (regnum + 1) & ~1; 988 989 /* printf ("push: type=%d len=%d\n", TYPE_CODE (type), len); */ 990 if (len <= 2 && regnum <= ARGN_REGNUM) 991 /* fits in a single register, do not align */ 992 { 993 val = extract_unsigned_integer (contents, len); 994 regcache_cooked_write_unsigned (regcache, regnum++, val); 995 } 996 else if (len <= (ARGN_REGNUM - aligned_regnum + 1) * 2) 997 /* value fits in remaining registers, store keeping left 998 aligned */ 999 { 1000 int b; 1001 regnum = aligned_regnum; 1002 for (b = 0; b < (len & ~1); b += 2) 1003 { 1004 val = extract_unsigned_integer (&contents[b], 2); 1005 regcache_cooked_write_unsigned (regcache, regnum++, val); 1006 } 1007 if (b < len) 1008 { 1009 val = extract_unsigned_integer (&contents[b], 1); 1010 regcache_cooked_write_unsigned (regcache, regnum++, (val << 8)); 1011 } 1012 } 1013 else 1014 { 1015 /* arg will go onto stack */ 1016 regnum = ARGN_REGNUM + 1; 1017 si = push_stack_item (si, contents, len); 1018 } 1019 } 1020 1021 while (si) 1022 { 1023 sp = (sp - si->len) & ~1; 1024 write_memory (sp, si->data, si->len); 1025 si = pop_stack_item (si); 1026 } 1027 1028 /* Finally, update the SP register. */ 1029 regcache_cooked_write_unsigned (regcache, D10V_SP_REGNUM, 1030 d10v_convert_daddr_to_raw (sp)); 1031 1032 return sp; 1033} 1034 1035/* Translate a GDB virtual ADDR/LEN into a format the remote target 1036 understands. Returns number of bytes that can be transfered 1037 starting at TARG_ADDR. Return ZERO if no bytes can be transfered 1038 (segmentation fault). Since the simulator knows all about how the 1039 VM system works, we just call that to do the translation. */ 1040 1041static void 1042remote_d10v_translate_xfer_address (struct gdbarch *gdbarch, 1043 struct regcache *regcache, 1044 CORE_ADDR memaddr, int nr_bytes, 1045 CORE_ADDR *targ_addr, int *targ_len) 1046{ 1047 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); 1048 long out_addr; 1049 long out_len; 1050 out_len = sim_d10v_translate_addr (memaddr, nr_bytes, &out_addr, regcache, 1051 tdep->dmap_register, tdep->imap_register); 1052 *targ_addr = out_addr; 1053 *targ_len = out_len; 1054} 1055 1056 1057/* The following code implements access to, and display of, the D10V's 1058 instruction trace buffer. The buffer consists of 64K or more 1059 4-byte words of data, of which each words includes an 8-bit count, 1060 an 8-bit segment number, and a 16-bit instruction address. 1061 1062 In theory, the trace buffer is continuously capturing instruction 1063 data that the CPU presents on its "debug bus", but in practice, the 1064 ROMified GDB stub only enables tracing when it continues or steps 1065 the program, and stops tracing when the program stops; so it 1066 actually works for GDB to read the buffer counter out of memory and 1067 then read each trace word. The counter records where the tracing 1068 stops, but there is no record of where it started, so we remember 1069 the PC when we resumed and then search backwards in the trace 1070 buffer for a word that includes that address. This is not perfect, 1071 because you will miss trace data if the resumption PC is the target 1072 of a branch. (The value of the buffer counter is semi-random, any 1073 trace data from a previous program stop is gone.) */ 1074 1075/* The address of the last word recorded in the trace buffer. */ 1076 1077#define DBBC_ADDR (0xd80000) 1078 1079/* The base of the trace buffer, at least for the "Board_0". */ 1080 1081#define TRACE_BUFFER_BASE (0xf40000) 1082 1083static void trace_command (char *, int); 1084 1085static void untrace_command (char *, int); 1086 1087static void trace_info (char *, int); 1088 1089static void tdisassemble_command (char *, int); 1090 1091static void display_trace (int, int); 1092 1093/* True when instruction traces are being collected. */ 1094 1095static int tracing; 1096 1097/* Remembered PC. */ 1098 1099static CORE_ADDR last_pc; 1100 1101/* True when trace output should be displayed whenever program stops. */ 1102 1103static int trace_display; 1104 1105/* True when trace listing should include source lines. */ 1106 1107static int default_trace_show_source = 1; 1108 1109struct trace_buffer 1110 { 1111 int size; 1112 short *counts; 1113 CORE_ADDR *addrs; 1114 } 1115trace_data; 1116 1117static void 1118trace_command (char *args, int from_tty) 1119{ 1120 /* Clear the host-side trace buffer, allocating space if needed. */ 1121 trace_data.size = 0; 1122 if (trace_data.counts == NULL) 1123 trace_data.counts = XCALLOC (65536, short); 1124 if (trace_data.addrs == NULL) 1125 trace_data.addrs = XCALLOC (65536, CORE_ADDR); 1126 1127 tracing = 1; 1128 1129 printf_filtered ("Tracing is now on.\n"); 1130} 1131 1132static void 1133untrace_command (char *args, int from_tty) 1134{ 1135 tracing = 0; 1136 1137 printf_filtered ("Tracing is now off.\n"); 1138} 1139 1140static void 1141trace_info (char *args, int from_tty) 1142{ 1143 int i; 1144 1145 if (trace_data.size) 1146 { 1147 printf_filtered ("%d entries in trace buffer:\n", trace_data.size); 1148 1149 for (i = 0; i < trace_data.size; ++i) 1150 { 1151 printf_filtered ("%d: %d instruction%s at 0x%s\n", 1152 i, 1153 trace_data.counts[i], 1154 (trace_data.counts[i] == 1 ? "" : "s"), 1155 paddr_nz (trace_data.addrs[i])); 1156 } 1157 } 1158 else 1159 printf_filtered ("No entries in trace buffer.\n"); 1160 1161 printf_filtered ("Tracing is currently %s.\n", (tracing ? "on" : "off")); 1162} 1163 1164static void 1165d10v_eva_prepare_to_trace (void) 1166{ 1167 if (!tracing) 1168 return; 1169 1170 last_pc = read_register (D10V_PC_REGNUM); 1171} 1172 1173/* Collect trace data from the target board and format it into a form 1174 more useful for display. */ 1175 1176static void 1177d10v_eva_get_trace_data (void) 1178{ 1179 int count, i, j, oldsize; 1180 int trace_addr, trace_seg, trace_cnt, next_cnt; 1181 unsigned int last_trace, trace_word, next_word; 1182 unsigned int *tmpspace; 1183 1184 if (!tracing) 1185 return; 1186 1187 tmpspace = xmalloc (65536 * sizeof (unsigned int)); 1188 1189 last_trace = read_memory_unsigned_integer (DBBC_ADDR, 2) << 2; 1190 1191 /* Collect buffer contents from the target, stopping when we reach 1192 the word recorded when execution resumed. */ 1193 1194 count = 0; 1195 while (last_trace > 0) 1196 { 1197 QUIT; 1198 trace_word = 1199 read_memory_unsigned_integer (TRACE_BUFFER_BASE + last_trace, 4); 1200 trace_addr = trace_word & 0xffff; 1201 last_trace -= 4; 1202 /* Ignore an apparently nonsensical entry. */ 1203 if (trace_addr == 0xffd5) 1204 continue; 1205 tmpspace[count++] = trace_word; 1206 if (trace_addr == last_pc) 1207 break; 1208 if (count > 65535) 1209 break; 1210 } 1211 1212 /* Move the data to the host-side trace buffer, adjusting counts to 1213 include the last instruction executed and transforming the address 1214 into something that GDB likes. */ 1215 1216 for (i = 0; i < count; ++i) 1217 { 1218 trace_word = tmpspace[i]; 1219 next_word = ((i == 0) ? 0 : tmpspace[i - 1]); 1220 trace_addr = trace_word & 0xffff; 1221 next_cnt = (next_word >> 24) & 0xff; 1222 j = trace_data.size + count - i - 1; 1223 trace_data.addrs[j] = (trace_addr << 2) + 0x1000000; 1224 trace_data.counts[j] = next_cnt + 1; 1225 } 1226 1227 oldsize = trace_data.size; 1228 trace_data.size += count; 1229 1230 xfree (tmpspace); 1231 1232 if (trace_display) 1233 display_trace (oldsize, trace_data.size); 1234} 1235 1236static void 1237tdisassemble_command (char *arg, int from_tty) 1238{ 1239 int i, count; 1240 CORE_ADDR low, high; 1241 1242 if (!arg) 1243 { 1244 low = 0; 1245 high = trace_data.size; 1246 } 1247 else 1248 { 1249 char *space_index = strchr (arg, ' '); 1250 if (space_index == NULL) 1251 { 1252 low = parse_and_eval_address (arg); 1253 high = low + 5; 1254 } 1255 else 1256 { 1257 /* Two arguments. */ 1258 *space_index = '\0'; 1259 low = parse_and_eval_address (arg); 1260 high = parse_and_eval_address (space_index + 1); 1261 if (high < low) 1262 high = low; 1263 } 1264 } 1265 1266 printf_filtered ("Dump of trace from %s to %s:\n", 1267 paddr_u (low), paddr_u (high)); 1268 1269 display_trace (low, high); 1270 1271 printf_filtered ("End of trace dump.\n"); 1272 gdb_flush (gdb_stdout); 1273} 1274 1275static void 1276display_trace (int low, int high) 1277{ 1278 int i, count, trace_show_source, first, suppress; 1279 CORE_ADDR next_address; 1280 1281 trace_show_source = default_trace_show_source; 1282 if (!have_full_symbols () && !have_partial_symbols ()) 1283 { 1284 trace_show_source = 0; 1285 printf_filtered ("No symbol table is loaded. Use the \"file\" command.\n"); 1286 printf_filtered ("Trace will not display any source.\n"); 1287 } 1288 1289 first = 1; 1290 suppress = 0; 1291 for (i = low; i < high; ++i) 1292 { 1293 next_address = trace_data.addrs[i]; 1294 count = trace_data.counts[i]; 1295 while (count-- > 0) 1296 { 1297 QUIT; 1298 if (trace_show_source) 1299 { 1300 struct symtab_and_line sal, sal_prev; 1301 1302 sal_prev = find_pc_line (next_address - 4, 0); 1303 sal = find_pc_line (next_address, 0); 1304 1305 if (sal.symtab) 1306 { 1307 if (first || sal.line != sal_prev.line) 1308 print_source_lines (sal.symtab, sal.line, sal.line + 1, 0); 1309 suppress = 0; 1310 } 1311 else 1312 { 1313 if (!suppress) 1314 /* FIXME-32x64--assumes sal.pc fits in long. */ 1315 printf_filtered ("No source file for address %s.\n", 1316 hex_string ((unsigned long) sal.pc)); 1317 suppress = 1; 1318 } 1319 } 1320 first = 0; 1321 print_address (next_address, gdb_stdout); 1322 printf_filtered (":"); 1323 printf_filtered ("\t"); 1324 wrap_here (" "); 1325 next_address += gdb_print_insn (next_address, gdb_stdout); 1326 printf_filtered ("\n"); 1327 gdb_flush (gdb_stdout); 1328 } 1329 } 1330} 1331 1332static CORE_ADDR 1333d10v_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame) 1334{ 1335 ULONGEST pc; 1336 frame_unwind_unsigned_register (next_frame, D10V_PC_REGNUM, &pc); 1337 return d10v_make_iaddr (pc); 1338} 1339 1340/* Given a GDB frame, determine the address of the calling function's 1341 frame. This will be used to create a new GDB frame struct. */ 1342 1343static void 1344d10v_frame_this_id (struct frame_info *next_frame, 1345 void **this_prologue_cache, 1346 struct frame_id *this_id) 1347{ 1348 struct d10v_unwind_cache *info 1349 = d10v_frame_unwind_cache (next_frame, this_prologue_cache); 1350 CORE_ADDR base; 1351 CORE_ADDR func; 1352 struct frame_id id; 1353 1354 /* The FUNC is easy. */ 1355 func = frame_func_unwind (next_frame); 1356 1357 /* Hopefully the prologue analysis either correctly determined the 1358 frame's base (which is the SP from the previous frame), or set 1359 that base to "NULL". */ 1360 base = info->prev_sp; 1361 if (base == STACK_START || base == 0) 1362 return; 1363 1364 id = frame_id_build (base, func); 1365 1366 (*this_id) = id; 1367} 1368 1369static void 1370d10v_frame_prev_register (struct frame_info *next_frame, 1371 void **this_prologue_cache, 1372 int regnum, int *optimizedp, 1373 enum lval_type *lvalp, CORE_ADDR *addrp, 1374 int *realnump, void *bufferp) 1375{ 1376 struct d10v_unwind_cache *info 1377 = d10v_frame_unwind_cache (next_frame, this_prologue_cache); 1378 trad_frame_get_prev_register (next_frame, info->saved_regs, regnum, 1379 optimizedp, lvalp, addrp, realnump, bufferp); 1380} 1381 1382static const struct frame_unwind d10v_frame_unwind = { 1383 NORMAL_FRAME, 1384 d10v_frame_this_id, 1385 d10v_frame_prev_register 1386}; 1387 1388static const struct frame_unwind * 1389d10v_frame_sniffer (struct frame_info *next_frame) 1390{ 1391 return &d10v_frame_unwind; 1392} 1393 1394static CORE_ADDR 1395d10v_frame_base_address (struct frame_info *next_frame, void **this_cache) 1396{ 1397 struct d10v_unwind_cache *info 1398 = d10v_frame_unwind_cache (next_frame, this_cache); 1399 return info->base; 1400} 1401 1402static const struct frame_base d10v_frame_base = { 1403 &d10v_frame_unwind, 1404 d10v_frame_base_address, 1405 d10v_frame_base_address, 1406 d10v_frame_base_address 1407}; 1408 1409/* Assuming NEXT_FRAME->prev is a dummy, return the frame ID of that 1410 dummy frame. The frame ID's base needs to match the TOS value 1411 saved by save_dummy_frame_tos(), and the PC match the dummy frame's 1412 breakpoint. */ 1413 1414static struct frame_id 1415d10v_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame) 1416{ 1417 return frame_id_build (d10v_unwind_sp (gdbarch, next_frame), 1418 frame_pc_unwind (next_frame)); 1419} 1420 1421static gdbarch_init_ftype d10v_gdbarch_init; 1422 1423static struct gdbarch * 1424d10v_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) 1425{ 1426 struct gdbarch *gdbarch; 1427 int d10v_num_regs; 1428 struct gdbarch_tdep *tdep; 1429 gdbarch_register_name_ftype *d10v_register_name; 1430 gdbarch_register_sim_regno_ftype *d10v_register_sim_regno; 1431 1432 /* Find a candidate among the list of pre-declared architectures. */ 1433 arches = gdbarch_list_lookup_by_info (arches, &info); 1434 if (arches != NULL) 1435 return arches->gdbarch; 1436 1437 /* None found, create a new architecture from the information 1438 provided. */ 1439 tdep = XMALLOC (struct gdbarch_tdep); 1440 gdbarch = gdbarch_alloc (&info, tdep); 1441 1442 switch (info.bfd_arch_info->mach) 1443 { 1444 case bfd_mach_d10v_ts2: 1445 d10v_num_regs = 37; 1446 d10v_register_name = d10v_ts2_register_name; 1447 d10v_register_sim_regno = d10v_ts2_register_sim_regno; 1448 tdep->a0_regnum = TS2_A0_REGNUM; 1449 tdep->nr_dmap_regs = TS2_NR_DMAP_REGS; 1450 tdep->dmap_register = d10v_ts2_dmap_register; 1451 tdep->imap_register = d10v_ts2_imap_register; 1452 break; 1453 default: 1454 case bfd_mach_d10v_ts3: 1455 d10v_num_regs = 42; 1456 d10v_register_name = d10v_ts3_register_name; 1457 d10v_register_sim_regno = d10v_ts3_register_sim_regno; 1458 tdep->a0_regnum = TS3_A0_REGNUM; 1459 tdep->nr_dmap_regs = TS3_NR_DMAP_REGS; 1460 tdep->dmap_register = d10v_ts3_dmap_register; 1461 tdep->imap_register = d10v_ts3_imap_register; 1462 break; 1463 } 1464 1465 set_gdbarch_read_pc (gdbarch, d10v_read_pc); 1466 set_gdbarch_write_pc (gdbarch, d10v_write_pc); 1467 set_gdbarch_unwind_sp (gdbarch, d10v_unwind_sp); 1468 1469 set_gdbarch_num_regs (gdbarch, d10v_num_regs); 1470 set_gdbarch_sp_regnum (gdbarch, D10V_SP_REGNUM); 1471 set_gdbarch_register_name (gdbarch, d10v_register_name); 1472 set_gdbarch_register_type (gdbarch, d10v_register_type); 1473 1474 set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT); 1475 set_gdbarch_addr_bit (gdbarch, 32); 1476 set_gdbarch_address_to_pointer (gdbarch, d10v_address_to_pointer); 1477 set_gdbarch_pointer_to_address (gdbarch, d10v_pointer_to_address); 1478 set_gdbarch_integer_to_address (gdbarch, d10v_integer_to_address); 1479 set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT); 1480 set_gdbarch_int_bit (gdbarch, 2 * TARGET_CHAR_BIT); 1481 set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT); 1482 set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT); 1483 /* NOTE: The d10v as a 32 bit ``float'' and ``double''. ``long 1484 double'' is 64 bits. */ 1485 set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT); 1486 set_gdbarch_double_bit (gdbarch, 4 * TARGET_CHAR_BIT); 1487 set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT); 1488 switch (info.byte_order) 1489 { 1490 case BFD_ENDIAN_BIG: 1491 set_gdbarch_float_format (gdbarch, &floatformat_ieee_single_big); 1492 set_gdbarch_double_format (gdbarch, &floatformat_ieee_single_big); 1493 set_gdbarch_long_double_format (gdbarch, &floatformat_ieee_double_big); 1494 break; 1495 case BFD_ENDIAN_LITTLE: 1496 set_gdbarch_float_format (gdbarch, &floatformat_ieee_single_little); 1497 set_gdbarch_double_format (gdbarch, &floatformat_ieee_single_little); 1498 set_gdbarch_long_double_format (gdbarch, 1499 &floatformat_ieee_double_little); 1500 break; 1501 default: 1502 internal_error (__FILE__, __LINE__, 1503 "d10v_gdbarch_init: bad byte order for float format"); 1504 } 1505 1506 set_gdbarch_return_value (gdbarch, d10v_return_value); 1507 set_gdbarch_push_dummy_code (gdbarch, d10v_push_dummy_code); 1508 set_gdbarch_push_dummy_call (gdbarch, d10v_push_dummy_call); 1509 1510 set_gdbarch_skip_prologue (gdbarch, d10v_skip_prologue); 1511 set_gdbarch_inner_than (gdbarch, core_addr_lessthan); 1512 set_gdbarch_decr_pc_after_break (gdbarch, 4); 1513 set_gdbarch_breakpoint_from_pc (gdbarch, d10v_breakpoint_from_pc); 1514 1515 set_gdbarch_remote_translate_xfer_address (gdbarch, 1516 remote_d10v_translate_xfer_address); 1517 1518 set_gdbarch_frame_align (gdbarch, d10v_frame_align); 1519 1520 set_gdbarch_register_sim_regno (gdbarch, d10v_register_sim_regno); 1521 1522 set_gdbarch_print_registers_info (gdbarch, d10v_print_registers_info); 1523 1524 frame_unwind_append_sniffer (gdbarch, d10v_frame_sniffer); 1525 frame_base_set_default (gdbarch, &d10v_frame_base); 1526 1527 /* Methods for saving / extracting a dummy frame's ID. The ID's 1528 stack address must match the SP value returned by 1529 PUSH_DUMMY_CALL, and saved by generic_save_dummy_frame_tos. */ 1530 set_gdbarch_unwind_dummy_id (gdbarch, d10v_unwind_dummy_id); 1531 1532 /* Return the unwound PC value. */ 1533 set_gdbarch_unwind_pc (gdbarch, d10v_unwind_pc); 1534 1535 set_gdbarch_print_insn (gdbarch, print_insn_d10v); 1536 1537 return gdbarch; 1538} 1539 1540void 1541_initialize_d10v_tdep (void) 1542{ 1543 register_gdbarch_init (bfd_arch_d10v, d10v_gdbarch_init); 1544 1545 deprecated_target_resume_hook = d10v_eva_prepare_to_trace; 1546 deprecated_target_wait_loop_hook = d10v_eva_get_trace_data; 1547 1548 deprecate_cmd (add_com ("regs", class_vars, show_regs, 1549 "Print all registers"), 1550 "info registers"); 1551 1552 add_com ("itrace", class_support, trace_command, 1553 "Enable tracing of instruction execution."); 1554 1555 add_com ("iuntrace", class_support, untrace_command, 1556 "Disable tracing of instruction execution."); 1557 1558 add_com ("itdisassemble", class_vars, tdisassemble_command, 1559 "Disassemble the trace buffer.\n\ 1560Two optional arguments specify a range of trace buffer entries\n\ 1561as reported by info trace (NOT addresses!)."); 1562 1563 add_info ("itrace", trace_info, 1564 "Display info about the trace data buffer."); 1565 1566 add_setshow_boolean_cmd ("itracedisplay", no_class, &trace_display, "\ 1567Set automatic display of trace.", "\ 1568Show automatic display of trace.", "\ 1569Controls the display of d10v specific instruction trace information.", "\ 1570Automatic display of trace is %s.", 1571 NULL, NULL, &setlist, &showlist); 1572 add_setshow_boolean_cmd ("itracesource", no_class, 1573 &default_trace_show_source, "\ 1574Set display of source code with trace.", "\ 1575Show display of source code with trace.", "\ 1576When on source code is included in the d10v instruction trace display.", "\ 1577Display of source code with trace is %s.", 1578 NULL, NULL, &setlist, &showlist); 1579} 1580