1 /* Target-dependent code for the Matsushita MN10200 for GDB, the GNU debugger.
2 Copyright 1997 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
27 #include "gdb_string.h"
31 /* The main purpose of this file is dealing with prologues to extract
32 information about stack frames and saved registers.
34 For reference here's how prologues look on the mn10200:
40 Register saves for d2, d3, a1, a2 as needed. Saves start
41 at fp - <size> + <outgoing_args_size> and work towards higher
42 addresses. Note that the saves are actually done off the stack
43 pointer in the prologue! This makes for smaller code and easier
44 prologue scanning as the displacement fields will unlikely
47 Without frame pointer:
49 Register saves for d2, d3, a1, a2 as needed. Saves start
50 at sp + <outgoing_args_size> and work towards higher addresses.
53 add <local size>,sp -- optional
55 add <outgoing_size>,sp -- optional
57 The stack pointer remains constant throughout the life of most
58 functions. As a result the compiler will usually omit the
59 frame pointer, so we must handle frame pointerless functions. */
61 /* Analyze the prologue to determine where registers are saved,
62 the end of the prologue, etc etc. Return the end of the prologue
65 We store into FI (if non-null) several tidbits of information:
67 * stack_size -- size of this stack frame. Note that if we stop in
68 certain parts of the prologue/epilogue we may claim the size of the
69 current frame is zero. This happens when the current frame has
70 not been allocated yet or has already been deallocated.
72 * fsr -- Addresses of registers saved in the stack by this frame.
74 * status -- A (relatively) generic status indicator. It's a bitmask
75 with the following bits:
77 MY_FRAME_IN_SP: The base of the current frame is actually in
78 the stack pointer. This can happen for frame pointerless
79 functions, or cases where we're stopped in the prologue/epilogue
80 itself. For these cases mn10200_analyze_prologue will need up
81 update fi->frame before returning or analyzing the register
84 MY_FRAME_IN_FP: The base of the current frame is in the
85 frame pointer register ($a2).
87 CALLER_A2_IN_A0: $a2 from the caller's frame is temporarily
88 in $a0. This can happen if we're stopped in the prologue.
90 NO_MORE_FRAMES: Set this if the current frame is "start" or
91 if the first instruction looks like mov <imm>,sp. This tells
92 frame chain to not bother trying to unwind past this frame. */
94 #define MY_FRAME_IN_SP 0x1
95 #define MY_FRAME_IN_FP 0x2
96 #define CALLER_A2_IN_A0 0x4
97 #define NO_MORE_FRAMES 0x8
100 mn10200_analyze_prologue (fi
, pc
)
101 struct frame_info
*fi
;
104 CORE_ADDR func_addr
, func_end
, addr
, stop
;
105 CORE_ADDR stack_size
;
106 unsigned char buf
[4];
109 int out_of_line_prologue
= 0;
111 /* Use the PC in the frame if it's provided to look up the
112 start of this function. */
113 pc
= (fi
? fi
->pc
: pc
);
115 /* Find the start of this function. */
116 status
= find_pc_partial_function (pc
, &name
, &func_addr
, &func_end
);
118 /* Do nothing if we couldn't find the start of this function or if we're
119 stopped at the first instruction in the prologue. */
123 /* If we're in start, then give up. */
124 if (strcmp (name
, "start") == 0)
127 fi
->status
= NO_MORE_FRAMES
;
131 /* At the start of a function our frame is in the stack pointer. */
133 fi
->status
= MY_FRAME_IN_SP
;
135 /* If we're physically on an RTS instruction, then our frame has already
138 fi->frame is bogus, we need to fix it. */
139 if (fi
&& fi
->pc
+ 1 == func_end
)
141 status
= target_read_memory (fi
->pc
, buf
, 1);
144 if (fi
->next
== NULL
)
145 fi
->frame
= read_sp ();
151 if (fi
->next
== NULL
)
152 fi
->frame
= read_sp ();
157 /* Similarly if we're stopped on the first insn of a prologue as our
158 frame hasn't been allocated yet. */
159 if (fi
&& fi
->pc
== func_addr
)
161 if (fi
->next
== NULL
)
162 fi
->frame
= read_sp ();
166 /* Figure out where to stop scanning. */
167 stop
= fi
? fi
->pc
: func_end
;
169 /* Don't walk off the end of the function. */
170 stop
= stop
> func_end
? func_end
: stop
;
172 /* Start scanning on the first instruction of this function. */
175 status
= target_read_memory (addr
, buf
, 2);
178 if (fi
&& fi
->next
== NULL
&& fi
->status
& MY_FRAME_IN_SP
)
179 fi
->frame
= read_sp ();
183 /* First see if this insn sets the stack pointer; if so, it's something
184 we won't understand, so quit now. */
186 || (buf
[0] == 0xf4 && buf
[1] == 0x77))
189 fi
->status
= NO_MORE_FRAMES
;
193 /* Now see if we have a frame pointer.
195 Search for mov a2,a0 (0xf278)
196 then mov a3,a2 (0xf27e). */
198 if (buf
[0] == 0xf2 && buf
[1] == 0x78)
200 /* Our caller's $a2 will be found in $a0 now. Note it for
203 fi
->status
|= CALLER_A2_IN_A0
;
207 /* We still haven't allocated our local stack. Handle this
208 as if we stopped on the first or last insn of a function. */
209 if (fi
&& fi
->next
== NULL
)
210 fi
->frame
= read_sp ();
214 status
= target_read_memory (addr
, buf
, 2);
217 if (fi
&& fi
->next
== NULL
)
218 fi
->frame
= read_sp ();
221 if (buf
[0] == 0xf2 && buf
[1] == 0x7e)
225 /* Our frame pointer is valid now. */
228 fi
->status
|= MY_FRAME_IN_FP
;
229 fi
->status
&= ~MY_FRAME_IN_SP
;
236 if (fi
&& fi
->next
== NULL
)
237 fi
->frame
= read_sp ();
242 /* Next we should allocate the local frame.
244 Search for add imm8,a3 (0xd3XX)
245 or add imm16,a3 (0xf70bXXXX)
246 or add imm24,a3 (0xf467XXXXXX).
248 If none of the above was found, then this prologue has
249 no stack, and therefore can't have any register saves,
251 status
= target_read_memory (addr
, buf
, 2);
254 if (fi
&& fi
->next
== NULL
&& (fi
->status
& MY_FRAME_IN_SP
))
255 fi
->frame
= read_sp ();
260 stack_size
= extract_signed_integer (&buf
[1], 1);
262 fi
->stack_size
= stack_size
;
266 if (fi
&& fi
->next
== NULL
&& (fi
->status
& MY_FRAME_IN_SP
))
267 fi
->frame
= read_sp () - stack_size
;
271 else if (buf
[0] == 0xf7 && buf
[1] == 0x0b)
273 status
= target_read_memory (addr
+ 2, buf
, 2);
276 if (fi
&& fi
->next
== NULL
&& (fi
->status
& MY_FRAME_IN_SP
))
277 fi
->frame
= read_sp ();
280 stack_size
= extract_signed_integer (buf
, 2);
282 fi
->stack_size
= stack_size
;
286 if (fi
&& fi
->next
== NULL
&& (fi
->status
& MY_FRAME_IN_SP
))
287 fi
->frame
= read_sp () - stack_size
;
291 else if (buf
[0] == 0xf4 && buf
[1] == 0x67)
293 status
= target_read_memory (addr
+ 2, buf
, 3);
296 if (fi
&& fi
->next
== NULL
&& (fi
->status
& MY_FRAME_IN_SP
))
297 fi
->frame
= read_sp ();
300 stack_size
= extract_signed_integer (buf
, 3);
302 fi
->stack_size
= stack_size
;
306 if (fi
&& fi
->next
== NULL
&& (fi
->status
& MY_FRAME_IN_SP
))
307 fi
->frame
= read_sp () - stack_size
;
312 /* Now see if we have a call to __prologue for an out of line
314 status
= target_read_memory (addr
, buf
, 2);
318 /* First check for 16bit pc-relative call to __prologue. */
322 status
= target_read_memory (addr
+ 1, buf
, 2);
325 if (fi
&& fi
->next
== NULL
&& (fi
->status
& MY_FRAME_IN_SP
))
326 fi
->frame
= read_sp ();
330 /* Get the PC this instruction will branch to. */
331 temp
= (extract_signed_integer (buf
, 2) + addr
+ 3) & 0xffffff;
333 /* Get the name of the function at the target address. */
334 status
= find_pc_partial_function (temp
, &name
, NULL
, NULL
);
337 if (fi
&& fi
->next
== NULL
&& (fi
->status
& MY_FRAME_IN_SP
))
338 fi
->frame
= read_sp ();
342 /* Note if it is an out of line prologue. */
343 out_of_line_prologue
= (strcmp (name
, "__prologue") == 0);
345 /* This sucks up 3 bytes of instruction space. */
346 if (out_of_line_prologue
)
351 if (fi
&& fi
->next
== NULL
)
353 fi
->stack_size
-= 16;
354 fi
->frame
= read_sp () - fi
->stack_size
;
359 /* Now check for the 24bit pc-relative call to __prologue. */
360 else if (buf
[0] == 0xf4 && buf
[1] == 0xe1)
363 status
= target_read_memory (addr
+ 2, buf
, 3);
366 if (fi
&& fi
->next
== NULL
&& (fi
->status
& MY_FRAME_IN_SP
))
367 fi
->frame
= read_sp ();
371 /* Get the PC this instruction will branch to. */
372 temp
= (extract_signed_integer (buf
, 3) + addr
+ 5) & 0xffffff;
374 /* Get the name of the function at the target address. */
375 status
= find_pc_partial_function (temp
, &name
, NULL
, NULL
);
378 if (fi
&& fi
->next
== NULL
&& (fi
->status
& MY_FRAME_IN_SP
))
379 fi
->frame
= read_sp ();
383 /* Note if it is an out of line prologue. */
384 out_of_line_prologue
= (strcmp (name
, "__prologue") == 0);
386 /* This sucks up 5 bytes of instruction space. */
387 if (out_of_line_prologue
)
392 if (fi
&& fi
->next
== NULL
&& (fi
->status
& MY_FRAME_IN_SP
))
394 fi
->stack_size
-= 16;
395 fi
->frame
= read_sp () - fi
->stack_size
;
401 /* Now actually handle the out of line prologue. */
402 if (out_of_line_prologue
)
404 int outgoing_args_size
= 0;
406 /* First adjust the stack size for this function. The out of
407 line prologue saves 4 registers (16bytes of data). */
409 fi
->stack_size
-= 16;
411 /* Update fi->frame if necessary. */
412 if (fi
&& fi
->next
== NULL
)
413 fi
->frame
= read_sp () - fi
->stack_size
;
415 /* After the out of line prologue, there may be another
416 stack adjustment for the outgoing arguments.
418 Search for add imm8,a3 (0xd3XX)
419 or add imm16,a3 (0xf70bXXXX)
420 or add imm24,a3 (0xf467XXXXXX). */
422 status
= target_read_memory (addr
, buf
, 2);
427 fi
->fsr
.regs
[2] = fi
->frame
+ fi
->stack_size
+ 4;
428 fi
->fsr
.regs
[3] = fi
->frame
+ fi
->stack_size
+ 8;
429 fi
->fsr
.regs
[5] = fi
->frame
+ fi
->stack_size
+ 12;
430 fi
->fsr
.regs
[6] = fi
->frame
+ fi
->stack_size
+ 16;
437 outgoing_args_size
= extract_signed_integer (&buf
[1], 1);
440 else if (buf
[0] == 0xf7 && buf
[1] == 0x0b)
442 status
= target_read_memory (addr
+ 2, buf
, 2);
447 fi
->fsr
.regs
[2] = fi
->frame
+ fi
->stack_size
+ 4;
448 fi
->fsr
.regs
[3] = fi
->frame
+ fi
->stack_size
+ 8;
449 fi
->fsr
.regs
[5] = fi
->frame
+ fi
->stack_size
+ 12;
450 fi
->fsr
.regs
[6] = fi
->frame
+ fi
->stack_size
+ 16;
454 outgoing_args_size
= extract_signed_integer (buf
, 2);
457 else if (buf
[0] == 0xf4 && buf
[1] == 0x67)
459 status
= target_read_memory (addr
+ 2, buf
, 3);
462 if (fi
&& fi
->next
== NULL
)
464 fi
->fsr
.regs
[2] = fi
->frame
+ fi
->stack_size
+ 4;
465 fi
->fsr
.regs
[3] = fi
->frame
+ fi
->stack_size
+ 8;
466 fi
->fsr
.regs
[5] = fi
->frame
+ fi
->stack_size
+ 12;
467 fi
->fsr
.regs
[6] = fi
->frame
+ fi
->stack_size
+ 16;
471 outgoing_args_size
= extract_signed_integer (buf
, 3);
475 outgoing_args_size
= 0;
477 /* Now that we know the size of the outgoing arguments, fix
478 fi->frame again if this is the innermost frame. */
479 if (fi
&& fi
->next
== NULL
)
480 fi
->frame
-= outgoing_args_size
;
482 /* Note the register save information and update the stack
483 size for this frame too. */
486 fi
->fsr
.regs
[2] = fi
->frame
+ fi
->stack_size
+ 4;
487 fi
->fsr
.regs
[3] = fi
->frame
+ fi
->stack_size
+ 8;
488 fi
->fsr
.regs
[5] = fi
->frame
+ fi
->stack_size
+ 12;
489 fi
->fsr
.regs
[6] = fi
->frame
+ fi
->stack_size
+ 16;
490 fi
->stack_size
+= outgoing_args_size
;
492 /* There can be no more prologue insns, so return now. */
496 /* At this point fi->frame needs to be correct.
498 If MY_FRAME_IN_SP is set and we're the innermost frame, then we
499 need to fix fi->frame so that backtracing, find_frame_saved_regs,
500 etc work correctly. */
501 if (fi
&& fi
->next
== NULL
&& (fi
->status
& MY_FRAME_IN_SP
) != 0)
502 fi
->frame
= read_sp () - fi
->stack_size
;
504 /* And last we have the register saves. These are relatively
505 simple because they're physically done off the stack pointer,
506 and thus the number of different instructions we need to
507 check is greatly reduced because we know the displacements
510 Search for movx d2,(X,a3) (0xf55eXX)
511 then movx d3,(X,a3) (0xf55fXX)
512 then mov a1,(X,a3) (0x5dXX) No frame pointer case
513 then mov a2,(X,a3) (0x5eXX) No frame pointer case
514 or mov a0,(X,a3) (0x5cXX) Frame pointer case. */
516 status
= target_read_memory (addr
, buf
, 2);
519 if (buf
[0] == 0xf5 && buf
[1] == 0x5e)
523 status
= target_read_memory (addr
+ 2, buf
, 1);
526 fi
->fsr
.regs
[2] = (fi
->frame
+ stack_size
527 + extract_signed_integer (buf
, 1));
532 status
= target_read_memory (addr
, buf
, 2);
536 if (buf
[0] == 0xf5 && buf
[1] == 0x5f)
540 status
= target_read_memory (addr
+ 2, buf
, 1);
543 fi
->fsr
.regs
[3] = (fi
->frame
+ stack_size
544 + extract_signed_integer (buf
, 1));
549 status
= target_read_memory (addr
, buf
, 2);
557 status
= target_read_memory (addr
+ 1, buf
, 1);
560 fi
->fsr
.regs
[5] = (fi
->frame
+ stack_size
561 + extract_signed_integer (buf
, 1));
566 status
= target_read_memory (addr
, buf
, 2);
570 if (buf
[0] == 0x5e || buf
[0] == 0x5c)
574 status
= target_read_memory (addr
+ 1, buf
, 1);
577 fi
->fsr
.regs
[6] = (fi
->frame
+ stack_size
578 + extract_signed_integer (buf
, 1));
579 fi
->status
&= ~CALLER_A2_IN_A0
;
589 /* Function: frame_chain
590 Figure out and return the caller's frame pointer given current
593 We don't handle dummy frames yet but we would probably just return the
594 stack pointer that was in use at the time the function call was made? */
597 mn10200_frame_chain (fi
)
598 struct frame_info
*fi
;
600 struct frame_info dummy_frame
;
602 /* Walk through the prologue to determine the stack size,
603 location of saved registers, end of the prologue, etc. */
605 mn10200_analyze_prologue (fi
, (CORE_ADDR
)0);
607 /* Quit now if mn10200_analyze_prologue set NO_MORE_FRAMES. */
608 if (fi
->status
& NO_MORE_FRAMES
)
611 /* Now that we've analyzed our prologue, determine the frame
612 pointer for our caller.
614 If our caller has a frame pointer, then we need to
615 find the entry value of $a2 to our function.
617 If CALLER_A2_IN_A0, then the chain is in $a0.
619 If fsr.regs[6] is nonzero, then it's at the memory
620 location pointed to by fsr.regs[6].
622 Else it's still in $a2.
624 If our caller does not have a frame pointer, then his
625 frame base is fi->frame + -caller's stack size + 4. */
627 /* The easiest way to get that info is to analyze our caller's frame.
629 So we set up a dummy frame and call mn10200_analyze_prologue to
630 find stuff for us. */
631 dummy_frame
.pc
= FRAME_SAVED_PC (fi
);
632 dummy_frame
.frame
= fi
->frame
;
633 memset (dummy_frame
.fsr
.regs
, '\000', sizeof dummy_frame
.fsr
.regs
);
634 dummy_frame
.status
= 0;
635 dummy_frame
.stack_size
= 0;
636 mn10200_analyze_prologue (&dummy_frame
);
638 if (dummy_frame
.status
& MY_FRAME_IN_FP
)
640 /* Our caller has a frame pointer. So find the frame in $a2, $a0,
643 return (read_memory_integer (fi
->fsr
.regs
[FP_REGNUM
], REGISTER_SIZE
)
645 else if (fi
->status
& CALLER_A2_IN_A0
)
646 return read_register (4);
648 return read_register (FP_REGNUM
);
652 /* Our caller does not have a frame pointer. So his frame starts
653 at the base of our frame (fi->frame) + <his size> + 4 (saved pc). */
654 return fi
->frame
+ -dummy_frame
.stack_size
+ 4;
658 /* Function: skip_prologue
659 Return the address of the first inst past the prologue of the function. */
662 mn10200_skip_prologue (pc
)
665 /* We used to check the debug symbols, but that can lose if
666 we have a null prologue. */
667 return mn10200_analyze_prologue (NULL
, pc
);
670 /* Function: pop_frame
671 This routine gets called when either the user uses the `return'
672 command, or the call dummy breakpoint gets hit. */
675 mn10200_pop_frame (frame
)
676 struct frame_info
*frame
;
680 if (PC_IN_CALL_DUMMY(frame
->pc
, frame
->frame
, frame
->frame
))
681 generic_pop_dummy_frame ();
684 write_register (PC_REGNUM
, FRAME_SAVED_PC (frame
));
686 /* Restore any saved registers. */
687 for (regnum
= 0; regnum
< NUM_REGS
; regnum
++)
688 if (frame
->fsr
.regs
[regnum
] != 0)
692 value
= read_memory_unsigned_integer (frame
->fsr
.regs
[regnum
],
693 REGISTER_RAW_SIZE (regnum
));
694 write_register (regnum
, value
);
697 /* Actually cut back the stack. */
698 write_register (SP_REGNUM
, FRAME_FP (frame
));
700 /* Don't we need to set the PC?!? XXX FIXME. */
703 /* Throw away any cached frame information. */
704 flush_cached_frames ();
707 /* Function: push_arguments
708 Setup arguments for a call to the target. Arguments go in
709 order on the stack. */
712 mn10200_push_arguments (nargs
, args
, sp
, struct_return
, struct_addr
)
716 unsigned char struct_return
;
717 CORE_ADDR struct_addr
;
721 int stack_offset
= 0;
722 int regsused
= struct_return
? 1 : 0;
724 /* This should be a nop, but align the stack just in case something
725 went wrong. Stacks are two byte aligned on the mn10200. */
728 /* Now make space on the stack for the args.
730 XXX This doesn't appear to handle pass-by-invisible reference
732 for (argnum
= 0; argnum
< nargs
; argnum
++)
734 int arg_length
= (TYPE_LENGTH (VALUE_TYPE (args
[argnum
])) + 1) & ~1;
736 /* If we've used all argument registers, then this argument is
738 if (regsused
>= 2 || arg_length
> 4)
743 /* We know we've got some arg register space left. If this argument
744 will fit entirely in regs, then put it there. */
745 else if (arg_length
<= 2
746 || TYPE_CODE (VALUE_TYPE (args
[argnum
])) == TYPE_CODE_PTR
)
750 else if (regsused
== 0)
761 /* Allocate stack space. */
764 regsused
= struct_return
? 1 : 0;
765 /* Push all arguments onto the stack. */
766 for (argnum
= 0; argnum
< nargs
; argnum
++)
771 /* XXX Check this. What about UNIONS? */
772 if (TYPE_CODE (VALUE_TYPE (*args
)) == TYPE_CODE_STRUCT
773 && TYPE_LENGTH (VALUE_TYPE (*args
)) > 8)
775 /* XXX Wrong, we want a pointer to this argument. */
776 len
= TYPE_LENGTH (VALUE_TYPE (*args
));
777 val
= (char *)VALUE_CONTENTS (*args
);
781 len
= TYPE_LENGTH (VALUE_TYPE (*args
));
782 val
= (char *)VALUE_CONTENTS (*args
);
787 || TYPE_CODE (VALUE_TYPE (*args
)) == TYPE_CODE_PTR
))
789 write_register (regsused
, extract_unsigned_integer (val
, 4));
792 else if (regsused
== 0 && len
== 4)
794 write_register (regsused
, extract_unsigned_integer (val
, 2));
795 write_register (regsused
+ 1, extract_unsigned_integer (val
+ 2, 2));
803 write_memory (sp
+ stack_offset
, val
, 2);
816 /* Function: push_return_address (pc)
817 Set up the return address for the inferior function call.
818 Needed for targets where we don't actually execute a JSR/BSR instruction */
821 mn10200_push_return_address (pc
, sp
)
825 unsigned char buf
[4];
827 store_unsigned_integer (buf
, 4, CALL_DUMMY_ADDRESS ());
828 write_memory (sp
- 4, buf
, 4);
832 /* Function: store_struct_return (addr,sp)
833 Store the structure value return address for an inferior function
837 mn10200_store_struct_return (addr
, sp
)
841 /* The structure return address is passed as the first argument. */
842 write_register (0, addr
);
846 /* Function: frame_saved_pc
847 Find the caller of this frame. We do this by seeing if RP_REGNUM
848 is saved in the stack anywhere, otherwise we get it from the
849 registers. If the inner frame is a dummy frame, return its PC
850 instead of RP, because that's where "caller" of the dummy-frame
854 mn10200_frame_saved_pc (fi
)
855 struct frame_info
*fi
;
857 /* The saved PC will always be at the base of the current frame. */
858 return (read_memory_integer (fi
->frame
, REGISTER_SIZE
) & 0xffffff);
862 get_saved_register (raw_buffer
, optimized
, addrp
, frame
, regnum
, lval
)
866 struct frame_info
*frame
;
868 enum lval_type
*lval
;
870 generic_get_saved_register (raw_buffer
, optimized
, addrp
,
871 frame
, regnum
, lval
);
874 /* Function: init_extra_frame_info
875 Setup the frame's frame pointer, pc, and frame addresses for saved
876 registers. Most of the work is done in mn10200_analyze_prologue().
878 Note that when we are called for the last frame (currently active frame),
879 that fi->pc and fi->frame will already be setup. However, fi->frame will
880 be valid only if this routine uses FP. For previous frames, fi-frame will
881 always be correct. mn10200_analyze_prologue will fix fi->frame if
884 We can be called with the PC in the call dummy under two circumstances.
885 First, during normal backtracing, second, while figuring out the frame
886 pointer just prior to calling the target function (see run_stack_dummy). */
889 mn10200_init_extra_frame_info (fi
)
890 struct frame_info
*fi
;
893 fi
->pc
= FRAME_SAVED_PC (fi
->next
);
895 memset (fi
->fsr
.regs
, '\000', sizeof fi
->fsr
.regs
);
899 mn10200_analyze_prologue (fi
, 0);
903 _initialize_mn10200_tdep ()
905 tm_print_insn
= print_insn_mn10200
;
This page took 0.066747 seconds and 4 git commands to generate.