gdb/msp430-tdep.c

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