src/cpus/cpu_sh_instr.c

/*
 *  Copyright (C) 2005-2006  Anders Gavare.  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  1. Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright  
 *     notice, this list of conditions and the following disclaimer in the 
 *     documentation and/or other materials provided with the distribution.
 *  3. The name of the author may not be used to endorse or promote products
 *     derived from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 *  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE   
 *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 *  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 *  OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 *  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 *  OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 *  SUCH DAMAGE.
 *
 *
 *  $Id: cpu_sh_instr.c,v 1.7 2006/02/24 01:20:36 debug Exp $
 *
 *  SH instructions.
 *
 *  Individual functions should keep track of cpu->n_translated_instrs.
 *  (If no instruction was executed, then it should be decreased. If, say, 4
 *  instructions were combined into one function and executed, then it should
 *  be increased by 3.)
 */


/*
 *  nop:  Do nothing.
 */
X(nop)
{
}


/*****************************************************************************/


X(end_of_page)
{
        /*  Update the PC:  (offset 0, but on the next page)  */
        cpu->pc &= ~((SH_IC_ENTRIES_PER_PAGE-1) <<
            SH_INSTR_ALIGNMENT_SHIFT);
        cpu->pc += (SH_IC_ENTRIES_PER_PAGE <<
            SH_INSTR_ALIGNMENT_SHIFT);

        /*  Find the new physical page and update the translation pointers:  */
        DYNTRANS_PC_TO_POINTERS(cpu);

        /*  end_of_page doesn't count as an executed instruction:  */
        cpu->n_translated_instrs --;
}


/*****************************************************************************/


/*
 *  sh_instr_to_be_translated():
 *
 *  Translate an instruction word into an sh_instr_call. ic is filled in with
 *  valid data for the translated instruction, or a "nothing" instruction if
 *  there was a translation failure. The newly translated instruction is then
 *  executed.
 */
X(to_be_translated)
{
        uint64_t addr, low_pc;
        uint32_t iword;
        unsigned char *page;
        unsigned char ib[4];
        int main_opcode, instr_size = 4;
        /* void (*samepage_function)(struct cpu *, struct sh_instr_call *);*/

        /*  Figure out the (virtual) address of the instruction:  */
        if (cpu->cd.sh.compact) {
                instr_size = 2;
                fatal("Compact: TODO\n");
                exit(1);
        } else {
                low_pc = ((size_t)ic - (size_t)cpu->cd.sh.cur_ic_page)
                    / sizeof(struct sh_instr_call);
                addr = cpu->pc & ~((SH_IC_ENTRIES_PER_PAGE-1)
                    << SH_INSTR_ALIGNMENT_SHIFT);
                addr += (low_pc << SH_INSTR_ALIGNMENT_SHIFT);
                cpu->pc = addr;
                addr &= ~0x3;
        }

        /*  Read the instruction word from memory:  */
        page = cpu->cd.sh.host_load[addr >> 12];

        if (page != NULL) {
                /*  fatal("TRANSLATION HIT!\n");  */
                memcpy(ib, page + (addr & 0xfff), sizeof(ib));
        } else {
                /*  fatal("TRANSLATION MISS!\n");  */
                if (!cpu->memory_rw(cpu, cpu->mem, addr, ib,
                    sizeof(ib), MEM_READ, CACHE_INSTRUCTION)) {
                        fatal("to_be_translated(): "
                            "read failed: TODO\n");
                        goto bad;
                }
        }

        iword = *((uint32_t *)&ib[0]);

#ifdef HOST_LITTLE_ENDIAN
        iword = ((iword & 0xff) << 24) |
                ((iword & 0xff00) << 8) |
                ((iword & 0xff0000) >> 8) |
                ((iword & 0xff000000) >> 24);
#endif


#define DYNTRANS_TO_BE_TRANSLATED_HEAD
#include "cpu_dyntrans.c"
#undef  DYNTRANS_TO_BE_TRANSLATED_HEAD


        /*
         *  Translate the instruction:
         */

        main_opcode = iword >> 26;

#if 0
        switch (main_opcode) {

        default:goto bad;
        }
#endif

#define DYNTRANS_TO_BE_TRANSLATED_TAIL
#include "cpu_dyntrans.c" 
#undef  DYNTRANS_TO_BE_TRANSLATED_TAIL
}

1	/*
2	* Copyright (C) 2005-2006 Anders Gavare. All rights reserved.
3	*
4	* Redistribution and use in source and binary forms, with or without
5	* modification, are permitted provided that the following conditions are met:
6	*
7	* 1. Redistributions of source code must retain the above copyright
8	* notice, this list of conditions and the following disclaimer.
9	* 2. Redistributions in binary form must reproduce the above copyright
10	* notice, this list of conditions and the following disclaimer in the
11	* documentation and/or other materials provided with the distribution.
12	* 3. The name of the author may not be used to endorse or promote products
13	* derived from this software without specific prior written permission.
14	*
15	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18	* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25	* SUCH DAMAGE.
26	*
27	*
28	* $Id: cpu_sh_instr.c,v 1.7 2006/02/24 01:20:36 debug Exp $
29	*
30	* SH instructions.
31	*
32	* Individual functions should keep track of cpu->n_translated_instrs.
33	* (If no instruction was executed, then it should be decreased. If, say, 4
34	* instructions were combined into one function and executed, then it should
35	* be increased by 3.)
36	*/
37
38
39	/*
40	* nop: Do nothing.
41	*/
42	X(nop)
43	{
44	}
45
46
47	/*****************************************************************************/
48
49
50	X(end_of_page)
51	{
52	/* Update the PC: (offset 0, but on the next page) */
53	cpu->pc &= ~((SH_IC_ENTRIES_PER_PAGE-1) <<
54	SH_INSTR_ALIGNMENT_SHIFT);
55	cpu->pc += (SH_IC_ENTRIES_PER_PAGE <<
56	SH_INSTR_ALIGNMENT_SHIFT);
57
58	/* Find the new physical page and update the translation pointers: */
59	DYNTRANS_PC_TO_POINTERS(cpu);
60
61	/* end_of_page doesn't count as an executed instruction: */
62	cpu->n_translated_instrs --;
63	}
64
65
66	/*****************************************************************************/
67
68
69	/*
70	* sh_instr_to_be_translated():
71	*
72	* Translate an instruction word into an sh_instr_call. ic is filled in with
73	* valid data for the translated instruction, or a "nothing" instruction if
74	* there was a translation failure. The newly translated instruction is then
75	* executed.
76	*/
77	X(to_be_translated)
78	{
79	uint64_t addr, low_pc;
80	uint32_t iword;
81	unsigned char *page;
82	unsigned char ib[4];
83	int main_opcode, instr_size = 4;
84	/* void (samepage_function)(struct cpu , struct sh_instr_call );/
85
86	/* Figure out the (virtual) address of the instruction: */
87	if (cpu->cd.sh.compact) {
88	instr_size = 2;
89	fatal("Compact: TODO\n");
90	exit(1);
91	} else {
92	low_pc = ((size_t)ic - (size_t)cpu->cd.sh.cur_ic_page)
93	/ sizeof(struct sh_instr_call);
94	addr = cpu->pc & ~((SH_IC_ENTRIES_PER_PAGE-1)
95	<< SH_INSTR_ALIGNMENT_SHIFT);
96	addr += (low_pc << SH_INSTR_ALIGNMENT_SHIFT);
97	cpu->pc = addr;
98	addr &= ~0x3;
99	}
100
101	/* Read the instruction word from memory: */
102	page = cpu->cd.sh.host_load[addr >> 12];
103
104	if (page != NULL) {
105	/* fatal("TRANSLATION HIT!\n"); */
106	memcpy(ib, page + (addr & 0xfff), sizeof(ib));
107	} else {
108	/* fatal("TRANSLATION MISS!\n"); */
109	if (!cpu->memory_rw(cpu, cpu->mem, addr, ib,
110	sizeof(ib), MEM_READ, CACHE_INSTRUCTION)) {
111	fatal("to_be_translated(): "
112	"read failed: TODO\n");
113	goto bad;
114	}
115	}
116
117	iword = ((uint32_t )&ib[0]);
118
119	#ifdef HOST_LITTLE_ENDIAN
120	iword = ((iword & 0xff) << 24) \|
121	((iword & 0xff00) << 8) \|
122	((iword & 0xff0000) >> 8) \|
123	((iword & 0xff000000) >> 24);
124	#endif
125
126
127	#define DYNTRANS_TO_BE_TRANSLATED_HEAD
128	#include "cpu_dyntrans.c"
129	#undef DYNTRANS_TO_BE_TRANSLATED_HEAD
130
131
132	/*
133	* Translate the instruction:
134	*/
135
136	main_opcode = iword >> 26;
137
138	#if 0
139	switch (main_opcode) {
140
141	default:goto bad;
142	}
143	#endif
144
145	#define DYNTRANS_TO_BE_TRANSLATED_TAIL
146	#include "cpu_dyntrans.c"
147	#undef DYNTRANS_TO_BE_TRANSLATED_TAIL
148	}
149