gdb/msp430-tdep.c

   1 /* Target-dependent code for the Texas Instruments MSP430 for GDB, the
   2    GNU debugger.
   3
   4    Copyright (C) 2012-2016 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   if (MSP430_NUM_REGS <= regnum && regnum < MSP430_NUM_TOTAL_REGS)
 252
 253     {
 254       ULONGEST val;
 255       enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 256       int regsize = register_size (gdbarch, regnum);
 257       int raw_regnum = regnum - MSP430_NUM_REGS;
 258
 259       val = extract_unsigned_integer (buffer, regsize, byte_order);
 260       regcache_raw_write_unsigned (regcache, raw_regnum, val);
 261
 262     }
 263   else
 264     gdb_assert_not_reached ("invalid pseudo register number");
 265 }
 266
 267 /* Implement the `register_sim_regno' gdbarch method.  */
 268
 269 static int
 270 msp430_register_sim_regno (struct gdbarch *gdbarch, int regnum)
 271 {
 272   gdb_assert (regnum < MSP430_NUM_REGS);
 273
 274   /* So long as regnum is in [0, RL78_NUM_REGS), it's valid.  We
 275      just want to override the default here which disallows register
 276      numbers which have no names.  */
 277   return regnum;
 278 }
 279
 280 /* Implement the "breakpoint_from_pc" gdbarch method.  */
 281
 282 static const gdb_byte *
 283 msp430_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr,
 284                            int *lenptr)
 285 {
 286   static gdb_byte breakpoint[] = { 0x43, 0x43 };
 287
 288   *lenptr = sizeof breakpoint;
 289   return breakpoint;
 290 }
 291
 292 /* Define a "handle" struct for fetching the next opcode.  */
 293
 294 struct msp430_get_opcode_byte_handle
 295 {
 296   CORE_ADDR pc;
 297 };
 298
 299 /* Fetch a byte on behalf of the opcode decoder.  HANDLE contains
 300    the memory address of the next byte to fetch.  If successful,
 301    the address in the handle is updated and the byte fetched is
 302    returned as the value of the function.  If not successful, -1
 303    is returned.  */
 304
 305 static int
 306 msp430_get_opcode_byte (void *handle)
 307 {
 308   struct msp430_get_opcode_byte_handle *opcdata
 309     = (struct msp430_get_opcode_byte_handle *) handle;
 310   int status;
 311   gdb_byte byte;
 312
 313   status = target_read_memory (opcdata->pc, &byte, 1);
 314   if (status == 0)
 315     {
 316       opcdata->pc += 1;
 317       return byte;
 318     }
 319   else
 320     return -1;
 321 }
 322
 323 /* Function for finding saved registers in a 'struct pv_area'; this
 324    function is passed to pv_area_scan.
 325
 326    If VALUE is a saved register, ADDR says it was saved at a constant
 327    offset from the frame base, and SIZE indicates that the whole
 328    register was saved, record its offset.  */
 329
 330 static void
 331 check_for_saved (void *result_untyped, pv_t addr, CORE_ADDR size, pv_t value)
 332 {
 333   struct msp430_prologue *result = (struct msp430_prologue *) result_untyped;
 334
 335   if (value.kind == pvk_register
 336       && value.k == 0
 337       && pv_is_register (addr, MSP430_SP_REGNUM)
 338       && size == register_size (target_gdbarch (), value.reg))
 339     result->reg_offset[value.reg] = addr.k;
 340 }
 341
 342 /* Analyze a prologue starting at START_PC, going no further than
 343    LIMIT_PC.  Fill in RESULT as appropriate.  */
 344
 345 static void
 346 msp430_analyze_prologue (struct gdbarch *gdbarch, CORE_ADDR start_pc,
 347                          CORE_ADDR limit_pc, struct msp430_prologue *result)
 348 {
 349   CORE_ADDR pc, next_pc;
 350   int rn;
 351   pv_t reg[MSP430_NUM_TOTAL_REGS];
 352   struct pv_area *stack;
 353   struct cleanup *back_to;
 354   CORE_ADDR after_last_frame_setup_insn = start_pc;
 355   int code_model = gdbarch_tdep (gdbarch)->code_model;
 356   int sz;
 357
 358   memset (result, 0, sizeof (*result));
 359
 360   for (rn = 0; rn < MSP430_NUM_TOTAL_REGS; rn++)
 361     {
 362       reg[rn] = pv_register (rn, 0);
 363       result->reg_offset[rn] = 1;
 364     }
 365
 366   stack = make_pv_area (MSP430_SP_REGNUM, gdbarch_addr_bit (gdbarch));
 367   back_to = make_cleanup_free_pv_area (stack);
 368
 369   /* The call instruction has saved the return address on the stack.  */
 370   sz = code_model == MSP_LARGE_CODE_MODEL ? 4 : 2;
 371   reg[MSP430_SP_REGNUM] = pv_add_constant (reg[MSP430_SP_REGNUM], -sz);
 372   pv_area_store (stack, reg[MSP430_SP_REGNUM], sz, reg[MSP430_PC_REGNUM]);
 373
 374   pc = start_pc;
 375   while (pc < limit_pc)
 376     {
 377       int bytes_read;
 378       struct msp430_get_opcode_byte_handle opcode_handle;
 379       MSP430_Opcode_Decoded opc;
 380
 381       opcode_handle.pc = pc;
 382       bytes_read = msp430_decode_opcode (pc, &opc, msp430_get_opcode_byte,
 383                                          &opcode_handle);
 384       next_pc = pc + bytes_read;
 385
 386       if (opc.id == MSO_push && opc.op[0].type == MSP430_Operand_Register)
 387         {
 388           int rsrc = opc.op[0].reg;
 389
 390           reg[MSP430_SP_REGNUM] = pv_add_constant (reg[MSP430_SP_REGNUM], -2);
 391           pv_area_store (stack, reg[MSP430_SP_REGNUM], 2, reg[rsrc]);
 392           after_last_frame_setup_insn = next_pc;
 393         }
 394       else if (opc.id == MSO_push       /* PUSHM  */
 395                && opc.op[0].type == MSP430_Operand_None
 396                && opc.op[1].type == MSP430_Operand_Register)
 397         {
 398           int rsrc = opc.op[1].reg;
 399           int count = opc.repeats + 1;
 400           int size = opc.size == 16 ? 2 : 4;
 401
 402           while (count > 0)
 403             {
 404               reg[MSP430_SP_REGNUM]
 405                 = pv_add_constant (reg[MSP430_SP_REGNUM], -size);
 406               pv_area_store (stack, reg[MSP430_SP_REGNUM], size, reg[rsrc]);
 407               rsrc--;
 408               count--;
 409             }
 410           after_last_frame_setup_insn = next_pc;
 411         }
 412       else if (opc.id == MSO_sub
 413                && opc.op[0].type == MSP430_Operand_Register
 414                && opc.op[0].reg == MSR_SP
 415                && opc.op[1].type == MSP430_Operand_Immediate)
 416         {
 417           int addend = opc.op[1].addend;
 418
 419           reg[MSP430_SP_REGNUM] = pv_add_constant (reg[MSP430_SP_REGNUM],
 420                                                    -addend);
 421           after_last_frame_setup_insn = next_pc;
 422         }
 423       else if (opc.id == MSO_mov
 424                && opc.op[0].type == MSP430_Operand_Immediate
 425                && 12 <= opc.op[0].reg && opc.op[0].reg <= 15)
 426         after_last_frame_setup_insn = next_pc;
 427       else
 428         {
 429           /* Terminate the prologue scan.  */
 430           break;
 431         }
 432
 433       pc = next_pc;
 434     }
 435
 436   /* Is the frame size (offset, really) a known constant?  */
 437   if (pv_is_register (reg[MSP430_SP_REGNUM], MSP430_SP_REGNUM))
 438     result->frame_size = reg[MSP430_SP_REGNUM].k;
 439
 440   /* Record where all the registers were saved.  */
 441   pv_area_scan (stack, check_for_saved, result);
 442
 443   result->prologue_end = after_last_frame_setup_insn;
 444
 445   do_cleanups (back_to);
 446 }
 447
 448 /* Implement the "skip_prologue" gdbarch method.  */
 449
 450 static CORE_ADDR
 451 msp430_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
 452 {
 453   const char *name;
 454   CORE_ADDR func_addr, func_end;
 455   struct msp430_prologue p;
 456
 457   /* Try to find the extent of the function that contains PC.  */
 458   if (!find_pc_partial_function (pc, &name, &func_addr, &func_end))
 459     return pc;
 460
 461   msp430_analyze_prologue (gdbarch, pc, func_end, &p);
 462   return p.prologue_end;
 463 }
 464
 465 /* Implement the "unwind_pc" gdbarch method.  */
 466
 467 static CORE_ADDR
 468 msp430_unwind_pc (struct gdbarch *arch, struct frame_info *next_frame)
 469 {
 470   return frame_unwind_register_unsigned (next_frame, MSP430_PC_REGNUM);
 471 }
 472
 473 /* Implement the "unwind_sp" gdbarch method.  */
 474
 475 static CORE_ADDR
 476 msp430_unwind_sp (struct gdbarch *arch, struct frame_info *next_frame)
 477 {
 478   return frame_unwind_register_unsigned (next_frame, MSP430_SP_REGNUM);
 479 }
 480
 481 /* Given a frame described by THIS_FRAME, decode the prologue of its
 482    associated function if there is not cache entry as specified by
 483    THIS_PROLOGUE_CACHE.  Save the decoded prologue in the cache and
 484    return that struct as the value of this function.  */
 485
 486 static struct msp430_prologue *
 487 msp430_analyze_frame_prologue (struct frame_info *this_frame,
 488                                void **this_prologue_cache)
 489 {
 490   if (!*this_prologue_cache)
 491     {
 492       CORE_ADDR func_start, stop_addr;
 493
 494       *this_prologue_cache = FRAME_OBSTACK_ZALLOC (struct msp430_prologue);
 495
 496       func_start = get_frame_func (this_frame);
 497       stop_addr = get_frame_pc (this_frame);
 498
 499       /* If we couldn't find any function containing the PC, then
 500          just initialize the prologue cache, but don't do anything.  */
 501       if (!func_start)
 502         stop_addr = func_start;
 503
 504       msp430_analyze_prologue (get_frame_arch (this_frame), func_start,
 505                                stop_addr,
 506                                (struct msp430_prologue *) *this_prologue_cache);
 507     }
 508
 509   return (struct msp430_prologue *) *this_prologue_cache;
 510 }
 511
 512 /* Given a frame and a prologue cache, return this frame's base.  */
 513
 514 static CORE_ADDR
 515 msp430_frame_base (struct frame_info *this_frame, void **this_prologue_cache)
 516 {
 517   struct msp430_prologue *p
 518     = msp430_analyze_frame_prologue (this_frame, this_prologue_cache);
 519   CORE_ADDR sp = get_frame_register_unsigned (this_frame, MSP430_SP_REGNUM);
 520
 521   return sp - p->frame_size;
 522 }
 523
 524 /* Implement the "frame_this_id" method for unwinding frames.  */
 525
 526 static void
 527 msp430_this_id (struct frame_info *this_frame,
 528                 void **this_prologue_cache, struct frame_id *this_id)
 529 {
 530   *this_id = frame_id_build (msp430_frame_base (this_frame,
 531                                                 this_prologue_cache),
 532                              get_frame_func (this_frame));
 533 }
 534
 535 /* Implement the "frame_prev_register" method for unwinding frames.  */
 536
 537 static struct value *
 538 msp430_prev_register (struct frame_info *this_frame,
 539                       void **this_prologue_cache, int regnum)
 540 {
 541   struct msp430_prologue *p
 542     = msp430_analyze_frame_prologue (this_frame, this_prologue_cache);
 543   CORE_ADDR frame_base = msp430_frame_base (this_frame, this_prologue_cache);
 544
 545   if (regnum == MSP430_SP_REGNUM)
 546     return frame_unwind_got_constant (this_frame, regnum, frame_base);
 547
 548   /* If prologue analysis says we saved this register somewhere,
 549      return a description of the stack slot holding it.  */
 550   else if (p->reg_offset[regnum] != 1)
 551     {
 552       struct value *rv = frame_unwind_got_memory (this_frame, regnum,
 553                                                   frame_base +
 554                                                   p->reg_offset[regnum]);
 555
 556       if (regnum == MSP430_PC_REGNUM)
 557         {
 558           ULONGEST pc = value_as_long (rv);
 559
 560           return frame_unwind_got_constant (this_frame, regnum, pc);
 561         }
 562       return rv;
 563     }
 564
 565   /* Otherwise, presume we haven't changed the value of this
 566      register, and get it from the next frame.  */
 567   else
 568     return frame_unwind_got_register (this_frame, regnum, regnum);
 569 }
 570
 571 static const struct frame_unwind msp430_unwind = {
 572   NORMAL_FRAME,
 573   default_frame_unwind_stop_reason,
 574   msp430_this_id,
 575   msp430_prev_register,
 576   NULL,
 577   default_frame_sniffer
 578 };
 579
 580 /* Implement the "dwarf2_reg_to_regnum" gdbarch method.  */
 581
 582 static int
 583 msp430_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, int reg)
 584 {
 585   if (reg >= 0 && reg < MSP430_NUM_REGS)
 586     return reg + MSP430_NUM_REGS;
 587   return -1;
 588 }
 589
 590 /* Implement the "return_value" gdbarch method.  */
 591
 592 static enum return_value_convention
 593 msp430_return_value (struct gdbarch *gdbarch,
 594                      struct value *function,
 595                      struct type *valtype,
 596                      struct regcache *regcache,
 597                      gdb_byte *readbuf, const gdb_byte *writebuf)
 598 {
 599   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 600   LONGEST valtype_len = TYPE_LENGTH (valtype);
 601   int code_model = gdbarch_tdep (gdbarch)->code_model;
 602
 603   if (TYPE_LENGTH (valtype) > 8
 604       || TYPE_CODE (valtype) == TYPE_CODE_STRUCT
 605       || TYPE_CODE (valtype) == TYPE_CODE_UNION)
 606     return RETURN_VALUE_STRUCT_CONVENTION;
 607
 608   if (readbuf)
 609     {
 610       ULONGEST u;
 611       int argreg = MSP430_R12_REGNUM;
 612       int offset = 0;
 613
 614       while (valtype_len > 0)
 615         {
 616           int size = 2;
 617
 618           if (code_model == MSP_LARGE_CODE_MODEL
 619               && TYPE_CODE (valtype) == TYPE_CODE_PTR)
 620             {
 621               size = 4;
 622             }
 623
 624           regcache_cooked_read_unsigned (regcache, argreg, &u);
 625           store_unsigned_integer (readbuf + offset, size, byte_order, u);
 626           valtype_len -= size;
 627           offset += size;
 628           argreg++;
 629         }
 630     }
 631
 632   if (writebuf)
 633     {
 634       ULONGEST u;
 635       int argreg = MSP430_R12_REGNUM;
 636       int offset = 0;
 637
 638       while (valtype_len > 0)
 639         {
 640           int size = 2;
 641
 642           if (code_model == MSP_LARGE_CODE_MODEL
 643               && TYPE_CODE (valtype) == TYPE_CODE_PTR)
 644             {
 645               size = 4;
 646             }
 647
 648           u = extract_unsigned_integer (writebuf + offset, size, byte_order);
 649           regcache_cooked_write_unsigned (regcache, argreg, u);
 650           valtype_len -= size;
 651           offset += size;
 652           argreg++;
 653         }
 654     }
 655
 656   return RETURN_VALUE_REGISTER_CONVENTION;
 657 }
 658
 659
 660 /* Implement the "frame_align" gdbarch method.  */
 661
 662 static CORE_ADDR
 663 msp430_frame_align (struct gdbarch *gdbarch, CORE_ADDR sp)
 664 {
 665   return align_down (sp, 2);
 666 }
 667
 668
 669 /* Implement the "dummy_id" gdbarch method.  */
 670
 671 static struct frame_id
 672 msp430_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
 673 {
 674   return
 675     frame_id_build (get_frame_register_unsigned
 676                     (this_frame, MSP430_SP_REGNUM),
 677                     get_frame_pc (this_frame));
 678 }
 679
 680
 681 /* Implement the "push_dummy_call" gdbarch method.  */
 682
 683 static CORE_ADDR
 684 msp430_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 685                         struct regcache *regcache, CORE_ADDR bp_addr,
 686                         int nargs, struct value **args, CORE_ADDR sp,
 687                         int struct_return, CORE_ADDR struct_addr)
 688 {
 689   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 690   int write_pass;
 691   int sp_off = 0;
 692   CORE_ADDR cfa;
 693   int code_model = gdbarch_tdep (gdbarch)->code_model;
 694
 695   struct type *func_type = value_type (function);
 696
 697   /* Dereference function pointer types.  */
 698   while (TYPE_CODE (func_type) == TYPE_CODE_PTR)
 699     func_type = TYPE_TARGET_TYPE (func_type);
 700
 701   /* The end result had better be a function or a method.  */
 702   gdb_assert (TYPE_CODE (func_type) == TYPE_CODE_FUNC
 703               || TYPE_CODE (func_type) == TYPE_CODE_METHOD);
 704
 705   /* We make two passes; the first does the stack allocation,
 706      the second actually stores the arguments.  */
 707   for (write_pass = 0; write_pass <= 1; write_pass++)
 708     {
 709       int i;
 710       int arg_reg = MSP430_R12_REGNUM;
 711       int args_on_stack = 0;
 712
 713       if (write_pass)
 714         sp = align_down (sp - sp_off, 4);
 715       sp_off = 0;
 716
 717       if (struct_return)
 718         {
 719           if (write_pass)
 720             regcache_cooked_write_unsigned (regcache, arg_reg, struct_addr);
 721           arg_reg++;
 722         }
 723
 724       /* Push the arguments.  */
 725       for (i = 0; i < nargs; i++)
 726         {
 727           struct value *arg = args[i];
 728           const gdb_byte *arg_bits = value_contents_all (arg);
 729           struct type *arg_type = check_typedef (value_type (arg));
 730           ULONGEST arg_size = TYPE_LENGTH (arg_type);
 731           int offset;
 732           int current_arg_on_stack;
 733
 734           current_arg_on_stack = 0;
 735
 736           if (TYPE_CODE (arg_type) == TYPE_CODE_STRUCT
 737               || TYPE_CODE (arg_type) == TYPE_CODE_UNION)
 738             {
 739               /* Aggregates of any size are passed by reference.  */
 740               gdb_byte struct_addr[4];
 741
 742               store_unsigned_integer (struct_addr, 4, byte_order,
 743                                       value_address (arg));
 744               arg_bits = struct_addr;
 745               arg_size = (code_model == MSP_LARGE_CODE_MODEL) ? 4 : 2;
 746             }
 747           else
 748             {
 749               /* Scalars bigger than 8 bytes such as complex doubles are passed
 750                  on the stack.  */
 751               if (arg_size > 8)
 752                 current_arg_on_stack = 1;
 753             }
 754
 755
 756           for (offset = 0; offset < arg_size; offset += 2)
 757             {
 758               /* The condition below prevents 8 byte scalars from being split
 759                  between registers and memory (stack).  It also prevents other
 760                  splits once the stack has been written to.  */
 761               if (!current_arg_on_stack
 762                   && (arg_reg
 763                       + ((arg_size == 8 || args_on_stack)
 764                          ? ((arg_size - offset) / 2 - 1)
 765                          : 0) <= MSP430_R15_REGNUM))
 766                 {
 767                   int size = 2;
 768
 769                   if (code_model == MSP_LARGE_CODE_MODEL
 770                       && (TYPE_CODE (arg_type) == TYPE_CODE_PTR
 771                           || TYPE_CODE (arg_type) == TYPE_CODE_REF
 772                           || TYPE_CODE (arg_type) == TYPE_CODE_STRUCT
 773                           || TYPE_CODE (arg_type) == TYPE_CODE_UNION))
 774                     {
 775                       /* When using the large memory model, pointer,
 776                          reference, struct, and union arguments are
 777                          passed using the entire register.  (As noted
 778                          earlier, aggregates are always passed by
 779                          reference.) */
 780                       if (offset != 0)
 781                         continue;
 782                       size = 4;
 783                     }
 784
 785                   if (write_pass)
 786                     regcache_cooked_write_unsigned (regcache, arg_reg,
 787                                                     extract_unsigned_integer
 788                                                     (arg_bits + offset, size,
 789                                                      byte_order));
 790
 791                   arg_reg++;
 792                 }
 793               else
 794                 {
 795                   if (write_pass)
 796                     write_memory (sp + sp_off, arg_bits + offset, 2);
 797
 798                   sp_off += 2;
 799                   args_on_stack = 1;
 800                   current_arg_on_stack = 1;
 801                 }
 802             }
 803         }
 804     }
 805
 806   /* Keep track of the stack address prior to pushing the return address.
 807      This is the value that we'll return.  */
 808   cfa = sp;
 809
 810   /* Push the return address.  */
 811   {
 812     int sz = (gdbarch_tdep (gdbarch)->code_model == MSP_SMALL_CODE_MODEL)
 813       ? 2 : 4;
 814     sp = sp - sz;
 815     write_memory_unsigned_integer (sp, sz, byte_order, bp_addr);
 816   }
 817
 818   /* Update the stack pointer.  */
 819   regcache_cooked_write_unsigned (regcache, MSP430_SP_REGNUM, sp);
 820
 821   return cfa;
 822 }
 823
 824 /* In order to keep code size small, the compiler may create epilogue
 825    code through which more than one function epilogue is routed.  I.e.
 826    the epilogue and return may just be a branch to some common piece of
 827    code which is responsible for tearing down the frame and performing
 828    the return.  These epilog (label) names will have the common prefix
 829    defined here.  */
 830
 831 static const char msp430_epilog_name_prefix[] = "__mspabi_func_epilog_";
 832
 833 /* Implement the "in_return_stub" gdbarch method.  */
 834
 835 static int
 836 msp430_in_return_stub (struct gdbarch *gdbarch, CORE_ADDR pc,
 837                        const char *name)
 838 {
 839   return (name != NULL
 840           && startswith (name, msp430_epilog_name_prefix));
 841 }
 842
 843 /* Implement the "skip_trampoline_code" gdbarch method.  */
 844 static CORE_ADDR
 845 msp430_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
 846 {
 847   struct bound_minimal_symbol bms;
 848   const char *stub_name;
 849   struct gdbarch *gdbarch = get_frame_arch (frame);
 850
 851   bms = lookup_minimal_symbol_by_pc (pc);
 852   if (!bms.minsym)
 853     return pc;
 854
 855   stub_name = MSYMBOL_LINKAGE_NAME (bms.minsym);
 856
 857   if (gdbarch_tdep (gdbarch)->code_model == MSP_SMALL_CODE_MODEL
 858       && msp430_in_return_stub (gdbarch, pc, stub_name))
 859     {
 860       CORE_ADDR sp = get_frame_register_unsigned (frame, MSP430_SP_REGNUM);
 861
 862       return read_memory_integer
 863         (sp + 2 * (stub_name[strlen (msp430_epilog_name_prefix)] - '0'),
 864          2, gdbarch_byte_order (gdbarch));
 865     }
 866
 867   return pc;
 868 }
 869
 870 /* Allocate and initialize a gdbarch object.  */
 871
 872 static struct gdbarch *
 873 msp430_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 874 {
 875   struct gdbarch *gdbarch;
 876   struct gdbarch_tdep *tdep;
 877   int elf_flags, isa, code_model;
 878
 879   /* Extract the elf_flags if available.  */
 880   if (info.abfd != NULL
 881       && bfd_get_flavour (info.abfd) == bfd_target_elf_flavour)
 882     elf_flags = elf_elfheader (info.abfd)->e_flags;
 883   else
 884     elf_flags = 0;
 885
 886   if (info.abfd != NULL)
 887     switch (bfd_elf_get_obj_attr_int (info.abfd, OBJ_ATTR_PROC,
 888                                       OFBA_MSPABI_Tag_ISA))
 889       {
 890       case 1:
 891         isa = MSP_ISA_MSP430;
 892         code_model = MSP_SMALL_CODE_MODEL;
 893         break;
 894       case 2:
 895         isa = MSP_ISA_MSP430X;
 896         switch (bfd_elf_get_obj_attr_int (info.abfd, OBJ_ATTR_PROC,
 897                                           OFBA_MSPABI_Tag_Code_Model))
 898           {
 899           case 1:
 900             code_model = MSP_SMALL_CODE_MODEL;
 901             break;
 902           case 2:
 903             code_model = MSP_LARGE_CODE_MODEL;
 904             break;
 905           default:
 906             internal_error (__FILE__, __LINE__,
 907                             _("Unknown msp430x code memory model"));
 908             break;
 909           }
 910         break;
 911       case 0:
 912         /* This can happen when loading a previously dumped data structure.
 913            Use the ISA and code model from the current architecture, provided
 914            it's compatible.  */
 915         {
 916           struct gdbarch *ca = get_current_arch ();
 917           if (ca && gdbarch_bfd_arch_info (ca)->arch == bfd_arch_msp430)
 918             {
 919               struct gdbarch_tdep *ca_tdep = gdbarch_tdep (ca);
 920
 921               elf_flags = ca_tdep->elf_flags;
 922               isa = ca_tdep->isa;
 923               code_model = ca_tdep->code_model;
 924               break;
 925             }
 926           /* Otherwise, fall through...  */
 927         }
 928       default:
 929         error (_("Unknown msp430 isa"));
 930         break;
 931       }
 932   else
 933     {
 934       isa = MSP_ISA_MSP430;
 935       code_model = MSP_SMALL_CODE_MODEL;
 936     }
 937
 938
 939   /* Try to find the architecture in the list of already defined
 940      architectures.  */
 941   for (arches = gdbarch_list_lookup_by_info (arches, &info);
 942        arches != NULL;
 943        arches = gdbarch_list_lookup_by_info (arches->next, &info))
 944     {
 945       struct gdbarch_tdep *candidate_tdep = gdbarch_tdep (arches->gdbarch);
 946
 947       if (candidate_tdep->elf_flags != elf_flags
 948           || candidate_tdep->isa != isa
 949           || candidate_tdep->code_model != code_model)
 950         continue;
 951
 952       return arches->gdbarch;
 953     }
 954
 955   /* None found, create a new architecture from the information
 956      provided.  */
 957   tdep = XNEW (struct gdbarch_tdep);
 958   gdbarch = gdbarch_alloc (&info, tdep);
 959   tdep->elf_flags = elf_flags;
 960   tdep->isa = isa;
 961   tdep->code_model = code_model;
 962
 963   /* Registers.  */
 964   set_gdbarch_num_regs (gdbarch, MSP430_NUM_REGS);
 965   set_gdbarch_num_pseudo_regs (gdbarch, MSP430_NUM_PSEUDO_REGS);
 966   set_gdbarch_register_name (gdbarch, msp430_register_name);
 967   if (isa == MSP_ISA_MSP430)
 968     set_gdbarch_register_type (gdbarch, msp430_register_type);
 969   else
 970     set_gdbarch_register_type (gdbarch, msp430x_register_type);
 971   set_gdbarch_pc_regnum (gdbarch, MSP430_PC_REGNUM);
 972   set_gdbarch_sp_regnum (gdbarch, MSP430_SP_REGNUM);
 973   set_gdbarch_register_reggroup_p (gdbarch, msp430_register_reggroup_p);
 974   set_gdbarch_pseudo_register_read (gdbarch, msp430_pseudo_register_read);
 975   set_gdbarch_pseudo_register_write (gdbarch, msp430_pseudo_register_write);
 976   set_gdbarch_dwarf2_reg_to_regnum (gdbarch, msp430_dwarf2_reg_to_regnum);
 977   set_gdbarch_register_sim_regno (gdbarch, msp430_register_sim_regno);
 978
 979   /* Data types.  */
 980   set_gdbarch_char_signed (gdbarch, 0);
 981   set_gdbarch_short_bit (gdbarch, 16);
 982   set_gdbarch_int_bit (gdbarch, 16);
 983   set_gdbarch_long_bit (gdbarch, 32);
 984   set_gdbarch_long_long_bit (gdbarch, 64);
 985   if (code_model == MSP_SMALL_CODE_MODEL)
 986     {
 987       set_gdbarch_ptr_bit (gdbarch, 16);
 988       set_gdbarch_addr_bit (gdbarch, 16);
 989     }
 990   else                          /* MSP_LARGE_CODE_MODEL */
 991     {
 992       set_gdbarch_ptr_bit (gdbarch, 32);
 993       set_gdbarch_addr_bit (gdbarch, 32);
 994     }
 995   set_gdbarch_dwarf2_addr_size (gdbarch, 4);
 996   set_gdbarch_float_bit (gdbarch, 32);
 997   set_gdbarch_float_format (gdbarch, floatformats_ieee_single);
 998   set_gdbarch_double_bit (gdbarch, 64);
 999   set_gdbarch_long_double_bit (gdbarch, 64);
1000   set_gdbarch_double_format (gdbarch, floatformats_ieee_double);
1001   set_gdbarch_long_double_format (gdbarch, floatformats_ieee_double);
1002
1003   /* Breakpoints.  */
1004   set_gdbarch_breakpoint_from_pc (gdbarch, msp430_breakpoint_from_pc);
1005   set_gdbarch_decr_pc_after_break (gdbarch, 1);
1006
1007   /* Disassembly.  */
1008   set_gdbarch_print_insn (gdbarch, print_insn_msp430);
1009
1010   /* Frames, prologues, etc.  */
1011   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1012   set_gdbarch_skip_prologue (gdbarch, msp430_skip_prologue);
1013   set_gdbarch_unwind_pc (gdbarch, msp430_unwind_pc);
1014   set_gdbarch_unwind_sp (gdbarch, msp430_unwind_sp);
1015   set_gdbarch_frame_align (gdbarch, msp430_frame_align);
1016   dwarf2_append_unwinders (gdbarch);
1017   frame_unwind_append_unwinder (gdbarch, &msp430_unwind);
1018
1019   /* Dummy frames, return values.  */
1020   set_gdbarch_dummy_id (gdbarch, msp430_dummy_id);
1021   set_gdbarch_push_dummy_call (gdbarch, msp430_push_dummy_call);
1022   set_gdbarch_return_value (gdbarch, msp430_return_value);
1023
1024   /* Trampolines.  */
1025   set_gdbarch_in_solib_return_trampoline (gdbarch, msp430_in_return_stub);
1026   set_gdbarch_skip_trampoline_code (gdbarch, msp430_skip_trampoline_code);
1027
1028   /* Virtual tables.  */
1029   set_gdbarch_vbit_in_delta (gdbarch, 0);
1030
1031   return gdbarch;
1032 }
1033
1034 /* -Wmissing-prototypes */
1035 extern initialize_file_ftype _initialize_msp430_tdep;
1036
1037 /* Register the initialization routine.  */
1038
1039 void
1040 _initialize_msp430_tdep (void)
1041 {
1042   register_gdbarch_init (bfd_arch_msp430, msp430_gdbarch_init);
1043 }