gdb/msp430-tdep.c

   1 /* Target-dependent code for the Texas Instruments MSP430 for GDB, the
   2    GNU debugger.
   3
   4    Copyright (C) 2012-2015 Free Software Foundation, Inc.
   5
   6    Contributed by Red Hat, Inc.
   7
   8    This file is part of GDB.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  22
  23 #include "defs.h"
  24 #include "arch-utils.h"
  25 #include "prologue-value.h"
  26 #include "target.h"
  27 #include "regcache.h"
  28 #include "dis-asm.h"
  29 #include "gdbtypes.h"
  30 #include "frame.h"
  31 #include "frame-unwind.h"
  32 #include "frame-base.h"
  33 #include "value.h"
  34 #include "gdbcore.h"
  35 #include "dwarf2-frame.h"
  36 #include "reggroups.h"
  37
  38 #include "elf/msp430.h"
  39 #include "opcode/msp430-decode.h"
  40 #include "elf-bfd.h"
  41
  42 /* Register Numbers.  */
  43
  44 enum
  45 {
  46   MSP430_PC_RAW_REGNUM,
  47   MSP430_SP_RAW_REGNUM,
  48   MSP430_SR_RAW_REGNUM,
  49   MSP430_CG_RAW_REGNUM,
  50   MSP430_R4_RAW_REGNUM,
  51   MSP430_R5_RAW_REGNUM,
  52   MSP430_R6_RAW_REGNUM,
  53   MSP430_R7_RAW_REGNUM,
  54   MSP430_R8_RAW_REGNUM,
  55   MSP430_R9_RAW_REGNUM,
  56   MSP430_R10_RAW_REGNUM,
  57   MSP430_R11_RAW_REGNUM,
  58   MSP430_R12_RAW_REGNUM,
  59   MSP430_R13_RAW_REGNUM,
  60   MSP430_R14_RAW_REGNUM,
  61   MSP430_R15_RAW_REGNUM,
  62
  63   MSP430_NUM_REGS,
  64
  65   MSP430_PC_REGNUM = MSP430_NUM_REGS,
  66   MSP430_SP_REGNUM,
  67   MSP430_SR_REGNUM,
  68   MSP430_CG_REGNUM,
  69   MSP430_R4_REGNUM,
  70   MSP430_R5_REGNUM,
  71   MSP430_R6_REGNUM,
  72   MSP430_R7_REGNUM,
  73   MSP430_R8_REGNUM,
  74   MSP430_R9_REGNUM,
  75   MSP430_R10_REGNUM,
  76   MSP430_R11_REGNUM,
  77   MSP430_R12_REGNUM,
  78   MSP430_R13_REGNUM,
  79   MSP430_R14_REGNUM,
  80   MSP430_R15_REGNUM,
  81
  82   MSP430_NUM_TOTAL_REGS,
  83   MSP430_NUM_PSEUDO_REGS = MSP430_NUM_TOTAL_REGS - MSP430_NUM_REGS
  84 };
  85
  86 enum
  87 {
  88   /* TI MSP430 Architecture.  */
  89   MSP_ISA_MSP430,
  90
  91   /* TI MSP430X Architecture.  */
  92   MSP_ISA_MSP430X
  93 };
  94
  95 enum
  96 {
  97   /* The small code model limits code addresses to 16 bits.  */
  98   MSP_SMALL_CODE_MODEL,
  99
 100   /* The large code model uses 20 bit addresses for function
 101      pointers.  These are stored in memory using four bytes (32 bits).  */
 102   MSP_LARGE_CODE_MODEL
 103 };
 104
 105 /* Architecture specific data.  */
 106
 107 struct gdbarch_tdep
 108 {
 109   /* The ELF header flags specify the multilib used.  */
 110   int elf_flags;
 111
 112   /* One of MSP_ISA_MSP430 or MSP_ISA_MSP430X.  */
 113   int isa;
 114
 115   /* One of MSP_SMALL_CODE_MODEL or MSP_LARGE_CODE_MODEL.  If, at
 116      some point, we support different data models too, we'll probably
 117      structure things so that we can combine values using logical
 118      "or".  */
 119   int code_model;
 120 };
 121
 122 /* This structure holds the results of a prologue analysis.  */
 123
 124 struct msp430_prologue
 125 {
 126   /* The offset from the frame base to the stack pointer --- always
 127      zero or negative.
 128
 129      Calling this a "size" is a bit misleading, but given that the
 130      stack grows downwards, using offsets for everything keeps one
 131      from going completely sign-crazy: you never change anything's
 132      sign for an ADD instruction; always change the second operand's
 133      sign for a SUB instruction; and everything takes care of
 134      itself.  */
 135   int frame_size;
 136
 137   /* Non-zero if this function has initialized the frame pointer from
 138      the stack pointer, zero otherwise.  */
 139   int has_frame_ptr;
 140
 141   /* If has_frame_ptr is non-zero, this is the offset from the frame
 142      base to where the frame pointer points.  This is always zero or
 143      negative.  */
 144   int frame_ptr_offset;
 145
 146   /* The address of the first instruction at which the frame has been
 147      set up and the arguments are where the debug info says they are
 148      --- as best as we can tell.  */
 149   CORE_ADDR prologue_end;
 150
 151   /* reg_offset[R] is the offset from the CFA at which register R is
 152      saved, or 1 if register R has not been saved.  (Real values are
 153      always zero or negative.)  */
 154   int reg_offset[MSP430_NUM_TOTAL_REGS];
 155 };
 156
 157 /* Implement the "register_type" gdbarch method.  */
 158
 159 static struct type *
 160 msp430_register_type (struct gdbarch *gdbarch, int reg_nr)
 161 {
 162   if (reg_nr < MSP430_NUM_REGS)
 163     return builtin_type (gdbarch)->builtin_uint32;
 164   else if (reg_nr == MSP430_PC_REGNUM)
 165     return builtin_type (gdbarch)->builtin_func_ptr;
 166   else
 167     return builtin_type (gdbarch)->builtin_uint16;
 168 }
 169
 170 /* Implement another version of the "register_type" gdbarch method
 171    for msp430x.  */
 172
 173 static struct type *
 174 msp430x_register_type (struct gdbarch *gdbarch, int reg_nr)
 175 {
 176   if (reg_nr < MSP430_NUM_REGS)
 177     return builtin_type (gdbarch)->builtin_uint32;
 178   else if (reg_nr == MSP430_PC_REGNUM)
 179     return builtin_type (gdbarch)->builtin_func_ptr;
 180   else
 181     return builtin_type (gdbarch)->builtin_uint32;
 182 }
 183
 184 /* Implement the "register_name" gdbarch method.  */
 185
 186 static const char *
 187 msp430_register_name (struct gdbarch *gdbarch, int regnr)
 188 {
 189   static const char *const reg_names[] = {
 190     /* Raw registers.  */
 191     "", "", "", "", "", "", "", "",
 192     "", "", "", "", "", "", "", "",
 193     /* Pseudo registers.  */
 194     "pc", "sp", "sr", "cg", "r4", "r5", "r6", "r7",
 195     "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
 196   };
 197
 198   return reg_names[regnr];
 199 }
 200
 201 /* Implement the "register_reggroup_p" gdbarch method.  */
 202
 203 static int
 204 msp430_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
 205                             struct reggroup *group)
 206 {
 207   if (group == all_reggroup)
 208     return 1;
 209
 210   /* All other registers are saved and restored.  */
 211   if (group == save_reggroup || group == restore_reggroup)
 212     return (MSP430_NUM_REGS <= regnum && regnum < MSP430_NUM_TOTAL_REGS);
 213
 214   return group == general_reggroup;
 215 }
 216
 217 /* Implement the "pseudo_register_read" gdbarch method.  */
 218
 219 static enum register_status
 220 msp430_pseudo_register_read (struct gdbarch *gdbarch,
 221                              struct regcache *regcache,
 222                              int regnum, gdb_byte *buffer)
 223 {
 224   enum register_status status = REG_UNKNOWN;
 225
 226   if (MSP430_NUM_REGS <= regnum && regnum < MSP430_NUM_TOTAL_REGS)
 227     {
 228       ULONGEST val;
 229       enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 230       int regsize = register_size (gdbarch, regnum);
 231       int raw_regnum = regnum - MSP430_NUM_REGS;
 232
 233       status = regcache_raw_read_unsigned (regcache, raw_regnum, &val);
 234       if (status == REG_VALID)
 235         store_unsigned_integer (buffer, regsize, byte_order, val);
 236
 237     }
 238   else
 239     gdb_assert_not_reached ("invalid pseudo register number");
 240
 241   return status;
 242 }
 243
 244 /* Implement the "pseudo_register_write" gdbarch method.  */
 245
 246 static void
 247 msp430_pseudo_register_write (struct gdbarch *gdbarch,
 248                               struct regcache *regcache,
 249                               int regnum, const gdb_byte *buffer)
 250 {
 251   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 252   if (MSP430_NUM_REGS <= regnum && regnum < MSP430_NUM_TOTAL_REGS)
 253
 254     {
 255       ULONGEST val;
 256       enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 257       int regsize = register_size (gdbarch, regnum);
 258       int raw_regnum = regnum - MSP430_NUM_REGS;
 259
 260       val = extract_unsigned_integer (buffer, regsize, byte_order);
 261       regcache_raw_write_unsigned (regcache, raw_regnum, val);
 262
 263     }
 264   else
 265     gdb_assert_not_reached ("invalid pseudo register number");
 266 }
 267
 268 /* Implement the `register_sim_regno' gdbarch method.  */
 269
 270 static int
 271 msp430_register_sim_regno (struct gdbarch *gdbarch, int regnum)
 272 {
 273   gdb_assert (regnum < MSP430_NUM_REGS);
 274
 275   /* So long as regnum is in [0, RL78_NUM_REGS), it's valid.  We
 276      just want to override the default here which disallows register
 277      numbers which have no names.  */
 278   return regnum;
 279 }
 280
 281 /* Implement the "breakpoint_from_pc" gdbarch method.  */
 282
 283 static const gdb_byte *
 284 msp430_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr,
 285                            int *lenptr)
 286 {
 287   static gdb_byte breakpoint[] = { 0x43, 0x43 };
 288
 289   *lenptr = sizeof breakpoint;
 290   return breakpoint;
 291 }
 292
 293 /* Define a "handle" struct for fetching the next opcode.  */
 294
 295 struct msp430_get_opcode_byte_handle
 296 {
 297   CORE_ADDR pc;
 298 };
 299
 300 /* Fetch a byte on behalf of the opcode decoder.  HANDLE contains
 301    the memory address of the next byte to fetch.  If successful,
 302    the address in the handle is updated and the byte fetched is
 303    returned as the value of the function.  If not successful, -1
 304    is returned.  */
 305
 306 static int
 307 msp430_get_opcode_byte (void *handle)
 308 {
 309   struct msp430_get_opcode_byte_handle *opcdata
 310     = (struct msp430_get_opcode_byte_handle *) handle;
 311   int status;
 312   gdb_byte byte;
 313
 314   status = target_read_memory (opcdata->pc, &byte, 1);
 315   if (status == 0)
 316     {
 317       opcdata->pc += 1;
 318       return byte;
 319     }
 320   else
 321     return -1;
 322 }
 323
 324 /* Function for finding saved registers in a 'struct pv_area'; this
 325    function is passed to pv_area_scan.
 326
 327    If VALUE is a saved register, ADDR says it was saved at a constant
 328    offset from the frame base, and SIZE indicates that the whole
 329    register was saved, record its offset.  */
 330
 331 static void
 332 check_for_saved (void *result_untyped, pv_t addr, CORE_ADDR size, pv_t value)
 333 {
 334   struct msp430_prologue *result = (struct msp430_prologue *) result_untyped;
 335
 336   if (value.kind == pvk_register
 337       && value.k == 0
 338       && pv_is_register (addr, MSP430_SP_REGNUM)
 339       && size == register_size (target_gdbarch (), value.reg))
 340     result->reg_offset[value.reg] = addr.k;
 341 }
 342
 343 /* Analyze a prologue starting at START_PC, going no further than
 344    LIMIT_PC.  Fill in RESULT as appropriate.  */
 345
 346 static void
 347 msp430_analyze_prologue (struct gdbarch *gdbarch, CORE_ADDR start_pc,
 348                          CORE_ADDR limit_pc, struct msp430_prologue *result)
 349 {
 350   CORE_ADDR pc, next_pc;
 351   int rn;
 352   pv_t reg[MSP430_NUM_TOTAL_REGS];
 353   struct pv_area *stack;
 354   struct cleanup *back_to;
 355   CORE_ADDR after_last_frame_setup_insn = start_pc;
 356   int code_model = gdbarch_tdep (gdbarch)->code_model;
 357   int sz;
 358
 359   memset (result, 0, sizeof (*result));
 360
 361   for (rn = 0; rn < MSP430_NUM_TOTAL_REGS; rn++)
 362     {
 363       reg[rn] = pv_register (rn, 0);
 364       result->reg_offset[rn] = 1;
 365     }
 366
 367   stack = make_pv_area (MSP430_SP_REGNUM, gdbarch_addr_bit (gdbarch));
 368   back_to = make_cleanup_free_pv_area (stack);
 369
 370   /* The call instruction has saved the return address on the stack.  */
 371   sz = code_model == MSP_LARGE_CODE_MODEL ? 4 : 2;
 372   reg[MSP430_SP_REGNUM] = pv_add_constant (reg[MSP430_SP_REGNUM], -sz);
 373   pv_area_store (stack, reg[MSP430_SP_REGNUM], sz, reg[MSP430_PC_REGNUM]);
 374
 375   pc = start_pc;
 376   while (pc < limit_pc)
 377     {
 378       int bytes_read;
 379       struct msp430_get_opcode_byte_handle opcode_handle;
 380       MSP430_Opcode_Decoded opc;
 381
 382       opcode_handle.pc = pc;
 383       bytes_read = msp430_decode_opcode (pc, &opc, msp430_get_opcode_byte,
 384                                          &opcode_handle);
 385       next_pc = pc + bytes_read;
 386
 387       if (opc.id == MSO_push && opc.op[0].type == MSP430_Operand_Register)
 388         {
 389           int rsrc = opc.op[0].reg;
 390
 391           reg[MSP430_SP_REGNUM] = pv_add_constant (reg[MSP430_SP_REGNUM], -2);
 392           pv_area_store (stack, reg[MSP430_SP_REGNUM], 2, reg[rsrc]);
 393           after_last_frame_setup_insn = next_pc;
 394         }
 395       else if (opc.id == MSO_push       /* PUSHM  */
 396                && opc.op[0].type == MSP430_Operand_None
 397                && opc.op[1].type == MSP430_Operand_Register)
 398         {
 399           int rsrc = opc.op[1].reg;
 400           int count = opc.repeats + 1;
 401           int size = opc.size == 16 ? 2 : 4;
 402
 403           while (count > 0)
 404             {
 405               reg[MSP430_SP_REGNUM]
 406                 = pv_add_constant (reg[MSP430_SP_REGNUM], -size);
 407               pv_area_store (stack, reg[MSP430_SP_REGNUM], size, reg[rsrc]);
 408               rsrc--;
 409               count--;
 410             }
 411           after_last_frame_setup_insn = next_pc;
 412         }
 413       else if (opc.id == MSO_sub
 414                && opc.op[0].type == MSP430_Operand_Register
 415                && opc.op[0].reg == MSR_SP
 416                && opc.op[1].type == MSP430_Operand_Immediate)
 417         {
 418           int addend = opc.op[1].addend;
 419
 420           reg[MSP430_SP_REGNUM] = pv_add_constant (reg[MSP430_SP_REGNUM],
 421                                                    -addend);
 422           after_last_frame_setup_insn = next_pc;
 423         }
 424       else if (opc.id == MSO_mov
 425                && opc.op[0].type == MSP430_Operand_Immediate
 426                && 12 <= opc.op[0].reg && opc.op[0].reg <= 15)
 427         after_last_frame_setup_insn = next_pc;
 428       else
 429         {
 430           /* Terminate the prologue scan.  */
 431           break;
 432         }
 433
 434       pc = next_pc;
 435     }
 436
 437   /* Is the frame size (offset, really) a known constant?  */
 438   if (pv_is_register (reg[MSP430_SP_REGNUM], MSP430_SP_REGNUM))
 439     result->frame_size = reg[MSP430_SP_REGNUM].k;
 440
 441   /* Record where all the registers were saved.  */
 442   pv_area_scan (stack, check_for_saved, result);
 443
 444   result->prologue_end = after_last_frame_setup_insn;
 445
 446   do_cleanups (back_to);
 447 }
 448
 449 /* Implement the "skip_prologue" gdbarch method.  */
 450
 451 static CORE_ADDR
 452 msp430_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
 453 {
 454   const char *name;
 455   CORE_ADDR func_addr, func_end;
 456   struct msp430_prologue p;
 457
 458   /* Try to find the extent of the function that contains PC.  */
 459   if (!find_pc_partial_function (pc, &name, &func_addr, &func_end))
 460     return pc;
 461
 462   msp430_analyze_prologue (gdbarch, pc, func_end, &p);
 463   return p.prologue_end;
 464 }
 465
 466 /* Implement the "unwind_pc" gdbarch method.  */
 467
 468 static CORE_ADDR
 469 msp430_unwind_pc (struct gdbarch *arch, struct frame_info *next_frame)
 470 {
 471   return frame_unwind_register_unsigned (next_frame, MSP430_PC_REGNUM);
 472 }
 473
 474 /* Implement the "unwind_sp" gdbarch method.  */
 475
 476 static CORE_ADDR
 477 msp430_unwind_sp (struct gdbarch *arch, struct frame_info *next_frame)
 478 {
 479   return frame_unwind_register_unsigned (next_frame, MSP430_SP_REGNUM);
 480 }
 481
 482 /* Given a frame described by THIS_FRAME, decode the prologue of its
 483    associated function if there is not cache entry as specified by
 484    THIS_PROLOGUE_CACHE.  Save the decoded prologue in the cache and
 485    return that struct as the value of this function.  */
 486
 487 static struct msp430_prologue *
 488 msp430_analyze_frame_prologue (struct frame_info *this_frame,
 489                                void **this_prologue_cache)
 490 {
 491   if (!*this_prologue_cache)
 492     {
 493       CORE_ADDR func_start, stop_addr;
 494
 495       *this_prologue_cache = FRAME_OBSTACK_ZALLOC (struct msp430_prologue);
 496
 497       func_start = get_frame_func (this_frame);
 498       stop_addr = get_frame_pc (this_frame);
 499
 500       /* If we couldn't find any function containing the PC, then
 501          just initialize the prologue cache, but don't do anything.  */
 502       if (!func_start)
 503         stop_addr = func_start;
 504
 505       msp430_analyze_prologue (get_frame_arch (this_frame), func_start,
 506                                stop_addr,
 507                                (struct msp430_prologue *) *this_prologue_cache);
 508     }
 509
 510   return (struct msp430_prologue *) *this_prologue_cache;
 511 }
 512
 513 /* Given a frame and a prologue cache, return this frame's base.  */
 514
 515 static CORE_ADDR
 516 msp430_frame_base (struct frame_info *this_frame, void **this_prologue_cache)
 517 {
 518   struct msp430_prologue *p
 519     = msp430_analyze_frame_prologue (this_frame, this_prologue_cache);
 520   CORE_ADDR sp = get_frame_register_unsigned (this_frame, MSP430_SP_REGNUM);
 521
 522   return sp - p->frame_size;
 523 }
 524
 525 /* Implement the "frame_this_id" method for unwinding frames.  */
 526
 527 static void
 528 msp430_this_id (struct frame_info *this_frame,
 529                 void **this_prologue_cache, struct frame_id *this_id)
 530 {
 531   *this_id = frame_id_build (msp430_frame_base (this_frame,
 532                                                 this_prologue_cache),
 533                              get_frame_func (this_frame));
 534 }
 535
 536 /* Implement the "frame_prev_register" method for unwinding frames.  */
 537
 538 static struct value *
 539 msp430_prev_register (struct frame_info *this_frame,
 540                       void **this_prologue_cache, int regnum)
 541 {
 542   struct msp430_prologue *p
 543     = msp430_analyze_frame_prologue (this_frame, this_prologue_cache);
 544   CORE_ADDR frame_base = msp430_frame_base (this_frame, this_prologue_cache);
 545
 546   if (regnum == MSP430_SP_REGNUM)
 547     return frame_unwind_got_constant (this_frame, regnum, frame_base);
 548
 549   /* If prologue analysis says we saved this register somewhere,
 550      return a description of the stack slot holding it.  */
 551   else if (p->reg_offset[regnum] != 1)
 552     {
 553       struct value *rv = frame_unwind_got_memory (this_frame, regnum,
 554                                                   frame_base +
 555                                                   p->reg_offset[regnum]);
 556
 557       if (regnum == MSP430_PC_REGNUM)
 558         {
 559           ULONGEST pc = value_as_long (rv);
 560
 561           return frame_unwind_got_constant (this_frame, regnum, pc);
 562         }
 563       return rv;
 564     }
 565
 566   /* Otherwise, presume we haven't changed the value of this
 567      register, and get it from the next frame.  */
 568   else
 569     return frame_unwind_got_register (this_frame, regnum, regnum);
 570 }
 571
 572 static const struct frame_unwind msp430_unwind = {
 573   NORMAL_FRAME,
 574   default_frame_unwind_stop_reason,
 575   msp430_this_id,
 576   msp430_prev_register,
 577   NULL,
 578   default_frame_sniffer
 579 };
 580
 581 /* Implement the "dwarf2_reg_to_regnum" gdbarch method.  */
 582
 583 static int
 584 msp430_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, int reg)
 585 {
 586   if (reg < MSP430_NUM_REGS)
 587     return reg + MSP430_NUM_REGS;
 588   else
 589     {
 590       warning (_("Unmapped DWARF Register #%d encountered."), reg);
 591       return -1;
 592     }
 593 }
 594
 595 /* Implement the "return_value" gdbarch method.  */
 596
 597 static enum return_value_convention
 598 msp430_return_value (struct gdbarch *gdbarch,
 599                      struct value *function,
 600                      struct type *valtype,
 601                      struct regcache *regcache,
 602                      gdb_byte *readbuf, const gdb_byte *writebuf)
 603 {
 604   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 605   LONGEST valtype_len = TYPE_LENGTH (valtype);
 606   int code_model = gdbarch_tdep (gdbarch)->code_model;
 607
 608   if (TYPE_LENGTH (valtype) > 8
 609       || TYPE_CODE (valtype) == TYPE_CODE_STRUCT
 610       || TYPE_CODE (valtype) == TYPE_CODE_UNION)
 611     return RETURN_VALUE_STRUCT_CONVENTION;
 612
 613   if (readbuf)
 614     {
 615       ULONGEST u;
 616       int argreg = MSP430_R12_REGNUM;
 617       int offset = 0;
 618
 619       while (valtype_len > 0)
 620         {
 621           int size = 2;
 622
 623           if (code_model == MSP_LARGE_CODE_MODEL
 624               && TYPE_CODE (valtype) == TYPE_CODE_PTR)
 625             {
 626               size = 4;
 627             }
 628
 629           regcache_cooked_read_unsigned (regcache, argreg, &u);
 630           store_unsigned_integer (readbuf + offset, size, byte_order, u);
 631           valtype_len -= size;
 632           offset += size;
 633           argreg++;
 634         }
 635     }
 636
 637   if (writebuf)
 638     {
 639       ULONGEST u;
 640       int argreg = MSP430_R12_REGNUM;
 641       int offset = 0;
 642
 643       while (valtype_len > 0)
 644         {
 645           int size = 2;
 646
 647           if (code_model == MSP_LARGE_CODE_MODEL
 648               && TYPE_CODE (valtype) == TYPE_CODE_PTR)
 649             {
 650               size = 4;
 651             }
 652
 653           u = extract_unsigned_integer (writebuf + offset, size, byte_order);
 654           regcache_cooked_write_unsigned (regcache, argreg, u);
 655           valtype_len -= size;
 656           offset += size;
 657           argreg++;
 658         }
 659     }
 660
 661   return RETURN_VALUE_REGISTER_CONVENTION;
 662 }
 663
 664
 665 /* Implement the "frame_align" gdbarch method.  */
 666
 667 static CORE_ADDR
 668 msp430_frame_align (struct gdbarch *gdbarch, CORE_ADDR sp)
 669 {
 670   return align_down (sp, 2);
 671 }
 672
 673
 674 /* Implement the "dummy_id" gdbarch method.  */
 675
 676 static struct frame_id
 677 msp430_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
 678 {
 679   return
 680     frame_id_build (get_frame_register_unsigned
 681                     (this_frame, MSP430_SP_REGNUM),
 682                     get_frame_pc (this_frame));
 683 }
 684
 685
 686 /* Implement the "push_dummy_call" gdbarch method.  */
 687
 688 static CORE_ADDR
 689 msp430_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 690                         struct regcache *regcache, CORE_ADDR bp_addr,
 691                         int nargs, struct value **args, CORE_ADDR sp,
 692                         int struct_return, CORE_ADDR struct_addr)
 693 {
 694   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 695   int write_pass;
 696   int sp_off = 0;
 697   CORE_ADDR cfa;
 698   int code_model = gdbarch_tdep (gdbarch)->code_model;
 699
 700   struct type *func_type = value_type (function);
 701
 702   /* Dereference function pointer types.  */
 703   while (TYPE_CODE (func_type) == TYPE_CODE_PTR)
 704     func_type = TYPE_TARGET_TYPE (func_type);
 705
 706   /* The end result had better be a function or a method.  */
 707   gdb_assert (TYPE_CODE (func_type) == TYPE_CODE_FUNC
 708               || TYPE_CODE (func_type) == TYPE_CODE_METHOD);
 709
 710   /* We make two passes; the first does the stack allocation,
 711      the second actually stores the arguments.  */
 712   for (write_pass = 0; write_pass <= 1; write_pass++)
 713     {
 714       int i;
 715       int arg_reg = MSP430_R12_REGNUM;
 716       int args_on_stack = 0;
 717
 718       if (write_pass)
 719         sp = align_down (sp - sp_off, 4);
 720       sp_off = 0;
 721
 722       if (struct_return)
 723         {
 724           if (write_pass)
 725             regcache_cooked_write_unsigned (regcache, arg_reg, struct_addr);
 726           arg_reg++;
 727         }
 728
 729       /* Push the arguments.  */
 730       for (i = 0; i < nargs; i++)
 731         {
 732           struct value *arg = args[i];
 733           const gdb_byte *arg_bits = value_contents_all (arg);
 734           struct type *arg_type = check_typedef (value_type (arg));
 735           ULONGEST arg_size = TYPE_LENGTH (arg_type);
 736           int offset;
 737           int current_arg_on_stack;
 738
 739           current_arg_on_stack = 0;
 740
 741           if (TYPE_CODE (arg_type) == TYPE_CODE_STRUCT
 742               || TYPE_CODE (arg_type) == TYPE_CODE_UNION)
 743             {
 744               /* Aggregates of any size are passed by reference.  */
 745               gdb_byte struct_addr[4];
 746
 747               store_unsigned_integer (struct_addr, 4, byte_order,
 748                                       value_address (arg));
 749               arg_bits = struct_addr;
 750               arg_size = (code_model == MSP_LARGE_CODE_MODEL) ? 4 : 2;
 751             }
 752           else
 753             {
 754               /* Scalars bigger than 8 bytes such as complex doubles are passed
 755                  on the stack.  */
 756               if (arg_size > 8)
 757                 current_arg_on_stack = 1;
 758             }
 759
 760
 761           for (offset = 0; offset < arg_size; offset += 2)
 762             {
 763               /* The condition below prevents 8 byte scalars from being split
 764                  between registers and memory (stack).  It also prevents other
 765                  splits once the stack has been written to.  */
 766               if (!current_arg_on_stack
 767                   && (arg_reg
 768                       + ((arg_size == 8 || args_on_stack)
 769                          ? ((arg_size - offset) / 2 - 1)
 770                          : 0) <= MSP430_R15_REGNUM))
 771                 {
 772                   int size = 2;
 773
 774                   if (code_model == MSP_LARGE_CODE_MODEL
 775                       && (TYPE_CODE (arg_type) == TYPE_CODE_PTR
 776                           || TYPE_CODE (arg_type) == TYPE_CODE_REF
 777                           || TYPE_CODE (arg_type) == TYPE_CODE_STRUCT
 778                           || TYPE_CODE (arg_type) == TYPE_CODE_UNION))
 779                     {
 780                       /* When using the large memory model, pointer,
 781                          reference, struct, and union arguments are
 782                          passed using the entire register.  (As noted
 783                          earlier, aggregates are always passed by
 784                          reference.) */
 785                       if (offset != 0)
 786                         continue;
 787                       size = 4;
 788                     }
 789
 790                   if (write_pass)
 791                     regcache_cooked_write_unsigned (regcache, arg_reg,
 792                                                     extract_unsigned_integer
 793                                                     (arg_bits + offset, size,
 794                                                      byte_order));
 795
 796                   arg_reg++;
 797                 }
 798               else
 799                 {
 800                   if (write_pass)
 801                     write_memory (sp + sp_off, arg_bits + offset, 2);
 802
 803                   sp_off += 2;
 804                   args_on_stack = 1;
 805                   current_arg_on_stack = 1;
 806                 }
 807             }
 808         }
 809     }
 810
 811   /* Keep track of the stack address prior to pushing the return address.
 812      This is the value that we'll return.  */
 813   cfa = sp;
 814
 815   /* Push the return address.  */
 816   {
 817     int sz = (gdbarch_tdep (gdbarch)->code_model == MSP_SMALL_CODE_MODEL)
 818       ? 2 : 4;
 819     sp = sp - sz;
 820     write_memory_unsigned_integer (sp, sz, byte_order, bp_addr);
 821   }
 822
 823   /* Update the stack pointer.  */
 824   regcache_cooked_write_unsigned (regcache, MSP430_SP_REGNUM, sp);
 825
 826   return cfa;
 827 }
 828
 829 /* In order to keep code size small, the compiler may create epilogue
 830    code through which more than one function epilogue is routed.  I.e.
 831    the epilogue and return may just be a branch to some common piece of
 832    code which is responsible for tearing down the frame and performing
 833    the return.  These epilog (label) names will have the common prefix
 834    defined here.  */
 835
 836 static const char msp430_epilog_name_prefix[] = "__mspabi_func_epilog_";
 837
 838 /* Implement the "in_return_stub" gdbarch method.  */
 839
 840 static int
 841 msp430_in_return_stub (struct gdbarch *gdbarch, CORE_ADDR pc,
 842                        const char *name)
 843 {
 844   return (name != NULL
 845           && startswith (name, msp430_epilog_name_prefix));
 846 }
 847
 848 /* Implement the "skip_trampoline_code" gdbarch method.  */
 849 static CORE_ADDR
 850 msp430_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
 851 {
 852   struct bound_minimal_symbol bms;
 853   const char *stub_name;
 854   struct gdbarch *gdbarch = get_frame_arch (frame);
 855
 856   bms = lookup_minimal_symbol_by_pc (pc);
 857   if (!bms.minsym)
 858     return pc;
 859
 860   stub_name = MSYMBOL_LINKAGE_NAME (bms.minsym);
 861
 862   if (gdbarch_tdep (gdbarch)->code_model == MSP_SMALL_CODE_MODEL
 863       && msp430_in_return_stub (gdbarch, pc, stub_name))
 864     {
 865       CORE_ADDR sp = get_frame_register_unsigned (frame, MSP430_SP_REGNUM);
 866
 867       return read_memory_integer
 868         (sp + 2 * (stub_name[strlen (msp430_epilog_name_prefix)] - '0'),
 869          2, gdbarch_byte_order (gdbarch));
 870     }
 871
 872   return pc;
 873 }
 874
 875 /* Allocate and initialize a gdbarch object.  */
 876
 877 static struct gdbarch *
 878 msp430_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 879 {
 880   struct gdbarch *gdbarch;
 881   struct gdbarch_tdep *tdep;
 882   int elf_flags, isa, code_model;
 883
 884   /* Extract the elf_flags if available.  */
 885   if (info.abfd != NULL
 886       && bfd_get_flavour (info.abfd) == bfd_target_elf_flavour)
 887     elf_flags = elf_elfheader (info.abfd)->e_flags;
 888   else
 889     elf_flags = 0;
 890
 891   if (info.abfd != NULL)
 892     switch (bfd_elf_get_obj_attr_int (info.abfd, OBJ_ATTR_PROC,
 893                                       OFBA_MSPABI_Tag_ISA))
 894       {
 895       case 1:
 896         isa = MSP_ISA_MSP430;
 897         code_model = MSP_SMALL_CODE_MODEL;
 898         break;
 899       case 2:
 900         isa = MSP_ISA_MSP430X;
 901         switch (bfd_elf_get_obj_attr_int (info.abfd, OBJ_ATTR_PROC,
 902                                           OFBA_MSPABI_Tag_Code_Model))
 903           {
 904           case 1:
 905             code_model = MSP_SMALL_CODE_MODEL;
 906             break;
 907           case 2:
 908             code_model = MSP_LARGE_CODE_MODEL;
 909             break;
 910           default:
 911             internal_error (__FILE__, __LINE__,
 912                             _("Unknown msp430x code memory model"));
 913             break;
 914           }
 915         break;
 916       case 0:
 917         /* This can happen when loading a previously dumped data structure.
 918            Use the ISA and code model from the current architecture, provided
 919            it's compatible.  */
 920         {
 921           struct gdbarch *ca = get_current_arch ();
 922           if (ca && gdbarch_bfd_arch_info (ca)->arch == bfd_arch_msp430)
 923             {
 924               struct gdbarch_tdep *ca_tdep = gdbarch_tdep (ca);
 925
 926               elf_flags = ca_tdep->elf_flags;
 927               isa = ca_tdep->isa;
 928               code_model = ca_tdep->code_model;
 929               break;
 930             }
 931           /* Otherwise, fall through...  */
 932         }
 933       default:
 934         error (_("Unknown msp430 isa"));
 935         break;
 936       }
 937   else
 938     {
 939       isa = MSP_ISA_MSP430;
 940       code_model = MSP_SMALL_CODE_MODEL;
 941     }
 942
 943
 944   /* Try to find the architecture in the list of already defined
 945      architectures.  */
 946   for (arches = gdbarch_list_lookup_by_info (arches, &info);
 947        arches != NULL;
 948        arches = gdbarch_list_lookup_by_info (arches->next, &info))
 949     {
 950       struct gdbarch_tdep *candidate_tdep = gdbarch_tdep (arches->gdbarch);
 951
 952       if (candidate_tdep->elf_flags != elf_flags
 953           || candidate_tdep->isa != isa
 954           || candidate_tdep->code_model != code_model)
 955         continue;
 956
 957       return arches->gdbarch;
 958     }
 959
 960   /* None found, create a new architecture from the information
 961      provided.  */
 962   tdep = XNEW (struct gdbarch_tdep);
 963   gdbarch = gdbarch_alloc (&info, tdep);
 964   tdep->elf_flags = elf_flags;
 965   tdep->isa = isa;
 966   tdep->code_model = code_model;
 967
 968   /* Registers.  */
 969   set_gdbarch_num_regs (gdbarch, MSP430_NUM_REGS);
 970   set_gdbarch_num_pseudo_regs (gdbarch, MSP430_NUM_PSEUDO_REGS);
 971   set_gdbarch_register_name (gdbarch, msp430_register_name);
 972   if (isa == MSP_ISA_MSP430)
 973     set_gdbarch_register_type (gdbarch, msp430_register_type);
 974   else
 975     set_gdbarch_register_type (gdbarch, msp430x_register_type);
 976   set_gdbarch_pc_regnum (gdbarch, MSP430_PC_REGNUM);
 977   set_gdbarch_sp_regnum (gdbarch, MSP430_SP_REGNUM);
 978   set_gdbarch_register_reggroup_p (gdbarch, msp430_register_reggroup_p);
 979   set_gdbarch_pseudo_register_read (gdbarch, msp430_pseudo_register_read);
 980   set_gdbarch_pseudo_register_write (gdbarch, msp430_pseudo_register_write);
 981   set_gdbarch_dwarf2_reg_to_regnum (gdbarch, msp430_dwarf2_reg_to_regnum);
 982   set_gdbarch_register_sim_regno (gdbarch, msp430_register_sim_regno);
 983
 984   /* Data types.  */
 985   set_gdbarch_char_signed (gdbarch, 0);
 986   set_gdbarch_short_bit (gdbarch, 16);
 987   set_gdbarch_int_bit (gdbarch, 16);
 988   set_gdbarch_long_bit (gdbarch, 32);
 989   set_gdbarch_long_long_bit (gdbarch, 64);
 990   if (code_model == MSP_SMALL_CODE_MODEL)
 991     {
 992       set_gdbarch_ptr_bit (gdbarch, 16);
 993       set_gdbarch_addr_bit (gdbarch, 16);
 994     }
 995   else                          /* MSP_LARGE_CODE_MODEL */
 996     {
 997       set_gdbarch_ptr_bit (gdbarch, 32);
 998       set_gdbarch_addr_bit (gdbarch, 32);
 999     }
1000   set_gdbarch_dwarf2_addr_size (gdbarch, 4);
1001   set_gdbarch_float_bit (gdbarch, 32);
1002   set_gdbarch_float_format (gdbarch, floatformats_ieee_single);
1003   set_gdbarch_double_bit (gdbarch, 64);
1004   set_gdbarch_long_double_bit (gdbarch, 64);
1005   set_gdbarch_double_format (gdbarch, floatformats_ieee_double);
1006   set_gdbarch_long_double_format (gdbarch, floatformats_ieee_double);
1007
1008   /* Breakpoints.  */
1009   set_gdbarch_breakpoint_from_pc (gdbarch, msp430_breakpoint_from_pc);
1010   set_gdbarch_decr_pc_after_break (gdbarch, 1);
1011
1012   /* Disassembly.  */
1013   set_gdbarch_print_insn (gdbarch, print_insn_msp430);
1014
1015   /* Frames, prologues, etc.  */
1016   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1017   set_gdbarch_skip_prologue (gdbarch, msp430_skip_prologue);
1018   set_gdbarch_unwind_pc (gdbarch, msp430_unwind_pc);
1019   set_gdbarch_unwind_sp (gdbarch, msp430_unwind_sp);
1020   set_gdbarch_frame_align (gdbarch, msp430_frame_align);
1021   dwarf2_append_unwinders (gdbarch);
1022   frame_unwind_append_unwinder (gdbarch, &msp430_unwind);
1023
1024   /* Dummy frames, return values.  */
1025   set_gdbarch_dummy_id (gdbarch, msp430_dummy_id);
1026   set_gdbarch_push_dummy_call (gdbarch, msp430_push_dummy_call);
1027   set_gdbarch_return_value (gdbarch, msp430_return_value);
1028
1029   /* Trampolines.  */
1030   set_gdbarch_in_solib_return_trampoline (gdbarch, msp430_in_return_stub);
1031   set_gdbarch_skip_trampoline_code (gdbarch, msp430_skip_trampoline_code);
1032
1033   /* Virtual tables.  */
1034   set_gdbarch_vbit_in_delta (gdbarch, 0);
1035
1036   return gdbarch;
1037 }
1038
1039 /* -Wmissing-prototypes */
1040 extern initialize_file_ftype _initialize_msp430_tdep;
1041
1042 /* Register the initialization routine.  */
1043
1044 void
1045 _initialize_msp430_tdep (void)
1046 {
1047   register_gdbarch_init (bfd_arch_msp430, msp430_gdbarch_init);
1048 }