gdb/d10v-tdep.c

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