gdb/msp430-tdep.c

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