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