[mupen64plus-pandora.git] / source / mupen64plus-core / src / r4300 / interpreter_tlb.def

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 *   Mupen64plus - interpreter_tlb.def                                     *
 *   Mupen64Plus homepage: http://code.google.com/p/mupen64plus/           *
 *   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 <zlib.h> // For adler32()

DECLARE_INSTRUCTION(TLBR)
{
   int index;
   index = Index & 0x1F;
   PageMask = tlb_e[index].mask << 13;
   EntryHi = ((tlb_e[index].vpn2 << 13) | tlb_e[index].asid);
   EntryLo0 = (tlb_e[index].pfn_even << 6) | (tlb_e[index].c_even << 3)
     | (tlb_e[index].d_even << 2) | (tlb_e[index].v_even << 1)
       | tlb_e[index].g;
   EntryLo1 = (tlb_e[index].pfn_odd << 6) | (tlb_e[index].c_odd << 3)
     | (tlb_e[index].d_odd << 2) | (tlb_e[index].v_odd << 1)
       | tlb_e[index].g;
   ADD_TO_PC(1);
}

static void TLBWrite(unsigned int idx)
{
   if (r4300emu != CORE_PURE_INTERPRETER)
   {
      unsigned int i;
      if (tlb_e[idx].v_even)
      {
         for (i=tlb_e[idx].start_even>>12; i<=tlb_e[idx].end_even>>12; i++)
         {
            if(!invalid_code[i] &&(invalid_code[tlb_LUT_r[i]>>12] ||
               invalid_code[(tlb_LUT_r[i]>>12)+0x20000]))
               invalid_code[i] = 1;
            if (!invalid_code[i])
            {
                /*int j;
                md5_state_t state;
                md5_byte_t digest[16];
                md5_init(&state);
                md5_append(&state, 
                       (const md5_byte_t*)&rdram[(tlb_LUT_r[i]&0x7FF000)/4],
                       0x1000);
                md5_finish(&state, digest);
                for (j=0; j<16; j++) blocks[i]->md5[j] = digest[j];*/
                
                blocks[i]->adler32 = adler32(0, (const unsigned char *)&rdram[(tlb_LUT_r[i]&0x7FF000)/4], 0x1000);
                
                invalid_code[i] = 1;
            }
            else if (blocks[i])
            {
               /*int j;
                for (j=0; j<16; j++) blocks[i]->md5[j] = 0;*/
               blocks[i]->adler32 = 0;
            }
         }
      }
      if (tlb_e[idx].v_odd)
      {
         for (i=tlb_e[idx].start_odd>>12; i<=tlb_e[idx].end_odd>>12; i++)
         {
            if(!invalid_code[i] &&(invalid_code[tlb_LUT_r[i]>>12] ||
               invalid_code[(tlb_LUT_r[i]>>12)+0x20000]))
               invalid_code[i] = 1;
            if (!invalid_code[i])
            {
               /*int j;
               md5_state_t state;
               md5_byte_t digest[16];
               md5_init(&state);
               md5_append(&state, 
                      (const md5_byte_t*)&rdram[(tlb_LUT_r[i]&0x7FF000)/4],
                      0x1000);
               md5_finish(&state, digest);
               for (j=0; j<16; j++) blocks[i]->md5[j] = digest[j];*/
                
               blocks[i]->adler32 = adler32(0, (const unsigned char *)&rdram[(tlb_LUT_r[i]&0x7FF000)/4], 0x1000);
                
               invalid_code[i] = 1;
            }
            else if (blocks[i])
            {
               /*int j;
               for (j=0; j<16; j++) blocks[i]->md5[j] = 0;*/
               blocks[i]->adler32 = 0;
            }
         }
      }
   }

   tlb_unmap(&tlb_e[idx]);

   tlb_e[idx].g = (EntryLo0 & EntryLo1 & 1);
   tlb_e[idx].pfn_even = (EntryLo0 & 0x3FFFFFC0) >> 6;
   tlb_e[idx].pfn_odd = (EntryLo1 & 0x3FFFFFC0) >> 6;
   tlb_e[idx].c_even = (EntryLo0 & 0x38) >> 3;
   tlb_e[idx].c_odd = (EntryLo1 & 0x38) >> 3;
   tlb_e[idx].d_even = (EntryLo0 & 0x4) >> 2;
   tlb_e[idx].d_odd = (EntryLo1 & 0x4) >> 2;
   tlb_e[idx].v_even = (EntryLo0 & 0x2) >> 1;
   tlb_e[idx].v_odd = (EntryLo1 & 0x2) >> 1;
   tlb_e[idx].asid = (EntryHi & 0xFF);
   tlb_e[idx].vpn2 = (EntryHi & 0xFFFFE000) >> 13;
   //tlb_e[idx].r = (EntryHi & 0xC000000000000000LL) >> 62;
   tlb_e[idx].mask = (PageMask & 0x1FFE000) >> 13;
   
   tlb_e[idx].start_even = tlb_e[idx].vpn2 << 13;
   tlb_e[idx].end_even = tlb_e[idx].start_even+
     (tlb_e[idx].mask << 12) + 0xFFF;
   tlb_e[idx].phys_even = tlb_e[idx].pfn_even << 12;
   

   tlb_e[idx].start_odd = tlb_e[idx].end_even+1;
   tlb_e[idx].end_odd = tlb_e[idx].start_odd+
     (tlb_e[idx].mask << 12) + 0xFFF;
   tlb_e[idx].phys_odd = tlb_e[idx].pfn_odd << 12;
   
   tlb_map(&tlb_e[idx]);

   if (r4300emu != CORE_PURE_INTERPRETER)
   {
      unsigned int i;
      if (tlb_e[idx].v_even)
      {    
         for (i=tlb_e[idx].start_even>>12; i<=tlb_e[idx].end_even>>12; i++)
         {
            /*if (blocks[i] && (blocks[i]->md5[0] || blocks[i]->md5[1] ||
                  blocks[i]->md5[2] || blocks[i]->md5[3]))
            {
               int j;
               int equal = 1;
               md5_state_t state;
               md5_byte_t digest[16];
               md5_init(&state);
               md5_append(&state, 
                  (const md5_byte_t*)&rdram[(tlb_LUT_r[i]&0x7FF000)/4],
                  0x1000);
               md5_finish(&state, digest);
               for (j=0; j<16; j++)
                 if (digest[j] != blocks[i]->md5[j])
                   equal = 0;
               if (equal) invalid_code[i] = 0;
               }*/
               if(blocks[i] && blocks[i]->adler32)
               {
                  if(blocks[i]->adler32 == adler32(0,(const unsigned char *)&rdram[(tlb_LUT_r[i]&0x7FF000)/4],0x1000))
                     invalid_code[i] = 0;
               }
         }
      }

      if (tlb_e[idx].v_odd)
      {    
         for (i=tlb_e[idx].start_odd>>12; i<=tlb_e[idx].end_odd>>12; i++)
         {
            /*if (blocks[i] && (blocks[i]->md5[0] || blocks[i]->md5[1] ||
                  blocks[i]->md5[2] || blocks[i]->md5[3]))
              {
            int j;
            int equal = 1;
            md5_state_t state;
            md5_byte_t digest[16];
            md5_init(&state);
            md5_append(&state, 
                   (const md5_byte_t*)&rdram[(tlb_LUT_r[i]&0x7FF000)/4],
                   0x1000);
            md5_finish(&state, digest);
            for (j=0; j<16; j++)
              if (digest[j] != blocks[i]->md5[j])
                equal = 0;
            if (equal) invalid_code[i] = 0;
            }*/
            if(blocks[i] && blocks[i]->adler32)
            {
               if(blocks[i]->adler32 == adler32(0,(const unsigned char *)&rdram[(tlb_LUT_r[i]&0x7FF000)/4],0x1000))
                  invalid_code[i] = 0;
            }
         }
      }
   }
}

DECLARE_INSTRUCTION(TLBWI)
{
   TLBWrite(Index&0x3F);
   ADD_TO_PC(1);
}

DECLARE_INSTRUCTION(TLBWR)
{
   update_count();
   Random = (Count/2 % (32 - Wired)) + Wired;
   TLBWrite(Random);
   ADD_TO_PC(1);
}

DECLARE_INSTRUCTION(TLBP)
{
   int i;
   Index |= 0x80000000;
   for (i=0; i<32; i++)
   {
      if (((tlb_e[i].vpn2 & (~tlb_e[i].mask)) ==
         (((EntryHi & 0xFFFFE000) >> 13) & (~tlb_e[i].mask))) &&
        ((tlb_e[i].g) ||
         (tlb_e[i].asid == (EntryHi & 0xFF))))
      {
         Index = i;
         break;
      }
   }
   ADD_TO_PC(1);
}

DECLARE_INSTRUCTION(ERET)
{
   update_count();
   if (Status & 0x4)
   {
     DebugMessage(M64MSG_ERROR, "error in ERET");
     stop=1;
   }
   else
   {
     Status &= ~0x2;
     generic_jump_to(EPC);
   }
   llbit = 0;
   check_interupt();
   last_addr = PCADDR;
   if (next_interupt <= Count) gen_interupt();
}
Commit	Line	Data
451ab91e	1	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
	2	* Mupen64plus - interpreter_tlb.def *
	3	* Mupen64Plus homepage: http://code.google.com/p/mupen64plus/ *
	4	* Copyright (C) 2002 Hacktarux *
	5	* *
	6	* This program is free software; you can redistribute it and/or modify *
	7	* it under the terms of the GNU General Public License as published by *
	8	* the Free Software Foundation; either version 2 of the License, or *
	9	* (at your option) any later version. *
	10	* *
	11	* This program is distributed in the hope that it will be useful, *
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of *
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
	14	* GNU General Public License for more details. *
	15	* *
	16	* You should have received a copy of the GNU General Public License *
	17	* along with this program; if not, write to the *
	18	* Free Software Foundation, Inc., *
	19	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. *
	20	* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
	21
	22	#include <zlib.h> // For adler32()
	23
	24	DECLARE_INSTRUCTION(TLBR)
	25	{
	26	int index;
	27	index = Index & 0x1F;
	28	PageMask = tlb_e[index].mask << 13;
	29	EntryHi = ((tlb_e[index].vpn2 << 13) \| tlb_e[index].asid);
	30	EntryLo0 = (tlb_e[index].pfn_even << 6) \| (tlb_e[index].c_even << 3)
	31	\| (tlb_e[index].d_even << 2) \| (tlb_e[index].v_even << 1)
	32	\| tlb_e[index].g;
	33	EntryLo1 = (tlb_e[index].pfn_odd << 6) \| (tlb_e[index].c_odd << 3)
	34	\| (tlb_e[index].d_odd << 2) \| (tlb_e[index].v_odd << 1)
	35	\| tlb_e[index].g;
	36	ADD_TO_PC(1);
	37	}
	38
	39	static void TLBWrite(unsigned int idx)
	40	{
	41	if (r4300emu != CORE_PURE_INTERPRETER)
	42	{
	43	unsigned int i;
	44	if (tlb_e[idx].v_even)
	45	{
	46	for (i=tlb_e[idx].start_even>>12; i<=tlb_e[idx].end_even>>12; i++)
	47	{
	48	if(!invalid_code[i] &&(invalid_code[tlb_LUT_r[i]>>12] \|\|
	49	invalid_code[(tlb_LUT_r[i]>>12)+0x20000]))
	50	invalid_code[i] = 1;
	51	if (!invalid_code[i])
	52	{
	53	/*int j;
	54	md5_state_t state;
	55	md5_byte_t digest[16];
	56	md5_init(&state);
	57	md5_append(&state,
	58	(const md5_byte_t*)&rdram[(tlb_LUT_r[i]&0x7FF000)/4],
	59	0x1000);
	60	md5_finish(&state, digest);
	61	for (j=0; j<16; j++) blocks[i]->md5[j] = digest[j];*/
	62
	63	blocks[i]->adler32 = adler32(0, (const unsigned char *)&rdram[(tlb_LUT_r[i]&0x7FF000)/4], 0x1000);
	64
65	invalid_code[i] = 1;
66	}
67	else if (blocks[i])
68	{
69	/*int j;
70	for (j=0; j<16; j++) blocks[i]->md5[j] = 0;*/
71	blocks[i]->adler32 = 0;
72	}
73	}
74	}
75	if (tlb_e[idx].v_odd)
76	{
77	for (i=tlb_e[idx].start_odd>>12; i<=tlb_e[idx].end_odd>>12; i++)
78	{
79	if(!invalid_code[i] &&(invalid_code[tlb_LUT_r[i]>>12] \|\|
80	invalid_code[(tlb_LUT_r[i]>>12)+0x20000]))
81	invalid_code[i] = 1;
82	if (!invalid_code[i])
83	{
84	/*int j;
85	md5_state_t state;
86	md5_byte_t digest[16];
87	md5_init(&state);
88	md5_append(&state,
89	(const md5_byte_t*)&rdram[(tlb_LUT_r[i]&0x7FF000)/4],
90	0x1000);
91	md5_finish(&state, digest);
92	for (j=0; j<16; j++) blocks[i]->md5[j] = digest[j];*/
93
94	blocks[i]->adler32 = adler32(0, (const unsigned char *)&rdram[(tlb_LUT_r[i]&0x7FF000)/4], 0x1000);
95
96	invalid_code[i] = 1;
97	}
98	else if (blocks[i])
99	{
100	/*int j;
101	for (j=0; j<16; j++) blocks[i]->md5[j] = 0;*/
102	blocks[i]->adler32 = 0;
103	}
104	}
105	}
106	}
107
108	tlb_unmap(&tlb_e[idx]);
109
110	tlb_e[idx].g = (EntryLo0 & EntryLo1 & 1);
111	tlb_e[idx].pfn_even = (EntryLo0 & 0x3FFFFFC0) >> 6;
112	tlb_e[idx].pfn_odd = (EntryLo1 & 0x3FFFFFC0) >> 6;
113	tlb_e[idx].c_even = (EntryLo0 & 0x38) >> 3;
114	tlb_e[idx].c_odd = (EntryLo1 & 0x38) >> 3;
115	tlb_e[idx].d_even = (EntryLo0 & 0x4) >> 2;
116	tlb_e[idx].d_odd = (EntryLo1 & 0x4) >> 2;
117	tlb_e[idx].v_even = (EntryLo0 & 0x2) >> 1;
118	tlb_e[idx].v_odd = (EntryLo1 & 0x2) >> 1;
119	tlb_e[idx].asid = (EntryHi & 0xFF);
120	tlb_e[idx].vpn2 = (EntryHi & 0xFFFFE000) >> 13;
121	//tlb_e[idx].r = (EntryHi & 0xC000000000000000LL) >> 62;
122	tlb_e[idx].mask = (PageMask & 0x1FFE000) >> 13;
123
124	tlb_e[idx].start_even = tlb_e[idx].vpn2 << 13;
125	tlb_e[idx].end_even = tlb_e[idx].start_even+
126	(tlb_e[idx].mask << 12) + 0xFFF;
127	tlb_e[idx].phys_even = tlb_e[idx].pfn_even << 12;
128
129
130	tlb_e[idx].start_odd = tlb_e[idx].end_even+1;
131	tlb_e[idx].end_odd = tlb_e[idx].start_odd+
132	(tlb_e[idx].mask << 12) + 0xFFF;
133	tlb_e[idx].phys_odd = tlb_e[idx].pfn_odd << 12;
134
135	tlb_map(&tlb_e[idx]);
136
137	if (r4300emu != CORE_PURE_INTERPRETER)
138	{
139	unsigned int i;
140	if (tlb_e[idx].v_even)
141	{
142	for (i=tlb_e[idx].start_even>>12; i<=tlb_e[idx].end_even>>12; i++)
143	{
144	/*if (blocks[i] && (blocks[i]->md5[0] \|\| blocks[i]->md5[1] \|\|
145	blocks[i]->md5[2] \|\| blocks[i]->md5[3]))
146	{
147	int j;
148	int equal = 1;
149	md5_state_t state;
150	md5_byte_t digest[16];
151	md5_init(&state);
152	md5_append(&state,
153	(const md5_byte_t*)&rdram[(tlb_LUT_r[i]&0x7FF000)/4],
154	0x1000);
155	md5_finish(&state, digest);
156	for (j=0; j<16; j++)
157	if (digest[j] != blocks[i]->md5[j])
158	equal = 0;
159	if (equal) invalid_code[i] = 0;
160	}*/
161	if(blocks[i] && blocks[i]->adler32)
162	{
163	if(blocks[i]->adler32 == adler32(0,(const unsigned char *)&rdram[(tlb_LUT_r[i]&0x7FF000)/4],0x1000))
164	invalid_code[i] = 0;
165	}
166	}
167	}
168
169	if (tlb_e[idx].v_odd)
170	{
171	for (i=tlb_e[idx].start_odd>>12; i<=tlb_e[idx].end_odd>>12; i++)
172	{
173	/*if (blocks[i] && (blocks[i]->md5[0] \|\| blocks[i]->md5[1] \|\|
174	blocks[i]->md5[2] \|\| blocks[i]->md5[3]))
175	{
176	int j;
177	int equal = 1;
178	md5_state_t state;
179	md5_byte_t digest[16];
180	md5_init(&state);
181	md5_append(&state,
182	(const md5_byte_t*)&rdram[(tlb_LUT_r[i]&0x7FF000)/4],
183	0x1000);
184	md5_finish(&state, digest);
185	for (j=0; j<16; j++)
186	if (digest[j] != blocks[i]->md5[j])
187	equal = 0;
188	if (equal) invalid_code[i] = 0;
189	}*/
190	if(blocks[i] && blocks[i]->adler32)
191	{
192	if(blocks[i]->adler32 == adler32(0,(const unsigned char *)&rdram[(tlb_LUT_r[i]&0x7FF000)/4],0x1000))
193	invalid_code[i] = 0;
194	}
195	}
196	}
197	}
198	}
199
200	DECLARE_INSTRUCTION(TLBWI)
201	{
202	TLBWrite(Index&0x3F);
203	ADD_TO_PC(1);
204	}
205
206	DECLARE_INSTRUCTION(TLBWR)
207	{
208	update_count();
209	Random = (Count/2 % (32 - Wired)) + Wired;
210	TLBWrite(Random);
211	ADD_TO_PC(1);
212	}
213
214	DECLARE_INSTRUCTION(TLBP)
215	{
216	int i;
217	Index \|= 0x80000000;
218	for (i=0; i<32; i++)
219	{
220	if (((tlb_e[i].vpn2 & (~tlb_e[i].mask)) ==
221	(((EntryHi & 0xFFFFE000) >> 13) & (~tlb_e[i].mask))) &&
222	((tlb_e[i].g) \|\|
223	(tlb_e[i].asid == (EntryHi & 0xFF))))
224	{
225	Index = i;
226	break;
227	}
228	}
229	ADD_TO_PC(1);
230	}
231
232	DECLARE_INSTRUCTION(ERET)
233	{
234	update_count();
235	if (Status & 0x4)
236	{
237	DebugMessage(M64MSG_ERROR, "error in ERET");
238	stop=1;
239	}
240	else
241	{
242	Status &= ~0x2;
243	generic_jump_to(EPC);
244	}
245	llbit = 0;
246	check_interupt();
247	last_addr = PCADDR;
248	if (next_interupt <= Count) gen_interupt();
249	}