gdb/mcore-tdep.c

   1 /* Target-machine dependent code for Motorola MCore for GDB, the GNU debugger
   2    Copyright 1999, 2000, 2001, 2002, 2003 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 "symtab.h"
  23 #include "value.h"
  24 #include "gdbcmd.h"
  25 #include "regcache.h"
  26 #include "symfile.h"
  27 #include "gdbcore.h"
  28 #include "inferior.h"
  29 #include "arch-utils.h"
  30 #include "gdb_string.h"
  31
  32 /* Functions declared and used only in this file */
  33
  34 static CORE_ADDR mcore_analyze_prologue (struct frame_info *fi, CORE_ADDR pc, int skip_prologue);
  35
  36 static struct frame_info *analyze_dummy_frame (CORE_ADDR pc, CORE_ADDR frame);
  37
  38 static int get_insn (CORE_ADDR pc);
  39
  40 /* Functions exported from this file */
  41
  42 int mcore_use_struct_convention (int gcc_p, struct type *type);
  43
  44 void _initialize_mcore (void);
  45
  46 void mcore_init_extra_frame_info (int fromleaf, struct frame_info *fi);
  47
  48 CORE_ADDR mcore_frame_saved_pc (struct frame_info *fi);
  49
  50 CORE_ADDR mcore_find_callers_reg (struct frame_info *fi, int regnum);
  51
  52 CORE_ADDR mcore_frame_args_address (struct frame_info *fi);
  53
  54 CORE_ADDR mcore_frame_locals_address (struct frame_info *fi);
  55
  56 CORE_ADDR mcore_push_return_address (CORE_ADDR pc, CORE_ADDR sp);
  57
  58 CORE_ADDR mcore_push_arguments (int nargs, struct value ** args, CORE_ADDR sp,
  59                         int struct_return, CORE_ADDR struct_addr);
  60
  61 void mcore_pop_frame ();
  62
  63 CORE_ADDR mcore_skip_prologue (CORE_ADDR pc);
  64
  65 CORE_ADDR mcore_frame_chain (struct frame_info *fi);
  66
  67 const unsigned char *mcore_breakpoint_from_pc (CORE_ADDR * bp_addr, int *bp_size);
  68
  69 int mcore_use_struct_convention (int gcc_p, struct type *type);
  70
  71 void mcore_store_return_value (struct type *type, char *valbuf);
  72
  73 CORE_ADDR mcore_extract_struct_value_address (char *regbuf);
  74
  75 void mcore_extract_return_value (struct type *type, char *regbuf, char *valbuf);
  76
  77 #ifdef MCORE_DEBUG
  78 int mcore_debug = 0;
  79 #endif
  80
  81
  82 /* All registers are 4 bytes long.  */
  83 #define MCORE_REG_SIZE 4
  84 #define MCORE_NUM_REGS 65
  85
  86 /* Some useful register numbers.  */
  87 #define PR_REGNUM 15
  88 #define FIRST_ARGREG 2
  89 #define LAST_ARGREG 7
  90 #define RETVAL_REGNUM 2
  91
  92
  93 /* Additional info that we use for managing frames */
  94 struct frame_extra_info
  95   {
  96     /* A generic status word */
  97     int status;
  98
  99     /* Size of this frame */
 100     int framesize;
 101
 102     /* The register that is acting as a frame pointer, if
 103        it is being used.  This is undefined if status
 104        does not contain the flag MY_FRAME_IN_FP. */
 105     int fp_regnum;
 106   };
 107
 108 /* frame_extra_info status flags */
 109
 110 /* The base of the current frame is actually in the stack pointer.
 111    This happens when there is no frame pointer (MCore ABI does not
 112    require a frame pointer) or when we're stopped in the prologue or
 113    epilogue itself.  In these cases, mcore_analyze_prologue will need
 114    to update fi->frame before returning or analyzing the register
 115    save instructions. */
 116 #define MY_FRAME_IN_SP 0x1
 117
 118 /* The base of the current frame is in a frame pointer register.
 119    This register is noted in frame_extra_info->fp_regnum.
 120
 121    Note that the existence of an FP might also indicate that the
 122    function has called alloca. */
 123 #define MY_FRAME_IN_FP 0x2
 124
 125 /* This flag is set to indicate that this frame is the top-most
 126    frame. This tells frame chain not to bother trying to unwind
 127    beyond this frame. */
 128 #define NO_MORE_FRAMES 0x4
 129
 130 /* Instruction macros used for analyzing the prologue */
 131 #define IS_SUBI0(x)   (((x) & 0xfe0f) == 0x2400)        /* subi r0,oimm5    */
 132 #define IS_STM(x)     (((x) & 0xfff0) == 0x0070)        /* stm rf-r15,r0    */
 133 #define IS_STWx0(x)   (((x) & 0xf00f) == 0x9000)        /* stw rz,(r0,disp) */
 134 #define IS_STWxy(x)   (((x) & 0xf000) == 0x9000)        /* stw rx,(ry,disp) */
 135 #define IS_MOVx0(x)   (((x) & 0xfff0) == 0x1200)        /* mov rn,r0        */
 136 #define IS_LRW1(x)    (((x) & 0xff00) == 0x7100)        /* lrw r1,literal   */
 137 #define IS_MOVI1(x)   (((x) & 0xf80f) == 0x6001)        /* movi r1,imm7     */
 138 #define IS_BGENI1(x)  (((x) & 0xfe0f) == 0x3201)        /* bgeni r1,imm5    */
 139 #define IS_BMASKI1(x) (((x) & 0xfe0f) == 0x2C01)        /* bmaski r1,imm5   */
 140 #define IS_ADDI1(x)   (((x) & 0xfe0f) == 0x2001)        /* addi r1,oimm5    */
 141 #define IS_SUBI1(x)   (((x) & 0xfe0f) == 0x2401)        /* subi r1,oimm5    */
 142 #define IS_RSUBI1(x)  (((x) & 0xfe0f) == 0x2801)        /* rsubi r1,imm5    */
 143 #define IS_NOT1(x)    (((x) & 0xffff) == 0x01f1)        /* not r1           */
 144 #define IS_ROTLI1(x)  (((x) & 0xfe0f) == 0x3801)        /* rotli r1,imm5    */
 145 #define IS_BSETI1(x)  (((x) & 0xfe0f) == 0x3401)        /* bseti r1,imm5    */
 146 #define IS_BCLRI1(x)  (((x) & 0xfe0f) == 0x3001)        /* bclri r1,imm5    */
 147 #define IS_IXH1(x)    (((x) & 0xffff) == 0x1d11)        /* ixh r1,r1        */
 148 #define IS_IXW1(x)    (((x) & 0xffff) == 0x1511)        /* ixw r1,r1        */
 149 #define IS_SUB01(x)   (((x) & 0xffff) == 0x0510)        /* subu r0,r1       */
 150 #define IS_RTS(x)     (((x) & 0xffff) == 0x00cf)        /* jmp r15          */
 151
 152 #define IS_R1_ADJUSTER(x) \
 153     (IS_ADDI1(x) || IS_SUBI1(x) || IS_ROTLI1(x) || IS_BSETI1(x) \
 154      || IS_BCLRI1(x) || IS_RSUBI1(x) || IS_NOT1(x) \
 155      || IS_IXH1(x) || IS_IXW1(x))
 156 \f
 157
 158 #ifdef MCORE_DEBUG
 159 static void
 160 mcore_dump_insn (char *commnt, CORE_ADDR pc, int insn)
 161 {
 162   if (mcore_debug)
 163     {
 164       printf_filtered ("MCORE:  %s %08x %08x ",
 165                        commnt, (unsigned int) pc, (unsigned int) insn);
 166       TARGET_PRINT_INSN (pc, &tm_print_insn_info);
 167       printf_filtered ("\n");
 168     }
 169 }
 170 #define mcore_insn_debug(args) { if (mcore_debug) printf_filtered args; }
 171 #else /* !MCORE_DEBUG */
 172 #define mcore_dump_insn(a,b,c) {}
 173 #define mcore_insn_debug(args) {}
 174 #endif
 175
 176
 177 static struct type *
 178 mcore_register_virtual_type (int regnum)
 179 {
 180   if (regnum < 0 || regnum >= MCORE_NUM_REGS)
 181     internal_error (__FILE__, __LINE__,
 182                     "mcore_register_virtual_type: illegal register number %d",
 183                     regnum);
 184   else
 185     return builtin_type_int;
 186 }
 187
 188 static int
 189 mcore_register_byte (int regnum)
 190 {
 191   if (regnum < 0 || regnum >= MCORE_NUM_REGS)
 192     internal_error (__FILE__, __LINE__,
 193                     "mcore_register_byte: illegal register number %d",
 194                     regnum);
 195   else
 196     return (regnum * MCORE_REG_SIZE);
 197 }
 198
 199 static int
 200 mcore_register_size (int regnum)
 201 {
 202
 203   if (regnum < 0 || regnum >= MCORE_NUM_REGS)
 204     internal_error (__FILE__, __LINE__,
 205                     "mcore_register_size: illegal register number %d",
 206                     regnum);
 207   else
 208     return MCORE_REG_SIZE;
 209 }
 210
 211 /* The registers of the Motorola MCore processors */
 212
 213 static const char *
 214 mcore_register_name (int regnum)
 215 {
 216
 217   static char *register_names[] = {
 218     "r0",   "r1",  "r2",    "r3",   "r4",   "r5",   "r6",   "r7",
 219     "r8",   "r9",  "r10",   "r11",  "r12",  "r13",  "r14",  "r15",
 220     "ar0",  "ar1", "ar2",   "ar3",  "ar4",  "ar5",  "ar6",  "ar7",
 221     "ar8",  "ar9", "ar10", "ar11",  "ar12", "ar13", "ar14", "ar15",
 222     "psr",  "vbr", "epsr",  "fpsr", "epc",  "fpc",  "ss0",  "ss1",
 223     "ss2",  "ss3", "ss4",   "gcr",  "gsr",  "cr13", "cr14", "cr15",
 224     "cr16", "cr17", "cr18", "cr19", "cr20", "cr21", "cr22", "cr23",
 225     "cr24", "cr25", "cr26", "cr27", "cr28", "cr29", "cr30", "cr31",
 226     "pc"
 227   };
 228
 229   if (regnum < 0 ||
 230       regnum >= sizeof (register_names) / sizeof (register_names[0]))
 231     internal_error (__FILE__, __LINE__,
 232                     "mcore_register_name: illegal register number %d",
 233                     regnum);
 234   else
 235     return register_names[regnum];
 236 }
 237
 238 /* Given the address at which to insert a breakpoint (BP_ADDR),
 239    what will that breakpoint be?
 240
 241    For MCore, we have a breakpoint instruction. Since all MCore
 242    instructions are 16 bits, this is all we need, regardless of
 243    address. bpkt = 0x0000 */
 244
 245 const unsigned char *
 246 mcore_breakpoint_from_pc (CORE_ADDR * bp_addr, int *bp_size)
 247 {
 248   static char breakpoint[] =
 249   {0x00, 0x00};
 250   *bp_size = 2;
 251   return breakpoint;
 252 }
 253
 254 static CORE_ADDR
 255 mcore_saved_pc_after_call (struct frame_info *frame)
 256 {
 257   return read_register (PR_REGNUM);
 258 }
 259
 260 /* This is currently handled by init_extra_frame_info.  */
 261 static void
 262 mcore_frame_init_saved_regs (struct frame_info *frame)
 263 {
 264
 265 }
 266
 267 /* This is currently handled by mcore_push_arguments  */
 268 static void
 269 mcore_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
 270 {
 271
 272 }
 273
 274 static int
 275 mcore_reg_struct_has_addr (int gcc_p, struct type *type)
 276 {
 277   return 0;
 278 }
 279
 280
 281 /* Helper function for several routines below.  This funtion simply
 282    sets up a fake, aka dummy, frame (not a _call_ dummy frame) that
 283    we can analyze with mcore_analyze_prologue. */
 284
 285 static struct frame_info *
 286 analyze_dummy_frame (CORE_ADDR pc, CORE_ADDR frame)
 287 {
 288   static struct frame_info *dummy = NULL;
 289
 290   if (dummy == NULL)
 291     {
 292       dummy = deprecated_frame_xmalloc ();
 293       dummy->saved_regs = (CORE_ADDR *) xmalloc (SIZEOF_FRAME_SAVED_REGS);
 294       dummy->extra_info =
 295         (struct frame_extra_info *) xmalloc (sizeof (struct frame_extra_info));
 296     }
 297
 298   dummy->next = NULL;
 299   dummy->prev = NULL;
 300   deprecated_update_frame_pc_hack (dummy, pc);
 301   deprecated_update_frame_base_hack (dummy, frame);
 302   dummy->extra_info->status = 0;
 303   dummy->extra_info->framesize = 0;
 304   memset (get_frame_saved_regs (dummy), '\000', SIZEOF_FRAME_SAVED_REGS);
 305   mcore_analyze_prologue (dummy, 0, 0);
 306   return dummy;
 307 }
 308
 309 /* Function prologues on the Motorola MCore processors consist of:
 310
 311    - adjustments to the stack pointer (r1 used as scratch register)
 312    - store word/multiples that use r0 as the base address
 313    - making a copy of r0 into another register (a "frame" pointer)
 314
 315    Note that the MCore really doesn't have a real frame pointer.
 316    Instead, the compiler may copy the SP into a register (usually
 317    r8) to act as an arg pointer.  For our target-dependent purposes,
 318    the frame info's "frame" member will be the beginning of the
 319    frame. The SP could, in fact, point below this.
 320
 321    The prologue ends when an instruction fails to meet either of
 322    the first two criteria or when an FP is made.  We make a special
 323    exception for gcc. When compiling unoptimized code, gcc will
 324    setup stack slots. We need to make sure that we skip the filling
 325    of these stack slots as much as possible. This is only done
 326    when SKIP_PROLOGUE is set, so that it does not mess up
 327    backtraces. */
 328
 329 /* Analyze the prologue of frame FI to determine where registers are saved,
 330    the end of the prologue, etc. Return the address of the first line
 331    of "real" code (i.e., the end of the prologue). */
 332
 333 static CORE_ADDR
 334 mcore_analyze_prologue (struct frame_info *fi, CORE_ADDR pc, int skip_prologue)
 335 {
 336   CORE_ADDR func_addr, func_end, addr, stop;
 337   CORE_ADDR stack_size;
 338   int insn, rn;
 339   int status;
 340   int fp_regnum = 0; /* dummy, valid when (flags & MY_FRAME_IN_FP) */
 341   int flags;
 342   int framesize;
 343   int register_offsets[NUM_REGS];
 344   char *name;
 345
 346   /* If provided, use the PC in the frame to look up the
 347      start of this function. */
 348   pc = (fi == NULL ? pc : get_frame_pc (fi));
 349
 350   /* Find the start of this function. */
 351   status = find_pc_partial_function (pc, &name, &func_addr, &func_end);
 352
 353   /* If the start of this function could not be found or if the debbuger
 354      is stopped at the first instruction of the prologue, do nothing. */
 355   if (status == 0)
 356     return pc;
 357
 358   /* If the debugger is entry function, give up. */
 359   if (func_addr == entry_point_address ())
 360     {
 361       if (fi != NULL)
 362         fi->extra_info->status |= NO_MORE_FRAMES;
 363       return pc;
 364     }
 365
 366   /* At the start of a function, our frame is in the stack pointer. */
 367   flags = MY_FRAME_IN_SP;
 368
 369   /* Start decoding the prologue.  We start by checking two special cases:
 370
 371      1. We're about to return
 372      2. We're at the first insn of the prologue.
 373
 374      If we're about to return, our frame has already been deallocated.
 375      If we are stopped at the first instruction of a prologue,
 376      then our frame has not yet been set up. */
 377
 378   /* Get the first insn from memory (all MCore instructions are 16 bits) */
 379   mcore_insn_debug (("MCORE: starting prologue decoding\n"));
 380   insn = get_insn (pc);
 381   mcore_dump_insn ("got 1: ", pc, insn);
 382
 383   /* Check for return. */
 384   if (fi != NULL && IS_RTS (insn))
 385     {
 386       mcore_insn_debug (("MCORE: got jmp r15"));
 387       if (fi->next == NULL)
 388         deprecated_update_frame_base_hack (fi, read_sp ());
 389       return get_frame_pc (fi);
 390     }
 391
 392   /* Check for first insn of prologue */
 393   if (fi != NULL && get_frame_pc (fi) == func_addr)
 394     {
 395       if (fi->next == NULL)
 396         deprecated_update_frame_base_hack (fi, read_sp ());
 397       return get_frame_pc (fi);
 398     }
 399
 400   /* Figure out where to stop scanning */
 401   stop = (fi ? get_frame_pc (fi) : func_end);
 402
 403   /* Don't walk off the end of the function */
 404   stop = (stop > func_end ? func_end : stop);
 405
 406   /* REGISTER_OFFSETS will contain offsets, from the top of the frame
 407      (NOT the frame pointer), for the various saved registers or -1
 408      if the register is not saved. */
 409   for (rn = 0; rn < NUM_REGS; rn++)
 410     register_offsets[rn] = -1;
 411
 412   /* Analyze the prologue. Things we determine from analyzing the
 413      prologue include:
 414      * the size of the frame
 415      * where saved registers are located (and which are saved)
 416      * FP used? */
 417   mcore_insn_debug (("MCORE: Scanning prologue: func_addr=0x%x, stop=0x%x\n",
 418                      (unsigned int) func_addr, (unsigned int) stop));
 419
 420   framesize = 0;
 421   for (addr = func_addr; addr < stop; addr += 2)
 422     {
 423       /* Get next insn */
 424       insn = get_insn (addr);
 425       mcore_dump_insn ("got 2: ", addr, insn);
 426
 427       if (IS_SUBI0 (insn))
 428         {
 429           int offset = 1 + ((insn >> 4) & 0x1f);
 430           mcore_insn_debug (("MCORE: got subi r0,%d; continuing\n", offset));
 431           framesize += offset;
 432           continue;
 433         }
 434       else if (IS_STM (insn))
 435         {
 436           /* Spill register(s) */
 437           int offset;
 438           int start_register;
 439
 440           /* BIG WARNING! The MCore ABI does not restrict functions
 441              to taking only one stack allocation. Therefore, when
 442              we save a register, we record the offset of where it was
 443              saved relative to the current framesize. This will
 444              then give an offset from the SP upon entry to our
 445              function. Remember, framesize is NOT constant until
 446              we're done scanning the prologue. */
 447           start_register = (insn & 0xf);
 448           mcore_insn_debug (("MCORE: got stm r%d-r15,(r0)\n", start_register));
 449
 450           for (rn = start_register, offset = 0; rn <= 15; rn++, offset += 4)
 451             {
 452               register_offsets[rn] = framesize - offset;
 453               mcore_insn_debug (("MCORE: r%d saved at 0x%x (offset %d)\n", rn,
 454                                  register_offsets[rn], offset));
 455             }
 456           mcore_insn_debug (("MCORE: continuing\n"));
 457           continue;
 458         }
 459       else if (IS_STWx0 (insn))
 460         {
 461           /* Spill register: see note for IS_STM above. */
 462           int imm;
 463
 464           rn = (insn >> 8) & 0xf;
 465           imm = (insn >> 4) & 0xf;
 466           register_offsets[rn] = framesize - (imm << 2);
 467           mcore_insn_debug (("MCORE: r%d saved at offset 0x%x\n", rn, register_offsets[rn]));
 468           mcore_insn_debug (("MCORE: continuing\n"));
 469           continue;
 470         }
 471       else if (IS_MOVx0 (insn))
 472         {
 473           /* We have a frame pointer, so this prologue is over.  Note
 474              the register which is acting as the frame pointer. */
 475           flags |= MY_FRAME_IN_FP;
 476           flags &= ~MY_FRAME_IN_SP;
 477           fp_regnum = insn & 0xf;
 478           mcore_insn_debug (("MCORE: Found a frame pointer: r%d\n", fp_regnum));
 479
 480           /* If we found an FP, we're at the end of the prologue. */
 481           mcore_insn_debug (("MCORE: end of prologue\n"));
 482           if (skip_prologue)
 483             continue;
 484
 485           /* If we're decoding prologue, stop here. */
 486           addr += 2;
 487           break;
 488         }
 489       else if (IS_STWxy (insn) && (flags & MY_FRAME_IN_FP) && ((insn & 0xf) == fp_regnum))
 490         {
 491           /* Special case. Skip over stack slot allocs, too. */
 492           mcore_insn_debug (("MCORE: push arg onto stack.\n"));
 493           continue;
 494         }
 495       else if (IS_LRW1 (insn) || IS_MOVI1 (insn)
 496                || IS_BGENI1 (insn) || IS_BMASKI1 (insn))
 497         {
 498           int adjust = 0;
 499           int offset = 0;
 500           int insn2;
 501
 502           mcore_insn_debug (("MCORE: looking at large frame\n"));
 503           if (IS_LRW1 (insn))
 504             {
 505               adjust =
 506                 read_memory_integer ((addr + 2 + ((insn & 0xff) << 2)) & 0xfffffffc, 4);
 507             }
 508           else if (IS_MOVI1 (insn))
 509             adjust = (insn >> 4) & 0x7f;
 510           else if (IS_BGENI1 (insn))
 511             adjust = 1 << ((insn >> 4) & 0x1f);
 512           else                  /* IS_BMASKI (insn) */
 513             adjust = (1 << (adjust >> 4) & 0x1f) - 1;
 514
 515           mcore_insn_debug (("MCORE: base framesize=0x%x\n", adjust));
 516
 517           /* May have zero or more insns which modify r1 */
 518           mcore_insn_debug (("MCORE: looking for r1 adjusters...\n"));
 519           offset = 2;
 520           insn2 = get_insn (addr + offset);
 521           while (IS_R1_ADJUSTER (insn2))
 522             {
 523               int imm;
 524
 525               imm = (insn2 >> 4) & 0x1f;
 526               mcore_dump_insn ("got 3: ", addr + offset, insn);
 527               if (IS_ADDI1 (insn2))
 528                 {
 529                   adjust += (imm + 1);
 530                   mcore_insn_debug (("MCORE: addi r1,%d\n", imm + 1));
 531                 }
 532               else if (IS_SUBI1 (insn2))
 533                 {
 534                   adjust -= (imm + 1);
 535                   mcore_insn_debug (("MCORE: subi r1,%d\n", imm + 1));
 536                 }
 537               else if (IS_RSUBI1 (insn2))
 538                 {
 539                   adjust = imm - adjust;
 540                   mcore_insn_debug (("MCORE: rsubi r1,%d\n", imm + 1));
 541                 }
 542               else if (IS_NOT1 (insn2))
 543                 {
 544                   adjust = ~adjust;
 545                   mcore_insn_debug (("MCORE: not r1\n"));
 546                 }
 547               else if (IS_ROTLI1 (insn2))
 548                 {
 549                   adjust <<= imm;
 550                   mcore_insn_debug (("MCORE: rotli r1,%d\n", imm + 1));
 551                 }
 552               else if (IS_BSETI1 (insn2))
 553                 {
 554                   adjust |= (1 << imm);
 555                   mcore_insn_debug (("MCORE: bseti r1,%d\n", imm));
 556                 }
 557               else if (IS_BCLRI1 (insn2))
 558                 {
 559                   adjust &= ~(1 << imm);
 560                   mcore_insn_debug (("MCORE: bclri r1,%d\n", imm));
 561                 }
 562               else if (IS_IXH1 (insn2))
 563                 {
 564                   adjust *= 3;
 565                   mcore_insn_debug (("MCORE: ix.h r1,r1\n"));
 566                 }
 567               else if (IS_IXW1 (insn2))
 568                 {
 569                   adjust *= 5;
 570                   mcore_insn_debug (("MCORE: ix.w r1,r1\n"));
 571                 }
 572
 573               offset += 2;
 574               insn2 = get_insn (addr + offset);
 575             };
 576
 577           mcore_insn_debug (("MCORE: done looking for r1 adjusters\n"));
 578
 579           /* If the next insn adjusts the stack pointer, we keep everything;
 580              if not, we scrap it and we've found the end of the prologue. */
 581           if (IS_SUB01 (insn2))
 582             {
 583               addr += offset;
 584               framesize += adjust;
 585               mcore_insn_debug (("MCORE: found stack adjustment of 0x%x bytes.\n", adjust));
 586               mcore_insn_debug (("MCORE: skipping to new address 0x%x\n", addr));
 587               mcore_insn_debug (("MCORE: continuing\n"));
 588               continue;
 589             }
 590
 591           /* None of these instructions are prologue, so don't touch
 592              anything. */
 593           mcore_insn_debug (("MCORE: no subu r1,r0, NOT altering framesize.\n"));
 594           break;
 595         }
 596
 597       /* This is not a prologue insn, so stop here. */
 598       mcore_insn_debug (("MCORE: insn is not a prologue insn -- ending scan\n"));
 599       break;
 600     }
 601
 602   mcore_insn_debug (("MCORE: done analyzing prologue\n"));
 603   mcore_insn_debug (("MCORE: prologue end = 0x%x\n", addr));
 604
 605   /* Save everything we have learned about this frame into FI. */
 606   if (fi != NULL)
 607     {
 608       fi->extra_info->framesize = framesize;
 609       fi->extra_info->fp_regnum = fp_regnum;
 610       fi->extra_info->status = flags;
 611
 612       /* Fix the frame pointer. When gcc uses r8 as a frame pointer,
 613          it is really an arg ptr. We adjust fi->frame to be a "real"
 614          frame pointer. */
 615       if (fi->next == NULL)
 616         {
 617           if (fi->extra_info->status & MY_FRAME_IN_SP)
 618             deprecated_update_frame_base_hack (fi, read_sp () + framesize);
 619           else
 620             deprecated_update_frame_base_hack (fi, read_register (fp_regnum) + framesize);
 621         }
 622
 623       /* Note where saved registers are stored. The offsets in REGISTER_OFFSETS
 624          are computed relative to the top of the frame. */
 625       for (rn = 0; rn < NUM_REGS; rn++)
 626         {
 627           if (register_offsets[rn] >= 0)
 628             {
 629               get_frame_saved_regs (fi)[rn] = fi->frame - register_offsets[rn];
 630               mcore_insn_debug (("Saved register %s stored at 0x%08x, value=0x%08x\n",
 631                                mcore_register_names[rn], fi->saved_regs[rn],
 632                               read_memory_integer (fi->saved_regs[rn], 4)));
 633             }
 634         }
 635     }
 636
 637   /* Return addr of first non-prologue insn. */
 638   return addr;
 639 }
 640
 641 /* Given a GDB frame, determine the address of the calling function's
 642    frame.  This will be used to create a new GDB frame struct, and
 643    then INIT_EXTRA_FRAME_INFO and DEPRECATED_INIT_FRAME_PC will be
 644    called for the new frame. */
 645
 646 CORE_ADDR
 647 mcore_frame_chain (struct frame_info * fi)
 648 {
 649   struct frame_info *dummy;
 650   CORE_ADDR callers_addr;
 651
 652   /* Analyze the prologue of this function. */
 653   if (fi->extra_info->status == 0)
 654     mcore_analyze_prologue (fi, 0, 0);
 655
 656   /* If mcore_analyze_prologue set NO_MORE_FRAMES, quit now. */
 657   if (fi->extra_info->status & NO_MORE_FRAMES)
 658     return 0;
 659
 660   /* Now that we've analyzed our prologue, we can start to ask
 661      for information about our caller. The easiest way to do
 662      this is to analyze our caller's prologue.
 663
 664      If our caller has a frame pointer, then we need to find
 665      the value of that register upon entry to our frame.
 666      This value is either in fi->saved_regs[rn] if it's saved,
 667      or it's still in a register.
 668
 669      If our caller does not have a frame pointer, then his frame base
 670      is <our base> + -<caller's frame size>. */
 671   dummy = analyze_dummy_frame (FRAME_SAVED_PC (fi), fi->frame);
 672
 673   if (dummy->extra_info->status & MY_FRAME_IN_FP)
 674     {
 675       int fp = dummy->extra_info->fp_regnum;
 676
 677       /* Our caller has a frame pointer. */
 678       if (get_frame_saved_regs (fi)[fp] != 0)
 679         {
 680           /* The "FP" was saved on the stack.  Don't forget to adjust
 681              the "FP" with the framesize to get a real FP. */
 682           callers_addr = read_memory_integer (get_frame_saved_regs (fi)[fp], REGISTER_SIZE)
 683             + dummy->extra_info->framesize;
 684         }
 685       else
 686         {
 687           /* It's still in the register.  Don't forget to adjust
 688              the "FP" with the framesize to get a real FP. */
 689           callers_addr = read_register (fp) + dummy->extra_info->framesize;
 690         }
 691     }
 692   else
 693     {
 694       /* Our caller does not have a frame pointer. */
 695       callers_addr = fi->frame + dummy->extra_info->framesize;
 696     }
 697
 698   return callers_addr;
 699 }
 700
 701 /* Skip the prologue of the function at PC. */
 702
 703 CORE_ADDR
 704 mcore_skip_prologue (CORE_ADDR pc)
 705 {
 706   CORE_ADDR func_addr, func_end;
 707   struct symtab_and_line sal;
 708
 709   /* If we have line debugging information, then the end of the
 710      prologue should be the first assembly instruction of the first
 711      source line */
 712   if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
 713     {
 714       sal = find_pc_line (func_addr, 0);
 715       if (sal.end && sal.end < func_end)
 716         return sal.end;
 717     }
 718
 719   return mcore_analyze_prologue (NULL, pc, 1);
 720 }
 721
 722 /* Return the address at which function arguments are offset. */
 723 CORE_ADDR
 724 mcore_frame_args_address (struct frame_info * fi)
 725 {
 726   return fi->frame - fi->extra_info->framesize;
 727 }
 728
 729 CORE_ADDR
 730 mcore_frame_locals_address (struct frame_info * fi)
 731 {
 732   return fi->frame - fi->extra_info->framesize;
 733 }
 734
 735 /* Return the frame pointer in use at address PC. */
 736
 737 void
 738 mcore_virtual_frame_pointer (CORE_ADDR pc, int *reg, LONGEST *offset)
 739 {
 740   struct frame_info *dummy = analyze_dummy_frame (pc, 0);
 741   if (dummy->extra_info->status & MY_FRAME_IN_SP)
 742     {
 743       *reg = SP_REGNUM;
 744       *offset = 0;
 745     }
 746   else
 747     {
 748       *reg = dummy->extra_info->fp_regnum;
 749       *offset = 0;
 750     }
 751 }
 752
 753 /* Find the value of register REGNUM in frame FI. */
 754
 755 CORE_ADDR
 756 mcore_find_callers_reg (struct frame_info *fi, int regnum)
 757 {
 758   for (; fi != NULL; fi = fi->next)
 759     {
 760       if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), fi->frame, fi->frame))
 761         return deprecated_read_register_dummy (get_frame_pc (fi), fi->frame, regnum);
 762       else if (get_frame_saved_regs (fi)[regnum] != 0)
 763         return read_memory_integer (get_frame_saved_regs (fi)[regnum],
 764                                     REGISTER_SIZE);
 765     }
 766
 767   return read_register (regnum);
 768 }
 769
 770 /* Find the saved pc in frame FI. */
 771
 772 CORE_ADDR
 773 mcore_frame_saved_pc (struct frame_info * fi)
 774 {
 775
 776   if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), fi->frame, fi->frame))
 777     return deprecated_read_register_dummy (get_frame_pc (fi), fi->frame, PC_REGNUM);
 778   else
 779     return mcore_find_callers_reg (fi, PR_REGNUM);
 780 }
 781 \f
 782 /* INFERIOR FUNCTION CALLS */
 783
 784 /* This routine gets called when either the user uses the "return"
 785    command, or the call dummy breakpoint gets hit. */
 786
 787 void
 788 mcore_pop_frame (void)
 789 {
 790   int rn;
 791   struct frame_info *fi = get_current_frame ();
 792
 793   if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), fi->frame, fi->frame))
 794     generic_pop_dummy_frame ();
 795   else
 796     {
 797       /* Write out the PC we saved. */
 798       write_register (PC_REGNUM, FRAME_SAVED_PC (fi));
 799
 800       /* Restore any saved registers. */
 801       for (rn = 0; rn < NUM_REGS; rn++)
 802         {
 803           if (get_frame_saved_regs (fi)[rn] != 0)
 804             {
 805               ULONGEST value;
 806
 807               value = read_memory_unsigned_integer (get_frame_saved_regs (fi)[rn],
 808                                                     REGISTER_SIZE);
 809               write_register (rn, value);
 810             }
 811         }
 812
 813       /* Actually cut back the stack. */
 814       write_register (SP_REGNUM, get_frame_base (fi));
 815     }
 816
 817   /* Finally, throw away any cached frame information. */
 818   flush_cached_frames ();
 819 }
 820
 821 /* Setup arguments and PR for a call to the target. First six arguments
 822    go in FIRST_ARGREG -> LAST_ARGREG, subsequent args go on to the stack.
 823
 824    * Types with lengths greater than REGISTER_SIZE may not be split
 825    between registers and the stack, and they must start in an even-numbered
 826    register. Subsequent args will go onto the stack.
 827
 828    * Structs may be split between registers and stack, left-aligned.
 829
 830    * If the function returns a struct which will not fit into registers (it's
 831    more than eight bytes), we must allocate for that, too. Gdb will tell
 832    us where this buffer is (STRUCT_ADDR), and we simply place it into
 833    FIRST_ARGREG, since the MCORE treats struct returns (of less than eight
 834    bytes) as hidden first arguments. */
 835
 836 CORE_ADDR
 837 mcore_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
 838                       int struct_return, CORE_ADDR struct_addr)
 839 {
 840   int argreg;
 841   int argnum;
 842   struct stack_arg
 843     {
 844       int len;
 845       char *val;
 846     }
 847    *stack_args;
 848   int nstack_args = 0;
 849
 850   stack_args = (struct stack_arg *) alloca (nargs * sizeof (struct stack_arg));
 851
 852   argreg = FIRST_ARGREG;
 853
 854   /* Align the stack. This is mostly a nop, but not always. It will be needed
 855      if we call a function which has argument overflow. */
 856   sp &= ~3;
 857
 858   /* If this function returns a struct which does not fit in the
 859      return registers, we must pass a buffer to the function
 860      which it can use to save the return value. */
 861   if (struct_return)
 862     write_register (argreg++, struct_addr);
 863
 864   /* FIXME: what about unions? */
 865   for (argnum = 0; argnum < nargs; argnum++)
 866     {
 867       char *val = (char *) VALUE_CONTENTS (args[argnum]);
 868       int len = TYPE_LENGTH (VALUE_TYPE (args[argnum]));
 869       struct type *type = VALUE_TYPE (args[argnum]);
 870       int olen;
 871
 872       mcore_insn_debug (("MCORE PUSH: argreg=%d; len=%d; %s\n",
 873                          argreg, len, TYPE_CODE (type) == TYPE_CODE_STRUCT ? "struct" : "not struct"));
 874       /* Arguments larger than a register must start in an even
 875          numbered register. */
 876       olen = len;
 877
 878       if (TYPE_CODE (type) != TYPE_CODE_STRUCT && len > REGISTER_SIZE && argreg % 2)
 879         {
 880           mcore_insn_debug (("MCORE PUSH: %d > REGISTER_SIZE: and %s is not even\n",
 881                              len, mcore_register_names[argreg]));
 882           argreg++;
 883         }
 884
 885       if ((argreg <= LAST_ARGREG && len <= (LAST_ARGREG - argreg + 1) * REGISTER_SIZE)
 886           || (TYPE_CODE (type) == TYPE_CODE_STRUCT))
 887         {
 888           /* Something that will fit entirely into registers (or a struct
 889              which may be split between registers and stack). */
 890           mcore_insn_debug (("MCORE PUSH: arg %d going into regs\n", argnum));
 891
 892           if (TYPE_CODE (type) == TYPE_CODE_STRUCT && olen < REGISTER_SIZE)
 893             {
 894               /* Small structs must be right aligned within the register,
 895                  the most significant bits are undefined. */
 896               write_register (argreg, extract_unsigned_integer (val, len));
 897               argreg++;
 898               len = 0;
 899             }
 900
 901           while (len > 0 && argreg <= LAST_ARGREG)
 902             {
 903               write_register (argreg, extract_unsigned_integer (val, REGISTER_SIZE));
 904               argreg++;
 905               val += REGISTER_SIZE;
 906               len -= REGISTER_SIZE;
 907             }
 908
 909           /* Any remainder for the stack is noted below... */
 910         }
 911       else if (TYPE_CODE (VALUE_TYPE (args[argnum])) != TYPE_CODE_STRUCT
 912                && len > REGISTER_SIZE)
 913         {
 914           /* All subsequent args go onto the stack. */
 915           mcore_insn_debug (("MCORE PUSH: does not fit into regs, going onto stack\n"));
 916           argnum = LAST_ARGREG + 1;
 917         }
 918
 919       if (len > 0)
 920         {
 921           /* Note that this must be saved onto the stack */
 922           mcore_insn_debug (("MCORE PUSH: adding arg %d to stack\n", argnum));
 923           stack_args[nstack_args].val = val;
 924           stack_args[nstack_args].len = len;
 925           nstack_args++;
 926         }
 927
 928     }
 929
 930   /* We're done with registers and stack allocation. Now do the actual
 931      stack pushes. */
 932   while (nstack_args--)
 933     {
 934       sp -= stack_args[nstack_args].len;
 935       write_memory (sp, stack_args[nstack_args].val, stack_args[nstack_args].len);
 936     }
 937
 938   /* Return adjusted stack pointer.  */
 939   return sp;
 940 }
 941
 942 /* Store the return address for the call dummy. For MCore, we've
 943    opted to use generic call dummies, so we simply store the
 944    CALL_DUMMY_ADDRESS into the PR register (r15). */
 945
 946 CORE_ADDR
 947 mcore_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
 948 {
 949   write_register (PR_REGNUM, CALL_DUMMY_ADDRESS ());
 950   return sp;
 951 }
 952
 953 /* Setting/getting return values from functions.
 954
 955    The Motorola MCore processors use r2/r3 to return anything
 956    not larger than 32 bits. Everything else goes into a caller-
 957    supplied buffer, which is passed in via a hidden first
 958    argument.
 959
 960    For gdb, this leaves us two routes, based on what
 961    USE_STRUCT_CONVENTION (mcore_use_struct_convention) returns.
 962    If this macro returns 1, gdb will call STORE_STRUCT_RETURN and
 963    EXTRACT_STRUCT_VALUE_ADDRESS.
 964
 965    If USE_STRUCT_CONVENTION retruns 0, then gdb uses STORE_RETURN_VALUE
 966    and EXTRACT_RETURN_VALUE to store/fetch the functions return value. */
 967
 968 /* Should we use EXTRACT_STRUCT_VALUE_ADDRESS instead of
 969    EXTRACT_RETURN_VALUE?  GCC_P is true if compiled with gcc
 970    and TYPE is the type (which is known to be struct, union or array). */
 971
 972 int
 973 mcore_use_struct_convention (int gcc_p, struct type *type)
 974 {
 975   return (TYPE_LENGTH (type) > 8);
 976 }
 977
 978 /* Where is the return value saved? For MCore, a pointer to
 979    this buffer was passed as a hidden first argument, so
 980    just return that address. */
 981
 982 CORE_ADDR
 983 mcore_extract_struct_value_address (char *regbuf)
 984 {
 985   return extract_address (regbuf + REGISTER_BYTE (FIRST_ARGREG), REGISTER_SIZE);
 986 }
 987
 988 /* Given a function which returns a value of type TYPE, extract the
 989    the function's return value and place the result into VALBUF.
 990    REGBUF is the register contents of the target. */
 991
 992 void
 993 mcore_extract_return_value (struct type *type, char *regbuf, char *valbuf)
 994 {
 995   /* Copy the return value (starting) in RETVAL_REGNUM to VALBUF. */
 996   /* Only getting the first byte! if len = 1, we need the last byte of
 997      the register, not the first. */
 998   memcpy (valbuf, regbuf + REGISTER_BYTE (RETVAL_REGNUM) +
 999   (TYPE_LENGTH (type) < 4 ? 4 - TYPE_LENGTH (type) : 0), TYPE_LENGTH (type));
1000 }
1001
1002 /* Store the return value in VALBUF (of type TYPE) where the caller
1003    expects to see it.
1004
1005    Values less than 32 bits are stored in r2, right justified and
1006    sign or zero extended.
1007
1008    Values between 32 and 64 bits are stored in r2 (most
1009    significant word) and r3 (least significant word, left justified).
1010    Note that this includes structures of less than eight bytes, too. */
1011
1012 void
1013 mcore_store_return_value (struct type *type, char *valbuf)
1014 {
1015   int value_size;
1016   int return_size;
1017   int offset;
1018   char *zeros;
1019
1020   value_size = TYPE_LENGTH (type);
1021
1022   /* Return value fits into registers. */
1023   return_size = (value_size + REGISTER_SIZE - 1) & ~(REGISTER_SIZE - 1);
1024   offset = REGISTER_BYTE (RETVAL_REGNUM) + (return_size - value_size);
1025   zeros = alloca (return_size);
1026   memset (zeros, 0, return_size);
1027
1028   deprecated_write_register_bytes (REGISTER_BYTE (RETVAL_REGNUM), zeros,
1029                                    return_size);
1030   deprecated_write_register_bytes (offset, valbuf, value_size);
1031 }
1032
1033 /* Initialize our target-dependent "stuff" for this newly created frame.
1034
1035    This includes allocating space for saved registers and analyzing
1036    the prologue of this frame. */
1037
1038 void
1039 mcore_init_extra_frame_info (int fromleaf, struct frame_info *fi)
1040 {
1041   if (fi && fi->next)
1042     deprecated_update_frame_pc_hack (fi, FRAME_SAVED_PC (fi->next));
1043
1044   frame_saved_regs_zalloc (fi);
1045
1046   fi->extra_info = (struct frame_extra_info *)
1047     frame_obstack_alloc (sizeof (struct frame_extra_info));
1048   fi->extra_info->status = 0;
1049   fi->extra_info->framesize = 0;
1050
1051   if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), fi->frame, fi->frame))
1052     {
1053       /* We need to setup fi->frame here because run_stack_dummy gets it wrong
1054          by assuming it's always FP.  */
1055       deprecated_update_frame_base_hack (fi, deprecated_read_register_dummy (get_frame_pc (fi), fi->frame, SP_REGNUM));
1056     }
1057   else
1058     mcore_analyze_prologue (fi, 0, 0);
1059 }
1060
1061 /* Get an insturction from memory. */
1062
1063 static int
1064 get_insn (CORE_ADDR pc)
1065 {
1066   char buf[4];
1067   int status = read_memory_nobpt (pc, buf, 2);
1068   if (status != 0)
1069     return 0;
1070
1071   return extract_unsigned_integer (buf, 2);
1072 }
1073
1074 static struct gdbarch *
1075 mcore_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1076 {
1077   static LONGEST call_dummy_words[7] = { };
1078   struct gdbarch_tdep *tdep = NULL;
1079   struct gdbarch *gdbarch;
1080
1081   /* find a candidate among the list of pre-declared architectures. */
1082   arches = gdbarch_list_lookup_by_info (arches, &info);
1083   if (arches != NULL)
1084     return (arches->gdbarch);
1085
1086   gdbarch = gdbarch_alloc (&info, 0);
1087
1088   /* NOTE: cagney/2002-12-06: This can be deleted when this arch is
1089      ready to unwind the PC first (see frame.c:get_prev_frame()).  */
1090   set_gdbarch_deprecated_init_frame_pc (gdbarch, init_frame_pc_default);
1091
1092   /* Registers: */
1093
1094   /* All registers are 32 bits */
1095   set_gdbarch_register_size (gdbarch, MCORE_REG_SIZE);
1096   set_gdbarch_max_register_raw_size (gdbarch, MCORE_REG_SIZE);
1097   set_gdbarch_max_register_virtual_size (gdbarch, MCORE_REG_SIZE);
1098   set_gdbarch_register_name (gdbarch, mcore_register_name);
1099   set_gdbarch_register_virtual_type (gdbarch, mcore_register_virtual_type);
1100   set_gdbarch_register_virtual_size (gdbarch, mcore_register_size);
1101   set_gdbarch_register_raw_size (gdbarch, mcore_register_size);
1102   set_gdbarch_register_byte (gdbarch, mcore_register_byte);
1103   set_gdbarch_register_bytes (gdbarch, MCORE_REG_SIZE * MCORE_NUM_REGS);
1104   set_gdbarch_num_regs (gdbarch, MCORE_NUM_REGS);
1105   set_gdbarch_pc_regnum (gdbarch, 64);
1106   set_gdbarch_sp_regnum (gdbarch, 0);
1107   set_gdbarch_fp_regnum (gdbarch, 0);
1108
1109   /* Call Dummies:  */
1110
1111   set_gdbarch_call_dummy_p (gdbarch, 1);
1112   set_gdbarch_call_dummy_words (gdbarch, call_dummy_words);
1113   set_gdbarch_sizeof_call_dummy_words (gdbarch, 0);
1114   set_gdbarch_call_dummy_start_offset (gdbarch, 0);
1115   set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 1);
1116   set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 0);
1117   set_gdbarch_fix_call_dummy (gdbarch, generic_fix_call_dummy);
1118   set_gdbarch_call_dummy_address (gdbarch, entry_point_address);
1119   set_gdbarch_save_dummy_frame_tos (gdbarch, generic_save_dummy_frame_tos);
1120   set_gdbarch_call_dummy_stack_adjust_p (gdbarch, 0);
1121   set_gdbarch_saved_pc_after_call (gdbarch, mcore_saved_pc_after_call);
1122   set_gdbarch_function_start_offset (gdbarch, 0);
1123   set_gdbarch_decr_pc_after_break (gdbarch, 0);
1124   set_gdbarch_breakpoint_from_pc (gdbarch, mcore_breakpoint_from_pc);
1125   set_gdbarch_push_return_address (gdbarch, mcore_push_return_address);
1126   set_gdbarch_push_dummy_frame (gdbarch, generic_push_dummy_frame);
1127   set_gdbarch_push_arguments (gdbarch, mcore_push_arguments);
1128   set_gdbarch_call_dummy_length (gdbarch, 0);
1129
1130   /* Frames:  */
1131
1132   set_gdbarch_init_extra_frame_info (gdbarch, mcore_init_extra_frame_info);
1133   set_gdbarch_frame_chain (gdbarch, mcore_frame_chain);
1134   set_gdbarch_frame_init_saved_regs (gdbarch, mcore_frame_init_saved_regs);
1135   set_gdbarch_frame_saved_pc (gdbarch, mcore_frame_saved_pc);
1136   set_gdbarch_deprecated_store_return_value (gdbarch, mcore_store_return_value);
1137   set_gdbarch_deprecated_extract_return_value (gdbarch,
1138                                                mcore_extract_return_value);
1139   set_gdbarch_store_struct_return (gdbarch, mcore_store_struct_return);
1140   set_gdbarch_deprecated_extract_struct_value_address (gdbarch,
1141                                                        mcore_extract_struct_value_address);
1142   set_gdbarch_skip_prologue (gdbarch, mcore_skip_prologue);
1143   set_gdbarch_frame_args_skip (gdbarch, 0);
1144   set_gdbarch_frame_args_address (gdbarch, mcore_frame_args_address);
1145   set_gdbarch_frame_locals_address (gdbarch, mcore_frame_locals_address);
1146   set_gdbarch_frame_num_args (gdbarch, frame_num_args_unknown);
1147   set_gdbarch_pop_frame (gdbarch, mcore_pop_frame);
1148   set_gdbarch_virtual_frame_pointer (gdbarch, mcore_virtual_frame_pointer);
1149
1150   /* Misc.:  */
1151
1152   /* Stack grows down.  */
1153   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1154   set_gdbarch_use_struct_convention (gdbarch, mcore_use_struct_convention);
1155   set_gdbarch_believe_pcc_promotion (gdbarch, 1);
1156   /* MCore will never pass a sturcture by reference. It will always be split
1157      between registers and stack.  */
1158   set_gdbarch_reg_struct_has_addr (gdbarch, mcore_reg_struct_has_addr);
1159
1160   return gdbarch;
1161 }
1162
1163 static void
1164 mcore_dump_tdep (struct gdbarch *current_gdbarch, struct ui_file *file)
1165 {
1166
1167 }
1168
1169 void
1170 _initialize_mcore_tdep (void)
1171 {
1172   extern int print_insn_mcore (bfd_vma, disassemble_info *);
1173   gdbarch_register (bfd_arch_mcore, mcore_gdbarch_init, mcore_dump_tdep);
1174   tm_print_insn = print_insn_mcore;
1175
1176 #ifdef MCORE_DEBUG
1177   add_show_from_set (add_set_cmd ("mcoredebug", no_class,
1178                                   var_boolean, (char *) &mcore_debug,
1179                                   "Set mcore debugging.\n", &setlist),
1180                      &showlist);
1181 #endif
1182 }