Search
lxdream.org :: lxdream/src/test/testsh4x86.c
lxdream 0.9.1
released Jun 29
Download Now
filename src/test/testsh4x86.c
changeset 586:2a3ba82cf243
prev550:a27e31340147
next602:a3aae8cbd1d7
author nkeynes
date Tue Jan 15 20:50:23 2008 +0000 (12 years ago)
permissions -rw-r--r--
last change Merged lxdream-mmu r570:596 to trunk
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 uint32_t start_addr = 0x8C010000;
    43 uint32_t sh4_cpu_period = 5;
    44 sh4ptr_t sh4_main_ram;
    45 FILE *in;
    47 char *inbuf;
    49 struct x86_symbol local_symbols[] = {
    50     { "_sh4_read_byte", sh4_read_byte },
    51     { "_sh4_read_word", sh4_read_word },
    52     { "_sh4_read_long", sh4_read_long },
    53     { "_sh4_write_byte", sh4_write_byte },
    54     { "_sh4_write_word", sh4_write_word },
    55     { "_sh4_write_long", sh4_write_long }
    56 };
    58 int32_t sh4_read_byte( uint32_t addr ) 
    59 {
    60     return *(uint8_t *)(inbuf+(addr-start_addr));
    61 }
    62 int32_t sh4_read_word( uint32_t addr ) 
    63 {
    64     return *(uint16_t *)(inbuf+(addr-start_addr));
    65 }
    66 int32_t sh4_read_long( uint32_t addr ) 
    67 {
    68     return *(uint32_t *)(inbuf+(addr-start_addr));
    69 }
    70 // Stubs
    71 gboolean sh4_execute_instruction( ) { }
    72 void sh4_accept_interrupt() {}
    73 void sh4_set_breakpoint( uint32_t pc, breakpoint_type_t type ) { }
    74 gboolean sh4_clear_breakpoint( uint32_t pc, breakpoint_type_t type ) { }
    75 gboolean sh4_is_using_xlat() { return TRUE; }
    76 int sh4_get_breakpoint( uint32_t pc ) { }
    77 void event_execute() {}
    78 void TMU_run_slice( uint32_t nanos ) {}
    79 void SCIF_run_slice( uint32_t nanos ) {}
    80 void sh4_write_byte( uint32_t addr, uint32_t val ) {}
    81 void sh4_write_word( uint32_t addr, uint32_t val ) {}
    82 void sh4_write_long( uint32_t addr, uint32_t val ) {}
    83 void mem_copy_to_sh4( sh4addr_t addr, sh4ptr_t src, size_t size ) { }
    84 void sh4_write_sr( uint32_t val ) { }
    85 void syscall_invoke( uint32_t val ) { }
    86 void dreamcast_stop() {} 
    87 void dreamcast_reset() {}
    88 uint32_t sh4_read_sr( void ) { }
    89 gboolean sh4_raise_reset( int exc ) {}
    90 gboolean sh4_raise_exception( int exc ) {}
    91 gboolean sh4_raise_tlb_exception( int exc ) {}
    92 gboolean sh4_raise_trap( int exc ) {}
    93 void sh4_sleep() { }
    94 void sh4_fsca( uint32_t angle, float *fr ) { }
    95 void sh4_ftrv( float *fv, float *xmtrx ) { }
    96 void signsat48(void) { }
    97 gboolean gui_error_dialog( const char *fmt, ... ) { }
    98 struct sh4_icache_struct sh4_icache;
   100 void usage()
   101 {
   102     fprintf( stderr, "Usage: testsh4x86 [options] <input bin file>\n");
   103     fprintf( stderr, "Options:\n");
   104     fprintf( stderr, "  -d <filename>  Diff results against contents of file\n" );
   105     fprintf( stderr, "  -h             Display this help message\n" );
   106     fprintf( stderr, "  -o <filename>  Output disassembly to file [stdout]\n" );
   107     fprintf( stderr, "  -s <addr>      Specify start address of binary [8C010000]\n" );
   108 }
   110 void emit( void *ptr, int level, const gchar *source, const char *msg, ... )
   111 {
   112     va_list ap;
   113     va_start( ap, msg );
   114     vfprintf( stderr, msg, ap );
   115     fprintf( stderr, "\n" );
   116     va_end(ap);
   117 }
   120 struct sh4_registers sh4r;
   123 int main( int argc, char *argv[] )
   124 {
   125     struct stat st;
   126     int opt;
   127     while( (opt = getopt_long( argc, argv, option_list, longopts, NULL )) != -1 ) {
   128 	switch( opt ) {
   129 	case 'd':
   130 	    diff_file = optarg;
   131 	    break;
   132 	case 'o':
   133 	    output_file = optarg;
   134 	    break;
   135 	case 's':
   136 	    start_addr = strtoul(optarg, NULL, 0);
   137 	    break;
   138 	case 'h':
   139 	    usage();
   140 	    exit(0);
   141 	}
   142     }
   143     if( optind < argc ) {
   144 	input_file = argv[optind++];
   145     } else {
   146 	usage();
   147 	exit(1);
   148     }
   150     in = fopen( input_file, "ro" );
   151     if( in == NULL ) {
   152 	perror( "Unable to open input file" );
   153 	exit(2);
   154     }
   155     fstat( fileno(in), &st );
   156     inbuf = malloc( st.st_size );
   157     fread( inbuf, st.st_size, 1, in );
   159     xlat_cache_init();
   160     uint32_t pc;
   161     uint8_t *buf = sh4_translate_basic_block( start_addr );
   162     uint32_t buflen = xlat_get_block_size(buf);
   163     x86_disasm_init( buf, 0x8c010000, buflen );
   164     x86_set_symtab( local_symbols, 6 );
   165     for( pc = 0x8c010000; pc < 0x8c010000 + buflen;  ) {
   166 	char buf[256];
   167 	char op[256];
   168 	uint32_t pc2 = x86_disasm_instruction( pc, buf, sizeof(buf), op );
   169 	fprintf( stdout, "%08X: %-20s %s\n", pc, op, buf );
   170 	pc = pc2;
   171     }
   172 }
.