Macintosh-Tools/dingusppc
1
0
Fork 0
mirror of https://github.com/dingusdev/dingusppc.git synced 2024-06-25 23:29:33 +00:00
Code Issues Projects Releases Wiki Activity

SPRs now use symbolic names

Browse Source
This commit is contained in:
dingusdev 2020-01-27 20:39:23 -07:00
parent 2953eaa538
commit aa20d64b48
7 changed files with 199 additions and 192 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

92
cpu/ppc/poweropcodes.cpp
View File

@ -47,7 +47,7 @@ void power_abso() {
ppc_grab_regsda();
if (ppc_result_a == 0x80000000) {
ppc_result_d = ppc_result_a;
ppc_state.ppc_spr[1] |= 0x40000000;
ppc_state.ppc_spr[SPR::XER] |= 0x40000000;
}
else {
@ -60,7 +60,7 @@ void power_absodot() {
ppc_grab_regsda();
if (ppc_result_a == 0x80000000) {
ppc_result_d = ppc_result_a;
ppc_state.ppc_spr[1] |= 0x40000000;
ppc_state.ppc_spr[SPR::XER] |= 0x40000000;
}
else {
@ -103,46 +103,46 @@ void power_clcsdot() {
void power_div() {
ppc_grab_regsdab();
ppc_result_d = (ppc_result_a | ppc_state.ppc_spr[0]) / ppc_result_b;
ppc_state.ppc_spr[0] = (ppc_result_a | ppc_state.ppc_spr[0]) % ppc_result_b;
ppc_result_d = (ppc_result_a | ppc_state.ppc_spr[SPR::MQ]) / ppc_result_b;
ppc_state.ppc_spr[SPR::MQ] = (ppc_result_a | ppc_state.ppc_spr[SPR::MQ]) % ppc_result_b;
ppc_store_result_regd();
}
void power_divdot() {
ppc_result_d = (ppc_result_a | ppc_state.ppc_spr[0]) / ppc_result_b;
ppc_state.ppc_spr[0] = (ppc_result_a | ppc_state.ppc_spr[0]) % ppc_result_b;
ppc_result_d = (ppc_result_a | ppc_state.ppc_spr[SPR::MQ]) / ppc_result_b;
ppc_state.ppc_spr[SPR::MQ] = (ppc_result_a | ppc_state.ppc_spr[SPR::MQ]) % ppc_result_b;
}
void power_divo() {
ppc_result_d = (ppc_result_a | ppc_state.ppc_spr[0]) / ppc_result_b;
ppc_state.ppc_spr[0] = (ppc_result_a | ppc_state.ppc_spr[0]) % ppc_result_b;
ppc_result_d = (ppc_result_a | ppc_state.ppc_spr[SPR::MQ]) / ppc_result_b;
ppc_state.ppc_spr[SPR::MQ] = (ppc_result_a | ppc_state.ppc_spr[SPR::MQ]) % ppc_result_b;
}
void power_divodot() {
ppc_result_d = (ppc_result_a | ppc_state.ppc_spr[0]) / ppc_result_b;
ppc_state.ppc_spr[0] = (ppc_result_a | ppc_state.ppc_spr[0]) % ppc_result_b;
ppc_result_d = (ppc_result_a | ppc_state.ppc_spr[SPR::MQ]) / ppc_result_b;
ppc_state.ppc_spr[SPR::MQ] = (ppc_result_a | ppc_state.ppc_spr[SPR::MQ]) % ppc_result_b;
}
void power_divs() {
ppc_grab_regsdab();
ppc_result_d = ppc_result_a / ppc_result_b;
ppc_state.ppc_spr[0] = (ppc_result_a % ppc_result_b);
ppc_state.ppc_spr[SPR::MQ] = (ppc_result_a % ppc_result_b);
ppc_store_result_regd();
}
void power_divsdot() {
ppc_result_d = ppc_result_a / ppc_result_b;
ppc_state.ppc_spr[0] = (ppc_result_a % ppc_result_b);
ppc_state.ppc_spr[SPR::MQ] = (ppc_result_a % ppc_result_b);
}
void power_divso() {
ppc_result_d = ppc_result_a / ppc_result_b;
ppc_state.ppc_spr[0] = (ppc_result_a % ppc_result_b);
ppc_state.ppc_spr[SPR::MQ] = (ppc_result_a % ppc_result_b);
}
void power_divsodot() {
ppc_result_d = ppc_result_a / ppc_result_b;
ppc_state.ppc_spr[0] = (ppc_result_a % ppc_result_b);
ppc_state.ppc_spr[SPR::MQ] = (ppc_result_a % ppc_result_b);
}
void power_doz() {
@ -203,11 +203,11 @@ void power_lscbx() {
bool match_found = false;
uint32_t shift_amount = 0;
uint8_t return_value;
uint8_t byte_compared = (uint8_t)((ppc_state.ppc_spr[1] & 0xFF00) >> 8);
if ((ppc_state.ppc_spr[1] & 0x7f) == 0) {
uint8_t byte_compared = (uint8_t)((ppc_state.ppc_spr[SPR::XER] & 0xFF00) >> 8);
if ((ppc_state.ppc_spr[SPR::XER] & 0x7f) == 0) {
return;
}
uint32_t bytes_to_load = (ppc_state.ppc_spr[1] & 0x7f) + 1;
uint32_t bytes_to_load = (ppc_state.ppc_spr[SPR::XER] & 0x7f) + 1;
ppc_effective_address = (reg_a == 0) ? ppc_result_b : ppc_result_a + ppc_result_b;
do {
ppc_effective_address++;
@ -250,7 +250,7 @@ void power_lscbx() {
shift_amount++;
}
} while (bytes_to_load > 0);
ppc_state.ppc_spr[1] = (ppc_state.ppc_spr[1] & 0xFFFFFF80) | bytes_copied;
ppc_state.ppc_spr[SPR::XER] = (ppc_state.ppc_spr[SPR::XER] & 0xFFFFFF80) | bytes_copied;
ppc_store_result_regd();
}
@ -347,7 +347,7 @@ void power_mul() {
product = ((uint64_t)ppc_result_a) * ((uint64_t)ppc_result_b);
ppc_result_d = ((uint32_t)(product >> 32));
ppc_state.ppc_spr[0] = ((uint32_t)(product));
ppc_state.ppc_spr[SPR::MQ] = ((uint32_t)(product));
ppc_store_result_regd();
}
@ -358,7 +358,7 @@ void power_muldot() {
product = ((uint64_t)ppc_result_a) * ((uint64_t)ppc_result_b);
ppc_result_d = ((uint32_t)(product >> 32));
ppc_state.ppc_spr[0] = ((uint32_t)(product));
ppc_state.ppc_spr[SPR::MQ] = ((uint32_t)(product));
ppc_changecrf0(ppc_result_d);
ppc_store_result_regd();
@ -369,7 +369,7 @@ void power_mulo() {
product = ((uint64_t)ppc_result_a) * ((uint64_t)ppc_result_b);
ppc_result_d = ((uint32_t)(product >> 32));
ppc_state.ppc_spr[0] = ((uint32_t)(product));
ppc_state.ppc_spr[SPR::MQ] = ((uint32_t)(product));
}
@ -378,7 +378,7 @@ void power_mulodot() {
product = ((uint64_t)ppc_result_a) * ((uint64_t)ppc_result_b);
ppc_result_d = ((uint32_t)(product >> 32));
ppc_state.ppc_spr[0] = ((uint32_t)(product));
ppc_state.ppc_spr[SPR::MQ] = ((uint32_t)(product));
}
@ -458,7 +458,7 @@ void power_sle() {
insert_mask |= (1 << i);
}
uint32_t insert_final = ((ppc_result_d << rot_amt) | (ppc_result_d >> (32 - rot_amt)));
ppc_state.ppc_spr[0] = insert_final & insert_mask;
ppc_state.ppc_spr[SPR::MQ] = insert_final & insert_mask;
ppc_result_a = insert_final & insert_mask;
ppc_store_result_rega();
}
@ -471,7 +471,7 @@ void power_sledot() {
insert_mask |= (1 << i);
}
uint32_t insert_final = ((ppc_result_d << rot_amt) | (ppc_result_d >> (32 - rot_amt)));
ppc_state.ppc_spr[0] = insert_final & insert_mask;
ppc_state.ppc_spr[SPR::MQ] = insert_final & insert_mask;
ppc_result_a = insert_final & insert_mask;
ppc_changecrf0(ppc_result_a);
ppc_store_result_rega();
@ -485,7 +485,7 @@ void power_sleq() {
insert_mask |= (1 << i);
}
uint32_t insert_start = ((ppc_result_d << rot_amt) | (ppc_result_d >> (rot_amt - 31)));
uint32_t insert_end = ppc_state.ppc_spr[0];
uint32_t insert_end = ppc_state.ppc_spr[SPR::MQ];
for (int i = 0; i < 32; i++) {
if (insert_mask & (1 << i)) {
@ -495,7 +495,7 @@ void power_sleq() {
}
ppc_result_a = insert_end;
ppc_state.ppc_spr[0] = insert_start;
ppc_state.ppc_spr[SPR::MQ] = insert_start;
ppc_store_result_rega();
}
@ -507,7 +507,7 @@ void power_sleqdot() {
insert_mask |= (1 << i);
}
uint32_t insert_start = ((ppc_result_d << rot_amt) | (ppc_result_d >> (rot_amt - 31)));
uint32_t insert_end = ppc_state.ppc_spr[0];
uint32_t insert_end = ppc_state.ppc_spr[SPR::MQ];
for (int i = 0; i < 32; i++) {
if (insert_mask & (1 << i)) {
@ -517,7 +517,7 @@ void power_sleqdot() {
}
ppc_result_a = insert_end;
ppc_state.ppc_spr[0] = insert_start;
ppc_state.ppc_spr[SPR::MQ] = insert_start;
ppc_changecrf0(ppc_result_a);
ppc_store_result_rega();
}
@ -530,7 +530,7 @@ void power_sliq() {
insert_mask |= (1 << i);
}
uint32_t insert_start = ((ppc_result_d << rot_sh) | (ppc_result_d >> (rot_sh - 31)));
uint32_t insert_end = ppc_state.ppc_spr[0];
uint32_t insert_end = ppc_state.ppc_spr[SPR::MQ];
for (int i = 0; i < 32; i++) {
if (insert_mask & (1 << i)) {
@ -540,7 +540,7 @@ void power_sliq() {
}
ppc_result_a = insert_end & insert_mask;
ppc_state.ppc_spr[0] = insert_start;
ppc_state.ppc_spr[SPR::MQ] = insert_start;
ppc_store_result_rega();
}
@ -552,7 +552,7 @@ void power_sliqdot() {
insert_mask |= (1 << i);
}
uint32_t insert_start = ((ppc_result_d << rot_sh) | (ppc_result_d >> (rot_sh - 31)));
uint32_t insert_end = ppc_state.ppc_spr[0];
uint32_t insert_end = ppc_state.ppc_spr[SPR::MQ];
for (int i = 0; i < 32; i++) {
if (insert_mask & (1 << i)) {
@ -562,7 +562,7 @@ void power_sliqdot() {
}
ppc_result_a = insert_end & insert_mask;
ppc_state.ppc_spr[0] = insert_start;
ppc_state.ppc_spr[SPR::MQ] = insert_start;
ppc_changecrf0(ppc_result_a);
ppc_store_result_rega();
}
@ -575,7 +575,7 @@ void power_slliq() {
insert_mask |= (1 << i);
}
uint32_t insert_start = ((ppc_result_d << rot_sh) | (ppc_result_d >> (32 - rot_sh)));
uint32_t insert_end = ppc_state.ppc_spr[0];
uint32_t insert_end = ppc_state.ppc_spr[SPR::MQ];
for (int i = 0; i < 32; i++) {
if (insert_mask & (1 << i)) {
@ -585,7 +585,7 @@ void power_slliq() {
}
ppc_result_a = insert_end;
ppc_state.ppc_spr[0] = insert_start;
ppc_state.ppc_spr[SPR::MQ] = insert_start;
ppc_store_result_rega();
}
@ -597,7 +597,7 @@ void power_slliqdot() {
insert_mask |= (1 << i);
}
uint32_t insert_start = ((ppc_result_d << rot_sh) | (ppc_result_d >> (32 - rot_sh)));
uint32_t insert_end = ppc_state.ppc_spr[0];
uint32_t insert_end = ppc_state.ppc_spr[SPR::MQ];
for (int i = 0; i < 32; i++) {
if (insert_mask & (1 << i)) {
@ -607,7 +607,7 @@ void power_slliqdot() {
}
ppc_result_a = insert_end;
ppc_state.ppc_spr[0] = insert_start;
ppc_state.ppc_spr[SPR::MQ] = insert_start;
ppc_changecrf0(ppc_result_a);
ppc_store_result_rega();
}
@ -652,7 +652,7 @@ void power_sre() {
insert_mask |= (1 << i);
}
uint32_t insert_final = ((ppc_result_d >> rot_amt) | (ppc_result_d << (32 - rot_amt)));
ppc_state.ppc_spr[0] = insert_final & insert_mask;
ppc_state.ppc_spr[SPR::MQ] = insert_final & insert_mask;
ppc_result_a = insert_final;
ppc_store_result_rega();
}
@ -665,7 +665,7 @@ void power_sredot() {
insert_mask |= (1 << i);
}
uint32_t insert_final = ((ppc_result_d >> rot_amt) | (ppc_result_d << (32 - rot_amt)));
ppc_state.ppc_spr[0] = insert_final & insert_mask;
ppc_state.ppc_spr[SPR::MQ] = insert_final & insert_mask;
ppc_result_a = insert_final;
ppc_changecrf0(ppc_result_a);
ppc_store_result_rega();
@ -687,7 +687,7 @@ void power_sreq() {
insert_mask |= (1 << i);
}
uint32_t insert_start = ((ppc_result_d >> rot_sh) | (ppc_result_d << (32 - rot_sh)));
uint32_t insert_end = ppc_state.ppc_spr[0];
uint32_t insert_end = ppc_state.ppc_spr[SPR::MQ];
for (int i = 0; i < 32; i++) {
if (insert_mask & (1 << i)) {
@ -697,7 +697,7 @@ void power_sreq() {
}
ppc_result_a = insert_end;
ppc_state.ppc_spr[0] = insert_start;
ppc_state.ppc_spr[SPR::MQ] = insert_start;
ppc_store_result_rega();
}
@ -709,7 +709,7 @@ void power_sreqdot() {
insert_mask |= (1 << i);
}
uint32_t insert_start = ((ppc_result_d >> rot_sh) | (ppc_result_d << (32 - rot_sh)));
uint32_t insert_end = ppc_state.ppc_spr[0];
uint32_t insert_end = ppc_state.ppc_spr[SPR::MQ];
for (int i = 0; i < 32; i++) {
if (insert_mask & (1 << i)) {
@ -719,7 +719,7 @@ void power_sreqdot() {
}
ppc_result_a = insert_end;
ppc_state.ppc_spr[0] = insert_start;
ppc_state.ppc_spr[SPR::MQ] = insert_start;
ppc_changecrf0(ppc_result_a);
ppc_store_result_rega();
}
@ -732,7 +732,7 @@ void power_sriq() {
insert_mask |= (1 << i);
}
uint32_t insert_start = ((ppc_result_d >> rot_sh) | (ppc_result_d << (32 - rot_sh)));
uint32_t insert_end = ppc_state.ppc_spr[0];
uint32_t insert_end = ppc_state.ppc_spr[SPR::MQ];
for (int i = 0; i < 32; i++) {
if (insert_mask & (1 << i)) {
@ -742,7 +742,7 @@ void power_sriq() {
}
ppc_result_a = insert_end;
ppc_state.ppc_spr[0] = insert_start;
ppc_state.ppc_spr[SPR::MQ] = insert_start;
ppc_store_result_rega();
}
@ -754,7 +754,7 @@ void power_sriqdot() {
insert_mask |= (1 << i);
}
uint32_t insert_start = ((ppc_result_d >> rot_sh) | (ppc_result_d << (32 - rot_sh)));
uint32_t insert_end = ppc_state.ppc_spr[0];
uint32_t insert_end = ppc_state.ppc_spr[SPR::MQ];
for (int i = 0; i < 32; i++) {
if (insert_mask & (1 << i)) {
@ -764,7 +764,7 @@ void power_sriqdot() {
}
ppc_result_a = insert_end;
ppc_state.ppc_spr[0] = insert_start;
ppc_state.ppc_spr[SPR::MQ] = insert_start;
ppc_changecrf0(ppc_result_a);
ppc_store_result_rega();
}

7
cpu/ppc/ppcemu.h
View File

@ -65,6 +65,7 @@ extern SetPRS ppc_state;
/** symbolic names for frequently used SPRs */
enum SPR : int {
MQ = 0,
XER = 1,
LR = 8,
CTR = 9,
@ -77,6 +78,12 @@ enum SPR : int {
PVR = 287
};
/** symbolic names for frequently used SPRs */
enum TBR : int {
TBL = 0,
TBU = 1
};
/** symbolic names for common PPC processors */
enum PPC_VER : uint32_t {
MPC601 = 0x00010001,

24
cpu/ppc/ppcexceptions.cpp
View File

@ -16,7 +16,7 @@ jmp_buf exc_env; /* Global exception environment. */
switch(exception_type) {
case Except_Type::EXC_SYSTEM_RESET:
ppc_state.ppc_spr[26] = ppc_cur_instruction & 0xFFFFFFFC;
ppc_state.ppc_spr[SPR::SRR0] = ppc_cur_instruction & 0xFFFFFFFC;
ppc_next_instruction_address = 0x0100;
break;
@ -24,52 +24,52 @@ jmp_buf exc_env; /* Global exception environment. */
if (!(ppc_state.ppc_msr & 0x1000)) {
/* TODO: handle internal checkstop */
}
ppc_state.ppc_spr[26] = ppc_cur_instruction & 0xFFFFFFFC;
ppc_state.ppc_spr[SPR::SRR0] = ppc_cur_instruction & 0xFFFFFFFC;
ppc_next_instruction_address = 0x0200;
break;
case Except_Type::EXC_DSI:
ppc_state.ppc_spr[26] = ppc_cur_instruction & 0xFFFFFFFC;
ppc_state.ppc_spr[SPR::SRR0] = ppc_cur_instruction & 0xFFFFFFFC;
ppc_next_instruction_address = 0x0300;
break;
case Except_Type::EXC_ISI:
ppc_state.ppc_spr[26] = ppc_next_instruction_address;
ppc_state.ppc_spr[SPR::SRR0] = ppc_next_instruction_address;
ppc_next_instruction_address = 0x0400;
break;
case Except_Type::EXC_EXT_INT:
ppc_state.ppc_spr[26] = ppc_next_instruction_address;
ppc_state.ppc_spr[SPR::SRR0] = ppc_next_instruction_address;
ppc_next_instruction_address = 0x0500;
break;
case Except_Type::EXC_ALIGNMENT:
ppc_state.ppc_spr[26] = ppc_cur_instruction & 0xFFFFFFFC;
ppc_state.ppc_spr[SPR::SRR0] = ppc_cur_instruction & 0xFFFFFFFC;
ppc_next_instruction_address = 0x0600;
break;
case Except_Type::EXC_PROGRAM:
ppc_state.ppc_spr[26] = ppc_cur_instruction & 0xFFFFFFFC;
ppc_state.ppc_spr[SPR::SRR0] = ppc_cur_instruction & 0xFFFFFFFC;
ppc_next_instruction_address = 0x0700;
break;
case Except_Type::EXC_NO_FPU:
ppc_state.ppc_spr[26] = ppc_cur_instruction & 0xFFFFFFFC;
ppc_state.ppc_spr[SPR::SRR0] = ppc_cur_instruction & 0xFFFFFFFC;
ppc_next_instruction_address = 0x0800;
break;
case Except_Type::EXC_DECR:
ppc_state.ppc_spr[26] = (ppc_cur_instruction & 0xFFFFFFFC) + 4;
ppc_state.ppc_spr[SPR::SRR0] = (ppc_cur_instruction & 0xFFFFFFFC) + 4;
ppc_next_instruction_address = 0x0900;
break;
case Except_Type::EXC_SYSCALL:
ppc_state.ppc_spr[26] = (ppc_cur_instruction & 0xFFFFFFFC) + 4;
ppc_state.ppc_spr[SPR::SRR0] = (ppc_cur_instruction & 0xFFFFFFFC) + 4;
ppc_next_instruction_address = 0x0C00;
break;
case Except_Type::EXC_TRACE:
ppc_state.ppc_spr[26] = (ppc_cur_instruction & 0xFFFFFFFC) + 4;
ppc_state.ppc_spr[SPR::SRR0] = (ppc_cur_instruction & 0xFFFFFFFC) + 4;
ppc_next_instruction_address = 0x0D00;
break;
@ -79,7 +79,7 @@ jmp_buf exc_env; /* Global exception environment. */
break;
}
ppc_state.ppc_spr[27] = (ppc_state.ppc_msr & 0x0000FF73) | srr1_bits;
ppc_state.ppc_spr[SPR::SRR1] = (ppc_state.ppc_msr & 0x0000FF73) | srr1_bits;
ppc_state.ppc_msr &= 0xFFFB1041;
/* copy MSR[ILE] to MSR[LE] */
ppc_state.ppc_msr = (ppc_state.ppc_msr & 0xFFFFFFFE) |

4
cpu/ppc/ppcfpopcodes.cpp
View File

@ -1111,14 +1111,14 @@ void ppc_mtfsfi() {
ppc_result_b = (ppc_cur_instruction >> 11) & 15;
crf_d = (ppc_cur_instruction >> 23) & 7;
crf_d = crf_d << 2;
ppc_state.ppc_fpscr = (ppc_state.ppc_cr & ~(0xF0000000UL >> crf_d)) | ((ppc_state.ppc_spr[1] & 0xF0000000UL) >> crf_d);
ppc_state.ppc_fpscr = (ppc_state.ppc_cr & ~(0xF0000000UL >> crf_d)) | ((ppc_state.ppc_spr[SPR::XER] & 0xF0000000UL) >> crf_d);
}
void ppc_mtfsfidot() {
ppc_result_b = (ppc_cur_instruction >> 11) & 15;
crf_d = (ppc_cur_instruction >> 23) & 7;
crf_d = crf_d << 2;
ppc_state.ppc_fpscr = (ppc_state.ppc_cr & ~(0xF0000000UL >> crf_d)) | ((ppc_state.ppc_spr[1] & 0xF0000000UL) >> crf_d);
ppc_state.ppc_fpscr = (ppc_state.ppc_cr & ~(0xF0000000UL >> crf_d)) | ((ppc_state.ppc_spr[SPR::XER] & 0xF0000000UL) >> crf_d);
ppc_fp_changecrf1();
}

10
cpu/ppc/ppcmmu.cpp
View File

@ -194,7 +194,7 @@ static inline uint8_t* calc_pteg_addr(uint32_t hash)
{
uint32_t sdr1_val, pteg_addr;
sdr1_val = ppc_state.ppc_spr[25];
sdr1_val = ppc_state.ppc_spr[SPR::SDR1];
pteg_addr = sdr1_val & 0xFE000000;
pteg_addr |= (sdr1_val & 0x01FF0000) |
@ -287,8 +287,8 @@ static uint32_t page_address_translate(uint32_t la, bool is_instr_fetch,
ppc_exception_handler(Except_Type::EXC_ISI, 0x40000000);
}
else {
ppc_state.ppc_spr[18] = 0x40000000 | (is_write << 25);
ppc_state.ppc_spr[19] = la;
ppc_state.ppc_spr[SPR::DSISR] = 0x40000000 | (is_write << 25);
ppc_state.ppc_spr[SPR::DAR] = la;
ppc_exception_handler(Except_Type::EXC_DSI, 0);
}
}
@ -310,8 +310,8 @@ static uint32_t page_address_translate(uint32_t la, bool is_instr_fetch,
ppc_exception_handler(Except_Type::EXC_ISI, 0x08000000);
}
else {
ppc_state.ppc_spr[18] = 0x08000000 | (is_write << 25);
ppc_state.ppc_spr[19] = la;
ppc_state.ppc_spr[SPR::DSISR] = 0x08000000 | (is_write << 25);
ppc_state.ppc_spr[SPR::DAR] = la;
ppc_exception_handler(Except_Type::EXC_DSI, 0);
}
}

242
cpu/ppc/ppcopcodes.cpp
View File

@ -150,7 +150,7 @@ void ppc_changecrf0(uint32_t set_result) {
ppc_state.ppc_cr |= 0x40000000UL;
}
if (ppc_state.ppc_spr[1] & 0x80000000) {
if (ppc_state.ppc_spr[SPR::XER] & 0x80000000) {
ppc_state.ppc_cr |= 0x10000000UL;
}
}
@ -158,10 +158,10 @@ void ppc_changecrf0(uint32_t set_result) {
//Affects the XER register's Carry Bit
void ppc_carry(uint32_t a, uint32_t b) {
if (b < a) { // TODO: ensure it works everywhere
ppc_state.ppc_spr[1] |= 0x20000000;
ppc_state.ppc_spr[SPR::XER] |= 0x20000000;
}
else {
ppc_state.ppc_spr[1] &= 0xDFFFFFFFUL;
ppc_state.ppc_spr[SPR::XER] &= 0xDFFFFFFFUL;
}
}
@ -171,17 +171,17 @@ void ppc_setsoov(uint32_t a, uint32_t b) {
uint64_t b64b = (uint64_t)b;
if ((a64b + b64b) > 0xFFFFFFFFUL) {
ppc_state.ppc_spr[1] |= 0x40000000UL;
ppc_state.ppc_spr[SPR::XER] |= 0x40000000UL;
}
else {
ppc_state.ppc_spr[1] &= 0xBFFFFFFFUL;
ppc_state.ppc_spr[SPR::XER] &= 0xBFFFFFFFUL;
}
if (((a64b + b64b) < 0x80000000UL) || (ppc_state.ppc_spr[1] & 0x40000000UL)) {
ppc_state.ppc_spr[1] |= 0x80000000UL;
if (((a64b + b64b) < 0x80000000UL) || (ppc_state.ppc_spr[SPR::XER] & 0x40000000UL)) {
ppc_state.ppc_spr[SPR::XER] |= 0x80000000UL;
}
else {
ppc_state.ppc_spr[1] &= 0x7FFFFFFFUL;
ppc_state.ppc_spr[SPR::XER] &= 0x7FFFFFFFUL;
}
}
@ -281,26 +281,26 @@ void ppc_addcodot() {
void ppc_adde() {
ppc_grab_regsdab();
uint32_t xer_ca = !!(ppc_state.ppc_spr[1] & 0x20000000);
uint32_t xer_ca = !!(ppc_state.ppc_spr[SPR::XER] & 0x20000000);
ppc_result_d = ppc_result_a + ppc_result_b + xer_ca;
if ((ppc_result_d < ppc_result_a) || (xer_ca && (ppc_result_d == ppc_result_a))) {
ppc_state.ppc_spr[1] |= 0x20000000UL;
ppc_state.ppc_spr[SPR::XER] |= 0x20000000UL;
}
else {
ppc_state.ppc_spr[1] &= 0xDFFFFFFFUL;
ppc_state.ppc_spr[SPR::XER] &= 0xDFFFFFFFUL;
}
ppc_store_result_regd();
}
void ppc_addedot() {
ppc_grab_regsdab();
uint32_t xer_ca = !!(ppc_state.ppc_spr[1] & 0x20000000);
uint32_t xer_ca = !!(ppc_state.ppc_spr[SPR::XER] & 0x20000000);
ppc_result_d = ppc_result_a + ppc_result_b + xer_ca;
if ((ppc_result_d < ppc_result_a) || (xer_ca && (ppc_result_d == ppc_result_a))) {
ppc_state.ppc_spr[1] |= 0x20000000UL;
ppc_state.ppc_spr[SPR::XER] |= 0x20000000UL;
}
else {
ppc_state.ppc_spr[1] &= 0xDFFFFFFFUL;
ppc_state.ppc_spr[SPR::XER] &= 0xDFFFFFFFUL;
}
ppc_changecrf0(ppc_result_d);
ppc_store_result_regd();
@ -308,13 +308,13 @@ void ppc_addedot() {
void ppc_addeo() {
ppc_grab_regsdab();
uint32_t xer_ca = !!(ppc_state.ppc_spr[1] & 0x20000000);
uint32_t xer_ca = !!(ppc_state.ppc_spr[SPR::XER] & 0x20000000);
ppc_result_d = ppc_result_a + ppc_result_b + xer_ca;
if ((ppc_result_d < ppc_result_a) || (xer_ca && (ppc_result_d == ppc_result_a))) {
ppc_state.ppc_spr[1] |= 0x20000000UL;
ppc_state.ppc_spr[SPR::XER] |= 0x20000000UL;
}
else {
ppc_state.ppc_spr[1] &= 0xDFFFFFFFUL;
ppc_state.ppc_spr[SPR::XER] &= 0xDFFFFFFFUL;
}
ppc_changecrf0(ppc_result_d);
ppc_store_result_regd();
@ -322,14 +322,14 @@ void ppc_addeo() {
void ppc_addeodot() {
ppc_grab_regsdab();
uint32_t xer_ca = !!(ppc_state.ppc_spr[1] & 0x20000000);
uint32_t xer_ca = !!(ppc_state.ppc_spr[SPR::XER] & 0x20000000);
ppc_setsoov(ppc_result_a, (ppc_result_b + xer_ca));
ppc_result_d = ppc_result_a + ppc_result_b + xer_ca;
if ((ppc_result_d < ppc_result_a) || (xer_ca && (ppc_result_d == ppc_result_a))) {
ppc_state.ppc_spr[1] |= 0x20000000UL;
ppc_state.ppc_spr[SPR::XER] |= 0x20000000UL;
}
else {
ppc_state.ppc_spr[1] &= 0xDFFFFFFFUL;
ppc_state.ppc_spr[SPR::XER] &= 0xDFFFFFFFUL;
}
ppc_changecrf0(ppc_result_d);
ppc_store_result_regd();
@ -337,26 +337,26 @@ void ppc_addeodot() {
void ppc_addme() {
ppc_grab_regsda();
uint32_t xer_ca = !!(ppc_state.ppc_spr[1] & 0x20000000);
uint32_t xer_ca = !!(ppc_state.ppc_spr[SPR::XER] & 0x20000000);
ppc_result_d = ppc_result_a + xer_ca - 1;
if (((xer_ca - 1) < 0xFFFFFFFFUL) | (ppc_result_d < ppc_result_a)) {
ppc_state.ppc_spr[1] |= 0x20000000UL;
ppc_state.ppc_spr[SPR::XER] |= 0x20000000UL;
}
else {
ppc_state.ppc_spr[1] &= 0xDFFFFFFFUL;
ppc_state.ppc_spr[SPR::XER] &= 0xDFFFFFFFUL;
}
ppc_store_result_regd();
}
void ppc_addmedot() {
ppc_grab_regsda();
uint32_t xer_ca = !!(ppc_state.ppc_spr[1] & 0x20000000);
uint32_t xer_ca = !!(ppc_state.ppc_spr[SPR::XER] & 0x20000000);
ppc_result_d = ppc_result_a + xer_ca - 1;
if (((xer_ca - 1) < 0xFFFFFFFFUL) | (ppc_result_d < ppc_result_a)) {
ppc_state.ppc_spr[1] |= 0x20000000UL;
ppc_state.ppc_spr[SPR::XER] |= 0x20000000UL;
}
else {
ppc_state.ppc_spr[1] &= 0xDFFFFFFFUL;
ppc_state.ppc_spr[SPR::XER] &= 0xDFFFFFFFUL;
}
ppc_changecrf0(ppc_result_d);
ppc_store_result_regd();
@ -364,55 +364,55 @@ void ppc_addmedot() {
void ppc_addmeo() {
ppc_grab_regsda();
uint32_t xer_ca = !!(ppc_state.ppc_spr[1] & 0x20000000);
uint32_t xer_ca = !!(ppc_state.ppc_spr[SPR::XER] & 0x20000000);
ppc_setsoov(ppc_result_a, xer_ca);
ppc_result_d = ppc_result_a + xer_ca - 1;
if (((xer_ca - 1) < 0xFFFFFFFFUL) | (ppc_result_d < ppc_result_a)) {
ppc_state.ppc_spr[1] |= 0x20000000UL;
ppc_state.ppc_spr[SPR::XER] |= 0x20000000UL;
}
else {
ppc_state.ppc_spr[1] &= 0xDFFFFFFFUL;
ppc_state.ppc_spr[SPR::XER] &= 0xDFFFFFFFUL;
}
ppc_store_result_regd();
}
void ppc_addmeodot() {
ppc_grab_regsda();
uint32_t xer_ca = !!(ppc_state.ppc_spr[1] & 0x20000000);
uint32_t xer_ca = !!(ppc_state.ppc_spr[SPR::XER] & 0x20000000);
ppc_setsoov(ppc_result_a, xer_ca);
ppc_result_d = ppc_result_a + xer_ca - 1;
ppc_changecrf0(ppc_result_d);
if (((xer_ca - 1) < 0xFFFFFFFFUL) | (ppc_result_d < ppc_result_a)) {
ppc_state.ppc_spr[1] |= 0x20000000UL;
ppc_state.ppc_spr[SPR::XER] |= 0x20000000UL;
}
else {
ppc_state.ppc_spr[1] &= 0xDFFFFFFFUL;
ppc_state.ppc_spr[SPR::XER] &= 0xDFFFFFFFUL;
}
ppc_store_result_regd();
}
void ppc_addze() {
ppc_grab_regsda();
uint32_t grab_xer = (ppc_state.ppc_spr[1] & 0x20000000);
uint32_t grab_xer = (ppc_state.ppc_spr[SPR::XER] & 0x20000000);
ppc_result_d = ppc_result_a + grab_xer;
if (ppc_result_d < ppc_result_a) {
ppc_state.ppc_spr[1] |= 0x20000000UL;
ppc_state.ppc_spr[SPR::XER] |= 0x20000000UL;
}
else {
ppc_state.ppc_spr[1] &= 0xDFFFFFFFUL;
ppc_state.ppc_spr[SPR::XER] &= 0xDFFFFFFFUL;
}
ppc_store_result_regd();
}
void ppc_addzedot() {
ppc_grab_regsda();
uint32_t grab_xer = (ppc_state.ppc_spr[1] & 0x20000000);
uint32_t grab_xer = (ppc_state.ppc_spr[SPR::XER] & 0x20000000);
ppc_result_d = ppc_result_a + grab_xer;
if (ppc_result_d < ppc_result_a) {
ppc_state.ppc_spr[1] |= 0x20000000UL;
ppc_state.ppc_spr[SPR::XER] |= 0x20000000UL;
}
else {
ppc_state.ppc_spr[1] &= 0xDFFFFFFFUL;
ppc_state.ppc_spr[SPR::XER] &= 0xDFFFFFFFUL;
}
ppc_changecrf0(ppc_result_d);
ppc_store_result_regd();
@ -420,28 +420,28 @@ void ppc_addzedot() {
void ppc_addzeo() {
ppc_grab_regsda();
uint32_t grab_xer = (ppc_state.ppc_spr[1] & 0x20000000);
uint32_t grab_xer = (ppc_state.ppc_spr[SPR::XER] & 0x20000000);
ppc_setsoov(ppc_result_a, grab_xer);
ppc_result_d = ppc_result_a + grab_xer;
if (ppc_result_d < ppc_result_a) {
ppc_state.ppc_spr[1] |= 0x20000000UL;
ppc_state.ppc_spr[SPR::XER] |= 0x20000000UL;
}
else {
ppc_state.ppc_spr[1] &= 0xDFFFFFFFUL;
ppc_state.ppc_spr[SPR::XER] &= 0xDFFFFFFFUL;
}
ppc_store_result_regd();
}
void ppc_addzeodot() {
ppc_grab_regsda();
uint32_t grab_xer = (ppc_state.ppc_spr[1] & 0x20000000);
uint32_t grab_xer = (ppc_state.ppc_spr[SPR::XER] & 0x20000000);
ppc_setsoov(ppc_result_a, grab_xer);
ppc_result_d = ppc_result_a + grab_xer;
if (ppc_result_d < ppc_result_a) {
ppc_state.ppc_spr[1] |= 0x20000000UL;
ppc_state.ppc_spr[SPR::XER] |= 0x20000000UL;
}
else {
ppc_state.ppc_spr[1] &= 0xDFFFFFFFUL;
ppc_state.ppc_spr[SPR::XER] &= 0xDFFFFFFFUL;
}
ppc_changecrf0(ppc_result_d);
ppc_store_result_regd();
@ -484,10 +484,10 @@ void ppc_subfc() {
not_this = ~ppc_result_a;
ppc_result_d = not_this + ppc_result_b + 1;
if (ppc_result_d <= not_this) {
ppc_state.ppc_spr[1] |= 0x20000000UL;
ppc_state.ppc_spr[SPR::XER] |= 0x20000000UL;
}
else {
ppc_state.ppc_spr[1] &= 0xDFFFFFFFUL;
ppc_state.ppc_spr[SPR::XER] &= 0xDFFFFFFFUL;
}
ppc_carry(ppc_result_a, ppc_result_d);
ppc_store_result_regd();
@ -498,10 +498,10 @@ void ppc_subfcdot() {
not_this = ~ppc_result_a;
ppc_result_d = not_this + ppc_result_b + 1;
if (ppc_result_d <= not_this) {
ppc_state.ppc_spr[1] |= 0x20000000UL;
ppc_state.ppc_spr[SPR::XER] |= 0x20000000UL;
}
else {
ppc_state.ppc_spr[1] &= 0xDFFFFFFFUL;
ppc_state.ppc_spr[SPR::XER] &= 0xDFFFFFFFUL;
}
ppc_carry(ppc_result_a, ppc_result_d);
ppc_changecrf0(ppc_result_d);
@ -514,10 +514,10 @@ void ppc_subfco() {
not_this = ~ppc_result_a;
ppc_result_d = not_this + ppc_result_b + 1;
if (ppc_result_d <= not_this) {
ppc_state.ppc_spr[1] |= 0x20000000UL;
ppc_state.ppc_spr[SPR::XER] |= 0x20000000UL;
}
else {
ppc_state.ppc_spr[1] &= 0xDFFFFFFFUL;
ppc_state.ppc_spr[SPR::XER] &= 0xDFFFFFFFUL;
}
ppc_carry(ppc_result_a, ppc_result_d);
ppc_store_result_regd();
@ -529,10 +529,10 @@ void ppc_subfcodot() {
not_this = ~ppc_result_a;
ppc_result_d = not_this + ppc_result_b + 1;
if (ppc_result_d <= not_this) {
ppc_state.ppc_spr[1] |= 0x20000000UL;
ppc_state.ppc_spr[SPR::XER] |= 0x20000000UL;
}
else {
ppc_state.ppc_spr[1] &= 0xDFFFFFFFUL;
ppc_state.ppc_spr[SPR::XER] &= 0xDFFFFFFFUL;
}
ppc_carry(ppc_result_a, ppc_result_d);
ppc_changecrf0(ppc_result_d);
@ -544,24 +544,24 @@ void ppc_subfic() {
not_this = ~ppc_result_a;
ppc_result_d = not_this + simm + 1;
if (ppc_result_d <= not_this) {
ppc_state.ppc_spr[1] |= 0x20000000UL;
ppc_state.ppc_spr[SPR::XER] |= 0x20000000UL;
}
else {
ppc_state.ppc_spr[1] &= 0xDFFFFFFFUL;
ppc_state.ppc_spr[SPR::XER] &= 0xDFFFFFFFUL;
}
ppc_store_result_regd();
}
void ppc_subfe() {
ppc_grab_regsdab();
uint32_t grab_xer = (ppc_state.ppc_spr[1] & 0x20000000);
uint32_t grab_xer = (ppc_state.ppc_spr[SPR::XER] & 0x20000000);
not_this = ~ppc_result_a;
ppc_result_d = not_this + ppc_result_b + (ppc_state.ppc_spr[1] & 0x20000000);
ppc_result_d = not_this + ppc_result_b + (ppc_state.ppc_spr[SPR::XER] & 0x20000000);
if (ppc_result_d <= (not_this + grab_xer)) {
ppc_state.ppc_spr[1] |= 0x20000000UL;
ppc_state.ppc_spr[SPR::XER] |= 0x20000000UL;
}
else {
ppc_state.ppc_spr[1] &= 0xDFFFFFFFUL;
ppc_state.ppc_spr[SPR::XER] &= 0xDFFFFFFFUL;
}
ppc_carry(ppc_result_a, ppc_result_d);
ppc_store_result_regd();
@ -569,14 +569,14 @@ void ppc_subfe() {
void ppc_subfedot() {
ppc_grab_regsdab();
uint32_t grab_xer = (ppc_state.ppc_spr[1] & 0x20000000);
uint32_t grab_xer = (ppc_state.ppc_spr[SPR::XER] & 0x20000000);
not_this = ~ppc_result_a;
ppc_result_d = not_this + ppc_result_b + grab_xer;
if (ppc_result_d <= (not_this + grab_xer)) {
ppc_state.ppc_spr[1] |= 0x20000000UL;
ppc_state.ppc_spr[SPR::XER] |= 0x20000000UL;
}
else {
ppc_state.ppc_spr[1] &= 0xDFFFFFFFUL;
ppc_state.ppc_spr[SPR::XER] &= 0xDFFFFFFFUL;
}
ppc_carry(ppc_result_a, ppc_result_d);
ppc_changecrf0(ppc_result_d);
@ -586,13 +586,13 @@ void ppc_subfedot() {
void ppc_subfme() {
ppc_grab_regsda();
not_this = ~ppc_result_a;
uint32_t grab_xer = (ppc_state.ppc_spr[1] & 0x20000000);
uint32_t grab_xer = (ppc_state.ppc_spr[SPR::XER] & 0x20000000);
ppc_result_d = not_this + grab_xer - 1;
if (ppc_result_a || grab_xer) {
ppc_state.ppc_spr[1] |= 0x20000000UL;
ppc_state.ppc_spr[SPR::XER] |= 0x20000000UL;
}
else {
ppc_state.ppc_spr[1] &= 0xDFFFFFFFUL;
ppc_state.ppc_spr[SPR::XER] &= 0xDFFFFFFFUL;
}
ppc_carry(ppc_result_a, grab_xer);
ppc_store_result_regd();
@ -601,13 +601,13 @@ void ppc_subfme() {
void ppc_subfmedot() {
ppc_grab_regsda();
not_this = ~ppc_result_a;
uint32_t grab_xer = (ppc_state.ppc_spr[1] & 0x20000000);
uint32_t grab_xer = (ppc_state.ppc_spr[SPR::XER] & 0x20000000);
ppc_result_d = not_this + grab_xer - 1;
if (ppc_result_d <= (not_this + grab_xer)) {
ppc_state.ppc_spr[1] |= 0x20000000UL;
ppc_state.ppc_spr[SPR::XER] |= 0x20000000UL;
}
else {
ppc_state.ppc_spr[1] &= 0xDFFFFFFFUL;
ppc_state.ppc_spr[SPR::XER] &= 0xDFFFFFFFUL;
}
ppc_carry(ppc_result_a, grab_xer);
ppc_changecrf0(ppc_result_d);
@ -617,28 +617,28 @@ void ppc_subfmedot() {
void ppc_subfze() {
ppc_grab_regsda();
not_this = ~ppc_result_a;
ppc_result_d = not_this + (ppc_state.ppc_spr[1] & 0x20000000);
ppc_result_d = not_this + (ppc_state.ppc_spr[SPR::XER] & 0x20000000);
if (ppc_result_d <= not_this) {
ppc_state.ppc_spr[1] |= 0x20000000UL;
ppc_state.ppc_spr[SPR::XER] |= 0x20000000UL;
}
else {
ppc_state.ppc_spr[1] &= 0xDFFFFFFFUL;
ppc_state.ppc_spr[SPR::XER] &= 0xDFFFFFFFUL;
}
ppc_carry(ppc_result_a, (ppc_state.ppc_spr[1] & 0x20000000));
ppc_carry(ppc_result_a, (ppc_state.ppc_spr[SPR::XER] & 0x20000000));
ppc_store_result_regd();
}
void ppc_subfzedot() {
ppc_grab_regsda();
not_this = ~ppc_result_a;
ppc_result_d = not_this + (ppc_state.ppc_spr[1] & 0x20000000);
ppc_result_d = not_this + (ppc_state.ppc_spr[SPR::XER] & 0x20000000);
if (ppc_result_d <= not_this) {
ppc_state.ppc_spr[1] |= 0x20000000UL;
ppc_state.ppc_spr[SPR::XER] |= 0x20000000UL;
}
else {
ppc_state.ppc_spr[1] &= 0xDFFFFFFFUL;
ppc_state.ppc_spr[SPR::XER] &= 0xDFFFFFFFUL;
}
ppc_carry(ppc_result_a, (ppc_state.ppc_spr[1] & 0x20000000));
ppc_carry(ppc_result_a, (ppc_state.ppc_spr[SPR::XER] & 0x20000000));
ppc_changecrf0(ppc_result_d);
ppc_store_result_regd();
}
@ -801,7 +801,7 @@ void ppc_negdot() {
void ppc_nego() {
ppc_grab_regsda();
ppc_result_d = ~(ppc_result_a)+1;
ppc_state.ppc_spr[1] |= 0x40000000UL;
ppc_state.ppc_spr[SPR::XER] |= 0x40000000UL;
ppc_setsoov(ppc_result_d, 1);
ppc_store_result_regd();
}
@ -810,7 +810,7 @@ void ppc_negodot() {
ppc_grab_regsda();
ppc_result_d = ~(ppc_result_a)+1;
ppc_changecrf0(ppc_result_d);
ppc_state.ppc_spr[1] |= 0x40000000UL;
ppc_state.ppc_spr[SPR::XER] |= 0x40000000UL;
ppc_setsoov(ppc_result_d, 1);
ppc_store_result_regd();
}
@ -1141,11 +1141,11 @@ void ppc_sraw() {
if (ppc_result_b > 32) {
ppc_result_a = ((ppc_result_d) > 0x7FFFFFFF) ? 0xFFFFFFFFUL : 0x0;
ppc_state.ppc_spr[1] = (ppc_state.ppc_spr[1] & 0xDFFFFFFFUL) | (((ppc_result_d) > 0x7FFFFFFF) ? 0x20000000 : 0x0);
ppc_state.ppc_spr[SPR::XER] = (ppc_state.ppc_spr[SPR::XER] & 0xDFFFFFFFUL) | (((ppc_result_d) > 0x7FFFFFFF) ? 0x20000000 : 0x0);
}
else {
ppc_result_a = (uint32_t)((int32_t)ppc_result_d >> ppc_result_b);
ppc_state.ppc_spr[1] = (ppc_state.ppc_spr[1] & 0xDFFFFFFFUL) | (((ppc_result_d) > 0x7FFFFFFF) ? 0x20000000 : 0x0);
ppc_state.ppc_spr[SPR::XER] = (ppc_state.ppc_spr[SPR::XER] & 0xDFFFFFFFUL) | (((ppc_result_d) > 0x7FFFFFFF) ? 0x20000000 : 0x0);
}
ppc_store_result_rega();
}
@ -1154,11 +1154,11 @@ void ppc_srawdot() {
ppc_grab_regssab();
if (ppc_result_b > 32) {
ppc_result_a = ((ppc_result_d) > 0x7FFFFFFF) ? 0xFFFFFFFFUL : 0x0;
ppc_state.ppc_spr[1] = (ppc_state.ppc_spr[1] & 0xDFFFFFFFUL) | (((ppc_result_d) > 0x7FFFFFFF) ? 0x20000000 : 0x0);
ppc_state.ppc_spr[SPR::XER] = (ppc_state.ppc_spr[SPR::XER] & 0xDFFFFFFFUL) | (((ppc_result_d) > 0x7FFFFFFF) ? 0x20000000 : 0x0);
}
else {
ppc_result_a = (uint32_t)((int32_t)ppc_result_d >> ppc_result_b);
ppc_state.ppc_spr[1] = (ppc_state.ppc_spr[1] & 0xDFFFFFFFUL) | (((ppc_result_d) > 0x7FFFFFFF) ? 0x20000000 : 0x0);
ppc_state.ppc_spr[SPR::XER] = (ppc_state.ppc_spr[SPR::XER] & 0xDFFFFFFFUL) | (((ppc_result_d) > 0x7FFFFFFF) ? 0x20000000 : 0x0);
}
ppc_changecrf0(ppc_result_a);
ppc_store_result_rega();
@ -1169,7 +1169,7 @@ void ppc_srawi() {
unsigned rot_sh = (ppc_cur_instruction >> 11) & 31;
ppc_result_a = (uint32_t)((int32_t)ppc_result_d >> rot_sh);
ppc_state.ppc_spr[1] = (ppc_state.ppc_spr[1] & 0xDFFFFFFFUL) | (((ppc_result_d) > 0x7FFFFFFF) ? 0x20000000 : 0x0);
ppc_state.ppc_spr[SPR::XER] = (ppc_state.ppc_spr[SPR::XER] & 0xDFFFFFFFUL) | (((ppc_result_d) > 0x7FFFFFFF) ? 0x20000000 : 0x0);
ppc_store_result_rega();
}
@ -1179,7 +1179,7 @@ void ppc_srawidot() {
unsigned rot_sh = (ppc_cur_instruction >> 11) & 31;
ppc_result_a = (uint32_t)((int32_t)ppc_result_d >> rot_sh);
ppc_state.ppc_spr[1] = (ppc_state.ppc_spr[1] & 0xDFFFFFFFUL) | (((ppc_result_d) > 0x7FFFFFFF) ? 0x20000000 : 0x0);
ppc_state.ppc_spr[SPR::XER] = (ppc_state.ppc_spr[SPR::XER] & 0xDFFFFFFFUL) | (((ppc_result_d) > 0x7FFFFFFF) ? 0x20000000 : 0x0);
ppc_changecrf0(ppc_result_a);
ppc_store_result_rega();
@ -1334,10 +1334,10 @@ void ppc_mtspr() {
switch (ref_spr) {
//Mirror the TBRs in the SPR range to the user-mode TBRs.
case 268:
ppc_state.ppc_tbr[0] = ppc_state.ppc_gpr[reg_s];
ppc_state.ppc_tbr[TBR::TBL] = ppc_state.ppc_gpr[reg_s];
break;
case 269:
ppc_state.ppc_tbr[1] = ppc_state.ppc_gpr[reg_s];
ppc_state.ppc_tbr[TBR::TBU] = ppc_state.ppc_gpr[reg_s];
break;
case 528:
case 529:
@ -1366,10 +1366,10 @@ void ppc_mftb() {
reg_d = (ppc_cur_instruction >> 21) & 31;
switch (ref_spr) {
case 268:
ppc_state.ppc_gpr[reg_d] = ppc_state.ppc_tbr[0];
ppc_state.ppc_gpr[reg_d] = ppc_state.ppc_tbr[TBR::TBL];
break;
case 269:
ppc_state.ppc_gpr[reg_d] = ppc_state.ppc_tbr[1];
ppc_state.ppc_gpr[reg_d] = ppc_state.ppc_tbr[TBR::TBU];
break;
default:
std::cout << "Invalid TBR access attempted!" << std::endl;
@ -1395,8 +1395,8 @@ void ppc_mtcrf() {
void ppc_mcrxr() {
crf_d = (ppc_cur_instruction >> 23) & 7;
crf_d = crf_d << 2;
ppc_state.ppc_cr = (ppc_state.ppc_cr & ~(0xF0000000UL >> crf_d)) | ((ppc_state.ppc_spr[1] & 0xF0000000UL) >> crf_d);
ppc_state.ppc_spr[1] &= 0x0FFFFFFF;
ppc_state.ppc_cr = (ppc_state.ppc_cr & ~(0xF0000000UL >> crf_d)) | ((ppc_state.ppc_spr[SPR::XER] & 0xF0000000UL) >> crf_d);
ppc_state.ppc_spr[SPR::XER] &= 0x0FFFFFFF;
}
void ppc_extsb() {
@ -1443,7 +1443,7 @@ void ppc_bl() {
uint32_t quick_test = (ppc_cur_instruction & 0x03FFFFFC);
adr_li = (quick_test < 0x2000000) ? quick_test : (0xFC000000UL + quick_test);
ppc_next_instruction_address = (uint32_t)(ppc_state.ppc_pc + adr_li);
ppc_state.ppc_spr[8] = (uint32_t)(ppc_state.ppc_pc + 4);
ppc_state.ppc_spr[SPR::LR] = (uint32_t)(ppc_state.ppc_pc + 4);
grab_branch = 1;
bb_kind = BB_end_kind::BB_BRANCH;
}
@ -1460,7 +1460,7 @@ void ppc_bla() {
uint32_t quick_test = (ppc_cur_instruction & 0x03FFFFFC);
adr_li = (quick_test < 0x2000000) ? quick_test : (0xFC000000UL + quick_test);
ppc_next_instruction_address = adr_li;
ppc_state.ppc_spr[8] = ppc_state.ppc_pc + 4;
ppc_state.ppc_spr[SPR::LR] = ppc_state.ppc_pc + 4;
grab_branch = 1;
bb_kind = BB_end_kind::BB_BRANCH;
}
@ -1474,9 +1474,9 @@ void ppc_bc()
int32_t br_bd = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFC));
if (!(br_bo & 0x04)) {
(ppc_state.ppc_spr[9])--; /* decrement CTR */
(ppc_state.ppc_spr[SPR::CTR])--; /* decrement CTR */
}
ctr_ok = (br_bo & 0x04) || ((ppc_state.ppc_spr[9] != 0) == !(br_bo & 0x02));
ctr_ok = (br_bo & 0x04) || ((ppc_state.ppc_spr[SPR::CTR] != 0) == !(br_bo & 0x02));
cnd_ok = (br_bo & 0x10) || (!(ppc_state.ppc_cr & (0x80000000UL >> br_bi)) == !(br_bo & 0x08));
if (ctr_ok && cnd_ok) {
@ -1495,9 +1495,9 @@ void ppc_bca()
int32_t br_bd = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFC));
if (!(br_bo & 0x04)) {
(ppc_state.ppc_spr[9])--; /* decrement CTR */
(ppc_state.ppc_spr[SPR::CTR])--; /* decrement CTR */
}
ctr_ok = (br_bo & 0x04) || ((ppc_state.ppc_spr[9] != 0) == !(br_bo & 0x02));
ctr_ok = (br_bo & 0x04) || ((ppc_state.ppc_spr[SPR::CTR] != 0) == !(br_bo & 0x02));
cnd_ok = (br_bo & 0x10) || (!(ppc_state.ppc_cr & (0x80000000UL >> br_bi)) == !(br_bo & 0x08));
if (ctr_ok && cnd_ok) {
@ -1516,9 +1516,9 @@ void ppc_bcl()
int32_t br_bd = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFC));
if (!(br_bo & 0x04)) {
(ppc_state.ppc_spr[9])--; /* decrement CTR */
(ppc_state.ppc_spr[SPR::CTR])--; /* decrement CTR */
}
ctr_ok = (br_bo & 0x04) || ((ppc_state.ppc_spr[9] != 0) == !(br_bo & 0x02));
ctr_ok = (br_bo & 0x04) || ((ppc_state.ppc_spr[SPR::CTR] != 0) == !(br_bo & 0x02));
cnd_ok = (br_bo & 0x10) || (!(ppc_state.ppc_cr & (0x80000000UL >> br_bi)) == !(br_bo & 0x08));
if (ctr_ok && cnd_ok) {
@ -1526,7 +1526,7 @@ void ppc_bcl()
grab_branch = 1;
bb_kind = BB_end_kind::BB_BRANCH;
}
ppc_state.ppc_spr[8] = ppc_state.ppc_pc + 4;
ppc_state.ppc_spr[SPR::LR] = ppc_state.ppc_pc + 4;
}
void ppc_bcla()
@ -1538,9 +1538,9 @@ void ppc_bcla()
int32_t br_bd = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFC));
if (!(br_bo & 0x04)) {
(ppc_state.ppc_spr[9])--; /* decrement CTR */
(ppc_state.ppc_spr[SPR::CTR])--; /* decrement CTR */
}
ctr_ok = (br_bo & 0x04) || ((ppc_state.ppc_spr[9] != 0) == !(br_bo & 0x02));
ctr_ok = (br_bo & 0x04) || ((ppc_state.ppc_spr[SPR::CTR] != 0) == !(br_bo & 0x02));
cnd_ok = (br_bo & 0x10) || (!(ppc_state.ppc_cr & (0x80000000UL >> br_bi)) == !(br_bo & 0x08));
if (ctr_ok && cnd_ok) {
@ -1548,7 +1548,7 @@ void ppc_bcla()
grab_branch = 1;
bb_kind = BB_end_kind::BB_BRANCH;
}
ppc_state.ppc_spr[8] = ppc_state.ppc_pc + 4;
ppc_state.ppc_spr[SPR::LR] = ppc_state.ppc_pc + 4;
}
void ppc_bcctr()
@ -1559,7 +1559,7 @@ void ppc_bcctr()
uint32_t cnd_ok = (br_bo & 0x10) || (!(ppc_state.ppc_cr & (0x80000000UL >> br_bi)) == !(br_bo & 0x08));
if (cnd_ok) {
ppc_next_instruction_address = (ppc_state.ppc_spr[9] & 0xFFFFFFFCUL);
ppc_next_instruction_address = (ppc_state.ppc_spr[SPR::CTR] & 0xFFFFFFFCUL);
grab_branch = 1;
bb_kind = BB_end_kind::BB_BRANCH;
}
@ -1573,11 +1573,11 @@ void ppc_bcctrl()
uint32_t cnd_ok = (br_bo & 0x10) || (!(ppc_state.ppc_cr & (0x80000000UL >> br_bi)) == !(br_bo & 0x08));
if (cnd_ok) {
ppc_next_instruction_address = (ppc_state.ppc_spr[9] & 0xFFFFFFFCUL);
ppc_next_instruction_address = (ppc_state.ppc_spr[SPR::CTR] & 0xFFFFFFFCUL);
grab_branch = 1;
bb_kind = BB_end_kind::BB_BRANCH;
}
ppc_state.ppc_spr[8] = ppc_state.ppc_pc + 4;
ppc_state.ppc_spr[SPR::LR] = ppc_state.ppc_pc + 4;
}
void ppc_bclr()
@ -1588,13 +1588,13 @@ void ppc_bclr()
uint32_t cnd_ok;
if (!(br_bo & 0x04)) {
(ppc_state.ppc_spr[9])--; /* decrement CTR */
(ppc_state.ppc_spr[SPR::CTR])--; /* decrement CTR */
}
ctr_ok = (br_bo & 0x04) || ((ppc_state.ppc_spr[9] != 0) == !(br_bo & 0x02));
ctr_ok = (br_bo & 0x04) || ((ppc_state.ppc_spr[SPR::CTR] != 0) == !(br_bo & 0x02));
cnd_ok = (br_bo & 0x10) || (!(ppc_state.ppc_cr & (0x80000000UL >> br_bi)) == !(br_bo & 0x08));
if (ctr_ok && cnd_ok) {
ppc_next_instruction_address = (ppc_state.ppc_spr[8] & 0xFFFFFFFCUL);
ppc_next_instruction_address = (ppc_state.ppc_spr[SPR::LR] & 0xFFFFFFFCUL);
grab_branch = 1;
bb_kind = BB_end_kind::BB_BRANCH;
}
@ -1608,17 +1608,17 @@ void ppc_bclrl()
uint32_t cnd_ok;
if (!(br_bo & 0x04)) {
(ppc_state.ppc_spr[9])--; /* decrement CTR */
(ppc_state.ppc_spr[SPR::CTR])--; /* decrement CTR */
}
ctr_ok = (br_bo & 0x04) || ((ppc_state.ppc_spr[9] != 0) == !(br_bo & 0x02));
ctr_ok = (br_bo & 0x04) || ((ppc_state.ppc_spr[SPR::CTR] != 0) == !(br_bo & 0x02));
cnd_ok = (br_bo & 0x10) || (!(ppc_state.ppc_cr & (0x80000000UL >> br_bi)) == !(br_bo & 0x08));
if (ctr_ok && cnd_ok) {
ppc_next_instruction_address = (ppc_state.ppc_spr[8] & 0xFFFFFFFCUL);
ppc_next_instruction_address = (ppc_state.ppc_spr[SPR::LR] & 0xFFFFFFFCUL);
grab_branch = 1;
bb_kind = BB_end_kind::BB_BRANCH;
}
ppc_state.ppc_spr[8] = ppc_state.ppc_pc + 4;
ppc_state.ppc_spr[SPR::LR] = ppc_state.ppc_pc + 4;
}
//Compare Instructions
@ -1627,7 +1627,7 @@ void ppc_cmp() {
crf_d = (ppc_cur_instruction >> 23) & 7;
crf_d = crf_d << 2;
ppc_grab_regssab();
xercon = (ppc_state.ppc_spr[1] & 0x80000000UL) >> 3;
xercon = (ppc_state.ppc_spr[SPR::XER] & 0x80000000UL) >> 3;
cmp_c = (((int32_t)ppc_result_a) == ((int32_t)ppc_result_b)) ? 0x20000000UL : (((int32_t)ppc_result_a) > ((int32_t)ppc_result_b)) ? 0x40000000UL : 0x80000000UL;
ppc_state.ppc_cr = ((ppc_state.ppc_cr & ~(0xf0000000UL >> crf_d)) | ((cmp_c + xercon) >> crf_d));
//}
@ -1647,7 +1647,7 @@ void ppc_cmpi() {
crf_d = (ppc_cur_instruction >> 23) & 7;
crf_d = crf_d << 2;
ppc_grab_regsasimm();
xercon = (ppc_state.ppc_spr[1] & 0x80000000UL) >> 3;
xercon = (ppc_state.ppc_spr[SPR::XER] & 0x80000000UL) >> 3;
cmp_c = (((int32_t)ppc_result_a) == simm) ? 0x20000000UL : (((int32_t)ppc_result_a) > simm) ? 0x40000000UL : 0x80000000UL;
ppc_state.ppc_cr = ((ppc_state.ppc_cr & ~(0xf0000000UL >> crf_d)) | ((cmp_c + xercon) >> crf_d));
}
@ -1663,7 +1663,7 @@ void ppc_cmpl() {
crf_d = (ppc_cur_instruction >> 23) & 7;
crf_d = crf_d << 2;
ppc_grab_regssab();
xercon = (ppc_state.ppc_spr[1] & 0x80000000UL) >> 3;
xercon = (ppc_state.ppc_spr[SPR::XER] & 0x80000000UL) >> 3;
cmp_c = (ppc_result_a == ppc_result_b) ? 0x20000000UL : (ppc_result_a > ppc_result_b) ? 0x40000000UL : 0x80000000UL;
ppc_state.ppc_cr = ((ppc_state.ppc_cr & ~(0xf0000000UL >> crf_d)) | ((cmp_c + xercon) >> crf_d));
}
@ -1679,7 +1679,7 @@ void ppc_cmpli() {
crf_d = (ppc_cur_instruction >> 23) & 7;
crf_d = crf_d << 2;
ppc_grab_regssauimm();
xercon = (ppc_state.ppc_spr[1] & 0x80000000UL) >> 3;
xercon = (ppc_state.ppc_spr[SPR::XER] & 0x80000000UL) >> 3;
cmp_c = (ppc_result_a == uimm) ? 0x20000000UL : (ppc_result_a > uimm) ? 0x40000000UL : 0x80000000UL;
ppc_state.ppc_cr = ((ppc_state.ppc_cr & ~(0xf0000000UL >> crf_d)) | ((cmp_c + xercon) >> crf_d));
}
@ -1766,10 +1766,10 @@ void ppc_rfi() {
#ifdef PROFILER
supervisor_inst_num++;
#endif
uint32_t new_srr1_val = (ppc_state.ppc_spr[27] & 0x87C0FF73UL);
uint32_t new_srr1_val = (ppc_state.ppc_spr[SPR::SRR1] & 0x87C0FF73UL);
uint32_t new_msr_val = (ppc_state.ppc_msr & ~(0x87C0FF73UL));
ppc_state.ppc_msr = (new_msr_val | new_srr1_val) & 0xFFFBFFFFUL;
ppc_next_instruction_address = ppc_state.ppc_spr[26] & 0xFFFFFFFCUL;
ppc_next_instruction_address = ppc_state.ppc_spr[SPR::SRR0] & 0xFFFFFFFCUL;
grab_return = true;
bb_kind = BB_end_kind::BB_RFI;
@ -1967,11 +1967,11 @@ void ppc_stwcx() {
ppc_effective_address = (reg_a == 0) ? ppc_result_b : (ppc_result_a + ppc_result_b);
if (ppc_state.ppc_reserve) {
mem_write_dword(ppc_effective_address, ppc_result_d);
ppc_state.ppc_cr |= (ppc_state.ppc_spr[1] & 0x80000000) ? 0x30000000 : 0x20000000;
ppc_state.ppc_cr |= (ppc_state.ppc_spr[SPR::XER] & 0x80000000) ? 0x30000000 : 0x20000000;
ppc_state.ppc_reserve = false;
}
else {
ppc_state.ppc_cr |= (ppc_state.ppc_spr[1] & 0x80000000) ? 0x10000000 : 0;
ppc_state.ppc_cr |= (ppc_state.ppc_spr[SPR::XER] & 0x80000000) ? 0x10000000 : 0;
}
}
@ -2305,7 +2305,7 @@ void ppc_lswx() {
ppc_exception_handler(Except_Type::EXC_PROGRAM, 0x100000);
}
ppc_effective_address = (reg_a == 0) ? ppc_result_b : (ppc_result_a + ppc_result_b);
grab_inb = ppc_state.ppc_spr[1] & 127;
grab_inb = ppc_state.ppc_spr[SPR::XER] & 127;
uint32_t shift_times = 0;
while (grab_inb > 0) {
switch (shift_times) {
@ -2387,7 +2387,7 @@ void ppc_stswi() {
void ppc_stswx() {
ppc_grab_regssab();
ppc_effective_address = (reg_a == 0) ? ppc_result_b : (ppc_result_a + ppc_result_b);
grab_inb = ppc_state.ppc_spr[1] & 127;
grab_inb = ppc_state.ppc_spr[SPR::XER] & 127;
uint32_t shift_times = 0;
while (grab_inb > 0) {
switch (shift_times) {

12
debugger/debugger.cpp
View File

@ -37,12 +37,12 @@ void dump_regs()
for (uint32_t i = 0; i < 32; i++)
cout << "GPR " << dec << i << " : " << hex << ppc_state.ppc_gpr[i] << endl;
cout << "PC: " << hex << ppc_state.ppc_pc << endl;
cout << "LR: " << hex << ppc_state.ppc_spr[8] << endl;
cout << "CR: " << hex << ppc_state.ppc_cr << endl;
cout << "CTR: " << hex << ppc_state.ppc_spr[9] << endl;
cout << "XER: " << hex << ppc_state.ppc_spr[1] << endl;
cout << "MSR: " << hex << ppc_state.ppc_msr << endl;
cout << "PC: " << hex << ppc_state.ppc_pc << endl;
cout << "LR: " << hex << ppc_state.ppc_spr[SPR::LR] << endl;
cout << "CR: " << hex << ppc_state.ppc_cr << endl;
cout << "CTR: " << hex << ppc_state.ppc_spr[SPR::CTR] << endl;
cout << "XER: " << hex << ppc_state.ppc_spr[SPR::XER] << endl;
cout << "MSR: " << hex << ppc_state.ppc_msr << endl;
}
void enter_debugger()