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