2541 lines
75 KiB
C++
2541 lines
75 KiB
C++
//DingusPPC - Prototype 5bf2
|
|
//Written by divingkatae
|
|
//(c)2018-20 (theweirdo)
|
|
//Please ask for permission
|
|
//if you want to distribute this.
|
|
//(divingkatae#1017 on Discord)
|
|
|
|
// General opcodes for the processor - ppcopcodes.cpp
|
|
|
|
#include <iostream>
|
|
#include <map>
|
|
#include <unordered_map>
|
|
#include <cstring>
|
|
#include <cinttypes>
|
|
#include <array>
|
|
#include <thread>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <stdexcept>
|
|
#include "ppcemumain.h"
|
|
#include "ppcmemory.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 br_bo;
|
|
uint32_t br_bi;
|
|
uint32_t rot_sh;
|
|
uint32_t rot_mb;
|
|
uint32_t rot_me;
|
|
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 grab_d; //This is for grabbing d from Store and Load instructions
|
|
uint32_t ppc_to;
|
|
int32_t simm;
|
|
int32_t adr_li;
|
|
int32_t br_bd;
|
|
|
|
//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;
|
|
|
|
int32_t sidiv_result;
|
|
uint32_t uidiv_result;
|
|
uint64_t uiproduct;
|
|
int64_t siproduct;
|
|
|
|
uint32_t strwrd_replace_value;
|
|
|
|
/**
|
|
Extract the registers desired and the values of the registers
|
|
This also takes the MSR into account, mainly to determine
|
|
what endian the numbers are to be stored in.
|
|
**/
|
|
|
|
//Storage and register retrieval functions for the integer functions.
|
|
void ppc_store_result_regd(){
|
|
ppc_state.ppc_gpr[reg_d] = ppc_result_d;
|
|
}
|
|
|
|
void ppc_store_result_rega(){
|
|
ppc_state.ppc_gpr[reg_a] = ppc_result_a;
|
|
}
|
|
|
|
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(){
|
|
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_regssasimm(){
|
|
reg_s = (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];
|
|
ppc_result_d = ppc_state.ppc_gpr[reg_s];
|
|
}
|
|
|
|
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));
|
|
ppc_result_d = ppc_state.ppc_gpr[reg_s];
|
|
ppc_result_a = ppc_state.ppc_gpr[reg_a];
|
|
}
|
|
|
|
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;
|
|
ppc_result_a = ppc_state.ppc_gpr[reg_a];
|
|
ppc_result_b = ppc_state.ppc_gpr[reg_b];
|
|
}
|
|
|
|
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;
|
|
ppc_result_d = ppc_state.ppc_gpr[reg_s];
|
|
ppc_result_a = ppc_state.ppc_gpr[reg_a];
|
|
ppc_result_b = ppc_state.ppc_gpr[reg_b];
|
|
}
|
|
|
|
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(){
|
|
reg_s = (ppc_cur_instruction >> 21) & 31;
|
|
reg_b = (ppc_cur_instruction >> 16) & 31;
|
|
ppc_result_d = ppc_state.ppc_gpr[reg_s];
|
|
ppc_result_b = ppc_state.ppc_gpr[reg_b];
|
|
}
|
|
|
|
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(){
|
|
reg_d = (ppc_cur_instruction >> 21) & 31;
|
|
reg_b = (ppc_cur_instruction >> 11) & 31;
|
|
ppc_result_b = ppc_state.ppc_gpr[reg_b];
|
|
}
|
|
|
|
|
|
//Affects CR Field 0 - For integer operations
|
|
void ppc_changecrf0(uint32_t set_result){
|
|
ppc_state.ppc_cr &= 0x0FFFFFFF;
|
|
|
|
if (set_result == 0){
|
|
ppc_state.ppc_cr |= 0x20000000;
|
|
}
|
|
else if (set_result & 0x80000000){
|
|
ppc_state.ppc_cr |= 0x80000000;
|
|
}
|
|
else{
|
|
ppc_state.ppc_cr |= 0x40000000;
|
|
}
|
|
|
|
if (ppc_state.ppc_spr[1] & 0x80000000){
|
|
ppc_state.ppc_cr |= 0x10000000;
|
|
}
|
|
}
|
|
|
|
//Affects the XER register's Carry Bit
|
|
void ppc_carry(uint32_t a, uint32_t b){
|
|
if (b < a){ // TODO: ensure it works everywhere
|
|
ppc_state.ppc_spr[1] |= 0x20000000;
|
|
}
|
|
else{
|
|
ppc_state.ppc_spr[1] &= 0xDFFFFFFF;
|
|
}
|
|
}
|
|
|
|
//Affects the XER register's SO and OV Bits
|
|
void ppc_setsoov(uint32_t a, uint32_t b){
|
|
uint64_t a64b = (uint64_t)a;
|
|
uint64_t b64b = (uint64_t)b;
|
|
|
|
if ((a64b + b64b) > 0xFFFFFFFF){
|
|
ppc_state.ppc_spr[1] |= 0x40000000;
|
|
}
|
|
else{
|
|
ppc_state.ppc_spr[1] &= 0xBFFFFFFF;
|
|
}
|
|
|
|
if (((a64b + b64b) < 0x80000000) || (ppc_state.ppc_spr[1] & 0x40000000)){
|
|
ppc_state.ppc_spr[1] |= 0x80000000;
|
|
}
|
|
else{
|
|
ppc_state.ppc_spr[1] &= 0x7FFFFFFF;
|
|
}
|
|
}
|
|
|
|
/**
|
|
Avoid some tedious steps to breaking down the opcodes,
|
|
allowing for some nice maps to cleanly organize each opcode.
|
|
**/
|
|
|
|
void ppc_illegalop(){
|
|
uint8_t illegal_code = ppc_cur_instruction >> 26;
|
|
uint32_t grab_it = (uint32_t) illegal_code;
|
|
printf("Illegal opcode reported: %d Report this! \n", grab_it);
|
|
exit(-1);
|
|
//ppc_expection_handler(0x0700, 0x80000);
|
|
}
|
|
|
|
void ppc_illegalsubop31(){
|
|
uint16_t illegal_subcode = ppc_cur_instruction & 2047;
|
|
uint32_t grab_it = (uint32_t) illegal_subcode;
|
|
printf("Illegal subopcode for 31 reported: %d Report this! \n", grab_it);
|
|
}
|
|
|
|
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;
|
|
printf("Executing subopcode entry %d \n .. or would if I bothered to implement it. SORRY!", regrab);
|
|
exit(0);
|
|
}
|
|
|
|
void ppc_opcode16(){
|
|
uint8_t subop_grab = ppc_cur_instruction & 3;
|
|
|
|
#ifdef EXHAUSTIVE_DEBUG
|
|
uint32_t regrab = (uint32_t)subop_grab;
|
|
printf("Executing Opcode 16 table subopcode entry %d \n", regrab);
|
|
SubOpcode16Grabber[subop_grab]();
|
|
#else
|
|
SubOpcode16Grabber[subop_grab]();
|
|
#endif // EXHAUSTIVE_DEBUG
|
|
}
|
|
|
|
void ppc_opcode18(){
|
|
uint8_t subop_grab = ppc_cur_instruction & 3;
|
|
//printf("Reading from Opcode 18 table \n");
|
|
//uint32_t regrab = (uint32_t)subop_grab;
|
|
//printf("Executing subopcode entry %d \n", regrab);
|
|
SubOpcode18Grabber[subop_grab]();
|
|
}
|
|
|
|
void ppc_opcode19(){
|
|
uint16_t subop_grab = ppc_cur_instruction & 2047;
|
|
#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){
|
|
SubOpcode19Grabber[subop_grab]();
|
|
}
|
|
else{
|
|
std::cout << "ILLEGAL SUBOPCODE: " << subop_grab << std::endl;
|
|
ppc_expection_handler(0x0700, 0x80000);
|
|
}
|
|
#else
|
|
SubOpcode19Grabber[subop_grab]();
|
|
#endif // EXHAUSTIVE_DEBUG
|
|
}
|
|
|
|
void ppc_opcode31(){
|
|
uint16_t subop_grab = ppc_cur_instruction & 2047;
|
|
#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){
|
|
SubOpcode31Grabber[subop_grab]();
|
|
}
|
|
else{
|
|
std::cout << "ILLEGAL SUBOPCODE: " << subop_grab << std::endl;
|
|
ppc_expection_handler(0x0700, 0x80000);
|
|
}
|
|
#else
|
|
SubOpcode31Grabber[subop_grab]();
|
|
#endif // EXHAUSTIVE_DEBUG
|
|
}
|
|
|
|
void ppc_opcode59(){
|
|
uint16_t subop_grab = ppc_cur_instruction & 2047;
|
|
#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){
|
|
SubOpcode59Grabber[subop_grab]();
|
|
}
|
|
else{
|
|
std::cout << "ILLEGAL SUBOPCODE: " << subop_grab << std::endl;
|
|
ppc_expection_handler(0x0700, 0x80000);
|
|
}
|
|
#else
|
|
SubOpcode59Grabber[subop_grab]();
|
|
#endif // EXHAUSTIVE_DEBUG
|
|
}
|
|
|
|
void ppc_opcode63(){
|
|
uint16_t subop_grab = ppc_cur_instruction & 2047;
|
|
#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){
|
|
SubOpcode63Grabber[subop_grab]();
|
|
}
|
|
else{
|
|
std::cout << "ILLEGAL SUBOPCODE: " << subop_grab << std::endl;
|
|
ppc_expection_handler(0x0700, 0x80000);
|
|
}
|
|
#else
|
|
SubOpcode63Grabber[subop_grab]();
|
|
#endif // EXHAUSTIVE_DEBUG
|
|
}
|
|
|
|
void ppc_main_opcode(){
|
|
//Grab the main opcode
|
|
uint8_t ppc_mainop = (ppc_cur_instruction >> 26) & 63;
|
|
//printf("Main Opcode: %d \n", ppc_mainop);
|
|
OpcodeGrabber[ppc_mainop]();
|
|
}
|
|
|
|
/**
|
|
The core functionality of this PPC emulation is within all of these void functions.
|
|
This is where the opcode tables in the ppcemumain.h come into play - reducing the number of comparisons needed.
|
|
This means loads of functions, but less CPU cycles needed to determine the function (theoretically).
|
|
**/
|
|
|
|
void ppc_addi(){
|
|
ppc_grab_regsdasimm();
|
|
ppc_result_d = (reg_a == 0)?simm:(ppc_result_a + simm);
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
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(){
|
|
ppc_grab_regsdasimm();
|
|
ppc_result_d = (ppc_result_a + simm);
|
|
ppc_changecrf0(ppc_result_d);
|
|
ppc_carry(ppc_result_a, ppc_result_d);
|
|
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(){
|
|
ppc_grab_regsdab();
|
|
ppc_result_d = ppc_result_a + ppc_result_b;
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
void ppc_adddot(){
|
|
ppc_grab_regsdab();
|
|
ppc_result_d = ppc_result_a + ppc_result_b;
|
|
ppc_changecrf0(ppc_result_d);
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
//addo + addodot
|
|
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(){
|
|
ppc_grab_regsdab();
|
|
ppc_setsoov(ppc_result_a, ppc_result_b);
|
|
ppc_result_d = ppc_result_a + ppc_result_b;
|
|
ppc_changecrf0(ppc_result_d);
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
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(){
|
|
ppc_grab_regsdab();
|
|
ppc_result_d = ppc_result_a + ppc_result_b;
|
|
ppc_carry(ppc_result_a, ppc_result_d);
|
|
ppc_changecrf0(ppc_result_d);
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
void ppc_addco(){
|
|
ppc_grab_regsdab();
|
|
ppc_setsoov(ppc_result_a, ppc_result_b);
|
|
ppc_result_d = ppc_result_a + ppc_result_b;
|
|
ppc_carry(ppc_result_a, ppc_result_d);
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
void ppc_addcodot(){
|
|
ppc_grab_regsdab();
|
|
ppc_setsoov(ppc_result_a, ppc_result_b);
|
|
ppc_result_d = ppc_result_a + ppc_result_b;
|
|
ppc_carry(ppc_result_a, ppc_result_d);
|
|
ppc_changecrf0(ppc_result_d);
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
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))){
|
|
ppc_state.ppc_spr[1] |= 0x20000000;
|
|
}
|
|
else{
|
|
ppc_state.ppc_spr[1] &= 0xDFFFFFFF;
|
|
}
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
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))){
|
|
ppc_state.ppc_spr[1] |= 0x20000000;
|
|
}
|
|
else{
|
|
ppc_state.ppc_spr[1] &= 0xDFFFFFFF;
|
|
}
|
|
ppc_changecrf0(ppc_result_d);
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
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))){
|
|
ppc_state.ppc_spr[1] |= 0x20000000;
|
|
}
|
|
else{
|
|
ppc_state.ppc_spr[1] &= 0xDFFFFFFF;
|
|
}
|
|
ppc_changecrf0(ppc_result_d);
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
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))){
|
|
ppc_state.ppc_spr[1] |= 0x20000000;
|
|
}
|
|
else{
|
|
ppc_state.ppc_spr[1] &= 0xDFFFFFFF;
|
|
}
|
|
ppc_changecrf0(ppc_result_d);
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
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) < 0xFFFFFFFF) | (ppc_result_d < ppc_result_a)){
|
|
ppc_state.ppc_spr[1] |= 0x20000000;
|
|
}
|
|
else{
|
|
ppc_state.ppc_spr[1] &= 0xDFFFFFFF;
|
|
}
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
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) < 0xFFFFFFFF) | (ppc_result_d < ppc_result_a)){
|
|
ppc_state.ppc_spr[1] |= 0x20000000;
|
|
}
|
|
else{
|
|
ppc_state.ppc_spr[1] &= 0xDFFFFFFF;
|
|
}
|
|
ppc_changecrf0(ppc_result_d);
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
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) < 0xFFFFFFFF) | (ppc_result_d < ppc_result_a)){
|
|
ppc_state.ppc_spr[1] |= 0x20000000;
|
|
}
|
|
else{
|
|
ppc_state.ppc_spr[1] &= 0xDFFFFFFF;
|
|
}
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
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) < 0xFFFFFFFF) | (ppc_result_d < ppc_result_a)){
|
|
ppc_state.ppc_spr[1] |= 0x20000000;
|
|
}
|
|
else{
|
|
ppc_state.ppc_spr[1] &= 0xDFFFFFFF;
|
|
}
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
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){
|
|
ppc_state.ppc_spr[1] |= 0x20000000;
|
|
}
|
|
else{
|
|
ppc_state.ppc_spr[1] &= 0xDFFFFFFF;
|
|
}
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
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){
|
|
ppc_state.ppc_spr[1] |= 0x20000000;
|
|
}
|
|
else{
|
|
ppc_state.ppc_spr[1] &= 0xDFFFFFFF;
|
|
}
|
|
ppc_changecrf0(ppc_result_d);
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
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){
|
|
ppc_state.ppc_spr[1] |= 0x20000000;
|
|
}
|
|
else{
|
|
ppc_state.ppc_spr[1] &= 0xDFFFFFFF;
|
|
}
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
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){
|
|
ppc_state.ppc_spr[1] |= 0x20000000;
|
|
}
|
|
else{
|
|
ppc_state.ppc_spr[1] &= 0xDFFFFFFF;
|
|
}
|
|
ppc_changecrf0(ppc_result_d);
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
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(){
|
|
ppc_grab_regsdab();
|
|
not_this = ~ppc_result_a;
|
|
ppc_result_d = not_this + ppc_result_b + 1;
|
|
ppc_changecrf0(ppc_result_d);
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
void ppc_subfo(){
|
|
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;
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
void ppc_subfodot(){
|
|
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;
|
|
ppc_changecrf0(ppc_result_d);
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
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){
|
|
ppc_state.ppc_spr[1] |= 0x20000000;
|
|
}
|
|
else{
|
|
ppc_state.ppc_spr[1] &= 0xDFFFFFFF;
|
|
}
|
|
ppc_carry(ppc_result_a, ppc_result_d);
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
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){
|
|
ppc_state.ppc_spr[1] |= 0x20000000;
|
|
}
|
|
else{
|
|
ppc_state.ppc_spr[1] &= 0xDFFFFFFF;
|
|
}
|
|
ppc_carry(ppc_result_a, ppc_result_d);
|
|
ppc_changecrf0(ppc_result_d);
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
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){
|
|
ppc_state.ppc_spr[1] |= 0x20000000;
|
|
}
|
|
else{
|
|
ppc_state.ppc_spr[1] &= 0xDFFFFFFF;
|
|
}
|
|
ppc_carry(ppc_result_a, ppc_result_d);
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
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){
|
|
ppc_state.ppc_spr[1] |= 0x20000000;
|
|
}
|
|
else{
|
|
ppc_state.ppc_spr[1] &= 0xDFFFFFFF;
|
|
}
|
|
ppc_carry(ppc_result_a, ppc_result_d);
|
|
ppc_changecrf0(ppc_result_d);
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
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] |= 0x20000000;
|
|
}
|
|
else{
|
|
ppc_state.ppc_spr[1] &= 0xDFFFFFFF;
|
|
}
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
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)){
|
|
ppc_state.ppc_spr[1] |= 0x20000000;
|
|
}
|
|
else{
|
|
ppc_state.ppc_spr[1] &= 0xDFFFFFFF;
|
|
}
|
|
ppc_carry(ppc_result_a, ppc_result_d);
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
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)){
|
|
ppc_state.ppc_spr[1] |= 0x20000000;
|
|
}
|
|
else{
|
|
ppc_state.ppc_spr[1] &= 0xDFFFFFFF;
|
|
}
|
|
ppc_carry(ppc_result_a, ppc_result_d);
|
|
ppc_state.ppc_spr[1] &= 0xDFFFFFFF;
|
|
ppc_changecrf0(ppc_result_d);
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
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){
|
|
ppc_state.ppc_spr[1] |= 0x20000000;
|
|
}
|
|
else{
|
|
ppc_state.ppc_spr[1] &= 0xDFFFFFFF;
|
|
}
|
|
ppc_carry(ppc_result_a, grab_xer);
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
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)){
|
|
ppc_state.ppc_spr[1] |= 0x20000000;
|
|
}
|
|
else{
|
|
ppc_state.ppc_spr[1] &= 0xDFFFFFFF;
|
|
}
|
|
ppc_carry(ppc_result_a, grab_xer);
|
|
ppc_changecrf0(ppc_result_d);
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
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){
|
|
ppc_state.ppc_spr[1] |= 0x20000000;
|
|
}
|
|
else{
|
|
ppc_state.ppc_spr[1] &= 0xDFFFFFFF;
|
|
}
|
|
ppc_carry(ppc_result_a, (ppc_state.ppc_spr[1] & 0x20000000));
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
void ppc_subfzedot(){
|
|
ppc_grab_regsda();
|
|
not_this = ~ppc_result_a;
|
|
ppc_result_d = not_this + (ppc_state.ppc_spr[1] & 0x20000000);
|
|
if (ppc_result_d <= not_this){
|
|
ppc_state.ppc_spr[1] |= 0x20000000;
|
|
}
|
|
else{
|
|
ppc_state.ppc_spr[1] &= 0xDFFFFFFF;
|
|
}
|
|
ppc_carry(ppc_result_a, (ppc_state.ppc_spr[1] & 0x20000000));
|
|
ppc_changecrf0(ppc_result_d);
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
void ppc_and(){
|
|
ppc_grab_regssab();
|
|
ppc_result_a = ppc_result_d & ppc_result_b;
|
|
ppc_store_result_rega();
|
|
}
|
|
|
|
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(){
|
|
ppc_grab_regssab();
|
|
ppc_result_a = ppc_result_d & ~(ppc_result_b);
|
|
ppc_store_result_rega();
|
|
}
|
|
|
|
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(){
|
|
ppc_grab_regssauimm();
|
|
ppc_result_a = ppc_result_d & uimm;
|
|
ppc_changecrf0(ppc_result_a);
|
|
ppc_store_result_rega();
|
|
}
|
|
|
|
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(){
|
|
ppc_grab_regssab();
|
|
ppc_result_a = ~(ppc_result_d & ppc_result_b);
|
|
ppc_store_result_rega();
|
|
}
|
|
|
|
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(){
|
|
ppc_grab_regssab();
|
|
ppc_result_a = ppc_result_d | ppc_result_b;
|
|
printf("OR Result: %x in Reg %d from Regs %d and %d \n", ppc_result_a, reg_a, reg_s, reg_b);
|
|
ppc_store_result_rega();
|
|
}
|
|
|
|
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(){
|
|
ppc_grab_regssab();
|
|
ppc_result_a = ppc_result_d | ~(ppc_result_b);
|
|
ppc_store_result_rega();
|
|
}
|
|
|
|
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(){
|
|
ppc_grab_regssauimm();
|
|
ppc_result_a = ppc_result_d | uimm;
|
|
ppc_store_result_rega();
|
|
}
|
|
|
|
void ppc_oris(){
|
|
ppc_grab_regssauimm();
|
|
ppc_result_a = ppc_result_d | (uimm << 16);
|
|
ppc_store_result_rega();
|
|
}
|
|
|
|
void ppc_eqv(){
|
|
ppc_grab_regssab();
|
|
ppc_result_a = ~(ppc_result_d ^ ppc_result_b);
|
|
ppc_store_result_rega();
|
|
}
|
|
|
|
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(){
|
|
ppc_grab_regssab();
|
|
ppc_result_a = ~(ppc_result_d | ppc_result_b);
|
|
ppc_store_result_rega();
|
|
}
|
|
|
|
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(){
|
|
ppc_grab_regssab();
|
|
ppc_result_a = ppc_result_d ^ ppc_result_b;
|
|
ppc_store_result_rega();
|
|
}
|
|
|
|
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(){
|
|
ppc_grab_regssauimm();
|
|
ppc_result_a = ppc_result_d ^ uimm;
|
|
ppc_store_result_rega();
|
|
}
|
|
|
|
void ppc_xoris(){
|
|
ppc_grab_regssauimm();
|
|
ppc_result_a = ppc_result_d ^ (uimm << 16);
|
|
ppc_store_result_rega();
|
|
}
|
|
|
|
void ppc_neg(){
|
|
ppc_grab_regsda();
|
|
ppc_result_d = ~(ppc_result_a) + 1;
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
void ppc_negdot(){
|
|
ppc_grab_regsda();
|
|
ppc_result_d = ~(ppc_result_a) + 1;
|
|
ppc_changecrf0(ppc_result_d);
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
void ppc_nego(){
|
|
ppc_grab_regsda();
|
|
ppc_result_d = ~(ppc_result_a) + 1;
|
|
ppc_state.ppc_spr[1] |= 0x40000000;
|
|
ppc_setsoov(ppc_result_d, 1);
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
void ppc_negodot(){
|
|
ppc_grab_regsda();
|
|
ppc_result_d = ~(ppc_result_a) + 1;
|
|
ppc_changecrf0(ppc_result_d);
|
|
ppc_state.ppc_spr[1] |= 0x40000000;
|
|
ppc_setsoov(ppc_result_d, 1);
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
void ppc_cntlzw(){
|
|
ppc_grab_regssa();
|
|
uint32_t trail = 0;
|
|
uint32_t bit_set = 0x80000000;
|
|
do{
|
|
if ((ppc_result_d && bit_set) == 1){
|
|
break;
|
|
}
|
|
bit_set = bit_set >> 1;
|
|
trail++;
|
|
} while (trail < 32);
|
|
ppc_result_a = trail;
|
|
ppc_store_result_rega();
|
|
}
|
|
|
|
void ppc_cntlzwdot(){
|
|
ppc_grab_regssa();
|
|
uint32_t trail = 0;
|
|
uint32_t bit_set = 0xF0000000;
|
|
do{
|
|
if ((ppc_result_d && bit_set) == 1){
|
|
break;
|
|
}
|
|
bit_set = bit_set >> 1;
|
|
trail++;
|
|
} while (trail < 32);
|
|
ppc_result_a = trail;
|
|
ppc_changecrf0(ppc_result_a);
|
|
ppc_store_result_rega();
|
|
}
|
|
|
|
void ppc_mulhwu(){
|
|
ppc_grab_regsdab();
|
|
uiproduct = (uint64_t) ppc_result_a * (uint64_t) ppc_result_b;
|
|
uiproduct = uiproduct >> 32;
|
|
ppc_result_d = uiproduct;
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
void ppc_mulhwudot(){
|
|
ppc_grab_regsdab();
|
|
uiproduct = (uint64_t) ppc_result_a * (uint64_t) ppc_result_b;
|
|
uiproduct = uiproduct >> 32;
|
|
ppc_result_d = uiproduct;
|
|
ppc_changecrf0(ppc_result_d);
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
void ppc_mulhw(){
|
|
ppc_grab_regsdab();
|
|
siproduct = (int64_t) ppc_result_a * (int64_t) ppc_result_b;
|
|
siproduct = siproduct >> 32;
|
|
ppc_result_d = (uint32_t) siproduct;
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
void ppc_mulhwdot(){
|
|
ppc_grab_regsdab();
|
|
siproduct = (int64_t) ppc_result_a * (int64_t) ppc_result_b;
|
|
siproduct = siproduct >> 32;
|
|
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(){
|
|
ppc_grab_regsdab();
|
|
siproduct = ppc_result_a * ppc_result_b;
|
|
siproduct &= 4294967295;
|
|
ppc_result_d = (uint32_t) siproduct;
|
|
ppc_changecrf0(ppc_result_d);
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
void ppc_mullwo(){
|
|
ppc_grab_regsdab();
|
|
ppc_setsoov(ppc_result_a, ppc_result_b);
|
|
siproduct = ppc_result_a * ppc_result_b;
|
|
siproduct &= 4294967295;
|
|
ppc_result_d = (uint32_t) siproduct;
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
void ppc_mullwodot(){
|
|
ppc_grab_regsdab();
|
|
ppc_setsoov(ppc_result_a, ppc_result_b);
|
|
siproduct = ppc_result_a * ppc_result_b;
|
|
siproduct &= 4294967295;
|
|
ppc_result_d = (uint32_t) siproduct;
|
|
ppc_changecrf0(ppc_result_d);
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
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_store_result_regd();
|
|
}
|
|
|
|
|
|
void ppc_divw(){
|
|
ppc_grab_regsdab();
|
|
|
|
//handle division by zero cases
|
|
if (ppc_result_b == 0){
|
|
ppc_result_d = 0;
|
|
ppc_store_result_regd();
|
|
return;
|
|
}
|
|
else if ((ppc_result_a == 0x80000000) & (ppc_result_b == 0xFFFFFFFF)){
|
|
ppc_result_d = 0;
|
|
ppc_store_result_regd();
|
|
return;
|
|
}
|
|
|
|
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(){
|
|
ppc_grab_regsdab();
|
|
|
|
//handle division by zero cases
|
|
if (ppc_result_b == 0){
|
|
ppc_result_d = 0;
|
|
ppc_store_result_regd();
|
|
ppc_state.ppc_cr &= 0x1FFFFFFF;
|
|
return;
|
|
}
|
|
else if ((ppc_result_a == 0x80000000) & (ppc_result_b == 0xFFFFFFFF)){
|
|
ppc_result_d = 0;
|
|
ppc_store_result_regd();
|
|
ppc_state.ppc_cr &= 0x1FFFFFFF;
|
|
return;
|
|
}
|
|
|
|
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(){
|
|
ppc_grab_regsdab();
|
|
|
|
//handle division by zero cases
|
|
if (ppc_result_b == 0){
|
|
ppc_result_d = 0;
|
|
ppc_state.ppc_cr |= 0x10000000;
|
|
ppc_store_result_regd();
|
|
return;
|
|
}
|
|
else if ((ppc_result_a == 0x80000000) & (ppc_result_b == 0xFFFFFFFF)){
|
|
ppc_result_d = 0;
|
|
ppc_state.ppc_cr |= 0x10000000;
|
|
ppc_store_result_regd();
|
|
return;
|
|
}
|
|
|
|
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;
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
void ppc_divwodot(){
|
|
ppc_grab_regsdab();
|
|
|
|
//handle division by zero cases
|
|
if (ppc_result_b == 0){
|
|
ppc_result_d = 0;
|
|
ppc_store_result_regd();
|
|
ppc_state.ppc_cr &= 0x1FFFFFFF;
|
|
ppc_state.ppc_cr |= 0x10000000;
|
|
return;
|
|
}
|
|
else if ((ppc_result_a == 0x80000000) & (ppc_result_b == 0xFFFFFFFF)){
|
|
ppc_result_d = 0;
|
|
ppc_store_result_regd();
|
|
ppc_state.ppc_cr &= 0x1FFFFFFF;
|
|
ppc_state.ppc_cr |= 0x10000000;
|
|
return;
|
|
}
|
|
|
|
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;
|
|
ppc_changecrf0(ppc_result_d);
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
void ppc_divwu(){
|
|
ppc_grab_regsdab();
|
|
|
|
//handle division by zero cases
|
|
if (ppc_result_b == 0){
|
|
ppc_result_d = 0;
|
|
ppc_store_result_regd();
|
|
return;
|
|
}
|
|
|
|
uidiv_result = ppc_result_a / ppc_result_b;
|
|
ppc_result_d = uidiv_result;
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
void ppc_divwudot(){
|
|
ppc_grab_regsdab();
|
|
|
|
//handle division by zero cases
|
|
if (ppc_result_b == 0){
|
|
ppc_result_d = 0;
|
|
ppc_store_result_regd();
|
|
ppc_state.ppc_cr &= 0x1FFFFFFF;
|
|
return;
|
|
}
|
|
|
|
uidiv_result = ppc_result_a / ppc_result_b;
|
|
ppc_result_d = uidiv_result;
|
|
ppc_changecrf0(ppc_result_d);
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
void ppc_divwuo(){
|
|
ppc_grab_regsdab();
|
|
|
|
//handle division by zero cases
|
|
if (ppc_result_b == 0){
|
|
ppc_result_d = 0;
|
|
ppc_state.ppc_cr |= 0x10000000;
|
|
ppc_store_result_regd();
|
|
return;
|
|
}
|
|
|
|
ppc_setsoov(ppc_result_a, ppc_result_b);
|
|
uidiv_result = ppc_result_a / ppc_result_b;
|
|
ppc_result_d = uidiv_result;
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
void ppc_divwuodot(){
|
|
ppc_grab_regsdab();
|
|
|
|
//handle division by zero cases
|
|
if (ppc_result_b == 0){
|
|
ppc_result_d = 0;
|
|
ppc_store_result_regd();
|
|
ppc_state.ppc_cr &= 0x1FFFFFFF;
|
|
ppc_state.ppc_cr |= 0x10000000;
|
|
return;
|
|
}
|
|
|
|
ppc_setsoov(ppc_result_a, ppc_result_b);
|
|
uidiv_result = ppc_result_a / ppc_result_b;
|
|
ppc_result_d = uidiv_result;
|
|
ppc_changecrf0(ppc_result_d);
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
//Value shifting
|
|
|
|
void ppc_slw(){
|
|
ppc_grab_regssab();
|
|
ppc_result_a = (ppc_result_b < 32)?(ppc_result_d << ppc_result_b):0;
|
|
ppc_store_result_rega();
|
|
}
|
|
|
|
void ppc_slwdot(){
|
|
ppc_grab_regssab();
|
|
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(){
|
|
ppc_grab_regssab();
|
|
ppc_result_a = (ppc_result_b < 32)?(ppc_result_d >> ppc_result_b):0;
|
|
ppc_store_result_rega();
|
|
}
|
|
|
|
void ppc_srwdot(){
|
|
ppc_grab_regssab();
|
|
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(){
|
|
ppc_grab_regssab();
|
|
|
|
if (ppc_result_b > 32){
|
|
ppc_result_a = ((ppc_result_d) > 0x7FFFFFFF)?0xFFFFFFFF:0x0;
|
|
ppc_state.ppc_spr[1] = (ppc_state.ppc_spr[1] & 0xDFFFFFFF) | (((ppc_result_d) > 0x7FFFFFFF)?0x20000000:0x0);
|
|
}
|
|
else{
|
|
ppc_result_a = (uint32_t)((int32_t)ppc_result_d >> ppc_result_b);
|
|
ppc_state.ppc_spr[1] = (ppc_state.ppc_spr[1] & 0xDFFFFFFF) | (((ppc_result_d) > 0x7FFFFFFF)?0x20000000:0x0);
|
|
}
|
|
ppc_store_result_rega();
|
|
}
|
|
|
|
void ppc_srawdot(){
|
|
ppc_grab_regssab();
|
|
if (ppc_result_b > 32){
|
|
ppc_result_a = ((ppc_result_d) > 0x7FFFFFFF)?0xFFFFFFFF:0x0;
|
|
ppc_state.ppc_spr[1] = (ppc_state.ppc_spr[1] & 0xDFFFFFFF) | (((ppc_result_d) > 0x7FFFFFFF)?0x20000000:0x0);
|
|
}
|
|
else{
|
|
ppc_result_a = (uint32_t)((int32_t)ppc_result_d >> ppc_result_b);
|
|
ppc_state.ppc_spr[1] = (ppc_state.ppc_spr[1] & 0xDFFFFFFF) | (((ppc_result_d) > 0x7FFFFFFF)?0x20000000:0x0);
|
|
}
|
|
ppc_changecrf0(ppc_result_a);
|
|
ppc_store_result_rega();
|
|
}
|
|
|
|
void ppc_srawi(){
|
|
ppc_grab_regssa();
|
|
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] & 0xDFFFFFFF) | (((ppc_result_d) > 0x7FFFFFFF)?0x20000000:0x0);
|
|
|
|
ppc_store_result_rega();
|
|
}
|
|
|
|
void ppc_srawidot(){
|
|
ppc_grab_regssa();
|
|
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] & 0xDFFFFFFF) | (((ppc_result_d) > 0x7FFFFFFF)?0x20000000:0x0);
|
|
|
|
ppc_changecrf0(ppc_result_a);
|
|
ppc_store_result_rega();
|
|
}
|
|
|
|
void ppc_rlwimi(){
|
|
ppc_grab_regssa();
|
|
rot_sh = (ppc_cur_instruction >> 11) & 31;
|
|
rot_mb = (ppc_cur_instruction >> 6) & 31;
|
|
rot_me = (ppc_cur_instruction >> 1) & 31;
|
|
uint32_t step1 = (0xFFFFFFFFUL << (31 - rot_me)) & (0xFFFFFFFFUL >> rot_mb);
|
|
uint32_t step2 = (rot_me < rot_mb)? ~step1 : step1;
|
|
uint32_t step3 = ((ppc_result_d << rot_sh) | (ppc_result_d >> (32-rot_sh)));
|
|
ppc_result_a = (ppc_result_a & ~step2) | (step3 & step2);
|
|
if ((ppc_cur_instruction & 0x01) == 1){
|
|
ppc_changecrf0(ppc_result_a);
|
|
}
|
|
ppc_store_result_rega();
|
|
}
|
|
|
|
void ppc_rlwinm(){
|
|
ppc_grab_regssa();
|
|
rot_sh = (ppc_cur_instruction >> 11) & 31;
|
|
rot_mb = (ppc_cur_instruction >> 6) & 31;
|
|
rot_me = (ppc_cur_instruction >> 1) & 31;
|
|
uint32_t step1 = (0xFFFFFFFFUL << (31 - rot_me)) & (0xFFFFFFFFUL >> rot_mb);
|
|
uint32_t step2 = (rot_me < rot_mb)? ~step1 : step1;
|
|
uint32_t step3 = ((ppc_result_d << rot_sh) | (ppc_result_d >> (32-rot_sh)));
|
|
ppc_result_a = step2 & step3;
|
|
if ((ppc_cur_instruction & 0x01) == 1){
|
|
ppc_changecrf0(ppc_result_a);
|
|
}
|
|
ppc_store_result_rega();
|
|
}
|
|
|
|
void ppc_rlwnm(){
|
|
ppc_grab_regssab();
|
|
rot_mb = (ppc_cur_instruction >> 6) & 31;
|
|
rot_me = (ppc_cur_instruction >> 1) & 31;
|
|
uint32_t step1 = (0xFFFFFFFFUL << (31 - rot_me)) & (0xFFFFFFFFUL >> rot_mb);
|
|
uint32_t step2 = (rot_me < rot_mb)? ~step1 : step1;
|
|
uint32_t step3 = ((ppc_result_d << ppc_result_b) | (ppc_result_d >> (32-ppc_result_b)));
|
|
ppc_result_a = step2 & step3;
|
|
if ((ppc_cur_instruction & 0x01) == 1){
|
|
ppc_changecrf0(ppc_result_a);
|
|
}
|
|
ppc_store_result_rega();
|
|
}
|
|
|
|
void ppc_mfcr(){
|
|
reg_d = (ppc_cur_instruction >> 21) & 31;
|
|
printf("CR: %x \n", ppc_state.ppc_cr);
|
|
ppc_state.ppc_gpr[reg_d] = ppc_state.ppc_cr;
|
|
}
|
|
|
|
void ppc_mtsr(){
|
|
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(){
|
|
if ((ppc_state.ppc_msr & 0x4000) == 0){
|
|
ppc_grab_regssb();
|
|
grab_sr = ppc_result_b & 15;
|
|
ppc_state.ppc_sr[grab_sr] = ppc_result_d;
|
|
}
|
|
}
|
|
|
|
void ppc_mfsr(){
|
|
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];
|
|
ppc_store_result_regd();
|
|
}
|
|
}
|
|
|
|
void ppc_mfsrin(){
|
|
if ((ppc_state.ppc_msr & 0x4000) == 0){
|
|
ppc_grab_regssb();
|
|
grab_sr = ppc_result_b & 15;
|
|
ppc_state.ppc_gpr[reg_d] = ppc_state.ppc_sr[grab_sr];
|
|
ppc_store_result_regd();
|
|
}
|
|
}
|
|
|
|
void ppc_mfmsr(){
|
|
if ((ppc_state.ppc_msr & 0x4000) == 0){
|
|
reg_d = (ppc_cur_instruction >> 21) & 31;
|
|
ppc_state.ppc_gpr[reg_d] = ppc_state.ppc_msr;
|
|
}
|
|
}
|
|
|
|
void ppc_mtmsr(){
|
|
//if ((ppc_state.ppc_msr && 0x4000) == 0){
|
|
reg_s = (ppc_cur_instruction >> 21) & 31;
|
|
ppc_state.ppc_msr = ppc_state.ppc_spr[reg_s];
|
|
msr_status_update();
|
|
//}
|
|
}
|
|
|
|
void ppc_mfspr(){
|
|
uint32_t ref_spr = (((ppc_cur_instruction >> 11) & 31) << 5) | ((ppc_cur_instruction >> 16) & 31);
|
|
printf("MFSPR SPR REF: %d \n", ref_spr);
|
|
reg_d = (ppc_cur_instruction >> 21) & 31;
|
|
ppc_state.ppc_gpr[reg_d] = ppc_state.ppc_spr[ref_spr];
|
|
printf("Contained inside Reg %d: %x \n", reg_d, ppc_state.ppc_gpr[reg_d]);
|
|
}
|
|
|
|
void ppc_mtspr(){
|
|
uint32_t ref_spr = (((ppc_cur_instruction >> 11) & 31) << 5) | ((ppc_cur_instruction >> 16) & 31);
|
|
printf("MTSPR SPR REF: %d \n", ref_spr);
|
|
reg_s = (ppc_cur_instruction >> 21) & 31;
|
|
printf("Contained inside Reg %d: %x \n", reg_s, ppc_state.ppc_gpr[reg_s]);
|
|
|
|
if (ref_spr != 287){
|
|
ppc_state.ppc_spr[ref_spr] = ppc_state.ppc_gpr[reg_s];
|
|
}
|
|
|
|
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();
|
|
std::cout << "IBAT CHANGED!" <<std::endl;
|
|
break;
|
|
case 536:
|
|
case 537:
|
|
case 538:
|
|
case 539:
|
|
case 540:
|
|
case 541:
|
|
case 542:
|
|
case 543:
|
|
dbat_update();
|
|
std::cout << "DBAT CHANGED!" <<std::endl;
|
|
}
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|
|
|
|
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;
|
|
ppc_state.ppc_cr = (ppc_result_d & cr_mask) | (ppc_state.ppc_cr & ~(cr_mask));
|
|
}
|
|
|
|
void ppc_mcrxr(){
|
|
crf_d = (ppc_cur_instruction >> 23) & 7;
|
|
crf_d = crf_d << 2;
|
|
ppc_state.ppc_cr = (ppc_state.ppc_cr & ~(0xF0000000 >> crf_d)) | ((ppc_state.ppc_spr[1] & 0xF0000000) >> crf_d);
|
|
ppc_state.ppc_spr[1] &= 0x0FFFFFFF;
|
|
}
|
|
|
|
void ppc_extsb(){
|
|
ppc_grab_regssa();
|
|
ppc_result_a = (ppc_result_d < 0x80)?(ppc_result_d & 0x000000FF):(0xFFFFFF00 | (ppc_result_d & 0x000000FF));
|
|
ppc_store_result_rega();
|
|
}
|
|
|
|
void ppc_extsbdot(){
|
|
ppc_grab_regssa();
|
|
ppc_result_a = (ppc_result_d < 0x80)?(ppc_result_d & 0x000000FF):(0xFFFFFF00 | (ppc_result_d & 0x000000FF));
|
|
ppc_changecrf0(ppc_result_a);
|
|
ppc_store_result_rega();
|
|
}
|
|
|
|
void ppc_extsh(){
|
|
ppc_grab_regssa();
|
|
ppc_result_a = (ppc_result_d < 0x8000)?(ppc_result_d & 0x0000FFFF):(0xFFFF0000 | (ppc_result_d & 0x0000FFFF));
|
|
ppc_store_result_rega();
|
|
}
|
|
|
|
void ppc_extshdot(){
|
|
ppc_grab_regssa();
|
|
ppc_result_a = (ppc_result_d < 0x8000)?(ppc_result_d & 0x0000FFFF):(0xFFFF0000 | (ppc_result_d & 0x0000FFFF));
|
|
ppc_changecrf0(ppc_result_a);
|
|
ppc_store_result_rega();
|
|
}
|
|
|
|
//Branching Instructions
|
|
|
|
//The last two bytes of the instruction are used for determining how the branch happens.
|
|
//The middle 24 bytes are the 24-bit address to use for branching to.
|
|
|
|
|
|
void ppc_b(){
|
|
uint32_t quick_test = (ppc_cur_instruction & 0x03FFFFFC);
|
|
adr_li = (quick_test < 0x2000000)? quick_test: (0xFC000000 + quick_test);
|
|
ppc_next_instruction_address = (uint32_t)(ppc_state.ppc_pc + adr_li);
|
|
grab_branch = 1;
|
|
}
|
|
|
|
void ppc_bl(){
|
|
uint32_t quick_test = (ppc_cur_instruction & 0x03FFFFFC);
|
|
adr_li = (quick_test < 0x2000000)? quick_test: (0xFC000000 + 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;
|
|
}
|
|
|
|
void ppc_ba(){
|
|
uint32_t quick_test = (ppc_cur_instruction & 0x03FFFFFC);
|
|
adr_li = (quick_test < 0x2000000)? quick_test: (0xFC000000 + quick_test);
|
|
ppc_next_instruction_address = adr_li;
|
|
grab_branch = 1;
|
|
}
|
|
|
|
void ppc_bla(){
|
|
uint32_t quick_test = (ppc_cur_instruction & 0x03FFFFFC);
|
|
adr_li = (quick_test < 0x2000000)? quick_test: (0xFC000000 + quick_test);
|
|
ppc_next_instruction_address = adr_li;
|
|
ppc_state.ppc_spr[8] = ppc_state.ppc_pc + 4;
|
|
grab_branch = 1;
|
|
}
|
|
|
|
void ppc_bc(){
|
|
br_bo = (ppc_cur_instruction >> 21) & 31;
|
|
br_bi = (ppc_cur_instruction >> 16) & 31;
|
|
br_bd = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFC));
|
|
uint32_t ctr_ok = 1;
|
|
uint32_t cnd_ok = 1;
|
|
|
|
if (!(br_bo & 0x04)){
|
|
(ppc_state.ppc_spr[9])--;
|
|
}
|
|
ctr_ok = ((br_bo & 0x04) || ((ppc_state.ppc_spr[9] != 0) ^ (br_bo & 0x02)));
|
|
cnd_ok = ((br_bo & 0x10) || !((ppc_state.ppc_cr & (0x80000000 >> br_bi)) ^ (br_bo & 0x08)));
|
|
|
|
if (ctr_ok && cnd_ok){
|
|
ppc_next_instruction_address = (ppc_state.ppc_pc + br_bd);
|
|
grab_branch = 1;
|
|
}
|
|
/*
|
|
else{
|
|
printf("BRANCH FAILED: %d %d", ctr_ok, cnd_ok);
|
|
}*/
|
|
}
|
|
|
|
void ppc_bca(){
|
|
br_bo = (ppc_cur_instruction >> 21) & 31;
|
|
br_bi = (ppc_cur_instruction >> 16) & 31;
|
|
br_bd = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFC));
|
|
uint32_t ctr_ok = 1;
|
|
uint32_t cnd_ok = 1;
|
|
|
|
if (!(br_bo & 0x04)){
|
|
(ppc_state.ppc_spr[9])--;
|
|
}
|
|
ctr_ok = ((br_bo & 0x04) || ((ppc_state.ppc_spr[9] != 0) ^ (br_bo & 0x02)));
|
|
cnd_ok = ((br_bo & 0x10) || !((ppc_state.ppc_cr & (0x80000000 >> br_bi)) ^ (br_bo & 0x08)));
|
|
|
|
if (ctr_ok && cnd_ok){
|
|
ppc_next_instruction_address = br_bd;
|
|
grab_branch = 1;
|
|
}
|
|
}
|
|
|
|
void ppc_bcl(){
|
|
|
|
br_bo = (ppc_cur_instruction >> 21) & 31;
|
|
br_bi = (ppc_cur_instruction >> 16) & 31;
|
|
br_bd = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFC));
|
|
uint32_t ctr_ok = 1;
|
|
uint32_t cnd_ok = 1;
|
|
|
|
if (!(br_bo & 0x04)){
|
|
(ppc_state.ppc_spr[9])--;
|
|
}
|
|
ctr_ok = ((br_bo & 0x04) || ((ppc_state.ppc_spr[9] != 0) ^ (br_bo & 0x02)));
|
|
cnd_ok = ((br_bo & 0x10) || !((ppc_state.ppc_cr & (0x80000000 >> br_bi)) ^ (br_bo & 0x08)));
|
|
|
|
if (ctr_ok && cnd_ok){
|
|
ppc_next_instruction_address = (ppc_state.ppc_pc + br_bd);
|
|
grab_branch = 1;
|
|
}
|
|
ppc_state.ppc_spr[8] = ppc_state.ppc_pc + 4;
|
|
}
|
|
|
|
void ppc_bcla(){
|
|
|
|
br_bo = (ppc_cur_instruction >> 21) & 31;
|
|
br_bi = (ppc_cur_instruction >> 16) & 31;
|
|
br_bd = (int32_t)((int16_t)(ppc_cur_instruction & 0xFFFC));
|
|
uint32_t ctr_ok = 1;
|
|
uint32_t cnd_ok = 1;
|
|
|
|
if (!(br_bo & 0x04)){
|
|
(ppc_state.ppc_spr[9])--;
|
|
}
|
|
ctr_ok = ((br_bo & 0x04) || ((ppc_state.ppc_spr[9] != 0) ^ (br_bo & 0x02)));
|
|
cnd_ok = ((br_bo & 0x10) || !((ppc_state.ppc_cr & (0x80000000 >> br_bi)) ^ (br_bo & 0x08)));
|
|
|
|
if (ctr_ok && cnd_ok){
|
|
ppc_next_instruction_address = br_bd;
|
|
grab_branch = 1;
|
|
}
|
|
ppc_state.ppc_spr[8] = ppc_state.ppc_pc + 4;
|
|
}
|
|
|
|
void ppc_bcctr(){
|
|
br_bo = (ppc_cur_instruction >> 21) & 31;
|
|
br_bi = (ppc_cur_instruction >> 16) & 31;
|
|
|
|
uint32_t cnd_ok = 1;
|
|
cnd_ok = ((br_bo & 0x10) || !((ppc_state.ppc_cr & (0x80000000 >> br_bi)) ^ (br_bo & 0x08)));
|
|
|
|
if (cnd_ok){
|
|
adr_li = (ppc_state.ppc_spr[9] & 0xFFFFFFFC);
|
|
ppc_next_instruction_address = adr_li;
|
|
grab_branch = 1;
|
|
}
|
|
}
|
|
|
|
void ppc_bcctrl(){
|
|
br_bo = (ppc_cur_instruction >> 21) & 31;
|
|
br_bi = (ppc_cur_instruction >> 16) & 31;
|
|
|
|
uint32_t cnd_ok = 1;
|
|
cnd_ok = ((br_bo & 0x10) || !((ppc_state.ppc_cr & (0x80000000 >> br_bi)) ^ (br_bo & 0x08)));
|
|
|
|
if (cnd_ok){
|
|
adr_li = (ppc_state.ppc_spr[9] & 0xFFFFFFFC);
|
|
ppc_next_instruction_address = adr_li;
|
|
grab_branch = 1;
|
|
}
|
|
ppc_state.ppc_spr[8] = ppc_state.ppc_pc + 4;
|
|
}
|
|
|
|
void ppc_bclr(){
|
|
br_bo = (ppc_cur_instruction >> 21) & 31;
|
|
br_bi = (ppc_cur_instruction >> 16) & 31;
|
|
uint32_t ctr_ok = 1;
|
|
uint32_t cnd_ok = 1;
|
|
|
|
if (!(br_bo & 0x04)){
|
|
(ppc_state.ppc_spr[9])--;
|
|
}
|
|
ctr_ok = ((br_bo & 0x04) | ((ppc_state.ppc_spr[9] != 0) ^ (br_bo & 0x02)));
|
|
cnd_ok = ((br_bo & 0x10) || !((ppc_state.ppc_cr & (0x80000000 >> br_bi)) ^ (br_bo & 0x08)));
|
|
|
|
if (ctr_ok && cnd_ok){
|
|
ppc_next_instruction_address = (ppc_state.ppc_spr[8] & 0xFFFFFFFC);
|
|
grab_branch = 1;
|
|
}
|
|
else{
|
|
printf("Branch failed. \n");
|
|
}
|
|
}
|
|
|
|
void ppc_bclrl(){
|
|
br_bo = (ppc_cur_instruction >> 21) & 31;
|
|
br_bi = (ppc_cur_instruction >> 16) & 31;
|
|
uint32_t ctr_ok = 1;
|
|
uint32_t cnd_ok = 1;
|
|
if (!(br_bo & 0x04)){
|
|
(ppc_state.ppc_spr[9])--;
|
|
}
|
|
ctr_ok = ((br_bo & 0x04) | ((ppc_state.ppc_spr[9] != 0) ^ (br_bo & 0x02)));
|
|
cnd_ok = ((br_bo & 0x10) || !((ppc_state.ppc_cr & (0x80000000 >> br_bi)) ^ (br_bo & 0x08)));
|
|
|
|
if (ctr_ok && cnd_ok){
|
|
ppc_next_instruction_address = (ppc_state.ppc_spr[8] & 0xFFFFFFFC);
|
|
grab_branch = 1;
|
|
}
|
|
ppc_state.ppc_spr[8] = ppc_state.ppc_pc + 4;
|
|
}
|
|
//Compare Instructions
|
|
|
|
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] & 0x80000000) >> 3;
|
|
cmp_c = (((int32_t)ppc_result_a) == ((int32_t)ppc_result_b)) ? 0x20000000 : (((int32_t)ppc_result_a) > ((int32_t)ppc_result_b)) ? 0x40000000 : 0x80000000;
|
|
ppc_state.ppc_cr = ((ppc_state.ppc_cr & ~(0xf0000000 >> crf_d)) | ((cmp_c + xercon) >> crf_d));
|
|
//}
|
|
//else{
|
|
// printf("Warning: Invalid CMP Instruction.");
|
|
//}
|
|
}
|
|
|
|
void ppc_cmpi(){
|
|
//if (!((ppc_cur_instruction >> 21) && 0x1)){
|
|
crf_d = (ppc_cur_instruction >> 23) & 7;
|
|
crf_d = crf_d << 2;
|
|
ppc_grab_regssasimm();
|
|
xercon = (ppc_state.ppc_spr[1] & 0x80000000) >> 3;
|
|
cmp_c = (((int32_t)ppc_result_a) == simm) ? 0x20000000 : (((int32_t)ppc_result_a) > simm) ? 0x40000000 : 0x80000000;
|
|
ppc_state.ppc_cr = ((ppc_state.ppc_cr & ~(0xf0000000 >> crf_d)) | ((cmp_c + xercon) >> crf_d));
|
|
// }
|
|
//else{
|
|
// printf("Warning: Invalid CMP Instruction.");
|
|
//}
|
|
}
|
|
|
|
void ppc_cmpl(){
|
|
//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] & 0x80000000) >> 3;
|
|
cmp_c = (ppc_result_a == ppc_result_b) ? 0x20000000 : (ppc_result_a > ppc_result_b) ? 0x40000000 : 0x80000000;
|
|
ppc_state.ppc_cr = ((ppc_state.ppc_cr & ~(0xf0000000 >> crf_d)) | ((cmp_c + xercon) >> crf_d));
|
|
//}
|
|
//else{
|
|
// printf("Warning: Invalid CMP Instruction.");
|
|
//}
|
|
}
|
|
|
|
void ppc_cmpli(){
|
|
// if (!((ppc_cur_instruction >> 21) && 0x1)){
|
|
crf_d = (ppc_cur_instruction >> 23) & 7;
|
|
crf_d = crf_d << 2;
|
|
ppc_grab_regssauimm();
|
|
xercon = (ppc_state.ppc_spr[1] & 0x80000000) >> 3;
|
|
cmp_c = (ppc_result_a == uimm) ? 0x20000000 : (ppc_result_a > uimm) ? 0x40000000 : 0x80000000;
|
|
ppc_state.ppc_cr = ((ppc_state.ppc_cr & ~(0xf0000000 >> crf_d)) | ((cmp_c + xercon) >> crf_d));
|
|
// }
|
|
//else{
|
|
// printf("Warning: Invalid CMP Instruction.");
|
|
// }
|
|
}
|
|
|
|
//Condition Register Changes
|
|
|
|
void ppc_crand(){
|
|
ppc_grab_regsdab();
|
|
if ((ppc_state.ppc_cr && (0x80000000 >> reg_a)) & (ppc_state.ppc_cr && (0x80000000 >> reg_b))){
|
|
ppc_state.ppc_cr |= (0x80000000 >> reg_d);
|
|
}
|
|
else{
|
|
ppc_state.ppc_cr &= ~(0x80000000 >> reg_d);
|
|
}
|
|
}
|
|
void ppc_crandc(){
|
|
ppc_grab_regsdab();
|
|
if ((ppc_state.ppc_cr && (0x80000000 >> reg_a)) & ~(ppc_state.ppc_cr && (0x80000000 >> reg_b))){
|
|
ppc_state.ppc_cr |= (0x80000000 >> reg_d);
|
|
}
|
|
else{
|
|
ppc_state.ppc_cr &= ~(0x80000000 >> reg_d);
|
|
}
|
|
}
|
|
void ppc_creqv(){
|
|
ppc_grab_regsdab();
|
|
if (!((ppc_state.ppc_cr && (0x80000000 >> reg_a)) ^ !(ppc_state.ppc_cr && (0x80000000 >> reg_b)))){
|
|
ppc_state.ppc_cr |= (0x80000000 >> reg_d);
|
|
}
|
|
else{
|
|
ppc_state.ppc_cr &= ~(0x80000000 >> reg_d);
|
|
}
|
|
}
|
|
void ppc_crnand(){
|
|
ppc_grab_regsdab();
|
|
if (!((ppc_state.ppc_cr && (0x80000000 >> reg_a)) & (ppc_state.ppc_cr && (0x80000000 >> reg_b)))){
|
|
ppc_state.ppc_cr |= (0x80000000 >> reg_d);
|
|
}
|
|
else{
|
|
ppc_state.ppc_cr &= ~(0x80000000 >> reg_d);
|
|
}
|
|
}
|
|
void ppc_crnor(){
|
|
ppc_grab_regsdab();
|
|
if (!((ppc_state.ppc_cr && (0x80000000 >> reg_a)) | ~(ppc_state.ppc_cr && (0x80000000 >> reg_b)))){
|
|
ppc_state.ppc_cr |= (0x80000000 >> reg_d);
|
|
}
|
|
else{
|
|
ppc_state.ppc_cr &= ~(0x80000000 >> reg_d);
|
|
}
|
|
}
|
|
|
|
void ppc_cror(){
|
|
ppc_grab_regsdab();
|
|
if ((ppc_state.ppc_cr && (0x80000000 >> reg_a)) | (ppc_state.ppc_cr && (0x80000000 >> reg_b))){
|
|
ppc_state.ppc_cr |= (0x80000000 >> reg_d);
|
|
}
|
|
else{
|
|
ppc_state.ppc_cr &= ~(0x80000000 >> reg_d);
|
|
}
|
|
}
|
|
void ppc_crorc(){
|
|
ppc_grab_regsdab();
|
|
if ((ppc_state.ppc_cr && (0x80000000 >> reg_a)) | ~(ppc_state.ppc_cr && (0x80000000 >> reg_b))){
|
|
ppc_state.ppc_cr |= (0x80000000 >> reg_d);
|
|
}
|
|
else{
|
|
ppc_state.ppc_cr &= ~(0x80000000 >> reg_d);
|
|
}
|
|
}
|
|
void ppc_crxor(){
|
|
ppc_grab_regsdab();
|
|
if ((ppc_state.ppc_cr && (0x80000000 >> reg_a)) ^ (ppc_state.ppc_cr && (0x80000000 >> reg_b))){
|
|
ppc_state.ppc_cr |= (0x80000000 >> reg_d);
|
|
}
|
|
else{
|
|
ppc_state.ppc_cr &= ~(0x80000000 >> reg_d);
|
|
}
|
|
}
|
|
|
|
//Processor MGMT Fns.
|
|
|
|
void ppc_rfi(){
|
|
uint32_t new_srr1_val = (ppc_state.ppc_spr[27] & 0x87C0FF73);
|
|
uint32_t new_msr_val = (ppc_state.ppc_msr & ~(0x87C0FF73));
|
|
ppc_state.ppc_msr = (new_msr_val | new_srr1_val) & 0xFFFBFFFF;
|
|
ppc_next_instruction_address = ppc_state.ppc_spr[26] & 0xFFFFFFFC;
|
|
|
|
grab_return = true;
|
|
}
|
|
|
|
void ppc_sc(){
|
|
ppc_expection_handler(0x0C00, 0x20000);
|
|
}
|
|
|
|
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))){
|
|
ppc_expection_handler(0x0700, 0x20000);
|
|
}
|
|
}
|
|
|
|
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))){
|
|
ppc_expection_handler(0x0700, 0x20000);
|
|
}
|
|
}
|
|
|
|
void ppc_eieio(){
|
|
std::cout << "Oops. Placeholder for eieio." << std::endl;
|
|
}
|
|
|
|
void ppc_isync(){
|
|
std::cout << "Oops. Placeholder for isync." << std::endl;
|
|
}
|
|
|
|
void ppc_sync(){
|
|
std::cout << "Oops. Placeholder for sync." << std::endl;
|
|
}
|
|
|
|
void ppc_icbi(){
|
|
std::cout << "Oops. Placeholder for icbi." << std::endl;
|
|
}
|
|
|
|
void ppc_dcbf(){
|
|
std::cout << "Oops. Placeholder for dcbf." << std::endl;
|
|
}
|
|
|
|
void ppc_dcbi(){
|
|
std::cout << "Oops. Placeholder for dcbi." << std::endl;
|
|
}
|
|
|
|
void ppc_dcbst(){
|
|
std::cout << "Oops. Placeholder for dcbst." << std::endl;
|
|
}
|
|
|
|
void ppc_dcbt(){
|
|
//Not needed, the HDI reg is touched to no-op this instruction.
|
|
return;
|
|
}
|
|
|
|
void ppc_dcbtst(){
|
|
//Not needed, the HDI reg is touched to no-op this instruction.
|
|
return;
|
|
}
|
|
|
|
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 < 0xFFFFFFE0)){
|
|
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);
|
|
}
|
|
else{
|
|
ppc_expection_handler(0x0600, 0x00000);
|
|
}
|
|
}
|
|
|
|
//Integer Load and Store Functions
|
|
|
|
void ppc_stb(){
|
|
ppc_grab_regssa();
|
|
grab_d = (uint32_t)((int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF)));
|
|
ppc_effective_address = (reg_a == 0)?grab_d:(ppc_result_a + grab_d);
|
|
#ifdef EXHAUSTIVE_DEBUG
|
|
printf("STB Storage Area: %x \n",ppc_effective_address);
|
|
#endif // EXHAUSTIVE_DEBUG
|
|
address_quickinsert_translate(ppc_result_d, ppc_effective_address, 1);
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
void ppc_stbu(){
|
|
ppc_grab_regssa();
|
|
grab_d = (uint32_t)((int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF)));
|
|
if (reg_a != 0){
|
|
ppc_effective_address = (reg_a == 0)?grab_d:(ppc_result_a + grab_d);
|
|
address_quickinsert_translate(ppc_result_d, ppc_effective_address, 1);
|
|
}
|
|
}
|
|
|
|
void ppc_stbux(){
|
|
ppc_grab_regssab();
|
|
if (reg_a != 0){
|
|
ppc_effective_address = ppc_result_a + reg_b;
|
|
address_quickinsert_translate(ppc_result_d, ppc_effective_address, 1);
|
|
}
|
|
else{
|
|
ppc_expection_handler(0x07000, 0x20000);
|
|
}
|
|
ppc_result_a = ppc_effective_address;
|
|
ppc_store_result_rega();
|
|
}
|
|
|
|
void ppc_sth(){
|
|
ppc_grab_regssa();
|
|
grab_d = (uint32_t)((int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF)));
|
|
ppc_effective_address = (reg_a == 0)?grab_d:(ppc_result_a + grab_d);
|
|
address_quickinsert_translate(ppc_result_d, ppc_effective_address, 2);
|
|
}
|
|
|
|
void ppc_sthu(){
|
|
ppc_grab_regssa();
|
|
grab_d = (uint32_t)((int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF)));
|
|
ppc_effective_address = (reg_a == 0)?grab_d:(ppc_result_a + grab_d);
|
|
address_quickinsert_translate(ppc_result_d, ppc_effective_address, 2);
|
|
}
|
|
|
|
void ppc_sthux(){
|
|
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);
|
|
ppc_result_a = ppc_effective_address;
|
|
ppc_store_result_rega();
|
|
}
|
|
|
|
void ppc_sthx(){
|
|
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);
|
|
}
|
|
|
|
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)(rev_endian16((uint16_t)ppc_result_d));
|
|
address_quickinsert_translate(ppc_result_d, ppc_effective_address, 2);
|
|
}
|
|
|
|
void ppc_stw(){
|
|
ppc_grab_regssa();
|
|
grab_d = (uint32_t)((int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF)));
|
|
ppc_effective_address = (reg_a == 0)?grab_d:(ppc_result_a + grab_d);
|
|
address_quickinsert_translate(ppc_result_d, ppc_effective_address, 4);
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
void ppc_stwcx(){
|
|
//PLACEHOLDER CODE FOR STWCX - We need to check for reserve memory
|
|
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);
|
|
ppc_state.ppc_cr |= (ppc_state.ppc_spr[1] & 0x80000000) ? 0x30000000 : 0x20000000;
|
|
ppc_state.ppc_reserve = false;
|
|
}
|
|
else{
|
|
ppc_state.ppc_cr |= (ppc_state.ppc_spr[1] & 0x80000000) ? 0x10000000 : 0;
|
|
}
|
|
}
|
|
|
|
void ppc_stwu(){
|
|
ppc_grab_regssa();
|
|
grab_d = (uint32_t)((int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF)));
|
|
ppc_effective_address = (reg_a == 0)?grab_d:(ppc_result_a + grab_d);
|
|
address_quickinsert_translate(ppc_result_d, ppc_effective_address, 4);
|
|
ppc_result_a = ppc_effective_address;
|
|
ppc_store_result_rega();
|
|
}
|
|
|
|
void ppc_stwux(){
|
|
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);
|
|
ppc_result_a = ppc_effective_address;
|
|
ppc_store_result_rega();
|
|
}
|
|
|
|
void ppc_stwbrx(){
|
|
ppc_grab_regssab();
|
|
ppc_effective_address = (reg_a == 0)?ppc_result_b:(ppc_result_a + ppc_result_b);
|
|
printf("STWBRX Storage Area: %x \n",ppc_effective_address);
|
|
ppc_result_d = rev_endian32(ppc_result_d);
|
|
address_quickinsert_translate(ppc_result_d, ppc_effective_address, 4);
|
|
}
|
|
|
|
void ppc_stmw(){
|
|
ppc_grab_regssa();
|
|
grab_d = (uint32_t)((int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF)));
|
|
ppc_effective_address = (reg_a == 0)?grab_d:(ppc_result_a + grab_d);
|
|
//How many words to store in memory - using a do-while for this
|
|
do{
|
|
address_quickinsert_translate(ppc_result_d, ppc_effective_address, 4);
|
|
ppc_effective_address +=4;
|
|
reg_d++;
|
|
}while (reg_d < 32);
|
|
}
|
|
|
|
void ppc_lbz(){
|
|
ppc_grab_regsda();
|
|
grab_d = (uint32_t)((int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF)));
|
|
ppc_effective_address = (reg_a == 0)?grab_d:(ppc_result_a + grab_d);
|
|
address_quickgrab_translate(ppc_effective_address, 1);
|
|
//printf("LBZ Storage Area: %x \n",ppc_effective_address);
|
|
ppc_result_d = return_value;
|
|
return_value = 0;
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
void ppc_lbzu(){
|
|
ppc_grab_regsda();
|
|
grab_d = (uint32_t)((int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF)));
|
|
if ((reg_a != reg_d) || reg_a != 0){
|
|
ppc_effective_address = ppc_result_a + grab_d;
|
|
}
|
|
else{
|
|
ppc_expection_handler(0x0700, 0x20000);
|
|
}
|
|
address_quickgrab_translate(ppc_effective_address, 1);
|
|
ppc_result_d = return_value;
|
|
return_value = 0;
|
|
ppc_result_a = ppc_effective_address;
|
|
ppc_store_result_regd();
|
|
ppc_store_result_rega();
|
|
}
|
|
|
|
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;
|
|
return_value = 0;
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
void ppc_lbzux(){
|
|
ppc_grab_regsdab();
|
|
if ((reg_a != reg_d) || reg_a != 0){
|
|
ppc_effective_address = ppc_result_a + ppc_result_b;
|
|
}
|
|
else{
|
|
ppc_expection_handler(0x0700, 0x20000);
|
|
}
|
|
address_quickgrab_translate(ppc_effective_address, 1);
|
|
ppc_result_d = return_value;
|
|
return_value = 0;
|
|
ppc_result_a = ppc_effective_address;
|
|
ppc_store_result_regd();
|
|
ppc_store_result_rega();
|
|
}
|
|
|
|
|
|
void ppc_lhz(){
|
|
ppc_grab_regsda();
|
|
grab_d = (uint32_t)((int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF)));
|
|
ppc_effective_address = (reg_a == 0)?grab_d:(ppc_result_a + grab_d);
|
|
address_quickgrab_translate(ppc_effective_address, 2);
|
|
ppc_result_d = return_value;
|
|
return_value = 0;
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
void ppc_lhzu(){
|
|
ppc_grab_regsda();
|
|
grab_d = (uint32_t)((int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF)));
|
|
ppc_effective_address = ppc_result_a + grab_d;
|
|
address_quickgrab_translate(ppc_effective_address, 2);
|
|
ppc_result_d = return_value;
|
|
return_value = 0;
|
|
ppc_result_a = ppc_effective_address;
|
|
ppc_store_result_regd();
|
|
ppc_store_result_rega();
|
|
}
|
|
|
|
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;
|
|
return_value = 0;
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
void ppc_lhzux(){
|
|
ppc_grab_regsdab();
|
|
ppc_effective_address = ppc_result_a + ppc_result_b;
|
|
address_quickgrab_translate(ppc_effective_address, 2);
|
|
ppc_result_d = return_value;
|
|
return_value = 0;
|
|
ppc_result_a = ppc_effective_address;
|
|
ppc_store_result_regd();
|
|
ppc_store_result_rega();
|
|
}
|
|
|
|
void ppc_lha(){
|
|
ppc_grab_regsda();
|
|
grab_d = (uint32_t)((int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF)));
|
|
ppc_effective_address = (reg_a == 0)?grab_d:(uint32_t)(ppc_result_a + grab_d);
|
|
address_quickgrab_translate(ppc_effective_address, 2);
|
|
uint16_t go_this = (uint16_t)return_value;
|
|
if (go_this & 0x8000){
|
|
ppc_result_d = 0xFFFF0000 | (uint32_t)return_value;
|
|
ppc_store_result_regd();
|
|
}
|
|
else{
|
|
ppc_result_d = (uint32_t)return_value;
|
|
ppc_store_result_regd();
|
|
}
|
|
return_value = 0;
|
|
}
|
|
|
|
void ppc_lhau(){
|
|
ppc_grab_regsda();
|
|
grab_d = (uint32_t)((int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF)));
|
|
ppc_effective_address = (reg_a == 0)?grab_d:(uint32_t)(ppc_result_a + grab_d);
|
|
address_quickgrab_translate(ppc_effective_address, 2);
|
|
uint16_t go_this = (uint16_t)return_value;
|
|
if (go_this & 0x8000){
|
|
ppc_result_d = 0xFFFF0000 | (uint32_t)return_value;
|
|
ppc_store_result_regd();
|
|
}
|
|
else{
|
|
ppc_result_d = (uint32_t)return_value;
|
|
ppc_store_result_regd();
|
|
}
|
|
return_value = 0;
|
|
ppc_result_a = ppc_effective_address;
|
|
ppc_store_result_rega();
|
|
}
|
|
|
|
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);
|
|
uint16_t go_this = (uint16_t)return_value;
|
|
if (go_this & 0x8000){
|
|
ppc_result_d = 0xFFFF0000 | (uint32_t)return_value;
|
|
ppc_store_result_regd();
|
|
}
|
|
else{
|
|
ppc_result_d = (uint32_t)return_value;
|
|
ppc_store_result_regd();
|
|
}
|
|
return_value = 0;
|
|
ppc_result_a = ppc_effective_address;
|
|
ppc_store_result_rega();
|
|
}
|
|
|
|
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);
|
|
uint16_t go_this = (uint16_t)return_value;
|
|
if (go_this & 0x8000){
|
|
ppc_result_d = 0xFFFF0000 | (uint32_t)return_value;
|
|
ppc_store_result_regd();
|
|
}
|
|
else{
|
|
ppc_result_d = (uint32_t)return_value;
|
|
ppc_store_result_regd();
|
|
}
|
|
return_value = 0;
|
|
}
|
|
|
|
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);
|
|
ppc_result_d = (uint32_t)(rev_endian16((uint16_t)ppc_result_d));
|
|
return_value = 0;
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
void ppc_lwz(){
|
|
ppc_grab_regsda();
|
|
grab_d = (uint32_t)((int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF)));
|
|
ppc_effective_address = (reg_a == 0)?grab_d:(ppc_result_a + grab_d);
|
|
address_quickgrab_translate(ppc_effective_address, 4);
|
|
ppc_result_d = return_value;
|
|
return_value = 0;
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
void ppc_lwbrx(){
|
|
ppc_grab_regsdab();
|
|
ppc_effective_address = (reg_a == 0)?ppc_result_b:(ppc_result_a + ppc_result_b);
|
|
printf("LWBRX Storage Area: %x \n",ppc_effective_address);
|
|
address_quickgrab_translate(ppc_effective_address, 4);
|
|
ppc_result_d = rev_endian32(return_value);
|
|
return_value = 0;
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
void ppc_lwzu(){
|
|
ppc_grab_regsda();
|
|
grab_d = (uint32_t)((int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF)));
|
|
if ((reg_a != reg_d) || reg_a != 0){
|
|
ppc_effective_address = ppc_result_a + grab_d;
|
|
}
|
|
else{
|
|
ppc_expection_handler(0x0700, 0x20000);
|
|
}
|
|
address_quickgrab_translate(ppc_effective_address, 4);
|
|
ppc_result_d = return_value;
|
|
return_value = 0;
|
|
ppc_store_result_regd();
|
|
ppc_result_a = ppc_effective_address;
|
|
ppc_store_result_rega();
|
|
}
|
|
|
|
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;
|
|
return_value = 0;
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
void ppc_lwzux(){
|
|
ppc_grab_regsdab();
|
|
if ((reg_a != reg_d) || reg_a != 0){
|
|
ppc_effective_address = ppc_result_a + ppc_result_b;
|
|
}
|
|
else{
|
|
ppc_expection_handler(0x0700, 0x20000);
|
|
}
|
|
address_quickgrab_translate(ppc_effective_address, 4);
|
|
ppc_result_d = return_value;
|
|
return_value = 0;
|
|
ppc_result_a = ppc_effective_address;
|
|
ppc_store_result_regd();
|
|
ppc_store_result_rega();
|
|
}
|
|
|
|
void ppc_lwarx(){
|
|
//Placeholder - Get the reservation of memory implemented!
|
|
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;
|
|
return_value = 0;
|
|
ppc_store_result_regd();
|
|
}
|
|
|
|
void ppc_lmw(){
|
|
ppc_grab_regsda();
|
|
grab_d = (uint32_t)((int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF)));
|
|
ppc_effective_address = (reg_a == 0)?grab_d:(ppc_result_a + grab_d);
|
|
//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;
|
|
return_value = 0;
|
|
ppc_effective_address +=4;
|
|
reg_d++;
|
|
}while (reg_d < 32);
|
|
}
|
|
|
|
void ppc_lswi(){
|
|
ppc_grab_regsda();
|
|
ppc_effective_address = ppc_result_a;
|
|
grab_inb = (ppc_cur_instruction >> 11) & 31;
|
|
grab_inb = grab_inb % 32 == 0 ? 32 : grab_inb;
|
|
|
|
uint32_t shift_times = 0;
|
|
|
|
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 & 0x00FFFFFF) | (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 & 0xFF00FFFF) | (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 & 0xFFFF00FF) | (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 & 0xFFFFFF00) | return_value;
|
|
ppc_store_result_regd();
|
|
return_value = 0;
|
|
break;
|
|
default:
|
|
printf("Something really horrible happened with lswi.");
|
|
}
|
|
if (shift_times == 3){
|
|
shift_times = 0;
|
|
reg_d = (reg_d + 1) & 0x1F;
|
|
}
|
|
else{
|
|
shift_times++;
|
|
}
|
|
return_value = 0;
|
|
ppc_effective_address++;
|
|
grab_inb--;
|
|
}
|
|
}
|
|
|
|
void ppc_lswx(){
|
|
ppc_grab_regsdab();
|
|
//Invalid instruction forms
|
|
if ((ppc_result_d == 0) && (ppc_result_a == 0)){
|
|
ppc_expection_handler(0x0700, 0x100000);
|
|
}
|
|
if ((ppc_result_d == ppc_result_a) || (ppc_result_a == ppc_result_b)){
|
|
ppc_expection_handler(0x0700, 0x100000);
|
|
}
|
|
ppc_effective_address = (reg_a == 0)?ppc_result_b:(ppc_result_a + ppc_result_b);
|
|
grab_inb = ppc_state.ppc_spr[1] & 127;
|
|
uint32_t shift_times = 0;
|
|
while (grab_inb > 0){
|
|
switch(shift_times){
|
|
case 0:
|
|
address_quickgrab_translate(ppc_effective_address, 1);
|
|
ppc_result_d = (ppc_result_d & 0x00FFFFFF) | (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 & 0xFF00FFFF) | (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 & 0xFFFF00FF) | (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 & 0xFFFFFF00) | return_value;
|
|
ppc_store_result_regd();
|
|
return_value = 0;
|
|
break;
|
|
default:
|
|
printf("Something really horrible happened with lswx.");
|
|
}
|
|
if (shift_times == 3){
|
|
shift_times = 0;
|
|
reg_d = (reg_d + 1) & 0x1F;
|
|
}
|
|
else{
|
|
shift_times++;
|
|
}
|
|
return_value = 0;
|
|
ppc_effective_address++;
|
|
grab_inb--;
|
|
}
|
|
|
|
}
|
|
|
|
void ppc_stswi(){
|
|
ppc_grab_regssa();
|
|
ppc_effective_address = (reg_a == 0)?0:ppc_result_a;
|
|
grab_inb = (ppc_cur_instruction >> 11) & 31;
|
|
grab_inb = grab_inb % 32 == 0 ? 32 : grab_inb;
|
|
uint32_t shift_times = 0;
|
|
while (grab_inb > 0){
|
|
switch(shift_times){
|
|
case 0:
|
|
strwrd_replace_value = (ppc_result_d >> 24);
|
|
address_quickinsert_translate(strwrd_replace_value, ppc_effective_address, 1);
|
|
break;
|
|
case 1:
|
|
strwrd_replace_value = (ppc_result_d >> 16);
|
|
address_quickinsert_translate(strwrd_replace_value, ppc_effective_address, 1);
|
|
break;
|
|
case 2:
|
|
strwrd_replace_value = (ppc_result_d >> 8);
|
|
address_quickinsert_translate(strwrd_replace_value, ppc_effective_address, 1);
|
|
break;
|
|
case 3:
|
|
strwrd_replace_value = (ppc_result_d);
|
|
address_quickinsert_translate(strwrd_replace_value, ppc_effective_address, 1);
|
|
break;
|
|
default:
|
|
printf("Something really horrible happened with stswi.");
|
|
}
|
|
if (shift_times == 3){
|
|
shift_times = 0;
|
|
reg_s = (reg_s + 1) & 0x1F;
|
|
}
|
|
else{
|
|
shift_times++;
|
|
}
|
|
return_value = 0;
|
|
ppc_effective_address++;
|
|
grab_inb--;
|
|
}
|
|
}
|
|
|
|
void ppc_stswx(){
|
|
ppc_grab_regssab();
|
|
ppc_effective_address = (reg_a == 0)?ppc_result_b:(ppc_result_a + ppc_result_b);
|
|
grab_inb = ppc_state.ppc_spr[1] & 127;
|
|
uint32_t shift_times = 0;
|
|
while (grab_inb > 0){
|
|
switch(shift_times){
|
|
case 0:
|
|
strwrd_replace_value = (ppc_result_d >> 24);
|
|
address_quickinsert_translate(strwrd_replace_value, ppc_effective_address, 1);
|
|
break;
|
|
case 1:
|
|
strwrd_replace_value = (ppc_result_d >> 16);
|
|
address_quickinsert_translate(strwrd_replace_value, ppc_effective_address, 1);
|
|
break;
|
|
case 2:
|
|
strwrd_replace_value = (ppc_result_d >> 8);
|
|
address_quickinsert_translate(strwrd_replace_value, ppc_effective_address, 1);
|
|
break;
|
|
case 3:
|
|
strwrd_replace_value = (ppc_result_d);
|
|
address_quickinsert_translate(strwrd_replace_value, ppc_effective_address, 1);
|
|
break;
|
|
default:
|
|
printf("Something really horrible happened with 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(){
|
|
/**
|
|
reg_b = (ppc_cur_instruction >> 11) & 31;
|
|
uint32_t vps = ppc_state.ppc_gpr[reg_b] & 0xFFFF000;
|
|
**/
|
|
printf("Placeholder for tlbie \n");
|
|
}
|
|
|
|
void ppc_tlbia(){
|
|
printf("Placeholder for tlbia \n");
|
|
}
|
|
|
|
void ppc_tlbld(){
|
|
printf("Placeholder for tlbld - 603 only \n");
|
|
}
|
|
|
|
void ppc_tlbli(){
|
|
printf("Placeholder for tlbli - 603 only \n");
|
|
}
|