/[pearpc]/src/cpu/cpu_jitc_x86/jitc_mmu.S
This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!
ViewVC logotype

Contents of /src/cpu/cpu_jitc_x86/jitc_mmu.S

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1 - (show annotations)
Wed Sep 5 17:11:21 2007 UTC (12 years, 2 months ago) by dpavlin
File size: 39674 byte(s)
import upstream CVS
1 /*
2 * PearPC
3 * jitc_mmu.S
4 *
5 * Copyright (C) 2003-2006 Sebastian Biallas (sb@biallas.net)
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 version 2 as
9 * published by the Free Software Foundation.
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 Free Software
18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */
20
21 #ifndef PREFIX
22 #define PREFIX
23 #endif
24
25 #define EXPORT(sym) EXPORT2(PREFIX, sym)
26 #define EXPORT2(p, sym) EXPORT3(p, sym)
27 #define EXPORT3(p, sym) .globl p##sym; p##sym
28
29 #define EXTERN(sym) EXTERN2(PREFIX, sym)
30 #define EXTERN2(p, sym) EXTERN3(p, sym)
31 #define EXTERN3(p, sym) p##sym
32
33 #define STRUCT .struct 0
34 #define MEMBER(m, s) m:;.struct m+s
35
36 .intel_syntax prefix
37
38 #define TLB_ENTRIES 32
39
40 # Define this if you want exact handling of the SO bit.
41 /* #define EXACT_SO */
42
43 STRUCT #PPC_CPU_State
44 MEMBER(dummy, 4)
45 MEMBER(gpr, 32*4)
46 MEMBER(fpr, 32*8)
47 MEMBER(cr, 4)
48 MEMBER(fpscr, 4)
49 MEMBER(xer, 4)
50 MEMBER(xer_ca, 4)
51 MEMBER(lt, 4)
52 MEMBER(ctr, 4)
53
54 MEMBER(msr, 4)
55 MEMBER(pvr, 4)
56
57 MEMBER(ibatu, 4*4)
58 MEMBER(ibatl, 4*4)
59 MEMBER(ibat_bl, 4*4)
60 MEMBER(ibat_nbl, 4*4)
61 MEMBER(ibat_bepi, 4*4)
62 MEMBER(ibat_brpn, 4*4)
63
64 MEMBER(dbatu, 4*4)
65 MEMBER(dbatl, 4*4)
66 MEMBER(dbat_bl, 4*4)
67 MEMBER(dbat_nbl, 4*4)
68 MEMBER(dbat_bepi, 4*4)
69 MEMBER(dbat_brpn, 4*4)
70
71 MEMBER(sdr1, 4)
72
73 MEMBER(sr, 16*4)
74
75 MEMBER(dar, 4)
76 MEMBER(dsisr, 4)
77 MEMBER(sprg, 4*4)
78 MEMBER(srr0, 4)
79 MEMBER(srr1, 4)
80
81 MEMBER(decr, 4)
82 MEMBER(ear, 4)
83 MEMBER(pir, 4)
84 MEMBER(tb, 8)
85
86 MEMBER(hid, 16*4)
87
88 MEMBER(pc, 4)
89 MEMBER(npc, 4)
90 MEMBER(current_opc, 4)
91
92 MEMBER(exception_pending, 1)
93 MEMBER(dec_exception, 1)
94 MEMBER(ext_exception, 1)
95 MEMBER(stop_exception, 1)
96 MEMBER(singlestep_ignore, 1)
97 MEMBER(align1, 1)
98 MEMBER(align2, 1)
99 MEMBER(align3, 1)
100
101 MEMBER(pagetable_base, 4)
102 MEMBER(pagetable_hashmask, 4)
103 MEMBER(reserve, 4)
104 MEMBER(have_reservation, 4)
105
106 MEMBER(tlb_last, 4)
107 MEMBER(tlb_pa, 4*4)
108 MEMBER(tlb_va, 4*4)
109 MEMBER(effective_code_page, 4)
110 MEMBER(physical_code_page, 4)
111 MEMBER(pdec, 2*4)
112 MEMBER(ptb, 2*4)
113
114 MEMBER(temp, 4)
115 MEMBER(temp2, 4)
116 MEMBER(x87cw, 4)
117 MEMBER(pc_ofs, 4)
118 MEMBER(current_code_base, 4)
119
120 STRUCT #JITC
121 MEMBER(clientPages, 4)
122 MEMBER(tlb_code_0_eff, TLB_ENTRIES*4)
123 MEMBER(tlb_data_0_eff, TLB_ENTRIES*4)
124 MEMBER(tlb_data_8_eff, TLB_ENTRIES*4)
125 MEMBER(tlb_code_0_phys, TLB_ENTRIES*4)
126 MEMBER(tlb_data_0_phys, TLB_ENTRIES*4)
127 MEMBER(tlb_data_8_phys, TLB_ENTRIES*4)
128 MEMBER(blblbl, 4)
129 MEMBER(tlb_code_0_hits, 8)
130 MEMBER(tlb_data_0_hits, 8)
131 MEMBER(tlb_data_8_hits, 8)
132 MEMBER(tlb_code_0_misses, 8)
133 MEMBER(tlb_data_0_misses, 8)
134 MEMBER(tlb_data_8_misses, 8)
135
136 MEMBER(nativeReg, 8*4)
137
138 MEMBER(nativeRegState, 8*4)
139
140 MEMBER(nativeFlags, 4)
141
142 MEMBER(nativeFlagsState, 4)
143 MEMBER(nativeCarryState, 4)
144
145 MEMBER(clientReg, 600*4)
146
147 MEMBER(nativeRegsList, 8*4)
148
149 MEMBER(LRUreg, 4)
150 MEMBER(MRUreg, 4)
151
152 MEMBER(LRUpage, 4)
153 MEMBER(MRUpage, 4)
154
155 MEMBER(freeFragmentsList, 4)
156
157 MEMBER(freeClientPages, 4)
158
159 MEMBER(translationCache, 4)
160
161 STRUCT #ClientPage
162 MEMBER(entrypoints, 1024*4)
163 MEMBER(baseaddress, 4)
164 MEMBER(tcf_current, 4)
165 MEMBER(bytesLeft, 4)
166 MEMBER(tcp, 4)
167 MEMBER(moreRU, 4)
168 MEMBER(lessRU, 4)
169
170 #define gCPU(r) EXTERN(gCPU)+r
171 #define gJITC(r) EXTERN(gJITC)+r
172
173 .text
174
175 .balign 16
176 ##############################################################################################
177 ##
178 EXPORT(ppc_mmu_tlb_invalidate_all_asm):
179 cld
180 or %eax, -1
181 mov %ecx, TLB_ENTRIES*4*3 / 4
182 mov %edi, offset gJITC(tlb_code_0_eff)
183 rep stosd
184 ret
185
186 ##############################################################################################
187 ##
188 ## IN: %eax: effective address to invalidate
189 ##
190 EXPORT(ppc_mmu_tlb_invalidate_entry_asm):
191 mov %ecx, %eax
192 or %eax, -1
193 shr %ecx, 12
194 and %ecx, TLB_ENTRIES-1
195 mov [gJITC(tlb_code_0_eff+%ecx*4)], %eax
196 mov [gJITC(tlb_data_0_eff+%ecx*4)], %eax
197 mov [gJITC(tlb_data_8_eff+%ecx*4)], %eax
198 ret
199
200 ##############################################################################################
201 ## read_physical_word_pg
202 .macro read_physical_word_pg r1, r2
203 mov \r2, [EXTERN(gMemory)]
204 mov \r2, [\r2 + \r1]
205 bswap \r2
206 .endm
207
208 .balign 16
209 ##############################################################################################
210 ## ppc_pte_protection
211 ppc_pte_protection:
212
213 ## read(0)/write(1)*8 | key*4 | pp
214
215 ## read
216 .byte 1 # r/w
217 .byte 1 # r/w
218 .byte 1 # r/w
219 .byte 1 # r
220 .byte 0 # -
221 .byte 1 # r
222 .byte 1 # r/w
223 .byte 1 # r
224
225 ## write
226 .byte 1 # r/w
227 .byte 1 # r/w
228 .byte 1 # r/w
229 .byte 0 # r
230 .byte 0 # -
231 .byte 0 # r
232 .byte 1 # r/w
233 .byte 0 # r
234
235 ###############################################################################
236 ## bat_lookup
237 #define bat_lookup(di, n, rw, datacode) \
238 mov %edx, [gCPU(di##bat_bl + n*4)]; \
239 mov %ebx, [gCPU(di##bat_bepi + n*4)]; \
240 \
241 and %edx, %eax; \
242 cmp %ebx, %edx; \
243 jne 3f; \
244 \
245 bt dword ptr [gCPU(msr)], 14; \
246 mov %ebp, 2; \
247 sbb %ebp, 0; /* BATU_Vp / BATU_Vs */ \
248 \
249 test [gCPU(di##batu + n*4)], %ebp; \
250 jz 3f; \
251 \
252 /* FIXME: check access rights */ \
253 mov %esi, %eax; \
254 mov %edi, %eax; \
255 mov %edx, 0xfffff000; \
256 and %eax, [gCPU(di##bat_nbl + n*4)]; \
257 or %eax, [gCPU(di##bat_brpn + n*4)]; \
258 \
259 /** TLB-Code */ \
260 shr %edi, 12; \
261 and %esi, %edx; \
262 and %edi, TLB_ENTRIES-1; \
263 and %edx, %eax; \
264 mov [gJITC(tlb_##datacode##_##rw##_eff+%edi*4)], %esi; \
265 mov [gJITC(tlb_##datacode##_##rw##_phys+%edi*4)], %edx; \
266 /* add dword ptr [gJITC(tlb_##datatcode##_##rw##_misses)], 1; */ \
267 /* adc dword ptr [gJITC(tlb_##datatcode##_##rw##_misses+4)], 0; */ \
268 ret 4; \
269 3:
270
271 ##############################################################################################
272 ## pg_table_lookup
273 ##
274 ## param1: PTE1_H or 0
275 ## param2: 0 for read, 8 for write
276 ## param3: data / code
277 ## param4: pt offset
278 #define pg_table_lookup(n, rw, datacode, offset) \
279 read_physical_word_pg %ebx+offset, %eax; \
280 /* %ecx = pte1 */ \
281 \
282 mov %ecx, %eax; \
283 and %eax, (1<<6) | (1<<31); /* (PTE1_V | PTE1_H) */ \
284 cmp %eax, (n) | (1<<31); \
285 jne 1f; \
286 \
287 mov %eax, %ecx; \
288 shr %ecx, 7; \
289 and %ecx, 0xffffff; /* VSID */ \
290 cmp %ecx, %ebp; \
291 jne 1f; \
292 \
293 and %eax, 0x3f; /* API */ \
294 cmp %eax, %edi; \
295 jne 1f; \
296 \
297 /* page found */ \
298 \
299 read_physical_word_pg %ebx+4+offset, %esi; \
300 /* # %esi = pte2; */ \
301 \
302 /* FIXME: use bt trick? */ \
303 test dword ptr [gCPU(msr)], (1<<14); /* MSR_PR */ \
304 mov %eax, (1<<29); /* SR_Kp */ \
305 setz %cl; \
306 shl %eax, %cl; /* SR_Kp <--> SR_Ks */ \
307 test %edx, %eax; /* SR_Kp / SR_Ks */ \
308 setnz %al; \
309 movzx %eax, %al; \
310 \
311 mov %ecx, %esi; \
312 and %ecx, 3; \
313 \
314 cmp byte ptr [ppc_pte_protection + (rw) + 4*%eax + %ecx], 1; \
315 .if n==0; \
316 /* add %esp, 4; /* hash1, no longer needed */ \
317 pop %edx; \
318 .endif; \
319 pop %eax; /* the effective address */ \
320 jne protection_fault_##rw##_##datacode; \
321 \
322 /* update R and C bits */ \
323 mov %edx, %esi; \
324 .if rw==0; \
325 or %edx, (1<<8); /* PTE2_R */ \
326 .else; \
327 or %edx, (1<<8) | (1<<7); /* PTE2_R | PTE2_C */ \
328 .endif; \
329 bswap %edx; \
330 add %ebx, [EXTERN(gMemory)]; \
331 mov [%ebx+4+offset], %edx; \
332 \
333 and %esi, 0xfffff000; \
334 /** TLB-Code */ \
335 mov %edx, %eax; \
336 mov %ecx, %eax; \
337 shr %edx, 12; \
338 and %ecx, 0xfffff000; \
339 and %edx, TLB_ENTRIES-1; \
340 mov [gJITC(tlb_## datacode ##_## rw ##_eff + %edx*4)], %ecx; \
341 mov [gJITC(tlb_## datacode ##_## rw ##_phys + %edx*4)], %esi; \
342 /* add dword ptr [gJITC(tlb_## datacode ##_## rw ##_misses)], 1;*/ \
343 /* adc dword ptr [gJITC(tlb_## datacode ##_## rw ##_misses+4)], 0;*/ \
344 /***/ \
345 and %eax, 0x00000fff; \
346 or %eax, %esi; \
347 ret 4; \
348 1:
349
350 ##############################################################################################
351 ## protection_fault_%2_%3
352 protection_fault_0_code:
353 # ppc_exception(PPC_EXC_ISI, PPC_EXC_SRR1_PROT, addr);
354 pop %edx # return address is no longer needed
355 pop %ebx # bytes to roll back
356 add %esp, %ebx
357 mov %ecx, (1<<27) # PPC_EXC_SRR1_PROT
358 jmp EXTERN(ppc_isi_exception_asm)
359 protection_fault_0_data:
360 # ppc_exception(PPC_EXC_DSI, PPC_EXC_DSISR_PROT, addr);
361 pop %edx # return address is no longer needed
362 pop %ebx # bytes to roll back
363 add %esp, %ebx
364 mov %ecx, (1<<27) # PPC_EXC_DSISR_PROT
365 jmp EXTERN(ppc_dsi_exception_asm)
366 protection_fault_8_data:
367 # ppc_exception(PPC_EXC_DSI, PPC_EXC_DSISR_PROT | PPC_EXC_DSISR_STORE, addr);
368 pop %edx # return address is no longer needed
369 pop %ebx # bytes to roll back
370 add %esp, %ebx
371 mov %ecx, (1<<27) | (1<<25) # PPC_EXC_DSISR_PROT | PPC_EXC_DSISR_STORE
372 jmp EXTERN(ppc_dsi_exception_asm)
373
374 ##############################################################################################
375 ## param1: 0 for read, 8 for write
376 ## param2: data / code
377 #define tlb_lookup(rw, datacode) \
378 mov %edx, %eax; \
379 mov %ecx, %eax; \
380 shr %edx, 12; \
381 and %ecx, 0xfffff000; \
382 and %edx, TLB_ENTRIES-1; \
383 cmp %ecx, [gJITC(tlb_##datacode##_##rw##_eff + %edx*4)]; \
384 jne 1f; \
385 /* \
386 * if a tlb entry is invalid, its \
387 * lower 12 bits are 1, so the cmp is guaranteed to fail. \
388 */ \
389 /* add dword ptr [gJITC(tlb_##datacode##_##rw##_hits)], 1; */ \
390 /* adc dword ptr [gJITC(tlb_##datacode##_##rw##_hits+4)], 0; */ \
391 and %eax, 0x00000fff; \
392 or %eax, [gJITC(tlb_##datacode##_##rw##_phys + %edx*4)]; \
393 ret 4; \
394 1: \
395
396 .balign 16
397 ppc_effective_to_physical_code_ret:
398 mov %edx, %eax
399 mov %ecx, %eax
400 shr %edx, 12
401 and %ecx, 0xfffff000
402 and %edx, TLB_ENTRIES-1
403 mov [gJITC(tlb_code_0_eff+%edx*4)], %ecx
404 mov [gJITC(tlb_code_0_phys+%edx*4)], %ecx
405 ret 4
406
407 .balign 16
408 ##############################################################################################
409 ## uint32 FASTCALL ppc_effective_to_physical_code(uint32 addr)
410 ##
411 ## IN %eax: address to translate
412 ##
413 ## WILL NOT RETURN ON EXCEPTION!
414 ##
415 EXPORT(ppc_effective_to_physical_code):
416 tlb_lookup(0, code)
417
418 test byte ptr [gCPU(msr)], (1<<5) # MSR_IR
419 jz ppc_effective_to_physical_code_ret
420
421 bat_lookup(i, 0, 0, code)
422 bat_lookup(i, 1, 0, code)
423 bat_lookup(i, 2, 0, code)
424 bat_lookup(i, 3, 0, code)
425
426 mov %ebx, %eax
427 shr %ebx, 28 # SR
428 mov %edx, [gCPU(sr+4*%ebx)]
429
430 # test %edx, SR_T --> die
431
432 test %edx, (1<<28) # SR_N
433 jnz 9f
434
435 mov %ebx, %eax
436 mov %ebp, %edx
437 shr %ebx, 12
438 mov %edi, %eax
439 and %ebx, 0xffff
440 shr %edi, 22
441 and %ebp, 0xffffff
442 and %edi, 0x3f
443
444 # now:
445 # %eax = addr
446 # %ebx = page_index
447 # %ebp = VSID
448 # %edi = api
449
450 xor %ebx, %ebp
451
452 # %ebx = hash1
453
454 push %eax
455 push %ebx # das brauch ich
456
457 and %ebx, [gCPU(pagetable_hashmask)]
458 shl %ebx, 6
459 or %ebx, [gCPU(pagetable_base)]
460
461 # %ebx = pteg_addr
462
463 pg_table_lookup(0, 0, code, 0)
464 pg_table_lookup(0, 0, code, 8)
465 pg_table_lookup(0, 0, code, 16)
466 pg_table_lookup(0, 0, code, 24)
467 pg_table_lookup(0, 0, code, 32)
468 pg_table_lookup(0, 0, code, 40)
469 pg_table_lookup(0, 0, code, 48)
470 pg_table_lookup(0, 0, code, 56)
471
472 # hash function number 2
473 pop %ebx
474 not %ebx
475 and %ebx, [gCPU(pagetable_hashmask)]
476 shl %ebx, 6
477 or %ebx, [gCPU(pagetable_base)]
478
479 pg_table_lookup(1<<6, 0, code, 0)
480 pg_table_lookup(1<<6, 0, code, 8)
481 pg_table_lookup(1<<6, 0, code, 16)
482 pg_table_lookup(1<<6, 0, code, 24)
483 pg_table_lookup(1<<6, 0, code, 32)
484 pg_table_lookup(1<<6, 0, code, 40)
485 pg_table_lookup(1<<6, 0, code, 48)
486 pg_table_lookup(1<<6, 0, code, 56)
487
488 # page lookup failed --> throw exception
489
490 pop %eax
491 pop %edx # return address is no longer needed
492 pop %ecx # bytes to roll back
493 add %esp, %ecx
494
495 mov %ecx, (1<<30) # PPC_EXC_SRR1_PAGE
496 jmp EXTERN(ppc_isi_exception_asm)
497 9:
498 # segment isnt executable --> throw exception
499 pop %edx # return address is no longer needed
500 pop %ecx # bytes to roll back
501 add %esp, %ecx
502
503 mov %ecx, (1<<28) # PPC_EXC_SRR1_GUARD
504 jmp EXTERN(ppc_isi_exception_asm)
505
506 .balign 16
507 ppc_effective_to_physical_data_read_ret:
508 mov %edx, %eax
509 mov %ecx, %eax
510 shr %edx, 12
511 and %ecx, 0xfffff000
512 and %edx, TLB_ENTRIES-1
513 mov [gJITC(tlb_data_0_eff+%edx*4)], %ecx
514 mov [gJITC(tlb_data_0_phys+%edx*4)], %ecx
515 ret 4
516
517 .balign 16
518 ##############################################################################################
519 ## uint32 FASTCALL ppc_effective_to_physical_data_read(uint32 addr)
520 ##
521 ## IN %eax: address to translate
522 ##
523 ## WILL NOT RETURN ON EXCEPTION!
524 ##
525 ppc_effective_to_physical_data_read:
526 tlb_lookup(0, data)
527
528 test byte ptr [gCPU(msr)], (1<<4) # MSR_DR
529 jz ppc_effective_to_physical_data_read_ret
530
531 bat_lookup(d, 0, 0, data)
532 bat_lookup(d, 1, 0, data)
533 bat_lookup(d, 2, 0, data)
534 bat_lookup(d, 3, 0, data)
535
536 mov %ebx, %eax
537 shr %ebx, 28 # SR
538 mov %edx, [gCPU(sr+4*%ebx)]
539
540 # test %edx, SR_T --> die
541
542 mov %ebx, %eax
543 mov %ebp, %edx
544 shr %ebx, 12
545 mov %edi, %eax
546 and %ebx, 0xffff
547 shr %edi, 22
548 and %ebp, 0xffffff
549 and %edi, 0x3f
550
551 # now:
552 # %eax = addr
553 # %ebx = page_index
554 # %ebp = VSID
555 # %edi = api
556
557 xor %ebx, %ebp
558
559 # %ebx = hash1
560
561 push %eax
562 push %ebx # das brauch ich
563
564 and %ebx, [gCPU(pagetable_hashmask)]
565 shl %ebx, 6
566 or %ebx, [gCPU(pagetable_base)]
567
568 # %ebx = pteg_addr
569
570 pg_table_lookup(0, 0, data, 0)
571 pg_table_lookup(0, 0, data, 8)
572 pg_table_lookup(0, 0, data, 16)
573 pg_table_lookup(0, 0, data, 24)
574 pg_table_lookup(0, 0, data, 32)
575 pg_table_lookup(0, 0, data, 40)
576 pg_table_lookup(0, 0, data, 48)
577 pg_table_lookup(0, 0, data, 56)
578
579 # hash function number 2
580 pop %ebx
581 not %ebx
582 and %ebx, [gCPU(pagetable_hashmask)]
583 shl %ebx, 6
584 or %ebx, [gCPU(pagetable_base)]
585
586 pg_table_lookup(1<<6, 0, data, 0)
587 pg_table_lookup(1<<6, 0, data, 8)
588 pg_table_lookup(1<<6, 0, data, 16)
589 pg_table_lookup(1<<6, 0, data, 24)
590 pg_table_lookup(1<<6, 0, data, 32)
591 pg_table_lookup(1<<6, 0, data, 40)
592 pg_table_lookup(1<<6, 0, data, 48)
593 pg_table_lookup(1<<6, 0, data, 56)
594
595 # page lookup failed --> throw exception
596
597 pop %eax
598 pop %edx # return address is no longer needed
599 pop %ecx # bytes to roll back
600 add %esp, %ecx
601
602 mov %ecx, (1<<30) # PPC_EXC_DSISR_PAGE
603 jmp EXTERN(ppc_dsi_exception_asm)
604
605 .balign 16
606 ppc_effective_to_physical_data_write_ret:
607 mov %edx, %eax
608 mov %ecx, %eax
609 shr %edx, 12
610 and %ecx, 0xfffff000
611 and %edx, TLB_ENTRIES-1
612 mov [gJITC(tlb_data_8_eff+%edx*4)], %ecx
613 mov [gJITC(tlb_data_8_phys+%edx*4)], %ecx
614 ret 4
615
616 .balign 16
617 ##############################################################################################
618 ## uint32 FASTCALL ppc_effective_to_physical_data_write(uint32 addr)
619 ##
620 ## IN %eax: address to translate
621 ##
622 ## WILL NOT RETURN ON EXCEPTION!
623 ##
624 ppc_effective_to_physical_data_write:
625 tlb_lookup(8, data)
626
627 test byte ptr [gCPU(msr)], (1<<4) # MSR_DR
628 jz ppc_effective_to_physical_data_write_ret
629
630 bat_lookup(d, 0, 8, data)
631 bat_lookup(d, 1, 8, data)
632 bat_lookup(d, 2, 8, data)
633 bat_lookup(d, 3, 8, data)
634
635 mov %ebx, %eax
636 shr %eax, 28 # SR
637 mov %edx, [gCPU(sr+4*%eax)]
638
639 # test %edx, SR_T --> die
640
641 mov %eax, %ebx
642 mov %edi, %ebx
643 mov %ebp, %edx
644 shr %ebx, 12
645 and %ebx, 0xffff
646 shr %edi, 22
647 and %ebp, 0xffffff
648 and %edi, 0x3f
649
650 # now:
651 # %eax = addr
652 # %ebx = page_index
653 # %ebp = VSID
654 # %edi = api
655
656 xor %ebx, %ebp
657
658 # %ebx = hash1
659
660 push %eax
661 push %ebx # das brauch ich
662
663 and %ebx, [gCPU(pagetable_hashmask)]
664 shl %ebx, 6
665 or %ebx, [gCPU(pagetable_base)]
666
667 # %ebx = pteg_addr
668
669 pg_table_lookup(0, 8, data, 0)
670 pg_table_lookup(0, 8, data, 8)
671 pg_table_lookup(0, 8, data, 16)
672 pg_table_lookup(0, 8, data, 24)
673 pg_table_lookup(0, 8, data, 32)
674 pg_table_lookup(0, 8, data, 40)
675 pg_table_lookup(0, 8, data, 48)
676 pg_table_lookup(0, 8, data, 56)
677
678 # hash function number 2
679 mov %ebx, [%esp]
680 add %esp, 4
681 not %ebx
682 and %ebx, [gCPU(pagetable_hashmask)]
683 shl %ebx, 6
684 or %ebx, [gCPU(pagetable_base)]
685
686 pg_table_lookup(1<<6, 8, data, 0)
687 pg_table_lookup(1<<6, 8, data, 8)
688 pg_table_lookup(1<<6, 8, data, 16)
689 pg_table_lookup(1<<6, 8, data, 24)
690 pg_table_lookup(1<<6, 8, data, 32)
691 pg_table_lookup(1<<6, 8, data, 40)
692 pg_table_lookup(1<<6, 8, data, 48)
693 pg_table_lookup(1<<6, 8, data, 56)
694
695 # page lookup failed --> throw exception
696
697 pop %eax
698 pop %edx # return address is no longer needed
699 pop %ebx # bytes to roll back
700 add %esp, %ebx
701
702 mov %ecx, (1<<30)|(1<<25) # PPC_EXC_DSISR_PAGE | PPC_EXC_DSISR_STORE
703 jmp EXTERN(ppc_dsi_exception_asm)
704
705 .balign 16
706 ##############################################################################################
707 ## uint32 FASTCALL ppc_effective_write_byte()
708 ##
709 ## IN %eax: address to translate
710 ## %esi: current client pc offset
711 ## %dl: byte to be written
712 ##
713 ## WILL NOT RETURN ON EXCEPTION!
714 ##
715 EXPORT(ppc_write_effective_byte_asm):
716 mov [gCPU(pc_ofs)], %esi
717
718 push %edx
719 push 8 # roll back 8 bytes in case of exception
720 call ppc_effective_to_physical_data_write
721 cmp %eax, [EXTERN(gMemorySize)]
722 pop %edx
723 jae 1f
724 add %eax, [EXTERN(gMemory)]
725 mov [%eax], %dl
726 ret
727 1:
728 mov %ecx, 1
729 movzx %edx, %dl
730 jmp EXTERN(io_mem_write_glue)
731
732 .balign 16
733 ##############################################################################################
734 ## uint32 FASTCALL ppc_effective_write_half()
735 ##
736 ## IN %eax: address to translate
737 ## %dx: half to be written
738 ## %esi: current client pc offset
739 ##
740 ## WILL NOT RETURN ON EXCEPTION!
741 ##
742 EXPORT(ppc_write_effective_half_asm):
743 mov [gCPU(pc_ofs)], %esi
744 mov %ebx, %eax
745 and %ebx, 0xfff
746 cmp %ebx, 4095
747 jae 1f
748
749 push %edx
750 push 8 # roll back 8 bytes in case of exception
751 call ppc_effective_to_physical_data_write
752 cmp %eax, [EXTERN(gMemorySize)]
753 pop %edx
754 jae 2f
755 add %eax, [EXTERN(gMemory)]
756 mov [%eax], %dh
757 mov [%eax+1], %dl
758 ret
759 2:
760 xchg %dh, %dl
761 mov %ecx, 2
762 movzx %edx, %dx
763 jmp EXTERN(io_mem_write_glue)
764
765 1:
766 push %edx
767 push %eax
768 push 12 # roll back 12 bytes in case of exception
769 call ppc_effective_to_physical_data_write
770 mov %ebx, %eax
771 pop %eax
772 push %ebx
773 inc %eax
774 push 12 # roll back 12 bytes in case of exception
775 call ppc_effective_to_physical_data_write
776 pop %ebx
777 pop %edx
778 cmp %ebx, [EXTERN(gMemorySize)]
779 jae 1f
780 add %ebx, [EXTERN(gMemory)]
781 mov [%ebx], %dh
782 3:
783 cmp %eax, [EXTERN(gMemorySize)]
784 jae 2f
785 add %eax, [EXTERN(gMemory)]
786 mov [%eax], %dl
787 ret
788
789 1:
790 push %eax
791 push %edx
792 movzx %edx, %dh
793 mov %eax, %ebx
794 mov %ecx, 1
795 call EXTERN(io_mem_write_glue)
796 pop %edx
797 pop %eax
798 jmp 3b
799 2:
800 movzx %edx, %dl
801 mov %ecx, 1
802 jmp EXTERN(io_mem_write_glue)
803
804 .balign 16
805 ##############################################################################################
806 ## uint32 FASTCALL ppc_effective_write_word()
807 ##
808 ## IN %eax: address to translate
809 ## %edx: word to be written
810 ## %esi: current client pc offset
811 ##
812 ## WILL NOT RETURN ON EXCEPTION!
813 ##
814 EXPORT(ppc_write_effective_word_asm):
815 mov [gCPU(pc_ofs)], %esi
816 mov %ebx, %eax
817 and %ebx, 0xfff
818 cmp %ebx, 4093
819 jae 1f
820
821 bswap %edx
822
823 push %edx
824 push 8 # roll back 8 bytes in case of exception
825 call ppc_effective_to_physical_data_write
826 cmp %eax, [EXTERN(gMemorySize)]
827 pop %edx
828 jae 2f
829 add %eax, [EXTERN(gMemory)]
830 mov [%eax], %edx
831 ret
832
833 2:
834 mov %ecx, 4
835 jmp EXTERN(io_mem_write_glue)
836
837 1:
838 push %edx
839 push %eax
840 push 12 # roll back 12 bytes in case of exception
841 call ppc_effective_to_physical_data_write
842 mov %ebx, %eax
843 pop %eax
844 add %eax, 4
845 push %ebx
846 push 12 # roll back 12 bytes in case of exception
847 call ppc_effective_to_physical_data_write
848 pop %ebx
849 pop %edx
850 mov %ebp, %ebx
851 and %ebp, 0xfff
852 neg %ebp
853 add %ebp, 4096
854 cmp %ebx, [EXTERN(gMemorySize)]
855 jae 2f
856 add %ebx, [EXTERN(gMemory)]
857 1:
858 rol %edx, 8
859 mov [%ebx], %dl
860 inc %ebx
861 dec %ebp
862 jnz 1b
863 4:
864 mov %ebp, %eax
865 and %eax, 0xfffff000
866 and %ebp, 0x00000fff
867 cmp %eax, [EXTERN(gMemorySize)]
868 jae 3f
869 add %eax, [EXTERN(gMemory)]
870 1:
871 rol %edx, 8
872 mov [%eax], %dl
873 inc %eax
874 dec %ebp
875 jnz 1b
876 ret
877
878 2:
879 push %eax
880 1:
881 rol %edx, 8
882 push %ebp
883 #push %ebx
884 push %edx
885 movzx %edx, %dl
886 mov %eax, %ebx
887 mov %ecx, 1
888 call EXTERN(io_mem_write_glue)
889 pop %edx
890 pop %ebp
891 inc %ebx
892 dec %ebp
893 jnz 1b
894 pop %eax
895 jmp 4b
896 3:
897 1:
898 rol %edx, 8
899 push %ebp
900 push %eax
901 push %edx
902 movzx %edx, %dl
903 mov %ecx, 1
904 call EXTERN(io_mem_write_glue)
905 pop %edx
906 pop %eax
907 pop %ebp
908 inc %eax
909 dec %ebp
910 jnz 1b
911 ret
912 .balign 16
913 ##############################################################################################
914 ## uint32 FASTCALL ppc_effective_write_dword()
915 ##
916 ## IN %eax: address to translate
917 ## %ecx:%edx dword to be written
918 ## %esi: current client pc offset
919 ##
920 ## WILL NOT RETURN ON EXCEPTION!
921 ##
922 EXPORT(ppc_write_effective_dword_asm):
923 mov [gCPU(pc_ofs)], %esi
924 mov %ebx, %eax
925 and %ebx, 0xfff
926 cmp %ebx, 4089
927 jae 2f # overlap
928
929 bswap %ecx
930 bswap %edx
931
932 push %ecx
933 push %edx
934 push 12 # roll back 12 bytes in case of exception
935 call ppc_effective_to_physical_data_write
936 cmp %eax, [EXTERN(gMemorySize)]
937 pop %edx
938 pop %ecx
939 jae 1f
940 add %eax, [EXTERN(gMemory)]
941 mov [%eax], %ecx
942 mov [%eax+4], %edx
943 ret
944 1:
945 mov %ebx, %ecx
946 mov %ecx, %edx
947 mov %edx, %ebx
948 jmp EXTERN(io_mem_write64_glue)
949
950 2:
951 push %ecx
952 push %edx
953 push %eax
954 push 16 # roll back 16 bytes in case of exception
955 call ppc_effective_to_physical_data_write
956 mov %ebx, %eax
957 pop %eax
958 add %eax, 8
959 push %ebx
960 push 16 # roll back 16 bytes in case of exception
961 call ppc_effective_to_physical_data_write
962 pop %ebx
963 pop %edx
964 pop %ecx
965 mov %ebp, %ebx
966 and %ebp, 0xfff
967 neg %ebp
968 add %ebp, 4096
969 bswap %ecx
970 bswap %edx
971 cmp %ebx, [EXTERN(gMemorySize)]
972 jae 3f
973 add %ebx, [EXTERN(gMemory)]
974 1:
975 mov [%ebx], %cl
976 shrd %ecx, %edx, 8
977 inc %ebx
978 shr %edx, 8
979 dec %ebp
980 jnz 1b
981 4:
982 mov %ebp, %eax
983 and %eax, 0xfffff000
984 and %ebp, 0x00000fff
985 cmp %eax, [EXTERN(gMemorySize)]
986 jae 5f
987 add %eax, [EXTERN(gMemory)]
988 1:
989 mov [%eax], %cl
990 shrd %ecx, %edx, 8
991 inc %eax
992 shr %edx, 8
993 dec %ebp
994 jnz 1b
995 ret
996 3:
997 1:
998 pusha
999 movzx %edx, %cl
1000 mov %eax, %ebx
1001 mov %ecx, 1
1002 call EXTERN(io_mem_write_glue)
1003 popa
1004 shrd %ecx, %edx, 8
1005 inc %ebx
1006 shr %edx, 8
1007 dec %ebp
1008 jnz 1b
1009 jmp 4b
1010 5:
1011 1:
1012 pusha
1013 movzx %edx, %cl
1014 mov %ecx, 1
1015 call EXTERN(io_mem_write_glue)
1016 popa
1017 shrd %ecx, %edx, 8
1018 inc %eax
1019 shr %edx, 8
1020 dec %ebp
1021 jnz 1b
1022 ret
1023 .balign 16
1024 ##############################################################################################
1025 ## uint32 FASTCALL ppc_effective_write_qword()
1026 ##
1027 ## IN %eax: address to translate
1028 ## %edx: address from which to get the values to be written
1029 ## %esi: current client pc offset
1030 ##
1031 ## WILL NOT RETURN ON EXCEPTION!
1032 ##
1033 EXPORT(ppc_write_effective_qword_asm):
1034 mov [gCPU(pc_ofs)], %esi
1035 and %eax, 0xfffffff0
1036 push %edx
1037
1038 push 8 # roll back 8 bytes in case of exception
1039 call ppc_effective_to_physical_data_write
1040
1041 cmp %eax, [EXTERN(gMemorySize)]
1042 pop %edx
1043 jae 1f
1044
1045 add %eax, [EXTERN(gMemory)]
1046
1047 mov %ebx, [%edx]
1048 mov %ecx, [%edx+4]
1049 mov %edi, [%edx+8]
1050 mov %esi, [%edx+12]
1051
1052 bswap %ebx
1053 bswap %ecx
1054 bswap %edi
1055 bswap %esi
1056
1057 mov [%eax+12], %ebx
1058 mov [%eax+8], %ecx
1059 mov [%eax+4], %edi
1060 mov [%eax], %esi
1061 ret
1062 1:
1063 call EXTERN(io_mem_write128_glue)
1064 ret
1065
1066 ppc_write_effective_qword_sse_asm:
1067 mov [gCPU(pc_ofs)], %esi
1068 and %eax, 0xfffffff0
1069 push %edx
1070
1071 push 8 # roll back 8 bytes in case of exception
1072 call ppc_effective_to_physical_data_write
1073
1074 cmp %eax, [EXTERN(gMemorySize)]
1075 pop %edx
1076 jae 1f
1077
1078 add %eax, [EXTERN(gMemory)]
1079
1080 movaps [%eax], %xmm0
1081 ret
1082 1:
1083 movaps [%edx], %xmm0
1084 call EXTERN(io_mem_write128_native_glue)
1085 ret
1086 .balign 16
1087 ##############################################################################################
1088 ## uint32 FASTCALL ppc_read_effective_byte()
1089 ##
1090 ## IN %eax: address to translate
1091 ## %esi: current client pc offset
1092 ##
1093 ## OUT %edx: byte, zero extended
1094 ##
1095 ## WILL NOT RETURN ON EXCEPTION!
1096 ##
1097 EXPORT(ppc_read_effective_byte_asm):
1098 mov [gCPU(pc_ofs)], %esi
1099
1100 push 4 # roll back 4 bytes in case of exception
1101 call ppc_effective_to_physical_data_read
1102 cmp %eax, [EXTERN(gMemorySize)]
1103 jae 1f
1104 add %eax, [EXTERN(gMemory)]
1105 movzx %edx, byte ptr [%eax]
1106 ret
1107 1:
1108 mov %edx, 1
1109 call EXTERN(io_mem_read_glue)
1110 movzx %edx, %al
1111 ret
1112
1113 .balign 16
1114 ##############################################################################################
1115 ## uint32 FASTCALL ppc_read_effective_half()
1116 ##
1117 ## IN %eax: address to translate
1118 ## %esi: current client pc offset
1119 ##
1120 ## OUT %edx: half, zero extended
1121 ##
1122 ## WILL NOT RETURN ON EXCEPTION!
1123 ##
1124 EXPORT(ppc_read_effective_half_z_asm):
1125 mov [gCPU(pc_ofs)], %esi
1126 mov %ebx, %eax
1127 and %ebx, 0xfff
1128 cmp %ebx, 4095
1129 jae 1f
1130
1131 push 4 # roll back 4 bytes in case of exception
1132 call ppc_effective_to_physical_data_read
1133 cmp %eax, [EXTERN(gMemorySize)]
1134 jae 2f
1135 add %eax, [EXTERN(gMemory)]
1136 movzx %edx, word ptr [%eax]
1137 xchg %dl, %dh
1138 ret
1139 2:
1140 mov %edx, 2
1141 call EXTERN(io_mem_read_glue)
1142 xchg %al, %ah
1143 movzx %edx, %ax
1144 ret
1145
1146 1:
1147 push %eax
1148 push 8 # roll back 8 bytes in case of exception
1149 call ppc_effective_to_physical_data_read
1150 xor %edx, %edx
1151 cmp %eax, [EXTERN(gMemorySize)]
1152 jae 2f
1153 add %eax, [EXTERN(gMemory)]
1154 mov %dh, [%eax]
1155 1:
1156 pop %eax
1157 push %edx
1158 inc %eax
1159 push 8 # roll back 8 bytes in case of exception
1160 call ppc_effective_to_physical_data_read
1161 pop %edx
1162 cmp %eax, [EXTERN(gMemorySize)]
1163 jae 3f
1164 add %eax, [EXTERN(gMemory)]
1165 mov %dl, [%eax]
1166 ret
1167
1168 2:
1169 pusha
1170 mov %edx, 1
1171 call EXTERN(io_mem_read_glue)
1172 mov [gCPU(temp2)], %al
1173 popa
1174 mov %dh, [gCPU(temp2)]
1175 jmp 1b
1176 3:
1177 push %edx
1178 mov %edx, 1
1179 call EXTERN(io_mem_read_glue)
1180 pop %edx
1181 mov %dl, %al
1182 ret
1183 .balign 16
1184 ##############################################################################################
1185 ## uint32 FASTCALL ppc_read_effective_half()
1186 ##
1187 ## IN %eax: address to translate
1188 ## %esi: current client pc offset
1189 ##
1190 ## OUT %edx: half, sign extended
1191 ##
1192 ## WILL NOT RETURN ON EXCEPTION!
1193 ##
1194 EXPORT(ppc_read_effective_half_s_asm):
1195 mov [gCPU(pc_ofs)], %esi
1196 mov %ebx, %eax
1197 and %ebx, 0xfff
1198 cmp %ebx, 4095
1199 jae 1f
1200
1201 push 4 # roll back 4 bytes in case of exception
1202 call ppc_effective_to_physical_data_read
1203 cmp %eax, [EXTERN(gMemorySize)]
1204 jae 2f
1205 add %eax, [EXTERN(gMemory)]
1206 mov %cx, [%eax]
1207 xchg %ch, %cl
1208 movsx %edx, %cx
1209 ret
1210 2:
1211 mov %edx, 2
1212 call EXTERN(io_mem_read_glue)
1213 xchg %ah, %al
1214 movsx %edx, %ax
1215 ret
1216
1217 1:
1218 push %eax
1219 push 8 # roll back 8 bytes in case of exception
1220 call ppc_effective_to_physical_data_read
1221 cmp %eax, [EXTERN(gMemorySize)]
1222 jae 2f
1223 add %eax, [EXTERN(gMemory)]
1224 mov %ch, [%eax]
1225 1:
1226 pop %eax
1227 push %ecx
1228 inc %eax
1229 push 8 # roll back 8 bytes in case of exception
1230 call ppc_effective_to_physical_data_read
1231 pop %ecx
1232 cmp %eax, [EXTERN(gMemorySize)]
1233 jae 3f
1234 add %eax, [EXTERN(gMemory)]
1235 mov %cl, [%eax]
1236 movsx %edx, %cx
1237 ret
1238
1239 2:
1240 pusha
1241 mov %edx, 1
1242 call EXTERN(io_mem_read_glue)
1243 mov [gCPU(temp2)], %al
1244 popa
1245 mov %ch, [gCPU(temp2)]
1246 jmp 1b
1247 3:
1248 push %ecx
1249 mov %edx, 1
1250 call EXTERN(io_mem_read_glue)
1251 pop %ecx
1252 mov %cl, %al
1253 movsx %edx, %cx
1254 ret
1255
1256 .balign 16
1257 ##############################################################################################
1258 ## uint32 FASTCALL ppc_read_effective_word()
1259 ##
1260 ## IN %eax: address to translate
1261 ## %esi: current client pc offset
1262 ##
1263 ## OUT %edx: word
1264 ##
1265 ## WILL NOT RETURN ON EXCEPTION!
1266 ##
1267 EXPORT(ppc_read_effective_word_asm):
1268 mov [gCPU(pc_ofs)], %esi
1269 mov %ebx, %eax
1270 and %ebx, 0xfff
1271 cmp %ebx, 4093
1272 jae 1f
1273
1274 push 4 # roll back 4 bytes in case of exception
1275 call ppc_effective_to_physical_data_read
1276 cmp %eax, [EXTERN(gMemorySize)]
1277 jae 2f
1278 add %eax, [EXTERN(gMemory)]
1279 mov %edx, [%eax]
1280 bswap %edx
1281 ret
1282 2:
1283 mov %edx, 4
1284 call EXTERN(io_mem_read_glue)
1285 mov %edx, %eax
1286 bswap %edx
1287 ret
1288 1:
1289 push %eax
1290 push %ebx
1291 push 12 # roll back 12 bytes in case of exception
1292 call ppc_effective_to_physical_data_read
1293 pop %ebx
1294 mov %ecx, 4096
1295 sub %ecx, %ebx
1296 cmp %eax, [EXTERN(gMemorySize)]
1297 jae 2f
1298 add %eax, [EXTERN(gMemory)]
1299 1:
1300 shl %edx, 8
1301 mov %dl, [%eax]
1302 inc %eax
1303 dec %ecx
1304 jnz 1b
1305 4:
1306 pop %eax
1307 push %edx
1308 add %eax, 4
1309 push %ebx
1310 and %eax, 0xfffff000
1311 push 12 # roll back 12 bytes in case of exception
1312 call ppc_effective_to_physical_data_read
1313 pop %ebx
1314 pop %edx
1315 sub %ebx, 4092
1316 cmp %eax, [EXTERN(gMemorySize)]
1317 jae 3f
1318 add %eax, [EXTERN(gMemory)]
1319 1:
1320 shl %edx, 8
1321 mov %dl, [%eax]
1322 inc %eax
1323 dec %ebx
1324 jnz 1b
1325 ret
1326
1327 2:
1328 1:
1329 shl %edx, 8
1330 pusha
1331 mov %edx, 1
1332 call EXTERN(io_mem_read_glue)
1333 mov [gCPU(temp2)], %al
1334 popa
1335 mov %dl, [gCPU(temp2)]
1336 inc %eax
1337 dec %ecx
1338 jnz 1b
1339 jmp 4b
1340 3:
1341 1:
1342 shl %edx, 8
1343 pusha
1344 mov %edx, 1
1345 call EXTERN(io_mem_read_glue)
1346 mov [gCPU(temp2)], %al
1347 popa
1348 mov %dl, [gCPU(temp2)]
1349 inc %eax
1350 dec %ebx
1351 jnz 1b
1352 ret
1353 .balign 16
1354 ##############################################################################################
1355 ## uint32 FASTCALL ppc_read_effective_dword()
1356 ##
1357 ## IN %eax: address to translate
1358 ## %esi: current client pc offset
1359 ##
1360 ## OUT %ecx:%edx dword
1361 ##
1362 ## WILL NOT RETURN ON EXCEPTION!
1363 ##
1364 EXPORT(ppc_read_effective_dword_asm):
1365 mov [gCPU(pc_ofs)], %esi
1366 mov %ebx, %eax
1367 and %ebx, 0xfff
1368 cmp %ebx, 4089
1369 jae 1f
1370
1371 push 4 # roll back 4 bytes in case of exception
1372 call ppc_effective_to_physical_data_read
1373 cmp %eax, [EXTERN(gMemorySize)]
1374 jae 2f
1375 add %eax, [EXTERN(gMemory)]
1376 mov %ecx, [%eax]
1377 mov %edx, [%eax+4]
1378 bswap %ecx
1379 bswap %edx
1380 ret
1381 2:
1382 call EXTERN(io_mem_read64_glue)
1383 mov %ecx, %eax
1384 mov %edx, %edx
1385 bswap %ecx
1386 bswap %edx
1387 ret
1388
1389 1:
1390 push %eax
1391 push %ebx
1392 push 12 # roll back 12 bytes in case of exception
1393 call ppc_effective_to_physical_data_read
1394 pop %ebx
1395 mov %ebp, 4096
1396 sub %ebp, %ebx
1397 cmp %eax, [EXTERN(gMemorySize)]
1398 jae 2f
1399 add %eax, [EXTERN(gMemory)]
1400 1:
1401 shld %ecx, %edx, 8
1402 shl %edx, 8
1403 mov %dl, [%eax]
1404 inc %eax
1405 dec %ebp
1406 jnz 1b
1407 4:
1408 pop %eax
1409 push %ecx
1410 push %edx
1411 add %eax, 8
1412 push %ebx
1413 and %eax, 0xfffff000
1414 push 16 # roll back 16 bytes in case of exception
1415 call ppc_effective_to_physical_data_read
1416 pop %ebx
1417 pop %edx
1418 pop %ecx
1419 sub %ebx, 4088
1420 cmp %eax, [EXTERN(gMemorySize)]
1421 jae 3f
1422 add %eax, [EXTERN(gMemory)]
1423 1:
1424 shld %ecx, %edx, 8
1425 shl %edx, 8
1426 mov %dl, [%eax]
1427 inc %eax
1428 dec %ebx
1429 jnz 1b
1430 ret
1431
1432 2:
1433 1:
1434 shld %ecx, %edx, 8
1435 shl %edx, 8
1436 pusha
1437 mov %edx, 1
1438 call EXTERN(io_mem_read_glue)
1439 mov [gCPU(temp2)], %al
1440 popa
1441 mov %dl, [gCPU(temp2)]
1442 inc %eax
1443 dec %ebp
1444 jnz 1b
1445 jmp 4b
1446 3:
1447 1:
1448 shld %ecx, %edx, 8
1449 shl %edx, 8
1450 pusha
1451 mov %edx, 1
1452 call EXTERN(io_mem_read_glue)
1453 mov [gCPU(temp2)], %al
1454 popa
1455 mov %dl, [gCPU(temp2)]
1456 inc %eax
1457 dec %ebx
1458 jnz 1b
1459 ret
1460 .balign 16
1461 ##############################################################################################
1462 ## uint32 FASTCALL ppc_read_effective_qword()
1463 ##
1464 ## IN %eax: address to translate
1465 ## %edx: address to store the qword
1466 ## %esi: current client pc offset
1467 ##
1468 ## WILL NOT RETURN ON EXCEPTION!
1469 ##
1470 EXPORT(ppc_read_effective_qword_asm):
1471 mov [gCPU(pc_ofs)], %esi
1472 and %eax, 0xfffffff0
1473 push %edx
1474
1475 push 8 # roll back 8 bytes in case of exception
1476 call ppc_effective_to_physical_data_read
1477
1478 cmp %eax, [EXTERN(gMemorySize)]
1479 pop %edx
1480 jae 1f
1481
1482 add %eax, [EXTERN(gMemory)]
1483
1484 mov %ebx, [%eax]
1485 mov %ecx, [%eax+4]
1486 mov %edi, [%eax+8]
1487 mov %esi, [%eax+12]
1488
1489 bswap %ebx
1490 bswap %ecx
1491 bswap %edi
1492 bswap %esi
1493
1494 mov [%edx+12], %ebx
1495 mov [%edx+8], %ecx
1496 mov [%edx+4], %edi
1497 mov [%edx], %esi
1498 ret
1499 1:
1500 call EXTERN(io_mem_read128_glue)
1501 ret
1502
1503 EXPORT(ppc_read_effective_qword_sse_asm):
1504 mov [gCPU(pc_ofs)], %esi
1505 and %eax, 0xfffffff0
1506 push %edx
1507
1508 push 8 # roll back 8 bytes in case of exception
1509 call ppc_effective_to_physical_data_read
1510
1511 cmp %eax, [EXTERN(gMemorySize)]
1512 pop %edx
1513 jae 1f
1514
1515 add %eax, [EXTERN(gMemory)]
1516
1517 movaps %xmm0, [%eax]
1518
1519 mov %ebx, [%eax]
1520 mov %ecx, [%eax+4]
1521 mov %edi, [%eax+8]
1522 mov %esi, [%eax+12]
1523
1524 bswap %ebx
1525 bswap %ecx
1526 bswap %edi
1527 bswap %esi
1528
1529 mov [%edx+12], %ebx
1530 mov [%edx+8], %ecx
1531 mov [%edx+4], %edi
1532 mov [%edx], %esi
1533 ret
1534
1535 1:
1536 push %edx
1537 call EXTERN(io_mem_read128_native_glue)
1538 pop %edx
1539
1540 movaps %xmm0, [%edx]
1541
1542 mov %eax, [%edx]
1543 mov %ebx, [%edx+4]
1544 mov %edi, [%edx+8]
1545 mov %esi, [%edx+12]
1546
1547 bswap %eax
1548 bswap %ebx
1549 bswap %edi
1550 bswap %esi
1551
1552 mov [%edx+12], %esi
1553 mov [%edx+8], %edi
1554 mov [%edx+4], %ebx
1555 mov [%edx], %eax
1556 ret
1557
1558 .balign 16
1559 ##############################################################################################
1560 ## uint32 FASTCALL ppc_opc_stswi_asm()
1561 ##
1562 ## IN %ecx: NB
1563 ## %ebx: source
1564 ## %eax: dest
1565 ## %esi: current client pc offset
1566 ##
1567 ## WILL NOT RETURN ON EXCEPTION!
1568 ##
1569 EXPORT(ppc_opc_stswi_asm):
1570 mov [gCPU(pc_ofs)], %esi
1571 mov %edi, 1
1572
1573 1:
1574 dec %edi
1575 jnz 2f
1576 mov %edx, [gCPU(gpr+4*%ebx)]
1577 inc %ebx
1578 mov %edi, 4
1579 and %ebx, 0x1f
1580 2:
1581 push %eax
1582 push %ecx
1583 push %ebx
1584 push %edi
1585 push %edx
1586 push 24 # roll back 24 bytes in case of exception
1587 call ppc_effective_to_physical_data_write
1588 cmp %eax, [EXTERN(gMemorySize)]
1589 pop %edx
1590 mov %ecx, %edx
1591 jae 3f
1592 shr %ecx, 24
1593 add %eax, [EXTERN(gMemory)]
1594 mov [%eax], %cl
1595 4:
1596 pop %edi
1597 pop %ebx
1598 pop %ecx
1599 pop %eax
1600 shl %edx, 8
1601 inc %eax
1602 dec %ecx
1603 jnz 1b
1604 ret
1605
1606 3:
1607 push %edx
1608 mov %ecx, 1
1609 shr %edx, 24
1610 call EXTERN(io_mem_write_glue)
1611 pop %edx
1612 jmp 4b
1613 .balign 16
1614 ##############################################################################################
1615 ## uint32 FASTCALL ppc_opc_lswi_asm()
1616 ##
1617 ## IN %ecx: NB
1618 ## %ebx: dest
1619 ## %eax: source
1620 ## %esi: current client pc offset
1621 ##
1622 ## WILL NOT RETURN ON EXCEPTION!
1623 ##
1624 EXPORT(ppc_opc_lswi_asm):
1625 mov [gCPU(pc_ofs)], %esi
1626 mov %edi, 4
1627 1:
1628 or %edi, %edi
1629 jnz 2f
1630 mov [gCPU(gpr+4*%ebx)], %edx
1631 inc %ebx
1632 mov %edi, 4
1633 and %ebx, 0x1f
1634 xor %edx, %edx
1635 2:
1636
1637 push %eax
1638 push %ecx
1639 push %ebx
1640 push %edi
1641 push %edx
1642 push 24 # roll back 24 bytes in case of exception
1643 call ppc_effective_to_physical_data_read
1644 pop %edx
1645 cmp %eax, [EXTERN(gMemorySize)]
1646 jae 3f
1647 add %eax, [EXTERN(gMemory)]
1648 shl %edx, 8
1649 mov %dl, byte ptr [%eax]
1650 4:
1651 pop %edi
1652 pop %ebx
1653 pop %ecx
1654 pop %eax
1655
1656 dec %edi
1657 inc %eax
1658 dec %ecx
1659 jnz 1b
1660
1661 or %edi, %edi
1662 jz 5f
1663 2:
1664 shl %edx, 8
1665 dec %edi
1666 jnz 2b
1667
1668 5:
1669 mov [gCPU(gpr)+4*%ebx], %edx
1670 ret
1671
1672 3:
1673 push %edx
1674 mov %edx, 1
1675 call EXTERN(io_mem_read_glue)
1676 pop %edx
1677 shl %edx, 8
1678 mov %dl, %al
1679 jmp 4b
1680
1681 .balign 16
1682 ##############################################################################################
1683 ## uint32 FASTCALL ppc_opc_icbi_asm()
1684 ##
1685 ## IN %eax: effective address
1686 EXPORT(ppc_opc_icbi_asm):
1687 mov [gCPU(pc_ofs)], %esi
1688 push 4 # roll back 4 bytes in case of exception
1689 add %eax, 1 # FIXME: WTF???
1690 call ppc_effective_to_physical_data_read
1691 cmp %eax, [EXTERN(gMemorySize)]
1692 mov %ebp, [gJITC(clientPages)]
1693 jae 1f
1694 shr %eax, 12
1695 cmp dword ptr [%ebp+%eax*4], 0
1696 jnz 2f
1697 1:
1698 ret
1699
1700 2:
1701 mov %eax, [%ebp+%eax*4]
1702 jmp EXTERN(jitcDestroyAndFreeClientPage)

Properties

Name Value
svn:executable *

  ViewVC Help
Powered by ViewVC 1.1.26