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. */
107 struct msp430_gdbarch_tdep
: gdbarch_tdep
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 msp430_gdbarch_tdep
*tdep
= (msp430_gdbarch_tdep
*) gdbarch_tdep (gdbarch
);
344 int code_model
= tdep
->code_model
;
347 memset (result
, 0, sizeof (*result
));
349 for (rn
= 0; rn
< MSP430_NUM_TOTAL_REGS
; rn
++)
351 reg
[rn
] = pv_register (rn
, 0);
352 result
->reg_offset
[rn
] = 1;
355 pv_area
stack (MSP430_SP_REGNUM
, gdbarch_addr_bit (gdbarch
));
357 /* The call instruction has saved the return address on the stack. */
358 sz
= code_model
== MSP_LARGE_CODE_MODEL
? 4 : 2;
359 reg
[MSP430_SP_REGNUM
] = pv_add_constant (reg
[MSP430_SP_REGNUM
], -sz
);
360 stack
.store (reg
[MSP430_SP_REGNUM
], sz
, reg
[MSP430_PC_REGNUM
]);
363 while (pc
< limit_pc
)
366 struct msp430_get_opcode_byte_handle opcode_handle
;
367 MSP430_Opcode_Decoded opc
;
369 opcode_handle
.pc
= pc
;
370 bytes_read
= msp430_decode_opcode (pc
, &opc
, msp430_get_opcode_byte
,
372 next_pc
= pc
+ bytes_read
;
374 if (opc
.id
== MSO_push
&& opc
.op
[0].type
== MSP430_Operand_Register
)
376 int rsrc
= opc
.op
[0].reg
;
378 reg
[MSP430_SP_REGNUM
] = pv_add_constant (reg
[MSP430_SP_REGNUM
], -2);
379 stack
.store (reg
[MSP430_SP_REGNUM
], 2, reg
[rsrc
]);
380 after_last_frame_setup_insn
= next_pc
;
382 else if (opc
.id
== MSO_push
/* PUSHM */
383 && opc
.op
[0].type
== MSP430_Operand_None
384 && opc
.op
[1].type
== MSP430_Operand_Register
)
386 int rsrc
= opc
.op
[1].reg
;
387 int count
= opc
.repeats
+ 1;
388 int size
= opc
.size
== 16 ? 2 : 4;
392 reg
[MSP430_SP_REGNUM
]
393 = pv_add_constant (reg
[MSP430_SP_REGNUM
], -size
);
394 stack
.store (reg
[MSP430_SP_REGNUM
], size
, reg
[rsrc
]);
398 after_last_frame_setup_insn
= next_pc
;
400 else if (opc
.id
== MSO_sub
401 && opc
.op
[0].type
== MSP430_Operand_Register
402 && opc
.op
[0].reg
== MSR_SP
403 && opc
.op
[1].type
== MSP430_Operand_Immediate
)
405 int addend
= opc
.op
[1].addend
;
407 reg
[MSP430_SP_REGNUM
] = pv_add_constant (reg
[MSP430_SP_REGNUM
],
409 after_last_frame_setup_insn
= next_pc
;
411 else if (opc
.id
== MSO_mov
412 && opc
.op
[0].type
== MSP430_Operand_Immediate
413 && 12 <= opc
.op
[0].reg
&& opc
.op
[0].reg
<= 15)
414 after_last_frame_setup_insn
= next_pc
;
417 /* Terminate the prologue scan. */
424 /* Is the frame size (offset, really) a known constant? */
425 if (pv_is_register (reg
[MSP430_SP_REGNUM
], MSP430_SP_REGNUM
))
426 result
->frame_size
= reg
[MSP430_SP_REGNUM
].k
;
428 /* Record where all the registers were saved. */
429 stack
.scan (check_for_saved
, result
);
431 result
->prologue_end
= after_last_frame_setup_insn
;
434 /* Implement the "skip_prologue" gdbarch method. */
437 msp430_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
440 CORE_ADDR func_addr
, func_end
;
441 struct msp430_prologue p
;
443 /* Try to find the extent of the function that contains PC. */
444 if (!find_pc_partial_function (pc
, &name
, &func_addr
, &func_end
))
447 msp430_analyze_prologue (gdbarch
, pc
, func_end
, &p
);
448 return p
.prologue_end
;
451 /* Given a frame described by THIS_FRAME, decode the prologue of its
452 associated function if there is not cache entry as specified by
453 THIS_PROLOGUE_CACHE. Save the decoded prologue in the cache and
454 return that struct as the value of this function. */
456 static struct msp430_prologue
*
457 msp430_analyze_frame_prologue (struct frame_info
*this_frame
,
458 void **this_prologue_cache
)
460 if (!*this_prologue_cache
)
462 CORE_ADDR func_start
, stop_addr
;
464 *this_prologue_cache
= FRAME_OBSTACK_ZALLOC (struct msp430_prologue
);
466 func_start
= get_frame_func (this_frame
);
467 stop_addr
= get_frame_pc (this_frame
);
469 /* If we couldn't find any function containing the PC, then
470 just initialize the prologue cache, but don't do anything. */
472 stop_addr
= func_start
;
474 msp430_analyze_prologue (get_frame_arch (this_frame
), func_start
,
476 (struct msp430_prologue
*) *this_prologue_cache
);
479 return (struct msp430_prologue
*) *this_prologue_cache
;
482 /* Given a frame and a prologue cache, return this frame's base. */
485 msp430_frame_base (struct frame_info
*this_frame
, void **this_prologue_cache
)
487 struct msp430_prologue
*p
488 = msp430_analyze_frame_prologue (this_frame
, this_prologue_cache
);
489 CORE_ADDR sp
= get_frame_register_unsigned (this_frame
, MSP430_SP_REGNUM
);
491 return sp
- p
->frame_size
;
494 /* Implement the "frame_this_id" method for unwinding frames. */
497 msp430_this_id (struct frame_info
*this_frame
,
498 void **this_prologue_cache
, struct frame_id
*this_id
)
500 *this_id
= frame_id_build (msp430_frame_base (this_frame
,
501 this_prologue_cache
),
502 get_frame_func (this_frame
));
505 /* Implement the "frame_prev_register" method for unwinding frames. */
507 static struct value
*
508 msp430_prev_register (struct frame_info
*this_frame
,
509 void **this_prologue_cache
, int regnum
)
511 struct msp430_prologue
*p
512 = msp430_analyze_frame_prologue (this_frame
, this_prologue_cache
);
513 CORE_ADDR frame_base
= msp430_frame_base (this_frame
, this_prologue_cache
);
515 if (regnum
== MSP430_SP_REGNUM
)
516 return frame_unwind_got_constant (this_frame
, regnum
, frame_base
);
518 /* If prologue analysis says we saved this register somewhere,
519 return a description of the stack slot holding it. */
520 else if (p
->reg_offset
[regnum
] != 1)
522 struct value
*rv
= frame_unwind_got_memory (this_frame
, regnum
,
524 p
->reg_offset
[regnum
]);
526 if (regnum
== MSP430_PC_REGNUM
)
528 ULONGEST pc
= value_as_long (rv
);
530 return frame_unwind_got_constant (this_frame
, regnum
, pc
);
535 /* Otherwise, presume we haven't changed the value of this
536 register, and get it from the next frame. */
538 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
541 static const struct frame_unwind msp430_unwind
= {
544 default_frame_unwind_stop_reason
,
546 msp430_prev_register
,
548 default_frame_sniffer
551 /* Implement the "dwarf2_reg_to_regnum" gdbarch method. */
554 msp430_dwarf2_reg_to_regnum (struct gdbarch
*gdbarch
, int reg
)
556 if (reg
>= 0 && reg
< MSP430_NUM_REGS
)
557 return reg
+ MSP430_NUM_REGS
;
561 /* Implement the "return_value" gdbarch method. */
563 static enum return_value_convention
564 msp430_return_value (struct gdbarch
*gdbarch
,
565 struct value
*function
,
566 struct type
*valtype
,
567 struct regcache
*regcache
,
568 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
570 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
571 LONGEST valtype_len
= TYPE_LENGTH (valtype
);
572 msp430_gdbarch_tdep
*tdep
= (msp430_gdbarch_tdep
*) gdbarch_tdep (gdbarch
);
573 int code_model
= tdep
->code_model
;
575 if (TYPE_LENGTH (valtype
) > 8
576 || valtype
->code () == TYPE_CODE_STRUCT
577 || valtype
->code () == TYPE_CODE_UNION
)
578 return RETURN_VALUE_STRUCT_CONVENTION
;
583 int argreg
= MSP430_R12_REGNUM
;
586 while (valtype_len
> 0)
590 if (code_model
== MSP_LARGE_CODE_MODEL
591 && valtype
->code () == TYPE_CODE_PTR
)
596 regcache_cooked_read_unsigned (regcache
, argreg
, &u
);
597 store_unsigned_integer (readbuf
+ offset
, size
, byte_order
, u
);
607 int argreg
= MSP430_R12_REGNUM
;
610 while (valtype_len
> 0)
614 if (code_model
== MSP_LARGE_CODE_MODEL
615 && valtype
->code () == TYPE_CODE_PTR
)
620 u
= extract_unsigned_integer (writebuf
+ offset
, size
, byte_order
);
621 regcache_cooked_write_unsigned (regcache
, argreg
, u
);
628 return RETURN_VALUE_REGISTER_CONVENTION
;
632 /* Implement the "frame_align" gdbarch method. */
635 msp430_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR sp
)
637 return align_down (sp
, 2);
640 /* Implement the "push_dummy_call" gdbarch method. */
643 msp430_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
644 struct regcache
*regcache
, CORE_ADDR bp_addr
,
645 int nargs
, struct value
**args
, CORE_ADDR sp
,
646 function_call_return_method return_method
,
647 CORE_ADDR struct_addr
)
649 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
653 msp430_gdbarch_tdep
*tdep
= (msp430_gdbarch_tdep
*) gdbarch_tdep (gdbarch
);
654 int code_model
= tdep
->code_model
;
656 struct type
*func_type
= value_type (function
);
658 /* Dereference function pointer types. */
659 while (func_type
->code () == TYPE_CODE_PTR
)
660 func_type
= TYPE_TARGET_TYPE (func_type
);
662 /* The end result had better be a function or a method. */
663 gdb_assert (func_type
->code () == TYPE_CODE_FUNC
664 || func_type
->code () == TYPE_CODE_METHOD
);
666 /* We make two passes; the first does the stack allocation,
667 the second actually stores the arguments. */
668 for (write_pass
= 0; write_pass
<= 1; write_pass
++)
671 int arg_reg
= MSP430_R12_REGNUM
;
672 int args_on_stack
= 0;
675 sp
= align_down (sp
- sp_off
, 4);
678 if (return_method
== return_method_struct
)
681 regcache_cooked_write_unsigned (regcache
, arg_reg
, struct_addr
);
685 /* Push the arguments. */
686 for (i
= 0; i
< nargs
; i
++)
688 struct value
*arg
= args
[i
];
689 const gdb_byte
*arg_bits
= value_contents_all (arg
).data ();
690 struct type
*arg_type
= check_typedef (value_type (arg
));
691 ULONGEST arg_size
= TYPE_LENGTH (arg_type
);
693 int current_arg_on_stack
;
694 gdb_byte struct_addr_buf
[4];
696 current_arg_on_stack
= 0;
698 if (arg_type
->code () == TYPE_CODE_STRUCT
699 || arg_type
->code () == TYPE_CODE_UNION
)
701 /* Aggregates of any size are passed by reference. */
702 store_unsigned_integer (struct_addr_buf
, 4, byte_order
,
703 value_address (arg
));
704 arg_bits
= struct_addr_buf
;
705 arg_size
= (code_model
== MSP_LARGE_CODE_MODEL
) ? 4 : 2;
709 /* Scalars bigger than 8 bytes such as complex doubles are passed
712 current_arg_on_stack
= 1;
716 for (offset
= 0; offset
< arg_size
; offset
+= 2)
718 /* The condition below prevents 8 byte scalars from being split
719 between registers and memory (stack). It also prevents other
720 splits once the stack has been written to. */
721 if (!current_arg_on_stack
723 + ((arg_size
== 8 || args_on_stack
)
724 ? ((arg_size
- offset
) / 2 - 1)
725 : 0) <= MSP430_R15_REGNUM
))
729 if (code_model
== MSP_LARGE_CODE_MODEL
730 && (arg_type
->code () == TYPE_CODE_PTR
731 || TYPE_IS_REFERENCE (arg_type
)
732 || arg_type
->code () == TYPE_CODE_STRUCT
733 || arg_type
->code () == TYPE_CODE_UNION
))
735 /* When using the large memory model, pointer,
736 reference, struct, and union arguments are
737 passed using the entire register. (As noted
738 earlier, aggregates are always passed by
746 regcache_cooked_write_unsigned (regcache
, arg_reg
,
747 extract_unsigned_integer
748 (arg_bits
+ offset
, size
,
756 write_memory (sp
+ sp_off
, arg_bits
+ offset
, 2);
760 current_arg_on_stack
= 1;
766 /* Keep track of the stack address prior to pushing the return address.
767 This is the value that we'll return. */
770 /* Push the return address. */
772 int sz
= tdep
->code_model
== MSP_SMALL_CODE_MODEL
? 2 : 4;
774 write_memory_unsigned_integer (sp
, sz
, byte_order
, bp_addr
);
777 /* Update the stack pointer. */
778 regcache_cooked_write_unsigned (regcache
, MSP430_SP_REGNUM
, sp
);
783 /* In order to keep code size small, the compiler may create epilogue
784 code through which more than one function epilogue is routed. I.e.
785 the epilogue and return may just be a branch to some common piece of
786 code which is responsible for tearing down the frame and performing
787 the return. These epilog (label) names will have the common prefix
790 static const char msp430_epilog_name_prefix
[] = "__mspabi_func_epilog_";
792 /* Implement the "in_return_stub" gdbarch method. */
795 msp430_in_return_stub (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
799 && startswith (name
, msp430_epilog_name_prefix
));
802 /* Implement the "skip_trampoline_code" gdbarch method. */
804 msp430_skip_trampoline_code (struct frame_info
*frame
, CORE_ADDR pc
)
806 struct bound_minimal_symbol bms
;
807 const char *stub_name
;
808 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
810 bms
= lookup_minimal_symbol_by_pc (pc
);
814 stub_name
= bms
.minsym
->linkage_name ();
816 msp430_gdbarch_tdep
*tdep
= (msp430_gdbarch_tdep
*) gdbarch_tdep (gdbarch
);
817 if (tdep
->code_model
== MSP_SMALL_CODE_MODEL
818 && msp430_in_return_stub (gdbarch
, pc
, stub_name
))
820 CORE_ADDR sp
= get_frame_register_unsigned (frame
, MSP430_SP_REGNUM
);
822 return read_memory_integer
823 (sp
+ 2 * (stub_name
[strlen (msp430_epilog_name_prefix
)] - '0'),
824 2, gdbarch_byte_order (gdbarch
));
830 /* Allocate and initialize a gdbarch object. */
832 static struct gdbarch
*
833 msp430_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
835 struct gdbarch
*gdbarch
;
836 int elf_flags
, isa
, code_model
;
838 /* Extract the elf_flags if available. */
839 if (info
.abfd
!= NULL
840 && bfd_get_flavour (info
.abfd
) == bfd_target_elf_flavour
)
841 elf_flags
= elf_elfheader (info
.abfd
)->e_flags
;
845 if (info
.abfd
!= NULL
)
846 switch (bfd_elf_get_obj_attr_int (info
.abfd
, OBJ_ATTR_PROC
,
847 OFBA_MSPABI_Tag_ISA
))
850 isa
= MSP_ISA_MSP430
;
851 code_model
= MSP_SMALL_CODE_MODEL
;
854 isa
= MSP_ISA_MSP430X
;
855 switch (bfd_elf_get_obj_attr_int (info
.abfd
, OBJ_ATTR_PROC
,
856 OFBA_MSPABI_Tag_Code_Model
))
859 code_model
= MSP_SMALL_CODE_MODEL
;
862 code_model
= MSP_LARGE_CODE_MODEL
;
865 internal_error (__FILE__
, __LINE__
,
866 _("Unknown msp430x code memory model"));
871 /* This can happen when loading a previously dumped data structure.
872 Use the ISA and code model from the current architecture, provided
875 struct gdbarch
*ca
= get_current_arch ();
876 if (ca
&& gdbarch_bfd_arch_info (ca
)->arch
== bfd_arch_msp430
)
878 msp430_gdbarch_tdep
*ca_tdep
879 = (msp430_gdbarch_tdep
*) gdbarch_tdep (ca
);
881 elf_flags
= ca_tdep
->elf_flags
;
883 code_model
= ca_tdep
->code_model
;
889 error (_("Unknown msp430 isa"));
894 isa
= MSP_ISA_MSP430
;
895 code_model
= MSP_SMALL_CODE_MODEL
;
899 /* Try to find the architecture in the list of already defined
901 for (arches
= gdbarch_list_lookup_by_info (arches
, &info
);
903 arches
= gdbarch_list_lookup_by_info (arches
->next
, &info
))
905 msp430_gdbarch_tdep
*candidate_tdep
906 = (msp430_gdbarch_tdep
*) gdbarch_tdep (arches
->gdbarch
);
908 if (candidate_tdep
->elf_flags
!= elf_flags
909 || candidate_tdep
->isa
!= isa
910 || candidate_tdep
->code_model
!= code_model
)
913 return arches
->gdbarch
;
916 /* None found, create a new architecture from the information
918 msp430_gdbarch_tdep
*tdep
= new msp430_gdbarch_tdep
;
919 gdbarch
= gdbarch_alloc (&info
, tdep
);
920 tdep
->elf_flags
= elf_flags
;
922 tdep
->code_model
= code_model
;
925 set_gdbarch_num_regs (gdbarch
, MSP430_NUM_REGS
);
926 set_gdbarch_num_pseudo_regs (gdbarch
, MSP430_NUM_PSEUDO_REGS
);
927 set_gdbarch_register_name (gdbarch
, msp430_register_name
);
928 if (isa
== MSP_ISA_MSP430
)
929 set_gdbarch_register_type (gdbarch
, msp430_register_type
);
931 set_gdbarch_register_type (gdbarch
, msp430x_register_type
);
932 set_gdbarch_pc_regnum (gdbarch
, MSP430_PC_REGNUM
);
933 set_gdbarch_sp_regnum (gdbarch
, MSP430_SP_REGNUM
);
934 set_gdbarch_register_reggroup_p (gdbarch
, msp430_register_reggroup_p
);
935 set_gdbarch_pseudo_register_read (gdbarch
, msp430_pseudo_register_read
);
936 set_gdbarch_pseudo_register_write (gdbarch
, msp430_pseudo_register_write
);
937 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, msp430_dwarf2_reg_to_regnum
);
938 set_gdbarch_register_sim_regno (gdbarch
, msp430_register_sim_regno
);
941 set_gdbarch_char_signed (gdbarch
, 0);
942 set_gdbarch_short_bit (gdbarch
, 16);
943 set_gdbarch_int_bit (gdbarch
, 16);
944 set_gdbarch_long_bit (gdbarch
, 32);
945 set_gdbarch_long_long_bit (gdbarch
, 64);
946 if (code_model
== MSP_SMALL_CODE_MODEL
)
948 set_gdbarch_ptr_bit (gdbarch
, 16);
949 set_gdbarch_addr_bit (gdbarch
, 16);
951 else /* MSP_LARGE_CODE_MODEL */
953 set_gdbarch_ptr_bit (gdbarch
, 32);
954 set_gdbarch_addr_bit (gdbarch
, 32);
956 set_gdbarch_dwarf2_addr_size (gdbarch
, 4);
957 set_gdbarch_float_bit (gdbarch
, 32);
958 set_gdbarch_float_format (gdbarch
, floatformats_ieee_single
);
959 set_gdbarch_double_bit (gdbarch
, 64);
960 set_gdbarch_long_double_bit (gdbarch
, 64);
961 set_gdbarch_double_format (gdbarch
, floatformats_ieee_double
);
962 set_gdbarch_long_double_format (gdbarch
, floatformats_ieee_double
);
965 set_gdbarch_breakpoint_kind_from_pc (gdbarch
,
966 msp430_breakpoint::kind_from_pc
);
967 set_gdbarch_sw_breakpoint_from_kind (gdbarch
,
968 msp430_breakpoint::bp_from_kind
);
969 set_gdbarch_decr_pc_after_break (gdbarch
, 1);
971 /* Frames, prologues, etc. */
972 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
973 set_gdbarch_skip_prologue (gdbarch
, msp430_skip_prologue
);
974 set_gdbarch_frame_align (gdbarch
, msp430_frame_align
);
975 dwarf2_append_unwinders (gdbarch
);
976 frame_unwind_append_unwinder (gdbarch
, &msp430_unwind
);
978 /* Dummy frames, return values. */
979 set_gdbarch_push_dummy_call (gdbarch
, msp430_push_dummy_call
);
980 set_gdbarch_return_value (gdbarch
, msp430_return_value
);
983 set_gdbarch_in_solib_return_trampoline (gdbarch
, msp430_in_return_stub
);
984 set_gdbarch_skip_trampoline_code (gdbarch
, msp430_skip_trampoline_code
);
986 /* Virtual tables. */
987 set_gdbarch_vbit_in_delta (gdbarch
, 0);
992 /* Register the initialization routine. */
994 void _initialize_msp430_tdep ();
996 _initialize_msp430_tdep ()
998 register_gdbarch_init (bfd_arch_msp430
, msp430_gdbarch_init
);