gdb/d30v-tdep.c

   1 /* Target-dependent code for Mitsubishi D30V, 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, hunt@cygnus.com */
  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
  37 #include "language.h" /* For local_hex_string() */
  38
  39 void d30v_frame_find_saved_regs (struct frame_info *fi,
  40                                  struct frame_saved_regs *fsr);
  41 void d30v_frame_find_saved_regs_offsets (struct frame_info *fi,
  42                                          struct frame_saved_regs *fsr);
  43 static void d30v_pop_dummy_frame (struct frame_info *fi);
  44 static void d30v_print_flags (void);
  45 static void print_flags_command (char *, int);
  46
  47 /* the following defines assume:
  48    fp is r61, lr is r62, sp is r63, and ?? is r22
  49    if that changes, they will need to be updated */
  50
  51 #define OP_MASK_ALL_BUT_RA      0x0ffc0fff      /* throw away Ra, keep the rest */
  52
  53 #define OP_STW_SPM              0x054c0fc0      /* stw Ra, @(sp-) */
  54 #define OP_STW_SP_R0            0x05400fc0      /* stw Ra, @(sp,r0) */
  55 #define OP_STW_SP_IMM0          0x05480fc0      /* st Ra, @(sp, 0x0) */
  56 #define OP_STW_R22P_R0          0x05440580      /* stw Ra, @(r22+,r0) */
  57
  58 #define OP_ST2W_SPM             0x056c0fc0      /* st2w Ra, @(sp-) */
  59 #define OP_ST2W_SP_R0           0x05600fc0      /* st2w Ra, @(sp, r0) */
  60 #define OP_ST2W_SP_IMM0         0x05680fc0      /* st2w Ra, @(sp, 0x0) */
  61 #define OP_ST2W_R22P_R0         0x05640580      /* st2w Ra, @(r22+, r0) */
  62
  63 #define OP_MASK_OPCODE          0x0ffc0000      /* just the opcode, ign operands */
  64 #define OP_NOP                  0x00f00000      /* nop */
  65
  66 #define OP_MASK_ALL_BUT_IMM     0x0fffffc0      /* throw away imm, keep the rest */
  67 #define OP_SUB_SP_IMM           0x082bffc0      /* sub sp,sp,imm */
  68 #define OP_ADD_SP_IMM           0x080bffc0      /* add sp,sp,imm */
  69 #define OP_ADD_R22_SP_IMM       0x08096fc0      /* add r22,sp,imm */
  70 #define OP_STW_FP_SP_IMM        0x054bdfc0      /* stw fp,@(sp,imm) */
  71 #define OP_OR_SP_R0_IMM         0x03abf000      /* or sp,r0,imm */
  72
  73 /* no mask */
  74 #define OP_OR_FP_R0_SP          0x03a3d03f      /* or fp,r0,sp */
  75 #define OP_OR_FP_SP_R0          0x03a3dfc0      /* or fp,sp,r0 */
  76 #define OP_OR_FP_IMM0_SP        0x03abd03f      /* or fp,0x0,sp */
  77 #define OP_STW_FP_R22P_R0       0x0547d580      /* stw fp,@(r22+,r0) */
  78 #define OP_STW_LR_R22P_R0       0x0547e580      /* stw lr,@(r22+,r0) */
  79
  80 #define OP_MASK_OP_AND_RB       0x0ff80fc0      /* keep op and rb,throw away rest */
  81 #define OP_STW_SP_IMM           0x05480fc0      /* stw Ra,@(sp,imm) */
  82 #define OP_ST2W_SP_IMM          0x05680fc0      /* st2w Ra,@(sp,imm) */
  83 #define OP_STW_FP_IMM           0x05480f40      /* stw Ra,@(fp,imm) */
  84 #define OP_STW_FP_R0            0x05400f40      /* stw Ra,@(fp,r0) */
  85
  86 #define OP_MASK_FM_BIT          0x80000000
  87 #define OP_MASK_CC_BITS         0x70000000
  88 #define OP_MASK_SUB_INST        0x0fffffff
  89
  90 #define EXTRACT_RA(op)          (((op) >> 12) & 0x3f)
  91 #define EXTRACT_RB(op)          (((op) >> 6) & 0x3f)
  92 #define EXTRACT_RC(op)          (((op) & 0x3f)
  93 #define EXTRACT_UIMM6(op)       ((op) & 0x3f)
  94 #define EXTRACT_IMM6(op)        ((((int)EXTRACT_UIMM6(op)) << 26) >> 26)
  95 #define EXTRACT_IMM26(op)       ((((op)&0x0ff00000) >> 2) | ((op)&0x0003ffff))
  96 #define EXTRACT_IMM32(opl, opr) ((EXTRACT_UIMM6(opl) << 26)|EXTRACT_IMM26(opr))
  97
  98
  99 int
 100 d30v_frame_chain_valid (chain, fi)
 101      CORE_ADDR chain;
 102      struct frame_info *fi;     /* not used here */
 103 {
 104 #if 0
 105   return ((chain) != 0 && (fi) != 0 && (fi)->return_pc != 0);
 106 #else
 107   return ((chain) != 0 && (fi) != 0 && (fi)->frame <= chain);
 108 #endif
 109 }
 110
 111 /* Discard from the stack the innermost frame, restoring all saved
 112    registers.  */
 113
 114 void
 115 d30v_pop_frame (void)
 116 {
 117   struct frame_info *frame = get_current_frame ();
 118   CORE_ADDR fp;
 119   int regnum;
 120   struct frame_saved_regs fsr;
 121   char raw_buffer[8];
 122
 123   fp = FRAME_FP (frame);
 124   if (frame->dummy)
 125     {
 126       d30v_pop_dummy_frame (frame);
 127       return;
 128     }
 129
 130   /* fill out fsr with the address of where each */
 131   /* register was stored in the frame */
 132   get_frame_saved_regs (frame, &fsr);
 133
 134   /* now update the current registers with the old values */
 135   for (regnum = A0_REGNUM; regnum < A0_REGNUM + 2; regnum++)
 136     {
 137       if (fsr.regs[regnum])
 138         {
 139           read_memory (fsr.regs[regnum], raw_buffer, 8);
 140           write_register_bytes (REGISTER_BYTE (regnum), raw_buffer, 8);
 141         }
 142     }
 143   for (regnum = 0; regnum < SP_REGNUM; regnum++)
 144     {
 145       if (fsr.regs[regnum])
 146         {
 147           write_register (regnum, read_memory_unsigned_integer (fsr.regs[regnum], 4));
 148         }
 149     }
 150   if (fsr.regs[PSW_REGNUM])
 151     {
 152       write_register (PSW_REGNUM, read_memory_unsigned_integer (fsr.regs[PSW_REGNUM], 4));
 153     }
 154
 155   write_register (PC_REGNUM, read_register (LR_REGNUM));
 156   write_register (SP_REGNUM, fp + frame->size);
 157   target_store_registers (-1);
 158   flush_cached_frames ();
 159 }
 160
 161 static int
 162 check_prologue (unsigned long op)
 163 {
 164   /* add sp,sp,imm -- observed */
 165   if ((op & OP_MASK_ALL_BUT_IMM) == OP_ADD_SP_IMM)
 166     return 1;
 167
 168   /* add r22,sp,imm -- observed */
 169   if ((op & OP_MASK_ALL_BUT_IMM) == OP_ADD_R22_SP_IMM)
 170     return 1;
 171
 172   /* or  fp,r0,sp -- observed */
 173   if (op == OP_OR_FP_R0_SP)
 174     return 1;
 175
 176   /* nop */
 177   if ((op & OP_MASK_OPCODE) == OP_NOP)
 178     return 1;
 179
 180   /* stw  Ra,@(sp,r0) */
 181   if ((op & OP_MASK_ALL_BUT_RA) == OP_STW_SP_R0)
 182     return 1;
 183
 184   /* stw  Ra,@(sp,0x0) */
 185   if ((op & OP_MASK_ALL_BUT_RA) == OP_STW_SP_IMM0)
 186     return 1;
 187
 188   /* st2w  Ra,@(sp,r0) */
 189   if ((op & OP_MASK_ALL_BUT_RA) == OP_ST2W_SP_R0)
 190     return 1;
 191
 192   /* st2w  Ra,@(sp,0x0) */
 193   if ((op & OP_MASK_ALL_BUT_RA) == OP_ST2W_SP_IMM0)
 194     return 1;
 195
 196   /* stw fp, @(r22+,r0) -- observed */
 197   if (op == OP_STW_FP_R22P_R0)
 198     return 1;
 199
 200   /* stw r62, @(r22+,r0) -- observed */
 201   if (op == OP_STW_LR_R22P_R0)
 202     return 1;
 203
 204   /* stw Ra, @(fp,r0) -- observed */
 205   if ((op & OP_MASK_ALL_BUT_RA) == OP_STW_FP_R0)
 206     return 1;                   /* first arg */
 207
 208   /* stw Ra, @(fp,imm) -- observed */
 209   if ((op & OP_MASK_OP_AND_RB) == OP_STW_FP_IMM)
 210     return 1;                   /* second and subsequent args */
 211
 212   /* stw fp,@(sp,imm) -- observed */
 213   if ((op & OP_MASK_ALL_BUT_IMM) == OP_STW_FP_SP_IMM)
 214     return 1;
 215
 216   /* st2w Ra,@(r22+,r0) */
 217   if ((op & OP_MASK_ALL_BUT_RA) == OP_ST2W_R22P_R0)
 218     return 1;
 219
 220   /* stw  Ra, @(sp-) */
 221   if ((op & OP_MASK_ALL_BUT_RA) == OP_STW_SPM)
 222     return 1;
 223
 224   /* st2w  Ra, @(sp-) */
 225   if ((op & OP_MASK_ALL_BUT_RA) == OP_ST2W_SPM)
 226     return 1;
 227
 228   /* sub.?  sp,sp,imm */
 229   if ((op & OP_MASK_ALL_BUT_IMM) == OP_SUB_SP_IMM)
 230     return 1;
 231
 232   return 0;
 233 }
 234
 235 CORE_ADDR
 236 d30v_skip_prologue (CORE_ADDR pc)
 237 {
 238   unsigned long op[2];
 239   unsigned long opl, opr;       /* left / right sub operations */
 240   unsigned long fm0, fm1;       /* left / right mode bits */
 241   unsigned long cc0, cc1;
 242   unsigned long op1, op2;
 243   CORE_ADDR func_addr, func_end;
 244   struct symtab_and_line sal;
 245
 246   /* If we have line debugging information, then the end of the */
 247   /* prologue should the first assembly instruction of  the first source line */
 248   if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
 249     {
 250       sal = find_pc_line (func_addr, 0);
 251       if (sal.end && sal.end < func_end)
 252         return sal.end;
 253     }
 254
 255   if (target_read_memory (pc, (char *) &op[0], 8))
 256     return pc;                  /* Can't access it -- assume no prologue. */
 257
 258   while (1)
 259     {
 260       opl = (unsigned long) read_memory_integer (pc, 4);
 261       opr = (unsigned long) read_memory_integer (pc + 4, 4);
 262
 263       fm0 = (opl & OP_MASK_FM_BIT);
 264       fm1 = (opr & OP_MASK_FM_BIT);
 265
 266       cc0 = (opl & OP_MASK_CC_BITS);
 267       cc1 = (opr & OP_MASK_CC_BITS);
 268
 269       opl = (opl & OP_MASK_SUB_INST);
 270       opr = (opr & OP_MASK_SUB_INST);
 271
 272       if (fm0 && fm1)
 273         {
 274           /* long instruction (opl contains the opcode) */
 275           if (((opl & OP_MASK_ALL_BUT_IMM) != OP_ADD_SP_IMM) &&         /* add sp,sp,imm */
 276               ((opl & OP_MASK_ALL_BUT_IMM) != OP_ADD_R22_SP_IMM) &&     /* add r22,sp,imm */
 277               ((opl & OP_MASK_OP_AND_RB) != OP_STW_SP_IMM) &&   /* stw Ra, @(sp,imm) */
 278               ((opl & OP_MASK_OP_AND_RB) != OP_ST2W_SP_IMM))    /* st2w Ra, @(sp,imm) */
 279             break;
 280         }
 281       else
 282         {
 283           /* short instructions */
 284           if (fm0 && !fm1)
 285             {
 286               op1 = opr;
 287               op2 = opl;
 288             }
 289           else
 290             {
 291               op1 = opl;
 292               op2 = opr;
 293             }
 294           if (check_prologue (op1))
 295             {
 296               if (!check_prologue (op2))
 297                 {
 298                   /* if the previous opcode was really part of the prologue */
 299                   /* and not just a NOP, then we want to break after both instructions */
 300                   if ((op1 & OP_MASK_OPCODE) != OP_NOP)
 301                     pc += 8;
 302                   break;
 303                 }
 304             }
 305           else
 306             break;
 307         }
 308       pc += 8;
 309     }
 310   return pc;
 311 }
 312
 313 static int end_of_stack;
 314
 315 /* Given a GDB frame, determine the address of the calling function's frame.
 316    This will be used to create a new GDB frame struct, and then
 317    INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC will be called for the new frame.
 318  */
 319
 320 CORE_ADDR
 321 d30v_frame_chain (struct frame_info *frame)
 322 {
 323   struct frame_saved_regs fsr;
 324
 325   d30v_frame_find_saved_regs (frame, &fsr);
 326
 327   if (end_of_stack)
 328     return (CORE_ADDR) 0;
 329
 330   if (frame->return_pc == IMEM_START)
 331     return (CORE_ADDR) 0;
 332
 333   if (!fsr.regs[FP_REGNUM])
 334     {
 335       if (!fsr.regs[SP_REGNUM] || fsr.regs[SP_REGNUM] == STACK_START)
 336         return (CORE_ADDR) 0;
 337
 338       return fsr.regs[SP_REGNUM];
 339     }
 340
 341   if (!read_memory_unsigned_integer (fsr.regs[FP_REGNUM], 4))
 342     return (CORE_ADDR) 0;
 343
 344   return read_memory_unsigned_integer (fsr.regs[FP_REGNUM], 4);
 345 }
 346
 347 static int next_addr, uses_frame;
 348 static int frame_size;
 349
 350 static int
 351 prologue_find_regs (unsigned long op, struct frame_saved_regs *fsr,
 352                     CORE_ADDR addr)
 353 {
 354   int n;
 355   int offset;
 356
 357   /* add sp,sp,imm -- observed */
 358   if ((op & OP_MASK_ALL_BUT_IMM) == OP_ADD_SP_IMM)
 359     {
 360       offset = EXTRACT_IMM6 (op);
 361       /*next_addr += offset; */
 362       frame_size += -offset;
 363       return 1;
 364     }
 365
 366   /* add r22,sp,imm -- observed */
 367   if ((op & OP_MASK_ALL_BUT_IMM) == OP_ADD_R22_SP_IMM)
 368     {
 369       offset = EXTRACT_IMM6 (op);
 370       next_addr = (offset - frame_size);
 371       return 1;
 372     }
 373
 374   /* stw Ra, @(fp, offset) -- observed */
 375   if ((op & OP_MASK_OP_AND_RB) == OP_STW_FP_IMM)
 376     {
 377       n = EXTRACT_RA (op);
 378       offset = EXTRACT_IMM6 (op);
 379       fsr->regs[n] = (offset - frame_size);
 380       return 1;
 381     }
 382
 383   /* stw Ra, @(fp, r0) -- observed */
 384   if ((op & OP_MASK_ALL_BUT_RA) == OP_STW_FP_R0)
 385     {
 386       n = EXTRACT_RA (op);
 387       fsr->regs[n] = (-frame_size);
 388       return 1;
 389     }
 390
 391   /* or  fp,0,sp -- observed */
 392   if ((op == OP_OR_FP_R0_SP) ||
 393       (op == OP_OR_FP_SP_R0) ||
 394       (op == OP_OR_FP_IMM0_SP))
 395     {
 396       uses_frame = 1;
 397       return 1;
 398     }
 399
 400   /* nop */
 401   if ((op & OP_MASK_OPCODE) == OP_NOP)
 402     return 1;
 403
 404   /* stw Ra,@(r22+,r0) -- observed */
 405   if ((op & OP_MASK_ALL_BUT_RA) == OP_STW_R22P_R0)
 406     {
 407       n = EXTRACT_RA (op);
 408       fsr->regs[n] = next_addr;
 409       next_addr += 4;
 410       return 1;
 411     }
 412 #if 0                           /* subsumed in pattern above */
 413   /* stw fp,@(r22+,r0) -- observed */
 414   if (op == OP_STW_FP_R22P_R0)
 415     {
 416       fsr->regs[FP_REGNUM] = next_addr;         /* XXX */
 417       next_addr += 4;
 418       return 1;
 419     }
 420
 421   /* stw r62,@(r22+,r0) -- observed */
 422   if (op == OP_STW_LR_R22P_R0)
 423     {
 424       fsr->regs[LR_REGNUM] = next_addr;
 425       next_addr += 4;
 426       return 1;
 427     }
 428 #endif
 429   /* st2w Ra,@(r22+,r0) -- observed */
 430   if ((op & OP_MASK_ALL_BUT_RA) == OP_ST2W_R22P_R0)
 431     {
 432       n = EXTRACT_RA (op);
 433       fsr->regs[n] = next_addr;
 434       fsr->regs[n + 1] = next_addr + 4;
 435       next_addr += 8;
 436       return 1;
 437     }
 438
 439   /* stw  rn, @(sp-) */
 440   if ((op & OP_MASK_ALL_BUT_RA) == OP_STW_SPM)
 441     {
 442       n = EXTRACT_RA (op);
 443       fsr->regs[n] = next_addr;
 444       next_addr -= 4;
 445       return 1;
 446     }
 447
 448   /* st2w  Ra, @(sp-) */
 449   else if ((op & OP_MASK_ALL_BUT_RA) == OP_ST2W_SPM)
 450     {
 451       n = EXTRACT_RA (op);
 452       fsr->regs[n] = next_addr;
 453       fsr->regs[n + 1] = next_addr + 4;
 454       next_addr -= 8;
 455       return 1;
 456     }
 457
 458   /* sub  sp,sp,imm */
 459   if ((op & OP_MASK_ALL_BUT_IMM) == OP_SUB_SP_IMM)
 460     {
 461       offset = EXTRACT_IMM6 (op);
 462       frame_size += -offset;
 463       return 1;
 464     }
 465
 466   /* st  rn, @(sp,0) -- observed */
 467   if (((op & OP_MASK_ALL_BUT_RA) == OP_STW_SP_R0) ||
 468       ((op & OP_MASK_ALL_BUT_RA) == OP_STW_SP_IMM0))
 469     {
 470       n = EXTRACT_RA (op);
 471       fsr->regs[n] = (-frame_size);
 472       return 1;
 473     }
 474
 475   /* st2w  rn, @(sp,0) */
 476   if (((op & OP_MASK_ALL_BUT_RA) == OP_ST2W_SP_R0) ||
 477       ((op & OP_MASK_ALL_BUT_RA) == OP_ST2W_SP_IMM0))
 478     {
 479       n = EXTRACT_RA (op);
 480       fsr->regs[n] = (-frame_size);
 481       fsr->regs[n + 1] = (-frame_size) + 4;
 482       return 1;
 483     }
 484
 485   /* stw fp,@(sp,imm) -- observed */
 486   if ((op & OP_MASK_ALL_BUT_IMM) == OP_STW_FP_SP_IMM)
 487     {
 488       offset = EXTRACT_IMM6 (op);
 489       fsr->regs[FP_REGNUM] = (offset - frame_size);
 490       return 1;
 491     }
 492   return 0;
 493 }
 494
 495 /* Put here the code to store, into a struct frame_saved_regs, the
 496    addresses of the saved registers of frame described by FRAME_INFO.
 497    This includes special registers such as pc and fp saved in special
 498    ways in the stack frame.  sp is even more special: the address we
 499    return for it IS the sp for the next frame. */
 500 void
 501 d30v_frame_find_saved_regs (struct frame_info *fi, struct frame_saved_regs *fsr)
 502 {
 503   CORE_ADDR fp, pc;
 504   unsigned long opl, opr;
 505   unsigned long op1, op2;
 506   unsigned long fm0, fm1;
 507   int i;
 508
 509   fp = fi->frame;
 510   memset (fsr, 0, sizeof (*fsr));
 511   next_addr = 0;
 512   frame_size = 0;
 513   end_of_stack = 0;
 514
 515   uses_frame = 0;
 516
 517   d30v_frame_find_saved_regs_offsets (fi, fsr);
 518
 519   fi->size = frame_size;
 520
 521   if (!fp)
 522     fp = read_register (SP_REGNUM);
 523
 524   for (i = 0; i < NUM_REGS - 1; i++)
 525     if (fsr->regs[i])
 526       {
 527         fsr->regs[i] = fsr->regs[i] + fp + frame_size;
 528       }
 529
 530   if (fsr->regs[LR_REGNUM])
 531     fi->return_pc = read_memory_unsigned_integer (fsr->regs[LR_REGNUM], 4);
 532   else
 533     fi->return_pc = read_register (LR_REGNUM);
 534
 535   /* the SP is not normally (ever?) saved, but check anyway */
 536   if (!fsr->regs[SP_REGNUM])
 537     {
 538       /* if the FP was saved, that means the current FP is valid, */
 539       /* otherwise, it isn't being used, so we use the SP instead */
 540       if (uses_frame)
 541         fsr->regs[SP_REGNUM] = read_register (FP_REGNUM) + fi->size;
 542       else
 543         {
 544           fsr->regs[SP_REGNUM] = fp + fi->size;
 545           fi->frameless = 1;
 546           fsr->regs[FP_REGNUM] = 0;
 547         }
 548     }
 549 }
 550
 551 void
 552 d30v_frame_find_saved_regs_offsets (struct frame_info *fi,
 553                                     struct frame_saved_regs *fsr)
 554 {
 555   CORE_ADDR fp, pc;
 556   unsigned long opl, opr;
 557   unsigned long op1, op2;
 558   unsigned long fm0, fm1;
 559   int i;
 560
 561   fp = fi->frame;
 562   memset (fsr, 0, sizeof (*fsr));
 563   next_addr = 0;
 564   frame_size = 0;
 565   end_of_stack = 0;
 566
 567   pc = get_pc_function_start (fi->pc);
 568
 569   uses_frame = 0;
 570   while (pc < fi->pc)
 571     {
 572       opl = (unsigned long) read_memory_integer (pc, 4);
 573       opr = (unsigned long) read_memory_integer (pc + 4, 4);
 574
 575       fm0 = (opl & OP_MASK_FM_BIT);
 576       fm1 = (opr & OP_MASK_FM_BIT);
 577
 578       opl = (opl & OP_MASK_SUB_INST);
 579       opr = (opr & OP_MASK_SUB_INST);
 580
 581       if (fm0 && fm1)
 582         {
 583           /* long instruction */
 584           if ((opl & OP_MASK_ALL_BUT_IMM) == OP_ADD_SP_IMM)
 585             {
 586               /* add sp,sp,n */
 587               long offset = EXTRACT_IMM32 (opl, opr);
 588               frame_size += -offset;
 589             }
 590           else if ((opl & OP_MASK_ALL_BUT_IMM) == OP_ADD_R22_SP_IMM)
 591             {
 592               /* add r22,sp,offset */
 593               long offset = EXTRACT_IMM32 (opl, opr);
 594               next_addr = (offset - frame_size);
 595             }
 596           else if ((opl & OP_MASK_OP_AND_RB) == OP_STW_SP_IMM)
 597             {
 598               /* st Ra, @(sp,imm) */
 599               long offset = EXTRACT_IMM32 (opl, opr);
 600               short n = EXTRACT_RA (opl);
 601               fsr->regs[n] = (offset - frame_size);
 602             }
 603           else if ((opl & OP_MASK_OP_AND_RB) == OP_ST2W_SP_IMM)
 604             {
 605               /* st2w Ra, @(sp,offset) */
 606               long offset = EXTRACT_IMM32 (opl, opr);
 607               short n = EXTRACT_RA (opl);
 608               fsr->regs[n] = (offset - frame_size);
 609               fsr->regs[n + 1] = (offset - frame_size) + 4;
 610             }
 611           else if ((opl & OP_MASK_ALL_BUT_IMM) == OP_OR_SP_R0_IMM)
 612             {
 613               end_of_stack = 1;
 614             }
 615           else
 616             break;
 617         }
 618       else
 619         {
 620           /* short instructions */
 621           if (fm0 && !fm1)
 622             {
 623               op2 = opl;
 624               op1 = opr;
 625             }
 626           else
 627             {
 628               op1 = opl;
 629               op2 = opr;
 630             }
 631           if (!prologue_find_regs (op1, fsr, pc) || !prologue_find_regs (op2, fsr, pc))
 632             break;
 633         }
 634       pc += 8;
 635     }
 636
 637 #if 0
 638   fi->size = frame_size;
 639
 640   if (!fp)
 641     fp = read_register (SP_REGNUM);
 642
 643   for (i = 0; i < NUM_REGS - 1; i++)
 644     if (fsr->regs[i])
 645       {
 646         fsr->regs[i] = fsr->regs[i] + fp + frame_size;
 647       }
 648
 649   if (fsr->regs[LR_REGNUM])
 650     fi->return_pc = read_memory_unsigned_integer (fsr->regs[LR_REGNUM], 4);
 651   else
 652     fi->return_pc = read_register (LR_REGNUM);
 653
 654   /* the SP is not normally (ever?) saved, but check anyway */
 655   if (!fsr->regs[SP_REGNUM])
 656     {
 657       /* if the FP was saved, that means the current FP is valid, */
 658       /* otherwise, it isn't being used, so we use the SP instead */
 659       if (uses_frame)
 660         fsr->regs[SP_REGNUM] = read_register (FP_REGNUM) + fi->size;
 661       else
 662         {
 663           fsr->regs[SP_REGNUM] = fp + fi->size;
 664           fi->frameless = 1;
 665           fsr->regs[FP_REGNUM] = 0;
 666         }
 667     }
 668 #endif
 669 }
 670
 671 void
 672 d30v_init_extra_frame_info (int fromleaf, struct frame_info *fi)
 673 {
 674   struct frame_saved_regs dummy;
 675
 676   if (fi->next && (fi->pc == 0))
 677     fi->pc = fi->next->return_pc;
 678
 679   d30v_frame_find_saved_regs_offsets (fi, &dummy);
 680
 681   if (uses_frame == 0)
 682     fi->frameless = 1;
 683   else
 684     fi->frameless = 0;
 685
 686   if ((fi->next == 0) && (uses_frame == 0))
 687     /* innermost frame and it's "frameless",
 688        so the fi->frame field is wrong, fix it! */
 689     fi->frame = read_sp ();
 690
 691   if (dummy.regs[LR_REGNUM])
 692     {
 693       /* it was saved, grab it! */
 694       dummy.regs[LR_REGNUM] += (fi->frame + frame_size);
 695       fi->return_pc = read_memory_unsigned_integer (dummy.regs[LR_REGNUM], 4);
 696     }
 697   else
 698     fi->return_pc = read_register (LR_REGNUM);
 699 }
 700
 701 void
 702 d30v_init_frame_pc (int fromleaf, struct frame_info *prev)
 703 {
 704   /* default value, put here so we can breakpoint on it and
 705      see if the default value is really the right thing to use */
 706   prev->pc = (fromleaf ? SAVED_PC_AFTER_CALL (prev->next) : \
 707               prev->next ? FRAME_SAVED_PC (prev->next) : read_pc ());
 708 }
 709
 710 static void d30v_print_register (int regnum, int tabular);
 711
 712 static void
 713 d30v_print_register (int regnum, int tabular)
 714 {
 715   if (regnum < A0_REGNUM)
 716     {
 717       if (tabular)
 718         printf_filtered ("%08lx", (long) read_register (regnum));
 719       else
 720         printf_filtered ("0x%lx %ld",
 721                          (long) read_register (regnum),
 722                          (long) read_register (regnum));
 723     }
 724   else
 725     {
 726       char regbuf[MAX_REGISTER_RAW_SIZE];
 727
 728       read_relative_register_raw_bytes (regnum, regbuf);
 729
 730       val_print (REGISTER_VIRTUAL_TYPE (regnum), regbuf, 0, 0,
 731                  gdb_stdout, 'x', 1, 0, Val_pretty_default);
 732
 733       if (!tabular)
 734         {
 735           printf_filtered ("    ");
 736           val_print (REGISTER_VIRTUAL_TYPE (regnum), regbuf, 0, 0,
 737                      gdb_stdout, 'd', 1, 0, Val_pretty_default);
 738         }
 739     }
 740 }
 741
 742 static void
 743 d30v_print_flags (void)
 744 {
 745   long psw = read_register (PSW_REGNUM);
 746   printf_filtered ("flags #1");
 747   printf_filtered ("   (sm) %d", (psw & PSW_SM) != 0);
 748   printf_filtered ("   (ea) %d", (psw & PSW_EA) != 0);
 749   printf_filtered ("   (db) %d", (psw & PSW_DB) != 0);
 750   printf_filtered ("   (ds) %d", (psw & PSW_DS) != 0);
 751   printf_filtered ("   (ie) %d", (psw & PSW_IE) != 0);
 752   printf_filtered ("   (rp) %d", (psw & PSW_RP) != 0);
 753   printf_filtered ("   (md) %d\n", (psw & PSW_MD) != 0);
 754
 755   printf_filtered ("flags #2");
 756   printf_filtered ("   (f0) %d", (psw & PSW_F0) != 0);
 757   printf_filtered ("   (f1) %d", (psw & PSW_F1) != 0);
 758   printf_filtered ("   (f2) %d", (psw & PSW_F2) != 0);
 759   printf_filtered ("   (f3) %d", (psw & PSW_F3) != 0);
 760   printf_filtered ("    (s) %d", (psw & PSW_S) != 0);
 761   printf_filtered ("    (v) %d", (psw & PSW_V) != 0);
 762   printf_filtered ("   (va) %d", (psw & PSW_VA) != 0);
 763   printf_filtered ("    (c) %d\n", (psw & PSW_C) != 0);
 764 }
 765
 766 static void
 767 print_flags_command (char *args, int from_tty)
 768 {
 769   d30v_print_flags ();
 770 }
 771
 772 void
 773 d30v_do_registers_info (int regnum, int fpregs)
 774 {
 775   long long num1, num2;
 776   long psw;
 777
 778   if (regnum != -1)
 779     {
 780       if (REGISTER_NAME (0) == NULL || REGISTER_NAME (0)[0] == '\000')
 781         return;
 782
 783       printf_filtered ("%s ", REGISTER_NAME (regnum));
 784       d30v_print_register (regnum, 0);
 785
 786       printf_filtered ("\n");
 787       return;
 788     }
 789
 790   /* Have to print all the registers.  Format them nicely.  */
 791
 792   printf_filtered ("PC=");
 793   print_address (read_pc (), gdb_stdout);
 794
 795   printf_filtered (" PSW=");
 796   d30v_print_register (PSW_REGNUM, 1);
 797
 798   printf_filtered (" BPC=");
 799   print_address (read_register (BPC_REGNUM), gdb_stdout);
 800
 801   printf_filtered (" BPSW=");
 802   d30v_print_register (BPSW_REGNUM, 1);
 803   printf_filtered ("\n");
 804
 805   printf_filtered ("DPC=");
 806   print_address (read_register (DPC_REGNUM), gdb_stdout);
 807
 808   printf_filtered (" DPSW=");
 809   d30v_print_register (DPSW_REGNUM, 1);
 810
 811   printf_filtered (" IBA=");
 812   print_address (read_register (IBA_REGNUM), gdb_stdout);
 813   printf_filtered ("\n");
 814
 815   printf_filtered ("RPT_C=");
 816   d30v_print_register (RPT_C_REGNUM, 1);
 817
 818   printf_filtered (" RPT_S=");
 819   print_address (read_register (RPT_S_REGNUM), gdb_stdout);
 820
 821   printf_filtered (" RPT_E=");
 822   print_address (read_register (RPT_E_REGNUM), gdb_stdout);
 823   printf_filtered ("\n");
 824
 825   printf_filtered ("MOD_S=");
 826   print_address (read_register (MOD_S_REGNUM), gdb_stdout);
 827
 828   printf_filtered (" MOD_E=");
 829   print_address (read_register (MOD_E_REGNUM), gdb_stdout);
 830   printf_filtered ("\n");
 831
 832   printf_filtered ("EIT_VB=");
 833   print_address (read_register (EIT_VB_REGNUM), gdb_stdout);
 834
 835   printf_filtered (" INT_S=");
 836   d30v_print_register (INT_S_REGNUM, 1);
 837
 838   printf_filtered (" INT_M=");
 839   d30v_print_register (INT_M_REGNUM, 1);
 840   printf_filtered ("\n");
 841
 842   d30v_print_flags ();
 843   for (regnum = 0; regnum <= 63;)
 844     {
 845       int i;
 846
 847       printf_filtered ("R%d-R%d ", regnum, regnum + 7);
 848       if (regnum < 10)
 849         printf_filtered (" ");
 850       if (regnum + 7 < 10)
 851         printf_filtered (" ");
 852
 853       for (i = 0; i < 8; i++)
 854         {
 855           printf_filtered (" ");
 856           d30v_print_register (regnum++, 1);
 857         }
 858
 859       printf_filtered ("\n");
 860     }
 861
 862   printf_filtered ("A0-A1    ");
 863
 864   d30v_print_register (A0_REGNUM, 1);
 865   printf_filtered ("    ");
 866   d30v_print_register (A1_REGNUM, 1);
 867   printf_filtered ("\n");
 868 }
 869
 870 CORE_ADDR
 871 d30v_fix_call_dummy (char *dummyname, CORE_ADDR start_sp, CORE_ADDR fun,
 872                      int nargs, value_ptr *args, struct type *type, int gcc_p)
 873 {
 874   int regnum;
 875   CORE_ADDR sp;
 876   char buffer[MAX_REGISTER_RAW_SIZE];
 877   struct frame_info *frame = get_current_frame ();
 878   frame->dummy = start_sp;
 879   /*start_sp |= DMEM_START; */
 880
 881   sp = start_sp;
 882   for (regnum = 0; regnum < NUM_REGS; regnum++)
 883     {
 884       sp -= REGISTER_RAW_SIZE (regnum);
 885       store_address (buffer, REGISTER_RAW_SIZE (regnum), read_register (regnum));
 886       write_memory (sp, buffer, REGISTER_RAW_SIZE (regnum));
 887     }
 888   write_register (SP_REGNUM, (LONGEST) sp);
 889   /* now we need to load LR with the return address */
 890   write_register (LR_REGNUM, (LONGEST) d30v_call_dummy_address ());
 891   return sp;
 892 }
 893
 894 static void
 895 d30v_pop_dummy_frame (struct frame_info *fi)
 896 {
 897   CORE_ADDR sp = fi->dummy;
 898   int regnum;
 899
 900   for (regnum = 0; regnum < NUM_REGS; regnum++)
 901     {
 902       sp -= REGISTER_RAW_SIZE (regnum);
 903       write_register (regnum, read_memory_unsigned_integer (sp, REGISTER_RAW_SIZE (regnum)));
 904     }
 905   flush_cached_frames ();       /* needed? */
 906 }
 907
 908
 909 CORE_ADDR
 910 d30v_push_arguments (int nargs, value_ptr *args, CORE_ADDR sp,
 911                      int struct_return, CORE_ADDR struct_addr)
 912 {
 913   int i, len, index = 0, regnum = 2;
 914   char buffer[4], *contents;
 915   LONGEST val;
 916   CORE_ADDR ptrs[10];
 917
 918 #if 0
 919   /* Pass 1. Put all large args on stack */
 920   for (i = 0; i < nargs; i++)
 921     {
 922       value_ptr arg = args[i];
 923       struct type *arg_type = check_typedef (VALUE_TYPE (arg));
 924       len = TYPE_LENGTH (arg_type);
 925       contents = VALUE_CONTENTS (arg);
 926       val = extract_signed_integer (contents, len);
 927       if (len > 4)
 928         {
 929           /* put on stack and pass pointers */
 930           sp -= len;
 931           write_memory (sp, contents, len);
 932           ptrs[index++] = sp;
 933         }
 934     }
 935 #endif
 936   index = 0;
 937
 938   for (i = 0; i < nargs; i++)
 939     {
 940       value_ptr arg = args[i];
 941       struct type *arg_type = check_typedef (VALUE_TYPE (arg));
 942       len = TYPE_LENGTH (arg_type);
 943       contents = VALUE_CONTENTS (arg);
 944       if (len > 4)
 945         {
 946           /* we need multiple registers */
 947           int ndx;
 948
 949           for (ndx = 0; len > 0; ndx += 8, len -= 8)
 950             {
 951               if (regnum & 1)
 952                 regnum++;       /* all args > 4 bytes start in even register */
 953
 954               if (regnum < 18)
 955                 {
 956                   val = extract_signed_integer (&contents[ndx], 4);
 957                   write_register (regnum++, val);
 958
 959                   if (len >= 8)
 960                     val = extract_signed_integer (&contents[ndx + 4], 4);
 961                   else
 962                     val = extract_signed_integer (&contents[ndx + 4], len - 4);
 963                   write_register (regnum++, val);
 964                 }
 965               else
 966                 {
 967                   /* no more registers available.  put it on the stack */
 968
 969                   /* all args > 4 bytes are padded to a multiple of 8 bytes
 970                      and start on an 8 byte boundary */
 971                   if (sp & 7)
 972                     sp -= (sp & 7);     /* align it */
 973
 974                   sp -= ((len + 7) & ~7);       /* allocate space */
 975                   write_memory (sp, &contents[ndx], len);
 976                   break;
 977                 }
 978             }
 979         }
 980       else
 981         {
 982           if (regnum < 18)
 983             {
 984               val = extract_signed_integer (contents, len);
 985               write_register (regnum++, val);
 986             }
 987           else
 988             {
 989               /* all args are padded to a multiple of 4 bytes (at least) */
 990               sp -= ((len + 3) & ~3);
 991               write_memory (sp, contents, len);
 992             }
 993         }
 994     }
 995   if (sp & 7)
 996     /* stack pointer is not on an 8 byte boundary -- align it */
 997     sp -= (sp & 7);
 998   return sp;
 999 }
1000
1001
1002 /* pick an out-of-the-way place to set the return value */
1003 /* for an inferior function call.  The link register is set to this  */
1004 /* value and a momentary breakpoint is set there.  When the breakpoint */
1005 /* is hit, the dummy frame is popped and the previous environment is */
1006 /* restored. */
1007
1008 CORE_ADDR
1009 d30v_call_dummy_address (void)
1010 {
1011   CORE_ADDR entry;
1012   struct minimal_symbol *sym;
1013
1014   entry = entry_point_address ();
1015
1016   if (entry != 0)
1017     return entry;
1018
1019   sym = lookup_minimal_symbol ("_start", NULL, symfile_objfile);
1020
1021   if (!sym || MSYMBOL_TYPE (sym) != mst_text)
1022     return 0;
1023   else
1024     return SYMBOL_VALUE_ADDRESS (sym);
1025 }
1026
1027 /* Given a return value in `regbuf' with a type `valtype',
1028    extract and copy its value into `valbuf'.  */
1029
1030 void
1031 d30v_extract_return_value (valtype, regbuf, valbuf)
1032      struct type *valtype;
1033      char regbuf[REGISTER_BYTES];
1034      char *valbuf;
1035 {
1036   memcpy (valbuf, regbuf + REGISTER_BYTE (2), TYPE_LENGTH (valtype));
1037 }
1038
1039 /* The following code implements access to, and display of, the D30V's
1040    instruction trace buffer.  The buffer consists of 64K or more
1041    4-byte words of data, of which each words includes an 8-bit count,
1042    an 8-bit segment number, and a 16-bit instruction address.
1043
1044    In theory, the trace buffer is continuously capturing instruction
1045    data that the CPU presents on its "debug bus", but in practice, the
1046    ROMified GDB stub only enables tracing when it continues or steps
1047    the program, and stops tracing when the program stops; so it
1048    actually works for GDB to read the buffer counter out of memory and
1049    then read each trace word.  The counter records where the tracing
1050    stops, but there is no record of where it started, so we remember
1051    the PC when we resumed and then search backwards in the trace
1052    buffer for a word that includes that address.  This is not perfect,
1053    because you will miss trace data if the resumption PC is the target
1054    of a branch.  (The value of the buffer counter is semi-random, any
1055    trace data from a previous program stop is gone.)  */
1056
1057 /* The address of the last word recorded in the trace buffer.  */
1058
1059 #define DBBC_ADDR (0xd80000)
1060
1061 /* The base of the trace buffer, at least for the "Board_0".  */
1062
1063 #define TRACE_BUFFER_BASE (0xf40000)
1064
1065 static void trace_command (char *, int);
1066
1067 static void untrace_command (char *, int);
1068
1069 static void trace_info (char *, int);
1070
1071 static void tdisassemble_command (char *, int);
1072
1073 static void display_trace (int, int);
1074
1075 /* True when instruction traces are being collected.  */
1076
1077 static int tracing;
1078
1079 /* Remembered PC.  */
1080
1081 static CORE_ADDR last_pc;
1082
1083 /* True when trace output should be displayed whenever program stops.  */
1084
1085 static int trace_display;
1086
1087 /* True when trace listing should include source lines.  */
1088
1089 static int default_trace_show_source = 1;
1090
1091 struct trace_buffer
1092   {
1093     int size;
1094     short *counts;
1095     CORE_ADDR *addrs;
1096   }
1097 trace_data;
1098
1099 static void
1100 trace_command (char *args, int from_tty)
1101 {
1102   /* Clear the host-side trace buffer, allocating space if needed.  */
1103   trace_data.size = 0;
1104   if (trace_data.counts == NULL)
1105     trace_data.counts = (short *) xmalloc (65536 * sizeof (short));
1106   if (trace_data.addrs == NULL)
1107     trace_data.addrs = (CORE_ADDR *) xmalloc (65536 * sizeof (CORE_ADDR));
1108
1109   tracing = 1;
1110
1111   printf_filtered ("Tracing is now on.\n");
1112 }
1113
1114 static void
1115 untrace_command (char *args, int from_tty)
1116 {
1117   tracing = 0;
1118
1119   printf_filtered ("Tracing is now off.\n");
1120 }
1121
1122 static void
1123 trace_info (char *args, int from_tty)
1124 {
1125   int i;
1126
1127   if (trace_data.size)
1128     {
1129       printf_filtered ("%d entries in trace buffer:\n", trace_data.size);
1130
1131       for (i = 0; i < trace_data.size; ++i)
1132         {
1133           printf_filtered ("%d: %d instruction%s at 0x%s\n",
1134                            i, trace_data.counts[i],
1135                            (trace_data.counts[i] == 1 ? "" : "s"),
1136                            paddr_nz (trace_data.addrs[i]));
1137         }
1138     }
1139   else
1140     printf_filtered ("No entries in trace buffer.\n");
1141
1142   printf_filtered ("Tracing is currently %s.\n", (tracing ? "on" : "off"));
1143 }
1144
1145 /* Print the instruction at address MEMADDR in debugged memory,
1146    on STREAM.  Returns length of the instruction, in bytes.  */
1147
1148 static int
1149 print_insn (CORE_ADDR memaddr, struct ui_file *stream)
1150 {
1151   /* If there's no disassembler, something is very wrong.  */
1152   if (tm_print_insn == NULL)
1153     internal_error ("print_insn: no disassembler");
1154
1155   if (TARGET_BYTE_ORDER == BIG_ENDIAN)
1156     tm_print_insn_info.endian = BFD_ENDIAN_BIG;
1157   else
1158     tm_print_insn_info.endian = BFD_ENDIAN_LITTLE;
1159   return (*tm_print_insn) (memaddr, &tm_print_insn_info);
1160 }
1161
1162 void
1163 d30v_eva_prepare_to_trace (void)
1164 {
1165   if (!tracing)
1166     return;
1167
1168   last_pc = read_register (PC_REGNUM);
1169 }
1170
1171 /* Collect trace data from the target board and format it into a form
1172    more useful for display.  */
1173
1174 void
1175 d30v_eva_get_trace_data (void)
1176 {
1177   int count, i, j, oldsize;
1178   int trace_addr, trace_seg, trace_cnt, next_cnt;
1179   unsigned int last_trace, trace_word, next_word;
1180   unsigned int *tmpspace;
1181
1182   if (!tracing)
1183     return;
1184
1185   tmpspace = xmalloc (65536 * sizeof (unsigned int));
1186
1187   last_trace = read_memory_unsigned_integer (DBBC_ADDR, 2) << 2;
1188
1189   /* Collect buffer contents from the target, stopping when we reach
1190      the word recorded when execution resumed.  */
1191
1192   count = 0;
1193   while (last_trace > 0)
1194     {
1195       QUIT;
1196       trace_word =
1197         read_memory_unsigned_integer (TRACE_BUFFER_BASE + last_trace, 4);
1198       trace_addr = trace_word & 0xffff;
1199       last_trace -= 4;
1200       /* Ignore an apparently nonsensical entry.  */
1201       if (trace_addr == 0xffd5)
1202         continue;
1203       tmpspace[count++] = trace_word;
1204       if (trace_addr == last_pc)
1205         break;
1206       if (count > 65535)
1207         break;
1208     }
1209
1210   /* Move the data to the host-side trace buffer, adjusting counts to
1211      include the last instruction executed and transforming the address
1212      into something that GDB likes.  */
1213
1214   for (i = 0; i < count; ++i)
1215     {
1216       trace_word = tmpspace[i];
1217       next_word = ((i == 0) ? 0 : tmpspace[i - 1]);
1218       trace_addr = trace_word & 0xffff;
1219       next_cnt = (next_word >> 24) & 0xff;
1220       j = trace_data.size + count - i - 1;
1221       trace_data.addrs[j] = (trace_addr << 2) + 0x1000000;
1222       trace_data.counts[j] = next_cnt + 1;
1223     }
1224
1225   oldsize = trace_data.size;
1226   trace_data.size += count;
1227
1228   free (tmpspace);
1229
1230   if (trace_display)
1231     display_trace (oldsize, trace_data.size);
1232 }
1233
1234 static void
1235 tdisassemble_command (char *arg, int from_tty)
1236 {
1237   int i, count;
1238   CORE_ADDR low, high;
1239   char *space_index;
1240
1241   if (!arg)
1242     {
1243       low = 0;
1244       high = trace_data.size;
1245     }
1246   else if (!(space_index = (char *) strchr (arg, ' ')))
1247     {
1248       low = parse_and_eval_address (arg);
1249       high = low + 5;
1250     }
1251   else
1252     {
1253       /* Two arguments.  */
1254       *space_index = '\0';
1255       low = parse_and_eval_address (arg);
1256       high = parse_and_eval_address (space_index + 1);
1257       if (high < low)
1258         high = low;
1259     }
1260
1261   printf_filtered ("Dump of trace from %s to %s:\n",
1262                    paddr_u (low),
1263                    paddr_u (high));
1264
1265   display_trace (low, high);
1266
1267   printf_filtered ("End of trace dump.\n");
1268   gdb_flush (gdb_stdout);
1269 }
1270
1271 static void
1272 display_trace (int low, int high)
1273 {
1274   int i, count, trace_show_source, first, suppress;
1275   CORE_ADDR next_address;
1276
1277   trace_show_source = default_trace_show_source;
1278   if (!have_full_symbols () && !have_partial_symbols ())
1279     {
1280       trace_show_source = 0;
1281       printf_filtered ("No symbol table is loaded.  Use the \"file\" command.\n");
1282       printf_filtered ("Trace will not display any source.\n");
1283     }
1284
1285   first = 1;
1286   suppress = 0;
1287   for (i = low; i < high; ++i)
1288     {
1289       next_address = trace_data.addrs[i];
1290       count = trace_data.counts[i];
1291       while (count-- > 0)
1292         {
1293           QUIT;
1294           if (trace_show_source)
1295             {
1296               struct symtab_and_line sal, sal_prev;
1297
1298               sal_prev = find_pc_line (next_address - 4, 0);
1299               sal = find_pc_line (next_address, 0);
1300
1301               if (sal.symtab)
1302                 {
1303                   if (first || sal.line != sal_prev.line)
1304                     print_source_lines (sal.symtab, sal.line, sal.line + 1, 0);
1305                   suppress = 0;
1306                 }
1307               else
1308                 {
1309                   if (!suppress)
1310                     /* FIXME-32x64--assumes sal.pc fits in long.  */
1311                     printf_filtered ("No source file for address %s.\n",
1312                                  local_hex_string ((unsigned long) sal.pc));
1313                   suppress = 1;
1314                 }
1315             }
1316           first = 0;
1317           print_address (next_address, gdb_stdout);
1318           printf_filtered (":");
1319           printf_filtered ("\t");
1320           wrap_here ("    ");
1321           next_address = next_address + print_insn (next_address, gdb_stdout);
1322           printf_filtered ("\n");
1323           gdb_flush (gdb_stdout);
1324         }
1325     }
1326 }
1327
1328 extern void (*target_resume_hook) (void);
1329 extern void (*target_wait_loop_hook) (void);
1330
1331 void
1332 _initialize_d30v_tdep (void)
1333 {
1334   tm_print_insn = print_insn_d30v;
1335
1336   target_resume_hook = d30v_eva_prepare_to_trace;
1337   target_wait_loop_hook = d30v_eva_get_trace_data;
1338
1339   add_info ("flags", print_flags_command, "Print d30v flags.");
1340
1341   add_com ("trace", class_support, trace_command,
1342            "Enable tracing of instruction execution.");
1343
1344   add_com ("untrace", class_support, untrace_command,
1345            "Disable tracing of instruction execution.");
1346
1347   add_com ("tdisassemble", class_vars, tdisassemble_command,
1348            "Disassemble the trace buffer.\n\
1349 Two optional arguments specify a range of trace buffer entries\n\
1350 as reported by info trace (NOT addresses!).");
1351
1352   add_info ("trace", trace_info,
1353             "Display info about the trace data buffer.");
1354
1355   add_show_from_set (add_set_cmd ("tracedisplay", no_class,
1356                                   var_integer, (char *) &trace_display,
1357                              "Set automatic display of trace.\n", &setlist),
1358                      &showlist);
1359   add_show_from_set (add_set_cmd ("tracesource", no_class,
1360                            var_integer, (char *) &default_trace_show_source,
1361                       "Set display of source code with trace.\n", &setlist),
1362                      &showlist);
1363
1364 }