Search
lxdream.org :: lxdream/src/test/testsh4x86.c
lxdream 0.9.1
released Jun 29
Download Now
filename src/test/testsh4x86.c
changeset 1302:765e514f99a6
prev1263:b3de98d19faf
author nkeynes
date Fri May 29 18:47:05 2015 +1000 (4 years ago)
permissions -rw-r--r--
last change Fix test case
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 <string.h>
    27 #include "xlat/xlatdasm.h"
    28 #include "sh4/sh4trans.h"
    29 #include "sh4/sh4core.h"
    30 #include "sh4/sh4mmio.h"
    31 #include "sh4/mmu.h"
    33 struct dreamcast_module sh4_module;
    34 struct mmio_region mmio_region_MMU;
    35 struct mmio_region mmio_region_PMM;
    36 struct breakpoint_struct sh4_breakpoints[MAX_BREAKPOINTS];
    37 int sh4_breakpoint_count = 0;
    38 gboolean sh4_profile_blocks = FALSE;
    40 #define MAX_INS_SIZE 32
    43 struct mem_region_fn **sh4_address_space = (void *)0x12345432;
    44 struct mem_region_fn **sh4_user_address_space = (void *)0x12345678;
    45 char *option_list = "s:o:d:h";
    46 struct option longopts[1] = { { NULL, 0, 0, 0 } };
    48 char *input_file = NULL;
    49 char *diff_file = NULL;
    50 char *output_file = NULL;
    51 gboolean sh4_starting;
    52 uint32_t start_addr = 0x8C010000;
    53 uint32_t sh4_cpu_period = 5;
    54 unsigned char dc_main_ram[4096];
    55 unsigned char dc_boot_rom[4096];
    56 FILE *in;
    58 char *inbuf;
    60 struct xlat_symbol local_symbols[] = {
    61     { "sh4r+128", ((char *)&sh4r)+128 },
    62     { "sh4_cpu_period", &sh4_cpu_period },
    63     { "sh4_address_space", (void *)0x12345432 },
    64     { "sh4_user_address_space", (void *)0x12345678 },
    65     { "sh4_write_fpscr", sh4_write_fpscr },
    66     { "sh4_write_sr", sh4_write_sr },
    67     { "sh4_read_sr", sh4_read_sr },
    68     { "sh4_sleep", sh4_sleep },
    69     { "sh4_fsca", sh4_fsca },
    70     { "sh4_ftrv", sh4_ftrv },
    71     { "sh4_switch_fr_banks", sh4_switch_fr_banks },
    72     { "sh4_execute_instruction", sh4_execute_instruction },
    73     { "signsat48", signsat48 },
    74     { "xlat_get_code_by_vma", xlat_get_code_by_vma },
    75     { "xlat_get_code", xlat_get_code }
    76 };
    78 // Stubs
    79 gboolean sh4_execute_instruction( ) { return TRUE; }
    80 void sh4_accept_interrupt() {}
    81 void sh4_set_breakpoint( uint32_t pc, breakpoint_type_t type ) { }
    82 gboolean sh4_clear_breakpoint( uint32_t pc, breakpoint_type_t type ) { return TRUE; }
    83 gboolean dreamcast_is_running() { return FALSE; }
    84 int sh4_get_breakpoint( uint32_t pc ) { return 0; }
    85 void sh4_finalize_instruction() { }
    86 void sh4_core_exit( int exit_code ){}
    87 void sh4_crashdump() {}
    88 void event_execute() {}
    89 void TMU_run_slice( uint32_t nanos ) {}
    90 void CCN_set_cache_control( int val ) { }
    91 void PMM_write_control( int ctr, uint32_t val ) { }
    92 void SCIF_run_slice( uint32_t nanos ) {}
    93 void FASTCALL sh4_write_fpscr( uint32_t val ) { }
    94 void FASTCALL sh4_write_sr( uint32_t val ) { }
    95 uint32_t FASTCALL sh4_read_sr( void ) { return 0; }
    96 void FASTCALL sh4_sleep() { }
    97 void FASTCALL sh4_fsca( uint32_t angle, float *fr ) { }
    98 void FASTCALL sh4_ftrv( float *fv ) { }
    99 void FASTCALL signsat48(void) { }
   100 void sh4_switch_fr_banks() { }
   101 void mem_copy_to_sh4( sh4addr_t addr, sh4ptr_t src, size_t size ) { }
   102 gboolean sh4_has_page( sh4vma_t vma ) { return TRUE; }
   103 void syscall_invoke( uint32_t val ) { }
   104 void dreamcast_stop() {} 
   105 void dreamcast_reset() {}
   106 void FASTCALL sh4_raise_reset( int exc ) { }
   107 void FASTCALL sh4_raise_exception( int exc ) { }
   108 void FASTCALL sh4_raise_tlb_exception( int exc, sh4vma_t vma ) { }
   109 void FASTCALL sh4_raise_tlb_multihit( sh4vma_t vma) { }
   110 void FASTCALL sh4_raise_trap( int exc ) { }
   111 void FASTCALL sh4_flush_store_queue( sh4addr_t addr ) { }
   112 void FASTCALL sh4_flush_store_queue_mmu( sh4addr_t addr, void *exc ) { }
   113 void sh4_shadow_block_begin() {}
   114 void sh4_shadow_block_end() {}
   115 void sh4_handle_pending_events() { }
   116 uint32_t sh4_sleep_run_slice(uint32_t nanosecs) { return nanosecs; }
   117 gboolean gui_error_dialog( const char *fmt, ... ) { return TRUE; }
   118 gboolean FASTCALL mmu_update_icache( sh4vma_t addr ) { return TRUE; }
   119 void MMU_ldtlb() { }
   120 void event_schedule(int event, uint32_t nanos) { }
   121 struct sh4_icache_struct sh4_icache;
   122 struct mem_region_fn mem_region_unmapped;
   123 const struct cpu_desc_struct sh4_cpu_desc;
   124 sh4addr_t FASTCALL mmu_vma_to_phys_disasm( sh4vma_t vma ) { return vma; }
   126 void usage()
   127 {
   128     fprintf( stderr, "Usage: testsh4x86 [options] <input bin file>\n");
   129     fprintf( stderr, "Options:\n");
   130     fprintf( stderr, "  -d <filename>  Diff results against contents of file\n" );
   131     fprintf( stderr, "  -h             Display this help message\n" );
   132     fprintf( stderr, "  -o <filename>  Output disassembly to file [stdout]\n" );
   133     fprintf( stderr, "  -s <addr>      Specify start address of binary [8C010000]\n" );
   134 }
   136 void emit( void *ptr, int level, const gchar *source, const char *msg, ... )
   137 {
   138     va_list ap;
   139     va_start( ap, msg );
   140     vfprintf( stderr, msg, ap );
   141     fprintf( stderr, "\n" );
   142     va_end(ap);
   143 }
   146 struct sh4_registers sh4r;
   149 int main( int argc, char *argv[] )
   150 {
   151     struct stat st;
   152     int opt;
   153     while( (opt = getopt_long( argc, argv, option_list, longopts, NULL )) != -1 ) {
   154 	switch( opt ) {
   155 	case 'd':
   156 	    diff_file = optarg;
   157 	    break;
   158 	case 'o':
   159 	    output_file = optarg;
   160 	    break;
   161 	case 's':
   162 	    start_addr = strtoul(optarg, NULL, 0);
   163 	    break;
   164 	case 'h':
   165 	    usage();
   166 	    exit(0);
   167 	}
   168     }
   169     if( optind < argc ) {
   170 	input_file = argv[optind++];
   171     } else {
   172 	usage();
   173 	exit(1);
   174     }
   176     mmio_region_MMU.mem = malloc(4096);
   177     memset( mmio_region_MMU.mem, 0, 4096 );
   179     ((uint32_t *)mmio_region_MMU.mem)[4] = 1;
   181     in = fopen( input_file, "ro" );
   182     if( in == NULL ) {
   183 	perror( "Unable to open input file" );
   184 	exit(2);
   185     }
   186     fstat( fileno(in), &st );
   187     inbuf = malloc( st.st_size );
   188     fread( inbuf, st.st_size, 1, in );
   189     sh4_icache.mask = 0xFFFFF000;
   190     sh4_icache.page_vma = start_addr & 0xFFFFF000;
   191     sh4_icache.page = (unsigned char *)(inbuf - (sh4_icache.page_vma&0xFFF));
   192     sh4_icache.page_ppa = start_addr & 0xFFFFF000;
   194     xlat_cache_init();
   195     uintptr_t pc;
   196     uint8_t *buf = sh4_translate_basic_block( start_addr );
   197     uint32_t buflen = xlat_get_code_size(buf);
   198     xlat_disasm_init( local_symbols, sizeof(local_symbols)/sizeof(struct xlat_symbol) );
   199     for( pc = (uintptr_t)buf; pc < ((uintptr_t)buf) + buflen;  ) {
   200 	char buf[256];
   201 	char op[256];
   202 	uintptr_t pc2 = xlat_disasm_instruction( pc, buf, sizeof(buf), op );
   203 	fprintf( stdout, "%p: %s\n", (void *)pc, buf );
   204 	pc = pc2;
   205     }
   206     return 0;
   207 }
.