1 /* Target-dependent code for the Texas Instruments MSP430 for GDB, the
4 Copyright (C) 2012-2021 Free Software Foundation, Inc.
6 Contributed by Red Hat, Inc.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "arch-utils.h"
25 #include "prologue-value.h"
31 #include "frame-unwind.h"
32 #include "frame-base.h"
35 #include "dwarf2/frame.h"
36 #include "reggroups.h"
38 #include "elf/msp430.h"
39 #include "opcode/msp430-decode.h"
42 /* Register Numbers. */
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
,
65 MSP430_PC_REGNUM
= MSP430_NUM_REGS
,
82 MSP430_NUM_TOTAL_REGS
,
83 MSP430_NUM_PSEUDO_REGS
= MSP430_NUM_TOTAL_REGS
- MSP430_NUM_REGS
88 /* TI MSP430 Architecture. */
91 /* TI MSP430X Architecture. */
97 /* The small code model limits code addresses to 16 bits. */
100 /* The large code model uses 20 bit addresses for function
101 pointers. These are stored in memory using four bytes (32 bits). */
105 /* Architecture specific data. */
109 /* The ELF header flags specify the multilib used. */
112 /* One of MSP_ISA_MSP430 or MSP_ISA_MSP430X. */
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
122 /* This structure holds the results of a prologue analysis. */
124 struct msp430_prologue
126 /* The offset from the frame base to the stack pointer --- always
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
137 /* Non-zero if this function has initialized the frame pointer from
138 the stack pointer, zero otherwise. */
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
144 int frame_ptr_offset
;
146 /* The address of the first instruction at which the frame has been
147 set up and the arguments are where the debug info says they are
148 --- as best as we can tell. */
149 CORE_ADDR prologue_end
;
151 /* reg_offset[R] is the offset from the CFA at which register R is
152 saved, or 1 if register R has not been saved. (Real values are
153 always zero or negative.) */
154 int reg_offset
[MSP430_NUM_TOTAL_REGS
];
157 /* Implement the "register_type" gdbarch method. */
160 msp430_register_type (struct gdbarch
*gdbarch
, int reg_nr
)
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
;
167 return builtin_type (gdbarch
)->builtin_uint16
;
170 /* Implement another version of the "register_type" gdbarch method
174 msp430x_register_type (struct gdbarch
*gdbarch
, int reg_nr
)
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
;
181 return builtin_type (gdbarch
)->builtin_uint32
;
184 /* Implement the "register_name" gdbarch method. */
187 msp430_register_name (struct gdbarch
*gdbarch
, int regnr
)
189 static const char *const reg_names
[] = {
191 "", "", "", "", "", "", "", "",
192 "", "", "", "", "", "", "", "",
193 /* Pseudo registers. */
194 "pc", "sp", "sr", "cg", "r4", "r5", "r6", "r7",
195 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
198 return reg_names
[regnr
];
201 /* Implement the "register_reggroup_p" gdbarch method. */
204 msp430_register_reggroup_p (struct gdbarch
*gdbarch
, int regnum
,
205 struct reggroup
*group
)
207 if (group
== all_reggroup
)
210 /* All other registers are saved and restored. */
211 if (group
== save_reggroup
|| group
== restore_reggroup
)
212 return (MSP430_NUM_REGS
<= regnum
&& regnum
< MSP430_NUM_TOTAL_REGS
);
214 return group
== general_reggroup
;
217 /* Implement the "pseudo_register_read" gdbarch method. */
219 static enum register_status
220 msp430_pseudo_register_read (struct gdbarch
*gdbarch
,
221 readable_regcache
*regcache
,
222 int regnum
, gdb_byte
*buffer
)
224 if (MSP430_NUM_REGS
<= regnum
&& regnum
< MSP430_NUM_TOTAL_REGS
)
226 enum register_status status
;
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
;
232 status
= regcache
->raw_read (raw_regnum
, &val
);
233 if (status
== REG_VALID
)
234 store_unsigned_integer (buffer
, regsize
, byte_order
, val
);
239 gdb_assert_not_reached ("invalid pseudo register number");
242 /* Implement the "pseudo_register_write" gdbarch method. */
245 msp430_pseudo_register_write (struct gdbarch
*gdbarch
,
246 struct regcache
*regcache
,
247 int regnum
, const gdb_byte
*buffer
)
249 if (MSP430_NUM_REGS
<= regnum
&& regnum
< MSP430_NUM_TOTAL_REGS
)
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
;
257 val
= extract_unsigned_integer (buffer
, regsize
, byte_order
);
258 regcache_raw_write_unsigned (regcache
, raw_regnum
, val
);
262 gdb_assert_not_reached ("invalid pseudo register number");
265 /* Implement the `register_sim_regno' gdbarch method. */
268 msp430_register_sim_regno (struct gdbarch
*gdbarch
, int regnum
)
270 gdb_assert (regnum
< MSP430_NUM_REGS
);
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. */
278 constexpr gdb_byte msp430_break_insn
[] = { 0x43, 0x43 };
280 typedef BP_MANIPULATION (msp430_break_insn
) msp430_breakpoint
;
282 /* Define a "handle" struct for fetching the next opcode. */
284 struct msp430_get_opcode_byte_handle
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
296 msp430_get_opcode_byte (void *handle
)
298 struct msp430_get_opcode_byte_handle
*opcdata
299 = (struct msp430_get_opcode_byte_handle
*) handle
;
303 status
= target_read_memory (opcdata
->pc
, &byte
, 1);
313 /* Function for finding saved registers in a 'struct pv_area'; this
314 function is passed to pv_area::scan.
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. */
321 check_for_saved (void *result_untyped
, pv_t addr
, CORE_ADDR size
, pv_t value
)
323 struct msp430_prologue
*result
= (struct msp430_prologue
*) result_untyped
;
325 if (value
.kind
== pvk_register
327 && pv_is_register (addr
, MSP430_SP_REGNUM
)
328 && size
== register_size (target_gdbarch (), value
.reg
))
329 result
->reg_offset
[value
.reg
] = addr
.k
;
332 /* Analyze a prologue starting at START_PC, going no further than
333 LIMIT_PC. Fill in RESULT as appropriate. */
336 msp430_analyze_prologue (struct gdbarch
*gdbarch
, CORE_ADDR start_pc
,
337 CORE_ADDR limit_pc
, struct msp430_prologue
*result
)
339 CORE_ADDR pc
, next_pc
;
341 pv_t reg
[MSP430_NUM_TOTAL_REGS
];
342 CORE_ADDR after_last_frame_setup_insn
= start_pc
;
343 int code_model
= gdbarch_tdep (gdbarch
)->code_model
;
346 memset (result
, 0, sizeof (*result
));
348 for (rn
= 0; rn
< MSP430_NUM_TOTAL_REGS
; rn
++)
350 reg
[rn
] = pv_register (rn
, 0);
351 result
->reg_offset
[rn
] = 1;
354 pv_area
stack (MSP430_SP_REGNUM
, gdbarch_addr_bit (gdbarch
));
356 /* The call instruction has saved the return address on the stack. */
357 sz
= code_model
== MSP_LARGE_CODE_MODEL
? 4 : 2;
358 reg
[MSP430_SP_REGNUM
] = pv_add_constant (reg
[MSP430_SP_REGNUM
], -sz
);
359 stack
.store (reg
[MSP430_SP_REGNUM
], sz
, reg
[MSP430_PC_REGNUM
]);
362 while (pc
< limit_pc
)
365 struct msp430_get_opcode_byte_handle opcode_handle
;
366 MSP430_Opcode_Decoded opc
;
368 opcode_handle
.pc
= pc
;
369 bytes_read
= msp430_decode_opcode (pc
, &opc
, msp430_get_opcode_byte
,
371 next_pc
= pc
+ bytes_read
;
373 if (opc
.id
== MSO_push
&& opc
.op
[0].type
== MSP430_Operand_Register
)
375 int rsrc
= opc
.op
[0].reg
;
377 reg
[MSP430_SP_REGNUM
] = pv_add_constant (reg
[MSP430_SP_REGNUM
], -2);
378 stack
.store (reg
[MSP430_SP_REGNUM
], 2, reg
[rsrc
]);
379 after_last_frame_setup_insn
= next_pc
;
381 else if (opc
.id
== MSO_push
/* PUSHM */
382 && opc
.op
[0].type
== MSP430_Operand_None
383 && opc
.op
[1].type
== MSP430_Operand_Register
)
385 int rsrc
= opc
.op
[1].reg
;
386 int count
= opc
.repeats
+ 1;
387 int size
= opc
.size
== 16 ? 2 : 4;
391 reg
[MSP430_SP_REGNUM
]
392 = pv_add_constant (reg
[MSP430_SP_REGNUM
], -size
);
393 stack
.store (reg
[MSP430_SP_REGNUM
], size
, reg
[rsrc
]);
397 after_last_frame_setup_insn
= next_pc
;
399 else if (opc
.id
== MSO_sub
400 && opc
.op
[0].type
== MSP430_Operand_Register
401 && opc
.op
[0].reg
== MSR_SP
402 && opc
.op
[1].type
== MSP430_Operand_Immediate
)
404 int addend
= opc
.op
[1].addend
;
406 reg
[MSP430_SP_REGNUM
] = pv_add_constant (reg
[MSP430_SP_REGNUM
],
408 after_last_frame_setup_insn
= next_pc
;
410 else if (opc
.id
== MSO_mov
411 && opc
.op
[0].type
== MSP430_Operand_Immediate
412 && 12 <= opc
.op
[0].reg
&& opc
.op
[0].reg
<= 15)
413 after_last_frame_setup_insn
= next_pc
;
416 /* Terminate the prologue scan. */
423 /* Is the frame size (offset, really) a known constant? */
424 if (pv_is_register (reg
[MSP430_SP_REGNUM
], MSP430_SP_REGNUM
))
425 result
->frame_size
= reg
[MSP430_SP_REGNUM
].k
;
427 /* Record where all the registers were saved. */
428 stack
.scan (check_for_saved
, result
);
430 result
->prologue_end
= after_last_frame_setup_insn
;
433 /* Implement the "skip_prologue" gdbarch method. */
436 msp430_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
439 CORE_ADDR func_addr
, func_end
;
440 struct msp430_prologue p
;
442 /* Try to find the extent of the function that contains PC. */
443 if (!find_pc_partial_function (pc
, &name
, &func_addr
, &func_end
))
446 msp430_analyze_prologue (gdbarch
, pc
, func_end
, &p
);
447 return p
.prologue_end
;
450 /* Given a frame described by THIS_FRAME, decode the prologue of its
451 associated function if there is not cache entry as specified by
452 THIS_PROLOGUE_CACHE. Save the decoded prologue in the cache and
453 return that struct as the value of this function. */
455 static struct msp430_prologue
*
456 msp430_analyze_frame_prologue (struct frame_info
*this_frame
,
457 void **this_prologue_cache
)
459 if (!*this_prologue_cache
)
461 CORE_ADDR func_start
, stop_addr
;
463 *this_prologue_cache
= FRAME_OBSTACK_ZALLOC (struct msp430_prologue
);
465 func_start
= get_frame_func (this_frame
);
466 stop_addr
= get_frame_pc (this_frame
);
468 /* If we couldn't find any function containing the PC, then
469 just initialize the prologue cache, but don't do anything. */
471 stop_addr
= func_start
;
473 msp430_analyze_prologue (get_frame_arch (this_frame
), func_start
,
475 (struct msp430_prologue
*) *this_prologue_cache
);
478 return (struct msp430_prologue
*) *this_prologue_cache
;
481 /* Given a frame and a prologue cache, return this frame's base. */
484 msp430_frame_base (struct frame_info
*this_frame
, void **this_prologue_cache
)
486 struct msp430_prologue
*p
487 = msp430_analyze_frame_prologue (this_frame
, this_prologue_cache
);
488 CORE_ADDR sp
= get_frame_register_unsigned (this_frame
, MSP430_SP_REGNUM
);
490 return sp
- p
->frame_size
;
493 /* Implement the "frame_this_id" method for unwinding frames. */
496 msp430_this_id (struct frame_info
*this_frame
,
497 void **this_prologue_cache
, struct frame_id
*this_id
)
499 *this_id
= frame_id_build (msp430_frame_base (this_frame
,
500 this_prologue_cache
),
501 get_frame_func (this_frame
));
504 /* Implement the "frame_prev_register" method for unwinding frames. */
506 static struct value
*
507 msp430_prev_register (struct frame_info
*this_frame
,
508 void **this_prologue_cache
, int regnum
)
510 struct msp430_prologue
*p
511 = msp430_analyze_frame_prologue (this_frame
, this_prologue_cache
);
512 CORE_ADDR frame_base
= msp430_frame_base (this_frame
, this_prologue_cache
);
514 if (regnum
== MSP430_SP_REGNUM
)
515 return frame_unwind_got_constant (this_frame
, regnum
, frame_base
);
517 /* If prologue analysis says we saved this register somewhere,
518 return a description of the stack slot holding it. */
519 else if (p
->reg_offset
[regnum
] != 1)
521 struct value
*rv
= frame_unwind_got_memory (this_frame
, regnum
,
523 p
->reg_offset
[regnum
]);
525 if (regnum
== MSP430_PC_REGNUM
)
527 ULONGEST pc
= value_as_long (rv
);
529 return frame_unwind_got_constant (this_frame
, regnum
, pc
);
534 /* Otherwise, presume we haven't changed the value of this
535 register, and get it from the next frame. */
537 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
540 static const struct frame_unwind msp430_unwind
= {
543 default_frame_unwind_stop_reason
,
545 msp430_prev_register
,
547 default_frame_sniffer
550 /* Implement the "dwarf2_reg_to_regnum" gdbarch method. */
553 msp430_dwarf2_reg_to_regnum (struct gdbarch
*gdbarch
, int reg
)
555 if (reg
>= 0 && reg
< MSP430_NUM_REGS
)
556 return reg
+ MSP430_NUM_REGS
;
560 /* Implement the "return_value" gdbarch method. */
562 static enum return_value_convention
563 msp430_return_value (struct gdbarch
*gdbarch
,
564 struct value
*function
,
565 struct type
*valtype
,
566 struct regcache
*regcache
,
567 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
569 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
570 LONGEST valtype_len
= TYPE_LENGTH (valtype
);
571 int code_model
= gdbarch_tdep (gdbarch
)->code_model
;
573 if (TYPE_LENGTH (valtype
) > 8
574 || valtype
->code () == TYPE_CODE_STRUCT
575 || valtype
->code () == TYPE_CODE_UNION
)
576 return RETURN_VALUE_STRUCT_CONVENTION
;
581 int argreg
= MSP430_R12_REGNUM
;
584 while (valtype_len
> 0)
588 if (code_model
== MSP_LARGE_CODE_MODEL
589 && valtype
->code () == TYPE_CODE_PTR
)
594 regcache_cooked_read_unsigned (regcache
, argreg
, &u
);
595 store_unsigned_integer (readbuf
+ offset
, size
, byte_order
, u
);
605 int argreg
= MSP430_R12_REGNUM
;
608 while (valtype_len
> 0)
612 if (code_model
== MSP_LARGE_CODE_MODEL
613 && valtype
->code () == TYPE_CODE_PTR
)
618 u
= extract_unsigned_integer (writebuf
+ offset
, size
, byte_order
);
619 regcache_cooked_write_unsigned (regcache
, argreg
, u
);
626 return RETURN_VALUE_REGISTER_CONVENTION
;
630 /* Implement the "frame_align" gdbarch method. */
633 msp430_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR sp
)
635 return align_down (sp
, 2);
638 /* Implement the "push_dummy_call" gdbarch method. */
641 msp430_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
642 struct regcache
*regcache
, CORE_ADDR bp_addr
,
643 int nargs
, struct value
**args
, CORE_ADDR sp
,
644 function_call_return_method return_method
,
645 CORE_ADDR struct_addr
)
647 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
651 int code_model
= gdbarch_tdep (gdbarch
)->code_model
;
653 struct type
*func_type
= value_type (function
);
655 /* Dereference function pointer types. */
656 while (func_type
->code () == TYPE_CODE_PTR
)
657 func_type
= TYPE_TARGET_TYPE (func_type
);
659 /* The end result had better be a function or a method. */
660 gdb_assert (func_type
->code () == TYPE_CODE_FUNC
661 || func_type
->code () == TYPE_CODE_METHOD
);
663 /* We make two passes; the first does the stack allocation,
664 the second actually stores the arguments. */
665 for (write_pass
= 0; write_pass
<= 1; write_pass
++)
668 int arg_reg
= MSP430_R12_REGNUM
;
669 int args_on_stack
= 0;
672 sp
= align_down (sp
- sp_off
, 4);
675 if (return_method
== return_method_struct
)
678 regcache_cooked_write_unsigned (regcache
, arg_reg
, struct_addr
);
682 /* Push the arguments. */
683 for (i
= 0; i
< nargs
; i
++)
685 struct value
*arg
= args
[i
];
686 const gdb_byte
*arg_bits
= value_contents_all (arg
);
687 struct type
*arg_type
= check_typedef (value_type (arg
));
688 ULONGEST arg_size
= TYPE_LENGTH (arg_type
);
690 int current_arg_on_stack
;
691 gdb_byte struct_addr_buf
[4];
693 current_arg_on_stack
= 0;
695 if (arg_type
->code () == TYPE_CODE_STRUCT
696 || arg_type
->code () == TYPE_CODE_UNION
)
698 /* Aggregates of any size are passed by reference. */
699 store_unsigned_integer (struct_addr_buf
, 4, byte_order
,
700 value_address (arg
));
701 arg_bits
= struct_addr_buf
;
702 arg_size
= (code_model
== MSP_LARGE_CODE_MODEL
) ? 4 : 2;
706 /* Scalars bigger than 8 bytes such as complex doubles are passed
709 current_arg_on_stack
= 1;
713 for (offset
= 0; offset
< arg_size
; offset
+= 2)
715 /* The condition below prevents 8 byte scalars from being split
716 between registers and memory (stack). It also prevents other
717 splits once the stack has been written to. */
718 if (!current_arg_on_stack
720 + ((arg_size
== 8 || args_on_stack
)
721 ? ((arg_size
- offset
) / 2 - 1)
722 : 0) <= MSP430_R15_REGNUM
))
726 if (code_model
== MSP_LARGE_CODE_MODEL
727 && (arg_type
->code () == TYPE_CODE_PTR
728 || TYPE_IS_REFERENCE (arg_type
)
729 || arg_type
->code () == TYPE_CODE_STRUCT
730 || arg_type
->code () == TYPE_CODE_UNION
))
732 /* When using the large memory model, pointer,
733 reference, struct, and union arguments are
734 passed using the entire register. (As noted
735 earlier, aggregates are always passed by
743 regcache_cooked_write_unsigned (regcache
, arg_reg
,
744 extract_unsigned_integer
745 (arg_bits
+ offset
, size
,
753 write_memory (sp
+ sp_off
, arg_bits
+ offset
, 2);
757 current_arg_on_stack
= 1;
763 /* Keep track of the stack address prior to pushing the return address.
764 This is the value that we'll return. */
767 /* Push the return address. */
769 int sz
= (gdbarch_tdep (gdbarch
)->code_model
== MSP_SMALL_CODE_MODEL
)
772 write_memory_unsigned_integer (sp
, sz
, byte_order
, bp_addr
);
775 /* Update the stack pointer. */
776 regcache_cooked_write_unsigned (regcache
, MSP430_SP_REGNUM
, sp
);
781 /* In order to keep code size small, the compiler may create epilogue
782 code through which more than one function epilogue is routed. I.e.
783 the epilogue and return may just be a branch to some common piece of
784 code which is responsible for tearing down the frame and performing
785 the return. These epilog (label) names will have the common prefix
788 static const char msp430_epilog_name_prefix
[] = "__mspabi_func_epilog_";
790 /* Implement the "in_return_stub" gdbarch method. */
793 msp430_in_return_stub (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
797 && startswith (name
, msp430_epilog_name_prefix
));
800 /* Implement the "skip_trampoline_code" gdbarch method. */
802 msp430_skip_trampoline_code (struct frame_info
*frame
, CORE_ADDR pc
)
804 struct bound_minimal_symbol bms
;
805 const char *stub_name
;
806 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
808 bms
= lookup_minimal_symbol_by_pc (pc
);
812 stub_name
= bms
.minsym
->linkage_name ();
814 if (gdbarch_tdep (gdbarch
)->code_model
== MSP_SMALL_CODE_MODEL
815 && msp430_in_return_stub (gdbarch
, pc
, stub_name
))
817 CORE_ADDR sp
= get_frame_register_unsigned (frame
, MSP430_SP_REGNUM
);
819 return read_memory_integer
820 (sp
+ 2 * (stub_name
[strlen (msp430_epilog_name_prefix
)] - '0'),
821 2, gdbarch_byte_order (gdbarch
));
827 /* Allocate and initialize a gdbarch object. */
829 static struct gdbarch
*
830 msp430_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
832 struct gdbarch
*gdbarch
;
833 struct gdbarch_tdep
*tdep
;
834 int elf_flags
, isa
, code_model
;
836 /* Extract the elf_flags if available. */
837 if (info
.abfd
!= NULL
838 && bfd_get_flavour (info
.abfd
) == bfd_target_elf_flavour
)
839 elf_flags
= elf_elfheader (info
.abfd
)->e_flags
;
843 if (info
.abfd
!= NULL
)
844 switch (bfd_elf_get_obj_attr_int (info
.abfd
, OBJ_ATTR_PROC
,
845 OFBA_MSPABI_Tag_ISA
))
848 isa
= MSP_ISA_MSP430
;
849 code_model
= MSP_SMALL_CODE_MODEL
;
852 isa
= MSP_ISA_MSP430X
;
853 switch (bfd_elf_get_obj_attr_int (info
.abfd
, OBJ_ATTR_PROC
,
854 OFBA_MSPABI_Tag_Code_Model
))
857 code_model
= MSP_SMALL_CODE_MODEL
;
860 code_model
= MSP_LARGE_CODE_MODEL
;
863 internal_error (__FILE__
, __LINE__
,
864 _("Unknown msp430x code memory model"));
869 /* This can happen when loading a previously dumped data structure.
870 Use the ISA and code model from the current architecture, provided
873 struct gdbarch
*ca
= get_current_arch ();
874 if (ca
&& gdbarch_bfd_arch_info (ca
)->arch
== bfd_arch_msp430
)
876 struct gdbarch_tdep
*ca_tdep
= gdbarch_tdep (ca
);
878 elf_flags
= ca_tdep
->elf_flags
;
880 code_model
= ca_tdep
->code_model
;
886 error (_("Unknown msp430 isa"));
891 isa
= MSP_ISA_MSP430
;
892 code_model
= MSP_SMALL_CODE_MODEL
;
896 /* Try to find the architecture in the list of already defined
898 for (arches
= gdbarch_list_lookup_by_info (arches
, &info
);
900 arches
= gdbarch_list_lookup_by_info (arches
->next
, &info
))
902 struct gdbarch_tdep
*candidate_tdep
= gdbarch_tdep (arches
->gdbarch
);
904 if (candidate_tdep
->elf_flags
!= elf_flags
905 || candidate_tdep
->isa
!= isa
906 || candidate_tdep
->code_model
!= code_model
)
909 return arches
->gdbarch
;
912 /* None found, create a new architecture from the information
914 tdep
= XCNEW (struct gdbarch_tdep
);
915 gdbarch
= gdbarch_alloc (&info
, tdep
);
916 tdep
->elf_flags
= elf_flags
;
918 tdep
->code_model
= code_model
;
921 set_gdbarch_num_regs (gdbarch
, MSP430_NUM_REGS
);
922 set_gdbarch_num_pseudo_regs (gdbarch
, MSP430_NUM_PSEUDO_REGS
);
923 set_gdbarch_register_name (gdbarch
, msp430_register_name
);
924 if (isa
== MSP_ISA_MSP430
)
925 set_gdbarch_register_type (gdbarch
, msp430_register_type
);
927 set_gdbarch_register_type (gdbarch
, msp430x_register_type
);
928 set_gdbarch_pc_regnum (gdbarch
, MSP430_PC_REGNUM
);
929 set_gdbarch_sp_regnum (gdbarch
, MSP430_SP_REGNUM
);
930 set_gdbarch_register_reggroup_p (gdbarch
, msp430_register_reggroup_p
);
931 set_gdbarch_pseudo_register_read (gdbarch
, msp430_pseudo_register_read
);
932 set_gdbarch_pseudo_register_write (gdbarch
, msp430_pseudo_register_write
);
933 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, msp430_dwarf2_reg_to_regnum
);
934 set_gdbarch_register_sim_regno (gdbarch
, msp430_register_sim_regno
);
937 set_gdbarch_char_signed (gdbarch
, 0);
938 set_gdbarch_short_bit (gdbarch
, 16);
939 set_gdbarch_int_bit (gdbarch
, 16);
940 set_gdbarch_long_bit (gdbarch
, 32);
941 set_gdbarch_long_long_bit (gdbarch
, 64);
942 if (code_model
== MSP_SMALL_CODE_MODEL
)
944 set_gdbarch_ptr_bit (gdbarch
, 16);
945 set_gdbarch_addr_bit (gdbarch
, 16);
947 else /* MSP_LARGE_CODE_MODEL */
949 set_gdbarch_ptr_bit (gdbarch
, 32);
950 set_gdbarch_addr_bit (gdbarch
, 32);
952 set_gdbarch_dwarf2_addr_size (gdbarch
, 4);
953 set_gdbarch_float_bit (gdbarch
, 32);
954 set_gdbarch_float_format (gdbarch
, floatformats_ieee_single
);
955 set_gdbarch_double_bit (gdbarch
, 64);
956 set_gdbarch_long_double_bit (gdbarch
, 64);
957 set_gdbarch_double_format (gdbarch
, floatformats_ieee_double
);
958 set_gdbarch_long_double_format (gdbarch
, floatformats_ieee_double
);
961 set_gdbarch_breakpoint_kind_from_pc (gdbarch
,
962 msp430_breakpoint::kind_from_pc
);
963 set_gdbarch_sw_breakpoint_from_kind (gdbarch
,
964 msp430_breakpoint::bp_from_kind
);
965 set_gdbarch_decr_pc_after_break (gdbarch
, 1);
967 /* Frames, prologues, etc. */
968 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
969 set_gdbarch_skip_prologue (gdbarch
, msp430_skip_prologue
);
970 set_gdbarch_frame_align (gdbarch
, msp430_frame_align
);
971 dwarf2_append_unwinders (gdbarch
);
972 frame_unwind_append_unwinder (gdbarch
, &msp430_unwind
);
974 /* Dummy frames, return values. */
975 set_gdbarch_push_dummy_call (gdbarch
, msp430_push_dummy_call
);
976 set_gdbarch_return_value (gdbarch
, msp430_return_value
);
979 set_gdbarch_in_solib_return_trampoline (gdbarch
, msp430_in_return_stub
);
980 set_gdbarch_skip_trampoline_code (gdbarch
, msp430_skip_trampoline_code
);
982 /* Virtual tables. */
983 set_gdbarch_vbit_in_delta (gdbarch
, 0);
988 /* Register the initialization routine. */
990 void _initialize_msp430_tdep ();
992 _initialize_msp430_tdep ()
994 register_gdbarch_init (bfd_arch_msp430
, msp430_gdbarch_init
);