gdb/h8300-tdep.c

   1 /* Target-machine dependent code for Hitachi H8/300, for GDB.
   2    Copyright (C) 1988, 1990, 1991 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, Boston, MA 02111-1307, USA.  */
  19
  20 /*
  21  Contributed by Steve Chamberlain
  22                 sac@cygnus.com
  23  */
  24
  25 #include "defs.h"
  26 #include "frame.h"
  27 #include "obstack.h"
  28 #include "symtab.h"
  29 #include "dis-asm.h"
  30 #include "gdbcmd.h"
  31 #include "gdbtypes.h"
  32 #include "gdbcore.h"
  33 #include "gdb_string.h"
  34 #include "value.h"
  35
  36
  37 #undef NUM_REGS
  38 #define NUM_REGS 11
  39
  40 #define UNSIGNED_SHORT(X) ((X) & 0xffff)
  41
  42 #define IS_PUSH(x) ((x & 0xfff0)==0x6df0)
  43 #define IS_PUSH_FP(x) (x == 0x6df6)
  44 #define IS_MOVE_FP(x) (x == 0x0d76 || x == 0x0ff6)
  45 #define IS_MOV_SP_FP(x) (x == 0x0d76 || x == 0x0ff6)
  46 #define IS_SUB2_SP(x) (x==0x1b87)
  47 #define IS_SUB4_SP(x) (x==0x1b97)
  48 #define IS_SUBL_SP(x) (x==0x7a37)
  49 #define IS_MOVK_R5(x) (x==0x7905)
  50 #define IS_SUB_R5SP(x) (x==0x1957)
  51
  52 /* Local function declarations.  */
  53
  54 static CORE_ADDR examine_prologue ();
  55 static void set_machine_hook PARAMS ((char *filename));
  56
  57 void frame_find_saved_regs ();
  58 CORE_ADDR
  59 h8300_skip_prologue (start_pc)
  60      CORE_ADDR start_pc;
  61 {
  62   short int w;
  63   int adjust = 0;
  64
  65   /* Skip past all push and stm insns.  */
  66   while (1)
  67     {
  68       w = read_memory_unsigned_integer (start_pc, 2);
  69       /* First look for push insns.  */
  70       if (w == 0x0100 || w == 0x0110 || w == 0x0120 || w == 0x0130)
  71         {
  72           w = read_memory_unsigned_integer (start_pc + 2, 2);
  73           adjust = 2;
  74         }
  75
  76       if (IS_PUSH (w))
  77         {
  78           start_pc += 2 + adjust;
  79           w = read_memory_unsigned_integer (start_pc, 2);
  80           continue;
  81         }
  82       adjust = 0;
  83       break;
  84     }
  85
  86   /* Skip past a move to FP, either word or long sized */
  87   w = read_memory_unsigned_integer (start_pc, 2);
  88   if (w == 0x0100)
  89     {
  90       w = read_memory_unsigned_integer (start_pc + 2, 2);
  91       adjust += 2;
  92     }
  93
  94   if (IS_MOVE_FP (w))
  95     {
  96       start_pc += 2 + adjust;
  97       w = read_memory_unsigned_integer (start_pc, 2);
  98     }
  99
 100   /* Check for loading either a word constant into r5;
 101      long versions are handled by the SUBL_SP below.  */
 102   if (IS_MOVK_R5 (w))
 103     {
 104       start_pc += 2;
 105       w = read_memory_unsigned_integer (start_pc, 2);
 106     }
 107
 108   /* Now check for subtracting r5 from sp, word sized only.  */
 109   if (IS_SUB_R5SP (w))
 110     {
 111       start_pc += 2 + adjust;
 112       w = read_memory_unsigned_integer (start_pc, 2);
 113     }
 114
 115   /* Check for subs #2 and subs #4. */
 116   while (IS_SUB2_SP (w) || IS_SUB4_SP (w))
 117     {
 118       start_pc += 2 + adjust;
 119       w = read_memory_unsigned_integer (start_pc, 2);
 120     }
 121
 122   /* Check for a 32bit subtract.  */
 123   if (IS_SUBL_SP (w))
 124     start_pc += 6 + adjust;
 125
 126   return start_pc;
 127 }
 128
 129 int
 130 gdb_print_insn_h8300 (memaddr, info)
 131      bfd_vma memaddr;
 132      disassemble_info *info;
 133 {
 134   if (h8300smode)
 135     return print_insn_h8300s (memaddr, info);
 136   else if (h8300hmode)
 137     return print_insn_h8300h (memaddr, info);
 138   else
 139     return print_insn_h8300 (memaddr, info);
 140 }
 141
 142 /* Given a GDB frame, determine the address of the calling function's frame.
 143    This will be used to create a new GDB frame struct, and then
 144    INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC will be called for the new frame.
 145
 146    For us, the frame address is its stack pointer value, so we look up
 147    the function prologue to determine the caller's sp value, and return it.  */
 148
 149 CORE_ADDR
 150 h8300_frame_chain (thisframe)
 151      struct frame_info *thisframe;
 152 {
 153   frame_find_saved_regs (thisframe, (struct frame_saved_regs *) 0);
 154   return thisframe->fsr->regs[SP_REGNUM];
 155 }
 156
 157 /* Put here the code to store, into a struct frame_saved_regs,
 158    the addresses of the saved registers of frame described by FRAME_INFO.
 159    This includes special registers such as pc and fp saved in special
 160    ways in the stack frame.  sp is even more special:
 161    the address we return for it IS the sp for the next frame.
 162
 163    We cache the result of doing this in the frame_cache_obstack, since
 164    it is fairly expensive.  */
 165
 166 void
 167 frame_find_saved_regs (fi, fsr)
 168      struct frame_info *fi;
 169      struct frame_saved_regs *fsr;
 170 {
 171   register struct frame_saved_regs *cache_fsr;
 172   extern struct obstack frame_cache_obstack;
 173   CORE_ADDR ip;
 174   struct symtab_and_line sal;
 175   CORE_ADDR limit;
 176
 177   if (!fi->fsr)
 178     {
 179       cache_fsr = (struct frame_saved_regs *)
 180         obstack_alloc (&frame_cache_obstack,
 181                        sizeof (struct frame_saved_regs));
 182       memset (cache_fsr, '\0', sizeof (struct frame_saved_regs));
 183
 184       fi->fsr = cache_fsr;
 185
 186       /* Find the start and end of the function prologue.  If the PC
 187          is in the function prologue, we only consider the part that
 188          has executed already.  */
 189
 190       ip = get_pc_function_start (fi->pc);
 191       sal = find_pc_line (ip, 0);
 192       limit = (sal.end && sal.end < fi->pc) ? sal.end : fi->pc;
 193
 194       /* This will fill in fields in *fi as well as in cache_fsr.  */
 195       examine_prologue (ip, limit, fi->frame, cache_fsr, fi);
 196     }
 197
 198   if (fsr)
 199     *fsr = *fi->fsr;
 200 }
 201
 202 /* Fetch the instruction at ADDR, returning 0 if ADDR is beyond LIM or
 203    is not the address of a valid instruction, the address of the next
 204    instruction beyond ADDR otherwise.  *PWORD1 receives the first word
 205    of the instruction.*/
 206
 207 CORE_ADDR
 208 NEXT_PROLOGUE_INSN (addr, lim, pword1)
 209      CORE_ADDR addr;
 210      CORE_ADDR lim;
 211      INSN_WORD *pword1;
 212 {
 213   char buf[2];
 214   if (addr < lim + 8)
 215     {
 216       read_memory (addr, buf, 2);
 217       *pword1 = extract_signed_integer (buf, 2);
 218
 219       return addr + 2;
 220     }
 221   return 0;
 222 }
 223
 224 /* Examine the prologue of a function.  `ip' points to the first instruction.
 225    `limit' is the limit of the prologue (e.g. the addr of the first
 226    linenumber, or perhaps the program counter if we're stepping through).
 227    `frame_sp' is the stack pointer value in use in this frame.
 228    `fsr' is a pointer to a frame_saved_regs structure into which we put
 229    info about the registers saved by this frame.
 230    `fi' is a struct frame_info pointer; we fill in various fields in it
 231    to reflect the offsets of the arg pointer and the locals pointer.  */
 232
 233 static CORE_ADDR
 234 examine_prologue (ip, limit, after_prolog_fp, fsr, fi)
 235      register CORE_ADDR ip;
 236      register CORE_ADDR limit;
 237      CORE_ADDR after_prolog_fp;
 238      struct frame_saved_regs *fsr;
 239      struct frame_info *fi;
 240 {
 241   register CORE_ADDR next_ip;
 242   int r;
 243   int have_fp = 0;
 244   INSN_WORD insn_word;
 245   /* Number of things pushed onto stack, starts at 2/4, 'cause the
 246      PC is already there */
 247   unsigned int reg_save_depth = h8300hmode ? 4 : 2;
 248
 249   unsigned int auto_depth = 0;  /* Number of bytes of autos */
 250
 251   char in_frame[11];            /* One for each reg */
 252
 253   int adjust = 0;
 254
 255   memset (in_frame, 1, 11);
 256   for (r = 0; r < 8; r++)
 257     {
 258       fsr->regs[r] = 0;
 259     }
 260   if (after_prolog_fp == 0)
 261     {
 262       after_prolog_fp = read_register (SP_REGNUM);
 263     }
 264
 265   /* If the PC isn't valid, quit now.  */
 266   if (ip == 0 || ip & (h8300hmode ? ~0xffffff : ~0xffff))
 267     return 0;
 268
 269   next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word);
 270
 271   if (insn_word == 0x0100)
 272     {
 273       insn_word = read_memory_unsigned_integer (ip + 2, 2);
 274       adjust = 2;
 275     }
 276
 277   /* Skip over any fp push instructions */
 278   fsr->regs[6] = after_prolog_fp;
 279   while (next_ip && IS_PUSH_FP (insn_word))
 280     {
 281       ip = next_ip + adjust;
 282
 283       in_frame[insn_word & 0x7] = reg_save_depth;
 284       next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word);
 285       reg_save_depth += 2 + adjust;
 286     }
 287
 288   /* Is this a move into the fp */
 289   if (next_ip && IS_MOV_SP_FP (insn_word))
 290     {
 291       ip = next_ip;
 292       next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word);
 293       have_fp = 1;
 294     }
 295
 296   /* Skip over any stack adjustment, happens either with a number of
 297      sub#2,sp or a mov #x,r5 sub r5,sp */
 298
 299   if (next_ip && (IS_SUB2_SP (insn_word) || IS_SUB4_SP (insn_word)))
 300     {
 301       while (next_ip && (IS_SUB2_SP (insn_word) || IS_SUB4_SP (insn_word)))
 302         {
 303           auto_depth += IS_SUB2_SP (insn_word) ? 2 : 4;
 304           ip = next_ip;
 305           next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word);
 306         }
 307     }
 308   else
 309     {
 310       if (next_ip && IS_MOVK_R5 (insn_word))
 311         {
 312           ip = next_ip;
 313           next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word);
 314           auto_depth += insn_word;
 315
 316           next_ip = NEXT_PROLOGUE_INSN (next_ip, limit, &insn_word);
 317           auto_depth += insn_word;
 318         }
 319       if (next_ip && IS_SUBL_SP (insn_word))
 320         {
 321           ip = next_ip;
 322           auto_depth += read_memory_unsigned_integer (ip, 4);
 323           ip += 4;
 324
 325           next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word);
 326         }
 327     }
 328
 329   /* Now examine the push insns to determine where everything lives
 330      on the stack.  */
 331   while (1)
 332     {
 333       adjust = 0;
 334       if (!next_ip)
 335         break;
 336
 337       if (insn_word == 0x0100)
 338         {
 339           ip = next_ip;
 340           next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word);
 341           adjust = 2;
 342         }
 343
 344       if (IS_PUSH (insn_word))
 345         {
 346           ip = next_ip;
 347           next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word);
 348           fsr->regs[r] = after_prolog_fp + auto_depth;
 349           auto_depth += 2 + adjust;
 350           continue;
 351         }
 352
 353       /* Now check for push multiple insns.  */
 354       if (insn_word == 0x0110 || insn_word == 0x0120 || insn_word == 0x0130)
 355         {
 356           int count = ((insn_word >> 4) & 0xf) + 1;
 357           int start, i;
 358
 359           ip = next_ip;
 360           next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word);
 361           start = insn_word & 0x7;
 362
 363           for (i = start; i <= start + count; i++)
 364             {
 365               fsr->regs[i] = after_prolog_fp + auto_depth;
 366               auto_depth += 4;
 367             }
 368         }
 369       break;
 370     }
 371
 372   /* The args are always reffed based from the stack pointer */
 373   fi->args_pointer = after_prolog_fp;
 374   /* Locals are always reffed based from the fp */
 375   fi->locals_pointer = after_prolog_fp;
 376   /* The PC is at a known place */
 377   fi->from_pc = read_memory_unsigned_integer (after_prolog_fp + BINWORD, BINWORD);
 378
 379   /* Rememeber any others too */
 380   in_frame[PC_REGNUM] = 0;
 381
 382   if (have_fp)
 383     /* We keep the old FP in the SP spot */
 384     fsr->regs[SP_REGNUM] = read_memory_unsigned_integer (fsr->regs[6], BINWORD);
 385   else
 386     fsr->regs[SP_REGNUM] = after_prolog_fp + auto_depth;
 387
 388   return (ip);
 389 }
 390
 391 void
 392 init_extra_frame_info (fromleaf, fi)
 393      int fromleaf;
 394      struct frame_info *fi;
 395 {
 396   fi->fsr = 0;                  /* Not yet allocated */
 397   fi->args_pointer = 0;         /* Unknown */
 398   fi->locals_pointer = 0;       /* Unknown */
 399   fi->from_pc = 0;
 400 }
 401
 402 /* Return the saved PC from this frame.
 403
 404    If the frame has a memory copy of SRP_REGNUM, use that.  If not,
 405    just use the register SRP_REGNUM itself.  */
 406
 407 CORE_ADDR
 408 frame_saved_pc (frame)
 409      struct frame_info *frame;
 410 {
 411   return frame->from_pc;
 412 }
 413
 414 CORE_ADDR
 415 frame_locals_address (fi)
 416      struct frame_info *fi;
 417 {
 418   if (!fi->locals_pointer)
 419     {
 420       struct frame_saved_regs ignore;
 421
 422       get_frame_saved_regs (fi, &ignore);
 423
 424     }
 425   return fi->locals_pointer;
 426 }
 427
 428 /* Return the address of the argument block for the frame
 429    described by FI.  Returns 0 if the address is unknown.  */
 430
 431 CORE_ADDR
 432 frame_args_address (fi)
 433      struct frame_info *fi;
 434 {
 435   if (!fi->args_pointer)
 436     {
 437       struct frame_saved_regs ignore;
 438
 439       get_frame_saved_regs (fi, &ignore);
 440
 441     }
 442
 443   return fi->args_pointer;
 444 }
 445
 446 void
 447 h8300_pop_frame ()
 448 {
 449   unsigned regnum;
 450   struct frame_saved_regs fsr;
 451   struct frame_info *frame = get_current_frame ();
 452
 453   get_frame_saved_regs (frame, &fsr);
 454
 455   for (regnum = 0; regnum < 8; regnum++)
 456     {
 457       /* Don't forget SP_REGNUM is a frame_saved_regs struct is the
 458          actual value we want, not the address of the value we want.  */
 459       if (fsr.regs[regnum] && regnum != SP_REGNUM)
 460         write_register (regnum, read_memory_integer(fsr.regs[regnum], BINWORD));
 461       else if (fsr.regs[regnum] && regnum == SP_REGNUM)
 462         write_register (regnum, fsr.regs[regnum]);
 463     }
 464
 465   /* Don't forget the update the PC too!  */
 466   write_pc (frame->from_pc);
 467   flush_cached_frames ();
 468 }
 469
 470
 471 struct cmd_list_element *setmemorylist;
 472
 473 static void
 474 h8300_command(args, from_tty)
 475 {
 476   extern int h8300hmode;
 477   h8300hmode = 0;
 478   h8300smode = 0;
 479 }
 480
 481 static void
 482 h8300h_command(args, from_tty)
 483 {
 484   extern int h8300hmode;
 485   h8300hmode = 1;
 486   h8300smode = 0;
 487 }
 488 static void
 489 h8300s_command(args, from_tty)
 490 {
 491   extern int h8300smode;
 492   extern int h8300hmode;
 493   h8300smode = 1;
 494   h8300hmode = 1;
 495 }
 496
 497
 498 static void
 499 set_machine (args, from_tty)
 500      char *args;
 501      int from_tty;
 502 {
 503   printf_unfiltered ("\"set machine\" must be followed by h8300, h8300h");
 504   printf_unfiltered ("or h8300s");
 505   help_list (setmemorylist, "set memory ", -1, gdb_stdout);
 506 }
 507
 508 /* set_machine_hook is called as the exec file is being opened, but
 509    before the symbol file is opened.  This allows us to set the
 510    h8300hmode flag based on the machine type specified in the exec
 511    file.  This in turn will cause subsequently defined pointer types
 512    to be 16 or 32 bits as appropriate for the machine.  */
 513
 514 static void
 515 set_machine_hook (filename)
 516      char *filename;
 517 {
 518   if (bfd_get_mach (exec_bfd) == bfd_mach_h8300s)
 519     {
 520       h8300smode = 1;
 521       h8300hmode = 1;
 522     }
 523   else
 524     if (bfd_get_mach (exec_bfd) == bfd_mach_h8300h)
 525     {
 526       h8300smode = 0;
 527       h8300hmode = 1;
 528     }
 529   else
 530     {
 531       h8300smode = 0;
 532       h8300hmode = 0;
 533     }
 534 }
 535
 536 void
 537 _initialize_h8300m ()
 538 {
 539   add_prefix_cmd ("machine", no_class, set_machine,
 540                   "set the machine type", &setmemorylist, "set machine ", 0,
 541                   &setlist);
 542
 543   add_cmd ("h8300", class_support, h8300_command,
 544            "Set machine to be H8/300.", &setmemorylist);
 545
 546   add_cmd ("h8300h", class_support, h8300h_command,
 547            "Set machine to be H8/300H.", &setmemorylist);
 548
 549   add_cmd ("h8300s", class_support, h8300s_command,
 550            "Set machine to be H8/300S.", &setmemorylist);
 551
 552   /* Add a hook to set the machine type when we're loading a file. */
 553
 554   specify_exec_file_hook(set_machine_hook);
 555 }
 556
 557
 558
 559 void
 560 print_register_hook (regno)
 561 {
 562   if (regno == 8)
 563     {
 564       /* CCR register */
 565       int C, Z, N, V;
 566       unsigned char b[4];
 567       unsigned char l;
 568       read_relative_register_raw_bytes (regno, b);
 569       l = b[REGISTER_VIRTUAL_SIZE(8) -1];
 570       printf_unfiltered ("\t");
 571       printf_unfiltered ("I-%d - ", (l & 0x80) != 0);
 572       printf_unfiltered ("H-%d - ", (l & 0x20) != 0);
 573       N = (l & 0x8) != 0;
 574       Z = (l & 0x4) != 0;
 575       V = (l & 0x2) != 0;
 576       C = (l & 0x1) != 0;
 577       printf_unfiltered ("N-%d ", N);
 578       printf_unfiltered ("Z-%d ", Z);
 579       printf_unfiltered ("V-%d ", V);
 580       printf_unfiltered ("C-%d ", C);
 581       if ((C | Z) == 0)
 582         printf_unfiltered ("u> ");
 583       if ((C | Z) == 1)
 584         printf_unfiltered ("u<= ");
 585       if ((C == 0))
 586         printf_unfiltered ("u>= ");
 587       if (C == 1)
 588         printf_unfiltered ("u< ");
 589       if (Z == 0)
 590         printf_unfiltered ("!= ");
 591       if (Z == 1)
 592         printf_unfiltered ("== ");
 593       if ((N ^ V) == 0)
 594         printf_unfiltered (">= ");
 595       if ((N ^ V) == 1)
 596         printf_unfiltered ("< ");
 597       if ((Z | (N ^ V)) == 0)
 598         printf_unfiltered ("> ");
 599       if ((Z | (N ^ V)) == 1)
 600         printf_unfiltered ("<= ");
 601     }
 602 }
 603
 604 void
 605 _initialize_h8300_tdep ()
 606 {
 607   tm_print_insn = gdb_print_insn_h8300;
 608 }