gdb/mn10300-tdep.c

   1 /* Target-dependent code for the Matsushita MN10300 for GDB, the GNU debugger.
   2    Copyright 1996, 1997, 1998 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 #include "defs.h"
  21 #include "frame.h"
  22 #include "inferior.h"
  23 #include "obstack.h"
  24 #include "target.h"
  25 #include "value.h"
  26 #include "bfd.h"
  27 #include "gdb_string.h"
  28 #include "gdbcore.h"
  29 #include "symfile.h"
  30
  31 char *mn10300_generic_register_names[] = REGISTER_NAMES;
  32
  33 /* start-sanitize-am33 */
  34 char *am33_register_names [] =
  35 { "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
  36   "sp", "pc", "mdr", "psw", "lir", "lar", "",
  37   "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
  38   "ssp", "msp", "usp", "mcrh", "mcrl", "mcvf", "", "", ""};
  39 /* end-sanitize-am33 */
  40
  41
  42 /* Set offsets of registers saved by movm instruction.
  43    This is a helper function for mn10300_analyze_prologue.  */
  44
  45 static void
  46 set_movm_offsets (fi, found_movm)
  47     struct frame_info *fi;
  48     int found_movm;
  49 {
  50   if (fi == NULL || found_movm == 0)
  51     return;
  52   fi->fsr.regs[7] = fi->frame;
  53   fi->fsr.regs[6] = fi->frame + 4;
  54   fi->fsr.regs[3] = fi->frame + 8;
  55   fi->fsr.regs[2] = fi->frame + 12;
  56   /* start-sanitize-am33 */
  57   fi->fsr.regs[E0_REGNUM+5] = fi->frame + 16;
  58   fi->fsr.regs[E0_REGNUM+4] = fi->frame + 20;
  59   fi->fsr.regs[E0_REGNUM+3] = fi->frame + 24;
  60   fi->fsr.regs[E0_REGNUM+2] = fi->frame + 28;
  61   /* end-sanitize-am33 */
  62 }
  63
  64
  65 /* The main purpose of this file is dealing with prologues to extract
  66    information about stack frames and saved registers.
  67
  68    For reference here's how prologues look on the mn10300:
  69
  70      With frame pointer:
  71         movm [d2,d3,a2,a3],sp
  72         mov sp,a3
  73         add <size>,sp
  74
  75      Without frame pointer:
  76         movm [d2,d3,a2,a3],sp (if needed)
  77         add <size>,sp
  78
  79    One day we might keep the stack pointer constant, that won't
  80    change the code for prologues, but it will make the frame
  81    pointerless case much more common.  */
  82
  83 /* Analyze the prologue to determine where registers are saved,
  84    the end of the prologue, etc etc.  Return the end of the prologue
  85    scanned.
  86
  87    We store into FI (if non-null) several tidbits of information:
  88
  89     * stack_size -- size of this stack frame.  Note that if we stop in
  90     certain parts of the prologue/epilogue we may claim the size of the
  91     current frame is zero.  This happens when the current frame has
  92     not been allocated yet or has already been deallocated.
  93
  94     * fsr -- Addresses of registers saved in the stack by this frame.
  95
  96     * status -- A (relatively) generic status indicator.  It's a bitmask
  97     with the following bits:
  98
  99       MY_FRAME_IN_SP: The base of the current frame is actually in
 100       the stack pointer.  This can happen for frame pointerless
 101       functions, or cases where we're stopped in the prologue/epilogue
 102       itself.  For these cases mn10300_analyze_prologue will need up
 103       update fi->frame before returning or analyzing the register
 104       save instructions.
 105
 106       MY_FRAME_IN_FP: The base of the current frame is in the
 107       frame pointer register ($a2).
 108
 109       NO_MORE_FRAMES: Set this if the current frame is "start" or
 110       if the first instruction looks like mov <imm>,sp.  This tells
 111       frame chain to not bother trying to unwind past this frame.  */
 112
 113 #define MY_FRAME_IN_SP 0x1
 114 #define MY_FRAME_IN_FP 0x2
 115 #define NO_MORE_FRAMES 0x4
 116
 117 static CORE_ADDR
 118 mn10300_analyze_prologue (fi, pc)
 119     struct frame_info *fi;
 120     CORE_ADDR pc;
 121 {
 122   CORE_ADDR func_addr, func_end, addr, stop;
 123   CORE_ADDR stack_size;
 124   int imm_size;
 125   unsigned char buf[4];
 126   int status, found_movm = 0;
 127   char *name;
 128
 129   /* Use the PC in the frame if it's provided to look up the
 130      start of this function.  */
 131   pc = (fi ? fi->pc : pc);
 132
 133   /* Find the start of this function.  */
 134   status = find_pc_partial_function (pc, &name, &func_addr, &func_end);
 135
 136   /* Do nothing if we couldn't find the start of this function or if we're
 137      stopped at the first instruction in the prologue.  */
 138   if (status == 0)
 139     return pc;
 140
 141   /* If we're in start, then give up.  */
 142   if (strcmp (name, "start") == 0)
 143     {
 144       fi->status = NO_MORE_FRAMES;
 145       return pc;
 146     }
 147
 148   /* At the start of a function our frame is in the stack pointer.  */
 149   if (fi)
 150     fi->status = MY_FRAME_IN_SP;
 151
 152   /* Get the next two bytes into buf, we need two because rets is a two
 153      byte insn and the first isn't enough to uniquely identify it.  */
 154   status = read_memory_nobpt (pc, buf, 2);
 155   if (status != 0)
 156     return pc;
 157
 158   /* If we're physically on an "rets" instruction, then our frame has
 159      already been deallocated.  Note this can also be true for retf
 160      and ret if they specify a size of zero.
 161
 162      In this case fi->frame is bogus, we need to fix it.  */
 163   if (fi && buf[0] == 0xf0 && buf[1] == 0xfc)
 164     {
 165       if (fi->next == NULL)
 166         fi->frame = read_sp ();
 167       return fi->pc;
 168     }
 169
 170   /* Similarly if we're stopped on the first insn of a prologue as our
 171      frame hasn't been allocated yet.  */
 172   if (fi && fi->pc == func_addr)
 173     {
 174       if (fi->next == NULL)
 175         fi->frame = read_sp ();
 176       return fi->pc;
 177     }
 178
 179   /* Figure out where to stop scanning.  */
 180   stop = fi ? fi->pc : func_end;
 181
 182   /* Don't walk off the end of the function.  */
 183   stop = stop > func_end ? func_end : stop;
 184
 185   /* Start scanning on the first instruction of this function.  */
 186   addr = func_addr;
 187
 188   /* Suck in two bytes.  */
 189   status = read_memory_nobpt (addr, buf, 2);
 190   if (status != 0)
 191     {
 192       if (fi && fi->next == NULL && fi->status & MY_FRAME_IN_SP)
 193         fi->frame = read_sp ();
 194       return addr;
 195     }
 196
 197   /* First see if this insn sets the stack pointer; if so, it's something
 198      we won't understand, so quit now.   */
 199   if (buf[0] == 0xf2 && (buf[1] & 0xf3) == 0xf0)
 200     {
 201       if (fi)
 202         fi->status = NO_MORE_FRAMES;
 203       return addr;
 204     }
 205
 206   /* Now look for movm [regs],sp, which saves the callee saved registers.
 207
 208      At this time we don't know if fi->frame is valid, so we only note
 209      that we encountered a movm instruction.  Later, we'll set the entries
 210      in fsr.regs as needed.  */
 211   if (buf[0] == 0xcf)
 212     {
 213       found_movm = 1;
 214       addr += 2;
 215
 216       /* Quit now if we're beyond the stop point.  */
 217       if (addr >= stop)
 218         {
 219           /* Fix fi->frame since it's bogus at this point.  */
 220           if (fi && fi->next == NULL)
 221             fi->frame = read_sp ();
 222
 223           /* Note if/where callee saved registers were saved.  */
 224           set_movm_offsets (fi, found_movm);
 225           return addr;
 226         }
 227
 228       /* Get the next two bytes so the prologue scan can continue.  */
 229       status = read_memory_nobpt (addr, buf, 2);
 230       if (status != 0)
 231         {
 232           /* Fix fi->frame since it's bogus at this point.  */
 233           if (fi && fi->next == NULL)
 234             fi->frame = read_sp ();
 235
 236           /* Note if/where callee saved registers were saved.  */
 237           set_movm_offsets (fi, found_movm);
 238           return addr;
 239         }
 240     }
 241
 242   /* Now see if we set up a frame pointer via "mov sp,a3" */
 243   if (buf[0] == 0x3f)
 244     {
 245       addr += 1;
 246
 247       /* The frame pointer is now valid.  */
 248       if (fi)
 249         {
 250           fi->status |= MY_FRAME_IN_FP;
 251           fi->status &= ~MY_FRAME_IN_SP;
 252         }
 253
 254       /* Quit now if we're beyond the stop point.  */
 255       if (addr >= stop)
 256         {
 257           /* Note if/where callee saved registers were saved.  */
 258           set_movm_offsets (fi, found_movm);
 259           return addr;
 260         }
 261
 262       /* Get two more bytes so scanning can continue.  */
 263       status = read_memory_nobpt (addr, buf, 2);
 264       if (status != 0)
 265         {
 266           /* Note if/where callee saved registers were saved.  */
 267           set_movm_offsets (fi, found_movm);
 268           return addr;
 269         }
 270     }
 271
 272   /* Next we should allocate the local frame.  No more prologue insns
 273      are found after allocating the local frame.
 274
 275      Search for add imm8,sp (0xf8feXX)
 276         or      add imm16,sp (0xfafeXXXX)
 277         or      add imm32,sp (0xfcfeXXXXXXXX).
 278
 279      If none of the above was found, then this prologue has no
 280      additional stack.  */
 281
 282   status = read_memory_nobpt (addr, buf, 2);
 283   if (status != 0)
 284     {
 285       /* Fix fi->frame if it's bogus at this point.  */
 286       if (fi && fi->next == NULL && (fi->status & MY_FRAME_IN_SP))
 287         fi->frame = read_sp ();
 288
 289       /* Note if/where callee saved registers were saved.  */
 290       set_movm_offsets (fi, found_movm);
 291       return addr;
 292     }
 293
 294   imm_size = 0;
 295   if (buf[0] == 0xf8 && buf[1] == 0xfe)
 296     imm_size = 1;
 297   else if (buf[0] == 0xfa && buf[1] == 0xfe)
 298     imm_size = 2;
 299   else if (buf[0] == 0xfc && buf[1] == 0xfe)
 300     imm_size = 4;
 301
 302   if (imm_size != 0)
 303     {
 304       /* Suck in imm_size more bytes, they'll hold the size of the
 305          current frame.  */
 306       status = read_memory_nobpt (addr + 2, buf, imm_size);
 307       if (status != 0)
 308         {
 309           /* Fix fi->frame if it's bogus at this point.  */
 310           if (fi && fi->next == NULL && (fi->status & MY_FRAME_IN_SP))
 311             fi->frame = read_sp ();
 312
 313           /* Note if/where callee saved registers were saved.  */
 314           set_movm_offsets (fi, found_movm);
 315           return addr;
 316         }
 317
 318       /* Note the size of the stack in the frame info structure.  */
 319       stack_size = extract_signed_integer (buf, imm_size);
 320       if (fi)
 321         fi->stack_size = stack_size;
 322
 323       /* We just consumed 2 + imm_size bytes.  */
 324       addr += 2 + imm_size;
 325
 326       /* No more prologue insns follow, so begin preparation to return.  */
 327       /* Fix fi->frame if it's bogus at this point.  */
 328       if (fi && fi->next == NULL && (fi->status & MY_FRAME_IN_SP))
 329         fi->frame = read_sp ();
 330
 331       /* Note if/where callee saved registers were saved.  */
 332       set_movm_offsets (fi, found_movm);
 333       return addr;
 334     }
 335
 336   /* We never found an insn which allocates local stack space, regardless
 337      this is the end of the prologue.  */
 338   /* Fix fi->frame if it's bogus at this point.  */
 339   if (fi && fi->next == NULL && (fi->status & MY_FRAME_IN_SP))
 340     fi->frame = read_sp ();
 341
 342   /* Note if/where callee saved registers were saved.  */
 343   set_movm_offsets (fi, found_movm);
 344   return addr;
 345 }
 346
 347 /* Function: frame_chain
 348    Figure out and return the caller's frame pointer given current
 349    frame_info struct.
 350
 351    We don't handle dummy frames yet but we would probably just return the
 352    stack pointer that was in use at the time the function call was made?  */
 353
 354 CORE_ADDR
 355 mn10300_frame_chain (fi)
 356      struct frame_info *fi;
 357 {
 358   struct frame_info dummy_frame;
 359
 360   /* Walk through the prologue to determine the stack size,
 361      location of saved registers, end of the prologue, etc.  */
 362   if (fi->status == 0)
 363     mn10300_analyze_prologue (fi, (CORE_ADDR)0);
 364
 365   /* Quit now if mn10300_analyze_prologue set NO_MORE_FRAMES.  */
 366   if (fi->status & NO_MORE_FRAMES)
 367     return 0;
 368
 369   /* Now that we've analyzed our prologue, determine the frame
 370      pointer for our caller.
 371
 372        If our caller has a frame pointer, then we need to
 373        find the entry value of $a3 to our function.
 374
 375          If fsr.regs[7] is nonzero, then it's at the memory
 376          location pointed to by fsr.regs[7].
 377
 378          Else it's still in $a3.
 379
 380        If our caller does not have a frame pointer, then his
 381        frame base is fi->frame + -caller's stack size.  */
 382
 383   /* The easiest way to get that info is to analyze our caller's frame.
 384
 385      So we set up a dummy frame and call mn10300_analyze_prologue to
 386      find stuff for us.  */
 387   dummy_frame.pc = FRAME_SAVED_PC (fi);
 388   dummy_frame.frame = fi->frame;
 389   memset (dummy_frame.fsr.regs, '\000', sizeof dummy_frame.fsr.regs);
 390   dummy_frame.status = 0;
 391   dummy_frame.stack_size = 0;
 392   mn10300_analyze_prologue (&dummy_frame);
 393
 394   if (dummy_frame.status & MY_FRAME_IN_FP)
 395     {
 396       /* Our caller has a frame pointer.  So find the frame in $a3 or
 397          in the stack.  */
 398       if (fi->fsr.regs[7])
 399         return (read_memory_integer (fi->fsr.regs[FP_REGNUM], REGISTER_SIZE));
 400       else
 401         return read_register (FP_REGNUM);
 402     }
 403   else
 404     {
 405       int adjust = 0;
 406
 407       adjust += (fi->fsr.regs[2] ? 4 : 0);
 408       adjust += (fi->fsr.regs[3] ? 4 : 0);
 409       adjust += (fi->fsr.regs[6] ? 4 : 0);
 410       adjust += (fi->fsr.regs[7] ? 4 : 0);
 411       /* start-sanitize-am33 */
 412       adjust += (fi->fsr.regs[E0_REGNUM+5] ? 4 : 0);
 413       adjust += (fi->fsr.regs[E0_REGNUM+4] ? 4 : 0);
 414       adjust += (fi->fsr.regs[E0_REGNUM+3] ? 4 : 0);
 415       adjust += (fi->fsr.regs[E0_REGNUM+2] ? 4 : 0);
 416       /* end-sanitize-am33 */
 417
 418       /* Our caller does not have a frame pointer.  So his frame starts
 419          at the base of our frame (fi->frame) + register save space. */
 420       return fi->frame + adjust;
 421     }
 422 }
 423
 424 /* Function: skip_prologue
 425    Return the address of the first inst past the prologue of the function.  */
 426
 427 CORE_ADDR
 428 mn10300_skip_prologue (pc)
 429      CORE_ADDR pc;
 430 {
 431   /* We used to check the debug symbols, but that can lose if
 432      we have a null prologue.  */
 433   return mn10300_analyze_prologue (NULL, pc);
 434 }
 435
 436
 437 /* Function: pop_frame
 438    This routine gets called when either the user uses the `return'
 439    command, or the call dummy breakpoint gets hit.  */
 440
 441 void
 442 mn10300_pop_frame (frame)
 443      struct frame_info *frame;
 444 {
 445   int regnum;
 446
 447   if (PC_IN_CALL_DUMMY(frame->pc, frame->frame, frame->frame))
 448     generic_pop_dummy_frame ();
 449   else
 450     {
 451       write_register (PC_REGNUM, FRAME_SAVED_PC (frame));
 452
 453       /* Restore any saved registers.  */
 454       for (regnum = 0; regnum < NUM_REGS; regnum++)
 455         if (frame->fsr.regs[regnum] != 0)
 456           {
 457             ULONGEST value;
 458
 459             value = read_memory_unsigned_integer (frame->fsr.regs[regnum],
 460                                                   REGISTER_RAW_SIZE (regnum));
 461             write_register (regnum, value);
 462           }
 463
 464       /* Actually cut back the stack.  */
 465       write_register (SP_REGNUM, FRAME_FP (frame));
 466
 467       /* Don't we need to set the PC?!?  XXX FIXME.  */
 468     }
 469
 470   /* Throw away any cached frame information.  */
 471   flush_cached_frames ();
 472 }
 473
 474 /* Function: push_arguments
 475    Setup arguments for a call to the target.  Arguments go in
 476    order on the stack.  */
 477
 478 CORE_ADDR
 479 mn10300_push_arguments (nargs, args, sp, struct_return, struct_addr)
 480      int nargs;
 481      value_ptr *args;
 482      CORE_ADDR sp;
 483      unsigned char struct_return;
 484      CORE_ADDR struct_addr;
 485 {
 486   int argnum = 0;
 487   int len = 0;
 488   int stack_offset = 0;
 489   int regsused = struct_return ? 1 : 0;
 490
 491   /* This should be a nop, but align the stack just in case something
 492      went wrong.  Stacks are four byte aligned on the mn10300.  */
 493   sp &= ~3;
 494
 495   /* Now make space on the stack for the args.
 496
 497      XXX This doesn't appear to handle pass-by-invisible reference
 498      arguments.  */
 499   for (argnum = 0; argnum < nargs; argnum++)
 500     {
 501       int arg_length = (TYPE_LENGTH (VALUE_TYPE (args[argnum])) + 3) & ~3;
 502
 503       while (regsused < 2 && arg_length > 0)
 504         {
 505           regsused++;
 506           arg_length -= 4;
 507         }
 508       len += arg_length;
 509     }
 510
 511   /* Allocate stack space.  */
 512   sp -= len;
 513
 514   regsused = struct_return ? 1 : 0;
 515   /* Push all arguments onto the stack. */
 516   for (argnum = 0; argnum < nargs; argnum++)
 517     {
 518       int len;
 519       char *val;
 520
 521       /* XXX Check this.  What about UNIONS?  */
 522       if (TYPE_CODE (VALUE_TYPE (*args)) == TYPE_CODE_STRUCT
 523           && TYPE_LENGTH (VALUE_TYPE (*args)) > 8)
 524         {
 525           /* XXX Wrong, we want a pointer to this argument.  */
 526           len = TYPE_LENGTH (VALUE_TYPE (*args));
 527           val = (char *)VALUE_CONTENTS (*args);
 528         }
 529       else
 530         {
 531           len = TYPE_LENGTH (VALUE_TYPE (*args));
 532           val = (char *)VALUE_CONTENTS (*args);
 533         }
 534
 535       while (regsused < 2 && len > 0)
 536         {
 537           write_register (regsused, extract_unsigned_integer (val, 4));
 538           val += 4;
 539           len -= 4;
 540           regsused++;
 541         }
 542
 543       while (len > 0)
 544         {
 545           write_memory (sp + stack_offset, val, 4);
 546           len -= 4;
 547           val += 4;
 548           stack_offset += 4;
 549         }
 550
 551       args++;
 552     }
 553
 554   /* Make space for the flushback area.  */
 555   sp -= 8;
 556   return sp;
 557 }
 558
 559 /* Function: push_return_address (pc)
 560    Set up the return address for the inferior function call.
 561    Needed for targets where we don't actually execute a JSR/BSR instruction */
 562
 563 CORE_ADDR
 564 mn10300_push_return_address (pc, sp)
 565      CORE_ADDR pc;
 566      CORE_ADDR sp;
 567 {
 568   unsigned char buf[4];
 569
 570   store_unsigned_integer (buf, 4, CALL_DUMMY_ADDRESS ());
 571   write_memory (sp - 4, buf, 4);
 572   return sp - 4;
 573 }
 574
 575 /* Function: store_struct_return (addr,sp)
 576    Store the structure value return address for an inferior function
 577    call.  */
 578
 579 CORE_ADDR
 580 mn10300_store_struct_return (addr, sp)
 581      CORE_ADDR addr;
 582      CORE_ADDR sp;
 583 {
 584   /* The structure return address is passed as the first argument.  */
 585   write_register (0, addr);
 586   return sp;
 587 }
 588
 589 /* Function: frame_saved_pc
 590    Find the caller of this frame.  We do this by seeing if RP_REGNUM
 591    is saved in the stack anywhere, otherwise we get it from the
 592    registers.  If the inner frame is a dummy frame, return its PC
 593    instead of RP, because that's where "caller" of the dummy-frame
 594    will be found.  */
 595
 596 CORE_ADDR
 597 mn10300_frame_saved_pc (fi)
 598      struct frame_info *fi;
 599 {
 600   int adjust = 0;
 601
 602   adjust += (fi->fsr.regs[2] ? 4 : 0);
 603   adjust += (fi->fsr.regs[3] ? 4 : 0);
 604   adjust += (fi->fsr.regs[6] ? 4 : 0);
 605   adjust += (fi->fsr.regs[7] ? 4 : 0);
 606   /* start-sanitize-am33 */
 607   adjust += (fi->fsr.regs[E0_REGNUM+5] ? 4 : 0);
 608   adjust += (fi->fsr.regs[E0_REGNUM+4] ? 4 : 0);
 609   adjust += (fi->fsr.regs[E0_REGNUM+3] ? 4 : 0);
 610   adjust += (fi->fsr.regs[E0_REGNUM+2] ? 4 : 0);
 611   /* end-sanitize-am33 */
 612
 613   return (read_memory_integer (fi->frame + adjust, REGISTER_SIZE));
 614 }
 615
 616 void
 617 get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
 618      char *raw_buffer;
 619      int *optimized;
 620      CORE_ADDR *addrp;
 621      struct frame_info *frame;
 622      int regnum;
 623      enum lval_type *lval;
 624 {
 625   generic_get_saved_register (raw_buffer, optimized, addrp,
 626                               frame, regnum, lval);
 627 }
 628
 629 /* Function: init_extra_frame_info
 630    Setup the frame's frame pointer, pc, and frame addresses for saved
 631    registers.  Most of the work is done in mn10300_analyze_prologue().
 632
 633    Note that when we are called for the last frame (currently active frame),
 634    that fi->pc and fi->frame will already be setup.  However, fi->frame will
 635    be valid only if this routine uses FP.  For previous frames, fi-frame will
 636    always be correct.  mn10300_analyze_prologue will fix fi->frame if
 637    it's not valid.
 638
 639    We can be called with the PC in the call dummy under two circumstances.
 640    First, during normal backtracing, second, while figuring out the frame
 641    pointer just prior to calling the target function (see run_stack_dummy).  */
 642
 643 void
 644 mn10300_init_extra_frame_info (fi)
 645      struct frame_info *fi;
 646 {
 647   if (fi->next)
 648     fi->pc = FRAME_SAVED_PC (fi->next);
 649
 650   memset (fi->fsr.regs, '\000', sizeof fi->fsr.regs);
 651   fi->status = 0;
 652   fi->stack_size = 0;
 653
 654   mn10300_analyze_prologue (fi, 0);
 655 }
 656
 657 /* This can be made more generic later.  */
 658 static void
 659 set_machine_hook (filename)
 660      char *filename;
 661 {
 662   int i;
 663
 664   if (bfd_get_mach (exec_bfd) == bfd_mach_mn10300
 665       || bfd_get_mach (exec_bfd) == 0)
 666     {
 667       for (i = 0; i < NUM_REGS; i++)
 668         reg_names[i] = mn10300_generic_register_names[i];
 669     }
 670
 671   /* start-sanitize-am33 */
 672   if (bfd_get_mach (exec_bfd) == bfd_mach_am33)
 673     {
 674       for (i = 0; i < NUM_REGS; i++)
 675         reg_names[i] = am33_register_names[i];
 676     }
 677   /* end-sanitize-am33 */
 678 }
 679
 680 void
 681 _initialize_mn10300_tdep ()
 682 {
 683 /*  printf("_initialize_mn10300_tdep\n"); */
 684
 685   tm_print_insn = print_insn_mn10300;
 686
 687   specify_exec_file_hook (set_machine_hook);
 688 }
 689