[mupen64plus-pandora.git] / source / front-end / src / compare_core.c

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 *   Mupen64plus - compare_core.h                                          *
 *   Mupen64Plus homepage: http://code.google.com/p/mupen64plus/           *
 *   Copyright (C) 2009 Richard Goedeken                                   *
 *   Copyright (C) 2002 Hacktarux                                          *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.          *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

#include <stdio.h>
#include <string.h>
#include <sys/stat.h>

#include "m64p_types.h"
#include "main.h"
#include "compare_core.h"
#include "core_interface.h"

/* local variables */

static FILE *fPipe = NULL;
static int comp_reg_32[32];
static long long comp_reg_64[32];
static unsigned int old_op = 0;
static int l_CoreCompareMode = CORE_COMPARE_DISABLE;

static long long *ptr_reg = NULL;  /* pointer to the 64-bit general purpose registers in the core */
static int       *ptr_cop0 = NULL; /* pointer to the 32-bit Co-processor 0 registers in the core */
static long long *ptr_fgr = NULL;  /* pointer to the 64-bit floating-point registers in the core */ 
static int       *ptr_PC = NULL;   /* pointer to 32-bit R4300 Program Counter */

/* local functions */
static void stop_it(void)
{
    static int errors = 0;

    (*CoreDoCommand)(M64CMD_STOP, 0, NULL);

    errors++;
#if !defined(WIN32)
    #if defined(__i386__) || defined(__x86_64__)
        if (errors > 7)
            asm("int $3;");
    #endif
#endif
}

static void display_error(char *txt)
{
    int i;

    printf("err: %6s  addr:%x\t ", txt, *ptr_PC);

    if (!strcmp(txt, "PC"))
    {
        printf("My PC: %x  Ref PC: %x\t ", *ptr_PC, *comp_reg_32);
    }
    else if (!strcmp(txt, "gpr"))
    {
        for (i=0; i<32; i++)
        {
            if (ptr_reg[i] != comp_reg_64[i])
                printf("My: reg[%d]=%llx\t Ref: reg[%d]=%llx\t ", i, ptr_reg[i], i, comp_reg_64[i]);
        }
    }
    else if (!strcmp(txt, "cop0"))
    {
        for (i=0; i<32; i++)
        {
            if (ptr_cop0[i] != comp_reg_32[i])
                printf("My: reg_cop0[%d]=%x\t Ref: reg_cop0[%d]=%x\t ", i, (unsigned int)ptr_cop0[i], i, (unsigned int)comp_reg_32[i]);
        }
    }
    else if (!strcmp(txt, "cop1"))
    {
        for (i=0; i<32; i++)
        {
            if (ptr_fgr[i] != comp_reg_64[i])
                printf("My: reg[%d]=%llx\t Ref: reg[%d]=%llx\t ", i, ptr_fgr[i], i, comp_reg_64[i]);
        }
    }
    printf("\n");
    /*for (i=0; i<32; i++)
      {
     if (reg_cop0[i] != comp_reg[i])
       printf("reg_cop0[%d]=%llx != reg[%d]=%llx\n",
          i, reg_cop0[i], i, comp_reg[i]);
      }*/

    stop_it();
}

static void compare_core_sync_data(int length, void *value)
{
    if (l_CoreCompareMode == CORE_COMPARE_RECV)
    {
        if (fread(value, 1, length, fPipe) != length)
            stop_it();
    }
    else if (l_CoreCompareMode == CORE_COMPARE_SEND)
    {
        if (fwrite(value, 1, length, fPipe) != length)
            stop_it();
    }
}

static void compare_core_check(unsigned int cur_opcode)
{
    static int comparecnt = 0;
    int iFirst = 1;
    char errHead[128];
    sprintf(errHead, "Compare #%i  old_op: %x op: %x\n", comparecnt++, old_op, cur_opcode);

    /* get pointer to current R4300 Program Counter address */
    ptr_PC = (int *) DebugGetCPUDataPtr(M64P_CPU_PC); /* this changes for every instruction */

    if (l_CoreCompareMode == CORE_COMPARE_RECV)
    {
        if (fread(comp_reg_32, sizeof(int), 4, fPipe) != 4)
            printf("compare_core_check: fread() failed");
        if (*ptr_PC != *comp_reg_32)
        {
            if (iFirst)
            {
                printf("%s", errHead);
                iFirst = 0;
            }
            display_error("PC");
        }
        if (fread (comp_reg_64, sizeof(long long int), 32, fPipe) != 32)
            printf("compare_core_check: fread() failed");
        if (memcmp(ptr_reg, comp_reg_64, 32*sizeof(long long int)) != 0)
        {
            if (iFirst)
            {
                printf("%s", errHead);
                iFirst = 0;
            }
            display_error("gpr");
        }
        if (fread(comp_reg_32, sizeof(int), 32, fPipe) != 32)
            printf("compare_core_check: fread() failed");
        if (memcmp(ptr_cop0, comp_reg_32, 32*sizeof(int)) != 0)
        {
            if (iFirst)
            {
                printf("%s", errHead);
                iFirst = 0;
            }
            display_error("cop0");
        }
        if (fread(comp_reg_64, sizeof(long long int), 32, fPipe) != 32)
            printf("compare_core_check: fread() failed");
        if (memcmp(ptr_fgr, comp_reg_64, 32*sizeof(long long int)))
        {
            if (iFirst)
            {
                printf("%s", errHead);
                iFirst = 0;
            }
            display_error("cop1");
        }
        /*fread(comp_reg, 1, sizeof(int), f);
        if (memcmp(&rdram[0x31280/4], comp_reg, sizeof(int)))
          display_error("mem");*/
        /*fread (comp_reg, 4, 1, f);
        if (memcmp(&FCR31, comp_reg, 4))
          display_error();*/
        old_op = cur_opcode;
    }
    else if (l_CoreCompareMode == CORE_COMPARE_SEND)
    {
        if (fwrite(ptr_PC, sizeof(int), 4, fPipe) != 4 ||
            fwrite(ptr_reg, sizeof(long long int), 32, fPipe) != 32 ||
            fwrite(ptr_cop0, sizeof(int), 32, fPipe) != 32 ||
            fwrite(ptr_fgr, sizeof(long long int), 32, fPipe) != 32)
            printf("compare_core_check: fwrite() failed");
        /*fwrite(&rdram[0x31280/4], 1, sizeof(int), f);
        fwrite(&FCR31, 4, 1, f);*/
    }
}

/* global functions */
void compare_core_init(int mode)
{
#if defined(WIN32)
    DebugMessage(M64MSG_VERBOSE, "core comparison feature not supported on Windows platform.");
    return;
#else
    /* set mode */
    l_CoreCompareMode = mode;
    /* set callback functions in core */
    if (DebugSetCoreCompare(compare_core_check, compare_core_sync_data) != M64ERR_SUCCESS)
    {
        l_CoreCompareMode = CORE_COMPARE_DISABLE;
        DebugMessage(M64MSG_WARNING, "DebugSetCoreCompare() failed, core comparison disabled.");
        return;
    }
    /* get pointers to emulated R4300 CPU registers */
    ptr_reg = (long long *) DebugGetCPUDataPtr(M64P_CPU_REG_REG);
    ptr_cop0 = (int *) DebugGetCPUDataPtr(M64P_CPU_REG_COP0);
    ptr_fgr = (long long *) DebugGetCPUDataPtr(M64P_CPU_REG_COP1_FGR_64);
    /* open file handle to FIFO pipe */
    if (l_CoreCompareMode == CORE_COMPARE_RECV)
    {
        mkfifo("compare_pipe", 0600);
        DebugMessage(M64MSG_INFO, "Core Comparison Waiting to read pipe.");
        fPipe = fopen("compare_pipe", "r");
    }
    else if (l_CoreCompareMode == CORE_COMPARE_SEND)
    {
        DebugMessage(M64MSG_INFO, "Core Comparison Waiting to write pipe.");
        fPipe = fopen("compare_pipe", "w");
    }
#endif
}
Commit	Line	Data
5288f542	1	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
	2	* Mupen64plus - compare_core.h *
	3	* Mupen64Plus homepage: http://code.google.com/p/mupen64plus/ *
	4	* Copyright (C) 2009 Richard Goedeken *
	5	* Copyright (C) 2002 Hacktarux *
	6	* *
	7	* This program is free software; you can redistribute it and/or modify *
	8	* it under the terms of the GNU General Public License as published by *
	9	* the Free Software Foundation; either version 2 of the License, or *
	10	* (at your option) any later version. *
	11	* *
	12	* This program is distributed in the hope that it will be useful, *
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of *
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
	15	* GNU General Public License for more details. *
	16	* *
	17	* You should have received a copy of the GNU General Public License *
	18	* along with this program; if not, write to the *
	19	* Free Software Foundation, Inc., *
	20	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. *
	21	* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
	22
	23	#include <stdio.h>
	24	#include <string.h>
	25	#include <sys/stat.h>
	26
	27	#include "m64p_types.h"
	28	#include "main.h"
	29	#include "compare_core.h"
	30	#include "core_interface.h"
	31
	32	/* local variables */
	33
	34	static FILE *fPipe = NULL;
	35	static int comp_reg_32[32];
	36	static long long comp_reg_64[32];
	37	static unsigned int old_op = 0;
	38	static int l_CoreCompareMode = CORE_COMPARE_DISABLE;
	39
	40	static long long ptr_reg = NULL; / pointer to the 64-bit general purpose registers in the core */
	41	static int ptr_cop0 = NULL; / pointer to the 32-bit Co-processor 0 registers in the core */
	42	static long long ptr_fgr = NULL; / pointer to the 64-bit floating-point registers in the core */
	43	static int ptr_PC = NULL; / pointer to 32-bit R4300 Program Counter */
	44
	45	/* local functions */
	46	static void stop_it(void)
	47	{
	48	static int errors = 0;
	49
	50	(*CoreDoCommand)(M64CMD_STOP, 0, NULL);
	51
	52	errors++;
	53	#if !defined(WIN32)
	54	#if defined(__i386__) \|\| defined(__x86_64__)
	55	if (errors > 7)
	56	asm("int $3;");
	57	#endif
	58	#endif
	59	}
	60
	61	static void display_error(char *txt)
	62	{
	63	int i;
	64
65	printf("err: %6s addr:%x\t ", txt, *ptr_PC);
66
67	if (!strcmp(txt, "PC"))
68	{
69	printf("My PC: %x Ref PC: %x\t ", ptr_PC, comp_reg_32);
70	}
71	else if (!strcmp(txt, "gpr"))
72	{
73	for (i=0; i<32; i++)
74	{
75	if (ptr_reg[i] != comp_reg_64[i])
76	printf("My: reg[%d]=%llx\t Ref: reg[%d]=%llx\t ", i, ptr_reg[i], i, comp_reg_64[i]);
77	}
78	}
79	else if (!strcmp(txt, "cop0"))
80	{
81	for (i=0; i<32; i++)
82	{
83	if (ptr_cop0[i] != comp_reg_32[i])
84	printf("My: reg_cop0[%d]=%x\t Ref: reg_cop0[%d]=%x\t ", i, (unsigned int)ptr_cop0[i], i, (unsigned int)comp_reg_32[i]);
85	}
86	}
87	else if (!strcmp(txt, "cop1"))
88	{
89	for (i=0; i<32; i++)
90	{
91	if (ptr_fgr[i] != comp_reg_64[i])
92	printf("My: reg[%d]=%llx\t Ref: reg[%d]=%llx\t ", i, ptr_fgr[i], i, comp_reg_64[i]);
93	}
94	}
95	printf("\n");
96	/*for (i=0; i<32; i++)
97	{
98	if (reg_cop0[i] != comp_reg[i])
99	printf("reg_cop0[%d]=%llx != reg[%d]=%llx\n",
100	i, reg_cop0[i], i, comp_reg[i]);
101	}*/
102
103	stop_it();
104	}
105
106	static void compare_core_sync_data(int length, void *value)
107	{
108	if (l_CoreCompareMode == CORE_COMPARE_RECV)
109	{
110	if (fread(value, 1, length, fPipe) != length)
111	stop_it();
112	}
113	else if (l_CoreCompareMode == CORE_COMPARE_SEND)
114	{
115	if (fwrite(value, 1, length, fPipe) != length)
116	stop_it();
117	}
118	}
119
120	static void compare_core_check(unsigned int cur_opcode)
121	{
122	static int comparecnt = 0;
123	int iFirst = 1;
124	char errHead[128];
125	sprintf(errHead, "Compare #%i old_op: %x op: %x\n", comparecnt++, old_op, cur_opcode);
126
127	/* get pointer to current R4300 Program Counter address */
128	ptr_PC = (int ) DebugGetCPUDataPtr(M64P_CPU_PC); / this changes for every instruction */
129
130	if (l_CoreCompareMode == CORE_COMPARE_RECV)
131	{
132	if (fread(comp_reg_32, sizeof(int), 4, fPipe) != 4)
133	printf("compare_core_check: fread() failed");
134	if (ptr_PC != comp_reg_32)
135	{
136	if (iFirst)
137	{
138	printf("%s", errHead);
139	iFirst = 0;
140	}
141	display_error("PC");
142	}
143	if (fread (comp_reg_64, sizeof(long long int), 32, fPipe) != 32)
144	printf("compare_core_check: fread() failed");
145	if (memcmp(ptr_reg, comp_reg_64, 32*sizeof(long long int)) != 0)
146	{
147	if (iFirst)
148	{
149	printf("%s", errHead);
150	iFirst = 0;
151	}
152	display_error("gpr");
153	}
154	if (fread(comp_reg_32, sizeof(int), 32, fPipe) != 32)
155	printf("compare_core_check: fread() failed");
156	if (memcmp(ptr_cop0, comp_reg_32, 32*sizeof(int)) != 0)
157	{
158	if (iFirst)
159	{
160	printf("%s", errHead);
161	iFirst = 0;
162	}
163	display_error("cop0");
164	}
165	if (fread(comp_reg_64, sizeof(long long int), 32, fPipe) != 32)
166	printf("compare_core_check: fread() failed");
167	if (memcmp(ptr_fgr, comp_reg_64, 32*sizeof(long long int)))
168	{
169	if (iFirst)
170	{
171	printf("%s", errHead);
172	iFirst = 0;
173	}
174	display_error("cop1");
175	}
176	/*fread(comp_reg, 1, sizeof(int), f);
177	if (memcmp(&rdram[0x31280/4], comp_reg, sizeof(int)))
178	display_error("mem");*/
179	/*fread (comp_reg, 4, 1, f);
180	if (memcmp(&FCR31, comp_reg, 4))
181	display_error();*/
182	old_op = cur_opcode;
183	}
184	else if (l_CoreCompareMode == CORE_COMPARE_SEND)
185	{
186	if (fwrite(ptr_PC, sizeof(int), 4, fPipe) != 4 \|\|
187	fwrite(ptr_reg, sizeof(long long int), 32, fPipe) != 32 \|\|
188	fwrite(ptr_cop0, sizeof(int), 32, fPipe) != 32 \|\|
189	fwrite(ptr_fgr, sizeof(long long int), 32, fPipe) != 32)
190	printf("compare_core_check: fwrite() failed");
191	/*fwrite(&rdram[0x31280/4], 1, sizeof(int), f);
192	fwrite(&FCR31, 4, 1, f);*/
193	}
194	}
195
196	/* global functions */
197	void compare_core_init(int mode)
198	{
199	#if defined(WIN32)
200	DebugMessage(M64MSG_VERBOSE, "core comparison feature not supported on Windows platform.");
201	return;
202	#else
203	/* set mode */
204	l_CoreCompareMode = mode;
205	/* set callback functions in core */
206	if (DebugSetCoreCompare(compare_core_check, compare_core_sync_data) != M64ERR_SUCCESS)
207	{
208	l_CoreCompareMode = CORE_COMPARE_DISABLE;
209	DebugMessage(M64MSG_WARNING, "DebugSetCoreCompare() failed, core comparison disabled.");
210	return;
211	}
212	/* get pointers to emulated R4300 CPU registers */
213	ptr_reg = (long long *) DebugGetCPUDataPtr(M64P_CPU_REG_REG);
214	ptr_cop0 = (int *) DebugGetCPUDataPtr(M64P_CPU_REG_COP0);
215	ptr_fgr = (long long *) DebugGetCPUDataPtr(M64P_CPU_REG_COP1_FGR_64);
216	/* open file handle to FIFO pipe */
217	if (l_CoreCompareMode == CORE_COMPARE_RECV)
218	{
219	mkfifo("compare_pipe", 0600);
220	DebugMessage(M64MSG_INFO, "Core Comparison Waiting to read pipe.");
221	fPipe = fopen("compare_pipe", "r");
222	}
223	else if (l_CoreCompareMode == CORE_COMPARE_SEND)
224	{
225	DebugMessage(M64MSG_INFO, "Core Comparison Waiting to write pipe.");
226	fPipe = fopen("compare_pipe", "w");
227	}
228	#endif
229	}
230