gdb/msp430-tdep.c - gdb

Global variables defined

Data types defined

Functions defined

Source code

  1. /* Target-dependent code for the Texas Instruments MSP430 for GDB, the
  2.    GNU debugger.

  4.    Copyright (C) 2012-2015 Free Software Foundation, Inc.

  6.    Contributed by Red Hat, Inc.

  8.    This file is part of GDB.

  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.

  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.

  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/>.  */

  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"

  38. #include "elf/msp430.h"
  39. #include "opcode/msp430-decode.h"
  40. #include "elf-bfd.h"

  42. /* Register Numbers.  */

  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,

  63.   MSP430_NUM_REGS,

  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,

  82.   MSP430_NUM_TOTAL_REGS,
  83.   MSP430_NUM_PSEUDO_REGS = MSP430_NUM_TOTAL_REGS - MSP430_NUM_REGS
  84. };

  86. enum
  87. {
  88.   /* TI MSP430 Architecture.  */
  89.   MSP_ISA_MSP430,

  91.   /* TI MSP430X Architecture.  */
  92.   MSP_ISA_MSP430X
  93. };

  95. enum
  96. {
  97.   /* The small code model limits code addresses to 16 bits.  */
  98.   MSP_SMALL_CODE_MODEL,

  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. };

  105. /* Architecture specific data.  */

  107. ‌struct gdbarch_tdep
  108. {
  109.   /* The ELF header flags specify the multilib used.  */
  110.   int elf_flags;

  112.   /* One of MSP_ISA_MSP430 or MSP_ISA_MSP430X.  */
  113.   int isa;

  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. };

  122. /* This structure holds the results of a prologue analysis.  */

  124. ‌struct msp430_prologue
  125. {
  126.   /* The offset from the frame base to the stack pointer --- always
  127.      zero or negative.

  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;

  137.   /* Non-zero if this function has initialized the frame pointer from
  138.      the stack pointer, zero otherwise.  */
  139.   int has_frame_ptr;

  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;

  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;

  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. };

  157. /* Implement the "register_type" gdbarch method.  */

  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. }

  170. /* Implement another version of the "register_type" gdbarch method
  171.    for msp430x.  */

  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. }

  184. /* Implement the "register_name" gdbarch method.  */

  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.   };

  198.   return reg_names[regnr];
  199. }

  201. /* Implement the "register_reggroup_p" gdbarch method.  */

  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;

  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);

  214.   return group == general_reggroup;
  215. }

  217. /* Implement the "pseudo_register_read" gdbarch method.  */

  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;

  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;

  233.       status = regcache_raw_read_unsigned (regcache, raw_regnum, &val);
  234.       if (status == REG_VALID)
  235.         store_unsigned_integer (buffer, regsize, byte_order, val);

  237.     }
  238.   else
  239.     gdb_assert_not_reached ("invalid pseudo register number");

  241.   return status;
  242. }

  244. /* Implement the "pseudo_register_write" gdbarch method.  */

  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)

  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;

  260.       val = extract_unsigned_integer (buffer, regsize, byte_order);
  261.       regcache_raw_write_unsigned (regcache, raw_regnum, val);

  263.     }
  264.   else
  265.     gdb_assert_not_reached ("invalid pseudo register number");
  266. }

  268. /* Implement the `register_sim_regno' gdbarch method.  */

  270. static int
  271. ‌msp430_register_sim_regno (struct gdbarch *gdbarch, int regnum)
  272. {
  273.   gdb_assert (regnum < MSP430_NUM_REGS);

  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. }

  281. /* Implement the "breakpoint_from_pc" gdbarch method.  */

  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 };

  289.   *lenptr = sizeof breakpoint;
  290.   return breakpoint;
  291. }

  293. /* Define a "handle" struct for fetching the next opcode.  */

  295. ‌struct msp430_get_opcode_byte_handle
  296. {
  297.   CORE_ADDR pc;
  298. };

  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.  */

  306. static int
  307. ‌msp430_get_opcode_byte (void *handle)
  308. {
  309.   struct msp430_get_opcode_byte_handle *opcdata = handle;
  310.   int status;
  311.   gdb_byte byte;

  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. }

  323. /* Function for finding saved registers in a 'struct pv_area'; this
  324.    function is passed to pv_area_scan.

  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.  */

  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;

  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. }

  342. /* Analyze a prologue starting at START_PC, going no further than
  343.    LIMIT_PC.  Fill in RESULT as appropriate.  */

  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;

  358.   memset (result, 0, sizeof (*result));

  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.     }

  366.   stack = make_pv_area (MSP430_SP_REGNUM, gdbarch_addr_bit (gdbarch));
  367.   back_to = make_cleanup_free_pv_area (stack);

  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]);

  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;

  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;

  386.       if (opc.id == MSO_push && opc.op[0].type == MSP430_Operand_Register)
  387.         {
  388.           int rsrc = opc.op[0].reg;

  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;

  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;

  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.         }

  433.       pc = next_pc;
  434.     }

  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;

  440.   /* Record where all the registers were saved.  */
  441.   pv_area_scan (stack, check_for_saved, result);

  443.   result->prologue_end = after_last_frame_setup_insn;

  445.   do_cleanups (back_to);
  446. }

  448. /* Implement the "skip_prologue" gdbarch method.  */

  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;

  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;

  461.   msp430_analyze_prologue (gdbarch, pc, func_end, &p);
  462.   return p.prologue_end;
  463. }

  465. /* Implement the "unwind_pc" gdbarch method.  */

  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. }

  473. /* Implement the "unwind_sp" gdbarch method.  */

  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. }

  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.  */

  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;

  494.       *this_prologue_cache = FRAME_OBSTACK_ZALLOC (struct msp430_prologue);

  496.       func_start = get_frame_func (this_frame);
  497.       stop_addr = get_frame_pc (this_frame);

  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;

  504.       msp430_analyze_prologue (get_frame_arch (this_frame), func_start,
  505.                                stop_addr, *this_prologue_cache);
  506.     }

  508.   return *this_prologue_cache;
  509. }

  511. /* Given a frame and a prologue cache, return this frame's base.  */

  513. static CORE_ADDR
  514. ‌msp430_frame_base (struct frame_info *this_frame, void **this_prologue_cache)
  515. {
  516.   struct msp430_prologue *p
  517.     = msp430_analyze_frame_prologue (this_frame, this_prologue_cache);
  518.   CORE_ADDR sp = get_frame_register_unsigned (this_frame, MSP430_SP_REGNUM);

  520.   return sp - p->frame_size;
  521. }

  523. /* Implement the "frame_this_id" method for unwinding frames.  */

  525. static void
  526. ‌msp430_this_id (struct frame_info *this_frame,
  527.                 void **this_prologue_cache, struct frame_id *this_id)
  528. {
  529.   *this_id = frame_id_build (msp430_frame_base (this_frame,
  530.                                                 this_prologue_cache),
  531.                              get_frame_func (this_frame));
  532. }

  534. /* Implement the "frame_prev_register" method for unwinding frames.  */

  536. static struct value *
  537. ‌msp430_prev_register (struct frame_info *this_frame,
  538.                       void **this_prologue_cache, int regnum)
  539. {
  540.   struct msp430_prologue *p
  541.     = msp430_analyze_frame_prologue (this_frame, this_prologue_cache);
  542.   CORE_ADDR frame_base = msp430_frame_base (this_frame, this_prologue_cache);

  544.   if (regnum == MSP430_SP_REGNUM)
  545.     return frame_unwind_got_constant (this_frame, regnum, frame_base);

  547.   /* If prologue analysis says we saved this register somewhere,
  548.      return a description of the stack slot holding it.  */
  549.   else if (p->reg_offset[regnum] != 1)
  550.     {
  551.       struct value *rv = frame_unwind_got_memory (this_frame, regnum,
  552.                                                   frame_base +
  553.                                                   p->reg_offset[regnum]);

  555.       if (regnum == MSP430_PC_REGNUM)
  556.         {
  557.           ULONGEST pc = value_as_long (rv);

  559.           return frame_unwind_got_constant (this_frame, regnum, pc);
  560.         }
  561.       return rv;
  562.     }

  564.   /* Otherwise, presume we haven't changed the value of this
  565.      register, and get it from the next frame.  */
  566.   else
  567.     return frame_unwind_got_register (this_frame, regnum, regnum);
  568. }

  570. ‌static const struct frame_unwind msp430_unwind = {
  571.   NORMAL_FRAME,
  572.   default_frame_unwind_stop_reason,
  573.   msp430_this_id,
  574.   msp430_prev_register,
  575.   NULL,
  576.   default_frame_sniffer
  577. };

  579. /* Implement the "dwarf2_reg_to_regnum" gdbarch method.  */

  581. static int
  582. ‌msp430_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, int reg)
  583. {
  584.   if (reg < MSP430_NUM_REGS)
  585.     return reg + MSP430_NUM_REGS;
  586.   else
  587.     {
  588.       warning (_("Unmapped DWARF Register #%d encountered."), reg);
  589.       return -1;
  590.     }
  591. }

  593. /* Implement the "return_value" gdbarch method.  */

  595. static enum return_value_convention
  596. ‌msp430_return_value (struct gdbarch *gdbarch,
  597.                      struct value *function,
  598.                      struct type *valtype,
  599.                      struct regcache *regcache,
  600.                      gdb_byte *readbuf, const gdb_byte *writebuf)
  601. {
  602.   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  603.   LONGEST valtype_len = TYPE_LENGTH (valtype);
  604.   int code_model = gdbarch_tdep (gdbarch)->code_model;

  606.   if (TYPE_LENGTH (valtype) > 8
  607.       || TYPE_CODE (valtype) == TYPE_CODE_STRUCT
  608.       || TYPE_CODE (valtype) == TYPE_CODE_UNION)
  609.     return RETURN_VALUE_STRUCT_CONVENTION;

  611.   if (readbuf)
  612.     {
  613.       ULONGEST u;
  614.       int argreg = MSP430_R12_REGNUM;
  615.       int offset = 0;

  617.       while (valtype_len > 0)
  618.         {
  619.           int size = 2;

  621.           if (code_model == MSP_LARGE_CODE_MODEL
  622.               && TYPE_CODE (valtype) == TYPE_CODE_PTR)
  623.             {
  624.               size = 4;
  625.             }

  627.           regcache_cooked_read_unsigned (regcache, argreg, &u);
  628.           store_unsigned_integer (readbuf + offset, size, byte_order, u);
  629.           valtype_len -= size;
  630.           offset += size;
  631.           argreg++;
  632.         }
  633.     }

  635.   if (writebuf)
  636.     {
  637.       ULONGEST u;
  638.       int argreg = MSP430_R12_REGNUM;
  639.       int offset = 0;

  641.       while (valtype_len > 0)
  642.         {
  643.           int size = 2;

  645.           if (code_model == MSP_LARGE_CODE_MODEL
  646.               && TYPE_CODE (valtype) == TYPE_CODE_PTR)
  647.             {
  648.               size = 4;
  649.             }

  651.           u = extract_unsigned_integer (writebuf + offset, size, byte_order);
  652.           regcache_cooked_write_unsigned (regcache, argreg, u);
  653.           valtype_len -= size;
  654.           offset += size;
  655.           argreg++;
  656.         }
  657.     }

  659.   return RETURN_VALUE_REGISTER_CONVENTION;
  660. }


  663. /* Implement the "frame_align" gdbarch method.  */

  665. static CORE_ADDR
  666. ‌msp430_frame_align (struct gdbarch *gdbarch, CORE_ADDR sp)
  667. {
  668.   return align_down (sp, 2);
  669. }


  672. /* Implement the "dummy_id" gdbarch method.  */

  674. static struct frame_id
  675. ‌msp430_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
  676. {
  677.   return
  678.     frame_id_build (get_frame_register_unsigned
  679.                     (this_frame, MSP430_SP_REGNUM),
  680.                     get_frame_pc (this_frame));
  681. }


  684. /* Implement the "push_dummy_call" gdbarch method.  */

  686. static CORE_ADDR
  687. ‌msp430_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
  688.                         struct regcache *regcache, CORE_ADDR bp_addr,
  689.                         int nargs, struct value **args, CORE_ADDR sp,
  690.                         int struct_return, CORE_ADDR struct_addr)
  691. {
  692.   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  693.   int write_pass;
  694.   int sp_off = 0;
  695.   CORE_ADDR cfa;
  696.   int code_model = gdbarch_tdep (gdbarch)->code_model;

  698.   struct type *func_type = value_type (function);

  700.   /* Dereference function pointer types.  */
  701.   while (TYPE_CODE (func_type) == TYPE_CODE_PTR)
  702.     func_type = TYPE_TARGET_TYPE (func_type);

  704.   /* The end result had better be a function or a method.  */
  705.   gdb_assert (TYPE_CODE (func_type) == TYPE_CODE_FUNC
  706.               || TYPE_CODE (func_type) == TYPE_CODE_METHOD);

  708.   /* We make two passes; the first does the stack allocation,
  709.      the second actually stores the arguments.  */
  710.   for (write_pass = 0; write_pass <= 1; write_pass++)
  711.     {
  712.       int i;
  713.       int arg_reg = MSP430_R12_REGNUM;
  714.       int args_on_stack = 0;

  716.       if (write_pass)
  717.         sp = align_down (sp - sp_off, 4);
  718.       sp_off = 0;

  720.       if (struct_return)
  721.         {
  722.           if (write_pass)
  723.             regcache_cooked_write_unsigned (regcache, arg_reg, struct_addr);
  724.           arg_reg++;
  725.         }

  727.       /* Push the arguments.  */
  728.       for (i = 0; i < nargs; i++)
  729.         {
  730.           struct value *arg = args[i];
  731.           const gdb_byte *arg_bits = value_contents_all (arg);
  732.           struct type *arg_type = check_typedef (value_type (arg));
  733.           ULONGEST arg_size = TYPE_LENGTH (arg_type);
  734.           int offset;
  735.           int current_arg_on_stack;

  737.           current_arg_on_stack = 0;

  739.           if (TYPE_CODE (arg_type) == TYPE_CODE_STRUCT
  740.               || TYPE_CODE (arg_type) == TYPE_CODE_UNION)
  741.             {
  742.               /* Aggregates of any size are passed by reference.  */
  743.               gdb_byte struct_addr[4];

  745.               store_unsigned_integer (struct_addr, 4, byte_order,
  746.                                       value_address (arg));
  747.               arg_bits = struct_addr;
  748.               arg_size = (code_model == MSP_LARGE_CODE_MODEL) ? 4 : 2;
  749.             }
  750.           else
  751.             {
  752.               /* Scalars bigger than 8 bytes such as complex doubles are passed
  753.                  on the stack.  */
  754.               if (arg_size > 8)
  755.                 current_arg_on_stack = 1;
  756.             }


  759.           for (offset = 0; offset < arg_size; offset += 2)
  760.             {
  761.               /* The condition below prevents 8 byte scalars from being split
  762.                  between registers and memory (stack).  It also prevents other
  763.                  splits once the stack has been written to.  */
  764.               if (!current_arg_on_stack
  765.                   && (arg_reg
  766.                       + ((arg_size == 8 || args_on_stack)
  767.                          ? ((arg_size - offset) / 2 - 1)
  768.                          : 0) <= MSP430_R15_REGNUM))
  769.                 {
  770.                   int size = 2;

  772.                   if (code_model == MSP_LARGE_CODE_MODEL
  773.                       && TYPE_CODE (arg_type) == TYPE_CODE_PTR)
  774.                     {
  775.                       /* Pointer arguments using large memory model are passed
  776.                          using entire register.  */
  777.                       if (offset != 0)
  778.                         continue;
  779.                       size = 4;
  780.                     }

  782.                   if (write_pass)
  783.                     regcache_cooked_write_unsigned (regcache, arg_reg,
  784.                                                     extract_unsigned_integer
  785.                                                     (arg_bits + offset, size,
  786.                                                      byte_order));

  788.                   arg_reg++;
  789.                 }
  790.               else
  791.                 {
  792.                   if (write_pass)
  793.                     write_memory (sp + sp_off, arg_bits + offset, 2);

  795.                   sp_off += 2;
  796.                   args_on_stack = 1;
  797.                   current_arg_on_stack = 1;
  798.                 }
  799.             }
  800.         }
  801.     }

  803.   /* Keep track of the stack address prior to pushing the return address.
  804.      This is the value that we'll return.  */
  805.   cfa = sp;

  807.   /* Push the return address.  */
  808.   {
  809.     int sz = (gdbarch_tdep (gdbarch)->code_model == MSP_SMALL_CODE_MODEL)
  810.       ? 2 : 4;
  811.     sp = sp - sz;
  812.     write_memory_unsigned_integer (sp, sz, byte_order, bp_addr);
  813.   }

  815.   /* Update the stack pointer.  */
  816.   regcache_cooked_write_unsigned (regcache, MSP430_SP_REGNUM, sp);

  818.   return cfa;
  819. }

  821. /* In order to keep code size small, the compiler may create epilogue
  822.    code through which more than one function epilogue is routed.  I.e.
  823.    the epilogue and return may just be a branch to some common piece of
  824.    code which is responsible for tearing down the frame and performing
  825.    the return.  These epilog (label) names will have the common prefix
  826.    defined here.  */

  828. ‌static const char msp430_epilog_name_prefix[] = "__mspabi_func_epilog_";

  830. /* Implement the "in_return_stub" gdbarch method.  */

  832. static int
  833. ‌msp430_in_return_stub (struct gdbarch *gdbarch, CORE_ADDR pc,
  834.                        const char *name)
  835. {
  836.   return (name != NULL
  837.           && strncmp (msp430_epilog_name_prefix, name,
  838.                       strlen (msp430_epilog_name_prefix)) == 0);
  839. }

  841. /* Implement the "skip_trampoline_code" gdbarch method.  */
  842. static CORE_ADDR
  843. ‌msp430_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
  844. {
  845.   struct bound_minimal_symbol bms;
  846.   const char *stub_name;
  847.   struct gdbarch *gdbarch = get_frame_arch (frame);

  849.   bms = lookup_minimal_symbol_by_pc (pc);
  850.   if (!bms.minsym)
  851.     return pc;

  853.   stub_name = MSYMBOL_LINKAGE_NAME (bms.minsym);

  855.   if (gdbarch_tdep (gdbarch)->code_model == MSP_SMALL_CODE_MODEL
  856.       && msp430_in_return_stub (gdbarch, pc, stub_name))
  857.     {
  858.       CORE_ADDR sp = get_frame_register_unsigned (frame, MSP430_SP_REGNUM);

  860.       return read_memory_integer
  861.         (sp + 2 * (stub_name[strlen (msp430_epilog_name_prefix)] - '0'),
  862.          2, gdbarch_byte_order (gdbarch));
  863.     }

  865.   return pc;
  866. }

  868. /* Allocate and initialize a gdbarch object.  */

  870. static struct gdbarch *
  871. ‌msp430_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
  872. {
  873.   struct gdbarch *gdbarch;
  874.   struct gdbarch_tdep *tdep;
  875.   int elf_flags, isa, code_model;

  877.   /* Extract the elf_flags if available.  */
  878.   if (info.abfd != NULL
  879.       && bfd_get_flavour (info.abfd) == bfd_target_elf_flavour)
  880.     elf_flags = elf_elfheader (info.abfd)->e_flags;
  881.   else
  882.     elf_flags = 0;

  884.   if (info.abfd != NULL)
  885.     switch (bfd_elf_get_obj_attr_int (info.abfd, OBJ_ATTR_PROC,
  886.                                       OFBA_MSPABI_Tag_ISA))
  887.       {
  888.       case 1:
  889.         isa = MSP_ISA_MSP430;
  890.         code_model = MSP_SMALL_CODE_MODEL;
  891.         break;
  892.       case 2:
  893.         isa = MSP_ISA_MSP430X;
  894.         switch (bfd_elf_get_obj_attr_int (info.abfd, OBJ_ATTR_PROC,
  895.                                           OFBA_MSPABI_Tag_Code_Model))
  896.           {
  897.           case 1:
  898.             code_model = MSP_SMALL_CODE_MODEL;
  899.             break;
  900.           case 2:
  901.             code_model = MSP_LARGE_CODE_MODEL;
  902.             break;
  903.           default:
  904.             internal_error (__FILE__, __LINE__,
  905.                             _("Unknown msp430x code memory model"));
  906.             break;
  907.           }
  908.         break;
  909.       case 0:
  910.         /* This can happen when loading a previously dumped data structure.
  911.            Use the ISA and code model from the current architecture, provided
  912.            it's compatible.  */
  913.         {
  914.           struct gdbarch *ca = get_current_arch ();
  915.           if (ca && gdbarch_bfd_arch_info (ca)->arch == bfd_arch_msp430)
  916.             {
  917.               struct gdbarch_tdep *ca_tdep = gdbarch_tdep (ca);

  919.               elf_flags = ca_tdep->elf_flags;
  920.               isa = ca_tdep->isa;
  921.               code_model = ca_tdep->code_model;
  922.               break;
  923.             }
  924.           /* Otherwise, fall through...  */
  925.         }
  926.       default:
  927.         error (_("Unknown msp430 isa"));
  928.         break;
  929.       }
  930.   else
  931.     {
  932.       isa = MSP_ISA_MSP430;
  933.       code_model = MSP_SMALL_CODE_MODEL;
  934.     }


  937.   /* Try to find the architecture in the list of already defined
  938.      architectures.  */
  939.   for (arches = gdbarch_list_lookup_by_info (arches, &info);
  940.        arches != NULL;
  941.        arches = gdbarch_list_lookup_by_info (arches->next, &info))
  942.     {
  943.       struct gdbarch_tdep *candidate_tdep = gdbarch_tdep (arches->gdbarch);

  945.       if (candidate_tdep->elf_flags != elf_flags
  946.           || candidate_tdep->isa != isa
  947.           || candidate_tdep->code_model != code_model)
  948.         continue;

  950.       return arches->gdbarch;
  951.     }

  953.   /* None found, create a new architecture from the information
  954.      provided.  */
  955.   tdep = (struct gdbarch_tdep *) xmalloc (sizeof (struct gdbarch_tdep));
  956.   gdbarch = gdbarch_alloc (&info, tdep);
  957.   tdep->elf_flags = elf_flags;
  958.   tdep->isa = isa;
  959.   tdep->code_model = code_model;

  961.   /* Registers.  */
  962.   set_gdbarch_num_regs (gdbarch, MSP430_NUM_REGS);
  963.   set_gdbarch_num_pseudo_regs (gdbarch, MSP430_NUM_PSEUDO_REGS);
  964.   set_gdbarch_register_name (gdbarch, msp430_register_name);
  965.   if (isa == MSP_ISA_MSP430)
  966.     set_gdbarch_register_type (gdbarch, msp430_register_type);
  967.   else
  968.     set_gdbarch_register_type (gdbarch, msp430x_register_type);
  969.   set_gdbarch_pc_regnum (gdbarch, MSP430_PC_REGNUM);
  970.   set_gdbarch_sp_regnum (gdbarch, MSP430_SP_REGNUM);
  971.   set_gdbarch_register_reggroup_p (gdbarch, msp430_register_reggroup_p);
  972.   set_gdbarch_pseudo_register_read (gdbarch, msp430_pseudo_register_read);
  973.   set_gdbarch_pseudo_register_write (gdbarch, msp430_pseudo_register_write);
  974.   set_gdbarch_dwarf2_reg_to_regnum (gdbarch, msp430_dwarf2_reg_to_regnum);
  975.   set_gdbarch_register_sim_regno (gdbarch, msp430_register_sim_regno);

  977.   /* Data types.  */
  978.   set_gdbarch_char_signed (gdbarch, 0);
  979.   set_gdbarch_short_bit (gdbarch, 16);
  980.   set_gdbarch_int_bit (gdbarch, 16);
  981.   set_gdbarch_long_bit (gdbarch, 32);
  982.   set_gdbarch_long_long_bit (gdbarch, 64);
  983.   if (code_model == MSP_SMALL_CODE_MODEL)
  984.     {
  985.       set_gdbarch_ptr_bit (gdbarch, 16);
  986.       set_gdbarch_addr_bit (gdbarch, 16);
  987.     }
  988.   else                                /* MSP_LARGE_CODE_MODEL */
  989.     {
  990.       set_gdbarch_ptr_bit (gdbarch, 32);
  991.       set_gdbarch_addr_bit (gdbarch, 32);
  992.     }
  993.   set_gdbarch_dwarf2_addr_size (gdbarch, 4);
  994.   set_gdbarch_float_bit (gdbarch, 32);
  995.   set_gdbarch_float_format (gdbarch, floatformats_ieee_single);
  996.   set_gdbarch_double_bit (gdbarch, 64);
  997.   set_gdbarch_long_double_bit (gdbarch, 64);
  998.   set_gdbarch_double_format (gdbarch, floatformats_ieee_double);
  999.   set_gdbarch_long_double_format (gdbarch, floatformats_ieee_double);

  1001.   /* Breakpoints.  */
  1002.   set_gdbarch_breakpoint_from_pc (gdbarch, msp430_breakpoint_from_pc);
  1003.   set_gdbarch_decr_pc_after_break (gdbarch, 1);

  1005.   /* Disassembly.  */
  1006.   set_gdbarch_print_insn (gdbarch, print_insn_msp430);

  1008.   /* Frames, prologues, etc.  */
  1009.   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
  1010.   set_gdbarch_skip_prologue (gdbarch, msp430_skip_prologue);
  1011.   set_gdbarch_unwind_pc (gdbarch, msp430_unwind_pc);
  1012.   set_gdbarch_unwind_sp (gdbarch, msp430_unwind_sp);
  1013.   set_gdbarch_frame_align (gdbarch, msp430_frame_align);
  1014.   dwarf2_append_unwinders (gdbarch);
  1015.   frame_unwind_append_unwinder (gdbarch, &msp430_unwind);

  1017.   /* Dummy frames, return values.  */
  1018.   set_gdbarch_dummy_id (gdbarch, msp430_dummy_id);
  1019.   set_gdbarch_push_dummy_call (gdbarch, msp430_push_dummy_call);
  1020.   set_gdbarch_return_value (gdbarch, msp430_return_value);

  1022.   /* Trampolines.  */
  1023.   set_gdbarch_in_solib_return_trampoline (gdbarch, msp430_in_return_stub);
  1024.   set_gdbarch_skip_trampoline_code (gdbarch, msp430_skip_trampoline_code);

  1026.   /* Virtual tables.  */
  1027.   set_gdbarch_vbit_in_delta (gdbarch, 0);

  1029.   return gdbarch;
  1030. }

  1032. /* -Wmissing-prototypes */
  1033. extern initialize_file_ftype _initialize_msp430_tdep;

  1035. /* Register the initialization routine.  */

  1037. void
  1038. ‌_initialize_msp430_tdep (void)
  1039. {
  1040.   register_gdbarch_init (bfd_arch_msp430, msp430_gdbarch_init);
  1041. }