gdb/d10v-tdep.c

   1 /* Target-dependent code for Mitsubishi D10V, for GDB.
   2    Copyright 1996, 1997, 1998, 1999, 2000, 2001
   3    Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 /*  Contributed by Martin Hunt, [email protected] */
  23
  24 #include "defs.h"
  25 #include "frame.h"
  26 #include "obstack.h"
  27 #include "symtab.h"
  28 #include "gdbtypes.h"
  29 #include "gdbcmd.h"
  30 #include "gdbcore.h"
  31 #include "gdb_string.h"
  32 #include "value.h"
  33 #include "inferior.h"
  34 #include "dis-asm.h"
  35 #include "symfile.h"
  36 #include "objfiles.h"
  37 #include "language.h"
  38 #include "arch-utils.h"
  39 #include "regcache.h"
  40
  41 #include "floatformat.h"
  42 #include "sim-d10v.h"
  43
  44 #undef XMALLOC
  45 #define XMALLOC(TYPE) ((TYPE*) xmalloc (sizeof (TYPE)))
  46
  47 struct frame_extra_info
  48   {
  49     CORE_ADDR return_pc;
  50     int frameless;
  51     int size;
  52   };
  53
  54 struct gdbarch_tdep
  55   {
  56     int a0_regnum;
  57     int nr_dmap_regs;
  58     unsigned long (*dmap_register) (int nr);
  59     unsigned long (*imap_register) (int nr);
  60   };
  61
  62 /* These are the addresses the D10V-EVA board maps data and
  63    instruction memory to. */
  64
  65 #define DMEM_START      0x2000000
  66 #define IMEM_START      0x1000000
  67 #define STACK_START     0x0007ffe
  68
  69 /* d10v register names. */
  70
  71 enum
  72   {
  73     R0_REGNUM = 0,
  74     LR_REGNUM = 13,
  75     PSW_REGNUM = 16,
  76     NR_IMAP_REGS = 2,
  77     NR_A_REGS = 2
  78   };
  79 #define NR_DMAP_REGS (gdbarch_tdep (current_gdbarch)->nr_dmap_regs)
  80 #define A0_REGNUM (gdbarch_tdep (current_gdbarch)->a0_regnum)
  81
  82 /* d10v calling convention. */
  83
  84 #define ARG1_REGNUM R0_REGNUM
  85 #define ARGN_REGNUM 3
  86 #define RET1_REGNUM R0_REGNUM
  87
  88 /* Local functions */
  89
  90 extern void _initialize_d10v_tdep (void);
  91
  92 static void d10v_eva_prepare_to_trace (void);
  93
  94 static void d10v_eva_get_trace_data (void);
  95
  96 static int prologue_find_regs (unsigned short op, struct frame_info *fi,
  97                                CORE_ADDR addr);
  98
  99 static void d10v_frame_init_saved_regs (struct frame_info *);
 100
 101 static void do_d10v_pop_frame (struct frame_info *fi);
 102
 103 static int
 104 d10v_frame_chain_valid (CORE_ADDR chain, struct frame_info *frame)
 105 {
 106   return ((chain) != 0 && (frame) != 0
 107           && (frame)->pc > IMEM_START
 108           && !inside_entry_file (FRAME_SAVED_PC (frame)));
 109 }
 110
 111 static CORE_ADDR
 112 d10v_stack_align (CORE_ADDR len)
 113 {
 114   return (len + 1) & ~1;
 115 }
 116
 117 /* Should we use EXTRACT_STRUCT_VALUE_ADDRESS instead of
 118    EXTRACT_RETURN_VALUE?  GCC_P is true if compiled with gcc
 119    and TYPE is the type (which is known to be struct, union or array).
 120
 121    The d10v returns anything less than 8 bytes in size in
 122    registers. */
 123
 124 static int
 125 d10v_use_struct_convention (int gcc_p, struct type *type)
 126 {
 127   long alignment;
 128   int i;
 129   /* The d10v only passes a struct in a register when that structure
 130      has an alignment that matches the size of a register. */
 131   /* If the structure doesn't fit in 4 registers, put it on the
 132      stack. */
 133   if (TYPE_LENGTH (type) > 8)
 134     return 1;
 135   /* If the struct contains only one field, don't put it on the stack
 136      - gcc can fit it in one or more registers. */
 137   if (TYPE_NFIELDS (type) == 1)
 138     return 0;
 139   alignment = TYPE_LENGTH (TYPE_FIELD_TYPE (type, 0));
 140   for (i = 1; i < TYPE_NFIELDS (type); i++)
 141     {
 142       /* If the alignment changes, just assume it goes on the
 143          stack. */
 144       if (TYPE_LENGTH (TYPE_FIELD_TYPE (type, i)) != alignment)
 145         return 1;
 146     }
 147   /* If the alignment is suitable for the d10v's 16 bit registers,
 148      don't put it on the stack. */
 149   if (alignment == 2 || alignment == 4)
 150     return 0;
 151   return 1;
 152 }
 153
 154
 155 static unsigned char *
 156 d10v_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
 157 {
 158   static unsigned char breakpoint[] =
 159   {0x2f, 0x90, 0x5e, 0x00};
 160   *lenptr = sizeof (breakpoint);
 161   return breakpoint;
 162 }
 163
 164 /* Map the REG_NR onto an ascii name.  Return NULL or an empty string
 165    when the reg_nr isn't valid. */
 166
 167 enum ts2_regnums
 168   {
 169     TS2_IMAP0_REGNUM = 32,
 170     TS2_DMAP_REGNUM = 34,
 171     TS2_NR_DMAP_REGS = 1,
 172     TS2_A0_REGNUM = 35
 173   };
 174
 175 static char *
 176 d10v_ts2_register_name (int reg_nr)
 177 {
 178   static char *register_names[] =
 179   {
 180     "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
 181     "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
 182     "psw", "bpsw", "pc", "bpc", "cr4", "cr5", "cr6", "rpt_c",
 183     "rpt_s", "rpt_e", "mod_s", "mod_e", "cr12", "cr13", "iba", "cr15",
 184     "imap0", "imap1", "dmap", "a0", "a1"
 185   };
 186   if (reg_nr < 0)
 187     return NULL;
 188   if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
 189     return NULL;
 190   return register_names[reg_nr];
 191 }
 192
 193 enum ts3_regnums
 194   {
 195     TS3_IMAP0_REGNUM = 36,
 196     TS3_DMAP0_REGNUM = 38,
 197     TS3_NR_DMAP_REGS = 4,
 198     TS3_A0_REGNUM = 32
 199   };
 200
 201 static char *
 202 d10v_ts3_register_name (int reg_nr)
 203 {
 204   static char *register_names[] =
 205   {
 206     "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
 207     "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
 208     "psw", "bpsw", "pc", "bpc", "cr4", "cr5", "cr6", "rpt_c",
 209     "rpt_s", "rpt_e", "mod_s", "mod_e", "cr12", "cr13", "iba", "cr15",
 210     "a0", "a1",
 211     "spi", "spu",
 212     "imap0", "imap1",
 213     "dmap0", "dmap1", "dmap2", "dmap3"
 214   };
 215   if (reg_nr < 0)
 216     return NULL;
 217   if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
 218     return NULL;
 219   return register_names[reg_nr];
 220 }
 221
 222 /* Access the DMAP/IMAP registers in a target independent way.
 223
 224    Divide the D10V's 64k data space into four 16k segments:
 225    0x0000 -- 0x3fff, 0x4000 -- 0x7fff, 0x8000 -- 0xbfff, and
 226    0xc000 -- 0xffff.
 227
 228    On the TS2, the first two segments (0x0000 -- 0x3fff, 0x4000 --
 229    0x7fff) always map to the on-chip data RAM, and the fourth always
 230    maps to I/O space.  The third (0x8000 - 0xbfff) can be mapped into
 231    unified memory or instruction memory, under the control of the
 232    single DMAP register.
 233
 234    On the TS3, there are four DMAP registers, each of which controls
 235    one of the segments.  */
 236
 237 static unsigned long
 238 d10v_ts2_dmap_register (int reg_nr)
 239 {
 240   switch (reg_nr)
 241     {
 242     case 0:
 243     case 1:
 244       return 0x2000;
 245     case 2:
 246       return read_register (TS2_DMAP_REGNUM);
 247     default:
 248       return 0;
 249     }
 250 }
 251
 252 static unsigned long
 253 d10v_ts3_dmap_register (int reg_nr)
 254 {
 255   return read_register (TS3_DMAP0_REGNUM + reg_nr);
 256 }
 257
 258 static unsigned long
 259 d10v_dmap_register (int reg_nr)
 260 {
 261   return gdbarch_tdep (current_gdbarch)->dmap_register (reg_nr);
 262 }
 263
 264 static unsigned long
 265 d10v_ts2_imap_register (int reg_nr)
 266 {
 267   return read_register (TS2_IMAP0_REGNUM + reg_nr);
 268 }
 269
 270 static unsigned long
 271 d10v_ts3_imap_register (int reg_nr)
 272 {
 273   return read_register (TS3_IMAP0_REGNUM + reg_nr);
 274 }
 275
 276 static unsigned long
 277 d10v_imap_register (int reg_nr)
 278 {
 279   return gdbarch_tdep (current_gdbarch)->imap_register (reg_nr);
 280 }
 281
 282 /* MAP GDB's internal register numbering (determined by the layout fo
 283    the REGISTER_BYTE array) onto the simulator's register
 284    numbering. */
 285
 286 static int
 287 d10v_ts2_register_sim_regno (int nr)
 288 {
 289   if (nr >= TS2_IMAP0_REGNUM
 290       && nr < TS2_IMAP0_REGNUM + NR_IMAP_REGS)
 291     return nr - TS2_IMAP0_REGNUM + SIM_D10V_IMAP0_REGNUM;
 292   if (nr == TS2_DMAP_REGNUM)
 293     return nr - TS2_DMAP_REGNUM + SIM_D10V_TS2_DMAP_REGNUM;
 294   if (nr >= TS2_A0_REGNUM
 295       && nr < TS2_A0_REGNUM + NR_A_REGS)
 296     return nr - TS2_A0_REGNUM + SIM_D10V_A0_REGNUM;
 297   return nr;
 298 }
 299
 300 static int
 301 d10v_ts3_register_sim_regno (int nr)
 302 {
 303   if (nr >= TS3_IMAP0_REGNUM
 304       && nr < TS3_IMAP0_REGNUM + NR_IMAP_REGS)
 305     return nr - TS3_IMAP0_REGNUM + SIM_D10V_IMAP0_REGNUM;
 306   if (nr >= TS3_DMAP0_REGNUM
 307       && nr < TS3_DMAP0_REGNUM + TS3_NR_DMAP_REGS)
 308     return nr - TS3_DMAP0_REGNUM + SIM_D10V_DMAP0_REGNUM;
 309   if (nr >= TS3_A0_REGNUM
 310       && nr < TS3_A0_REGNUM + NR_A_REGS)
 311     return nr - TS3_A0_REGNUM + SIM_D10V_A0_REGNUM;
 312   return nr;
 313 }
 314
 315 /* Index within `registers' of the first byte of the space for
 316    register REG_NR.  */
 317
 318 static int
 319 d10v_register_byte (int reg_nr)
 320 {
 321   if (reg_nr < A0_REGNUM)
 322     return (reg_nr * 2);
 323   else if (reg_nr < (A0_REGNUM + NR_A_REGS))
 324     return (A0_REGNUM * 2
 325             + (reg_nr - A0_REGNUM) * 8);
 326   else
 327     return (A0_REGNUM * 2
 328             + NR_A_REGS * 8
 329             + (reg_nr - A0_REGNUM - NR_A_REGS) * 2);
 330 }
 331
 332 /* Number of bytes of storage in the actual machine representation for
 333    register REG_NR.  */
 334
 335 static int
 336 d10v_register_raw_size (int reg_nr)
 337 {
 338   if (reg_nr < A0_REGNUM)
 339     return 2;
 340   else if (reg_nr < (A0_REGNUM + NR_A_REGS))
 341     return 8;
 342   else
 343     return 2;
 344 }
 345
 346 /* Return the GDB type object for the "standard" data type
 347    of data in register N.  */
 348
 349 static struct type *
 350 d10v_register_virtual_type (int reg_nr)
 351 {
 352   if (reg_nr == PC_REGNUM)
 353     return builtin_type_void_func_ptr;
 354   else if (reg_nr >= A0_REGNUM
 355       && reg_nr < (A0_REGNUM + NR_A_REGS))
 356     return builtin_type_int64;
 357   else
 358     return builtin_type_int16;
 359 }
 360
 361 static CORE_ADDR
 362 d10v_make_daddr (CORE_ADDR x)
 363 {
 364   return ((x) | DMEM_START);
 365 }
 366
 367 static CORE_ADDR
 368 d10v_make_iaddr (CORE_ADDR x)
 369 {
 370   return (((x) << 2) | IMEM_START);
 371 }
 372
 373 static int
 374 d10v_daddr_p (CORE_ADDR x)
 375 {
 376   return (((x) & 0x3000000) == DMEM_START);
 377 }
 378
 379 static int
 380 d10v_iaddr_p (CORE_ADDR x)
 381 {
 382   return (((x) & 0x3000000) == IMEM_START);
 383 }
 384
 385
 386 static CORE_ADDR
 387 d10v_convert_iaddr_to_raw (CORE_ADDR x)
 388 {
 389   return (((x) >> 2) & 0xffff);
 390 }
 391
 392 static CORE_ADDR
 393 d10v_convert_daddr_to_raw (CORE_ADDR x)
 394 {
 395   return ((x) & 0xffff);
 396 }
 397
 398 static void
 399 d10v_address_to_pointer (struct type *type, void *buf, CORE_ADDR addr)
 400 {
 401   /* Is it a code address?  */
 402   if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC
 403       || TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_METHOD)
 404     {
 405 #if 0
 406       if (! d10v_iaddr_p (addr))
 407         {
 408           warning_begin ();
 409           fprintf_unfiltered (gdb_stderr, "address `");
 410           print_address_numeric (addr, 1, gdb_stderr);
 411           fprintf_unfiltered (gdb_stderr, "' is not a code address\n");
 412         }
 413 #endif
 414
 415       store_unsigned_integer (buf, TYPE_LENGTH (type),
 416                               d10v_convert_iaddr_to_raw (addr));
 417     }
 418   else
 419     {
 420       /* Strip off any upper segment bits.  */
 421       store_unsigned_integer (buf, TYPE_LENGTH (type),
 422                               d10v_convert_daddr_to_raw (addr));
 423     }
 424 }
 425
 426 static CORE_ADDR
 427 d10v_pointer_to_address (struct type *type, void *buf)
 428 {
 429   CORE_ADDR addr = extract_address (buf, TYPE_LENGTH (type));
 430
 431   /* Is it a code address?  */
 432   if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC
 433       || TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_METHOD ||
 434       (TYPE_FLAGS (TYPE_TARGET_TYPE (type)) & TYPE_FLAG_CODE_SPACE) != 0)
 435     return d10v_make_iaddr (addr);
 436   else
 437     return d10v_make_daddr (addr);
 438 }
 439
 440 static CORE_ADDR
 441 d10v_integer_to_address (struct type *type, void *buf)
 442 {
 443   LONGEST val;
 444   val = unpack_long (type, buf);
 445   if (TYPE_CODE (type) == TYPE_CODE_INT
 446       && TYPE_LENGTH (type) <= TYPE_LENGTH (builtin_type_void_data_ptr))
 447     /* Convert small integers that would would be directly copied into
 448        a pointer variable into an address pointing into data space.  */
 449     return d10v_make_daddr (val & 0xffff);
 450   else
 451     /* The value is too large to fit in a pointer.  Assume this was
 452        intentional and that the user in fact specified a raw address.  */
 453     return val;
 454 }
 455
 456 /* Store the address of the place in which to copy the structure the
 457    subroutine will return.  This is called from call_function.
 458
 459    We store structs through a pointer passed in the first Argument
 460    register. */
 461
 462 static void
 463 d10v_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
 464 {
 465   write_register (ARG1_REGNUM, (addr));
 466 }
 467
 468 /* Write into appropriate registers a function return value
 469    of type TYPE, given in virtual format.
 470
 471    Things always get returned in RET1_REGNUM, RET2_REGNUM, ... */
 472
 473 static void
 474 d10v_store_return_value (struct type *type, char *valbuf)
 475 {
 476   write_register_bytes (REGISTER_BYTE (RET1_REGNUM),
 477                         valbuf,
 478                         TYPE_LENGTH (type));
 479 }
 480
 481 /* Extract from an array REGBUF containing the (raw) register state
 482    the address in which a function should return its structure value,
 483    as a CORE_ADDR (or an expression that can be used as one).  */
 484
 485 static CORE_ADDR
 486 d10v_extract_struct_value_address (char *regbuf)
 487 {
 488   return (extract_address ((regbuf) + REGISTER_BYTE (ARG1_REGNUM),
 489                            REGISTER_RAW_SIZE (ARG1_REGNUM))
 490           | DMEM_START);
 491 }
 492
 493 static CORE_ADDR
 494 d10v_frame_saved_pc (struct frame_info *frame)
 495 {
 496   return ((frame)->extra_info->return_pc);
 497 }
 498
 499 /* Immediately after a function call, return the saved pc.  We can't
 500    use frame->return_pc beause that is determined by reading R13 off
 501    the stack and that may not be written yet. */
 502
 503 static CORE_ADDR
 504 d10v_saved_pc_after_call (struct frame_info *frame)
 505 {
 506   return ((read_register (LR_REGNUM) << 2)
 507           | IMEM_START);
 508 }
 509
 510 /* Discard from the stack the innermost frame, restoring all saved
 511    registers.  */
 512
 513 static void
 514 d10v_pop_frame (void)
 515 {
 516   generic_pop_current_frame (do_d10v_pop_frame);
 517 }
 518
 519 static void
 520 do_d10v_pop_frame (struct frame_info *fi)
 521 {
 522   CORE_ADDR fp;
 523   int regnum;
 524   char raw_buffer[8];
 525
 526   fp = FRAME_FP (fi);
 527   /* fill out fsr with the address of where each */
 528   /* register was stored in the frame */
 529   d10v_frame_init_saved_regs (fi);
 530
 531   /* now update the current registers with the old values */
 532   for (regnum = A0_REGNUM; regnum < A0_REGNUM + NR_A_REGS; regnum++)
 533     {
 534       if (fi->saved_regs[regnum])
 535         {
 536           read_memory (fi->saved_regs[regnum], raw_buffer, REGISTER_RAW_SIZE (regnum));
 537           write_register_bytes (REGISTER_BYTE (regnum), raw_buffer, REGISTER_RAW_SIZE (regnum));
 538         }
 539     }
 540   for (regnum = 0; regnum < SP_REGNUM; regnum++)
 541     {
 542       if (fi->saved_regs[regnum])
 543         {
 544           write_register (regnum, read_memory_unsigned_integer (fi->saved_regs[regnum], REGISTER_RAW_SIZE (regnum)));
 545         }
 546     }
 547   if (fi->saved_regs[PSW_REGNUM])
 548     {
 549       write_register (PSW_REGNUM, read_memory_unsigned_integer (fi->saved_regs[PSW_REGNUM], REGISTER_RAW_SIZE (PSW_REGNUM)));
 550     }
 551
 552   write_register (PC_REGNUM, read_register (LR_REGNUM));
 553   write_register (SP_REGNUM, fp + fi->extra_info->size);
 554   target_store_registers (-1);
 555   flush_cached_frames ();
 556 }
 557
 558 static int
 559 check_prologue (unsigned short op)
 560 {
 561   /* st  rn, @-sp */
 562   if ((op & 0x7E1F) == 0x6C1F)
 563     return 1;
 564
 565   /* st2w  rn, @-sp */
 566   if ((op & 0x7E3F) == 0x6E1F)
 567     return 1;
 568
 569   /* subi  sp, n */
 570   if ((op & 0x7FE1) == 0x01E1)
 571     return 1;
 572
 573   /* mv  r11, sp */
 574   if (op == 0x417E)
 575     return 1;
 576
 577   /* nop */
 578   if (op == 0x5E00)
 579     return 1;
 580
 581   /* st  rn, @sp */
 582   if ((op & 0x7E1F) == 0x681E)
 583     return 1;
 584
 585   /* st2w  rn, @sp */
 586   if ((op & 0x7E3F) == 0x3A1E)
 587     return 1;
 588
 589   return 0;
 590 }
 591
 592 static CORE_ADDR
 593 d10v_skip_prologue (CORE_ADDR pc)
 594 {
 595   unsigned long op;
 596   unsigned short op1, op2;
 597   CORE_ADDR func_addr, func_end;
 598   struct symtab_and_line sal;
 599
 600   /* If we have line debugging information, then the end of the */
 601   /* prologue should the first assembly instruction of  the first source line */
 602   if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
 603     {
 604       sal = find_pc_line (func_addr, 0);
 605       if (sal.end && sal.end < func_end)
 606         return sal.end;
 607     }
 608
 609   if (target_read_memory (pc, (char *) &op, 4))
 610     return pc;                  /* Can't access it -- assume no prologue. */
 611
 612   while (1)
 613     {
 614       op = (unsigned long) read_memory_integer (pc, 4);
 615       if ((op & 0xC0000000) == 0xC0000000)
 616         {
 617           /* long instruction */
 618           if (((op & 0x3FFF0000) != 0x01FF0000) &&      /* add3 sp,sp,n */
 619               ((op & 0x3F0F0000) != 0x340F0000) &&      /* st  rn, @(offset,sp) */
 620               ((op & 0x3F1F0000) != 0x350F0000))        /* st2w  rn, @(offset,sp) */
 621             break;
 622         }
 623       else
 624         {
 625           /* short instructions */
 626           if ((op & 0xC0000000) == 0x80000000)
 627             {
 628               op2 = (op & 0x3FFF8000) >> 15;
 629               op1 = op & 0x7FFF;
 630             }
 631           else
 632             {
 633               op1 = (op & 0x3FFF8000) >> 15;
 634               op2 = op & 0x7FFF;
 635             }
 636           if (check_prologue (op1))
 637             {
 638               if (!check_prologue (op2))
 639                 {
 640                   /* if the previous opcode was really part of the prologue */
 641                   /* and not just a NOP, then we want to break after both instructions */
 642                   if (op1 != 0x5E00)
 643                     pc += 4;
 644                   break;
 645                 }
 646             }
 647           else
 648             break;
 649         }
 650       pc += 4;
 651     }
 652   return pc;
 653 }
 654
 655 /* Given a GDB frame, determine the address of the calling function's frame.
 656    This will be used to create a new GDB frame struct, and then
 657    INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC will be called for the new frame.
 658  */
 659
 660 static CORE_ADDR
 661 d10v_frame_chain (struct frame_info *fi)
 662 {
 663   d10v_frame_init_saved_regs (fi);
 664
 665   if (fi->extra_info->return_pc == IMEM_START
 666       || inside_entry_file (fi->extra_info->return_pc))
 667     return (CORE_ADDR) 0;
 668
 669   if (!fi->saved_regs[FP_REGNUM])
 670     {
 671       if (!fi->saved_regs[SP_REGNUM]
 672           || fi->saved_regs[SP_REGNUM] == STACK_START)
 673         return (CORE_ADDR) 0;
 674
 675       return fi->saved_regs[SP_REGNUM];
 676     }
 677
 678   if (!read_memory_unsigned_integer (fi->saved_regs[FP_REGNUM],
 679                                      REGISTER_RAW_SIZE (FP_REGNUM)))
 680     return (CORE_ADDR) 0;
 681
 682   return d10v_make_daddr (read_memory_unsigned_integer (fi->saved_regs[FP_REGNUM],
 683                                             REGISTER_RAW_SIZE (FP_REGNUM)));
 684 }
 685
 686 static int next_addr, uses_frame;
 687
 688 static int
 689 prologue_find_regs (unsigned short op, struct frame_info *fi, CORE_ADDR addr)
 690 {
 691   int n;
 692
 693   /* st  rn, @-sp */
 694   if ((op & 0x7E1F) == 0x6C1F)
 695     {
 696       n = (op & 0x1E0) >> 5;
 697       next_addr -= 2;
 698       fi->saved_regs[n] = next_addr;
 699       return 1;
 700     }
 701
 702   /* st2w  rn, @-sp */
 703   else if ((op & 0x7E3F) == 0x6E1F)
 704     {
 705       n = (op & 0x1E0) >> 5;
 706       next_addr -= 4;
 707       fi->saved_regs[n] = next_addr;
 708       fi->saved_regs[n + 1] = next_addr + 2;
 709       return 1;
 710     }
 711
 712   /* subi  sp, n */
 713   if ((op & 0x7FE1) == 0x01E1)
 714     {
 715       n = (op & 0x1E) >> 1;
 716       if (n == 0)
 717         n = 16;
 718       next_addr -= n;
 719       return 1;
 720     }
 721
 722   /* mv  r11, sp */
 723   if (op == 0x417E)
 724     {
 725       uses_frame = 1;
 726       return 1;
 727     }
 728
 729   /* nop */
 730   if (op == 0x5E00)
 731     return 1;
 732
 733   /* st  rn, @sp */
 734   if ((op & 0x7E1F) == 0x681E)
 735     {
 736       n = (op & 0x1E0) >> 5;
 737       fi->saved_regs[n] = next_addr;
 738       return 1;
 739     }
 740
 741   /* st2w  rn, @sp */
 742   if ((op & 0x7E3F) == 0x3A1E)
 743     {
 744       n = (op & 0x1E0) >> 5;
 745       fi->saved_regs[n] = next_addr;
 746       fi->saved_regs[n + 1] = next_addr + 2;
 747       return 1;
 748     }
 749
 750   return 0;
 751 }
 752
 753 /* Put here the code to store, into fi->saved_regs, the addresses of
 754    the saved registers of frame described by FRAME_INFO.  This
 755    includes special registers such as pc and fp saved in special ways
 756    in the stack frame.  sp is even more special: the address we return
 757    for it IS the sp for the next frame. */
 758
 759 static void
 760 d10v_frame_init_saved_regs (struct frame_info *fi)
 761 {
 762   CORE_ADDR fp, pc;
 763   unsigned long op;
 764   unsigned short op1, op2;
 765   int i;
 766
 767   fp = fi->frame;
 768   memset (fi->saved_regs, 0, SIZEOF_FRAME_SAVED_REGS);
 769   next_addr = 0;
 770
 771   pc = get_pc_function_start (fi->pc);
 772
 773   uses_frame = 0;
 774   while (1)
 775     {
 776       op = (unsigned long) read_memory_integer (pc, 4);
 777       if ((op & 0xC0000000) == 0xC0000000)
 778         {
 779           /* long instruction */
 780           if ((op & 0x3FFF0000) == 0x01FF0000)
 781             {
 782               /* add3 sp,sp,n */
 783               short n = op & 0xFFFF;
 784               next_addr += n;
 785             }
 786           else if ((op & 0x3F0F0000) == 0x340F0000)
 787             {
 788               /* st  rn, @(offset,sp) */
 789               short offset = op & 0xFFFF;
 790               short n = (op >> 20) & 0xF;
 791               fi->saved_regs[n] = next_addr + offset;
 792             }
 793           else if ((op & 0x3F1F0000) == 0x350F0000)
 794             {
 795               /* st2w  rn, @(offset,sp) */
 796               short offset = op & 0xFFFF;
 797               short n = (op >> 20) & 0xF;
 798               fi->saved_regs[n] = next_addr + offset;
 799               fi->saved_regs[n + 1] = next_addr + offset + 2;
 800             }
 801           else
 802             break;
 803         }
 804       else
 805         {
 806           /* short instructions */
 807           if ((op & 0xC0000000) == 0x80000000)
 808             {
 809               op2 = (op & 0x3FFF8000) >> 15;
 810               op1 = op & 0x7FFF;
 811             }
 812           else
 813             {
 814               op1 = (op & 0x3FFF8000) >> 15;
 815               op2 = op & 0x7FFF;
 816             }
 817           if (!prologue_find_regs (op1, fi, pc) || !prologue_find_regs (op2, fi, pc))
 818             break;
 819         }
 820       pc += 4;
 821     }
 822
 823   fi->extra_info->size = -next_addr;
 824
 825   if (!(fp & 0xffff))
 826     fp = d10v_make_daddr (read_register (SP_REGNUM));
 827
 828   for (i = 0; i < NUM_REGS - 1; i++)
 829     if (fi->saved_regs[i])
 830       {
 831         fi->saved_regs[i] = fp - (next_addr - fi->saved_regs[i]);
 832       }
 833
 834   if (fi->saved_regs[LR_REGNUM])
 835     {
 836       CORE_ADDR return_pc = read_memory_unsigned_integer (fi->saved_regs[LR_REGNUM], REGISTER_RAW_SIZE (LR_REGNUM));
 837       fi->extra_info->return_pc = d10v_make_iaddr (return_pc);
 838     }
 839   else
 840     {
 841       fi->extra_info->return_pc = d10v_make_iaddr (read_register (LR_REGNUM));
 842     }
 843
 844   /* th SP is not normally (ever?) saved, but check anyway */
 845   if (!fi->saved_regs[SP_REGNUM])
 846     {
 847       /* if the FP was saved, that means the current FP is valid, */
 848       /* otherwise, it isn't being used, so we use the SP instead */
 849       if (uses_frame)
 850         fi->saved_regs[SP_REGNUM] = read_register (FP_REGNUM) + fi->extra_info->size;
 851       else
 852         {
 853           fi->saved_regs[SP_REGNUM] = fp + fi->extra_info->size;
 854           fi->extra_info->frameless = 1;
 855           fi->saved_regs[FP_REGNUM] = 0;
 856         }
 857     }
 858 }
 859
 860 static void
 861 d10v_init_extra_frame_info (int fromleaf, struct frame_info *fi)
 862 {
 863   fi->extra_info = (struct frame_extra_info *)
 864     frame_obstack_alloc (sizeof (struct frame_extra_info));
 865   frame_saved_regs_zalloc (fi);
 866
 867   fi->extra_info->frameless = 0;
 868   fi->extra_info->size = 0;
 869   fi->extra_info->return_pc = 0;
 870
 871   /* The call dummy doesn't save any registers on the stack, so we can
 872      return now.  */
 873   if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
 874     {
 875       return;
 876     }
 877   else
 878     {
 879       d10v_frame_init_saved_regs (fi);
 880     }
 881 }
 882
 883 static void
 884 show_regs (char *args, int from_tty)
 885 {
 886   int a;
 887   printf_filtered ("PC=%04lx (0x%lx) PSW=%04lx RPT_S=%04lx RPT_E=%04lx RPT_C=%04lx\n",
 888                    (long) read_register (PC_REGNUM),
 889                    (long) d10v_make_iaddr (read_register (PC_REGNUM)),
 890                    (long) read_register (PSW_REGNUM),
 891                    (long) read_register (24),
 892                    (long) read_register (25),
 893                    (long) read_register (23));
 894   printf_filtered ("R0-R7  %04lx %04lx %04lx %04lx %04lx %04lx %04lx %04lx\n",
 895                    (long) read_register (0),
 896                    (long) read_register (1),
 897                    (long) read_register (2),
 898                    (long) read_register (3),
 899                    (long) read_register (4),
 900                    (long) read_register (5),
 901                    (long) read_register (6),
 902                    (long) read_register (7));
 903   printf_filtered ("R8-R15 %04lx %04lx %04lx %04lx %04lx %04lx %04lx %04lx\n",
 904                    (long) read_register (8),
 905                    (long) read_register (9),
 906                    (long) read_register (10),
 907                    (long) read_register (11),
 908                    (long) read_register (12),
 909                    (long) read_register (13),
 910                    (long) read_register (14),
 911                    (long) read_register (15));
 912   for (a = 0; a < NR_IMAP_REGS; a++)
 913     {
 914       if (a > 0)
 915         printf_filtered ("    ");
 916       printf_filtered ("IMAP%d %04lx", a, d10v_imap_register (a));
 917     }
 918   if (NR_DMAP_REGS == 1)
 919     printf_filtered ("    DMAP %04lx\n", d10v_dmap_register (2));
 920   else
 921     {
 922       for (a = 0; a < NR_DMAP_REGS; a++)
 923         {
 924           printf_filtered ("    DMAP%d %04lx", a, d10v_dmap_register (a));
 925         }
 926       printf_filtered ("\n");
 927     }
 928   printf_filtered ("A0-A%d", NR_A_REGS - 1);
 929   for (a = A0_REGNUM; a < A0_REGNUM + NR_A_REGS; a++)
 930     {
 931       char num[MAX_REGISTER_RAW_SIZE];
 932       int i;
 933       printf_filtered ("  ");
 934       read_register_gen (a, (char *) &num);
 935       for (i = 0; i < MAX_REGISTER_RAW_SIZE; i++)
 936         {
 937           printf_filtered ("%02x", (num[i] & 0xff));
 938         }
 939     }
 940   printf_filtered ("\n");
 941 }
 942
 943 static CORE_ADDR
 944 d10v_read_pc (ptid_t ptid)
 945 {
 946   ptid_t save_ptid;
 947   CORE_ADDR pc;
 948   CORE_ADDR retval;
 949
 950   save_ptid = inferior_ptid;
 951   inferior_ptid = ptid;
 952   pc = (int) read_register (PC_REGNUM);
 953   inferior_ptid = save_ptid;
 954   retval = d10v_make_iaddr (pc);
 955   return retval;
 956 }
 957
 958 static void
 959 d10v_write_pc (CORE_ADDR val, ptid_t ptid)
 960 {
 961   ptid_t save_ptid;
 962
 963   save_ptid = inferior_ptid;
 964   inferior_ptid = ptid;
 965   write_register (PC_REGNUM, d10v_convert_iaddr_to_raw (val));
 966   inferior_ptid = save_ptid;
 967 }
 968
 969 static CORE_ADDR
 970 d10v_read_sp (void)
 971 {
 972   return (d10v_make_daddr (read_register (SP_REGNUM)));
 973 }
 974
 975 static void
 976 d10v_write_sp (CORE_ADDR val)
 977 {
 978   write_register (SP_REGNUM, d10v_convert_daddr_to_raw (val));
 979 }
 980
 981 static void
 982 d10v_write_fp (CORE_ADDR val)
 983 {
 984   write_register (FP_REGNUM, d10v_convert_daddr_to_raw (val));
 985 }
 986
 987 static CORE_ADDR
 988 d10v_read_fp (void)
 989 {
 990   return (d10v_make_daddr (read_register (FP_REGNUM)));
 991 }
 992
 993 /* Function: push_return_address (pc)
 994    Set up the return address for the inferior function call.
 995    Needed for targets where we don't actually execute a JSR/BSR instruction */
 996
 997 static CORE_ADDR
 998 d10v_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
 999 {
1000   write_register (LR_REGNUM, d10v_convert_iaddr_to_raw (CALL_DUMMY_ADDRESS ()));
1001   return sp;
1002 }
1003
1004
1005 /* When arguments must be pushed onto the stack, they go on in reverse
1006    order.  The below implements a FILO (stack) to do this. */
1007
1008 struct stack_item
1009 {
1010   int len;
1011   struct stack_item *prev;
1012   void *data;
1013 };
1014
1015 static struct stack_item *push_stack_item (struct stack_item *prev,
1016                                            void *contents, int len);
1017 static struct stack_item *
1018 push_stack_item (struct stack_item *prev, void *contents, int len)
1019 {
1020   struct stack_item *si;
1021   si = xmalloc (sizeof (struct stack_item));
1022   si->data = xmalloc (len);
1023   si->len = len;
1024   si->prev = prev;
1025   memcpy (si->data, contents, len);
1026   return si;
1027 }
1028
1029 static struct stack_item *pop_stack_item (struct stack_item *si);
1030 static struct stack_item *
1031 pop_stack_item (struct stack_item *si)
1032 {
1033   struct stack_item *dead = si;
1034   si = si->prev;
1035   xfree (dead->data);
1036   xfree (dead);
1037   return si;
1038 }
1039
1040
1041 static CORE_ADDR
1042 d10v_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
1043                      int struct_return, CORE_ADDR struct_addr)
1044 {
1045   int i;
1046   int regnum = ARG1_REGNUM;
1047   struct stack_item *si = NULL;
1048
1049   /* Fill in registers and arg lists */
1050   for (i = 0; i < nargs; i++)
1051     {
1052       struct value *arg = args[i];
1053       struct type *type = check_typedef (VALUE_TYPE (arg));
1054       char *contents = VALUE_CONTENTS (arg);
1055       int len = TYPE_LENGTH (type);
1056       /* printf ("push: type=%d len=%d\n", type->code, len); */
1057         {
1058           int aligned_regnum = (regnum + 1) & ~1;
1059           if (len <= 2 && regnum <= ARGN_REGNUM)
1060             /* fits in a single register, do not align */
1061             {
1062               long val = extract_unsigned_integer (contents, len);
1063               write_register (regnum++, val);
1064             }
1065           else if (len <= (ARGN_REGNUM - aligned_regnum + 1) * 2)
1066             /* value fits in remaining registers, store keeping left
1067                aligned */
1068             {
1069               int b;
1070               regnum = aligned_regnum;
1071               for (b = 0; b < (len & ~1); b += 2)
1072                 {
1073                   long val = extract_unsigned_integer (&contents[b], 2);
1074                   write_register (regnum++, val);
1075                 }
1076               if (b < len)
1077                 {
1078                   long val = extract_unsigned_integer (&contents[b], 1);
1079                   write_register (regnum++, (val << 8));
1080                 }
1081             }
1082           else
1083             {
1084               /* arg will go onto stack */
1085               regnum = ARGN_REGNUM + 1;
1086               si = push_stack_item (si, contents, len);
1087             }
1088         }
1089     }
1090
1091   while (si)
1092     {
1093       sp = (sp - si->len) & ~1;
1094       write_memory (sp, si->data, si->len);
1095       si = pop_stack_item (si);
1096     }
1097
1098   return sp;
1099 }
1100
1101
1102 /* Given a return value in `regbuf' with a type `valtype',
1103    extract and copy its value into `valbuf'.  */
1104
1105 static void
1106 d10v_extract_return_value (struct type *type, char regbuf[REGISTER_BYTES],
1107                            char *valbuf)
1108 {
1109   int len;
1110   /*    printf("RET: TYPE=%d len=%d r%d=0x%x\n",type->code, TYPE_LENGTH (type), RET1_REGNUM - R0_REGNUM, (int) extract_unsigned_integer (regbuf + REGISTER_BYTE(RET1_REGNUM), REGISTER_RAW_SIZE (RET1_REGNUM)));  */
1111     {
1112       len = TYPE_LENGTH (type);
1113       if (len == 1)
1114         {
1115           unsigned short c = extract_unsigned_integer (regbuf + REGISTER_BYTE (RET1_REGNUM), REGISTER_RAW_SIZE (RET1_REGNUM));
1116           store_unsigned_integer (valbuf, 1, c);
1117         }
1118       else if ((len & 1) == 0)
1119         memcpy (valbuf, regbuf + REGISTER_BYTE (RET1_REGNUM), len);
1120       else
1121         {
1122           /* For return values of odd size, the first byte is in the
1123              least significant part of the first register.  The
1124              remaining bytes in remaining registers. Interestingly,
1125              when such values are passed in, the last byte is in the
1126              most significant byte of that same register - wierd. */
1127           memcpy (valbuf, regbuf + REGISTER_BYTE (RET1_REGNUM) + 1, len);
1128         }
1129     }
1130 }
1131
1132 /* Translate a GDB virtual ADDR/LEN into a format the remote target
1133    understands.  Returns number of bytes that can be transfered
1134    starting at TARG_ADDR.  Return ZERO if no bytes can be transfered
1135    (segmentation fault).  Since the simulator knows all about how the
1136    VM system works, we just call that to do the translation. */
1137
1138 static void
1139 remote_d10v_translate_xfer_address (CORE_ADDR memaddr, int nr_bytes,
1140                                     CORE_ADDR *targ_addr, int *targ_len)
1141 {
1142   long out_addr;
1143   long out_len;
1144   out_len = sim_d10v_translate_addr (memaddr, nr_bytes,
1145                                      &out_addr,
1146                                      d10v_dmap_register,
1147                                      d10v_imap_register);
1148   *targ_addr = out_addr;
1149   *targ_len = out_len;
1150 }
1151
1152
1153 /* The following code implements access to, and display of, the D10V's
1154    instruction trace buffer.  The buffer consists of 64K or more
1155    4-byte words of data, of which each words includes an 8-bit count,
1156    an 8-bit segment number, and a 16-bit instruction address.
1157
1158    In theory, the trace buffer is continuously capturing instruction
1159    data that the CPU presents on its "debug bus", but in practice, the
1160    ROMified GDB stub only enables tracing when it continues or steps
1161    the program, and stops tracing when the program stops; so it
1162    actually works for GDB to read the buffer counter out of memory and
1163    then read each trace word.  The counter records where the tracing
1164    stops, but there is no record of where it started, so we remember
1165    the PC when we resumed and then search backwards in the trace
1166    buffer for a word that includes that address.  This is not perfect,
1167    because you will miss trace data if the resumption PC is the target
1168    of a branch.  (The value of the buffer counter is semi-random, any
1169    trace data from a previous program stop is gone.)  */
1170
1171 /* The address of the last word recorded in the trace buffer.  */
1172
1173 #define DBBC_ADDR (0xd80000)
1174
1175 /* The base of the trace buffer, at least for the "Board_0".  */
1176
1177 #define TRACE_BUFFER_BASE (0xf40000)
1178
1179 static void trace_command (char *, int);
1180
1181 static void untrace_command (char *, int);
1182
1183 static void trace_info (char *, int);
1184
1185 static void tdisassemble_command (char *, int);
1186
1187 static void display_trace (int, int);
1188
1189 /* True when instruction traces are being collected.  */
1190
1191 static int tracing;
1192
1193 /* Remembered PC.  */
1194
1195 static CORE_ADDR last_pc;
1196
1197 /* True when trace output should be displayed whenever program stops.  */
1198
1199 static int trace_display;
1200
1201 /* True when trace listing should include source lines.  */
1202
1203 static int default_trace_show_source = 1;
1204
1205 struct trace_buffer
1206   {
1207     int size;
1208     short *counts;
1209     CORE_ADDR *addrs;
1210   }
1211 trace_data;
1212
1213 static void
1214 trace_command (char *args, int from_tty)
1215 {
1216   /* Clear the host-side trace buffer, allocating space if needed.  */
1217   trace_data.size = 0;
1218   if (trace_data.counts == NULL)
1219     trace_data.counts = (short *) xmalloc (65536 * sizeof (short));
1220   if (trace_data.addrs == NULL)
1221     trace_data.addrs = (CORE_ADDR *) xmalloc (65536 * sizeof (CORE_ADDR));
1222
1223   tracing = 1;
1224
1225   printf_filtered ("Tracing is now on.\n");
1226 }
1227
1228 static void
1229 untrace_command (char *args, int from_tty)
1230 {
1231   tracing = 0;
1232
1233   printf_filtered ("Tracing is now off.\n");
1234 }
1235
1236 static void
1237 trace_info (char *args, int from_tty)
1238 {
1239   int i;
1240
1241   if (trace_data.size)
1242     {
1243       printf_filtered ("%d entries in trace buffer:\n", trace_data.size);
1244
1245       for (i = 0; i < trace_data.size; ++i)
1246         {
1247           printf_filtered ("%d: %d instruction%s at 0x%s\n",
1248                            i,
1249                            trace_data.counts[i],
1250                            (trace_data.counts[i] == 1 ? "" : "s"),
1251                            paddr_nz (trace_data.addrs[i]));
1252         }
1253     }
1254   else
1255     printf_filtered ("No entries in trace buffer.\n");
1256
1257   printf_filtered ("Tracing is currently %s.\n", (tracing ? "on" : "off"));
1258 }
1259
1260 /* Print the instruction at address MEMADDR in debugged memory,
1261    on STREAM.  Returns length of the instruction, in bytes.  */
1262
1263 static int
1264 print_insn (CORE_ADDR memaddr, struct ui_file *stream)
1265 {
1266   /* If there's no disassembler, something is very wrong.  */
1267   if (tm_print_insn == NULL)
1268     internal_error (__FILE__, __LINE__,
1269                     "print_insn: no disassembler");
1270
1271   if (TARGET_BYTE_ORDER == BIG_ENDIAN)
1272     tm_print_insn_info.endian = BFD_ENDIAN_BIG;
1273   else
1274     tm_print_insn_info.endian = BFD_ENDIAN_LITTLE;
1275   return TARGET_PRINT_INSN (memaddr, &tm_print_insn_info);
1276 }
1277
1278 static void
1279 d10v_eva_prepare_to_trace (void)
1280 {
1281   if (!tracing)
1282     return;
1283
1284   last_pc = read_register (PC_REGNUM);
1285 }
1286
1287 /* Collect trace data from the target board and format it into a form
1288    more useful for display.  */
1289
1290 static void
1291 d10v_eva_get_trace_data (void)
1292 {
1293   int count, i, j, oldsize;
1294   int trace_addr, trace_seg, trace_cnt, next_cnt;
1295   unsigned int last_trace, trace_word, next_word;
1296   unsigned int *tmpspace;
1297
1298   if (!tracing)
1299     return;
1300
1301   tmpspace = xmalloc (65536 * sizeof (unsigned int));
1302
1303   last_trace = read_memory_unsigned_integer (DBBC_ADDR, 2) << 2;
1304
1305   /* Collect buffer contents from the target, stopping when we reach
1306      the word recorded when execution resumed.  */
1307
1308   count = 0;
1309   while (last_trace > 0)
1310     {
1311       QUIT;
1312       trace_word =
1313         read_memory_unsigned_integer (TRACE_BUFFER_BASE + last_trace, 4);
1314       trace_addr = trace_word & 0xffff;
1315       last_trace -= 4;
1316       /* Ignore an apparently nonsensical entry.  */
1317       if (trace_addr == 0xffd5)
1318         continue;
1319       tmpspace[count++] = trace_word;
1320       if (trace_addr == last_pc)
1321         break;
1322       if (count > 65535)
1323         break;
1324     }
1325
1326   /* Move the data to the host-side trace buffer, adjusting counts to
1327      include the last instruction executed and transforming the address
1328      into something that GDB likes.  */
1329
1330   for (i = 0; i < count; ++i)
1331     {
1332       trace_word = tmpspace[i];
1333       next_word = ((i == 0) ? 0 : tmpspace[i - 1]);
1334       trace_addr = trace_word & 0xffff;
1335       next_cnt = (next_word >> 24) & 0xff;
1336       j = trace_data.size + count - i - 1;
1337       trace_data.addrs[j] = (trace_addr << 2) + 0x1000000;
1338       trace_data.counts[j] = next_cnt + 1;
1339     }
1340
1341   oldsize = trace_data.size;
1342   trace_data.size += count;
1343
1344   xfree (tmpspace);
1345
1346   if (trace_display)
1347     display_trace (oldsize, trace_data.size);
1348 }
1349
1350 static void
1351 tdisassemble_command (char *arg, int from_tty)
1352 {
1353   int i, count;
1354   CORE_ADDR low, high;
1355   char *space_index;
1356
1357   if (!arg)
1358     {
1359       low = 0;
1360       high = trace_data.size;
1361     }
1362   else if (!(space_index = (char *) strchr (arg, ' ')))
1363     {
1364       low = parse_and_eval_address (arg);
1365       high = low + 5;
1366     }
1367   else
1368     {
1369       /* Two arguments.  */
1370       *space_index = '\0';
1371       low = parse_and_eval_address (arg);
1372       high = parse_and_eval_address (space_index + 1);
1373       if (high < low)
1374         high = low;
1375     }
1376
1377   printf_filtered ("Dump of trace from %s to %s:\n", paddr_u (low), paddr_u (high));
1378
1379   display_trace (low, high);
1380
1381   printf_filtered ("End of trace dump.\n");
1382   gdb_flush (gdb_stdout);
1383 }
1384
1385 static void
1386 display_trace (int low, int high)
1387 {
1388   int i, count, trace_show_source, first, suppress;
1389   CORE_ADDR next_address;
1390
1391   trace_show_source = default_trace_show_source;
1392   if (!have_full_symbols () && !have_partial_symbols ())
1393     {
1394       trace_show_source = 0;
1395       printf_filtered ("No symbol table is loaded.  Use the \"file\" command.\n");
1396       printf_filtered ("Trace will not display any source.\n");
1397     }
1398
1399   first = 1;
1400   suppress = 0;
1401   for (i = low; i < high; ++i)
1402     {
1403       next_address = trace_data.addrs[i];
1404       count = trace_data.counts[i];
1405       while (count-- > 0)
1406         {
1407           QUIT;
1408           if (trace_show_source)
1409             {
1410               struct symtab_and_line sal, sal_prev;
1411
1412               sal_prev = find_pc_line (next_address - 4, 0);
1413               sal = find_pc_line (next_address, 0);
1414
1415               if (sal.symtab)
1416                 {
1417                   if (first || sal.line != sal_prev.line)
1418                     print_source_lines (sal.symtab, sal.line, sal.line + 1, 0);
1419                   suppress = 0;
1420                 }
1421               else
1422                 {
1423                   if (!suppress)
1424                     /* FIXME-32x64--assumes sal.pc fits in long.  */
1425                     printf_filtered ("No source file for address %s.\n",
1426                                  local_hex_string ((unsigned long) sal.pc));
1427                   suppress = 1;
1428                 }
1429             }
1430           first = 0;
1431           print_address (next_address, gdb_stdout);
1432           printf_filtered (":");
1433           printf_filtered ("\t");
1434           wrap_here ("    ");
1435           next_address = next_address + print_insn (next_address, gdb_stdout);
1436           printf_filtered ("\n");
1437           gdb_flush (gdb_stdout);
1438         }
1439     }
1440 }
1441
1442
1443 static gdbarch_init_ftype d10v_gdbarch_init;
1444
1445 static struct gdbarch *
1446 d10v_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1447 {
1448   static LONGEST d10v_call_dummy_words[] =
1449   {0};
1450   struct gdbarch *gdbarch;
1451   int d10v_num_regs;
1452   struct gdbarch_tdep *tdep;
1453   gdbarch_register_name_ftype *d10v_register_name;
1454   gdbarch_register_sim_regno_ftype *d10v_register_sim_regno;
1455
1456   /* Find a candidate among the list of pre-declared architectures. */
1457   arches = gdbarch_list_lookup_by_info (arches, &info);
1458   if (arches != NULL)
1459     return arches->gdbarch;
1460
1461   /* None found, create a new architecture from the information
1462      provided. */
1463   tdep = XMALLOC (struct gdbarch_tdep);
1464   gdbarch = gdbarch_alloc (&info, tdep);
1465
1466   switch (info.bfd_arch_info->mach)
1467     {
1468     case bfd_mach_d10v_ts2:
1469       d10v_num_regs = 37;
1470       d10v_register_name = d10v_ts2_register_name;
1471       d10v_register_sim_regno = d10v_ts2_register_sim_regno;
1472       tdep->a0_regnum = TS2_A0_REGNUM;
1473       tdep->nr_dmap_regs = TS2_NR_DMAP_REGS;
1474       tdep->dmap_register = d10v_ts2_dmap_register;
1475       tdep->imap_register = d10v_ts2_imap_register;
1476       break;
1477     default:
1478     case bfd_mach_d10v_ts3:
1479       d10v_num_regs = 42;
1480       d10v_register_name = d10v_ts3_register_name;
1481       d10v_register_sim_regno = d10v_ts3_register_sim_regno;
1482       tdep->a0_regnum = TS3_A0_REGNUM;
1483       tdep->nr_dmap_regs = TS3_NR_DMAP_REGS;
1484       tdep->dmap_register = d10v_ts3_dmap_register;
1485       tdep->imap_register = d10v_ts3_imap_register;
1486       break;
1487     }
1488
1489   set_gdbarch_read_pc (gdbarch, d10v_read_pc);
1490   set_gdbarch_write_pc (gdbarch, d10v_write_pc);
1491   set_gdbarch_read_fp (gdbarch, d10v_read_fp);
1492   set_gdbarch_write_fp (gdbarch, d10v_write_fp);
1493   set_gdbarch_read_sp (gdbarch, d10v_read_sp);
1494   set_gdbarch_write_sp (gdbarch, d10v_write_sp);
1495
1496   set_gdbarch_num_regs (gdbarch, d10v_num_regs);
1497   set_gdbarch_sp_regnum (gdbarch, 15);
1498   set_gdbarch_fp_regnum (gdbarch, 11);
1499   set_gdbarch_pc_regnum (gdbarch, 18);
1500   set_gdbarch_register_name (gdbarch, d10v_register_name);
1501   set_gdbarch_register_size (gdbarch, 2);
1502   set_gdbarch_register_bytes (gdbarch, (d10v_num_regs - 2) * 2 + 16);
1503   set_gdbarch_register_byte (gdbarch, d10v_register_byte);
1504   set_gdbarch_register_raw_size (gdbarch, d10v_register_raw_size);
1505   set_gdbarch_max_register_raw_size (gdbarch, 8);
1506   set_gdbarch_register_virtual_size (gdbarch, generic_register_virtual_size);
1507   set_gdbarch_max_register_virtual_size (gdbarch, 8);
1508   set_gdbarch_register_virtual_type (gdbarch, d10v_register_virtual_type);
1509
1510   set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
1511   set_gdbarch_addr_bit (gdbarch, 32);
1512   set_gdbarch_address_to_pointer (gdbarch, d10v_address_to_pointer);
1513   set_gdbarch_pointer_to_address (gdbarch, d10v_pointer_to_address);
1514   set_gdbarch_integer_to_address (gdbarch, d10v_integer_to_address);
1515   set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
1516   set_gdbarch_int_bit (gdbarch, 2 * TARGET_CHAR_BIT);
1517   set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1518   set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
1519   /* NOTE: The d10v as a 32 bit ``float'' and ``double''. ``long
1520      double'' is 64 bits. */
1521   set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1522   set_gdbarch_double_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1523   set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
1524   switch (info.byte_order)
1525     {
1526     case BIG_ENDIAN:
1527       set_gdbarch_float_format (gdbarch, &floatformat_ieee_single_big);
1528       set_gdbarch_double_format (gdbarch, &floatformat_ieee_single_big);
1529       set_gdbarch_long_double_format (gdbarch, &floatformat_ieee_double_big);
1530       break;
1531     case LITTLE_ENDIAN:
1532       set_gdbarch_float_format (gdbarch, &floatformat_ieee_single_little);
1533       set_gdbarch_double_format (gdbarch, &floatformat_ieee_single_little);
1534       set_gdbarch_long_double_format (gdbarch, &floatformat_ieee_double_little);
1535       break;
1536     default:
1537       internal_error (__FILE__, __LINE__,
1538                       "d10v_gdbarch_init: bad byte order for float format");
1539     }
1540
1541   set_gdbarch_use_generic_dummy_frames (gdbarch, 1);
1542   set_gdbarch_call_dummy_length (gdbarch, 0);
1543   set_gdbarch_call_dummy_location (gdbarch, AT_ENTRY_POINT);
1544   set_gdbarch_call_dummy_address (gdbarch, entry_point_address);
1545   set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 1);
1546   set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 0);
1547   set_gdbarch_call_dummy_start_offset (gdbarch, 0);
1548   set_gdbarch_pc_in_call_dummy (gdbarch, generic_pc_in_call_dummy);
1549   set_gdbarch_call_dummy_words (gdbarch, d10v_call_dummy_words);
1550   set_gdbarch_sizeof_call_dummy_words (gdbarch, sizeof (d10v_call_dummy_words));
1551   set_gdbarch_call_dummy_p (gdbarch, 1);
1552   set_gdbarch_call_dummy_stack_adjust_p (gdbarch, 0);
1553   set_gdbarch_get_saved_register (gdbarch, generic_get_saved_register);
1554   set_gdbarch_fix_call_dummy (gdbarch, generic_fix_call_dummy);
1555
1556   set_gdbarch_extract_return_value (gdbarch, d10v_extract_return_value);
1557   set_gdbarch_push_arguments (gdbarch, d10v_push_arguments);
1558   set_gdbarch_push_dummy_frame (gdbarch, generic_push_dummy_frame);
1559   set_gdbarch_push_return_address (gdbarch, d10v_push_return_address);
1560
1561   set_gdbarch_store_struct_return (gdbarch, d10v_store_struct_return);
1562   set_gdbarch_store_return_value (gdbarch, d10v_store_return_value);
1563   set_gdbarch_extract_struct_value_address (gdbarch, d10v_extract_struct_value_address);
1564   set_gdbarch_use_struct_convention (gdbarch, d10v_use_struct_convention);
1565
1566   set_gdbarch_frame_init_saved_regs (gdbarch, d10v_frame_init_saved_regs);
1567   set_gdbarch_init_extra_frame_info (gdbarch, d10v_init_extra_frame_info);
1568
1569   set_gdbarch_pop_frame (gdbarch, d10v_pop_frame);
1570
1571   set_gdbarch_skip_prologue (gdbarch, d10v_skip_prologue);
1572   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1573   set_gdbarch_decr_pc_after_break (gdbarch, 4);
1574   set_gdbarch_function_start_offset (gdbarch, 0);
1575   set_gdbarch_breakpoint_from_pc (gdbarch, d10v_breakpoint_from_pc);
1576
1577   set_gdbarch_remote_translate_xfer_address (gdbarch, remote_d10v_translate_xfer_address);
1578
1579   set_gdbarch_frame_args_skip (gdbarch, 0);
1580   set_gdbarch_frameless_function_invocation (gdbarch, frameless_look_for_prologue);
1581   set_gdbarch_frame_chain (gdbarch, d10v_frame_chain);
1582   set_gdbarch_frame_chain_valid (gdbarch, d10v_frame_chain_valid);
1583   set_gdbarch_frame_saved_pc (gdbarch, d10v_frame_saved_pc);
1584   set_gdbarch_frame_args_address (gdbarch, default_frame_address);
1585   set_gdbarch_frame_locals_address (gdbarch, default_frame_address);
1586   set_gdbarch_saved_pc_after_call (gdbarch, d10v_saved_pc_after_call);
1587   set_gdbarch_frame_num_args (gdbarch, frame_num_args_unknown);
1588   set_gdbarch_stack_align (gdbarch, d10v_stack_align);
1589
1590   set_gdbarch_register_sim_regno (gdbarch, d10v_register_sim_regno);
1591   set_gdbarch_extra_stack_alignment_needed (gdbarch, 0);
1592
1593   return gdbarch;
1594 }
1595
1596
1597 extern void (*target_resume_hook) (void);
1598 extern void (*target_wait_loop_hook) (void);
1599
1600 void
1601 _initialize_d10v_tdep (void)
1602 {
1603   register_gdbarch_init (bfd_arch_d10v, d10v_gdbarch_init);
1604
1605   tm_print_insn = print_insn_d10v;
1606
1607   target_resume_hook = d10v_eva_prepare_to_trace;
1608   target_wait_loop_hook = d10v_eva_get_trace_data;
1609
1610   add_com ("regs", class_vars, show_regs, "Print all registers");
1611
1612   add_com ("itrace", class_support, trace_command,
1613            "Enable tracing of instruction execution.");
1614
1615   add_com ("iuntrace", class_support, untrace_command,
1616            "Disable tracing of instruction execution.");
1617
1618   add_com ("itdisassemble", class_vars, tdisassemble_command,
1619            "Disassemble the trace buffer.\n\
1620 Two optional arguments specify a range of trace buffer entries\n\
1621 as reported by info trace (NOT addresses!).");
1622
1623   add_info ("itrace", trace_info,
1624             "Display info about the trace data buffer.");
1625
1626   add_show_from_set (add_set_cmd ("itracedisplay", no_class,
1627                                   var_integer, (char *) &trace_display,
1628                              "Set automatic display of trace.\n", &setlist),
1629                      &showlist);
1630   add_show_from_set (add_set_cmd ("itracesource", no_class,
1631                            var_integer, (char *) &default_trace_show_source,
1632                       "Set display of source code with trace.\n", &setlist),
1633                      &showlist);
1634
1635 }