filename | src/test/testsh4x86.c |
changeset | 672:cc2c2b0ab272 |
prev | 669:ab344e42bca9 |
next | 740:dd11269ee48b |
author | nkeynes |
date | Sun Jun 22 04:01:27 2008 +0000 (15 years ago) |
permissions | -rw-r--r-- |
last change | Commit work-in-progress CoreAudio driver (along with various changes to the audio subsystem) |
view | annotate | diff | log | raw |
1 /**
2 * $Id$
3 *
4 * Test cases for the SH4 => x86 translator core. Takes as
5 * input a binary SH4 object (and VMA), generates the
6 * corresponding x86 code, and outputs the disassembly.
7 *
8 * Copyright (c) 2005 Nathan Keynes.
9 *
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 2 of the License, or
13 * (at your option) any later version.
14 *
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.
19 */
21 #include <stdio.h>
22 #include <stdarg.h>
23 #include <getopt.h>
24 #include <sys/stat.h>
25 #include "x86dasm/x86dasm.h"
26 #include "sh4/sh4trans.h"
27 #include "sh4/sh4core.h"
28 #include "sh4/sh4mmio.h"
30 struct mmio_region mmio_region_MMU;
31 struct breakpoint_struct sh4_breakpoints[MAX_BREAKPOINTS];
32 int sh4_breakpoint_count = 0;
34 #define MAX_INS_SIZE 32
36 char *option_list = "s:o:d:h";
37 struct option longopts[1] = { { NULL, 0, 0, 0 } };
39 char *input_file = NULL;
40 char *diff_file = NULL;
41 char *output_file = NULL;
42 gboolean sh4_starting;
43 uint32_t start_addr = 0x8C010000;
44 uint32_t sh4_cpu_period = 5;
45 sh4ptr_t sh4_main_ram;
46 FILE *in;
48 char *inbuf;
50 struct x86_symbol local_symbols[] = {
51 { "_sh4_read_byte", sh4_read_byte },
52 { "_sh4_read_word", sh4_read_word },
53 { "_sh4_read_long", sh4_read_long },
54 { "_sh4_write_byte", sh4_write_byte },
55 { "_sh4_write_word", sh4_write_word },
56 { "_sh4_write_long", sh4_write_long }
57 };
59 int32_t sh4_read_byte( uint32_t addr )
60 {
61 return *(uint8_t *)(inbuf+(addr-start_addr));
62 }
63 int32_t sh4_read_word( uint32_t addr )
64 {
65 return *(uint16_t *)(inbuf+(addr-start_addr));
66 }
67 int32_t sh4_read_long( uint32_t addr )
68 {
69 return *(uint32_t *)(inbuf+(addr-start_addr));
70 }
71 // Stubs
72 gboolean sh4_execute_instruction( ) { }
73 void sh4_accept_interrupt() {}
74 void sh4_set_breakpoint( uint32_t pc, breakpoint_type_t type ) { }
75 gboolean sh4_clear_breakpoint( uint32_t pc, breakpoint_type_t type ) { }
76 gboolean sh4_is_using_xlat() { return TRUE; }
77 int sh4_get_breakpoint( uint32_t pc ) { }
78 void event_execute() {}
79 void TMU_run_slice( uint32_t nanos ) {}
80 void SCIF_run_slice( uint32_t nanos ) {}
81 void sh4_write_byte( uint32_t addr, uint32_t val ) {}
82 void sh4_write_word( uint32_t addr, uint32_t val ) {}
83 void sh4_write_long( uint32_t addr, uint32_t val ) {}
84 void sh4_write_fpscr( uint32_t val ) { }
85 void sh4_switch_fr_banks() { }
86 void mem_copy_to_sh4( sh4addr_t addr, sh4ptr_t src, size_t size ) { }
87 void sh4_write_sr( uint32_t val ) { }
88 gboolean sh4_has_page( sh4vma_t vma ) { return TRUE; }
89 void syscall_invoke( uint32_t val ) { }
90 void dreamcast_stop() {}
91 void dreamcast_reset() {}
92 uint32_t sh4_read_sr( void ) { }
93 gboolean sh4_raise_reset( int exc ) {}
94 gboolean sh4_raise_exception( int exc ) {}
95 gboolean sh4_raise_tlb_exception( int exc ) {}
96 gboolean sh4_raise_trap( int exc ) {}
97 void sh4_sleep() { }
98 uint32_t sh4_sleep_run_slice(uint32_t nanosecs) { }
99 void sh4_fsca( uint32_t angle, float *fr ) { }
100 void sh4_ftrv( float *fv ) { }
101 void signsat48(void) { }
102 gboolean gui_error_dialog( const char *fmt, ... ) { }
103 struct sh4_icache_struct sh4_icache;
105 void usage()
106 {
107 fprintf( stderr, "Usage: testsh4x86 [options] <input bin file>\n");
108 fprintf( stderr, "Options:\n");
109 fprintf( stderr, " -d <filename> Diff results against contents of file\n" );
110 fprintf( stderr, " -h Display this help message\n" );
111 fprintf( stderr, " -o <filename> Output disassembly to file [stdout]\n" );
112 fprintf( stderr, " -s <addr> Specify start address of binary [8C010000]\n" );
113 }
115 void emit( void *ptr, int level, const gchar *source, const char *msg, ... )
116 {
117 va_list ap;
118 va_start( ap, msg );
119 vfprintf( stderr, msg, ap );
120 fprintf( stderr, "\n" );
121 va_end(ap);
122 }
125 struct sh4_registers sh4r;
128 int main( int argc, char *argv[] )
129 {
130 struct stat st;
131 int opt;
132 while( (opt = getopt_long( argc, argv, option_list, longopts, NULL )) != -1 ) {
133 switch( opt ) {
134 case 'd':
135 diff_file = optarg;
136 break;
137 case 'o':
138 output_file = optarg;
139 break;
140 case 's':
141 start_addr = strtoul(optarg, NULL, 0);
142 break;
143 case 'h':
144 usage();
145 exit(0);
146 }
147 }
148 if( optind < argc ) {
149 input_file = argv[optind++];
150 } else {
151 usage();
152 exit(1);
153 }
155 in = fopen( input_file, "ro" );
156 if( in == NULL ) {
157 perror( "Unable to open input file" );
158 exit(2);
159 }
160 fstat( fileno(in), &st );
161 inbuf = malloc( st.st_size );
162 fread( inbuf, st.st_size, 1, in );
164 xlat_cache_init();
165 uint32_t pc;
166 uint8_t *buf = sh4_translate_basic_block( start_addr );
167 uint32_t buflen = xlat_get_block_size(buf);
168 x86_disasm_init( buf, 0x8c010000, buflen );
169 x86_set_symtab( local_symbols, 6 );
170 for( pc = 0x8c010000; pc < 0x8c010000 + buflen; ) {
171 char buf[256];
172 char op[256];
173 uint32_t pc2 = x86_disasm_instruction( pc, buf, sizeof(buf), op );
174 fprintf( stdout, "%08X: %-20s %s\n", pc, op, buf );
175 pc = pc2;
176 }
177 }
.