void Interpreter::stfs(UGeckoInstruction _inst)
{
	//double value = rPS0(_inst.FS);
	//float fTemp = (float)value;
	//Memory::Write_U32(*(u32*)&fTemp, Helper_Get_EA(_inst));
	Memory::Write_U32(ConvertToSingle(riPS0(_inst.FS)), Helper_Get_EA(_inst));
}

void Interpreter::lbz(UGeckoInstruction inst)
{
  const u32 temp = PowerPC::Read_U8(Helper_Get_EA(inst));

  if (!(PowerPC::ppcState.Exceptions & EXCEPTION_DSI))
    rGPR[inst.RD] = temp;
}

// FIXME: lmw should do a total rollback if a DSI occurs
void Interpreter::lmw(UGeckoInstruction inst)
{
  u32 address = Helper_Get_EA(inst);

  if ((address & 0b11) != 0 || UReg_MSR{MSR}.LE)
  {
    GenerateAlignmentException(address);
    return;
  }

  for (int i = inst.RD; i <= 31; i++, address += 4)
  {
    const u32 temp_reg = PowerPC::Read_U32(address);

    if (PowerPC::ppcState.Exceptions & EXCEPTION_DSI)
    {
      PanicAlert("DSI exception in lmw");
      NOTICE_LOG(POWERPC, "DSI exception in lmw");
      return;
    }
    else
    {
      rGPR[i] = temp_reg;
    }
  }
}

void Interpreter::lhz(UGeckoInstruction _inst)
{
	u32 temp = (u32)(u16)Memory::Read_U16(Helper_Get_EA(_inst));
	if (!(PowerPC::ppcState.Exceptions & EXCEPTION_DSI))
	{
		m_GPR[_inst.RD] = temp;
	}
}

void Interpreter::lha(UGeckoInstruction inst)
{
  const u32 temp = (u32)(s32)(s16)PowerPC::Read_U16(Helper_Get_EA(inst));

  if (!(PowerPC::ppcState.Exceptions & EXCEPTION_DSI))
  {
    rGPR[inst.RD] = temp;
  }
}

void Interpreter::lwz(UGeckoInstruction _inst)
{
	u32 uAddress = Helper_Get_EA(_inst);
	u32 temp = PowerPC::Read_U32(uAddress);
	if (!(PowerPC::ppcState.Exceptions & EXCEPTION_DSI))
	{
		rGPR[_inst.RD] = temp;
	}
}

void Interpreter::lfs(UGeckoInstruction _inst)
{
	u32 uTemp = PowerPC::Read_U32(Helper_Get_EA(_inst));
	if (!(PowerPC::ppcState.Exceptions & EXCEPTION_DSI))
	{
		u64 value = ConvertToDouble(uTemp);
		riPS0(_inst.FD) = value;
		riPS1(_inst.FD) = value;
	}
}

void Interpreter::lfs(UGeckoInstruction _inst)
{
	u32 uTemp = Memory::Read_U32(Helper_Get_EA(_inst));
	if (!(PowerPC::ppcState.Exceptions & EXCEPTION_DSI))
	{
		double value = *(float*)&uTemp;
		rPS0(_inst.FD) = value;
		rPS1(_inst.FD) = value;
	}
}

void Interpreter::stb(UGeckoInstruction _inst)
{
	Memory::Write_U8((u8)rGPR[_inst.RS], Helper_Get_EA(_inst));
}

void Interpreter::lfd(UGeckoInstruction _inst)
{
	u64 temp = Memory::Read_U64(Helper_Get_EA(_inst));
	if (!(PowerPC::ppcState.Exceptions & EXCEPTION_DSI))
		riPS0(_inst.FD) = temp;
}