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.
8 * Copyright (c) 2005 Nathan Keynes.
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.
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.
25 #include "x86dasm/x86dasm.h"
26 #include "sh4/sh4trans.h"
27 #include "sh4/sh4core.h"
28 #include "sh4/sh4mmio.h"
30 struct dreamcast_module sh4_module;
31 struct mmio_region mmio_region_MMU;
32 struct mmio_region mmio_region_PMM;
33 struct breakpoint_struct sh4_breakpoints[MAX_BREAKPOINTS];
34 int sh4_breakpoint_count = 0;
36 #define MAX_INS_SIZE 32
38 char *option_list = "s:o:d:h";
39 struct option longopts[1] = { { NULL, 0, 0, 0 } };
41 char *input_file = NULL;
42 char *diff_file = NULL;
43 char *output_file = NULL;
44 gboolean sh4_starting;
45 uint32_t start_addr = 0x8C010000;
46 uint32_t sh4_cpu_period = 5;
47 sh4ptr_t sh4_main_ram;
52 struct x86_symbol local_symbols[] = {
53 { "sh4r+128", ((char *)&sh4r)+128 },
54 { "sh4_cpu_period", &sh4_cpu_period },
55 { "mmu_vma_to_phys_read", mmu_vma_to_phys_read },
56 { "mmu_vma_to_phys_write", mmu_vma_to_phys_write },
57 { "sh4_write_fpscr", sh4_write_fpscr },
58 { "sh4_write_sr", sh4_write_sr },
59 { "sh4_read_sr", sh4_read_sr },
60 { "sh4_sleep", sh4_sleep },
61 { "sh4_fsca", sh4_fsca },
62 { "sh4_ftrv", sh4_ftrv },
63 { "sh4_switch_fr_banks", sh4_switch_fr_banks },
64 { "sh4_execute_instruction", sh4_execute_instruction },
65 { "signsat48", signsat48 },
66 { "sh4_read_byte", sh4_read_byte },
67 { "sh4_read_word", sh4_read_word },
68 { "sh4_read_long", sh4_read_long },
69 { "sh4_write_byte", sh4_write_byte },
70 { "sh4_write_word", sh4_write_word },
71 { "sh4_write_long", sh4_write_long },
72 { "xlat_get_code_by_vma", xlat_get_code_by_vma },
73 { "xlat_get_code", xlat_get_code }
76 int32_t FASTCALL sh4_read_byte( uint32_t addr )
78 return *(uint8_t *)(inbuf+(addr-start_addr));
80 int32_t FASTCALL sh4_read_word( uint32_t addr )
82 return *(uint16_t *)(inbuf+(addr-start_addr));
84 int32_t FASTCALL sh4_read_long( uint32_t addr )
86 return *(uint32_t *)(inbuf+(addr-start_addr));
89 gboolean sh4_execute_instruction( ) { return TRUE; }
90 void sh4_accept_interrupt() {}
91 void sh4_set_breakpoint( uint32_t pc, breakpoint_type_t type ) { }
92 gboolean sh4_clear_breakpoint( uint32_t pc, breakpoint_type_t type ) { return TRUE; }
93 gboolean dreamcast_is_running() { return FALSE; }
94 int sh4_get_breakpoint( uint32_t pc ) { return 0; }
95 void sh4_core_exit( int exit_code ){}
96 void sh4_flush_icache(){}
97 void event_execute() {}
98 void TMU_run_slice( uint32_t nanos ) {}
99 void PMM_write_control( int ctr, uint32_t val ) { }
100 void SCIF_run_slice( uint32_t nanos ) {}
101 void FASTCALL sh4_write_byte( uint32_t addr, uint32_t val ) {}
102 void FASTCALL sh4_write_word( uint32_t addr, uint32_t val ) {}
103 void FASTCALL sh4_write_long( uint32_t addr, uint32_t val ) {}
104 void FASTCALL sh4_write_fpscr( uint32_t val ) { }
105 void FASTCALL sh4_write_sr( uint32_t val ) { }
106 uint32_t FASTCALL sh4_read_sr( void ) { return 0; }
107 void FASTCALL sh4_sleep() { }
108 void FASTCALL sh4_fsca( uint32_t angle, float *fr ) { }
109 void FASTCALL sh4_ftrv( float *fv ) { }
110 void FASTCALL signsat48(void) { }
111 void sh4_switch_fr_banks() { }
112 void mem_copy_to_sh4( sh4addr_t addr, sh4ptr_t src, size_t size ) { }
113 gboolean sh4_has_page( sh4vma_t vma ) { return TRUE; }
114 void syscall_invoke( uint32_t val ) { }
115 void dreamcast_stop() {}
116 void dreamcast_reset() {}
117 gboolean FASTCALL sh4_raise_reset( int exc ) { return TRUE; }
118 gboolean FASTCALL sh4_raise_exception( int exc ) { return TRUE; }
119 gboolean FASTCALL sh4_raise_tlb_exception( int exc ) { return TRUE; }
120 gboolean FASTCALL sh4_raise_trap( int exc ) { return TRUE; }
121 uint32_t sh4_sleep_run_slice(uint32_t nanosecs) { return nanosecs; }
122 gboolean gui_error_dialog( const char *fmt, ... ) { return TRUE; }
123 struct sh4_icache_struct sh4_icache;
127 fprintf( stderr, "Usage: testsh4x86 [options] <input bin file>\n");
128 fprintf( stderr, "Options:\n");
129 fprintf( stderr, " -d <filename> Diff results against contents of file\n" );
130 fprintf( stderr, " -h Display this help message\n" );
131 fprintf( stderr, " -o <filename> Output disassembly to file [stdout]\n" );
132 fprintf( stderr, " -s <addr> Specify start address of binary [8C010000]\n" );
135 void emit( void *ptr, int level, const gchar *source, const char *msg, ... )
139 vfprintf( stderr, msg, ap );
140 fprintf( stderr, "\n" );
145 struct sh4_registers sh4r;
148 int main( int argc, char *argv[] )
152 while( (opt = getopt_long( argc, argv, option_list, longopts, NULL )) != -1 ) {
158 output_file = optarg;
161 start_addr = strtoul(optarg, NULL, 0);
168 if( optind < argc ) {
169 input_file = argv[optind++];
175 mmio_region_MMU.mem = malloc(4096);
176 memset( mmio_region_MMU.mem, 0, 4096 );
178 in = fopen( input_file, "ro" );
180 perror( "Unable to open input file" );
183 fstat( fileno(in), &st );
184 inbuf = malloc( st.st_size );
185 fread( inbuf, st.st_size, 1, in );
186 sh4_icache.mask = 0xFFFFF000;
187 sh4_icache.page_vma = start_addr & 0xFFFFF000;
188 sh4_icache.page = (unsigned char *)(inbuf - (sh4_icache.page_vma&0xFFF));
189 sh4_icache.page_ppa = start_addr & 0xFFFFF000;
193 uint8_t *buf = sh4_translate_basic_block( start_addr );
194 uint32_t buflen = xlat_get_code_size(buf);
195 x86_disasm_init( buf, 0x8c010000, buflen );
196 x86_set_symtab( local_symbols, sizeof(local_symbols)/sizeof(struct x86_symbol) );
197 for( pc = 0x8c010000; pc < 0x8c010000 + buflen; ) {
200 uint32_t pc2 = x86_disasm_instruction( pc, buf, sizeof(buf), op );
201 fprintf( stdout, "%s\n", buf );
.