diff --git a/cpu/ppc/poweropcodes.cpp b/cpu/ppc/poweropcodes.cpp index b007008..90afc17 100644 --- a/cpu/ppc/poweropcodes.cpp +++ b/cpu/ppc/poweropcodes.cpp @@ -17,265 +17,265 @@ #include #include -void power_abs(){ +void power_abs() { ppc_grab_regsda(); - if (ppc_result_a == 0x80000000){ + if (ppc_result_a == 0x80000000) { ppc_result_d = ppc_result_a; } - else{ + else { ppc_result_d = ppc_result_a & 0x7FFFFFFF; } ppc_store_result_regd(); } -void power_absdot(){ +void power_absdot() { ppc_grab_regsda(); - if (ppc_result_a == 0x80000000){ + if (ppc_result_a == 0x80000000) { ppc_result_d = ppc_result_a; } - else{ + else { ppc_result_d = ppc_result_a & 0x7FFFFFFF; } ppc_changecrf0(ppc_result_d); ppc_store_result_regd(); } -void power_abso(){ +void power_abso() { ppc_grab_regsda(); - if (ppc_result_a == 0x80000000){ + if (ppc_result_a == 0x80000000) { ppc_result_d = ppc_result_a; ppc_state.ppc_spr[1] |= 0x40000000; } - else{ + else { ppc_result_d = ppc_result_a & 0x7FFFFFFF; } ppc_store_result_regd(); } -void power_absodot(){ +void power_absodot() { ppc_grab_regsda(); - if (ppc_result_a == 0x80000000){ + if (ppc_result_a == 0x80000000) { ppc_result_d = ppc_result_a; ppc_state.ppc_spr[1] |= 0x40000000; } - else{ + else { ppc_result_d = ppc_result_a & 0x7FFFFFFF; } ppc_changecrf0(ppc_result_d); ppc_store_result_regd(); } -void power_clcs(){ +void power_clcs() { ppc_grab_regsda(); - switch(reg_a){ - case 12: - case 13: - case 14: - case 15: - ppc_result_d = 65535; - break; - default: - ppc_result_d = 0; + switch (reg_a) { + case 12: + case 13: + case 14: + case 15: + ppc_result_d = 65535; + break; + default: + ppc_result_d = 0; } ppc_store_result_regd(); } -void power_clcsdot(){ - switch(reg_a){ - case 12: - case 13: - case 14: - case 15: - ppc_result_d = 65535; - break; - default: - ppc_result_d = 0; +void power_clcsdot() { + switch (reg_a) { + case 12: + case 13: + case 14: + case 15: + ppc_result_d = 65535; + break; + default: + ppc_result_d = 0; } ppc_changecrf0(ppc_result_d); printf("Does RC do anything here? (TODO) \n"); ppc_store_result_regd(); } -void power_div(){ +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_store_result_regd(); } -void power_divdot(){ +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; } -void power_divo(){ +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; } -void power_divodot(){ +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; } -void power_divs(){ +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[0] = (ppc_result_a % ppc_result_b); ppc_store_result_regd(); } -void power_divsdot(){ +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[0] = (ppc_result_a % ppc_result_b); } -void power_divso(){ +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[0] = (ppc_result_a % ppc_result_b); } -void power_divsodot(){ +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[0] = (ppc_result_a % ppc_result_b); } -void power_doz(){ +void power_doz() { ppc_grab_regsdab(); - if (((int32_t)ppc_result_a) > ((int32_t)ppc_result_b)){ + if (((int32_t)ppc_result_a) > ((int32_t)ppc_result_b)) { ppc_result_d = 0; } - else{ + else { ppc_result_d = ~ppc_result_a + ppc_result_b + 1; } ppc_store_result_rega(); } -void power_dozdot(){ +void power_dozdot() { ppc_grab_regsdab(); - if (((int32_t)ppc_result_a) > ((int32_t)ppc_result_b)){ + if (((int32_t)ppc_result_a) > ((int32_t)ppc_result_b)) { ppc_result_d = 0; } - else{ + else { ppc_result_d = ~ppc_result_a + ppc_result_b + 1; } ppc_changecrf0(ppc_result_d); ppc_store_result_rega(); } -void power_dozo(){ - if (((int32_t)ppc_result_a) > ((int32_t)ppc_result_b)){ +void power_dozo() { + if (((int32_t)ppc_result_a) > ((int32_t)ppc_result_b)) { ppc_result_d = 0; } - else{ + else { ppc_result_d = ~ppc_result_a + ppc_result_b + 1; } } -void power_dozodot(){ - if (((int32_t)ppc_result_a) > ((int32_t)ppc_result_b)){ +void power_dozodot() { + if (((int32_t)ppc_result_a) > ((int32_t)ppc_result_b)) { ppc_result_d = 0; } - else{ + else { ppc_result_d = ~ppc_result_a + ppc_result_b + 1; } } -void power_dozi(){ +void power_dozi() { ppc_grab_regsdab(); - if (((int32_t)ppc_result_a) > simm){ + if (((int32_t)ppc_result_a) > simm) { ppc_result_d = 0; } - else{ + else { ppc_result_d = ~ppc_result_a + simm + 1; } ppc_store_result_rega(); } -void power_lscbx(){ +void power_lscbx() { ppc_grab_regsdab(); uint32_t bytes_copied = 0; bool match_found = false; uint32_t shift_amount = 0; uint8_t byte_compared = (uint8_t)((ppc_state.ppc_spr[1] & 0xFF00) >> 8); - if ((ppc_state.ppc_spr[1] & 0x7f) == 0){ + if ((ppc_state.ppc_spr[1] & 0x7f) == 0) { return; } uint32_t bytes_to_load = (ppc_state.ppc_spr[1] & 0x7f) + 1; - ppc_effective_address = (reg_a == 0)?ppc_result_b:ppc_result_a + ppc_result_b; - do{ + ppc_effective_address = (reg_a == 0) ? ppc_result_b : ppc_result_a + ppc_result_b; + do { ppc_effective_address++; bytes_to_load--; - if (match_found == false){ - switch(shift_amount){ - case 0: - address_quickgrab_translate(ppc_effective_address, 1); - ppc_result_d = (ppc_result_d & 0x00FFFFFF) | (return_value << 24); - ppc_store_result_regd(); - break; - case 1: - address_quickgrab_translate(ppc_effective_address, 1); - ppc_result_d = (ppc_result_d & 0xFF00FFFF) | (return_value << 16); - ppc_store_result_regd(); - break; - case 2: - address_quickgrab_translate(ppc_effective_address, 1); - ppc_result_d = (ppc_result_d & 0xFFFF00FF) | (return_value << 8); - ppc_store_result_regd(); - break; - case 3: - address_quickgrab_translate(ppc_effective_address, 1); - ppc_result_d = (ppc_result_d & 0xFFFFFF00) | return_value; - ppc_store_result_regd(); - break; + if (match_found == false) { + switch (shift_amount) { + case 0: + address_grab8bit_translate(ppc_effective_address); + ppc_result_d = (ppc_result_d & 0x00FFFFFF) | ((uint32_t)return_value << 24); + ppc_store_result_regd(); + break; + case 1: + address_grab8bit_translate(ppc_effective_address); + ppc_result_d = (ppc_result_d & 0xFF00FFFF) | ((uint32_t)return_value << 16); + ppc_store_result_regd(); + break; + case 2: + address_grab8bit_translate(ppc_effective_address); + ppc_result_d = (ppc_result_d & 0xFFFF00FF) | ((uint32_t)return_value << 8); + ppc_store_result_regd(); + break; + case 3: + address_grab8bit_translate(ppc_effective_address); + ppc_result_d = (ppc_result_d & 0xFFFFFF00) | (uint32_t)return_value; + ppc_store_result_regd(); + break; } bytes_copied++; } - if (((uint8_t)return_value) == byte_compared){ + if (((uint8_t)return_value) == byte_compared) { break; } return_value = 0; - if (shift_amount == 3){ + if (shift_amount == 3) { shift_amount = 0; reg_d = (reg_d + 1) & 0x1F; } - else{ + else { shift_amount++; } - }while (bytes_to_load > 0); + } while (bytes_to_load > 0); ppc_state.ppc_spr[1] = (ppc_state.ppc_spr[1] & 0xFFFFFF80) | bytes_copied; ppc_store_result_regd(); } -void power_lscbxdot(){ - printf("OOPS! Placeholder!!! \n"); +void power_lscbxdot() { + printf("OOPS! Placeholder!!! \n"); } -void power_maskg(){ +void power_maskg() { ppc_grab_regssab(); uint32_t mask_start = ppc_result_d & 31; uint32_t mask_end = ppc_result_b & 31; uint32_t insert_mask = 0; - if (mask_start < (mask_end + 1)){ - for (uint32_t i = mask_start; i < mask_end; i++){ + if (mask_start < (mask_end + 1)) { + for (uint32_t i = mask_start; i < mask_end; i++) { insert_mask |= (0x80000000 >> i); } } - else if (mask_start == (mask_end + 1)){ + else if (mask_start == (mask_end + 1)) { insert_mask = 0xFFFFFFFF; } - else{ + else { insert_mask = 0xFFFFFFFF; - for (uint32_t i = (mask_end + 1); i < (mask_start - 1); i++){ + for (uint32_t i = (mask_end + 1); i < (mask_start - 1); i++) { insert_mask &= (~(0x80000000 >> i)); } } @@ -284,23 +284,23 @@ void power_maskg(){ ppc_store_result_rega(); } -void power_maskgdot(){ +void power_maskgdot() { ppc_grab_regssab(); uint32_t mask_start = ppc_result_d & 31; uint32_t mask_end = ppc_result_b & 31; uint32_t insert_mask = 0; - if (mask_start < (mask_end + 1)){ - for (uint32_t i = mask_start; i < mask_end; i++){ + if (mask_start < (mask_end + 1)) { + for (uint32_t i = mask_start; i < mask_end; i++) { insert_mask |= (0x80000000 >> i); } } - else if (mask_start == (mask_end + 1)){ + else if (mask_start == (mask_end + 1)) { insert_mask = 0xFFFFFFFF; } - else{ + else { insert_mask = 0xFFFFFFFF; - for (uint32_t i = (mask_end + 1); i < (mask_start - 1); i++){ + for (uint32_t i = (mask_end + 1); i < (mask_start - 1); i++) { insert_mask &= (~(0x80000000 >> i)); } } @@ -309,40 +309,40 @@ void power_maskgdot(){ ppc_store_result_rega(); } -void power_maskir(){ +void power_maskir() { ppc_grab_regssab(); uint32_t mask_insert = ppc_result_a; uint32_t insert_rot = 0x80000000; - do{ - if (ppc_result_b & insert_rot){ + do { + if (ppc_result_b & insert_rot) { mask_insert &= ~insert_rot; mask_insert |= (ppc_result_d & insert_rot); } - insert_rot = insert_rot>> 1; - }while(insert_rot > 0); + insert_rot = insert_rot >> 1; + } while (insert_rot > 0); ppc_result_a = (ppc_result_d & ppc_result_b); ppc_store_result_rega(); } -void power_maskirdot(){ +void power_maskirdot() { ppc_grab_regssab(); uint32_t mask_insert = ppc_result_a; uint32_t insert_rot = 0x80000000; - do{ - if (ppc_result_b & insert_rot){ + do { + if (ppc_result_b & insert_rot) { mask_insert &= ~insert_rot; mask_insert |= (ppc_result_d & insert_rot); } - insert_rot = insert_rot>> 1; - }while(insert_rot > 0); + insert_rot = insert_rot >> 1; + } while (insert_rot > 0); ppc_result_a = (ppc_result_d & ppc_result_b); ppc_changecrf0(ppc_result_a); ppc_store_result_rega(); } -void power_mul(){ +void power_mul() { ppc_grab_regsdab(); uint64_t product; @@ -353,7 +353,7 @@ void power_mul(){ } -void power_muldot(){ +void power_muldot() { ppc_grab_regsdab(); uint64_t product; @@ -365,7 +365,7 @@ void power_muldot(){ } -void power_mulo(){ +void power_mulo() { uint64_t product; product = ((uint64_t)ppc_result_a) * ((uint64_t)ppc_result_b); @@ -374,7 +374,7 @@ void power_mulo(){ } -void power_mulodot(){ +void power_mulodot() { uint64_t product; product = ((uint64_t)ppc_result_a) * ((uint64_t)ppc_result_b); @@ -383,42 +383,42 @@ void power_mulodot(){ } -void power_nabs(){ +void power_nabs() { ppc_grab_regsda(); ppc_result_d = (0x80000000 | ppc_result_a); ppc_store_result_regd(); } -void power_nabsdot(){ +void power_nabsdot() { ppc_result_d = (0x80000000 | ppc_result_a); } -void power_nabso(){ +void power_nabso() { ppc_result_d = (0x80000000 | ppc_result_a); } -void power_nabsodot(){ +void power_nabsodot() { ppc_result_d = (0x80000000 | ppc_result_a); } -void power_rlmi(){ +void power_rlmi() { ppc_grab_regssab(); unsigned rot_mb = (ppc_cur_instruction >> 6) & 31; unsigned rot_me = (ppc_cur_instruction >> 1) & 31; uint32_t rot_amt = ppc_result_b & 31; uint32_t insert_mask = 0; - if (rot_mb < (rot_me + 1)){ - for (uint32_t i = rot_mb; i < rot_me; i++){ + if (rot_mb < (rot_me + 1)) { + for (uint32_t i = rot_mb; i < rot_me; i++) { insert_mask |= (0x80000000 >> i); } } - else if (rot_mb == (rot_me + 1)){ + else if (rot_mb == (rot_me + 1)) { insert_mask = 0xFFFFFFFF; } - else{ + else { insert_mask = 0xFFFFFFFF; - for (uint32_t i = (rot_me + 1); i < (rot_mb - 1); i++){ + for (uint32_t i = (rot_me + 1); i < (rot_mb - 1); i++) { insert_mask &= (~(0x80000000 >> i)); } } @@ -428,34 +428,34 @@ void power_rlmi(){ ppc_store_result_rega(); } -void power_rrib(){ +void power_rrib() { ppc_grab_regssab(); - if (ppc_result_d & 0x80000000){ + if (ppc_result_d & 0x80000000) { ppc_result_a |= (0x80000000 >> ppc_result_b); } - else{ + else { ppc_result_a &= ~(0x80000000 >> ppc_result_b); } ppc_store_result_rega(); } -void power_rribdot(){ +void power_rribdot() { ppc_grab_regssab(); - if (ppc_result_d & 0x80000000){ + if (ppc_result_d & 0x80000000) { ppc_result_a |= (0x80000000 >> ppc_result_b); } - else{ + else { ppc_result_a &= ~(0x80000000 >> ppc_result_b); } ppc_changecrf0(ppc_result_a); ppc_store_result_rega(); } -void power_sle(){ +void power_sle() { ppc_grab_regssa(); uint32_t insert_mask = 0; uint32_t rot_amt = ppc_result_b & 31; - for (uint32_t i = 31; i > rot_amt; i--){ + for (uint32_t i = 31; i > rot_amt; i--) { insert_mask |= (1 << i); } uint32_t insert_final = ((ppc_result_d << rot_amt) | (ppc_result_d >> (32 - rot_amt))); @@ -464,11 +464,11 @@ void power_sle(){ ppc_store_result_rega(); } -void power_sledot(){ +void power_sledot() { ppc_grab_regssa(); uint32_t insert_mask = 0; uint32_t rot_amt = ppc_result_b & 31; - for (uint32_t i = 31; i > rot_amt; i--){ + for (uint32_t i = 31; i > rot_amt; i--) { insert_mask |= (1 << i); } uint32_t insert_final = ((ppc_result_d << rot_amt) | (ppc_result_d >> (32 - rot_amt))); @@ -478,18 +478,18 @@ void power_sledot(){ ppc_store_result_rega(); } -void power_sleq(){ +void power_sleq() { ppc_grab_regssa(); uint32_t insert_mask = 0; uint32_t rot_amt = ppc_result_b & 31; - for (uint32_t i = 31; i > rot_amt; i--){ + for (uint32_t i = 31; i > rot_amt; i--) { insert_mask |= (1 << i); } - uint32_t insert_start= ((ppc_result_d << rot_amt) | (ppc_result_d >> (rot_amt - 31))); + uint32_t insert_start = ((ppc_result_d << rot_amt) | (ppc_result_d >> (rot_amt - 31))); uint32_t insert_end = ppc_state.ppc_spr[0]; - for (int i = 0; i < 32; i++){ - if (insert_mask & (1 << i)){ + for (int i = 0; i < 32; i++) { + if (insert_mask & (1 << i)) { insert_end &= ~(1 << i); insert_end |= (insert_start & (1 << i)); } @@ -500,18 +500,18 @@ void power_sleq(){ ppc_store_result_rega(); } -void power_sleqdot(){ +void power_sleqdot() { ppc_grab_regssa(); uint32_t insert_mask = 0; uint32_t rot_amt = ppc_result_b & 31; - for (uint32_t i = 31; i > rot_amt; i--){ + for (uint32_t i = 31; i > rot_amt; i--) { insert_mask |= (1 << i); } - uint32_t insert_start= ((ppc_result_d << rot_amt) | (ppc_result_d >> (rot_amt - 31))); + uint32_t insert_start = ((ppc_result_d << rot_amt) | (ppc_result_d >> (rot_amt - 31))); uint32_t insert_end = ppc_state.ppc_spr[0]; - for (int i = 0; i < 32; i++){ - if (insert_mask & (1 << i)){ + for (int i = 0; i < 32; i++) { + if (insert_mask & (1 << i)) { insert_end &= ~(1 << i); insert_end |= (insert_start & (1 << i)); } @@ -523,18 +523,18 @@ void power_sleqdot(){ ppc_store_result_rega(); } -void power_sliq(){ +void power_sliq() { ppc_grab_regssa(); uint32_t insert_mask = 0; unsigned rot_sh = (ppc_cur_instruction >> 11) & 31; - for (uint32_t i = 31; i > rot_sh; i--){ + for (uint32_t i = 31; i > rot_sh; i--) { insert_mask |= (1 << i); } - uint32_t insert_start= ((ppc_result_d << rot_sh) | (ppc_result_d >> (rot_sh - 31))); + uint32_t insert_start = ((ppc_result_d << rot_sh) | (ppc_result_d >> (rot_sh - 31))); uint32_t insert_end = ppc_state.ppc_spr[0]; - for (int i = 0; i < 32; i++){ - if (insert_mask & (1 << i)){ + for (int i = 0; i < 32; i++) { + if (insert_mask & (1 << i)) { insert_end &= ~(1 << i); insert_end |= (insert_start & (1 << i)); } @@ -545,18 +545,18 @@ void power_sliq(){ ppc_store_result_rega(); } -void power_sliqdot(){ +void power_sliqdot() { ppc_grab_regssa(); uint32_t insert_mask = 0; unsigned rot_sh = (ppc_cur_instruction >> 11) & 31; - for (uint32_t i = 31; i > rot_sh; i--){ + for (uint32_t i = 31; i > rot_sh; i--) { insert_mask |= (1 << i); } - uint32_t insert_start= ((ppc_result_d << rot_sh) | (ppc_result_d >> (rot_sh - 31))); + uint32_t insert_start = ((ppc_result_d << rot_sh) | (ppc_result_d >> (rot_sh - 31))); uint32_t insert_end = ppc_state.ppc_spr[0]; - for (int i = 0; i < 32; i++){ - if (insert_mask & (1 << i)){ + for (int i = 0; i < 32; i++) { + if (insert_mask & (1 << i)) { insert_end &= ~(1 << i); insert_end |= (insert_start & (1 << i)); } @@ -568,18 +568,18 @@ void power_sliqdot(){ ppc_store_result_rega(); } -void power_slliq(){ +void power_slliq() { ppc_grab_regssa(); uint32_t insert_mask = 0; unsigned rot_sh = (ppc_cur_instruction >> 11) & 31; - for (uint32_t i = 31; i > rot_sh; i--){ + for (uint32_t i = 31; i > rot_sh; i--) { insert_mask |= (1 << i); } - uint32_t insert_start= ((ppc_result_d << rot_sh) | (ppc_result_d >> (32 - rot_sh))); + uint32_t insert_start = ((ppc_result_d << rot_sh) | (ppc_result_d >> (32 - rot_sh))); uint32_t insert_end = ppc_state.ppc_spr[0]; - for (int i = 0; i < 32; i++){ - if (insert_mask & (1 << i)){ + for (int i = 0; i < 32; i++) { + if (insert_mask & (1 << i)) { insert_end &= ~(1 << i); insert_end |= (insert_start & (1 << i)); } @@ -590,18 +590,18 @@ void power_slliq(){ ppc_store_result_rega(); } -void power_slliqdot(){ +void power_slliqdot() { ppc_grab_regssa(); uint32_t insert_mask = 0; unsigned rot_sh = (ppc_cur_instruction >> 11) & 31; - for (uint32_t i = 31; i > rot_sh; i--){ + for (uint32_t i = 31; i > rot_sh; i--) { insert_mask |= (1 << i); } - uint32_t insert_start= ((ppc_result_d << rot_sh) | (ppc_result_d >> (32 - rot_sh))); + uint32_t insert_start = ((ppc_result_d << rot_sh) | (ppc_result_d >> (32 - rot_sh))); uint32_t insert_end = ppc_state.ppc_spr[0]; - for (int i = 0; i < 32; i++){ - if (insert_mask & (1 << i)){ + for (int i = 0; i < 32; i++) { + if (insert_mask & (1 << i)) { insert_end &= ~(1 << i); insert_end |= (insert_start & (1 << i)); } @@ -613,43 +613,43 @@ void power_slliqdot(){ ppc_store_result_rega(); } -void power_sllq(){ - printf("OOPS! Placeholder!!! \n"); +void power_sllq() { + printf("OOPS! Placeholder!!! \n"); } -void power_sllqdot(){ - printf("OOPS! Placeholder!!! \n"); +void power_sllqdot() { + printf("OOPS! Placeholder!!! \n"); } -void power_slq(){ - printf("OOPS! Placeholder!!! \n"); +void power_slq() { + printf("OOPS! Placeholder!!! \n"); } -void power_slqdot(){ - printf("OOPS! Placeholder!!! \n"); +void power_slqdot() { + printf("OOPS! Placeholder!!! \n"); } -void power_sraiq(){ - printf("OOPS! Placeholder!!! \n"); +void power_sraiq() { + printf("OOPS! Placeholder!!! \n"); } -void power_sraiqdot(){ - printf("OOPS! Placeholder!!! \n"); +void power_sraiqdot() { + printf("OOPS! Placeholder!!! \n"); } -void power_sraq(){ - printf("OOPS! Placeholder!!! \n"); +void power_sraq() { + printf("OOPS! Placeholder!!! \n"); } -void power_sraqdot(){ - printf("OOPS! Placeholder!!! \n"); +void power_sraqdot() { + printf("OOPS! Placeholder!!! \n"); } -void power_sre(){ +void power_sre() { ppc_grab_regssa(); uint32_t insert_mask = 0; uint32_t rot_amt = ppc_result_b & 31; - for (uint32_t i = 31; i > rot_amt; i--){ + for (uint32_t i = 31; i > rot_amt; i--) { insert_mask |= (1 << i); } uint32_t insert_final = ((ppc_result_d >> rot_amt) | (ppc_result_d << (32 - rot_amt))); @@ -658,11 +658,11 @@ void power_sre(){ ppc_store_result_rega(); } -void power_sredot(){ +void power_sredot() { ppc_grab_regssa(); uint32_t insert_mask = 0; uint32_t rot_amt = ppc_result_b & 31; - for (uint32_t i = 31; i > rot_amt; i--){ + for (uint32_t i = 31; i > rot_amt; i--) { insert_mask |= (1 << i); } uint32_t insert_final = ((ppc_result_d >> rot_amt) | (ppc_result_d << (32 - rot_amt))); @@ -672,26 +672,26 @@ void power_sredot(){ ppc_store_result_rega(); } -void power_srea(){ - printf("OOPS! Placeholder!!! \n"); +void power_srea() { + printf("OOPS! Placeholder!!! \n"); } -void power_sreadot(){ - printf("OOPS! Placeholder!!! \n"); +void power_sreadot() { + printf("OOPS! Placeholder!!! \n"); } -void power_sreq(){ +void power_sreq() { ppc_grab_regssa(); uint32_t insert_mask = 0; unsigned rot_sh = ppc_result_b & 31; - for (uint32_t i = 31; i > rot_sh; i--){ + for (uint32_t i = 31; i > rot_sh; i--) { insert_mask |= (1 << i); } - uint32_t insert_start= ((ppc_result_d >> rot_sh) | (ppc_result_d << (32 - rot_sh))); + uint32_t insert_start = ((ppc_result_d >> rot_sh) | (ppc_result_d << (32 - rot_sh))); uint32_t insert_end = ppc_state.ppc_spr[0]; - for (int i = 0; i < 32; i++){ - if (insert_mask & (1 << i)){ + for (int i = 0; i < 32; i++) { + if (insert_mask & (1 << i)) { insert_end &= ~(1 << i); insert_end |= (insert_start & (1 << i)); } @@ -702,18 +702,18 @@ void power_sreq(){ ppc_store_result_rega(); } -void power_sreqdot(){ +void power_sreqdot() { ppc_grab_regssa(); uint32_t insert_mask = 0; unsigned rot_sh = ppc_result_b & 31; - for (uint32_t i = 31; i > rot_sh; i--){ + for (uint32_t i = 31; i > rot_sh; i--) { insert_mask |= (1 << i); } - uint32_t insert_start= ((ppc_result_d >> rot_sh) | (ppc_result_d << (32 - rot_sh))); + uint32_t insert_start = ((ppc_result_d >> rot_sh) | (ppc_result_d << (32 - rot_sh))); uint32_t insert_end = ppc_state.ppc_spr[0]; - for (int i = 0; i < 32; i++){ - if (insert_mask & (1 << i)){ + for (int i = 0; i < 32; i++) { + if (insert_mask & (1 << i)) { insert_end &= ~(1 << i); insert_end |= (insert_start & (1 << i)); } @@ -725,18 +725,18 @@ void power_sreqdot(){ ppc_store_result_rega(); } -void power_sriq(){ +void power_sriq() { ppc_grab_regssa(); uint32_t insert_mask = 0; unsigned rot_sh = (ppc_cur_instruction >> 11) & 31; - for (uint32_t i = 31; i > rot_sh; i--){ + for (uint32_t i = 31; i > rot_sh; i--) { insert_mask |= (1 << i); } - uint32_t insert_start= ((ppc_result_d >> rot_sh) | (ppc_result_d << (32 - rot_sh))); + uint32_t insert_start = ((ppc_result_d >> rot_sh) | (ppc_result_d << (32 - rot_sh))); uint32_t insert_end = ppc_state.ppc_spr[0]; - for (int i = 0; i < 32; i++){ - if (insert_mask & (1 << i)){ + for (int i = 0; i < 32; i++) { + if (insert_mask & (1 << i)) { insert_end &= ~(1 << i); insert_end |= (insert_start & (1 << i)); } @@ -747,18 +747,18 @@ void power_sriq(){ ppc_store_result_rega(); } -void power_sriqdot(){ +void power_sriqdot() { ppc_grab_regssa(); uint32_t insert_mask = 0; unsigned rot_sh = (ppc_cur_instruction >> 11) & 31; - for (uint32_t i = 31; i > rot_sh; i--){ + for (uint32_t i = 31; i > rot_sh; i--) { insert_mask |= (1 << i); } - uint32_t insert_start= ((ppc_result_d >> rot_sh) | (ppc_result_d << (32 - rot_sh))); + uint32_t insert_start = ((ppc_result_d >> rot_sh) | (ppc_result_d << (32 - rot_sh))); uint32_t insert_end = ppc_state.ppc_spr[0]; - for (int i = 0; i < 32; i++){ - if (insert_mask & (1 << i)){ + for (int i = 0; i < 32; i++) { + if (insert_mask & (1 << i)) { insert_end &= ~(1 << i); insert_end |= (insert_start & (1 << i)); } @@ -770,26 +770,26 @@ void power_sriqdot(){ ppc_store_result_rega(); } -void power_srliq(){ - printf("OOPS! Placeholder!!! \n"); +void power_srliq() { + printf("OOPS! Placeholder!!! \n"); } -void power_srliqdot(){ - printf("OOPS! Placeholder!!! \n"); +void power_srliqdot() { + printf("OOPS! Placeholder!!! \n"); } -void power_srlq(){ - printf("OOPS! Placeholder!!! \n"); +void power_srlq() { + printf("OOPS! Placeholder!!! \n"); } -void power_srlqdot(){ - printf("OOPS! Placeholder!!! \n"); +void power_srlqdot() { + printf("OOPS! Placeholder!!! \n"); } -void power_srq(){ - printf("OOPS! Placeholder!!! \n"); +void power_srq() { + printf("OOPS! Placeholder!!! \n"); } -void power_srqdot(){ - printf("OOPS! Placeholder!!! \n"); -} +void power_srqdot() { + printf("OOPS! Placeholder!!! \n"); +} \ No newline at end of file diff --git a/cpu/ppc/ppcemu.h b/cpu/ppc/ppcemu.h index 7133dc8..440f9f3 100644 --- a/cpu/ppc/ppcemu.h +++ b/cpu/ppc/ppcemu.h @@ -24,12 +24,12 @@ //Uncomment this to use Visual Studio built-in functions. //#define USE_VS_BUILTINS 1 -enum endian_switch {big_end = 0, little_end = 1}; +enum endian_switch { big_end = 0, little_end = 1 }; typedef void (*PPCOpcode)(void); union FPR_storage { - double dbl64_r; // double floating-point representation + double dbl64_r = 0.0; // double floating-point representation uint64_t int64_r; // double integer representation }; @@ -48,16 +48,16 @@ fpscr = FP Status and Condition Register **/ typedef struct struct_ppc_state { - FPR_storage ppc_fpr [32]; - uint32_t ppc_pc; //Referred as the CIA in the PPC manual - uint32_t ppc_gpr [32]; - uint32_t ppc_cr; - uint32_t ppc_fpscr; - uint32_t ppc_tbr [2]; - uint32_t ppc_spr [1024]; - uint32_t ppc_msr; - uint32_t ppc_sr [16]; - bool ppc_reserve; //reserve bit used for lwarx and stcwx + FPR_storage ppc_fpr[32] = { 0 }; + uint32_t ppc_pc = 0; //Referred as the CIA in the PPC manual + uint32_t ppc_gpr[32] = { 0 }; + uint32_t ppc_cr = 0; + uint32_t ppc_fpscr = 0; + uint32_t ppc_tbr[2] = { 0 }; + uint32_t ppc_spr[1024] = { 0 }; + uint32_t ppc_msr = 0; + uint32_t ppc_sr[16] = { 0 }; + bool ppc_reserve = 0; //reserve bit used for lwarx and stcwx } SetPRS; extern SetPRS ppc_state; @@ -101,7 +101,7 @@ SUPERVISOR MODEL 536 - 543 are the Data BAT registers **/ -extern uint32_t return_value; //used for loading from memory +extern uint64_t return_value; //used for loading from memory extern uint32_t opcode_value; //used for interpreting opcodes extern uint32_t ram_size_set; @@ -163,7 +163,7 @@ extern uint64_t ppc_result64_d; /* The precise end of a basic block. */ enum class BB_end_kind { - BB_NONE = 0, /* no basic block end is reached */ + BB_NONE = 0, /* no basic block end is reached */ BB_BRANCH = 1, /* a branch instruction is encountered */ BB_EXCEPTION, /* an exception is occured */ BB_RFI /* the rfi instruction is encountered */ @@ -181,7 +181,7 @@ enum class Except_Type { EXC_NO_FPU, EXC_DECR, EXC_SYSCALL = 12, - EXC_TRACE = 13 + EXC_TRACE = 13 }; //extern bool bb_end; @@ -265,13 +265,13 @@ void ppc_fp_changecrf1(); void ppc_tbr_update(); [[noreturn]] void ppc_exception_handler(Except_Type exception_type, - uint32_t srr1_bits); + uint32_t srr1_bits); //MEMORY DECLARATIONS -extern MemCtrlBase *mem_ctrl_instance; +extern MemCtrlBase* mem_ctrl_instance; -extern unsigned char * machine_sysram_mem; -extern unsigned char * machine_sysrom_mem; +extern unsigned char* machine_sysram_mem; +extern unsigned char* machine_sysrom_mem; //The functions used by the PowerPC processor extern void ppc_bcctr(); @@ -490,12 +490,15 @@ extern void ppc_xoris(); extern void ppc_lfs(); extern void ppc_lfsu(); -extern void ppc_lfsux(); extern void ppc_lfsx(); +extern void ppc_lfsux(); extern void ppc_lfd(); extern void ppc_lfdu(); +extern void ppc_lfdx(); +extern void ppc_lfdux(); extern void ppc_stfs(); extern void ppc_stfsu(); +extern void ppc_stfsx(); extern void ppc_stfsux(); extern void ppc_stfd(); extern void ppc_stfdu(); @@ -647,4 +650,4 @@ extern void ppc_exec(void); extern void ppc_exec_single(void); extern void ppc_exec_until(uint32_t goal_addr); -#endif /* PPCEMU_H */ +#endif /* PPCEMU_H */ \ No newline at end of file diff --git a/cpu/ppc/ppcexec.cpp b/cpu/ppc/ppcexec.cpp index 763b9bc..df42cea 100644 --- a/cpu/ppc/ppcexec.cpp +++ b/cpu/ppc/ppcexec.cpp @@ -104,10 +104,13 @@ static std::unordered_map SubOpcode31Grabber = { {1083, &power_maskirdot}, {1104, &ppc_subfo}, {1105, &ppc_subfodot}, {1132, &ppc_tlbsync}, {1134, &ppc_lfsux}, {1190, &ppc_mfsr}, {1194, &ppc_lswi}, - {1196, &ppc_sync}, {1232, &ppc_nego}, {1233, &ppc_negodot}, - {1238, &power_mulo}, {1239, &power_mulodot}, {1300, &ppc_addeo}, + {1196, &ppc_sync}, {1198, &ppc_lfdx}, + {1232, &ppc_nego}, {1233, &ppc_negodot}, + {1238, &power_mulo}, {1239, &power_mulodot}, + {1262, &ppc_lfdux}, {1300, &ppc_addeo}, {1301, &ppc_addeodot}, {1318, &ppc_mfsrin}, {1322, &ppc_stswx}, - {1324, &ppc_stwbrx}, {1328, &power_srq}, {1329, &power_srqdot}, + {1324, &ppc_stwbrx}, {1326, &ppc_stfsx}, + {1328, &power_srq}, {1329, &power_srqdot}, {1330, &power_sre}, {1331, &power_sredot}, {1390, &ppc_stfsux}, {1392, &power_sriq}, {1393, &power_sriqdot}, {1428, &ppc_addzeo}, {1429, &ppc_addzeodot}, {1450, &ppc_stswi}, {1454, &ppc_stfdx}, @@ -270,7 +273,7 @@ static std::unordered_map SubOpcode63Grabber = { { 239, &ppc_fseldot}, { 242, &ppc_fmult}, { 243, &ppc_fmultdot}, { 248, &ppc_fmsub}, { 249, &ppc_fmsubdot}, { 250, &ppc_fmadd}, { 251, &ppc_fmadddot}, { 252, &ppc_fnmsub}, { 253, &ppc_fnmsubdot}, - { 254, &ppc_fnmadd}, { 255, &ppc_fnmadddot}, { 268, &ppc_mtfsfi}, + { 254, &ppc_fnmadd}, { 255, &ppc_fnmadddot}, { 268, &ppc_mtfsfi}, { 272, &ppc_fnabs}, { 273, &ppc_fnabsdot}, { 302, &ppc_fsel}, { 303, &ppc_fseldot}, { 306, &ppc_fmult}, { 307, &ppc_fmultdot}, { 312, &ppc_fmsub}, @@ -391,20 +394,20 @@ static std::unordered_map SubOpcode63Grabber = { /** Opcode decoding functions. */ -void ppc_illegalop(){ +void ppc_illegalop() { uint8_t illegal_code = ppc_cur_instruction >> 26; - uint32_t grab_it = (uint32_t) illegal_code; + uint32_t grab_it = (uint32_t)illegal_code; printf("Illegal opcode reported: %d Report this! \n", grab_it); exit(-1); } -void ppc_illegalsubop31(){ +void ppc_illegalsubop31() { uint16_t illegal_subcode = ppc_cur_instruction & 2047; - uint32_t grab_it = (uint32_t) illegal_subcode; + uint32_t grab_it = (uint32_t)illegal_subcode; printf("Illegal subopcode for 31 reported: %d Report this! \n", grab_it); } -void ppc_opcode4(){ +void ppc_opcode4() { printf("Reading from Opcode 4 table \n"); uint8_t subop_grab = ppc_cur_instruction & 3; uint32_t regrab = (uint32_t)subop_grab; @@ -412,83 +415,83 @@ void ppc_opcode4(){ exit(0); } -void ppc_opcode16(){ +void ppc_opcode16() { SubOpcode16Grabber[ppc_cur_instruction & 3](); } -void ppc_opcode18(){ +void ppc_opcode18() { SubOpcode18Grabber[ppc_cur_instruction & 3](); } -void ppc_opcode19(){ +void ppc_opcode19() { uint16_t subop_grab = ppc_cur_instruction & 2047; - #ifdef EXHAUSTIVE_DEBUG +#ifdef EXHAUSTIVE_DEBUG uint32_t regrab = (uint32_t)subop_grab; printf("Executing Opcode 19 table supopcode entry %d \n", regrab); - if (SubOpcode19Grabber.count(subop_grab) == 1){ + if (SubOpcode19Grabber.count(subop_grab) == 1) { SubOpcode19Grabber[subop_grab](); } - else{ + else { std::cout << "ILLEGAL SUBOPCODE: " << subop_grab << std::endl; ppc_exception_handler(Except_Type::EXC_PROGRAM, 0x80000); } - #else +#else SubOpcode19Grabber[subop_grab](); - #endif // EXHAUSTIVE_DEBUG +#endif // EXHAUSTIVE_DEBUG } -void ppc_opcode31(){ +void ppc_opcode31() { uint16_t subop_grab = ppc_cur_instruction & 2047; - #ifdef EXHAUSTIVE_DEBUG +#ifdef EXHAUSTIVE_DEBUG uint32_t regrab = (uint32_t)subop_grab; printf("Executing Opcode 31 table supopcode entry %d \n", regrab); - if (SubOpcode31Grabber.count(subop_grab) == 1){ + if (SubOpcode31Grabber.count(subop_grab) == 1) { SubOpcode31Grabber[subop_grab](); } - else{ + else { std::cout << "ILLEGAL SUBOPCODE: " << subop_grab << std::endl; ppc_exception_handler(Except_Type::EXC_PROGRAM, 0x80000); } - #else +#else SubOpcode31Grabber[subop_grab](); - #endif // EXHAUSTIVE_DEBUG +#endif // EXHAUSTIVE_DEBUG } -void ppc_opcode59(){ +void ppc_opcode59() { uint16_t subop_grab = ppc_cur_instruction & 2047; - #ifdef EXHAUSTIVE_DEBUG +#ifdef EXHAUSTIVE_DEBUG uint32_t regrab = (uint32_t)subop_grab; printf("Executing Opcode 59 table supopcode entry %d \n", regrab); - if (SubOpcode59Grabber.count(subop_grab) == 1){ + if (SubOpcode59Grabber.count(subop_grab) == 1) { SubOpcode59Grabber[subop_grab](); } - else{ + else { std::cout << "ILLEGAL SUBOPCODE: " << subop_grab << std::endl; ppc_exception_handler(Except_Type::EXC_PROGRAM, 0x80000); } - #else +#else SubOpcode59Grabber[subop_grab](); - #endif // EXHAUSTIVE_DEBUG +#endif // EXHAUSTIVE_DEBUG } -void ppc_opcode63(){ +void ppc_opcode63() { uint16_t subop_grab = ppc_cur_instruction & 2047; - #ifdef EXHAUSTIVE_DEBUG +#ifdef EXHAUSTIVE_DEBUG uint32_t regrab = (uint32_t)subop_grab; std::cout << "Executing Opcode 63 table subopcode entry " << regrab << std::endl; - if (SubOpcode63Grabber.count(subop_grab) == 1){ + if (SubOpcode63Grabber.count(subop_grab) == 1) { SubOpcode63Grabber[subop_grab](); } - else{ + else { std::cout << "ILLEGAL SUBOPCODE: " << subop_grab << std::endl; ppc_exception_handler(Except_Type::EXC_PROGRAM, 0x80000); } - #else +#else SubOpcode63Grabber[subop_grab](); - #endif // EXHAUSTIVE_DEBUG +#endif // EXHAUSTIVE_DEBUG } -void ppc_main_opcode(){ +void ppc_main_opcode() { //Grab the main opcode uint8_t ppc_mainop = (ppc_cur_instruction >> 26) & 63; OpcodeGrabber[ppc_mainop](); @@ -498,23 +501,23 @@ void ppc_main_opcode(){ void ppc_tbr_update() { clock_t clock_test_current = clock(); - uint32_t test_clock = ((uint32_t) (clock_test_current - clock_test_begin)) / CLOCKS_PER_SEC; - if (test_clock){ - if (ppc_state.ppc_tbr[0] != 0xFFFFFFFF){ + uint32_t test_clock = ((uint32_t)(clock_test_current - clock_test_begin)) / CLOCKS_PER_SEC; + if (test_clock) { + if (ppc_state.ppc_tbr[0] != 0xFFFFFFFF) { ppc_state.ppc_tbr[0]++; } - else{ + else { ppc_state.ppc_tbr[0] = 0; - if (ppc_state.ppc_tbr[1] !=0xFFFFFFFF){ + if (ppc_state.ppc_tbr[1] != 0xFFFFFFFF) { ppc_state.ppc_tbr[1]++; } - else{ + else { ppc_state.ppc_tbr[1] = 0; } } clock_test_begin = clock(); //Placeholder Decrementing Code - if(ppc_state.ppc_spr[22] > 0){ + if (ppc_state.ppc_spr[22] > 0) { ppc_state.ppc_spr[22]--; } } @@ -524,22 +527,22 @@ void ppc_tbr_update() #if 0 void ppc_exec() { - while (power_on){ + while (power_on) { //printf("PowerPC Address: %x \n", ppc_state.ppc_pc); quickinstruction_translate(ppc_state.ppc_pc); ppc_main_opcode(); - if (grab_branch & !grab_exception){ + if (grab_branch & !grab_exception) { ppc_state.ppc_pc = ppc_next_instruction_address; grab_branch = 0; ppc_tbr_update(); } - else if (grab_return | grab_exception){ + else if (grab_return | grab_exception) { ppc_state.ppc_pc = ppc_next_instruction_address; grab_exception = 0; grab_return = 0; ppc_tbr_update(); } - else{ + else { ppc_state.ppc_pc += 4; ppc_tbr_update(); } @@ -549,7 +552,7 @@ void ppc_exec() void ppc_exec() { uint32_t bb_start_la, page_start; - uint8_t *pc_real; + uint8_t* pc_real; /* start new basic block */ bb_start_la = ppc_state.ppc_pc; @@ -581,13 +584,15 @@ again: if ((ppc_next_instruction_address & 0xFFFFF000) != page_start) { page_start = bb_start_la & 0xFFFFF000; pc_real = quickinstruction_translate(bb_start_la); - } else { + } + else { pc_real += (int)bb_start_la - (int)ppc_state.ppc_pc; ppc_set_cur_instruction(pc_real); } ppc_state.ppc_pc = bb_start_la; bb_kind = BB_end_kind::BB_NONE; - } else { + } + else { ppc_state.ppc_pc += 4; pc_real += 4; ppc_set_cur_instruction(pc_real); @@ -634,7 +639,8 @@ void ppc_exec_single() if (bb_kind != BB_end_kind::BB_NONE) { ppc_state.ppc_pc = ppc_next_instruction_address; bb_kind = BB_end_kind::BB_NONE; - } else { + } + else { ppc_state.ppc_pc += 4; } timebase_counter += 1; @@ -670,7 +676,7 @@ void ppc_exec_until(uint32_t goal_addr) void ppc_exec_until(uint32_t goal_addr) { uint32_t bb_start_la, page_start; - uint8_t *pc_real; + uint8_t* pc_real; /* start new basic block */ bb_start_la = ppc_state.ppc_pc; @@ -702,13 +708,15 @@ again: if ((ppc_next_instruction_address & 0xFFFFF000) != page_start) { page_start = bb_start_la & 0xFFFFF000; pc_real = quickinstruction_translate(bb_start_la); - } else { + } + else { pc_real += (int)bb_start_la - (int)ppc_state.ppc_pc; ppc_set_cur_instruction(pc_real); } ppc_state.ppc_pc = bb_start_la; bb_kind = BB_end_kind::BB_NONE; - } else { + } + else { ppc_state.ppc_pc += 4; pc_real += 4; ppc_set_cur_instruction(pc_real); @@ -721,4 +729,4 @@ void ppc_init() { clock_test_begin = clock(); timebase_counter = 0; -} +} \ No newline at end of file diff --git a/cpu/ppc/ppcfpopcodes.cpp b/cpu/ppc/ppcfpopcodes.cpp index 50725a1..6c2217e 100644 --- a/cpu/ppc/ppcfpopcodes.cpp +++ b/cpu/ppc/ppcfpopcodes.cpp @@ -242,6 +242,8 @@ bool ppc_confirm_inf_nan(uint64_t input_a, uint64_t input_b, bool is_single, uin return true; } break; + default: + return false; } } else { @@ -280,8 +282,11 @@ bool ppc_confirm_inf_nan(uint64_t input_a, uint64_t input_b, bool is_single, uin return true; } break; + default: + return false; } } + return false; } @@ -773,7 +778,7 @@ void ppc_fsqrtsdot() { void ppc_frsqrte() { ppc_grab_regsfpdb(false); double testd2 = (double)ppc_result64_b; - for (int i = 0; i < 10; i++){ + for (int i = 0; i < 10; i++) { testd2 = testd2 * (1.5 - (testd2 * .5) * testd2 * testd2); } ppc_dblresult64_d = testd2; @@ -796,8 +801,8 @@ void ppc_frsqrtedot() { void ppc_frsp() { ppc_grab_regsfpdb(false); double testd2 = (double)ppc_result64_b; - float testf2 = (float) testd2; - ppc_result64_d = (double) testf2; + float testf2 = (float)testd2; + ppc_dblresult64_d = (double)testf2; ppc_store_dfpresult(false); } @@ -805,7 +810,7 @@ void ppc_frspdot() { ppc_grab_regsfpdb(false); double testd2 = (double)ppc_result64_b; float testf2 = (float)testd2; - ppc_result64_d = (double)testf2; + ppc_dblresult64_d = (double)testf2; ppc_store_dfpresult(false); ppc_changecrf1(); } @@ -829,45 +834,43 @@ void ppc_fresdot() { void ppc_fctiw() { //PLACEHOLDER! - /*ppc_grab_regsfpdiab(); - double testd1 = (double)ppc_result64_b; + ppc_grab_regsfpdiab(false); - ppc_result_d = (uint32_t)(testd1); + ppc_result_d = (uint32_t)(ppc_dblresult64_d); ppc_store_result_regd(); - ppc_changecrf1(); */ } void ppc_fctiwdot() { //PLACEHOLDER! - /*ppc_grab_regsfpdiab(); - double testd1 = (double)ppc_result64_b; + ppc_grab_regsfpdiab(false); - ppc_result_d = (uint32_t)(testd1); + ppc_result_d = (uint32_t)(ppc_dblresult64_d); - ppc_store_result_regd(); */ + ppc_store_result_regd(); + ppc_changecrf1(); } void ppc_fctiwz() { //PLACEHOLDER! - /*ppc_grab_regsfpdiab(); + ppc_grab_regsfpdiab(false); double testd1 = (double)ppc_result64_a; ppc_result_d = (uint32_t)(testd1); ppc_store_result_regd(); - ppc_changecrf1(); */ } void ppc_fctiwzdot() { //PLACEHOLDER! - /* - ppc_grab_regsfpdiab(); + + ppc_grab_regsfpdiab(false); double testd1 = (double)ppc_result64_a; ppc_result_d = (uint32_t)(testd1); - ppc_store_result_regd();*/ + ppc_store_result_regd(); + ppc_changecrf1(); } //Floating Point Store and Load @@ -876,7 +879,7 @@ void ppc_lfs() { ppc_grab_regsfpdia(true); ppc_effective_address = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF)); ppc_effective_address += (reg_a > 0) ? ppc_result_a : 0; - address_quickgrab_translate(ppc_effective_address, 4); + address_grab32bit_translate(ppc_effective_address); ppc_result64_d = (uint64_t)return_value; ppc_store_dfpresult(true); } @@ -884,132 +887,175 @@ void ppc_lfs() { void ppc_lfsu() { ppc_grab_regsfpdia(true); - ppc_effective_address = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF)); - ppc_effective_address += (reg_a > 0) ? ppc_result_a : 0; - address_quickgrab_translate(ppc_effective_address, 4); - ppc_result64_d = (uint64_t)return_value; - ppc_result_a = ppc_effective_address; - ppc_store_dfpresult(true); - ppc_store_result_rega(); + if (reg_a == 0) { + ppc_effective_address = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF)); + ppc_effective_address += (reg_a > 0) ? ppc_result_a : 0; + address_grab32bit_translate(ppc_effective_address); + ppc_result64_d = (uint64_t)return_value; + ppc_result_a = ppc_effective_address; + ppc_store_dfpresult(true); + ppc_store_result_rega(); + } + else { + ppc_exception_handler(Except_Type::EXC_PROGRAM, 0x20000); + } } void ppc_lfsx() { ppc_grab_regsfpdiab(true); ppc_effective_address = (reg_a == 0) ? ppc_result_b : ppc_result_a + ppc_result_b; - address_quickgrab_translate(ppc_effective_address, 4); + address_grab32bit_translate(ppc_effective_address); ppc_result64_d = (uint64_t)return_value; ppc_store_dfpresult(true); } - void ppc_lfsux() { ppc_grab_regsfpdiab(true); - ppc_effective_address = (reg_a == 0) ? ppc_result_b : ppc_result_a + ppc_result_b; - address_quickgrab_translate(ppc_effective_address, 4); - ppc_result64_d = (uint64_t)return_value; - ppc_result_a = ppc_effective_address; - ppc_store_dfpresult(true); - ppc_store_result_rega(); + if (reg_a == 0) { + ppc_effective_address = ppc_result_a + ppc_result_b; + address_grab32bit_translate(ppc_effective_address); + ppc_result64_d = (uint64_t)return_value; + ppc_result_a = ppc_effective_address; + ppc_store_dfpresult(true); + ppc_store_result_rega(); + } + else { + ppc_exception_handler(Except_Type::EXC_PROGRAM, 0x20000); + } } void ppc_lfd() { ppc_grab_regsfpdia(true); ppc_effective_address = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF)); ppc_effective_address += (reg_a > 0) ? ppc_result_a : 0; - address_quickgrab_translate(ppc_effective_address, 4); - uint64_t combine_result1 = (uint64_t)(return_value); - address_quickgrab_translate((ppc_effective_address + 4), 4); - uint64_t combine_result2 = (uint64_t)(return_value); - ppc_result64_d = (combine_result1 << 32) | combine_result2; + address_grab64bit_translate(ppc_effective_address); + ppc_result64_d = return_value; ppc_store_dfpresult(true); } - void ppc_lfdu() { ppc_grab_regsfpdia(true); - ppc_effective_address = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF)); - ppc_effective_address += (reg_a > 0) ? ppc_result_a : 0; - address_quickgrab_translate(ppc_effective_address, 4); - uint64_t combine_result1 = (uint64_t)(return_value); - address_quickgrab_translate((ppc_effective_address + 4), 4); - uint64_t combine_result2 = (uint64_t)(return_value); - ppc_result64_d = (combine_result1 << 32) | combine_result2; + if (reg_a == 0) { + ppc_effective_address = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF)); + ppc_effective_address += ppc_result_a; + address_grab64bit_translate(ppc_effective_address); + ppc_result64_d = return_value; + ppc_store_dfpresult(true); + ppc_result_a = ppc_effective_address; + ppc_store_result_rega(); + } + else { + ppc_exception_handler(Except_Type::EXC_PROGRAM, 0x20000); + } +} + +void ppc_lfdx() { + ppc_grab_regsfpdia(true); + ppc_effective_address += (reg_a > 0) ? ppc_result_a + ppc_result_b : ppc_result_b; + address_grab64bit_translate(ppc_effective_address); + ppc_result64_d = return_value; ppc_store_dfpresult(true); - ppc_result_a = ppc_effective_address; - ppc_store_result_rega(); +} + +void ppc_lfdux() { + ppc_grab_regsfpdiab(true); + if (reg_a == 0) { + ppc_effective_address = ppc_result_a + ppc_result_b; + address_grab64bit_translate(ppc_effective_address); + ppc_result64_d = return_value; + ppc_store_dfpresult(true); + ppc_result_a = ppc_effective_address; + ppc_store_result_rega(); + } + else { + ppc_exception_handler(Except_Type::EXC_PROGRAM, 0x20000); + } } void ppc_stfs() { ppc_grab_regsfpsia(true); ppc_effective_address = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF)); ppc_effective_address += (reg_a > 0) ? ppc_result_a : 0; - address_quickinsert_translate(uint32_t(ppc_state.ppc_fpr[reg_s].int64_r), ppc_effective_address, 4); + address_insert32bit_translate(uint32_t(ppc_state.ppc_fpr[reg_s].int64_r), ppc_effective_address); } void ppc_stfsu() { ppc_grab_regsfpsia(true); - ppc_effective_address = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF)); - ppc_effective_address += (reg_a > 0) ? ppc_result_a : 0; - address_quickinsert_translate(uint32_t(ppc_state.ppc_fpr[reg_s].int64_r), ppc_effective_address, 4); - ppc_result_a = ppc_effective_address; - ppc_store_result_rega(); + if (reg_a == 0) { + ppc_effective_address = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF)); + ppc_effective_address += ppc_result_a; + address_insert32bit_translate(uint32_t(ppc_state.ppc_fpr[reg_s].int64_r), ppc_effective_address); + ppc_result_a = ppc_effective_address; + ppc_store_result_rega(); + } + else { + ppc_exception_handler(Except_Type::EXC_PROGRAM, 0x20000); + } +} + +void ppc_stfsx() { + ppc_grab_regsfpsiab(true); + ppc_effective_address = (reg_a == 0) ? ppc_result_b : ppc_result_a + ppc_result_b; + address_insert32bit_translate(uint32_t(ppc_state.ppc_fpr[reg_s].int64_r), ppc_effective_address); } void ppc_stfsux() { ppc_grab_regsfpsiab(true); - ppc_effective_address = (reg_a == 0) ? ppc_result_b : ppc_result_a + ppc_result_b; - address_quickinsert_translate(uint32_t(ppc_state.ppc_fpr[reg_s].int64_r), ppc_effective_address, 4); - ppc_result_a = ppc_effective_address; - ppc_store_result_rega(); + if (reg_a == 0) { + ppc_effective_address = ppc_result_a + ppc_result_b; + address_insert32bit_translate(uint32_t(ppc_state.ppc_fpr[reg_s].int64_r), ppc_effective_address); + ppc_result_a = ppc_effective_address; + ppc_store_result_rega(); + } + else { + ppc_exception_handler(Except_Type::EXC_PROGRAM, 0x20000); + } } void ppc_stfd() { ppc_grab_regsfpsia(true); ppc_effective_address = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF)); ppc_effective_address += (reg_a > 0) ? ppc_result_a : 0; - uint32_t split_result1 = (uint32_t)(ppc_state.ppc_fpr[reg_s].int64_r >> 32); - address_quickinsert_translate(split_result1, ppc_effective_address, 4); - uint32_t split_result2 = (uint32_t)(ppc_state.ppc_fpr[reg_s].int64_r); - address_quickinsert_translate(split_result2, ppc_effective_address, 4); + address_insert64bit_translate(ppc_state.ppc_fpr[reg_s].int64_r, ppc_effective_address); } void ppc_stfdu() { ppc_grab_regsfpsia(true); - ppc_effective_address = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF)); - ppc_effective_address += (reg_a > 0) ? ppc_result_a : 0; - uint32_t split_result1 = (uint32_t)(ppc_state.ppc_fpr[reg_s].int64_r >> 32); - address_quickinsert_translate(split_result1, ppc_effective_address, 4); - uint32_t split_result2 = (uint32_t)(ppc_state.ppc_fpr[reg_s].int64_r); - address_quickinsert_translate(split_result2, ppc_effective_address, 4); - ppc_result_a = ppc_effective_address; - ppc_store_result_rega(); + if (reg_a == 0) { + ppc_effective_address = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF)); + ppc_effective_address += ppc_result_a; + address_insert64bit_translate(ppc_state.ppc_fpr[reg_s].int64_r, ppc_effective_address); + ppc_result_a = ppc_effective_address; + ppc_store_result_rega(); + } + else { + ppc_exception_handler(Except_Type::EXC_PROGRAM, 0x20000); + } } void ppc_stfdx() { ppc_grab_regsfpsiab(true); ppc_effective_address = (reg_a == 0) ? ppc_result_b : ppc_result_a + ppc_result_b; - uint32_t split_result1 = (uint32_t)(ppc_state.ppc_fpr[reg_s].int64_r >> 32); - address_quickinsert_translate(split_result1, ppc_effective_address, 4); - uint32_t split_result2 = (uint32_t)(ppc_state.ppc_fpr[reg_s].int64_r); - address_quickinsert_translate(split_result2, ppc_effective_address, 4); + address_insert64bit_translate(ppc_state.ppc_fpr[reg_s].int64_r, ppc_effective_address); } void ppc_stfdux() { ppc_grab_regsfpsiab(true); - ppc_effective_address = (reg_a == 0) ? ppc_result_b : ppc_result_a + ppc_result_b; - uint32_t split_result1 = (uint32_t)(ppc_state.ppc_fpr[reg_s].int64_r >> 32); - address_quickinsert_translate(split_result1, ppc_effective_address, 4); - uint32_t split_result2 = (uint32_t)(ppc_state.ppc_fpr[reg_s].int64_r); - address_quickinsert_translate(split_result2, ppc_effective_address, 4); - ppc_result_a = ppc_effective_address; - ppc_store_result_rega(); + if (reg_a == 0) { + ppc_effective_address = ppc_result_a + ppc_result_b; + address_insert64bit_translate(ppc_state.ppc_fpr[reg_s].int64_r, ppc_effective_address); + ppc_result_a = ppc_effective_address; + ppc_store_result_rega(); + } + else { + ppc_exception_handler(Except_Type::EXC_PROGRAM, 0x20000); + } } void ppc_stfiwx() { ppc_grab_regsfpsiab(true); ppc_effective_address = (reg_a == 0) ? ppc_result_b : ppc_result_a + ppc_result_b; - uint32_t split_result1 = (uint32_t)(ppc_state.ppc_fpr[reg_s].int64_r); - address_quickinsert_translate(split_result1, ppc_effective_address, 4); + address_insert32bit_translate((uint32_t)(ppc_state.ppc_fpr[reg_s].int64_r), ppc_effective_address); } //Floating Point Register Transfer @@ -1193,4 +1239,4 @@ void ppc_fcmpu() { if ((db_test_a == snan) || (db_test_b == snan)) { ppc_state.ppc_fpscr |= 0x1000000; } -} +} \ No newline at end of file diff --git a/cpu/ppc/ppcmmu.cpp b/cpu/ppc/ppcmmu.cpp index ce80c36..4b83525 100644 --- a/cpu/ppc/ppcmmu.cpp +++ b/cpu/ppc/ppcmmu.cpp @@ -29,77 +29,97 @@ #include "devices/mpc106.h" -/** PowerPC-style MMU BAT arrays (NULL initialization isn't prescribed). */ -PPC_BAT_entry ibat_array[4] = {{0}}; -PPC_BAT_entry dbat_array[4] = {{0}}; + /** PowerPC-style MMU BAT arrays (NULL initialization isn't prescribed). */ +PPC_BAT_entry ibat_array[4] = { {0} }; +PPC_BAT_entry dbat_array[4] = { {0} }; -void ppc_set_cur_instruction(const uint8_t *ptr) +void ppc_set_cur_instruction(const uint8_t* ptr) { ppc_cur_instruction = READ_DWORD_BE_A(ptr); } -static inline void ppc_set_return_val(const uint8_t *ptr, int num_size) -{ - //Put the final result in return_value here - //This is what gets put back into the register - - if (num_size == 1) { // BYTE - return_value = ptr[0]; +static inline void ppc_set_retval_16bit(const uint8_t* ptr) { + if (ppc_state.ppc_msr & 1) { + return_value = READ_WORD_LE_A(ptr); } - - if (ppc_state.ppc_msr & 1) { /* little-endian byte ordering */ - if (num_size == 2) { // WORD - return_value = READ_WORD_LE_A(ptr); - } - else if (num_size == 4) { // DWORD - return_value = READ_DWORD_LE_A(ptr); - } - } else { /* big-endian byte ordering */ - if (num_size == 2) { // WORD - return_value = READ_WORD_BE_A(ptr); - } - else if (num_size == 4) { // DWORD - return_value = READ_DWORD_BE_A(ptr); - } + else { + return_value = READ_WORD_BE_A(ptr); } } -static inline void ppc_memstore_value(unsigned char *ptr, uint32_t value, - uint32_t offset, int num_size) -{ - if (ppc_state.ppc_msr & 1) { /* little-endian byte ordering */ - if (num_size >= 1) { // BYTE - ptr[offset] = value & 0xFF; - } - if (num_size >= 2) { // WORD - ptr[offset+1] = (value >> 8) & 0xFF; - } - if (num_size == 4) { // DWORD - ptr[offset+2] = (value >> 16) & 0xFF; - ptr[offset+3] = (value >> 24) & 0xFF; - } - } else { /* big-endian byte ordering */ - if (num_size == 1) { // BYTE - ptr[offset] = value & 0xFF; - } - else if (num_size == 2) { // WORD - ptr[offset] = (value >> 8) & 0xFF; - ptr[offset+1] = value & 0xFF; - } - else if (num_size == 4) { // DWORD - ptr[offset] = (value >> 24) & 0xFF; - ptr[offset+1] = (value >> 16) & 0xFF; - ptr[offset+2] = (value >> 8) & 0xFF; - ptr[offset+3] = value & 0xFF; - } +static inline void ppc_set_retval_32bit(const uint8_t* ptr) { + if (ppc_state.ppc_msr & 1) { + return_value = READ_DWORD_LE_A(ptr); + } + else { + return_value = READ_DWORD_BE_A(ptr); } } +static inline void ppc_set_retval_64bit(const uint8_t* ptr) { + if (ppc_state.ppc_msr & 1) { + return_value = READ_QWORD_LE_A(ptr); + } + else { + return_value = READ_QWORD_BE_A(ptr); + } +} + +static inline void ppc_memstore_16bit(unsigned char* ptr, uint16_t value, uint32_t offset) { + if (ppc_state.ppc_msr & 1) { /* little-endian byte ordering */ + ptr[offset] = value & 0xFF; + ptr[offset + 1] = (value >> 8) & 0xFF; + } + else { /* big-endian byte ordering */ + ptr[offset] = (value >> 8) & 0xFF; + ptr[offset + 1] = value & 0xFF; + } +} + +static inline void ppc_memstore_32bit(unsigned char* ptr, uint32_t value, uint32_t offset) { + if (ppc_state.ppc_msr & 1) { /* little-endian byte ordering */ + ptr[offset] = value & 0xFF; + ptr[offset + 1] = (value >> 8) & 0xFF; + ptr[offset + 2] = (value >> 16) & 0xFF; + ptr[offset + 3] = (value >> 24) & 0xFF; + } + else { /* big-endian byte ordering */ + ptr[offset] = (value >> 24) & 0xFF; + ptr[offset + 1] = (value >> 16) & 0xFF; + ptr[offset + 2] = (value >> 8) & 0xFF; + ptr[offset + 3] = value & 0xFF; + } +} + +static inline void ppc_memstore_64bit(unsigned char* ptr, uint64_t value, uint32_t offset) { + if (ppc_state.ppc_msr & 1) { /* little-endian byte ordering */ + ptr[offset] = value & 0xFF; + ptr[offset + 1] = (value >> 8) & 0xFF; + ptr[offset + 2] = (value >> 16) & 0xFF; + ptr[offset + 3] = (value >> 24) & 0xFF; + ptr[offset + 4] = (value >> 32) & 0xFF; + ptr[offset + 5] = (value >> 40) & 0xFF; + ptr[offset + 6] = (value >> 48) & 0xFF; + ptr[offset + 7] = (value >> 56) & 0xFF; + } + else { /* big-endian byte ordering */ + ptr[offset] = (value >> 56) & 0xFF; + ptr[offset + 1] = (value >> 48) & 0xFF; + ptr[offset + 2] = (value >> 40) & 0xFF; + ptr[offset + 3] = (value >> 32) & 0xFF; + ptr[offset + 4] = (value >> 24) & 0xFF; + ptr[offset + 5] = (value >> 16) & 0xFF; + ptr[offset + 6] = (value >> 8) & 0xFF; + ptr[offset + 7] = value & 0xFF; + } +} + + void ibat_update(uint32_t bat_reg) { int upper_reg_num; uint32_t bl, lo_mask; - PPC_BAT_entry *bat_entry; + PPC_BAT_entry* bat_entry; upper_reg_num = bat_reg & 0xFFFFFFFE; @@ -108,11 +128,11 @@ void ibat_update(uint32_t bat_reg) bl = (ppc_state.ppc_spr[upper_reg_num] >> 2) & 0x7FF; lo_mask = (bl << 17) | 0x1FFFF; - bat_entry->access = ppc_state.ppc_spr[upper_reg_num] & 3; - bat_entry->prot = ppc_state.ppc_spr[upper_reg_num + 1] & 3; + bat_entry->access = ppc_state.ppc_spr[upper_reg_num] & 3; + bat_entry->prot = ppc_state.ppc_spr[upper_reg_num + 1] & 3; bat_entry->lo_mask = lo_mask; bat_entry->phys_hi = ppc_state.ppc_spr[upper_reg_num + 1] & ~lo_mask; - bat_entry->bepi = ppc_state.ppc_spr[upper_reg_num] & ~lo_mask; + bat_entry->bepi = ppc_state.ppc_spr[upper_reg_num] & ~lo_mask; } } @@ -120,7 +140,7 @@ void dbat_update(uint32_t bat_reg) { int upper_reg_num; uint32_t bl, lo_mask; - PPC_BAT_entry *bat_entry; + PPC_BAT_entry* bat_entry; upper_reg_num = bat_reg & 0xFFFFFFFE; @@ -129,20 +149,20 @@ void dbat_update(uint32_t bat_reg) bl = (ppc_state.ppc_spr[upper_reg_num] >> 2) & 0x7FF; lo_mask = (bl << 17) | 0x1FFFF; - bat_entry->access = ppc_state.ppc_spr[upper_reg_num] & 3; - bat_entry->prot = ppc_state.ppc_spr[upper_reg_num + 1] & 3; + bat_entry->access = ppc_state.ppc_spr[upper_reg_num] & 3; + bat_entry->prot = ppc_state.ppc_spr[upper_reg_num + 1] & 3; bat_entry->lo_mask = lo_mask; bat_entry->phys_hi = ppc_state.ppc_spr[upper_reg_num + 1] & ~lo_mask; - bat_entry->bepi = ppc_state.ppc_spr[upper_reg_num] & ~lo_mask; + bat_entry->bepi = ppc_state.ppc_spr[upper_reg_num] & ~lo_mask; } } /* remember page table memory region for quicker translation. */ -uint32_t page_table_pa_start = 0; -uint32_t page_table_pa_end = 0; -unsigned char *page_table_ptr = 0; +uint32_t page_table_pa_start = 0; +uint32_t page_table_pa_end = 0; +unsigned char* page_table_ptr = 0; -static inline uint8_t *calc_pteg_addr(uint32_t hash) +static inline uint8_t* calc_pteg_addr(uint32_t hash) { uint32_t sdr1_val, pteg_addr; @@ -150,31 +170,33 @@ static inline uint8_t *calc_pteg_addr(uint32_t hash) pteg_addr = sdr1_val & 0xFE000000; pteg_addr |= (sdr1_val & 0x01FF0000) | - (((sdr1_val & 0x1FF) << 16) & ((hash & 0x7FC00) << 6)); + (((sdr1_val & 0x1FF) << 16) & ((hash & 0x7FC00) << 6)); pteg_addr |= (hash & 0x3FF) << 6; if (pteg_addr >= page_table_pa_start && pteg_addr <= page_table_pa_end) { return page_table_ptr + (pteg_addr - page_table_pa_start); - } else { - AddressMapEntry *entry = mem_ctrl_instance->find_range(pteg_addr); + } + else { + AddressMapEntry* entry = mem_ctrl_instance->find_range(pteg_addr); if (entry && entry->type & (RT_ROM | RT_RAM)) { page_table_pa_start = entry->start; - page_table_pa_end = entry->end; - page_table_ptr = entry->mem_ptr; + page_table_pa_end = entry->end; + page_table_ptr = entry->mem_ptr; return page_table_ptr + (pteg_addr - page_table_pa_start); - } else { + } + else { printf("SOS: no page table region was found at %08X!\n", pteg_addr); exit(-1); // FIXME: ugly error handling, must be the proper exception! } } } -static bool search_pteg(uint8_t *pteg_addr, uint8_t **ret_pte_addr, - uint32_t vsid, uint16_t page_index, uint8_t pteg_num) +static bool search_pteg(uint8_t* pteg_addr, uint8_t** ret_pte_addr, + uint32_t vsid, uint16_t page_index, uint8_t pteg_num) { /* construct PTE matching word */ uint32_t pte_check = 0x80000000 | (vsid << 7) | (pteg_num << 6) | - (page_index >> 10); + (page_index >> 10); #ifdef MMU_INTEGRITY_CHECKS /* PTEG integrity check that ensures that all matching PTEs have @@ -189,7 +211,8 @@ static bool search_pteg(uint8_t *pteg_addr, uint8_t **ret_pte_addr, printf("Multiple PTEs with different RPN/WIMG/PP found!\n"); exit(-1); } - } else { + } + else { /* isolate RPN, WIMG and PP fields */ pte_word2_check = READ_DWORD_BE_A(pteg_addr) & 0xFFFFF07B; *ret_pte_addr = pteg_addr; @@ -209,11 +232,11 @@ static bool search_pteg(uint8_t *pteg_addr, uint8_t **ret_pte_addr, } static uint32_t page_address_translate(uint32_t la, bool is_instr_fetch, - unsigned msr_pr, int is_write) + unsigned msr_pr, int is_write) { uint32_t sr_val, page_index, pteg_hash1, vsid, pte_word2; unsigned key, pp; - uint8_t *pte_addr; + uint8_t* pte_addr; sr_val = ppc_state.ppc_sr[(la >> 28) & 0x0F]; if (sr_val & 0x80000000) { @@ -234,7 +257,8 @@ static uint32_t page_address_translate(uint32_t la, bool is_instr_fetch, if (!search_pteg(calc_pteg_addr(~pteg_hash1), &pte_addr, vsid, page_index, 1)) { if (is_instr_fetch) { ppc_exception_handler(Except_Type::EXC_ISI, 0x40000000); - } else { + } + else { ppc_state.ppc_spr[18] = 0x40000000 | (is_write << 25); ppc_state.ppc_spr[19] = la; ppc_exception_handler(Except_Type::EXC_DSI, 0); @@ -244,7 +268,7 @@ static uint32_t page_address_translate(uint32_t la, bool is_instr_fetch, pte_word2 = READ_DWORD_BE_A(pte_addr + 4); - key = (((sr_val >> 29) & 1) & msr_pr) | (((sr_val >> 30) & 1) & (msr_pr ^ 1)); + key = (((sr_val >> 29) & 1)& msr_pr) | (((sr_val >> 30) & 1)& (msr_pr ^ 1)); /* check page access */ pp = pte_word2 & 3; @@ -256,7 +280,8 @@ static uint32_t page_address_translate(uint32_t la, bool is_instr_fetch, if ((key && (!pp || (pp == 1 && is_write))) || (pp == 3 && is_write)) { if (is_instr_fetch) { ppc_exception_handler(Except_Type::EXC_ISI, 0x08000000); - } else { + } + else { ppc_state.ppc_spr[18] = 0x08000000 | (is_write << 25); ppc_state.ppc_spr[19] = la; ppc_exception_handler(Except_Type::EXC_DSI, 0); @@ -287,8 +312,8 @@ static uint32_t ppc_mmu_instr_translate(uint32_t la) // Those bits are mutually exclusive unsigned access_bits = (~msr_pr << 1) | msr_pr; - for (int bat_index = 0; bat_index < 4; bat_index++){ - PPC_BAT_entry *bat_entry = &ibat_array[bat_index]; + for (int bat_index = 0; bat_index < 4; bat_index++) { + PPC_BAT_entry* bat_entry = &ibat_array[bat_index]; if ((bat_entry->access & access_bits) && ((la & ~bat_entry->lo_mask) == bat_entry->bepi)) { @@ -326,8 +351,8 @@ static uint32_t ppc_mmu_addr_translate(uint32_t la, int is_write) // Those bits are mutually exclusive unsigned access_bits = (~msr_pr << 1) | msr_pr; - for (int bat_index = 0; bat_index < 4; bat_index++){ - PPC_BAT_entry *bat_entry = &dbat_array[bat_index]; + for (int bat_index = 0; bat_index < 4; bat_index++) { + PPC_BAT_entry* bat_entry = &dbat_array[bat_index]; if ((bat_entry->access & access_bits) && ((la & ~bat_entry->lo_mask) == bat_entry->bepi)) { @@ -349,11 +374,17 @@ static uint32_t ppc_mmu_addr_translate(uint32_t la, int is_write) } -uint32_t write_last_pa_start = 0; -uint32_t write_last_pa_end = 0; -unsigned char *write_last_ptr = 0; +uint32_t write_last_pa_start = 0; +uint32_t write_last_pa_end = 0; +unsigned char* write_last_ptr = 0; -void address_quickinsert_translate(uint32_t value, uint32_t addr, uint8_t num_bytes) +void set_write_pa_ptr(AddressMapEntry* entry) { + write_last_pa_start = entry->start; + write_last_pa_end = entry->end; + write_last_ptr = entry->mem_ptr; +} + +void address_insert8bit_translate(uint8_t value, uint32_t addr) { /* data address translation if enabled */ if (ppc_state.ppc_msr & 0x10) { @@ -361,33 +392,132 @@ void address_quickinsert_translate(uint32_t value, uint32_t addr, uint8_t num_by } if (addr >= write_last_pa_start && addr <= write_last_pa_end) { - ppc_memstore_value(write_last_ptr, value, addr - write_last_pa_start, num_bytes); - } else { - AddressMapEntry *entry = mem_ctrl_instance->find_range(addr); + uint32_t offset = addr - write_last_pa_start; + write_last_ptr[offset] = value; + } + else { + AddressMapEntry* entry = mem_ctrl_instance->find_range(addr); if (entry) { if (entry->type & RT_RAM) { - write_last_pa_start = entry->start; - write_last_pa_end = entry->end; - write_last_ptr = entry->mem_ptr; - ppc_memstore_value(write_last_ptr, value, addr - entry->start, num_bytes); - } else if (entry->type & RT_MMIO) { - entry->devobj->write(addr - entry->start, value, num_bytes); - } else { + set_write_pa_ptr(entry); + uint32_t offset = addr - entry->start; + write_last_ptr[offset] = value; + } + else if (entry->type & RT_MMIO) { + entry->devobj->write(addr - entry->start, (uint32_t)value, 1); + } + else { printf("Please check your address map!\n"); } - } else { + } + else { printf("WARNING: write attempt to unmapped memory at 0x%08X!\n", addr); } } } +void address_insert16bit_translate(uint16_t value, uint32_t addr) +{ + /* data address translation if enabled */ + if (ppc_state.ppc_msr & 0x10) { + addr = ppc_mmu_addr_translate(addr, 1); + } -uint32_t read_last_pa_start = 0; -uint32_t read_last_pa_end = 0; -unsigned char *read_last_ptr = 0; + if (addr >= write_last_pa_start && addr <= write_last_pa_end) { + ppc_memstore_16bit(write_last_ptr, value, addr - write_last_pa_start); + } + else { + AddressMapEntry* entry = mem_ctrl_instance->find_range(addr); + if (entry) { + if (entry->type & RT_RAM) { + set_write_pa_ptr(entry); + ppc_memstore_16bit(write_last_ptr, value, addr - write_last_pa_start); + } + else if (entry->type & RT_MMIO) { + entry->devobj->write(addr - entry->start, (uint32_t)value, 2); + } + else { + printf("Please check your address map!\n"); + } + } + else { + printf("WARNING: write attempt to unmapped memory at 0x%08X!\n", addr); + } + } +} + +void address_insert32bit_translate(uint32_t value, uint32_t addr) +{ + /* data address translation if enabled */ + if (ppc_state.ppc_msr & 0x10) { + addr = ppc_mmu_addr_translate(addr, 1); + } + + if (addr >= write_last_pa_start && addr <= write_last_pa_end) { + ppc_memstore_32bit(write_last_ptr, value, addr - write_last_pa_start); + } + else { + AddressMapEntry* entry = mem_ctrl_instance->find_range(addr); + if (entry) { + if (entry->type & RT_RAM) { + set_write_pa_ptr(entry); + ppc_memstore_32bit(write_last_ptr, value, addr - write_last_pa_start); + } + else if (entry->type & RT_MMIO) { + entry->devobj->write(addr - entry->start, value, 4); + } + else { + printf("Please check your address map!\n"); + } + } + else { + printf("WARNING: write attempt to unmapped memory at 0x%08X!\n", addr); + } + } +} + +void address_insert64bit_translate(uint64_t value, uint32_t addr) +{ + /* data address translation if enabled */ + if (ppc_state.ppc_msr & 0x10) { + addr = ppc_mmu_addr_translate(addr, 1); + } + + if (addr >= write_last_pa_start && addr <= write_last_pa_end) { + ppc_memstore_64bit(write_last_ptr, value, addr - write_last_pa_start); + } + else { + AddressMapEntry* entry = mem_ctrl_instance->find_range(addr); + if (entry) { + if (entry->type & RT_RAM) { + set_write_pa_ptr(entry); + ppc_memstore_64bit(write_last_ptr, value, addr - write_last_pa_start); + } + else if (entry->type & RT_MMIO) { + entry->devobj->write(addr - entry->start, (uint32_t)value, 4); + } + else { + printf("Please check your address map!\n"); + } + } + else { + printf("WARNING: write attempt to unmapped memory at 0x%08X!\n", addr); + } + } +} + +uint32_t read_last_pa_start = 0; +uint32_t read_last_pa_end = 0; +unsigned char* read_last_ptr = 0; + +void set_read_pa_ptr(AddressMapEntry* entry) { + read_last_pa_start = entry->start; + read_last_pa_end = entry->end; + read_last_ptr = entry->mem_ptr; +} /** Grab a value from memory into a register */ -void address_quickgrab_translate(uint32_t addr, uint8_t num_bytes) +void address_grab8bit_translate(uint32_t addr) { /* data address translation if enabled */ if (ppc_state.ppc_msr & 0x10) { @@ -395,24 +525,135 @@ void address_quickgrab_translate(uint32_t addr, uint8_t num_bytes) } if (addr >= read_last_pa_start && addr <= read_last_pa_end) { - ppc_set_return_val(read_last_ptr + (addr - read_last_pa_start), num_bytes); - } else { - AddressMapEntry *entry = mem_ctrl_instance->find_range(addr); + uint8_t* pointer = (read_last_ptr + (addr - read_last_pa_start)); + return_value = (*(uint8_t*)((pointer))); + } + else { + AddressMapEntry* entry = mem_ctrl_instance->find_range(addr); if (entry) { if (entry->type & (RT_ROM | RT_RAM)) { - read_last_pa_start = entry->start; - read_last_pa_end = entry->end; - read_last_ptr = entry->mem_ptr; - ppc_set_return_val(read_last_ptr + (addr - entry->start), num_bytes); - } else if (entry->type & RT_MMIO) { - return_value = entry->devobj->read(addr - entry->start, num_bytes); - } else { + set_read_pa_ptr(entry); + uint8_t* pointer = (read_last_ptr + (addr - entry->start)); + return_value = (*(uint8_t*)((pointer))); + } + else if (entry->type & RT_MMIO) { + return_value = entry->devobj->read(addr - entry->start, 1); + } + else { printf("Please check your address map!\n"); } - } else { + } + else { printf("WARNING: read attempt from unmapped memory at 0x%08X!\n", addr); /* reading from unmapped memory will return unmapped value */ + return_value = 0xFF; + } + } +} + +void address_grab16bit_translate(uint32_t addr) +{ + /* data address translation if enabled */ + if (ppc_state.ppc_msr & 0x10) { + addr = ppc_mmu_addr_translate(addr, 0); + } + + if (addr >= read_last_pa_start && addr <= read_last_pa_end) { + ppc_set_retval_16bit(read_last_ptr + (addr - read_last_pa_start)); + } + else { + AddressMapEntry* entry = mem_ctrl_instance->find_range(addr); + if (entry) { + if (entry->type & (RT_ROM | RT_RAM)) { + set_read_pa_ptr(entry); + ppc_set_retval_16bit(read_last_ptr + (addr - entry->start)); + } + else if (entry->type & RT_MMIO) { + return_value = entry->devobj->read(addr - entry->start, 4); + } + else { + printf("Please check your address map!\n"); + } + } + else { + printf("WARNING: read attempt from unmapped memory at 0x%08X!\n", addr); + + /* reading from unmapped memory will return unmapped value */ + uint8_t num_bytes = 2; + + for (return_value = 0xFF; --num_bytes > 0;) + return_value = (return_value << 8) | 0xFF; + } + } +} + +void address_grab32bit_translate(uint32_t addr) +{ + /* data address translation if enabled */ + if (ppc_state.ppc_msr & 0x10) { + addr = ppc_mmu_addr_translate(addr, 0); + } + + if (addr >= read_last_pa_start && addr <= read_last_pa_end) { + ppc_set_retval_32bit(read_last_ptr + (addr - read_last_pa_start)); + } + else { + AddressMapEntry* entry = mem_ctrl_instance->find_range(addr); + if (entry) { + if (entry->type & (RT_ROM | RT_RAM)) { + set_read_pa_ptr(entry); + ppc_set_retval_32bit(read_last_ptr + (addr - entry->start)); + } + else if (entry->type & RT_MMIO) { + return_value = entry->devobj->read(addr - entry->start, 4); + } + else { + printf("Please check your address map!\n"); + } + } + else { + printf("WARNING: read attempt from unmapped memory at 0x%08X!\n", addr); + + /* reading from unmapped memory will return unmapped value */ + uint8_t num_bytes = 4; + + for (return_value = 0xFF; --num_bytes > 0;) + return_value = (return_value << 8) | 0xFF; + } + } +} + +void address_grab64bit_translate(uint32_t addr) +{ + /* data address translation if enabled */ + if (ppc_state.ppc_msr & 0x10) { + addr = ppc_mmu_addr_translate(addr, 0); + } + + if (addr >= read_last_pa_start && addr <= read_last_pa_end) { + ppc_set_retval_64bit(read_last_ptr + (addr - read_last_pa_start)); + } + else { + AddressMapEntry* entry = mem_ctrl_instance->find_range(addr); + if (entry) { + if (entry->type & (RT_ROM | RT_RAM)) { + set_read_pa_ptr(entry); + ppc_set_retval_64bit(read_last_ptr + (addr - entry->start)); + } + else if (entry->type & RT_MMIO) { + return_value = entry->devobj->read(addr - entry->start, 4); + } + else { + printf("Please check your address map!\n"); + } + } + else { + printf("WARNING: read attempt from unmapped memory at 0x%08X!\n", addr); + + /* reading from unmapped memory will return unmapped value */ + uint8_t num_bytes = 8; + for (return_value = 0xFF; --num_bytes > 0;) return_value = (return_value << 8) | 0xFF; } @@ -420,13 +661,13 @@ void address_quickgrab_translate(uint32_t addr, uint8_t num_bytes) } /* remember recently used memory region for quicker translation. */ -uint32_t exec_last_pa_start = 0; -uint32_t exec_last_pa_end = 0; -unsigned char *exec_last_ptr = 0; +uint32_t exec_last_pa_start = 0; +uint32_t exec_last_pa_end = 0; +unsigned char* exec_last_ptr = 0; -uint8_t *quickinstruction_translate(uint32_t addr) +uint8_t* quickinstruction_translate(uint32_t addr) { - uint8_t *real_addr; + uint8_t* real_addr; /* perform instruction address translation if enabled */ if (ppc_state.ppc_msr & 0x20) { @@ -436,19 +677,21 @@ uint8_t *quickinstruction_translate(uint32_t addr) if (addr >= exec_last_pa_start && addr <= exec_last_pa_end) { real_addr = exec_last_ptr + (addr - exec_last_pa_start); ppc_set_cur_instruction(real_addr); - } else { - AddressMapEntry *entry = mem_ctrl_instance->find_range(addr); + } + else { + AddressMapEntry* entry = mem_ctrl_instance->find_range(addr); if (entry && entry->type & (RT_ROM | RT_RAM)) { exec_last_pa_start = entry->start; - exec_last_pa_end = entry->end; + exec_last_pa_end = entry->end; exec_last_ptr = entry->mem_ptr; real_addr = exec_last_ptr + (addr - exec_last_pa_start); ppc_set_cur_instruction(real_addr); - } else { + } + else { printf("WARNING: attempt to execute code at %08X!\n", addr); exit(-1); // FIXME: ugly error handling, must be the proper exception! } } return real_addr; -} +} \ No newline at end of file diff --git a/cpu/ppc/ppcmmu.h b/cpu/ppc/ppcmmu.h index da2c54c..fa088cf 100644 --- a/cpu/ppc/ppcmmu.h +++ b/cpu/ppc/ppcmmu.h @@ -29,9 +29,15 @@ typedef struct PPC_BAT_entry { extern void ibat_update(uint32_t bat_reg); extern void dbat_update(uint32_t bat_reg); -extern void ppc_set_cur_instruction(const uint8_t *ptr); -extern void address_quickinsert_translate(uint32_t value_insert, uint32_t address_grab, uint8_t num_bytes); -extern void address_quickgrab_translate(uint32_t address_grab, uint8_t num_bytes); -extern uint8_t *quickinstruction_translate(uint32_t address_grab); +extern void ppc_set_cur_instruction(const uint8_t* ptr); +extern void address_insert8bit_translate(uint8_t value, uint32_t addr); +extern void address_insert16bit_translate(uint16_t value, uint32_t addr); +extern void address_insert32bit_translate(uint32_t value, uint32_t addr); +extern void address_insert64bit_translate(uint64_t value, uint32_t addr); +extern void address_grab8bit_translate(uint32_t addr); +extern void address_grab16bit_translate(uint32_t addr); +extern void address_grab32bit_translate(uint32_t addr); +extern void address_grab64bit_translate(uint32_t addr); +extern uint8_t* quickinstruction_translate(uint32_t address_grab); -#endif // PPCMEMORY_H +#endif // PPCMEMORY_H \ No newline at end of file diff --git a/cpu/ppc/ppcopcodes.cpp b/cpu/ppc/ppcopcodes.cpp index afbcae4..ec86676 100644 --- a/cpu/ppc/ppcopcodes.cpp +++ b/cpu/ppc/ppcopcodes.cpp @@ -18,36 +18,36 @@ #include "ppcemu.h" #include "ppcmmu.h" - uint32_t crf_d; - uint32_t crf_s; - uint32_t reg_s; - uint32_t reg_d; - uint32_t reg_a; - uint32_t reg_b; - uint32_t reg_c; //used only for floating point multiplication operations - uint32_t xercon; - uint32_t cmp_c; - uint32_t crm; - uint32_t uimm; - uint32_t not_this; - uint32_t grab_sr; - uint32_t grab_inb; //This is for grabbing the number of immediate bytes for loading and storing - uint32_t ppc_to; - int32_t simm; - int32_t adr_li; +uint32_t crf_d; +uint32_t crf_s; +uint32_t reg_s; +uint32_t reg_d; +uint32_t reg_a; +uint32_t reg_b; +uint32_t reg_c; //used only for floating point multiplication operations +uint32_t xercon; +uint32_t cmp_c; +uint32_t crm; +uint32_t uimm; +uint32_t not_this; +uint32_t grab_sr; +uint32_t grab_inb; //This is for grabbing the number of immediate bytes for loading and storing +uint32_t ppc_to; +int32_t simm; +int32_t adr_li; //Used for GP calcs - uint32_t ppc_result_a = 0; - uint32_t ppc_result_b = 0; - uint32_t ppc_result_c = 0; - uint32_t ppc_result_d = 0; +uint32_t ppc_result_a = 0; +uint32_t ppc_result_b = 0; +uint32_t ppc_result_c = 0; +uint32_t ppc_result_d = 0; - int32_t sidiv_result; - uint32_t uidiv_result; - uint64_t uiproduct; - int64_t siproduct; +int32_t sidiv_result; +uint32_t uidiv_result; +uint64_t uiproduct; +int64_t siproduct; - uint32_t strwrd_replace_value; +uint32_t strwrd_replace_value; /** Extract the registers desired and the values of the registers @@ -56,35 +56,35 @@ what endian the numbers are to be stored in. **/ //Storage and register retrieval functions for the integer functions. -void ppc_store_result_regd(){ +void ppc_store_result_regd() { ppc_state.ppc_gpr[reg_d] = ppc_result_d; } -void ppc_store_result_rega(){ +void ppc_store_result_rega() { ppc_state.ppc_gpr[reg_a] = ppc_result_a; } -void ppc_grab_regsdasimm(){ +void ppc_grab_regsdasimm() { reg_d = (ppc_cur_instruction >> 21) & 31; reg_a = (ppc_cur_instruction >> 16) & 31; simm = (int32_t)((int16_t)((ppc_cur_instruction) & 65535)); ppc_result_a = ppc_state.ppc_gpr[reg_a]; } -void ppc_grab_regsdauimm(){ +void ppc_grab_regsdauimm() { reg_d = (ppc_cur_instruction >> 21) & 31; reg_a = (ppc_cur_instruction >> 16) & 31; uimm = (uint32_t)((uint16_t)((ppc_cur_instruction) & 65535)); ppc_result_a = ppc_state.ppc_gpr[reg_a]; } -void ppc_grab_regsasimm(){ +void ppc_grab_regsasimm() { reg_a = (ppc_cur_instruction >> 16) & 31; simm = (int32_t)((int16_t)(ppc_cur_instruction & 65535)); ppc_result_a = ppc_state.ppc_gpr[reg_a]; } -void ppc_grab_regssauimm(){ +void ppc_grab_regssauimm() { reg_s = (ppc_cur_instruction >> 21) & 31; reg_a = (ppc_cur_instruction >> 16) & 31; uimm = (uint32_t)((uint16_t)((ppc_cur_instruction) & 65535)); @@ -92,7 +92,7 @@ void ppc_grab_regssauimm(){ ppc_result_a = ppc_state.ppc_gpr[reg_a]; } -void ppc_grab_regsdab(){ +void ppc_grab_regsdab() { reg_d = (ppc_cur_instruction >> 21) & 31; reg_a = (ppc_cur_instruction >> 16) & 31; reg_b = (ppc_cur_instruction >> 11) & 31; @@ -100,7 +100,7 @@ void ppc_grab_regsdab(){ ppc_result_b = ppc_state.ppc_gpr[reg_b]; } -void ppc_grab_regssab(){ +void ppc_grab_regssab() { reg_s = (ppc_cur_instruction >> 21) & 31; reg_a = (ppc_cur_instruction >> 16) & 31; reg_b = (ppc_cur_instruction >> 11) & 31; @@ -109,27 +109,27 @@ void ppc_grab_regssab(){ ppc_result_b = ppc_state.ppc_gpr[reg_b]; } -void ppc_grab_regssa(){ +void ppc_grab_regssa() { reg_s = (ppc_cur_instruction >> 21) & 31; reg_a = (ppc_cur_instruction >> 16) & 31; ppc_result_d = ppc_state.ppc_gpr[reg_s]; ppc_result_a = ppc_state.ppc_gpr[reg_a]; } -void ppc_grab_regssb(){ +void ppc_grab_regssb() { reg_s = (ppc_cur_instruction >> 21) & 31; reg_b = (ppc_cur_instruction >> 11) & 31; ppc_result_d = ppc_state.ppc_gpr[reg_s]; ppc_result_b = ppc_state.ppc_gpr[reg_b]; } -void ppc_grab_regsda(){ +void ppc_grab_regsda() { reg_d = (ppc_cur_instruction >> 21) & 31; reg_a = (ppc_cur_instruction >> 16) & 31; ppc_result_a = ppc_state.ppc_gpr[reg_a]; } -void ppc_grab_regsdb(){ +void ppc_grab_regsdb() { reg_d = (ppc_cur_instruction >> 21) & 31; reg_b = (ppc_cur_instruction >> 11) & 31; ppc_result_b = ppc_state.ppc_gpr[reg_b]; @@ -137,50 +137,50 @@ void ppc_grab_regsdb(){ //Affects CR Field 0 - For integer operations -void ppc_changecrf0(uint32_t set_result){ +void ppc_changecrf0(uint32_t set_result) { ppc_state.ppc_cr &= 0x0FFFFFFF; - if (set_result == 0){ + if (set_result == 0) { ppc_state.ppc_cr |= 0x20000000UL; } - else if (set_result & 0x80000000){ + else if (set_result & 0x80000000) { ppc_state.ppc_cr |= 0x80000000UL; } - else{ + else { ppc_state.ppc_cr |= 0x40000000UL; } - if (ppc_state.ppc_spr[1] & 0x80000000){ + if (ppc_state.ppc_spr[1] & 0x80000000) { ppc_state.ppc_cr |= 0x10000000UL; } } //Affects the XER register's Carry Bit -void ppc_carry(uint32_t a, uint32_t b){ - if (b < a){ // TODO: ensure it works everywhere +void ppc_carry(uint32_t a, uint32_t b) { + if (b < a) { // TODO: ensure it works everywhere ppc_state.ppc_spr[1] |= 0x20000000; } - else{ + else { ppc_state.ppc_spr[1] &= 0xDFFFFFFFUL; } } //Affects the XER register's SO and OV Bits -void ppc_setsoov(uint32_t a, uint32_t b){ +void ppc_setsoov(uint32_t a, uint32_t b) { uint64_t a64b = (uint64_t)a; uint64_t b64b = (uint64_t)b; - if ((a64b + b64b) > 0xFFFFFFFFUL){ + if ((a64b + b64b) > 0xFFFFFFFFUL) { ppc_state.ppc_spr[1] |= 0x40000000UL; } - else{ + else { ppc_state.ppc_spr[1] &= 0xBFFFFFFFUL; } - if (((a64b + b64b) < 0x80000000UL) || (ppc_state.ppc_spr[1] & 0x40000000UL)){ + if (((a64b + b64b) < 0x80000000UL) || (ppc_state.ppc_spr[1] & 0x40000000UL)) { ppc_state.ppc_spr[1] |= 0x80000000UL; } - else{ + else { ppc_state.ppc_spr[1] &= 0x7FFFFFFFUL; } } @@ -191,20 +191,20 @@ This is where the opcode tables in the ppcemumain.h come into play - reducing th This means loads of functions, but less CPU cycles needed to determine the function (theoretically). **/ -void ppc_addi(){ +void ppc_addi() { ppc_grab_regsdasimm(); - ppc_result_d = (reg_a == 0)?simm:(ppc_result_a + simm); + ppc_result_d = (reg_a == 0) ? simm : (ppc_result_a + simm); ppc_store_result_regd(); } -void ppc_addic(){ +void ppc_addic() { ppc_grab_regsdasimm(); ppc_result_d = (ppc_result_a + simm); ppc_carry(ppc_result_a, ppc_result_d); ppc_store_result_regd(); } -void ppc_addicdot(){ +void ppc_addicdot() { ppc_grab_regsdasimm(); ppc_result_d = (ppc_result_a + simm); ppc_changecrf0(ppc_result_d); @@ -212,19 +212,19 @@ void ppc_addicdot(){ ppc_store_result_regd(); } -void ppc_addis(){ - ppc_grab_regsdasimm(); - ppc_result_d = (reg_a == 0)?(simm << 16):(ppc_result_a + (simm << 16)); - ppc_store_result_regd(); +void ppc_addis() { + ppc_grab_regsdasimm(); + ppc_result_d = (reg_a == 0) ? (simm << 16) : (ppc_result_a + (simm << 16)); + ppc_store_result_regd(); } -void ppc_add(){ +void ppc_add() { ppc_grab_regsdab(); ppc_result_d = ppc_result_a + ppc_result_b; ppc_store_result_regd(); } -void ppc_adddot(){ +void ppc_adddot() { ppc_grab_regsdab(); ppc_result_d = ppc_result_a + ppc_result_b; ppc_changecrf0(ppc_result_d); @@ -232,14 +232,14 @@ void ppc_adddot(){ } //addo + addodot -void ppc_addo(){ +void ppc_addo() { ppc_grab_regsdab(); ppc_setsoov(ppc_result_a, ppc_result_b); ppc_result_d = ppc_result_a + ppc_result_b; ppc_store_result_regd(); } -void ppc_addodot(){ +void ppc_addodot() { ppc_grab_regsdab(); ppc_setsoov(ppc_result_a, ppc_result_b); ppc_result_d = ppc_result_a + ppc_result_b; @@ -247,14 +247,14 @@ void ppc_addodot(){ ppc_store_result_regd(); } -void ppc_addc(){ +void ppc_addc() { ppc_grab_regsdab(); ppc_result_d = ppc_result_a + ppc_result_b; ppc_carry(ppc_result_a, ppc_result_d); ppc_store_result_regd(); } -void ppc_addcdot(){ +void ppc_addcdot() { ppc_grab_regsdab(); ppc_result_d = ppc_result_a + ppc_result_b; ppc_carry(ppc_result_a, ppc_result_d); @@ -262,7 +262,7 @@ void ppc_addcdot(){ ppc_store_result_regd(); } -void ppc_addco(){ +void ppc_addco() { ppc_grab_regsdab(); ppc_setsoov(ppc_result_a, ppc_result_b); ppc_result_d = ppc_result_a + ppc_result_b; @@ -270,7 +270,7 @@ void ppc_addco(){ ppc_store_result_regd(); } -void ppc_addcodot(){ +void ppc_addcodot() { ppc_grab_regsdab(); ppc_setsoov(ppc_result_a, ppc_result_b); ppc_result_d = ppc_result_a + ppc_result_b; @@ -279,182 +279,182 @@ void ppc_addcodot(){ ppc_store_result_regd(); } -void ppc_adde(){ +void ppc_adde() { ppc_grab_regsdab(); uint32_t xer_ca = !!(ppc_state.ppc_spr[1] & 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))){ + if ((ppc_result_d < ppc_result_a) || (xer_ca && (ppc_result_d == ppc_result_a))) { ppc_state.ppc_spr[1] |= 0x20000000UL; } - else{ + else { ppc_state.ppc_spr[1] &= 0xDFFFFFFFUL; } ppc_store_result_regd(); } -void ppc_addedot(){ +void ppc_addedot() { ppc_grab_regsdab(); uint32_t xer_ca = !!(ppc_state.ppc_spr[1] & 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))){ + if ((ppc_result_d < ppc_result_a) || (xer_ca && (ppc_result_d == ppc_result_a))) { ppc_state.ppc_spr[1] |= 0x20000000UL; } - else{ + else { ppc_state.ppc_spr[1] &= 0xDFFFFFFFUL; } ppc_changecrf0(ppc_result_d); ppc_store_result_regd(); } -void ppc_addeo(){ +void ppc_addeo() { ppc_grab_regsdab(); uint32_t xer_ca = !!(ppc_state.ppc_spr[1] & 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))){ + if ((ppc_result_d < ppc_result_a) || (xer_ca && (ppc_result_d == ppc_result_a))) { ppc_state.ppc_spr[1] |= 0x20000000UL; } - else{ + else { ppc_state.ppc_spr[1] &= 0xDFFFFFFFUL; } ppc_changecrf0(ppc_result_d); ppc_store_result_regd(); } -void ppc_addeodot(){ +void ppc_addeodot() { ppc_grab_regsdab(); uint32_t xer_ca = !!(ppc_state.ppc_spr[1] & 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))){ + if ((ppc_result_d < ppc_result_a) || (xer_ca && (ppc_result_d == ppc_result_a))) { ppc_state.ppc_spr[1] |= 0x20000000UL; } - else{ + else { ppc_state.ppc_spr[1] &= 0xDFFFFFFFUL; } ppc_changecrf0(ppc_result_d); ppc_store_result_regd(); } -void ppc_addme(){ +void ppc_addme() { ppc_grab_regsda(); uint32_t xer_ca = !!(ppc_state.ppc_spr[1] & 0x20000000); ppc_result_d = ppc_result_a + xer_ca - 1; - if (((xer_ca - 1) < 0xFFFFFFFFUL) | (ppc_result_d < ppc_result_a)){ + if (((xer_ca - 1) < 0xFFFFFFFFUL) | (ppc_result_d < ppc_result_a)) { ppc_state.ppc_spr[1] |= 0x20000000UL; } - else{ + else { ppc_state.ppc_spr[1] &= 0xDFFFFFFFUL; } ppc_store_result_regd(); } -void ppc_addmedot(){ +void ppc_addmedot() { ppc_grab_regsda(); uint32_t xer_ca = !!(ppc_state.ppc_spr[1] & 0x20000000); ppc_result_d = ppc_result_a + xer_ca - 1; - if (((xer_ca - 1) < 0xFFFFFFFFUL) | (ppc_result_d < ppc_result_a)){ + if (((xer_ca - 1) < 0xFFFFFFFFUL) | (ppc_result_d < ppc_result_a)) { ppc_state.ppc_spr[1] |= 0x20000000UL; } - else{ + else { ppc_state.ppc_spr[1] &= 0xDFFFFFFFUL; } ppc_changecrf0(ppc_result_d); ppc_store_result_regd(); } -void ppc_addmeo(){ +void ppc_addmeo() { ppc_grab_regsda(); uint32_t xer_ca = !!(ppc_state.ppc_spr[1] & 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)){ + if (((xer_ca - 1) < 0xFFFFFFFFUL) | (ppc_result_d < ppc_result_a)) { ppc_state.ppc_spr[1] |= 0x20000000UL; } - else{ + else { ppc_state.ppc_spr[1] &= 0xDFFFFFFFUL; } ppc_store_result_regd(); } -void ppc_addmeodot(){ +void ppc_addmeodot() { ppc_grab_regsda(); uint32_t xer_ca = !!(ppc_state.ppc_spr[1] & 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)){ + if (((xer_ca - 1) < 0xFFFFFFFFUL) | (ppc_result_d < ppc_result_a)) { ppc_state.ppc_spr[1] |= 0x20000000UL; } - else{ + else { ppc_state.ppc_spr[1] &= 0xDFFFFFFFUL; } ppc_store_result_regd(); } -void ppc_addze(){ +void ppc_addze() { ppc_grab_regsda(); uint32_t grab_xer = (ppc_state.ppc_spr[1] & 0x20000000); ppc_result_d = ppc_result_a + grab_xer; - if (ppc_result_d < ppc_result_a){ + if (ppc_result_d < ppc_result_a) { ppc_state.ppc_spr[1] |= 0x20000000UL; } - else{ + else { ppc_state.ppc_spr[1] &= 0xDFFFFFFFUL; } ppc_store_result_regd(); } -void ppc_addzedot(){ +void ppc_addzedot() { ppc_grab_regsda(); uint32_t grab_xer = (ppc_state.ppc_spr[1] & 0x20000000); ppc_result_d = ppc_result_a + grab_xer; - if (ppc_result_d < ppc_result_a){ + if (ppc_result_d < ppc_result_a) { ppc_state.ppc_spr[1] |= 0x20000000UL; } - else{ + else { ppc_state.ppc_spr[1] &= 0xDFFFFFFFUL; } ppc_changecrf0(ppc_result_d); ppc_store_result_regd(); } -void ppc_addzeo(){ +void ppc_addzeo() { ppc_grab_regsda(); uint32_t grab_xer = (ppc_state.ppc_spr[1] & 0x20000000); ppc_setsoov(ppc_result_a, grab_xer); ppc_result_d = ppc_result_a + grab_xer; - if (ppc_result_d < ppc_result_a){ + if (ppc_result_d < ppc_result_a) { ppc_state.ppc_spr[1] |= 0x20000000UL; } - else{ + else { ppc_state.ppc_spr[1] &= 0xDFFFFFFFUL; } ppc_store_result_regd(); } -void ppc_addzeodot(){ +void ppc_addzeodot() { ppc_grab_regsda(); uint32_t grab_xer = (ppc_state.ppc_spr[1] & 0x20000000); ppc_setsoov(ppc_result_a, grab_xer); ppc_result_d = ppc_result_a + grab_xer; - if (ppc_result_d < ppc_result_a){ + if (ppc_result_d < ppc_result_a) { ppc_state.ppc_spr[1] |= 0x20000000UL; } - else{ + else { ppc_state.ppc_spr[1] &= 0xDFFFFFFFUL; } ppc_changecrf0(ppc_result_d); ppc_store_result_regd(); } -void ppc_subf(){ +void ppc_subf() { ppc_grab_regsdab(); not_this = ~ppc_result_a; ppc_result_d = not_this + ppc_result_b + 1; ppc_store_result_regd(); } -void ppc_subfdot(){ +void ppc_subfdot() { ppc_grab_regsdab(); not_this = ~ppc_result_a; ppc_result_d = not_this + ppc_result_b + 1; @@ -462,7 +462,7 @@ void ppc_subfdot(){ ppc_store_result_regd(); } -void ppc_subfo(){ +void ppc_subfo() { ppc_grab_regsdab(); ppc_setsoov(ppc_result_a, ppc_result_b); not_this = ~ppc_result_a; @@ -470,7 +470,7 @@ void ppc_subfo(){ ppc_store_result_regd(); } -void ppc_subfodot(){ +void ppc_subfodot() { ppc_grab_regsdab(); ppc_setsoov(ppc_result_a, ppc_result_b); not_this = ~ppc_result_a; @@ -479,28 +479,28 @@ void ppc_subfodot(){ ppc_store_result_regd(); } -void ppc_subfc(){ +void ppc_subfc() { ppc_grab_regsdab(); not_this = ~ppc_result_a; ppc_result_d = not_this + ppc_result_b + 1; - if (ppc_result_d <= not_this){ + if (ppc_result_d <= not_this) { ppc_state.ppc_spr[1] |= 0x20000000UL; } - else{ + else { ppc_state.ppc_spr[1] &= 0xDFFFFFFFUL; } ppc_carry(ppc_result_a, ppc_result_d); ppc_store_result_regd(); } -void ppc_subfcdot(){ +void ppc_subfcdot() { ppc_grab_regsdab(); not_this = ~ppc_result_a; ppc_result_d = not_this + ppc_result_b + 1; - if (ppc_result_d <= not_this){ + if (ppc_result_d <= not_this) { ppc_state.ppc_spr[1] |= 0x20000000UL; } - else{ + else { ppc_state.ppc_spr[1] &= 0xDFFFFFFFUL; } ppc_carry(ppc_result_a, ppc_result_d); @@ -508,30 +508,30 @@ void ppc_subfcdot(){ ppc_store_result_regd(); } -void ppc_subfco(){ +void ppc_subfco() { ppc_grab_regsdab(); ppc_setsoov(ppc_result_a, ppc_result_b); not_this = ~ppc_result_a; ppc_result_d = not_this + ppc_result_b + 1; - if (ppc_result_d <= not_this){ + if (ppc_result_d <= not_this) { ppc_state.ppc_spr[1] |= 0x20000000UL; } - else{ + else { ppc_state.ppc_spr[1] &= 0xDFFFFFFFUL; } ppc_carry(ppc_result_a, ppc_result_d); ppc_store_result_regd(); } -void ppc_subfcodot(){ +void ppc_subfcodot() { ppc_grab_regsdab(); ppc_setsoov(ppc_result_a, ppc_result_b); not_this = ~ppc_result_a; ppc_result_d = not_this + ppc_result_b + 1; - if (ppc_result_d <= not_this){ + if (ppc_result_d <= not_this) { ppc_state.ppc_spr[1] |= 0x20000000UL; } - else{ + else { ppc_state.ppc_spr[1] &= 0xDFFFFFFFUL; } ppc_carry(ppc_result_a, ppc_result_d); @@ -539,43 +539,43 @@ void ppc_subfcodot(){ ppc_store_result_regd(); } -void ppc_subfic(){ +void ppc_subfic() { ppc_grab_regsdasimm(); not_this = ~ppc_result_a; ppc_result_d = not_this + simm + 1; if (ppc_result_d <= not_this) { ppc_state.ppc_spr[1] |= 0x20000000UL; } - else{ + else { ppc_state.ppc_spr[1] &= 0xDFFFFFFFUL; } ppc_store_result_regd(); } -void ppc_subfe(){ +void ppc_subfe() { ppc_grab_regsdab(); uint32_t grab_xer = (ppc_state.ppc_spr[1] & 0x20000000); not_this = ~ppc_result_a; ppc_result_d = not_this + ppc_result_b + (ppc_state.ppc_spr[1] & 0x20000000); - if (ppc_result_d <= (not_this + grab_xer)){ + if (ppc_result_d <= (not_this + grab_xer)) { ppc_state.ppc_spr[1] |= 0x20000000UL; } - else{ + else { ppc_state.ppc_spr[1] &= 0xDFFFFFFFUL; } ppc_carry(ppc_result_a, ppc_result_d); ppc_store_result_regd(); } -void ppc_subfedot(){ +void ppc_subfedot() { ppc_grab_regsdab(); uint32_t grab_xer = (ppc_state.ppc_spr[1] & 0x20000000); not_this = ~ppc_result_a; ppc_result_d = not_this + ppc_result_b + grab_xer; - if (ppc_result_d <= (not_this + grab_xer)){ + if (ppc_result_d <= (not_this + grab_xer)) { ppc_state.ppc_spr[1] |= 0x20000000UL; } - else{ + else { ppc_state.ppc_spr[1] &= 0xDFFFFFFFUL; } ppc_carry(ppc_result_a, ppc_result_d); @@ -583,30 +583,30 @@ void ppc_subfedot(){ ppc_store_result_regd(); } -void ppc_subfme(){ +void ppc_subfme() { ppc_grab_regsda(); not_this = ~ppc_result_a; uint32_t grab_xer = (ppc_state.ppc_spr[1] & 0x20000000); ppc_result_d = not_this + grab_xer - 1; - if (ppc_result_a || grab_xer){ + if (ppc_result_a || grab_xer) { ppc_state.ppc_spr[1] |= 0x20000000UL; } - else{ + else { ppc_state.ppc_spr[1] &= 0xDFFFFFFFUL; } ppc_carry(ppc_result_a, grab_xer); ppc_store_result_regd(); } -void ppc_subfmedot(){ +void ppc_subfmedot() { ppc_grab_regsda(); not_this = ~ppc_result_a; uint32_t grab_xer = (ppc_state.ppc_spr[1] & 0x20000000); ppc_result_d = not_this + grab_xer - 1; - if (ppc_result_d <= (not_this + grab_xer)){ + if (ppc_result_d <= (not_this + grab_xer)) { ppc_state.ppc_spr[1] |= 0x20000000UL; } - else{ + else { ppc_state.ppc_spr[1] &= 0xDFFFFFFFUL; } ppc_carry(ppc_result_a, grab_xer); @@ -614,28 +614,28 @@ void ppc_subfmedot(){ ppc_store_result_regd(); } -void ppc_subfze(){ +void ppc_subfze() { ppc_grab_regsda(); not_this = ~ppc_result_a; ppc_result_d = not_this + (ppc_state.ppc_spr[1] & 0x20000000); - if (ppc_result_d <= not_this){ + if (ppc_result_d <= not_this) { ppc_state.ppc_spr[1] |= 0x20000000UL; } - else{ + else { ppc_state.ppc_spr[1] &= 0xDFFFFFFFUL; } ppc_carry(ppc_result_a, (ppc_state.ppc_spr[1] & 0x20000000)); ppc_store_result_regd(); } -void ppc_subfzedot(){ +void ppc_subfzedot() { ppc_grab_regsda(); not_this = ~ppc_result_a; ppc_result_d = not_this + (ppc_state.ppc_spr[1] & 0x20000000); - if (ppc_result_d <= not_this){ + if (ppc_result_d <= not_this) { ppc_state.ppc_spr[1] |= 0x20000000UL; } - else{ + else { ppc_state.ppc_spr[1] &= 0xDFFFFFFFUL; } ppc_carry(ppc_result_a, (ppc_state.ppc_spr[1] & 0x20000000)); @@ -643,376 +643,376 @@ void ppc_subfzedot(){ ppc_store_result_regd(); } -void ppc_and(){ +void ppc_and() { ppc_grab_regssab(); ppc_result_a = ppc_result_d & ppc_result_b; ppc_store_result_rega(); } -void ppc_anddot(){ +void ppc_anddot() { ppc_grab_regssab(); ppc_result_a = ppc_result_d & ppc_result_b; ppc_changecrf0(ppc_result_a); ppc_store_result_rega(); } -void ppc_andc(){ +void ppc_andc() { ppc_grab_regssab(); ppc_result_a = ppc_result_d & ~(ppc_result_b); ppc_store_result_rega(); } -void ppc_andcdot(){ +void ppc_andcdot() { ppc_grab_regssab(); ppc_result_a = ppc_result_d & ~(ppc_result_b); ppc_changecrf0(ppc_result_a); ppc_store_result_rega(); } -void ppc_andidot(){ +void ppc_andidot() { ppc_grab_regssauimm(); ppc_result_a = ppc_result_d & uimm; ppc_changecrf0(ppc_result_a); ppc_store_result_rega(); } -void ppc_andisdot(){ +void ppc_andisdot() { ppc_grab_regssauimm(); ppc_result_a = ppc_result_d & (uimm << 16); ppc_changecrf0(ppc_result_a); ppc_store_result_rega(); } -void ppc_nand(){ +void ppc_nand() { ppc_grab_regssab(); ppc_result_a = ~(ppc_result_d & ppc_result_b); ppc_store_result_rega(); } -void ppc_nanddot(){ +void ppc_nanddot() { ppc_grab_regssab(); ppc_result_a = ~(ppc_result_d & ppc_result_b); ppc_changecrf0(ppc_result_a); ppc_store_result_rega(); } -void ppc_or(){ +void ppc_or() { ppc_grab_regssab(); ppc_result_a = ppc_result_d | ppc_result_b; ppc_store_result_rega(); } -void ppc_ordot(){ +void ppc_ordot() { ppc_grab_regssab(); ppc_result_a = ppc_result_d | ppc_result_b; ppc_changecrf0(ppc_result_a); ppc_store_result_rega(); } -void ppc_orc(){ +void ppc_orc() { ppc_grab_regssab(); ppc_result_a = ppc_result_d | ~(ppc_result_b); ppc_store_result_rega(); } -void ppc_orcdot(){ +void ppc_orcdot() { ppc_grab_regssab(); ppc_result_a = ppc_result_d | ~(ppc_result_b); ppc_changecrf0(ppc_result_a); ppc_store_result_rega(); } -void ppc_ori(){ +void ppc_ori() { ppc_grab_regssauimm(); ppc_result_a = ppc_result_d | uimm; ppc_store_result_rega(); } -void ppc_oris(){ +void ppc_oris() { ppc_grab_regssauimm(); ppc_result_a = ppc_result_d | (uimm << 16); ppc_store_result_rega(); } -void ppc_eqv(){ +void ppc_eqv() { ppc_grab_regssab(); ppc_result_a = ~(ppc_result_d ^ ppc_result_b); ppc_store_result_rega(); } -void ppc_eqvdot(){ +void ppc_eqvdot() { ppc_grab_regssab(); ppc_result_a = ~(ppc_result_d ^ ppc_result_b); ppc_changecrf0(ppc_result_a); ppc_store_result_rega(); } -void ppc_nor(){ +void ppc_nor() { ppc_grab_regssab(); ppc_result_a = ~(ppc_result_d | ppc_result_b); ppc_store_result_rega(); } -void ppc_nordot(){ +void ppc_nordot() { ppc_grab_regssab(); ppc_result_a = ~(ppc_result_d | ppc_result_b); ppc_changecrf0(ppc_result_a); ppc_store_result_rega(); } -void ppc_xor(){ +void ppc_xor() { ppc_grab_regssab(); ppc_result_a = ppc_result_d ^ ppc_result_b; ppc_store_result_rega(); } -void ppc_xordot(){ +void ppc_xordot() { ppc_grab_regssab(); ppc_result_a = ppc_result_d ^ ppc_result_b; ppc_changecrf0(ppc_result_a); ppc_store_result_rega(); } -void ppc_xori(){ +void ppc_xori() { ppc_grab_regssauimm(); ppc_result_a = ppc_result_d ^ uimm; ppc_store_result_rega(); } -void ppc_xoris(){ +void ppc_xoris() { ppc_grab_regssauimm(); ppc_result_a = ppc_result_d ^ (uimm << 16); ppc_store_result_rega(); } -void ppc_neg(){ +void ppc_neg() { ppc_grab_regsda(); - ppc_result_d = ~(ppc_result_a) + 1; + ppc_result_d = ~(ppc_result_a)+1; ppc_store_result_regd(); } -void ppc_negdot(){ +void ppc_negdot() { ppc_grab_regsda(); - ppc_result_d = ~(ppc_result_a) + 1; + ppc_result_d = ~(ppc_result_a)+1; ppc_changecrf0(ppc_result_d); ppc_store_result_regd(); } -void ppc_nego(){ +void ppc_nego() { ppc_grab_regsda(); - ppc_result_d = ~(ppc_result_a) + 1; + ppc_result_d = ~(ppc_result_a)+1; ppc_state.ppc_spr[1] |= 0x40000000UL; ppc_setsoov(ppc_result_d, 1); ppc_store_result_regd(); } -void ppc_negodot(){ +void ppc_negodot() { ppc_grab_regsda(); - ppc_result_d = ~(ppc_result_a) + 1; + ppc_result_d = ~(ppc_result_a)+1; ppc_changecrf0(ppc_result_d); ppc_state.ppc_spr[1] |= 0x40000000UL; ppc_setsoov(ppc_result_d, 1); ppc_store_result_regd(); } -void ppc_cntlzw(){ +void ppc_cntlzw() { ppc_grab_regssa(); uint32_t lead = 0; uint32_t bit_check = ppc_result_d; - #ifdef USE_GCC_BUILTINS +#ifdef USE_GCC_BUILTINS lead = __builtin_clz(bit_check); #elifdef USE_VS_BUILTINS - lead = __lzcnt(bit_check); - #else - do{ + lead = __lzcnt(bit_check); +#else + do { bit_check >>= 1; ++lead; } while (bit_check > 0); - #endif +#endif ppc_result_a = lead; ppc_store_result_rega(); } -void ppc_cntlzwdot(){ +void ppc_cntlzwdot() { ppc_grab_regssa(); uint32_t lead = 0; uint32_t bit_check = ppc_result_d; - #ifdef USE_GCC_BUILTINS +#ifdef USE_GCC_BUILTINS lead = __builtin_clz(bit_check); #elifdef USE_VS_BUILTINS - lead = __lzcnt(bit_check); - #else - do{ + lead = __lzcnt(bit_check); +#else + do { bit_check >>= 1; ++lead; } while (bit_check > 0); - #endif +#endif ppc_result_a = lead; ppc_changecrf0(ppc_result_a); ppc_store_result_rega(); } -void ppc_mulhwu(){ +void ppc_mulhwu() { ppc_grab_regsdab(); - uiproduct = (uint64_t) ppc_result_a * (uint64_t) ppc_result_b; + uiproduct = (uint64_t)ppc_result_a * (uint64_t)ppc_result_b; uiproduct = uiproduct >> 32; - ppc_result_d = (uint32_t) uiproduct; + ppc_result_d = (uint32_t)uiproduct; ppc_store_result_regd(); } -void ppc_mulhwudot(){ +void ppc_mulhwudot() { ppc_grab_regsdab(); - uiproduct = (uint64_t) ppc_result_a * (uint64_t) ppc_result_b; + uiproduct = (uint64_t)ppc_result_a * (uint64_t)ppc_result_b; uiproduct = uiproduct >> 32; ppc_result_d = (uint32_t)uiproduct; ppc_changecrf0(ppc_result_d); ppc_store_result_regd(); } -void ppc_mulhw(){ +void ppc_mulhw() { ppc_grab_regsdab(); - siproduct = (int64_t) ppc_result_a * (int64_t) ppc_result_b; + siproduct = (int64_t)ppc_result_a * (int64_t)ppc_result_b; siproduct = siproduct >> 32; - ppc_result_d = (uint32_t) siproduct; + ppc_result_d = (uint32_t)siproduct; ppc_store_result_regd(); } -void ppc_mulhwdot(){ +void ppc_mulhwdot() { ppc_grab_regsdab(); - siproduct = (int64_t) ppc_result_a * (int64_t) ppc_result_b; + siproduct = (int64_t)ppc_result_a * (int64_t)ppc_result_b; siproduct = siproduct >> 32; - ppc_result_d = (uint32_t) siproduct; + ppc_result_d = (uint32_t)siproduct; ppc_changecrf0(ppc_result_d); ppc_store_result_regd(); } -void ppc_mullw(){ - ppc_grab_regsdab(); - siproduct = (int64_t) ppc_result_a * (int64_t) ppc_result_b; - siproduct &= 4294967295; - ppc_result_d = (uint32_t) siproduct; - ppc_store_result_regd(); -} - -void ppc_mullwdot(){ +void ppc_mullw() { ppc_grab_regsdab(); siproduct = (int64_t)ppc_result_a * (int64_t)ppc_result_b; siproduct &= 4294967295; - ppc_result_d = (uint32_t) siproduct; + ppc_result_d = (uint32_t)siproduct; + ppc_store_result_regd(); +} + +void ppc_mullwdot() { + ppc_grab_regsdab(); + siproduct = (int64_t)ppc_result_a * (int64_t)ppc_result_b; + siproduct &= 4294967295; + ppc_result_d = (uint32_t)siproduct; ppc_changecrf0(ppc_result_d); ppc_store_result_regd(); } -void ppc_mullwo(){ +void ppc_mullwo() { ppc_grab_regsdab(); ppc_setsoov(ppc_result_a, ppc_result_b); siproduct = (int64_t)ppc_result_a * (int64_t)ppc_result_b; siproduct &= 4294967295; - ppc_result_d = (uint32_t) siproduct; + ppc_result_d = (uint32_t)siproduct; ppc_store_result_regd(); } -void ppc_mullwodot(){ +void ppc_mullwodot() { ppc_grab_regsdab(); ppc_setsoov(ppc_result_a, ppc_result_b); siproduct = (int64_t)ppc_result_a * (int64_t)ppc_result_b; siproduct &= 4294967295; - ppc_result_d = (uint32_t) siproduct; + ppc_result_d = (uint32_t)siproduct; ppc_changecrf0(ppc_result_d); ppc_store_result_regd(); } -void ppc_mulli(){ +void ppc_mulli() { ppc_grab_regsdasimm(); int64_t siproduct = (int64_t)((ppc_result_a) * ((int64_t)simm)); siproduct &= 4294967295; - ppc_result_d = (uint32_t) siproduct; + ppc_result_d = (uint32_t)siproduct; ppc_store_result_regd(); } -void ppc_divw(){ +void ppc_divw() { ppc_grab_regsdab(); //handle division by zero cases - switch (ppc_result_b){ + switch (ppc_result_b) { case 0: ppc_result_d = 0; ppc_store_result_regd(); return; case 0xFFFFFFFF: - if (ppc_result_a == 0x80000000){ + if (ppc_result_a == 0x80000000) { ppc_result_d = 0; ppc_store_result_regd(); return; } - default: - sidiv_result = (int32_t) ppc_result_a / (int32_t) ppc_result_b; - ppc_result_d = (uint32_t) sidiv_result; + default: + sidiv_result = (int32_t)ppc_result_a / (int32_t)ppc_result_b; + ppc_result_d = (uint32_t)sidiv_result; ppc_store_result_regd(); } } -void ppc_divwdot(){ +void ppc_divwdot() { ppc_grab_regsdab(); //handle division by zero cases - switch (ppc_result_b){ + switch (ppc_result_b) { case 0: ppc_result_d = 0; ppc_store_result_regd(); ppc_state.ppc_cr &= 0x1FFFFFFF; return; case 0xFFFFFFFF: - if (ppc_result_a == 0x80000000){ + if (ppc_result_a == 0x80000000) { ppc_result_d = 0; ppc_store_result_regd(); ppc_state.ppc_cr &= 0x1FFFFFFF; return; } default: - sidiv_result = (int32_t) ppc_result_a / (int32_t) ppc_result_b; - ppc_result_d = (uint32_t) sidiv_result; + sidiv_result = (int32_t)ppc_result_a / (int32_t)ppc_result_b; + ppc_result_d = (uint32_t)sidiv_result; ppc_changecrf0(ppc_result_d); ppc_store_result_regd(); } } -void ppc_divwo(){ +void ppc_divwo() { ppc_grab_regsdab(); //handle division by zero cases - switch (ppc_result_b){ + switch (ppc_result_b) { case 0: ppc_result_d = 0; ppc_state.ppc_cr |= 0x10000000; ppc_store_result_regd(); return; case 0xFFFFFFFF: - if (ppc_result_a == 0x80000000){ + if (ppc_result_a == 0x80000000) { ppc_result_d = 0; ppc_state.ppc_cr |= 0x10000000; ppc_store_result_regd(); return; } - default: + default: ppc_setsoov(ppc_result_a, ppc_result_b); - sidiv_result = (int32_t) ppc_result_a / (int32_t) ppc_result_b; - ppc_result_d = (uint32_t) sidiv_result; + sidiv_result = (int32_t)ppc_result_a / (int32_t)ppc_result_b; + ppc_result_d = (uint32_t)sidiv_result; ppc_store_result_regd(); } } -void ppc_divwodot(){ +void ppc_divwodot() { ppc_grab_regsdab(); - //handle division by zero cases - switch (ppc_result_b){ + //handle division by zero cases + switch (ppc_result_b) { case 0: ppc_result_d = 0; ppc_store_result_regd(); @@ -1020,27 +1020,27 @@ void ppc_divwodot(){ ppc_state.ppc_cr |= 0x10000000; return; case 0xFFFFFFFF: - if (ppc_result_a == 0x80000000){ + if (ppc_result_a == 0x80000000) { ppc_result_d = 0; ppc_store_result_regd(); ppc_state.ppc_cr &= 0x1FFFFFFF; ppc_state.ppc_cr |= 0x10000000; return; } - default: + default: ppc_setsoov(ppc_result_a, ppc_result_b); - sidiv_result = (int32_t) ppc_result_a / (int32_t) ppc_result_b; - ppc_result_d = (uint32_t) sidiv_result; + sidiv_result = (int32_t)ppc_result_a / (int32_t)ppc_result_b; + ppc_result_d = (uint32_t)sidiv_result; ppc_changecrf0(ppc_result_d); ppc_store_result_regd(); } } -void ppc_divwu(){ +void ppc_divwu() { ppc_grab_regsdab(); //handle division by zero cases - switch (ppc_result_b){ + switch (ppc_result_b) { case 0: ppc_result_d = 0; ppc_store_result_regd(); @@ -1052,11 +1052,11 @@ void ppc_divwu(){ } } -void ppc_divwudot(){ +void ppc_divwudot() { ppc_grab_regsdab(); //handle division by zero cases - switch (ppc_result_b){ + switch (ppc_result_b) { case 0: ppc_result_d = 0; ppc_store_result_regd(); @@ -1070,11 +1070,11 @@ void ppc_divwudot(){ } } -void ppc_divwuo(){ +void ppc_divwuo() { ppc_grab_regsdab(); //handle division by zero cases - switch (ppc_result_b){ + switch (ppc_result_b) { case 0: ppc_result_d = 0; ppc_state.ppc_cr |= 0x10000000; @@ -1088,11 +1088,11 @@ void ppc_divwuo(){ } } -void ppc_divwuodot(){ +void ppc_divwuodot() { ppc_grab_regsdab(); //handle division by zero cases - switch (ppc_result_b){ + switch (ppc_result_b) { case 0: ppc_result_d = 0; ppc_store_result_regd(); @@ -1110,76 +1110,76 @@ void ppc_divwuodot(){ //Value shifting -void ppc_slw(){ +void ppc_slw() { ppc_grab_regssab(); - ppc_result_a = (ppc_result_b < 32)?(ppc_result_d << ppc_result_b):0; + ppc_result_a = (ppc_result_b < 32) ? (ppc_result_d << ppc_result_b) : 0; ppc_store_result_rega(); } -void ppc_slwdot(){ +void ppc_slwdot() { ppc_grab_regssab(); - ppc_result_a = (ppc_result_b < 32)?(ppc_result_d << ppc_result_b):0; + ppc_result_a = (ppc_result_b < 32) ? (ppc_result_d << ppc_result_b) : 0; ppc_changecrf0(ppc_result_a); ppc_store_result_rega(); } -void ppc_srw(){ +void ppc_srw() { ppc_grab_regssab(); - ppc_result_a = (ppc_result_b < 32)?(ppc_result_d >> ppc_result_b):0; + ppc_result_a = (ppc_result_b < 32) ? (ppc_result_d >> ppc_result_b) : 0; ppc_store_result_rega(); } -void ppc_srwdot(){ +void ppc_srwdot() { ppc_grab_regssab(); - ppc_result_a = (ppc_result_b < 32)?(ppc_result_d >> ppc_result_b):0; + ppc_result_a = (ppc_result_b < 32) ? (ppc_result_d >> ppc_result_b) : 0; ppc_changecrf0(ppc_result_a); ppc_store_result_rega(); } -void ppc_sraw(){ +void ppc_sraw() { 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); + 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); } - else{ + 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[1] = (ppc_state.ppc_spr[1] & 0xDFFFFFFFUL) | (((ppc_result_d) > 0x7FFFFFFF) ? 0x20000000 : 0x0); } ppc_store_result_rega(); } -void ppc_srawdot(){ +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); + 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); } - else{ + 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[1] = (ppc_state.ppc_spr[1] & 0xDFFFFFFFUL) | (((ppc_result_d) > 0x7FFFFFFF) ? 0x20000000 : 0x0); } ppc_changecrf0(ppc_result_a); ppc_store_result_rega(); } -void ppc_srawi(){ +void ppc_srawi() { ppc_grab_regssa(); 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[1] = (ppc_state.ppc_spr[1] & 0xDFFFFFFFUL) | (((ppc_result_d) > 0x7FFFFFFF) ? 0x20000000 : 0x0); ppc_store_result_rega(); } -void ppc_srawidot(){ +void ppc_srawidot() { ppc_grab_regssa(); 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[1] = (ppc_state.ppc_spr[1] & 0xDFFFFFFFUL) | (((ppc_result_d) > 0x7FFFFFFF) ? 0x20000000 : 0x0); ppc_changecrf0(ppc_result_a); ppc_store_result_rega(); @@ -1193,97 +1193,97 @@ static inline uint32_t rot_mask(unsigned rot_mb, unsigned rot_me) return ((rot_mb <= rot_me) ? m2 & m1 : m1 | m2); } -void ppc_rlwimi(){ +void ppc_rlwimi() { ppc_grab_regssa(); unsigned rot_sh = (ppc_cur_instruction >> 11) & 31; unsigned rot_mb = (ppc_cur_instruction >> 6) & 31; unsigned rot_me = (ppc_cur_instruction >> 1) & 31; uint32_t mask = rot_mask(rot_mb, rot_me); - uint32_t r = ((ppc_result_d << rot_sh) | (ppc_result_d >> (32-rot_sh))); + uint32_t r = ((ppc_result_d << rot_sh) | (ppc_result_d >> (32 - rot_sh))); ppc_result_a = (ppc_result_a & ~mask) | (r & mask); - if ((ppc_cur_instruction & 0x01) == 1){ + if ((ppc_cur_instruction & 0x01) == 1) { ppc_changecrf0(ppc_result_a); } ppc_store_result_rega(); } -void ppc_rlwinm(){ +void ppc_rlwinm() { ppc_grab_regssa(); unsigned rot_sh = (ppc_cur_instruction >> 11) & 31; unsigned rot_mb = (ppc_cur_instruction >> 6) & 31; unsigned rot_me = (ppc_cur_instruction >> 1) & 31; uint32_t mask = rot_mask(rot_mb, rot_me); - uint32_t r = ((ppc_result_d << rot_sh) | (ppc_result_d >> (32-rot_sh))); + uint32_t r = ((ppc_result_d << rot_sh) | (ppc_result_d >> (32 - rot_sh))); ppc_result_a = r & mask; - if ((ppc_cur_instruction & 0x01) == 1){ + if ((ppc_cur_instruction & 0x01) == 1) { ppc_changecrf0(ppc_result_a); } ppc_store_result_rega(); } -void ppc_rlwnm(){ +void ppc_rlwnm() { ppc_grab_regssab(); unsigned rot_mb = (ppc_cur_instruction >> 6) & 31; unsigned rot_me = (ppc_cur_instruction >> 1) & 31; uint32_t mask = rot_mask(rot_mb, rot_me); - uint32_t r = ((ppc_result_d << ppc_result_b) | (ppc_result_d >> (32-ppc_result_b))); + uint32_t r = ((ppc_result_d << ppc_result_b) | (ppc_result_d >> (32 - ppc_result_b))); ppc_result_a = r & mask; - if ((ppc_cur_instruction & 0x01) == 1){ + if ((ppc_cur_instruction & 0x01) == 1) { ppc_changecrf0(ppc_result_a); } ppc_store_result_rega(); } -void ppc_mfcr(){ +void ppc_mfcr() { reg_d = (ppc_cur_instruction >> 21) & 31; ppc_state.ppc_gpr[reg_d] = ppc_state.ppc_cr; } -void ppc_mtsr(){ +void ppc_mtsr() { #ifdef PROFILER supervisor_inst_num++; #endif - if ((ppc_state.ppc_msr & 0x4000) == 0){ + if ((ppc_state.ppc_msr & 0x4000) == 0) { reg_s = (ppc_cur_instruction >> 21) & 31; grab_sr = (ppc_cur_instruction >> 16) & 15; ppc_state.ppc_sr[grab_sr] = ppc_state.ppc_gpr[reg_s]; } } -void ppc_mtsrin(){ +void ppc_mtsrin() { #ifdef PROFILER supervisor_inst_num++; #endif - if ((ppc_state.ppc_msr & 0x4000) == 0){ + if ((ppc_state.ppc_msr & 0x4000) == 0) { ppc_grab_regssb(); grab_sr = ppc_result_b >> 28; ppc_state.ppc_sr[grab_sr] = ppc_result_d; } } -void ppc_mfsr(){ +void ppc_mfsr() { #ifdef PROFILER supervisor_inst_num++; #endif - if ((ppc_state.ppc_msr & 0x4000) == 0){ + if ((ppc_state.ppc_msr & 0x4000) == 0) { reg_d = (ppc_cur_instruction >> 21) & 31; grab_sr = (ppc_cur_instruction >> 16) & 15; ppc_state.ppc_gpr[reg_d] = ppc_state.ppc_sr[grab_sr]; } } -void ppc_mfsrin(){ +void ppc_mfsrin() { #ifdef PROFILER supervisor_inst_num++; #endif - if ((ppc_state.ppc_msr & 0x4000) == 0){ + if ((ppc_state.ppc_msr & 0x4000) == 0) { ppc_grab_regsdb(); grab_sr = ppc_result_b >> 28; ppc_state.ppc_gpr[reg_d] = ppc_state.ppc_sr[grab_sr]; } } -void ppc_mfmsr(){ +void ppc_mfmsr() { #ifdef PROFILER supervisor_inst_num++; #endif @@ -1294,7 +1294,7 @@ void ppc_mfmsr(){ ppc_state.ppc_gpr[reg_d] = ppc_state.ppc_msr; } -void ppc_mtmsr(){ +void ppc_mtmsr() { #ifdef PROFILER supervisor_inst_num++; #endif @@ -1305,7 +1305,7 @@ void ppc_mtmsr(){ ppc_state.ppc_msr = ppc_state.ppc_gpr[reg_s]; } -void ppc_mfspr(){ +void ppc_mfspr() { uint32_t ref_spr = (((ppc_cur_instruction >> 11) & 31) << 5) | ((ppc_cur_instruction >> 16) & 31); #ifdef PROFILER @@ -1317,7 +1317,7 @@ void ppc_mfspr(){ ppc_state.ppc_gpr[reg_d] = ppc_state.ppc_spr[ref_spr]; } -void ppc_mtspr(){ +void ppc_mtspr() { uint32_t ref_spr = (((ppc_cur_instruction >> 11) & 31) << 5) | ((ppc_cur_instruction >> 16) & 31); reg_s = (ppc_cur_instruction >> 21) & 31; @@ -1327,100 +1327,100 @@ void ppc_mtspr(){ } #endif - if (ref_spr != 287){ + if (ref_spr != 287) { ppc_state.ppc_spr[ref_spr] = ppc_state.ppc_gpr[reg_s]; } - switch(ref_spr){ + 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]; - break; - case 269: - ppc_state.ppc_tbr[1] = ppc_state.ppc_gpr[reg_s]; - break; - case 528: - case 529: - case 530: - case 531: - case 532: - case 533: - case 534: - case 535: - ibat_update(ref_spr); - break; - case 536: - case 537: - case 538: - case 539: - case 540: - case 541: - case 542: - case 543: - dbat_update(ref_spr); + case 268: + ppc_state.ppc_tbr[0] = ppc_state.ppc_gpr[reg_s]; + break; + case 269: + ppc_state.ppc_tbr[1] = ppc_state.ppc_gpr[reg_s]; + break; + case 528: + case 529: + case 530: + case 531: + case 532: + case 533: + case 534: + case 535: + ibat_update(ref_spr); + break; + case 536: + case 537: + case 538: + case 539: + case 540: + case 541: + case 542: + case 543: + dbat_update(ref_spr); } } -void ppc_mftb(){ +void ppc_mftb() { uint32_t ref_spr = (((ppc_cur_instruction >> 11) & 31) << 5) | ((ppc_cur_instruction >> 16) & 31); reg_d = (ppc_cur_instruction >> 21) & 31; - switch(ref_spr){ - case 268: - ppc_state.ppc_gpr[reg_d] = ppc_state.ppc_tbr[0]; - break; - case 269: - ppc_state.ppc_gpr[reg_d] = ppc_state.ppc_tbr[1]; - break; - default: - std::cout << "Invalid TBR access attempted!" << std::endl; + switch (ref_spr) { + case 268: + ppc_state.ppc_gpr[reg_d] = ppc_state.ppc_tbr[0]; + break; + case 269: + ppc_state.ppc_gpr[reg_d] = ppc_state.ppc_tbr[1]; + break; + default: + std::cout << "Invalid TBR access attempted!" << std::endl; } } -void ppc_mtcrf(){ +void ppc_mtcrf() { uint32_t cr_mask = 0; ppc_grab_regssa(); crm = ((ppc_cur_instruction >> 12) & 255); //check this cr_mask += (crm & 128) ? 0xF0000000 : 0x00000000; - cr_mask += (crm & 64) ? 0x0F000000 : 0x00000000; - cr_mask += (crm & 32) ? 0x00F00000 : 0x00000000; - cr_mask += (crm & 16) ? 0x000F0000 : 0x00000000; - cr_mask += (crm & 8) ? 0x0000F000 : 0x00000000; - cr_mask += (crm & 4) ? 0x00000F00 : 0x00000000; - cr_mask += (crm & 2) ? 0x000000F0 : 0x00000000; - cr_mask += (crm & 1) ? 0x0000000F : 0x00000000; + cr_mask += (crm & 64) ? 0x0F000000 : 0x00000000; + cr_mask += (crm & 32) ? 0x00F00000 : 0x00000000; + cr_mask += (crm & 16) ? 0x000F0000 : 0x00000000; + cr_mask += (crm & 8) ? 0x0000F000 : 0x00000000; + cr_mask += (crm & 4) ? 0x00000F00 : 0x00000000; + cr_mask += (crm & 2) ? 0x000000F0 : 0x00000000; + cr_mask += (crm & 1) ? 0x0000000F : 0x00000000; ppc_state.ppc_cr = (ppc_result_d & cr_mask) | (ppc_state.ppc_cr & ~(cr_mask)); } -void ppc_mcrxr(){ +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; } -void ppc_extsb(){ +void ppc_extsb() { ppc_grab_regssa(); - ppc_result_a = (ppc_result_d < 0x80)?(ppc_result_d & 0x000000FF):(0xFFFFFF00UL | (ppc_result_d & 0x000000FF)); + ppc_result_a = (ppc_result_d < 0x80) ? (ppc_result_d & 0x000000FF) : (0xFFFFFF00UL | (ppc_result_d & 0x000000FF)); ppc_store_result_rega(); } -void ppc_extsbdot(){ +void ppc_extsbdot() { ppc_grab_regssa(); - ppc_result_a = (ppc_result_d < 0x80)?(ppc_result_d & 0x000000FF):(0xFFFFFF00UL | (ppc_result_d & 0x000000FF)); + ppc_result_a = (ppc_result_d < 0x80) ? (ppc_result_d & 0x000000FF) : (0xFFFFFF00UL | (ppc_result_d & 0x000000FF)); ppc_changecrf0(ppc_result_a); ppc_store_result_rega(); } -void ppc_extsh(){ +void ppc_extsh() { ppc_grab_regssa(); - ppc_result_a = (ppc_result_d < 0x8000)?(ppc_result_d & 0x0000FFFF):(0xFFFF0000UL | (ppc_result_d & 0x0000FFFF)); + ppc_result_a = (ppc_result_d < 0x8000) ? (ppc_result_d & 0x0000FFFF) : (0xFFFF0000UL | (ppc_result_d & 0x0000FFFF)); ppc_store_result_rega(); } -void ppc_extshdot(){ +void ppc_extshdot() { ppc_grab_regssa(); - ppc_result_a = (ppc_result_d < 0x8000)?(ppc_result_d & 0x0000FFFF):(0xFFFF0000UL | (ppc_result_d & 0x0000FFFF)); + ppc_result_a = (ppc_result_d < 0x8000) ? (ppc_result_d & 0x0000FFFF) : (0xFFFF0000UL | (ppc_result_d & 0x0000FFFF)); ppc_changecrf0(ppc_result_a); ppc_store_result_rega(); } @@ -1431,34 +1431,34 @@ void ppc_extshdot(){ //The middle 24 bytes are the 24-bit address to use for branching to. -void ppc_b(){ +void ppc_b() { uint32_t quick_test = (ppc_cur_instruction & 0x03FFFFFC); - adr_li = (quick_test < 0x2000000)? quick_test: (0xFC000000UL + quick_test); + adr_li = (quick_test < 0x2000000) ? quick_test : (0xFC000000UL + quick_test); ppc_next_instruction_address = (uint32_t)(ppc_state.ppc_pc + adr_li); grab_branch = 1; bb_kind = BB_end_kind::BB_BRANCH; } -void ppc_bl(){ +void ppc_bl() { uint32_t quick_test = (ppc_cur_instruction & 0x03FFFFFC); - adr_li = (quick_test < 0x2000000)? quick_test: (0xFC000000UL + quick_test); + 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); grab_branch = 1; bb_kind = BB_end_kind::BB_BRANCH; } -void ppc_ba(){ +void ppc_ba() { uint32_t quick_test = (ppc_cur_instruction & 0x03FFFFFC); - adr_li = (quick_test < 0x2000000)? quick_test: (0xFC000000UL + quick_test); + adr_li = (quick_test < 0x2000000) ? quick_test : (0xFC000000UL + quick_test); ppc_next_instruction_address = adr_li; grab_branch = 1; bb_kind = BB_end_kind::BB_BRANCH; } -void ppc_bla(){ +void ppc_bla() { uint32_t quick_test = (ppc_cur_instruction & 0x03FFFFFC); - adr_li = (quick_test < 0x2000000)? quick_test: (0xFC000000UL + quick_test); + 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; grab_branch = 1; @@ -1473,13 +1473,13 @@ void ppc_bc() uint32_t br_bi = (ppc_cur_instruction >> 16) & 31; int32_t br_bd = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFC)); - if (!(br_bo & 0x04)){ + if (!(br_bo & 0x04)) { (ppc_state.ppc_spr[9])--; /* decrement CTR */ } ctr_ok = (br_bo & 0x04) || ((ppc_state.ppc_spr[9] != 0) == !(br_bo & 0x02)); cnd_ok = (br_bo & 0x10) || (!(ppc_state.ppc_cr & (0x80000000UL >> br_bi)) == !(br_bo & 0x08)); - if (ctr_ok && cnd_ok){ + if (ctr_ok && cnd_ok) { ppc_next_instruction_address = (ppc_state.ppc_pc + br_bd); grab_branch = 1; bb_kind = BB_end_kind::BB_BRANCH; @@ -1494,13 +1494,13 @@ void ppc_bca() uint32_t br_bi = (ppc_cur_instruction >> 16) & 31; int32_t br_bd = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFC)); - if (!(br_bo & 0x04)){ + if (!(br_bo & 0x04)) { (ppc_state.ppc_spr[9])--; /* decrement CTR */ } ctr_ok = (br_bo & 0x04) || ((ppc_state.ppc_spr[9] != 0) == !(br_bo & 0x02)); cnd_ok = (br_bo & 0x10) || (!(ppc_state.ppc_cr & (0x80000000UL >> br_bi)) == !(br_bo & 0x08)); - if (ctr_ok && cnd_ok){ + if (ctr_ok && cnd_ok) { ppc_next_instruction_address = br_bd; grab_branch = 1; bb_kind = BB_end_kind::BB_BRANCH; @@ -1515,13 +1515,13 @@ void ppc_bcl() uint32_t br_bi = (ppc_cur_instruction >> 16) & 31; int32_t br_bd = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFC)); - if (!(br_bo & 0x04)){ + if (!(br_bo & 0x04)) { (ppc_state.ppc_spr[9])--; /* decrement CTR */ } ctr_ok = (br_bo & 0x04) || ((ppc_state.ppc_spr[9] != 0) == !(br_bo & 0x02)); cnd_ok = (br_bo & 0x10) || (!(ppc_state.ppc_cr & (0x80000000UL >> br_bi)) == !(br_bo & 0x08)); - if (ctr_ok && cnd_ok){ + if (ctr_ok && cnd_ok) { ppc_next_instruction_address = (ppc_state.ppc_pc + br_bd); grab_branch = 1; bb_kind = BB_end_kind::BB_BRANCH; @@ -1537,13 +1537,13 @@ void ppc_bcla() uint32_t br_bi = (ppc_cur_instruction >> 16) & 31; int32_t br_bd = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFC)); - if (!(br_bo & 0x04)){ + if (!(br_bo & 0x04)) { (ppc_state.ppc_spr[9])--; /* decrement CTR */ } ctr_ok = (br_bo & 0x04) || ((ppc_state.ppc_spr[9] != 0) == !(br_bo & 0x02)); cnd_ok = (br_bo & 0x10) || (!(ppc_state.ppc_cr & (0x80000000UL >> br_bi)) == !(br_bo & 0x08)); - if (ctr_ok && cnd_ok){ + if (ctr_ok && cnd_ok) { ppc_next_instruction_address = br_bd; grab_branch = 1; bb_kind = BB_end_kind::BB_BRANCH; @@ -1558,7 +1558,7 @@ void ppc_bcctr() uint32_t cnd_ok = (br_bo & 0x10) || (!(ppc_state.ppc_cr & (0x80000000UL >> br_bi)) == !(br_bo & 0x08)); - if (cnd_ok){ + if (cnd_ok) { ppc_next_instruction_address = (ppc_state.ppc_spr[9] & 0xFFFFFFFCUL); grab_branch = 1; bb_kind = BB_end_kind::BB_BRANCH; @@ -1572,7 +1572,7 @@ void ppc_bcctrl() uint32_t cnd_ok = (br_bo & 0x10) || (!(ppc_state.ppc_cr & (0x80000000UL >> br_bi)) == !(br_bo & 0x08)); - if (cnd_ok){ + if (cnd_ok) { ppc_next_instruction_address = (ppc_state.ppc_spr[9] & 0xFFFFFFFCUL); grab_branch = 1; bb_kind = BB_end_kind::BB_BRANCH; @@ -1587,13 +1587,13 @@ void ppc_bclr() uint32_t ctr_ok; uint32_t cnd_ok; - if (!(br_bo & 0x04)){ + if (!(br_bo & 0x04)) { (ppc_state.ppc_spr[9])--; /* decrement CTR */ } ctr_ok = (br_bo & 0x04) || ((ppc_state.ppc_spr[9] != 0) == !(br_bo & 0x02)); cnd_ok = (br_bo & 0x10) || (!(ppc_state.ppc_cr & (0x80000000UL >> br_bi)) == !(br_bo & 0x08)); - if (ctr_ok && cnd_ok){ + if (ctr_ok && cnd_ok) { ppc_next_instruction_address = (ppc_state.ppc_spr[8] & 0xFFFFFFFCUL); grab_branch = 1; bb_kind = BB_end_kind::BB_BRANCH; @@ -1607,13 +1607,13 @@ void ppc_bclrl() uint32_t ctr_ok; uint32_t cnd_ok; - if (!(br_bo & 0x04)){ + if (!(br_bo & 0x04)) { (ppc_state.ppc_spr[9])--; /* decrement CTR */ } ctr_ok = (br_bo & 0x04) || ((ppc_state.ppc_spr[9] != 0) == !(br_bo & 0x02)); cnd_ok = (br_bo & 0x10) || (!(ppc_state.ppc_cr & (0x80000000UL >> br_bi)) == !(br_bo & 0x08)); - if (ctr_ok && cnd_ok){ + if (ctr_ok && cnd_ok) { ppc_next_instruction_address = (ppc_state.ppc_spr[8] & 0xFFFFFFFCUL); grab_branch = 1; bb_kind = BB_end_kind::BB_BRANCH; @@ -1622,147 +1622,147 @@ void ppc_bclrl() } //Compare Instructions -void ppc_cmp(){ +void ppc_cmp() { //if (!((ppc_cur_instruction >> 21) && 0x1)){ - crf_d = (ppc_cur_instruction >> 23) & 7; - crf_d = crf_d << 2; - ppc_grab_regssab(); - xercon = (ppc_state.ppc_spr[1] & 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)); + crf_d = (ppc_cur_instruction >> 23) & 7; + crf_d = crf_d << 2; + ppc_grab_regssab(); + xercon = (ppc_state.ppc_spr[1] & 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)); //} //else{ // printf("Warning: Invalid CMP Instruction."); //} } -void ppc_cmpi(){ - #ifdef CHECK_INVALID +void ppc_cmpi() { +#ifdef CHECK_INVALID if (ppc_cur_instruction & 0x200000) { printf("WARNING: invalid CMPI instruction form (L=1)!\n"); return; } - #endif +#endif crf_d = (ppc_cur_instruction >> 23) & 7; crf_d = crf_d << 2; ppc_grab_regsasimm(); xercon = (ppc_state.ppc_spr[1] & 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)); + ppc_state.ppc_cr = ((ppc_state.ppc_cr & ~(0xf0000000UL >> crf_d)) | ((cmp_c + xercon) >> crf_d)); } -void ppc_cmpl(){ - #ifdef CHECK_INVALID +void ppc_cmpl() { +#ifdef CHECK_INVALID if (ppc_cur_instruction & 0x200000) { printf("WARNING: invalid CMPL instruction form (L=1)!\n"); return; } - #endif +#endif crf_d = (ppc_cur_instruction >> 23) & 7; crf_d = crf_d << 2; ppc_grab_regssab(); xercon = (ppc_state.ppc_spr[1] & 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)); + ppc_state.ppc_cr = ((ppc_state.ppc_cr & ~(0xf0000000UL >> crf_d)) | ((cmp_c + xercon) >> crf_d)); } -void ppc_cmpli(){ - #ifdef CHECK_INVALID +void ppc_cmpli() { +#ifdef CHECK_INVALID if (ppc_cur_instruction & 0x200000) { printf("WARNING: invalid CMPLI instruction form (L=1)!\n"); return; } - #endif +#endif crf_d = (ppc_cur_instruction >> 23) & 7; crf_d = crf_d << 2; ppc_grab_regssauimm(); xercon = (ppc_state.ppc_spr[1] & 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)); + ppc_state.ppc_cr = ((ppc_state.ppc_cr & ~(0xf0000000UL >> crf_d)) | ((cmp_c + xercon) >> crf_d)); } //Condition Register Changes -void ppc_crand(){ +void ppc_crand() { ppc_grab_regsdab(); - if ((ppc_state.ppc_cr & (0x80000000UL >> reg_a)) && (ppc_state.ppc_cr & (0x80000000UL >> reg_b))){ + if ((ppc_state.ppc_cr & (0x80000000UL >> reg_a)) && (ppc_state.ppc_cr & (0x80000000UL >> reg_b))) { ppc_state.ppc_cr |= (0x80000000UL >> reg_d); } - else{ + else { ppc_state.ppc_cr &= ~(0x80000000UL >> reg_d); } } -void ppc_crandc(){ +void ppc_crandc() { ppc_grab_regsdab(); - if ((ppc_state.ppc_cr & (0x80000000UL >> reg_a)) && !(ppc_state.ppc_cr & (0x80000000UL >> reg_b))){ + if ((ppc_state.ppc_cr & (0x80000000UL >> reg_a)) && !(ppc_state.ppc_cr & (0x80000000UL >> reg_b))) { ppc_state.ppc_cr |= (0x80000000UL >> reg_d); } - else{ + else { ppc_state.ppc_cr &= ~(0x80000000UL >> reg_d); } } -void ppc_creqv(){ +void ppc_creqv() { ppc_grab_regsdab(); - if (!((ppc_state.ppc_cr & (0x80000000UL >> reg_a)) ^ (ppc_state.ppc_cr & (0x80000000UL >> reg_b)))){ + if (!((ppc_state.ppc_cr & (0x80000000UL >> reg_a)) ^ (ppc_state.ppc_cr & (0x80000000UL >> reg_b)))) { ppc_state.ppc_cr |= (0x80000000UL >> reg_d); } - else{ + else { ppc_state.ppc_cr &= ~(0x80000000UL >> reg_d); } } -void ppc_crnand(){ +void ppc_crnand() { ppc_grab_regsdab(); - if (!((ppc_state.ppc_cr & (0x80000000UL >> reg_a)) && (ppc_state.ppc_cr & (0x80000000UL >> reg_b)))){ + if (!((ppc_state.ppc_cr & (0x80000000UL >> reg_a)) && (ppc_state.ppc_cr & (0x80000000UL >> reg_b)))) { ppc_state.ppc_cr |= (0x80000000UL >> reg_d); } - else{ + else { ppc_state.ppc_cr &= ~(0x80000000UL >> reg_d); } } -void ppc_crnor(){ +void ppc_crnor() { ppc_grab_regsdab(); - if (!((ppc_state.ppc_cr & (0x80000000UL >> reg_a)) || (ppc_state.ppc_cr & (0x80000000UL >> reg_b)))){ + if (!((ppc_state.ppc_cr & (0x80000000UL >> reg_a)) || (ppc_state.ppc_cr & (0x80000000UL >> reg_b)))) { ppc_state.ppc_cr |= (0x80000000UL >> reg_d); } - else{ + else { ppc_state.ppc_cr &= ~(0x80000000UL >> reg_d); } } -void ppc_cror(){ +void ppc_cror() { ppc_grab_regsdab(); - if ((ppc_state.ppc_cr & (0x80000000UL >> reg_a)) || (ppc_state.ppc_cr & (0x80000000UL >> reg_b))){ + if ((ppc_state.ppc_cr & (0x80000000UL >> reg_a)) || (ppc_state.ppc_cr & (0x80000000UL >> reg_b))) { ppc_state.ppc_cr |= (0x80000000UL >> reg_d); } - else{ + else { ppc_state.ppc_cr &= ~(0x80000000UL >> reg_d); } } -void ppc_crorc(){ +void ppc_crorc() { ppc_grab_regsdab(); - if ((ppc_state.ppc_cr & (0x80000000UL >> reg_a)) || !(ppc_state.ppc_cr & (0x80000000UL >> reg_b))){ + if ((ppc_state.ppc_cr & (0x80000000UL >> reg_a)) || !(ppc_state.ppc_cr & (0x80000000UL >> reg_b))) { ppc_state.ppc_cr |= (0x80000000UL >> reg_d); } - else{ + else { ppc_state.ppc_cr &= ~(0x80000000UL >> reg_d); } } -void ppc_crxor(){ +void ppc_crxor() { ppc_grab_regsdab(); - if ((ppc_state.ppc_cr & (0x80000000UL >> reg_a)) ^ (ppc_state.ppc_cr & (0x80000000UL >> reg_b))){ + if ((ppc_state.ppc_cr & (0x80000000UL >> reg_a)) ^ (ppc_state.ppc_cr & (0x80000000UL >> reg_b))) { ppc_state.ppc_cr |= (0x80000000UL >> reg_d); } - else{ + else { ppc_state.ppc_cr &= ~(0x80000000UL >> reg_d); } } //Processor MGMT Fns. -void ppc_rfi(){ +void ppc_rfi() { #ifdef PROFILER supervisor_inst_num++; #endif @@ -1775,93 +1775,89 @@ void ppc_rfi(){ bb_kind = BB_end_kind::BB_RFI; } -void ppc_sc(){ +void ppc_sc() { ppc_exception_handler(Except_Type::EXC_SYSCALL, 0x20000); } -void ppc_tw(){ +void ppc_tw() { reg_a = (ppc_cur_instruction >> 11) & 31; reg_b = (ppc_cur_instruction >> 16) & 31; ppc_to = (ppc_cur_instruction >> 21) & 31; if ((((int32_t)ppc_state.ppc_gpr[reg_a] < (int32_t)ppc_state.ppc_gpr[reg_b]) & (ppc_to & 0x10)) || \ - (((int32_t)ppc_state.ppc_gpr[reg_a] > (int32_t)ppc_state.ppc_gpr[reg_b]) & (ppc_to & 0x08)) || \ - (((int32_t)ppc_state.ppc_gpr[reg_a] == (int32_t)ppc_state.ppc_gpr[reg_b]) & (ppc_to & 0x04)) || \ - ((ppc_state.ppc_gpr[reg_a] < ppc_state.ppc_gpr[reg_b]) & (ppc_to & 0x02)) || \ - ((ppc_state.ppc_gpr[reg_a] > ppc_state.ppc_gpr[reg_b]) & (ppc_to & 0x01))){ + (((int32_t)ppc_state.ppc_gpr[reg_a] > (int32_t)ppc_state.ppc_gpr[reg_b])& (ppc_to & 0x08)) || \ + (((int32_t)ppc_state.ppc_gpr[reg_a] == (int32_t)ppc_state.ppc_gpr[reg_b]) & (ppc_to & 0x04)) || \ + ((ppc_state.ppc_gpr[reg_a] < ppc_state.ppc_gpr[reg_b]) & (ppc_to & 0x02)) || \ + ((ppc_state.ppc_gpr[reg_a] > ppc_state.ppc_gpr[reg_b])& (ppc_to & 0x01))) { ppc_exception_handler(Except_Type::EXC_PROGRAM, 0x20000); } } -void ppc_twi(){ +void ppc_twi() { simm = (int32_t)((int16_t)((ppc_cur_instruction) & 65535)); reg_b = (ppc_cur_instruction >> 16) & 31; ppc_to = (ppc_cur_instruction >> 21) & 31; if ((((int32_t)ppc_state.ppc_gpr[reg_a] < simm) & (ppc_to & 0x10)) || \ - (((int32_t)ppc_state.ppc_gpr[reg_a] > simm) & (ppc_to & 0x08)) || \ - (((int32_t)ppc_state.ppc_gpr[reg_a] == simm) & (ppc_to & 0x04)) || \ - ((ppc_state.ppc_gpr[reg_a] < (uint32_t)simm) & (ppc_to & 0x02)) || \ - ((ppc_state.ppc_gpr[reg_a] > (uint32_t)simm) & (ppc_to & 0x01))){ + (((int32_t)ppc_state.ppc_gpr[reg_a] > simm)& (ppc_to & 0x08)) || \ + (((int32_t)ppc_state.ppc_gpr[reg_a] == simm) & (ppc_to & 0x04)) || \ + ((ppc_state.ppc_gpr[reg_a] < (uint32_t)simm) & (ppc_to & 0x02)) || \ + ((ppc_state.ppc_gpr[reg_a] > (uint32_t)simm)& (ppc_to & 0x01))) { ppc_exception_handler(Except_Type::EXC_PROGRAM, 0x20000); } } -void ppc_eieio(){ +void ppc_eieio() { //std::cout << "Oops. Placeholder for eieio." << std::endl; } -void ppc_isync(){ +void ppc_isync() { //std::cout << "Oops. Placeholder for isync." << std::endl; } -void ppc_sync(){ +void ppc_sync() { //std::cout << "Oops. Placeholder for sync." << std::endl; } -void ppc_icbi(){ +void ppc_icbi() { std::cout << "Oops. Placeholder for icbi." << std::endl; } -void ppc_dcbf(){ +void ppc_dcbf() { std::cout << "Oops. Placeholder for dcbf." << std::endl; } -void ppc_dcbi(){ - #ifdef PROFILER +void ppc_dcbi() { +#ifdef PROFILER supervisor_inst_num++; - #endif +#endif std::cout << "Oops. Placeholder for dcbi." << std::endl; } -void ppc_dcbst(){ +void ppc_dcbst() { std::cout << "Oops. Placeholder for dcbst." << std::endl; } -void ppc_dcbt(){ +void ppc_dcbt() { //Not needed, the HDI reg is touched to no-op this instruction. return; } -void ppc_dcbtst(){ +void ppc_dcbtst() { //Not needed, the HDI reg is touched to no-op this instruction. return; } -void ppc_dcbz(){ +void ppc_dcbz() { ppc_grab_regsdab(); - ppc_effective_address = (reg_a == 0)?ppc_result_b:(ppc_result_a + ppc_result_b); - if (!(ppc_state.ppc_pc & 32) && (ppc_state.ppc_pc < 0xFFFFFFE0UL)){ + ppc_effective_address = (reg_a == 0) ? ppc_result_b : (ppc_result_a + ppc_result_b); + if (!(ppc_state.ppc_pc & 32) && (ppc_state.ppc_pc < 0xFFFFFFE0UL)) { ppc_grab_regsdab(); - ppc_effective_address = (reg_a == 0)?ppc_result_b:(ppc_result_a + ppc_result_b); - address_quickinsert_translate(0, ppc_effective_address, 4); - address_quickinsert_translate(0, (ppc_effective_address + 4), 4); - address_quickinsert_translate(0, (ppc_effective_address + 8), 4); - address_quickinsert_translate(0, (ppc_effective_address + 12), 4); - address_quickinsert_translate(0, (ppc_effective_address + 16), 4); - address_quickinsert_translate(0, (ppc_effective_address + 20), 4); - address_quickinsert_translate(0, (ppc_effective_address + 24), 4); - address_quickinsert_translate(0, (ppc_effective_address + 28), 4); + ppc_effective_address = (reg_a == 0) ? ppc_result_b : (ppc_result_a + ppc_result_b); + address_insert64bit_translate(0, ppc_effective_address); + address_insert64bit_translate(0, (ppc_effective_address + 8)); + address_insert64bit_translate(0, (ppc_effective_address + 16)); + address_insert64bit_translate(0, (ppc_effective_address + 24)); } - else{ + else { ppc_exception_handler(Except_Type::EXC_ALIGNMENT, 0x00000); } } @@ -1873,13 +1869,13 @@ void ppc_stb() { ppc_grab_regssa(); ppc_effective_address = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF)); ppc_effective_address += (reg_a > 0) ? ppc_result_a : 0; - address_quickinsert_translate(ppc_result_d, ppc_effective_address, 1); + address_insert8bit_translate(ppc_result_d, ppc_effective_address); } void ppc_stbx() { ppc_grab_regssab(); ppc_effective_address = (reg_a == 0) ? ppc_result_b : (ppc_result_a + ppc_result_b); - address_quickinsert_translate(ppc_result_d, ppc_effective_address, 1); + address_insert8bit_translate(ppc_result_d, ppc_effective_address); } void ppc_stbu() { @@ -1887,7 +1883,7 @@ void ppc_stbu() { if (reg_a != 0) { ppc_effective_address = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF)); ppc_effective_address += ppc_result_a; - address_quickinsert_translate(ppc_result_d, ppc_effective_address, 1); + address_insert8bit_translate(ppc_result_d, ppc_effective_address); ppc_state.ppc_gpr[reg_a] = ppc_effective_address; } else { @@ -1899,7 +1895,7 @@ void ppc_stbux() { ppc_grab_regssab(); if (reg_a != 0) { ppc_effective_address = ppc_result_a + ppc_result_b; - address_quickinsert_translate(ppc_result_d, ppc_effective_address, 1); + address_insert8bit_translate(ppc_result_d, ppc_effective_address); ppc_state.ppc_gpr[reg_a] = ppc_effective_address; } else { @@ -1911,7 +1907,7 @@ void ppc_sth() { ppc_grab_regssa(); ppc_effective_address = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF)); ppc_effective_address += (reg_a > 0) ? ppc_result_a : 0; - address_quickinsert_translate(ppc_result_d, ppc_effective_address, 2); + address_insert16bit_translate(ppc_result_d, ppc_effective_address); } void ppc_sthu() { @@ -1919,7 +1915,7 @@ void ppc_sthu() { if (reg_a != 0) { ppc_effective_address = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF)); ppc_effective_address += ppc_result_a; - address_quickinsert_translate(ppc_result_d, ppc_effective_address, 2); + address_insert16bit_translate(ppc_result_d, ppc_effective_address); ppc_state.ppc_gpr[reg_a] = ppc_effective_address; } else { @@ -1931,7 +1927,7 @@ void ppc_sthux() { ppc_grab_regssab(); if (reg_a != 0) { ppc_effective_address = ppc_result_a + ppc_result_b; - address_quickinsert_translate(ppc_result_d, ppc_effective_address, 2); + address_insert16bit_translate(ppc_result_d, ppc_effective_address); ppc_state.ppc_gpr[reg_a] = ppc_effective_address; } else { @@ -1942,27 +1938,27 @@ void ppc_sthux() { void ppc_sthx() { ppc_grab_regssab(); ppc_effective_address = (reg_a == 0) ? ppc_result_b : (ppc_result_a + ppc_result_b); - address_quickinsert_translate(ppc_result_d, ppc_effective_address, 2); + address_insert16bit_translate(ppc_result_d, ppc_effective_address); } void ppc_sthbrx() { ppc_grab_regssab(); ppc_effective_address = (reg_a == 0) ? ppc_result_b : (ppc_result_a + ppc_result_b); ppc_result_d = (uint32_t)(BYTESWAP_16((uint16_t)ppc_result_d)); - address_quickinsert_translate(ppc_result_d, ppc_effective_address, 2); + address_insert16bit_translate(ppc_result_d, ppc_effective_address); } void ppc_stw() { ppc_grab_regssa(); ppc_effective_address = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF)); ppc_effective_address += (reg_a > 0) ? ppc_result_a : 0; - address_quickinsert_translate(ppc_result_d, ppc_effective_address, 4); + address_insert32bit_translate(ppc_result_d, ppc_effective_address); } void ppc_stwx() { ppc_grab_regssab(); ppc_effective_address = (reg_a == 0) ? ppc_result_b : (ppc_result_a + ppc_result_b); - address_quickinsert_translate(ppc_result_d, ppc_effective_address, 4); + address_insert32bit_translate(ppc_result_d, ppc_effective_address); } void ppc_stwcx() { @@ -1970,7 +1966,7 @@ void ppc_stwcx() { ppc_grab_regssab(); ppc_effective_address = (reg_a == 0) ? ppc_result_b : (ppc_result_a + ppc_result_b); if (ppc_state.ppc_reserve) { - address_quickinsert_translate(ppc_result_d, ppc_effective_address, 4); + address_insert32bit_translate(ppc_result_d, ppc_effective_address); ppc_state.ppc_cr |= (ppc_state.ppc_spr[1] & 0x80000000) ? 0x30000000 : 0x20000000; ppc_state.ppc_reserve = false; } @@ -1984,7 +1980,7 @@ void ppc_stwu() { if (reg_a != 0) { ppc_effective_address = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF)); ppc_effective_address += ppc_result_a; - address_quickinsert_translate(ppc_result_d, ppc_effective_address, 4); + address_insert32bit_translate(ppc_result_d, ppc_effective_address); ppc_state.ppc_gpr[reg_a] = ppc_effective_address; } else { @@ -1996,7 +1992,7 @@ void ppc_stwux() { ppc_grab_regssab(); if (reg_a != 0) { ppc_effective_address = ppc_result_a + ppc_result_b; - address_quickinsert_translate(ppc_result_d, ppc_effective_address, 4); + address_insert32bit_translate(ppc_result_d, ppc_effective_address); ppc_state.ppc_gpr[reg_a] = ppc_effective_address; } else { @@ -2008,7 +2004,7 @@ void ppc_stwbrx() { ppc_grab_regssab(); ppc_effective_address = (reg_a == 0) ? ppc_result_b : (ppc_result_a + ppc_result_b); ppc_result_d = BYTESWAP_32(ppc_result_d); - address_quickinsert_translate(ppc_result_d, ppc_effective_address, 4); + address_insert32bit_translate(ppc_result_d, ppc_effective_address); } void ppc_stmw() { @@ -2017,7 +2013,7 @@ void ppc_stmw() { ppc_effective_address += (reg_a > 0) ? ppc_result_a : 0; //How many words to store in memory - using a do-while for this do { - address_quickinsert_translate(ppc_result_d, ppc_effective_address, 4); + address_insert32bit_translate(ppc_result_d, ppc_effective_address); ppc_effective_address += 4; reg_d++; } while (reg_d < 32); @@ -2027,8 +2023,8 @@ void ppc_lbz() { ppc_grab_regsda(); ppc_effective_address = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF)); ppc_effective_address += (reg_a > 0) ? ppc_result_a : 0; - address_quickgrab_translate(ppc_effective_address, 1); - ppc_result_d = return_value; + address_grab8bit_translate(ppc_effective_address); + ppc_result_d = (uint32_t)return_value; return_value = 0; ppc_store_result_regd(); } @@ -2038,8 +2034,8 @@ void ppc_lbzu() { ppc_effective_address = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF)); if ((reg_a != reg_d) || reg_a != 0) { ppc_effective_address += ppc_result_a; - address_quickgrab_translate(ppc_effective_address, 1); - ppc_result_d = return_value; + address_grab8bit_translate(ppc_effective_address); + ppc_result_d = (uint32_t)return_value; return_value = 0; ppc_result_a = ppc_effective_address; ppc_store_result_regd(); @@ -2053,8 +2049,8 @@ void ppc_lbzu() { void ppc_lbzx() { ppc_grab_regsdab(); ppc_effective_address = (reg_a == 0) ? ppc_result_b : (ppc_result_a + ppc_result_b); - address_quickgrab_translate(ppc_effective_address, 1); - ppc_result_d = return_value; + address_grab8bit_translate(ppc_effective_address); + ppc_result_d = (uint32_t)return_value; return_value = 0; ppc_store_result_regd(); } @@ -2063,8 +2059,8 @@ void ppc_lbzux() { ppc_grab_regsdab(); if ((reg_a != reg_d) || reg_a != 0) { ppc_effective_address = ppc_result_a + ppc_result_b; - address_quickgrab_translate(ppc_effective_address, 1); - ppc_result_d = return_value; + address_grab8bit_translate(ppc_effective_address); + ppc_result_d = (uint32_t)return_value; return_value = 0; ppc_result_a = ppc_effective_address; ppc_store_result_regd(); @@ -2080,8 +2076,8 @@ void ppc_lhz() { ppc_grab_regsda(); ppc_effective_address = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF)); ppc_effective_address += (reg_a > 0) ? ppc_result_a : 0; - address_quickgrab_translate(ppc_effective_address, 2); - ppc_result_d = return_value; + address_grab16bit_translate(ppc_effective_address); + ppc_result_d = (uint32_t)return_value; return_value = 0; ppc_store_result_regd(); } @@ -2091,8 +2087,8 @@ void ppc_lhzu() { if ((reg_a != reg_d) || reg_a != 0) { ppc_effective_address = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF)); ppc_effective_address += ppc_result_a; - address_quickgrab_translate(ppc_effective_address, 2); - ppc_result_d = return_value; + address_grab16bit_translate(ppc_effective_address); + ppc_result_d = (uint32_t)return_value; return_value = 0; ppc_result_a = ppc_effective_address; ppc_store_result_regd(); @@ -2106,8 +2102,8 @@ void ppc_lhzu() { void ppc_lhzx() { ppc_grab_regsdab(); ppc_effective_address = (reg_a == 0) ? ppc_result_b : (ppc_result_a + ppc_result_b); - address_quickgrab_translate(ppc_effective_address, 2); - ppc_result_d = return_value; + address_grab16bit_translate(ppc_effective_address); + ppc_result_d = (uint32_t)return_value; return_value = 0; ppc_store_result_regd(); } @@ -2116,8 +2112,8 @@ void ppc_lhzux() { ppc_grab_regsdab(); if ((reg_a != reg_d) || reg_a != 0) { ppc_effective_address = ppc_result_a + ppc_result_b; - address_quickgrab_translate(ppc_effective_address, 2); - ppc_result_d = return_value; + address_grab16bit_translate(ppc_effective_address); + ppc_result_d = (uint32_t)return_value; return_value = 0; ppc_result_a = ppc_effective_address; ppc_store_result_regd(); @@ -2132,7 +2128,7 @@ void ppc_lha() { ppc_grab_regsda(); ppc_effective_address = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF)); ppc_effective_address += (reg_a > 0) ? ppc_result_a : 0; - address_quickgrab_translate(ppc_effective_address, 2); + address_grab16bit_translate(ppc_effective_address); uint16_t go_this = (uint16_t)return_value; if (go_this & 0x8000) { ppc_result_d = 0xFFFF0000UL | (uint32_t)return_value; @@ -2150,7 +2146,7 @@ void ppc_lhau() { if ((reg_a != reg_d) || reg_a != 0) { ppc_effective_address = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF)); ppc_effective_address += ppc_result_a; - address_quickgrab_translate(ppc_effective_address, 2); + address_grab16bit_translate(ppc_effective_address); uint16_t go_this = (uint16_t)return_value; if (go_this & 0x8000) { ppc_result_d = 0xFFFF0000UL | (uint32_t)return_value; @@ -2172,7 +2168,7 @@ void ppc_lhau() { void ppc_lhaux() { ppc_grab_regsdab(); ppc_effective_address = (reg_a == 0) ? ppc_result_b : (ppc_result_a + ppc_result_b); - address_quickgrab_translate(ppc_effective_address, 2); + address_grab16bit_translate(ppc_effective_address); uint16_t go_this = (uint16_t)return_value; if (go_this & 0x8000) { ppc_result_d = 0xFFFF0000UL | (uint32_t)return_value; @@ -2190,7 +2186,7 @@ void ppc_lhaux() { void ppc_lhax() { ppc_grab_regsdab(); ppc_effective_address = (reg_a == 0) ? ppc_result_b : (ppc_result_a + ppc_result_b); - address_quickgrab_translate(ppc_effective_address, 2); + address_grab16bit_translate(ppc_effective_address); uint16_t go_this = (uint16_t)return_value; if (go_this & 0x8000) { ppc_result_d = 0xFFFF0000UL | (uint32_t)return_value; @@ -2206,7 +2202,7 @@ void ppc_lhax() { void ppc_lhbrx() { ppc_grab_regsdab(); ppc_effective_address = (reg_a == 0) ? ppc_result_b : (ppc_result_a + ppc_result_b); - address_quickgrab_translate(ppc_effective_address, 2); + address_grab16bit_translate(ppc_effective_address); ppc_result_d = (uint32_t)(BYTESWAP_16((uint16_t)ppc_result_d)); return_value = 0; ppc_store_result_regd(); @@ -2216,8 +2212,8 @@ void ppc_lwz() { ppc_grab_regsda(); ppc_effective_address = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF)); ppc_effective_address += (reg_a > 0) ? ppc_result_a : 0; - address_quickgrab_translate(ppc_effective_address, 4); - ppc_result_d = return_value; + address_grab32bit_translate(ppc_effective_address); + ppc_result_d = (uint32_t)return_value; return_value = 0; ppc_store_result_regd(); } @@ -2225,8 +2221,8 @@ void ppc_lwz() { void ppc_lwbrx() { ppc_grab_regsdab(); ppc_effective_address = (reg_a == 0) ? ppc_result_b : (ppc_result_a + ppc_result_b); - address_quickgrab_translate(ppc_effective_address, 4); - ppc_result_d = BYTESWAP_32(return_value); + address_grab32bit_translate(ppc_effective_address); + ppc_result_d = BYTESWAP_32((uint32_t)return_value); return_value = 0; ppc_store_result_regd(); } @@ -2236,8 +2232,8 @@ void ppc_lwzu() { ppc_effective_address = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF)); if ((reg_a != reg_d) || reg_a != 0) { ppc_effective_address += ppc_result_a; - address_quickgrab_translate(ppc_effective_address, 4); - ppc_result_d = return_value; + address_grab32bit_translate(ppc_effective_address); + ppc_result_d = (uint32_t)return_value; return_value = 0; ppc_store_result_regd(); ppc_result_a = ppc_effective_address; @@ -2251,8 +2247,8 @@ void ppc_lwzu() { void ppc_lwzx() { ppc_grab_regsdab(); ppc_effective_address = (reg_a == 0) ? ppc_result_b : (ppc_result_a + ppc_result_b); - address_quickgrab_translate(ppc_effective_address, 4); - ppc_result_d = return_value; + address_grab32bit_translate(ppc_effective_address); + ppc_result_d = (uint32_t)return_value; return_value = 0; ppc_store_result_regd(); } @@ -2265,8 +2261,8 @@ void ppc_lwzux() { else { ppc_exception_handler(Except_Type::EXC_PROGRAM, 0x20000); } - address_quickgrab_translate(ppc_effective_address, 4); - ppc_result_d = return_value; + address_grab32bit_translate(ppc_effective_address); + ppc_result_d = (uint32_t)return_value; return_value = 0; ppc_result_a = ppc_effective_address; ppc_store_result_regd(); @@ -2278,8 +2274,8 @@ void ppc_lwarx() { ppc_grab_regsdab(); ppc_effective_address = (reg_a == 0) ? ppc_result_b : (ppc_result_a + ppc_result_b); ppc_state.ppc_reserve = true; - address_quickgrab_translate(ppc_effective_address, 4); - ppc_result_d = return_value; + address_grab32bit_translate(ppc_effective_address); + ppc_result_d = (uint32_t)return_value; return_value = 0; ppc_store_result_regd(); } @@ -2290,8 +2286,8 @@ void ppc_lmw() { ppc_effective_address += (reg_a > 0) ? ppc_result_a : 0; //How many words to load in memory - using a do-while for this do { - address_quickgrab_translate(ppc_effective_address, 4); - ppc_state.ppc_gpr[reg_d] = return_value; + address_grab32bit_translate(ppc_effective_address); + ppc_state.ppc_gpr[reg_d] = (uint32_t)return_value; return_value = 0; ppc_effective_address += 4; reg_d++; @@ -2309,26 +2305,26 @@ void ppc_lswi() { while (grab_inb > 0) { switch (shift_times) { case 0: - address_quickgrab_translate(ppc_effective_address, 1); - ppc_state.ppc_gpr[reg_d] = (ppc_result_d & 0x00FFFFFFUL) | (return_value << 24); + address_grab8bit_translate(ppc_effective_address);; + ppc_state.ppc_gpr[reg_d] = (ppc_result_d & 0x00FFFFFFUL) | ((uint32_t)return_value << 24); ppc_store_result_regd(); return_value = 0; break; case 1: - address_quickgrab_translate(ppc_effective_address, 1); - ppc_result_d = (ppc_result_d & 0xFF00FFFFUL) | (return_value << 16); + address_grab8bit_translate(ppc_effective_address);; + ppc_result_d = (ppc_result_d & 0xFF00FFFFUL) | ((uint32_t)return_value << 16); ppc_store_result_regd(); return_value = 0; break; case 2: - address_quickgrab_translate(ppc_effective_address, 1); - ppc_result_d = (ppc_result_d & 0xFFFF00FFUL) | (return_value << 8); + address_grab8bit_translate(ppc_effective_address);; + ppc_result_d = (ppc_result_d & 0xFFFF00FFUL) | ((uint32_t)return_value << 8); ppc_store_result_regd(); return_value = 0; break; case 3: - address_quickgrab_translate(ppc_effective_address, 1); - ppc_result_d = (ppc_result_d & 0xFFFFFF00UL) | return_value; + address_grab8bit_translate(ppc_effective_address);; + ppc_result_d = (ppc_result_d & 0xFFFFFF00UL) | (uint32_t)return_value; ppc_store_result_regd(); return_value = 0; break; @@ -2363,26 +2359,26 @@ void ppc_lswx() { while (grab_inb > 0) { switch (shift_times) { case 0: - address_quickgrab_translate(ppc_effective_address, 1); - ppc_result_d = (ppc_result_d & 0x00FFFFFFUL) | (return_value << 24); + address_grab8bit_translate(ppc_effective_address);; + ppc_result_d = (ppc_result_d & 0x00FFFFFFUL) | ((uint32_t)return_value << 24); ppc_store_result_regd(); return_value = 0; break; case 1: - address_quickgrab_translate(ppc_effective_address, 1); - ppc_result_d = (ppc_result_d & 0xFF00FFFFUL) | (return_value << 16); + address_grab8bit_translate(ppc_effective_address);; + ppc_result_d = (ppc_result_d & 0xFF00FFFFUL) | ((uint32_t)return_value << 16); ppc_store_result_regd(); return_value = 0; break; case 2: - address_quickgrab_translate(ppc_effective_address, 1); - ppc_result_d = (ppc_result_d & 0xFFFF00FFUL) | (return_value << 8); + address_grab8bit_translate(ppc_effective_address);; + ppc_result_d = (ppc_result_d & 0xFFFF00FFUL) | ((uint32_t)return_value << 8); ppc_store_result_regd(); return_value = 0; break; case 3: - address_quickgrab_translate(ppc_effective_address, 1); - ppc_result_d = (ppc_result_d & 0xFFFFFF00UL) | return_value; + address_grab8bit_translate(ppc_effective_address);; + ppc_result_d = (ppc_result_d & 0xFFFFFF00UL) | (uint32_t)return_value; ppc_store_result_regd(); return_value = 0; break; @@ -2413,19 +2409,19 @@ void ppc_stswi() { switch (shift_times) { case 0: strwrd_replace_value = (ppc_result_d >> 24); - address_quickinsert_translate(strwrd_replace_value, ppc_effective_address, 1); + address_insert8bit_translate(strwrd_replace_value, ppc_effective_address); break; case 1: strwrd_replace_value = (ppc_result_d >> 16); - address_quickinsert_translate(strwrd_replace_value, ppc_effective_address, 1); + address_insert8bit_translate(strwrd_replace_value, ppc_effective_address); break; case 2: strwrd_replace_value = (ppc_result_d >> 8); - address_quickinsert_translate(strwrd_replace_value, ppc_effective_address, 1); + address_insert8bit_translate(strwrd_replace_value, ppc_effective_address); break; case 3: strwrd_replace_value = (ppc_result_d); - address_quickinsert_translate(strwrd_replace_value, ppc_effective_address, 1); + address_insert8bit_translate(strwrd_replace_value, ppc_effective_address); break; default: printf("Something really horrible happened with stswi."); @@ -2452,19 +2448,19 @@ void ppc_stswx() { switch (shift_times) { case 0: strwrd_replace_value = (ppc_result_d >> 24); - address_quickinsert_translate(strwrd_replace_value, ppc_effective_address, 1); + address_insert8bit_translate(strwrd_replace_value, ppc_effective_address); break; case 1: strwrd_replace_value = (ppc_result_d >> 16); - address_quickinsert_translate(strwrd_replace_value, ppc_effective_address, 1); + address_insert8bit_translate(strwrd_replace_value, ppc_effective_address); break; case 2: strwrd_replace_value = (ppc_result_d >> 8); - address_quickinsert_translate(strwrd_replace_value, ppc_effective_address, 1); + address_insert8bit_translate(strwrd_replace_value, ppc_effective_address); break; case 3: strwrd_replace_value = (ppc_result_d); - address_quickinsert_translate(strwrd_replace_value, ppc_effective_address, 1); + address_insert8bit_translate(strwrd_replace_value, ppc_effective_address); break; default: printf("Something really horrible happened with stswx."); @@ -2472,19 +2468,19 @@ void ppc_stswx() { if (shift_times == 3) { shift_times = 0; reg_s = (reg_s + 1) & 0x1F; - } + } else { shift_times++; } return_value = 0; ppc_effective_address++; grab_inb--; -} + } } //TLB Instructions -void ppc_tlbie(){ +void ppc_tlbie() { #ifdef PROFILER supervisor_inst_num++; #endif @@ -2495,21 +2491,21 @@ void ppc_tlbie(){ printf("Placeholder for tlbie \n"); } -void ppc_tlbia(){ +void ppc_tlbia() { #ifdef PROFILER supervisor_inst_num++; #endif printf("Placeholder for tlbia \n"); } -void ppc_tlbld(){ +void ppc_tlbld() { #ifdef PROFILER supervisor_inst_num++; #endif printf("Placeholder for tlbld - 603 only \n"); } -void ppc_tlbli(){ +void ppc_tlbli() { #ifdef PROFILER supervisor_inst_num++; #endif @@ -2521,4 +2517,4 @@ void ppc_tlbsync() { supervisor_inst_num++; #endif printf("Placeholder for tlbsync \n"); -} +} \ No newline at end of file diff --git a/main.cpp b/main.cpp index 70750ed..8f26264 100644 --- a/main.cpp +++ b/main.cpp @@ -68,7 +68,7 @@ uint32_t ppc_effective_address; uint32_t ppc_real_address; uint32_t ppc_next_instruction_address; //Used for branching, setting up the NIA -uint32_t return_value; +uint64_t return_value; MemCtrlBase *mem_ctrl_instance = 0; HeathrowIC *heathrow = 0; diff --git a/memreadwrite.h b/memreadwrite.h index 8e82e29..c006e1e 100644 --- a/memreadwrite.h +++ b/memreadwrite.h @@ -8,18 +8,23 @@ #include #include "endianswap.h" -/* read an aligned big-endian WORD (16bit) */ + /* read an aligned big-endian WORD (16bit) */ #define READ_WORD_BE_A(addr) (BYTESWAP_16(*((uint16_t *)((addr))))) /* read an aligned big-endian DWORD (32bit) */ #define READ_DWORD_BE_A(addr) (BYTESWAP_32(*((uint32_t *)((addr))))) +/* read an aligned big-endian QWORD (64bit) */ +#define READ_QWORD_BE_A(addr) (BYTESWAP_64(*((uint64_t *)((addr))))) + /* read an aligned little-endian WORD (16bit) */ #define READ_WORD_LE_A(addr) (*(uint16_t *)((addr))) /* read an aligned little-endian DWORD (32bit) */ #define READ_DWORD_LE_A(addr) (*(uint32_t *)((addr))) +/* read an aligned little-endian QWORD (64bit) */ +#define READ_QWORD_LE_A(addr) (*(uint64_t *)((addr))) /* read an unaligned big-endian WORD (16bit) */ #define READ_WORD_BE_U(addr) (((addr)[0] << 8) | (addr)[1]) @@ -28,6 +33,12 @@ #define READ_DWORD_BE_U(addr) (((addr)[0] << 24) | ((addr)[1] << 16) | \ ((addr)[2] << 8) | (addr)[3]) +/* read an unaligned big-endian QWORD (32bit) */ +#define READ_QWORD_BE_U(addr) (((addr)[0] << 56) | ((addr)[1] << 48) | \ + ((addr)[2] << 40) | ((addr)[3] << 32) | \ + ((addr)[4] << 24) | ((addr)[5] << 16) | \ + ((addr)[6] << 8) | (addr)[7]) + /* read an unaligned little-endian WORD (16bit) */ #define READ_WORD_LE_U(addr) (((addr)[1] << 8) | (ptr)[0]) @@ -35,4 +46,9 @@ #define READ_DWORD_LE_U(addr) (((addr)[3] << 24) | ((addr)[2] << 16) | \ ((addr)[1] << 8) | (addr)[0]) -#endif /* MEM_READ_WRITE_H */ +/* read an unaligned little-endian DWORD (32bit) */ +#define READ_QWORD_LE_U(addr) (((addr)[7] << 56) | ((addr)[6] << 48) | \ + ((addr)[5] << 40) | ((addr)[4] << 32) | \ + ((addr)[3] << 24) | ((addr)[2] << 16) | \ + ((addr)[1] << 8) | (addr)[0]) +#endif /* MEM_READ_WRITE_H */ \ No newline at end of file