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,
19 Boston, MA 02111-1307, USA. */
28 #include "gdb_string.h"
33 /* Should call_function allocate stack space for a struct return? */
35 mn10200_use_struct_convention (gcc_p
, type
)
39 return (TYPE_NFIELDS (type
) > 1 || TYPE_LENGTH (type
) > 8);
42 /* The main purpose of this file is dealing with prologues to extract
43 information about stack frames and saved registers.
45 For reference here's how prologues look on the mn10200:
51 Register saves for d2, d3, a1, a2 as needed. Saves start
52 at fp - <size> + <outgoing_args_size> and work towards higher
53 addresses. Note that the saves are actually done off the stack
54 pointer in the prologue! This makes for smaller code and easier
55 prologue scanning as the displacement fields will unlikely
58 Without frame pointer:
60 Register saves for d2, d3, a1, a2 as needed. Saves start
61 at sp + <outgoing_args_size> and work towards higher addresses.
64 add <local size>,sp -- optional
66 add <outgoing_size>,sp -- optional
68 The stack pointer remains constant throughout the life of most
69 functions. As a result the compiler will usually omit the
70 frame pointer, so we must handle frame pointerless functions. */
72 /* Analyze the prologue to determine where registers are saved,
73 the end of the prologue, etc etc. Return the end of the prologue
76 We store into FI (if non-null) several tidbits of information:
78 * stack_size -- size of this stack frame. Note that if we stop in
79 certain parts of the prologue/epilogue we may claim the size of the
80 current frame is zero. This happens when the current frame has
81 not been allocated yet or has already been deallocated.
83 * fsr -- Addresses of registers saved in the stack by this frame.
85 * status -- A (relatively) generic status indicator. It's a bitmask
86 with the following bits:
88 MY_FRAME_IN_SP: The base of the current frame is actually in
89 the stack pointer. This can happen for frame pointerless
90 functions, or cases where we're stopped in the prologue/epilogue
91 itself. For these cases mn10200_analyze_prologue will need up
92 update fi->frame before returning or analyzing the register
95 MY_FRAME_IN_FP: The base of the current frame is in the
96 frame pointer register ($a2).
98 CALLER_A2_IN_A0: $a2 from the caller's frame is temporarily
99 in $a0. This can happen if we're stopped in the prologue.
101 NO_MORE_FRAMES: Set this if the current frame is "start" or
102 if the first instruction looks like mov <imm>,sp. This tells
103 frame chain to not bother trying to unwind past this frame. */
109 #define MY_FRAME_IN_SP 0x1
110 #define MY_FRAME_IN_FP 0x2
111 #define CALLER_A2_IN_A0 0x4
112 #define NO_MORE_FRAMES 0x8
115 mn10200_analyze_prologue (fi
, pc
)
116 struct frame_info
*fi
;
119 CORE_ADDR func_addr
, func_end
, addr
, stop
;
120 CORE_ADDR stack_size
;
121 unsigned char buf
[4];
124 int out_of_line_prologue
= 0;
126 /* Use the PC in the frame if it's provided to look up the
127 start of this function. */
128 pc
= (fi
? fi
->pc
: pc
);
130 /* Find the start of this function. */
131 status
= find_pc_partial_function (pc
, &name
, &func_addr
, &func_end
);
133 /* Do nothing if we couldn't find the start of this function or if we're
134 stopped at the first instruction in the prologue. */
138 /* If we're in start, then give up. */
139 if (strcmp (name
, "start") == 0)
142 fi
->status
= NO_MORE_FRAMES
;
146 /* At the start of a function our frame is in the stack pointer. */
148 fi
->status
= MY_FRAME_IN_SP
;
150 /* If we're physically on an RTS instruction, then our frame has already
153 fi->frame is bogus, we need to fix it. */
154 if (fi
&& fi
->pc
+ 1 == func_end
)
156 status
= target_read_memory (fi
->pc
, buf
, 1);
159 if (fi
->next
== NULL
)
160 fi
->frame
= read_sp ();
166 if (fi
->next
== NULL
)
167 fi
->frame
= read_sp ();
172 /* Similarly if we're stopped on the first insn of a prologue as our
173 frame hasn't been allocated yet. */
174 if (fi
&& fi
->pc
== func_addr
)
176 if (fi
->next
== NULL
)
177 fi
->frame
= read_sp ();
181 /* Figure out where to stop scanning. */
182 stop
= fi
? fi
->pc
: func_end
;
184 /* Don't walk off the end of the function. */
185 stop
= stop
> func_end
? func_end
: stop
;
187 /* Start scanning on the first instruction of this function. */
190 status
= target_read_memory (addr
, buf
, 2);
193 if (fi
&& fi
->next
== NULL
&& fi
->status
& MY_FRAME_IN_SP
)
194 fi
->frame
= read_sp ();
198 /* First see if this insn sets the stack pointer; if so, it's something
199 we won't understand, so quit now. */
201 || (buf
[0] == 0xf4 && buf
[1] == 0x77))
204 fi
->status
= NO_MORE_FRAMES
;
208 /* Now see if we have a frame pointer.
210 Search for mov a2,a0 (0xf278)
211 then mov a3,a2 (0xf27e). */
213 if (buf
[0] == 0xf2 && buf
[1] == 0x78)
215 /* Our caller's $a2 will be found in $a0 now. Note it for
218 fi
->status
|= CALLER_A2_IN_A0
;
222 /* We still haven't allocated our local stack. Handle this
223 as if we stopped on the first or last insn of a function. */
224 if (fi
&& fi
->next
== NULL
)
225 fi
->frame
= read_sp ();
229 status
= target_read_memory (addr
, buf
, 2);
232 if (fi
&& fi
->next
== NULL
)
233 fi
->frame
= read_sp ();
236 if (buf
[0] == 0xf2 && buf
[1] == 0x7e)
240 /* Our frame pointer is valid now. */
243 fi
->status
|= MY_FRAME_IN_FP
;
244 fi
->status
&= ~MY_FRAME_IN_SP
;
251 if (fi
&& fi
->next
== NULL
)
252 fi
->frame
= read_sp ();
257 /* Next we should allocate the local frame.
259 Search for add imm8,a3 (0xd3XX)
260 or add imm16,a3 (0xf70bXXXX)
261 or add imm24,a3 (0xf467XXXXXX).
263 If none of the above was found, then this prologue has
264 no stack, and therefore can't have any register saves,
266 status
= target_read_memory (addr
, buf
, 2);
269 if (fi
&& fi
->next
== NULL
&& (fi
->status
& MY_FRAME_IN_SP
))
270 fi
->frame
= read_sp ();
275 stack_size
= extract_signed_integer (&buf
[1], 1);
277 fi
->stack_size
= stack_size
;
281 if (fi
&& fi
->next
== NULL
&& (fi
->status
& MY_FRAME_IN_SP
))
282 fi
->frame
= read_sp () - stack_size
;
286 else if (buf
[0] == 0xf7 && buf
[1] == 0x0b)
288 status
= target_read_memory (addr
+ 2, buf
, 2);
291 if (fi
&& fi
->next
== NULL
&& (fi
->status
& MY_FRAME_IN_SP
))
292 fi
->frame
= read_sp ();
295 stack_size
= extract_signed_integer (buf
, 2);
297 fi
->stack_size
= stack_size
;
301 if (fi
&& fi
->next
== NULL
&& (fi
->status
& MY_FRAME_IN_SP
))
302 fi
->frame
= read_sp () - stack_size
;
306 else if (buf
[0] == 0xf4 && buf
[1] == 0x67)
308 status
= target_read_memory (addr
+ 2, buf
, 3);
311 if (fi
&& fi
->next
== NULL
&& (fi
->status
& MY_FRAME_IN_SP
))
312 fi
->frame
= read_sp ();
315 stack_size
= extract_signed_integer (buf
, 3);
317 fi
->stack_size
= stack_size
;
321 if (fi
&& fi
->next
== NULL
&& (fi
->status
& MY_FRAME_IN_SP
))
322 fi
->frame
= read_sp () - stack_size
;
327 /* Now see if we have a call to __prologue for an out of line
329 status
= target_read_memory (addr
, buf
, 2);
333 /* First check for 16bit pc-relative call to __prologue. */
337 status
= target_read_memory (addr
+ 1, buf
, 2);
340 if (fi
&& fi
->next
== NULL
&& (fi
->status
& MY_FRAME_IN_SP
))
341 fi
->frame
= read_sp ();
345 /* Get the PC this instruction will branch to. */
346 temp
= (extract_signed_integer (buf
, 2) + addr
+ 3) & 0xffffff;
348 /* Get the name of the function at the target address. */
349 status
= find_pc_partial_function (temp
, &name
, NULL
, NULL
);
352 if (fi
&& fi
->next
== NULL
&& (fi
->status
& MY_FRAME_IN_SP
))
353 fi
->frame
= read_sp ();
357 /* Note if it is an out of line prologue. */
358 out_of_line_prologue
= (strcmp (name
, "__prologue") == 0);
360 /* This sucks up 3 bytes of instruction space. */
361 if (out_of_line_prologue
)
366 if (fi
&& fi
->next
== NULL
)
368 fi
->stack_size
-= 16;
369 fi
->frame
= read_sp () - fi
->stack_size
;
374 /* Now check for the 24bit pc-relative call to __prologue. */
375 else if (buf
[0] == 0xf4 && buf
[1] == 0xe1)
378 status
= target_read_memory (addr
+ 2, buf
, 3);
381 if (fi
&& fi
->next
== NULL
&& (fi
->status
& MY_FRAME_IN_SP
))
382 fi
->frame
= read_sp ();
386 /* Get the PC this instruction will branch to. */
387 temp
= (extract_signed_integer (buf
, 3) + addr
+ 5) & 0xffffff;
389 /* Get the name of the function at the target address. */
390 status
= find_pc_partial_function (temp
, &name
, NULL
, NULL
);
393 if (fi
&& fi
->next
== NULL
&& (fi
->status
& MY_FRAME_IN_SP
))
394 fi
->frame
= read_sp ();
398 /* Note if it is an out of line prologue. */
399 out_of_line_prologue
= (strcmp (name
, "__prologue") == 0);
401 /* This sucks up 5 bytes of instruction space. */
402 if (out_of_line_prologue
)
407 if (fi
&& fi
->next
== NULL
&& (fi
->status
& MY_FRAME_IN_SP
))
409 fi
->stack_size
-= 16;
410 fi
->frame
= read_sp () - fi
->stack_size
;
416 /* Now actually handle the out of line prologue. */
417 if (out_of_line_prologue
)
419 int outgoing_args_size
= 0;
421 /* First adjust the stack size for this function. The out of
422 line prologue saves 4 registers (16bytes of data). */
424 fi
->stack_size
-= 16;
426 /* Update fi->frame if necessary. */
427 if (fi
&& fi
->next
== NULL
)
428 fi
->frame
= read_sp () - fi
->stack_size
;
430 /* After the out of line prologue, there may be another
431 stack adjustment for the outgoing arguments.
433 Search for add imm8,a3 (0xd3XX)
434 or add imm16,a3 (0xf70bXXXX)
435 or add imm24,a3 (0xf467XXXXXX). */
437 status
= target_read_memory (addr
, buf
, 2);
442 fi
->fsr
.regs
[2] = fi
->frame
+ fi
->stack_size
+ 4;
443 fi
->fsr
.regs
[3] = fi
->frame
+ fi
->stack_size
+ 8;
444 fi
->fsr
.regs
[5] = fi
->frame
+ fi
->stack_size
+ 12;
445 fi
->fsr
.regs
[6] = fi
->frame
+ fi
->stack_size
+ 16;
452 outgoing_args_size
= extract_signed_integer (&buf
[1], 1);
455 else if (buf
[0] == 0xf7 && buf
[1] == 0x0b)
457 status
= target_read_memory (addr
+ 2, buf
, 2);
462 fi
->fsr
.regs
[2] = fi
->frame
+ fi
->stack_size
+ 4;
463 fi
->fsr
.regs
[3] = fi
->frame
+ fi
->stack_size
+ 8;
464 fi
->fsr
.regs
[5] = fi
->frame
+ fi
->stack_size
+ 12;
465 fi
->fsr
.regs
[6] = fi
->frame
+ fi
->stack_size
+ 16;
469 outgoing_args_size
= extract_signed_integer (buf
, 2);
472 else if (buf
[0] == 0xf4 && buf
[1] == 0x67)
474 status
= target_read_memory (addr
+ 2, buf
, 3);
477 if (fi
&& fi
->next
== NULL
)
479 fi
->fsr
.regs
[2] = fi
->frame
+ fi
->stack_size
+ 4;
480 fi
->fsr
.regs
[3] = fi
->frame
+ fi
->stack_size
+ 8;
481 fi
->fsr
.regs
[5] = fi
->frame
+ fi
->stack_size
+ 12;
482 fi
->fsr
.regs
[6] = fi
->frame
+ fi
->stack_size
+ 16;
486 outgoing_args_size
= extract_signed_integer (buf
, 3);
490 outgoing_args_size
= 0;
492 /* Now that we know the size of the outgoing arguments, fix
493 fi->frame again if this is the innermost frame. */
494 if (fi
&& fi
->next
== NULL
)
495 fi
->frame
-= outgoing_args_size
;
497 /* Note the register save information and update the stack
498 size for this frame too. */
501 fi
->fsr
.regs
[2] = fi
->frame
+ fi
->stack_size
+ 4;
502 fi
->fsr
.regs
[3] = fi
->frame
+ fi
->stack_size
+ 8;
503 fi
->fsr
.regs
[5] = fi
->frame
+ fi
->stack_size
+ 12;
504 fi
->fsr
.regs
[6] = fi
->frame
+ fi
->stack_size
+ 16;
505 fi
->stack_size
+= outgoing_args_size
;
507 /* There can be no more prologue insns, so return now. */
511 /* At this point fi->frame needs to be correct.
513 If MY_FRAME_IN_SP is set and we're the innermost frame, then we
514 need to fix fi->frame so that backtracing, find_frame_saved_regs,
515 etc work correctly. */
516 if (fi
&& fi
->next
== NULL
&& (fi
->status
& MY_FRAME_IN_SP
) != 0)
517 fi
->frame
= read_sp () - fi
->stack_size
;
519 /* And last we have the register saves. These are relatively
520 simple because they're physically done off the stack pointer,
521 and thus the number of different instructions we need to
522 check is greatly reduced because we know the displacements
525 Search for movx d2,(X,a3) (0xf55eXX)
526 then movx d3,(X,a3) (0xf55fXX)
527 then mov a1,(X,a3) (0x5dXX) No frame pointer case
528 then mov a2,(X,a3) (0x5eXX) No frame pointer case
529 or mov a0,(X,a3) (0x5cXX) Frame pointer case. */
531 status
= target_read_memory (addr
, buf
, 2);
534 if (buf
[0] == 0xf5 && buf
[1] == 0x5e)
538 status
= target_read_memory (addr
+ 2, buf
, 1);
541 fi
->fsr
.regs
[2] = (fi
->frame
+ stack_size
542 + extract_signed_integer (buf
, 1));
547 status
= target_read_memory (addr
, buf
, 2);
551 if (buf
[0] == 0xf5 && buf
[1] == 0x5f)
555 status
= target_read_memory (addr
+ 2, buf
, 1);
558 fi
->fsr
.regs
[3] = (fi
->frame
+ stack_size
559 + extract_signed_integer (buf
, 1));
564 status
= target_read_memory (addr
, buf
, 2);
572 status
= target_read_memory (addr
+ 1, buf
, 1);
575 fi
->fsr
.regs
[5] = (fi
->frame
+ stack_size
576 + extract_signed_integer (buf
, 1));
581 status
= target_read_memory (addr
, buf
, 2);
585 if (buf
[0] == 0x5e || buf
[0] == 0x5c)
589 status
= target_read_memory (addr
+ 1, buf
, 1);
592 fi
->fsr
.regs
[6] = (fi
->frame
+ stack_size
593 + extract_signed_integer (buf
, 1));
594 fi
->status
&= ~CALLER_A2_IN_A0
;
604 /* Function: frame_chain
605 Figure out and return the caller's frame pointer given current
608 We don't handle dummy frames yet but we would probably just return the
609 stack pointer that was in use at the time the function call was made? */
612 mn10200_frame_chain (fi
)
613 struct frame_info
*fi
;
615 struct frame_info dummy_frame
;
617 /* Walk through the prologue to determine the stack size,
618 location of saved registers, end of the prologue, etc. */
620 mn10200_analyze_prologue (fi
, (CORE_ADDR
) 0);
622 /* Quit now if mn10200_analyze_prologue set NO_MORE_FRAMES. */
623 if (fi
->status
& NO_MORE_FRAMES
)
626 /* Now that we've analyzed our prologue, determine the frame
627 pointer for our caller.
629 If our caller has a frame pointer, then we need to
630 find the entry value of $a2 to our function.
632 If CALLER_A2_IN_A0, then the chain is in $a0.
634 If fsr.regs[6] is nonzero, then it's at the memory
635 location pointed to by fsr.regs[6].
637 Else it's still in $a2.
639 If our caller does not have a frame pointer, then his
640 frame base is fi->frame + -caller's stack size + 4. */
642 /* The easiest way to get that info is to analyze our caller's frame.
644 So we set up a dummy frame and call mn10200_analyze_prologue to
645 find stuff for us. */
646 dummy_frame
.pc
= FRAME_SAVED_PC (fi
);
647 dummy_frame
.frame
= fi
->frame
;
648 memset (dummy_frame
.fsr
.regs
, '\000', sizeof dummy_frame
.fsr
.regs
);
649 dummy_frame
.status
= 0;
650 dummy_frame
.stack_size
= 0;
651 mn10200_analyze_prologue (&dummy_frame
);
653 if (dummy_frame
.status
& MY_FRAME_IN_FP
)
655 /* Our caller has a frame pointer. So find the frame in $a2, $a0,
658 return (read_memory_integer (fi
->fsr
.regs
[FP_REGNUM
], REGISTER_SIZE
)
660 else if (fi
->status
& CALLER_A2_IN_A0
)
661 return read_register (4);
663 return read_register (FP_REGNUM
);
667 /* Our caller does not have a frame pointer. So his frame starts
668 at the base of our frame (fi->frame) + <his size> + 4 (saved pc). */
669 return fi
->frame
+ -dummy_frame
.stack_size
+ 4;
673 /* Function: skip_prologue
674 Return the address of the first inst past the prologue of the function. */
677 mn10200_skip_prologue (pc
)
680 /* We used to check the debug symbols, but that can lose if
681 we have a null prologue. */
682 return mn10200_analyze_prologue (NULL
, pc
);
685 /* Function: pop_frame
686 This routine gets called when either the user uses the `return'
687 command, or the call dummy breakpoint gets hit. */
690 mn10200_pop_frame (frame
)
691 struct frame_info
*frame
;
695 if (PC_IN_CALL_DUMMY (frame
->pc
, frame
->frame
, frame
->frame
))
696 generic_pop_dummy_frame ();
699 write_register (PC_REGNUM
, FRAME_SAVED_PC (frame
));
701 /* Restore any saved registers. */
702 for (regnum
= 0; regnum
< NUM_REGS
; regnum
++)
703 if (frame
->fsr
.regs
[regnum
] != 0)
707 value
= read_memory_unsigned_integer (frame
->fsr
.regs
[regnum
],
708 REGISTER_RAW_SIZE (regnum
));
709 write_register (regnum
, value
);
712 /* Actually cut back the stack. */
713 write_register (SP_REGNUM
, FRAME_FP (frame
));
715 /* Don't we need to set the PC?!? XXX FIXME. */
718 /* Throw away any cached frame information. */
719 flush_cached_frames ();
722 /* Function: push_arguments
723 Setup arguments for a call to the target. Arguments go in
724 order on the stack. */
727 mn10200_push_arguments (nargs
, args
, sp
, struct_return
, struct_addr
)
731 unsigned char struct_return
;
732 CORE_ADDR struct_addr
;
736 int stack_offset
= 0;
737 int regsused
= struct_return
? 1 : 0;
739 /* This should be a nop, but align the stack just in case something
740 went wrong. Stacks are two byte aligned on the mn10200. */
743 /* Now make space on the stack for the args.
745 XXX This doesn't appear to handle pass-by-invisible reference
747 for (argnum
= 0; argnum
< nargs
; argnum
++)
749 int arg_length
= (TYPE_LENGTH (VALUE_TYPE (args
[argnum
])) + 1) & ~1;
751 /* If we've used all argument registers, then this argument is
753 if (regsused
>= 2 || arg_length
> 4)
758 /* We know we've got some arg register space left. If this argument
759 will fit entirely in regs, then put it there. */
760 else if (arg_length
<= 2
761 || TYPE_CODE (VALUE_TYPE (args
[argnum
])) == TYPE_CODE_PTR
)
765 else if (regsused
== 0)
776 /* Allocate stack space. */
779 regsused
= struct_return
? 1 : 0;
780 /* Push all arguments onto the stack. */
781 for (argnum
= 0; argnum
< nargs
; argnum
++)
786 /* XXX Check this. What about UNIONS? */
787 if (TYPE_CODE (VALUE_TYPE (*args
)) == TYPE_CODE_STRUCT
788 && TYPE_LENGTH (VALUE_TYPE (*args
)) > 8)
790 /* XXX Wrong, we want a pointer to this argument. */
791 len
= TYPE_LENGTH (VALUE_TYPE (*args
));
792 val
= (char *) VALUE_CONTENTS (*args
);
796 len
= TYPE_LENGTH (VALUE_TYPE (*args
));
797 val
= (char *) VALUE_CONTENTS (*args
);
802 || TYPE_CODE (VALUE_TYPE (*args
)) == TYPE_CODE_PTR
))
804 write_register (regsused
, extract_unsigned_integer (val
, 4));
807 else if (regsused
== 0 && len
== 4)
809 write_register (regsused
, extract_unsigned_integer (val
, 2));
810 write_register (regsused
+ 1, extract_unsigned_integer (val
+ 2, 2));
818 write_memory (sp
+ stack_offset
, val
, 2);
831 /* Function: push_return_address (pc)
832 Set up the return address for the inferior function call.
833 Needed for targets where we don't actually execute a JSR/BSR instruction */
836 mn10200_push_return_address (pc
, sp
)
840 unsigned char buf
[4];
842 store_unsigned_integer (buf
, 4, CALL_DUMMY_ADDRESS ());
843 write_memory (sp
- 4, buf
, 4);
847 /* Function: store_struct_return (addr,sp)
848 Store the structure value return address for an inferior function
852 mn10200_store_struct_return (addr
, sp
)
856 /* The structure return address is passed as the first argument. */
857 write_register (0, addr
);
861 /* Function: frame_saved_pc
862 Find the caller of this frame. We do this by seeing if RP_REGNUM
863 is saved in the stack anywhere, otherwise we get it from the
864 registers. If the inner frame is a dummy frame, return its PC
865 instead of RP, because that's where "caller" of the dummy-frame
869 mn10200_frame_saved_pc (fi
)
870 struct frame_info
*fi
;
872 /* The saved PC will always be at the base of the current frame. */
873 return (read_memory_integer (fi
->frame
, REGISTER_SIZE
) & 0xffffff);
876 /* Function: init_extra_frame_info
877 Setup the frame's frame pointer, pc, and frame addresses for saved
878 registers. Most of the work is done in mn10200_analyze_prologue().
880 Note that when we are called for the last frame (currently active frame),
881 that fi->pc and fi->frame will already be setup. However, fi->frame will
882 be valid only if this routine uses FP. For previous frames, fi-frame will
883 always be correct. mn10200_analyze_prologue will fix fi->frame if
886 We can be called with the PC in the call dummy under two circumstances.
887 First, during normal backtracing, second, while figuring out the frame
888 pointer just prior to calling the target function (see run_stack_dummy). */
891 mn10200_init_extra_frame_info (fi
)
892 struct frame_info
*fi
;
895 fi
->pc
= FRAME_SAVED_PC (fi
->next
);
897 memset (fi
->fsr
.regs
, '\000', sizeof fi
->fsr
.regs
);
901 mn10200_analyze_prologue (fi
, 0);
905 _initialize_mn10200_tdep ()
907 tm_print_insn
= print_insn_mn10200
;
This page took 0.048977 seconds and 4 git commands to generate.