4e9f372dfdfd7c9c6136d1df0af85787749557ff
[deliverable/binutils-gdb.git] / gdb / mn10300-tdep.c
1 /* Target-dependent code for the Matsushita MN10300 for GDB, the GNU debugger.
2
3 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
4 Free Software Foundation, Inc.
5
6 This file is part of GDB.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
22
23 #include "defs.h"
24 #include "arch-utils.h"
25 #include "dis-asm.h"
26 #include "gdbtypes.h"
27 #include "regcache.h"
28 #include "gdb_string.h"
29 #include "gdb_assert.h"
30 #include "gdbcore.h" /* for write_memory_unsigned_integer */
31 #include "value.h"
32 #include "gdbtypes.h"
33 #include "frame.h"
34 #include "frame-unwind.h"
35 #include "frame-base.h"
36 #include "trad-frame.h"
37 #include "symtab.h"
38 #include "dwarf2-frame.h"
39 #include "osabi.h"
40
41 #include "mn10300-tdep.h"
42
43 /* Forward decl. */
44 extern struct trad_frame_cache *mn10300_frame_unwind_cache (struct frame_info*,
45 void **);
46
47 /* Compute the alignment required by a type. */
48
49 static int
50 mn10300_type_align (struct type *type)
51 {
52 int i, align = 1;
53
54 switch (TYPE_CODE (type))
55 {
56 case TYPE_CODE_INT:
57 case TYPE_CODE_ENUM:
58 case TYPE_CODE_SET:
59 case TYPE_CODE_RANGE:
60 case TYPE_CODE_CHAR:
61 case TYPE_CODE_BOOL:
62 case TYPE_CODE_FLT:
63 case TYPE_CODE_PTR:
64 case TYPE_CODE_REF:
65 return TYPE_LENGTH (type);
66
67 case TYPE_CODE_COMPLEX:
68 return TYPE_LENGTH (type) / 2;
69
70 case TYPE_CODE_STRUCT:
71 case TYPE_CODE_UNION:
72 for (i = 0; i < TYPE_NFIELDS (type); i++)
73 {
74 int falign = mn10300_type_align (TYPE_FIELD_TYPE (type, i));
75 while (align < falign)
76 align <<= 1;
77 }
78 return align;
79
80 case TYPE_CODE_ARRAY:
81 /* HACK! Structures containing arrays, even small ones, are not
82 elligible for returning in registers. */
83 return 256;
84
85 case TYPE_CODE_TYPEDEF:
86 return mn10300_type_align (check_typedef (type));
87
88 default:
89 internal_error (__FILE__, __LINE__, _("bad switch"));
90 }
91 }
92
93 /* Should call_function allocate stack space for a struct return? */
94 static int
95 mn10300_use_struct_convention (struct type *type)
96 {
97 /* Structures bigger than a pair of words can't be returned in
98 registers. */
99 if (TYPE_LENGTH (type) > 8)
100 return 1;
101
102 switch (TYPE_CODE (type))
103 {
104 case TYPE_CODE_STRUCT:
105 case TYPE_CODE_UNION:
106 /* Structures with a single field are handled as the field
107 itself. */
108 if (TYPE_NFIELDS (type) == 1)
109 return mn10300_use_struct_convention (TYPE_FIELD_TYPE (type, 0));
110
111 /* Structures with word or double-word size are passed in memory, as
112 long as they require at least word alignment. */
113 if (mn10300_type_align (type) >= 4)
114 return 0;
115
116 return 1;
117
118 /* Arrays are addressable, so they're never returned in
119 registers. This condition can only hold when the array is
120 the only field of a struct or union. */
121 case TYPE_CODE_ARRAY:
122 return 1;
123
124 case TYPE_CODE_TYPEDEF:
125 return mn10300_use_struct_convention (check_typedef (type));
126
127 default:
128 return 0;
129 }
130 }
131
132 static void
133 mn10300_store_return_value (struct gdbarch *gdbarch, struct type *type,
134 struct regcache *regcache, const void *valbuf)
135 {
136 int len = TYPE_LENGTH (type);
137 int reg, regsz;
138
139 if (TYPE_CODE (type) == TYPE_CODE_PTR)
140 reg = 4;
141 else
142 reg = 0;
143
144 regsz = register_size (gdbarch, reg);
145
146 if (len <= regsz)
147 regcache_raw_write_part (regcache, reg, 0, len, valbuf);
148 else if (len <= 2 * regsz)
149 {
150 regcache_raw_write (regcache, reg, valbuf);
151 gdb_assert (regsz == register_size (gdbarch, reg + 1));
152 regcache_raw_write_part (regcache, reg+1, 0,
153 len - regsz, (char *) valbuf + regsz);
154 }
155 else
156 internal_error (__FILE__, __LINE__,
157 _("Cannot store return value %d bytes long."), len);
158 }
159
160 static void
161 mn10300_extract_return_value (struct gdbarch *gdbarch, struct type *type,
162 struct regcache *regcache, void *valbuf)
163 {
164 char buf[MAX_REGISTER_SIZE];
165 int len = TYPE_LENGTH (type);
166 int reg, regsz;
167
168 if (TYPE_CODE (type) == TYPE_CODE_PTR)
169 reg = 4;
170 else
171 reg = 0;
172
173 regsz = register_size (gdbarch, reg);
174 if (len <= regsz)
175 {
176 regcache_raw_read (regcache, reg, buf);
177 memcpy (valbuf, buf, len);
178 }
179 else if (len <= 2 * regsz)
180 {
181 regcache_raw_read (regcache, reg, buf);
182 memcpy (valbuf, buf, regsz);
183 gdb_assert (regsz == register_size (gdbarch, reg + 1));
184 regcache_raw_read (regcache, reg + 1, buf);
185 memcpy ((char *) valbuf + regsz, buf, len - regsz);
186 }
187 else
188 internal_error (__FILE__, __LINE__,
189 _("Cannot extract return value %d bytes long."), len);
190 }
191
192 /* Determine, for architecture GDBARCH, how a return value of TYPE
193 should be returned. If it is supposed to be returned in registers,
194 and READBUF is non-zero, read the appropriate value from REGCACHE,
195 and copy it into READBUF. If WRITEBUF is non-zero, write the value
196 from WRITEBUF into REGCACHE. */
197
198 static enum return_value_convention
199 mn10300_return_value (struct gdbarch *gdbarch, struct type *type,
200 struct regcache *regcache, gdb_byte *readbuf,
201 const gdb_byte *writebuf)
202 {
203 if (mn10300_use_struct_convention (type))
204 return RETURN_VALUE_STRUCT_CONVENTION;
205
206 if (readbuf)
207 mn10300_extract_return_value (gdbarch, type, regcache, readbuf);
208 if (writebuf)
209 mn10300_store_return_value (gdbarch, type, regcache, writebuf);
210
211 return RETURN_VALUE_REGISTER_CONVENTION;
212 }
213
214 static char *
215 register_name (int reg, char **regs, long sizeof_regs)
216 {
217 if (reg < 0 || reg >= sizeof_regs / sizeof (regs[0]))
218 return NULL;
219 else
220 return regs[reg];
221 }
222
223 static const char *
224 mn10300_generic_register_name (int reg)
225 {
226 static char *regs[] =
227 { "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
228 "sp", "pc", "mdr", "psw", "lir", "lar", "", "",
229 "", "", "", "", "", "", "", "",
230 "", "", "", "", "", "", "", "fp"
231 };
232 return register_name (reg, regs, sizeof regs);
233 }
234
235
236 static const char *
237 am33_register_name (int reg)
238 {
239 static char *regs[] =
240 { "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
241 "sp", "pc", "mdr", "psw", "lir", "lar", "",
242 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
243 "ssp", "msp", "usp", "mcrh", "mcrl", "mcvf", "", "", ""
244 };
245 return register_name (reg, regs, sizeof regs);
246 }
247
248
249 static struct type *
250 mn10300_register_type (struct gdbarch *gdbarch, int reg)
251 {
252 return builtin_type_int;
253 }
254
255 static CORE_ADDR
256 mn10300_read_pc (ptid_t ptid)
257 {
258 return read_register_pid (E_PC_REGNUM, ptid);
259 }
260
261 static void
262 mn10300_write_pc (CORE_ADDR val, ptid_t ptid)
263 {
264 return write_register_pid (E_PC_REGNUM, val, ptid);
265 }
266
267 /* The breakpoint instruction must be the same size as the smallest
268 instruction in the instruction set.
269
270 The Matsushita mn10x00 processors have single byte instructions
271 so we need a single byte breakpoint. Matsushita hasn't defined
272 one, so we defined it ourselves. */
273
274 const static unsigned char *
275 mn10300_breakpoint_from_pc (CORE_ADDR *bp_addr, int *bp_size)
276 {
277 static char breakpoint[] = {0xff};
278 *bp_size = 1;
279 return breakpoint;
280 }
281
282 /*
283 * Frame Extra Info:
284 *
285 * status -- actually frame type (SP, FP, or last frame)
286 * stack size -- offset to the next frame
287 *
288 * The former might ultimately be stored in the frame_base.
289 * Seems like there'd be a way to store the later too.
290 *
291 * Temporarily supply empty stub functions as place holders.
292 */
293
294 static void
295 my_frame_is_in_sp (struct frame_info *fi, void **this_cache)
296 {
297 struct trad_frame_cache *cache = mn10300_frame_unwind_cache (fi, this_cache);
298 trad_frame_set_this_base (cache,
299 frame_unwind_register_unsigned (fi,
300 E_SP_REGNUM));
301 }
302
303 static void
304 my_frame_is_in_fp (struct frame_info *fi, void **this_cache)
305 {
306 struct trad_frame_cache *cache = mn10300_frame_unwind_cache (fi, this_cache);
307 trad_frame_set_this_base (cache,
308 frame_unwind_register_unsigned (fi,
309 E_A3_REGNUM));
310 }
311
312 static void
313 my_frame_is_last (struct frame_info *fi)
314 {
315 }
316
317 static void
318 set_my_stack_size (struct frame_info *fi, CORE_ADDR size)
319 {
320 }
321
322
323 /* Set offsets of registers saved by movm instruction.
324 This is a helper function for mn10300_analyze_prologue. */
325
326 static void
327 set_movm_offsets (struct frame_info *fi,
328 void **this_cache,
329 int movm_args)
330 {
331 struct trad_frame_cache *cache;
332 int offset = 0;
333 CORE_ADDR base;
334
335 if (fi == NULL || this_cache == NULL)
336 return;
337
338 cache = mn10300_frame_unwind_cache (fi, this_cache);
339 if (cache == NULL)
340 return;
341
342 base = trad_frame_get_this_base (cache);
343 if (movm_args & movm_other_bit)
344 {
345 /* The `other' bit leaves a blank area of four bytes at the
346 beginning of its block of saved registers, making it 32 bytes
347 long in total. */
348 trad_frame_set_reg_addr (cache, E_LAR_REGNUM, base + offset + 4);
349 trad_frame_set_reg_addr (cache, E_LIR_REGNUM, base + offset + 8);
350 trad_frame_set_reg_addr (cache, E_MDR_REGNUM, base + offset + 12);
351 trad_frame_set_reg_addr (cache, E_A0_REGNUM + 1, base + offset + 16);
352 trad_frame_set_reg_addr (cache, E_A0_REGNUM, base + offset + 20);
353 trad_frame_set_reg_addr (cache, E_D0_REGNUM + 1, base + offset + 24);
354 trad_frame_set_reg_addr (cache, E_D0_REGNUM, base + offset + 28);
355 offset += 32;
356 }
357
358 if (movm_args & movm_a3_bit)
359 {
360 trad_frame_set_reg_addr (cache, E_A3_REGNUM, base + offset);
361 offset += 4;
362 }
363 if (movm_args & movm_a2_bit)
364 {
365 trad_frame_set_reg_addr (cache, E_A2_REGNUM, base + offset);
366 offset += 4;
367 }
368 if (movm_args & movm_d3_bit)
369 {
370 trad_frame_set_reg_addr (cache, E_D3_REGNUM, base + offset);
371 offset += 4;
372 }
373 if (movm_args & movm_d2_bit)
374 {
375 trad_frame_set_reg_addr (cache, E_D2_REGNUM, base + offset);
376 offset += 4;
377 }
378 if (AM33_MODE)
379 {
380 if (movm_args & movm_exother_bit)
381 {
382 trad_frame_set_reg_addr (cache, E_MCVF_REGNUM, base + offset);
383 trad_frame_set_reg_addr (cache, E_MCRL_REGNUM, base + offset + 4);
384 trad_frame_set_reg_addr (cache, E_MCRH_REGNUM, base + offset + 8);
385 trad_frame_set_reg_addr (cache, E_MDRQ_REGNUM, base + offset + 12);
386 trad_frame_set_reg_addr (cache, E_E1_REGNUM, base + offset + 16);
387 trad_frame_set_reg_addr (cache, E_E0_REGNUM, base + offset + 20);
388 offset += 24;
389 }
390 if (movm_args & movm_exreg1_bit)
391 {
392 trad_frame_set_reg_addr (cache, E_E7_REGNUM, base + offset);
393 trad_frame_set_reg_addr (cache, E_E6_REGNUM, base + offset + 4);
394 trad_frame_set_reg_addr (cache, E_E5_REGNUM, base + offset + 8);
395 trad_frame_set_reg_addr (cache, E_E4_REGNUM, base + offset + 12);
396 offset += 16;
397 }
398 if (movm_args & movm_exreg0_bit)
399 {
400 trad_frame_set_reg_addr (cache, E_E3_REGNUM, base + offset);
401 trad_frame_set_reg_addr (cache, E_E2_REGNUM, base + offset + 4);
402 offset += 8;
403 }
404 }
405 /* The last (or first) thing on the stack will be the PC. */
406 trad_frame_set_reg_addr (cache, E_PC_REGNUM, base + offset);
407 /* Save the SP in the 'traditional' way.
408 This will be the same location where the PC is saved. */
409 trad_frame_set_reg_value (cache, E_SP_REGNUM, base + offset);
410 }
411
412 /* The main purpose of this file is dealing with prologues to extract
413 information about stack frames and saved registers.
414
415 In gcc/config/mn13000/mn10300.c, the expand_prologue prologue
416 function is pretty readable, and has a nice explanation of how the
417 prologue is generated. The prologues generated by that code will
418 have the following form (NOTE: the current code doesn't handle all
419 this!):
420
421 + If this is an old-style varargs function, then its arguments
422 need to be flushed back to the stack:
423
424 mov d0,(4,sp)
425 mov d1,(4,sp)
426
427 + If we use any of the callee-saved registers, save them now.
428
429 movm [some callee-saved registers],(sp)
430
431 + If we have any floating-point registers to save:
432
433 - Decrement the stack pointer to reserve space for the registers.
434 If the function doesn't need a frame pointer, we may combine
435 this with the adjustment that reserves space for the frame.
436
437 add -SIZE, sp
438
439 - Save the floating-point registers. We have two possible
440 strategies:
441
442 . Save them at fixed offset from the SP:
443
444 fmov fsN,(OFFSETN,sp)
445 fmov fsM,(OFFSETM,sp)
446 ...
447
448 Note that, if OFFSETN happens to be zero, you'll get the
449 different opcode: fmov fsN,(sp)
450
451 . Or, set a0 to the start of the save area, and then use
452 post-increment addressing to save the FP registers.
453
454 mov sp, a0
455 add SIZE, a0
456 fmov fsN,(a0+)
457 fmov fsM,(a0+)
458 ...
459
460 + If the function needs a frame pointer, we set it here.
461
462 mov sp, a3
463
464 + Now we reserve space for the stack frame proper. This could be
465 merged into the `add -SIZE, sp' instruction for FP saves up
466 above, unless we needed to set the frame pointer in the previous
467 step, or the frame is so large that allocating the whole thing at
468 once would put the FP register save slots out of reach of the
469 addressing mode (128 bytes).
470
471 add -SIZE, sp
472
473 One day we might keep the stack pointer constant, that won't
474 change the code for prologues, but it will make the frame
475 pointerless case much more common. */
476
477 /* Analyze the prologue to determine where registers are saved,
478 the end of the prologue, etc etc. Return the end of the prologue
479 scanned.
480
481 We store into FI (if non-null) several tidbits of information:
482
483 * stack_size -- size of this stack frame. Note that if we stop in
484 certain parts of the prologue/epilogue we may claim the size of the
485 current frame is zero. This happens when the current frame has
486 not been allocated yet or has already been deallocated.
487
488 * fsr -- Addresses of registers saved in the stack by this frame.
489
490 * status -- A (relatively) generic status indicator. It's a bitmask
491 with the following bits:
492
493 MY_FRAME_IN_SP: The base of the current frame is actually in
494 the stack pointer. This can happen for frame pointerless
495 functions, or cases where we're stopped in the prologue/epilogue
496 itself. For these cases mn10300_analyze_prologue will need up
497 update fi->frame before returning or analyzing the register
498 save instructions.
499
500 MY_FRAME_IN_FP: The base of the current frame is in the
501 frame pointer register ($a3).
502
503 NO_MORE_FRAMES: Set this if the current frame is "start" or
504 if the first instruction looks like mov <imm>,sp. This tells
505 frame chain to not bother trying to unwind past this frame. */
506
507 static CORE_ADDR
508 mn10300_analyze_prologue (struct frame_info *fi,
509 void **this_cache,
510 CORE_ADDR pc)
511 {
512 CORE_ADDR func_addr, func_end, addr, stop;
513 long stack_size;
514 int imm_size;
515 unsigned char buf[4];
516 int status, movm_args = 0;
517 char *name;
518
519 /* Use the PC in the frame if it's provided to look up the
520 start of this function.
521
522 Note: kevinb/2003-07-16: We used to do the following here:
523 pc = (fi ? get_frame_pc (fi) : pc);
524 But this is (now) badly broken when called from analyze_dummy_frame().
525 */
526 if (fi)
527 {
528 pc = (pc ? pc : get_frame_pc (fi));
529 /* At the start of a function our frame is in the stack pointer. */
530 my_frame_is_in_sp (fi, this_cache);
531 }
532
533 /* Find the start of this function. */
534 status = find_pc_partial_function (pc, &name, &func_addr, &func_end);
535
536 /* Do nothing if we couldn't find the start of this function
537
538 MVS: comment went on to say "or if we're stopped at the first
539 instruction in the prologue" -- but code doesn't reflect that,
540 and I don't want to do that anyway. */
541 if (status == 0)
542 {
543 return pc;
544 }
545
546 /* If we're in start, then give up. */
547 if (strcmp (name, "start") == 0)
548 {
549 if (fi != NULL)
550 my_frame_is_last (fi);
551 return pc;
552 }
553
554 #if 0
555 /* Get the next two bytes into buf, we need two because rets is a two
556 byte insn and the first isn't enough to uniquely identify it. */
557 status = deprecated_read_memory_nobpt (pc, buf, 2);
558 if (status != 0)
559 return pc;
560
561 /* Note: kevinb/2003-07-16: We shouldn't be making these sorts of
562 changes to the frame in prologue examination code. */
563 /* If we're physically on an "rets" instruction, then our frame has
564 already been deallocated. Note this can also be true for retf
565 and ret if they specify a size of zero.
566
567 In this case fi->frame is bogus, we need to fix it. */
568 if (fi && buf[0] == 0xf0 && buf[1] == 0xfc)
569 {
570 if (get_next_frame (fi) == NULL)
571 deprecated_update_frame_base_hack (fi, read_sp ());
572 return get_frame_pc (fi);
573 }
574
575 /* Similarly if we're stopped on the first insn of a prologue as our
576 frame hasn't been allocated yet. */
577 if (fi && get_frame_pc (fi) == func_addr)
578 {
579 if (get_next_frame (fi) == NULL)
580 deprecated_update_frame_base_hack (fi, read_sp ());
581 return get_frame_pc (fi);
582 }
583 #endif
584
585 /* NOTE: from here on, we don't want to return without jumping to
586 finish_prologue. */
587
588
589 /* Figure out where to stop scanning. */
590 stop = fi ? pc : func_end;
591
592 /* Don't walk off the end of the function. */
593 stop = stop > func_end ? func_end : stop;
594
595 /* Start scanning on the first instruction of this function. */
596 addr = func_addr;
597
598 /* Suck in two bytes. */
599 if (addr + 2 >= stop
600 || (status = deprecated_read_memory_nobpt (addr, buf, 2)) != 0)
601 goto finish_prologue;
602
603 /* First see if this insn sets the stack pointer from a register; if
604 so, it's probably the initialization of the stack pointer in _start,
605 so mark this as the bottom-most frame. */
606 if (buf[0] == 0xf2 && (buf[1] & 0xf3) == 0xf0)
607 {
608 if (fi)
609 my_frame_is_last (fi);
610 goto finish_prologue;
611 }
612
613 /* Now look for movm [regs],sp, which saves the callee saved registers.
614
615 At this time we don't know if fi->frame is valid, so we only note
616 that we encountered a movm instruction. Later, we'll set the entries
617 in fsr.regs as needed. */
618 if (buf[0] == 0xcf)
619 {
620 /* Extract the register list for the movm instruction. */
621 movm_args = buf[1];
622
623 addr += 2;
624
625 /* Quit now if we're beyond the stop point. */
626 if (addr >= stop)
627 goto finish_prologue;
628
629 /* Get the next two bytes so the prologue scan can continue. */
630 status = deprecated_read_memory_nobpt (addr, buf, 2);
631 if (status != 0)
632 goto finish_prologue;
633 }
634
635 /* Now see if we set up a frame pointer via "mov sp,a3" */
636 if (buf[0] == 0x3f)
637 {
638 addr += 1;
639
640 /* The frame pointer is now valid. */
641 if (fi)
642 {
643 my_frame_is_in_fp (fi, this_cache);
644 }
645
646 /* Quit now if we're beyond the stop point. */
647 if (addr >= stop)
648 goto finish_prologue;
649
650 /* Get two more bytes so scanning can continue. */
651 status = deprecated_read_memory_nobpt (addr, buf, 2);
652 if (status != 0)
653 goto finish_prologue;
654 }
655
656 /* Next we should allocate the local frame. No more prologue insns
657 are found after allocating the local frame.
658
659 Search for add imm8,sp (0xf8feXX)
660 or add imm16,sp (0xfafeXXXX)
661 or add imm32,sp (0xfcfeXXXXXXXX).
662
663 If none of the above was found, then this prologue has no
664 additional stack. */
665
666 imm_size = 0;
667 if (buf[0] == 0xf8 && buf[1] == 0xfe)
668 imm_size = 1;
669 else if (buf[0] == 0xfa && buf[1] == 0xfe)
670 imm_size = 2;
671 else if (buf[0] == 0xfc && buf[1] == 0xfe)
672 imm_size = 4;
673
674 if (imm_size != 0)
675 {
676 /* Suck in imm_size more bytes, they'll hold the size of the
677 current frame. */
678 status = deprecated_read_memory_nobpt (addr + 2, buf, imm_size);
679 if (status != 0)
680 goto finish_prologue;
681
682 /* Note the size of the stack in the frame info structure. */
683 stack_size = extract_signed_integer (buf, imm_size);
684 if (fi)
685 set_my_stack_size (fi, stack_size);
686
687 /* We just consumed 2 + imm_size bytes. */
688 addr += 2 + imm_size;
689
690 /* No more prologue insns follow, so begin preparation to return. */
691 goto finish_prologue;
692 }
693 /* Do the essentials and get out of here. */
694 finish_prologue:
695 /* Note if/where callee saved registers were saved. */
696 if (fi)
697 set_movm_offsets (fi, this_cache, movm_args);
698 return addr;
699 }
700
701 /* Function: skip_prologue
702 Return the address of the first inst past the prologue of the function. */
703
704 static CORE_ADDR
705 mn10300_skip_prologue (CORE_ADDR pc)
706 {
707 return mn10300_analyze_prologue (NULL, NULL, pc);
708 }
709
710 /* Simple frame_unwind_cache.
711 This finds the "extra info" for the frame. */
712 struct trad_frame_cache *
713 mn10300_frame_unwind_cache (struct frame_info *next_frame,
714 void **this_prologue_cache)
715 {
716 struct trad_frame_cache *cache;
717 CORE_ADDR pc, start, end;
718
719 if (*this_prologue_cache)
720 return (*this_prologue_cache);
721
722 cache = trad_frame_cache_zalloc (next_frame);
723 pc = gdbarch_unwind_pc (current_gdbarch, next_frame);
724 mn10300_analyze_prologue (next_frame, (void **) &cache, pc);
725 if (find_pc_partial_function (pc, NULL, &start, &end))
726 trad_frame_set_id (cache,
727 frame_id_build (trad_frame_get_this_base (cache),
728 start));
729 else
730 trad_frame_set_id (cache,
731 frame_id_build (trad_frame_get_this_base (cache),
732 frame_func_unwind (next_frame)));
733
734 (*this_prologue_cache) = cache;
735 return cache;
736 }
737
738 /* Here is a dummy implementation. */
739 static struct frame_id
740 mn10300_unwind_dummy_id (struct gdbarch *gdbarch,
741 struct frame_info *next_frame)
742 {
743 return frame_id_build (frame_sp_unwind (next_frame),
744 frame_pc_unwind (next_frame));
745 }
746
747 /* Trad frame implementation. */
748 static void
749 mn10300_frame_this_id (struct frame_info *next_frame,
750 void **this_prologue_cache,
751 struct frame_id *this_id)
752 {
753 struct trad_frame_cache *cache =
754 mn10300_frame_unwind_cache (next_frame, this_prologue_cache);
755
756 trad_frame_get_id (cache, this_id);
757 }
758
759 static void
760 mn10300_frame_prev_register (struct frame_info *next_frame,
761 void **this_prologue_cache,
762 int regnum, int *optimizedp,
763 enum lval_type *lvalp, CORE_ADDR *addrp,
764 int *realnump, gdb_byte *bufferp)
765 {
766 struct trad_frame_cache *cache =
767 mn10300_frame_unwind_cache (next_frame, this_prologue_cache);
768
769 trad_frame_get_register (cache, next_frame, regnum, optimizedp,
770 lvalp, addrp, realnump, bufferp);
771 /* Or...
772 trad_frame_get_prev_register (next_frame, cache->prev_regs, regnum,
773 optimizedp, lvalp, addrp, realnump, bufferp);
774 */
775 }
776
777 static const struct frame_unwind mn10300_frame_unwind = {
778 NORMAL_FRAME,
779 mn10300_frame_this_id,
780 mn10300_frame_prev_register
781 };
782
783 static CORE_ADDR
784 mn10300_frame_base_address (struct frame_info *next_frame,
785 void **this_prologue_cache)
786 {
787 struct trad_frame_cache *cache =
788 mn10300_frame_unwind_cache (next_frame, this_prologue_cache);
789
790 return trad_frame_get_this_base (cache);
791 }
792
793 static const struct frame_unwind *
794 mn10300_frame_sniffer (struct frame_info *next_frame)
795 {
796 return &mn10300_frame_unwind;
797 }
798
799 static const struct frame_base mn10300_frame_base = {
800 &mn10300_frame_unwind,
801 mn10300_frame_base_address,
802 mn10300_frame_base_address,
803 mn10300_frame_base_address
804 };
805
806 static CORE_ADDR
807 mn10300_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
808 {
809 ULONGEST pc;
810
811 frame_unwind_unsigned_register (next_frame, E_PC_REGNUM, &pc);
812 return pc;
813 }
814
815 static CORE_ADDR
816 mn10300_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
817 {
818 ULONGEST sp;
819
820 frame_unwind_unsigned_register (next_frame, E_SP_REGNUM, &sp);
821 return sp;
822 }
823
824 static void
825 mn10300_frame_unwind_init (struct gdbarch *gdbarch)
826 {
827 frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer);
828 frame_unwind_append_sniffer (gdbarch, mn10300_frame_sniffer);
829 frame_base_set_default (gdbarch, &mn10300_frame_base);
830 set_gdbarch_unwind_dummy_id (gdbarch, mn10300_unwind_dummy_id);
831 set_gdbarch_unwind_pc (gdbarch, mn10300_unwind_pc);
832 set_gdbarch_unwind_sp (gdbarch, mn10300_unwind_sp);
833 }
834
835 /* Function: push_dummy_call
836 *
837 * Set up machine state for a target call, including
838 * function arguments, stack, return address, etc.
839 *
840 */
841
842 static CORE_ADDR
843 mn10300_push_dummy_call (struct gdbarch *gdbarch,
844 struct value *target_func,
845 struct regcache *regcache,
846 CORE_ADDR bp_addr,
847 int nargs, struct value **args,
848 CORE_ADDR sp,
849 int struct_return,
850 CORE_ADDR struct_addr)
851 {
852 const int push_size = register_size (gdbarch, E_PC_REGNUM);
853 int regs_used;
854 int len, arg_len;
855 int stack_offset = 0;
856 int argnum;
857 char *val, valbuf[MAX_REGISTER_SIZE];
858
859 /* This should be a nop, but align the stack just in case something
860 went wrong. Stacks are four byte aligned on the mn10300. */
861 sp &= ~3;
862
863 /* Now make space on the stack for the args.
864
865 XXX This doesn't appear to handle pass-by-invisible reference
866 arguments. */
867 regs_used = struct_return ? 1 : 0;
868 for (len = 0, argnum = 0; argnum < nargs; argnum++)
869 {
870 arg_len = (TYPE_LENGTH (value_type (args[argnum])) + 3) & ~3;
871 while (regs_used < 2 && arg_len > 0)
872 {
873 regs_used++;
874 arg_len -= push_size;
875 }
876 len += arg_len;
877 }
878
879 /* Allocate stack space. */
880 sp -= len;
881
882 if (struct_return)
883 {
884 regs_used = 1;
885 write_register (E_D0_REGNUM, struct_addr);
886 }
887 else
888 regs_used = 0;
889
890 /* Push all arguments onto the stack. */
891 for (argnum = 0; argnum < nargs; argnum++)
892 {
893 /* FIXME what about structs? Unions? */
894 if (TYPE_CODE (value_type (*args)) == TYPE_CODE_STRUCT
895 && TYPE_LENGTH (value_type (*args)) > 8)
896 {
897 /* Change to pointer-to-type. */
898 arg_len = push_size;
899 store_unsigned_integer (valbuf, push_size,
900 VALUE_ADDRESS (*args));
901 val = &valbuf[0];
902 }
903 else
904 {
905 arg_len = TYPE_LENGTH (value_type (*args));
906 val = (char *) value_contents (*args);
907 }
908
909 while (regs_used < 2 && arg_len > 0)
910 {
911 write_register (regs_used,
912 extract_unsigned_integer (val, push_size));
913 val += push_size;
914 arg_len -= push_size;
915 regs_used++;
916 }
917
918 while (arg_len > 0)
919 {
920 write_memory (sp + stack_offset, val, push_size);
921 arg_len -= push_size;
922 val += push_size;
923 stack_offset += push_size;
924 }
925
926 args++;
927 }
928
929 /* Make space for the flushback area. */
930 sp -= 8;
931
932 /* Push the return address that contains the magic breakpoint. */
933 sp -= 4;
934 write_memory_unsigned_integer (sp, push_size, bp_addr);
935 /* Update $sp. */
936 regcache_cooked_write_unsigned (regcache, E_SP_REGNUM, sp);
937 return sp;
938 }
939
940 /* If DWARF2 is a register number appearing in Dwarf2 debug info, then
941 mn10300_dwarf2_reg_to_regnum (DWARF2) is the corresponding GDB
942 register number. Why don't Dwarf2 and GDB use the same numbering?
943 Who knows? But since people have object files lying around with
944 the existing Dwarf2 numbering, and other people have written stubs
945 to work with the existing GDB, neither of them can change. So we
946 just have to cope. */
947 static int
948 mn10300_dwarf2_reg_to_regnum (int dwarf2)
949 {
950 /* This table is supposed to be shaped like the REGISTER_NAMES
951 initializer in gcc/config/mn10300/mn10300.h. Registers which
952 appear in GCC's numbering, but have no counterpart in GDB's
953 world, are marked with a -1. */
954 static int dwarf2_to_gdb[] = {
955 0, 1, 2, 3, 4, 5, 6, 7, -1, 8,
956 15, 16, 17, 18, 19, 20, 21, 22,
957 32, 33, 34, 35, 36, 37, 38, 39,
958 40, 41, 42, 43, 44, 45, 46, 47,
959 48, 49, 50, 51, 52, 53, 54, 55,
960 56, 57, 58, 59, 60, 61, 62, 63
961 };
962
963 if (dwarf2 < 0
964 || dwarf2 >= ARRAY_SIZE (dwarf2_to_gdb)
965 || dwarf2_to_gdb[dwarf2] == -1)
966 {
967 warning (_("Bogus register number in debug info: %d"), dwarf2);
968 return 0;
969 }
970
971 return dwarf2_to_gdb[dwarf2];
972 }
973
974 static struct gdbarch *
975 mn10300_gdbarch_init (struct gdbarch_info info,
976 struct gdbarch_list *arches)
977 {
978 struct gdbarch *gdbarch;
979 struct gdbarch_tdep *tdep;
980
981 arches = gdbarch_list_lookup_by_info (arches, &info);
982 if (arches != NULL)
983 return arches->gdbarch;
984
985 tdep = xmalloc (sizeof (struct gdbarch_tdep));
986 gdbarch = gdbarch_alloc (&info, tdep);
987
988 switch (info.bfd_arch_info->mach)
989 {
990 case 0:
991 case bfd_mach_mn10300:
992 set_gdbarch_register_name (gdbarch, mn10300_generic_register_name);
993 tdep->am33_mode = 0;
994 break;
995 case bfd_mach_am33:
996 set_gdbarch_register_name (gdbarch, am33_register_name);
997 tdep->am33_mode = 1;
998 break;
999 default:
1000 internal_error (__FILE__, __LINE__,
1001 _("mn10300_gdbarch_init: Unknown mn10300 variant"));
1002 break;
1003 }
1004
1005 /* Registers. */
1006 set_gdbarch_num_regs (gdbarch, E_NUM_REGS);
1007 set_gdbarch_register_type (gdbarch, mn10300_register_type);
1008 set_gdbarch_skip_prologue (gdbarch, mn10300_skip_prologue);
1009 set_gdbarch_read_pc (gdbarch, mn10300_read_pc);
1010 set_gdbarch_write_pc (gdbarch, mn10300_write_pc);
1011 set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);
1012 set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM);
1013 set_gdbarch_dwarf2_reg_to_regnum (gdbarch, mn10300_dwarf2_reg_to_regnum);
1014
1015 /* Stack unwinding. */
1016 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1017 /* Breakpoints. */
1018 set_gdbarch_breakpoint_from_pc (gdbarch, mn10300_breakpoint_from_pc);
1019 /* decr_pc_after_break? */
1020 /* Disassembly. */
1021 set_gdbarch_print_insn (gdbarch, print_insn_mn10300);
1022
1023 /* Stage 2 */
1024 set_gdbarch_return_value (gdbarch, mn10300_return_value);
1025
1026 /* Stage 3 -- get target calls working. */
1027 set_gdbarch_push_dummy_call (gdbarch, mn10300_push_dummy_call);
1028 /* set_gdbarch_return_value (store, extract) */
1029
1030
1031 mn10300_frame_unwind_init (gdbarch);
1032
1033 /* Hook in ABI-specific overrides, if they have been registered. */
1034 gdbarch_init_osabi (info, gdbarch);
1035
1036 return gdbarch;
1037 }
1038
1039 /* Dump out the mn10300 specific architecture information. */
1040
1041 static void
1042 mn10300_dump_tdep (struct gdbarch *current_gdbarch, struct ui_file *file)
1043 {
1044 struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1045 fprintf_unfiltered (file, "mn10300_dump_tdep: am33_mode = %d\n",
1046 tdep->am33_mode);
1047 }
1048
1049 void
1050 _initialize_mn10300_tdep (void)
1051 {
1052 gdbarch_register (bfd_arch_mn10300, mn10300_gdbarch_init, mn10300_dump_tdep);
1053 }
1054
This page took 0.052215 seconds and 4 git commands to generate.