loadstore.c

来自「ppc750 system design simulator using sys」· C语言 代码 · 共 1,959 行 · 第 1/5 页

/***************************************************************************
                          loadstore.c  -  description
                             -------------------
    begin                : Wed Sep 26 2001
    copyright            : (C) 2001 Universite Paris Sud and CEA
    author               : Gilles Mouchard
    email                : [e-mail], [e-mail]
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#include <loadstore.h>
#include <ppcemul.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <xmlize.h>

#define EA_U (GPR(RA) + SEXT16(OFS))
#define EA (RA ? GPR(RA) + SEXT16(OFS) : SEXT16(OFS))
#define EA_UX (GPR(RA) + GPR(RB))
#define EA_X (RA ? GPR(RA) + GPR(RB) : GPR(RB))


void lbz_impl(ppc_inst_t inst)
{
	addr_t ea = EA;
	byte_t result = MEM_READ_BYTE(ea);
	GPR(RD) = (word_t) result;
}	

void lbzu_impl(ppc_inst_t inst)
{
	addr_t ea = EA_U;
	byte_t result = MEM_READ_BYTE(ea);
	GPR(RD) = (word_t) result;
	GPR(RA) = ea;
}

void lfd_impl(ppc_inst_t inst)
{
	addr_t ea = EA;
	dword_t result = MEM_READ_DWORD(ea);
	FPR_DW(FD) = result;
}

void lfdu_impl(ppc_inst_t inst)
{
	addr_t ea = EA_U;
	dword_t result = MEM_READ_DWORD(ea);
	FPR_DW(FD) = result;
	GPR(RA) = ea;
}

void lfs_impl(ppc_inst_t inst)
{
	addr_t ea = EA;
	word_t result = MEM_READ_WORD(ea);
	FPR_DBL(FD) = (double) *(float *) &result;
}

void lfsu_impl(ppc_inst_t inst)
{
	addr_t ea = EA_U;
	word_t result = MEM_READ_WORD(ea);
	FPR_DBL(FD) = (double) *(float *) &result;
	GPR(RA) = ea;
}

void lha_impl(ppc_inst_t inst)
{
	addr_t ea = EA;
	shalfword_t result = (shalfword_t) MEM_READ_HALF_WORD(ea);
	GPR(RD) = SEXT16(result);
}

void lhau_impl(ppc_inst_t inst)
{
	addr_t ea = EA_U;
	shalfword_t result = (shalfword_t) MEM_READ_HALF_WORD(ea);
	GPR(RD) = SEXT16(result);
	GPR(RA) = ea;
}


void lhz_impl(ppc_inst_t inst)
{
	addr_t ea = EA;
	halfword_t result = MEM_READ_HALF_WORD(ea);
	GPR(RD) = (word_t) result;
}

void lhzu_impl(ppc_inst_t inst)
{
	addr_t ea = EA_U;
	halfword_t result = MEM_READ_HALF_WORD(ea);
	GPR(RD) = (word_t) result;
	GPR(RA) = ea;
}

void lmw_impl(ppc_inst_t inst) { abort(); }


void lwz_impl(ppc_inst_t inst)
{
	addr_t ea = EA;
	word_t result = MEM_READ_WORD(ea);
	GPR(RD) = (word_t) result;
}


void lwzu_impl(ppc_inst_t inst)
{
	addr_t ea = EA_U;
	word_t result = MEM_READ_WORD(ea);
	GPR(RD) = (word_t) result;
	GPR(RA) = ea;
}


void stb_impl(ppc_inst_t inst)
{
	addr_t ea = EA;
	MEM_WRITE_BYTE(ea, GPR(RS));
}


void stbu_impl(ppc_inst_t inst)
{
	addr_t ea = EA_U;
	MEM_WRITE_BYTE(ea, GPR(RS));
	GPR(RA) = ea;
}

void stfd_impl(ppc_inst_t inst)
{
	addr_t ea = EA;
	MEM_WRITE_DWORD(ea, FPR_DW(FS));
}

void stfdu_impl(ppc_inst_t inst)
{
	addr_t ea = EA_U;
	MEM_WRITE_DWORD(ea, FPR_DW(FS));
	GPR(RA) = ea;
}

void stfs_impl(ppc_inst_t inst)
{
	addr_t ea = EA;
	float tmp = (float) FPR_DBL(FS);
	MEM_WRITE_WORD(ea, *(word_t *) &tmp);	
}

void stfsu_impl(ppc_inst_t inst)
{
	addr_t ea = EA_U;
	float tmp = (float) FPR_DBL(FS);
	MEM_WRITE_WORD(ea, *(word_t *) &tmp);	
	GPR(RA) = ea;
}

void sth_impl(ppc_inst_t inst)
{
	addr_t ea = EA;
	MEM_WRITE_HALF_WORD(ea, GPR(RS));
}

void sthu_impl(ppc_inst_t inst)
{
	addr_t ea = EA_U;
	MEM_WRITE_HALF_WORD(ea, GPR(RS));
	GPR(RA) = ea;
}

void stmw_impl(ppc_inst_t inst) { abort(); }


void stw_impl(ppc_inst_t inst)
{
	addr_t ea = EA;
	MEM_WRITE_WORD(ea, GPR(RS));
}


void stwu_impl(ppc_inst_t inst)
{
	addr_t ea = EA_U;
	MEM_WRITE_WORD(ea, GPR(RS));
	GPR(RA) = ea;
}

void dcba_impl(ppc_inst_t inst) { abort(); }
void dcbf_impl(ppc_inst_t inst) { abort(); }
void dcbi_impl(ppc_inst_t inst) { abort(); }
void dcbst_impl(ppc_inst_t inst) { abort(); }
void dcbt_impl(ppc_inst_t inst) { abort(); }
void dcbtst_impl(ppc_inst_t inst) { abort(); }

void dcbz_impl(ppc_inst_t inst)
{
	addr_t ea = EA_X;
	MEM_SET(ea - (ea % 32), 0, 32);
}

void eciwx_impl(ppc_inst_t inst) { abort(); }
void ecowx_impl(ppc_inst_t inst) { abort(); }
void eieio_impl(ppc_inst_t inst) { abort(); }
void icbi_impl(ppc_inst_t inst) { abort(); }

void lbzux_impl(ppc_inst_t inst)
{
	addr_t ea = EA_UX;
	byte_t result = MEM_READ_BYTE(ea);
	GPR(RD) = (word_t) result;
	GPR(RA) = ea;
}

void lbzx_impl(ppc_inst_t inst)
{
	addr_t ea = EA_X;
	byte_t result = MEM_READ_BYTE(ea);
	GPR(RD) = (word_t) result;
}

void lfdux_impl(ppc_inst_t inst)
{
	addr_t ea = EA_UX;
	dword_t result = MEM_READ_DWORD(ea);
	FPR_DW(FD) = result;
	GPR(RA) = ea;
}

void lfdx_impl(ppc_inst_t inst)
{
	addr_t ea = EA_X;
	dword_t result = MEM_READ_DWORD(ea);
	FPR_DW(FD) = result;
}

void lfsux_impl(ppc_inst_t inst)
{
	addr_t ea = EA_UX;
	word_t result = MEM_READ_WORD(ea);
	FPR_DBL(FD) = (double) *(float *) &result;
	GPR(RA) = ea;
}

void lfsx_impl(ppc_inst_t inst)
{
	addr_t ea = EA_X;
	word_t result = MEM_READ_WORD(ea);
	FPR_DBL(FD) = (double) *(float *) &result;
}


void lhaux_impl(ppc_inst_t inst)
{
	addr_t ea = EA_UX;
	shalfword_t result = (shalfword_t) MEM_READ_HALF_WORD(ea);
	GPR(RD) = SEXT16(result);
	GPR(RA) = ea;
}

void lhax_impl(ppc_inst_t inst)
{
	addr_t ea = EA_X;
	shalfword_t result = (shalfword_t) MEM_READ_HALF_WORD(ea);
	GPR(RD) = SEXT16(result);
}

void lhbrx_impl(ppc_inst_t inst)
{
	addr_t ea = EA_X;
	halfword_t result = MEM_READ_HALF_WORD_BYTE_REVERSE(ea);
	GPR(RD) = (word_t) result;
}

void lhzux_impl(ppc_inst_t inst)
{
	addr_t ea = EA_UX;
	halfword_t result = MEM_READ_HALF_WORD(ea);
	GPR(RD) = (word_t) result;
	GPR(RA) = ea;
}

void lhzx_impl(ppc_inst_t inst)
{
	addr_t ea = EA_X;
	halfword_t result = MEM_READ_HALF_WORD(ea);
	GPR(RD) = (word_t) result;
}

void lswi_impl(ppc_inst_t inst) { abort(); }
void lswx_impl(ppc_inst_t inst) { abort(); }
void lwarx_impl(ppc_inst_t inst) { abort(); }

void lwbrx_impl(ppc_inst_t inst)
{
	addr_t ea = EA_X;
	word_t result = MEM_READ_WORD_BYTE_REVERSE(ea);
	GPR(RD) = (word_t) result;
}

void lwzux_impl(ppc_inst_t inst)
{
	addr_t ea = EA_UX;
	word_t result = MEM_READ_WORD(ea);
	GPR(RD) = (word_t) result;
	GPR(RA) = ea;
}
	
void lwzx_impl(ppc_inst_t inst)
{
	addr_t ea = EA_X;
	word_t result = MEM_READ_WORD(ea);
	GPR(RD) = (word_t) result;
}

void stbux_impl(ppc_inst_t inst)
{
	addr_t ea = EA_UX;
	MEM_WRITE_BYTE(ea, GPR(RS));
	GPR(RA) = ea;
}

void stbx_impl(ppc_inst_t inst)
{
	addr_t ea = EA_X;
	MEM_WRITE_BYTE(ea, GPR(RS));
}

void stfdux_impl(ppc_inst_t inst)
{
	addr_t ea = EA_UX;
	MEM_WRITE_DWORD(ea, FPR_DW(FS));
	GPR(RA) = ea;
}

void stfdx_impl(ppc_inst_t inst)
{
	addr_t ea = EA_X;
	MEM_WRITE_DWORD(ea, FPR_DW(FS));
}

void stfiwx_impl(ppc_inst_t inst) { abort(); }

void stfsux_impl(ppc_inst_t inst)
{
	addr_t ea = EA_UX;
	float tmp = (float) FPR_DBL(FS);
	MEM_WRITE_WORD(ea, *(word_t *) &tmp);
	GPR(RA) = ea;
}

void stfsx_impl(ppc_inst_t inst)
{
	addr_t ea = EA_X;
	float tmp = (float) FPR_DBL(FS);
	MEM_WRITE_WORD(ea, *(word_t *) &tmp);
}

void sthbrx_impl(ppc_inst_t inst)
{
	addr_t ea = EA_X;
	MEM_WRITE_HALF_WORD_BYTE_REVERSE(ea, GPR(RS));
}
	
void sthux_impl(ppc_inst_t inst)
{
	addr_t ea = EA_UX;
	MEM_WRITE_HALF_WORD(ea, GPR(RS));
	GPR(RA) = ea;
}

void sthx_impl(ppc_inst_t inst)
{
	addr_t ea = EA_X;
	MEM_WRITE_HALF_WORD(ea, GPR(RS));
}

void stswi_impl(ppc_inst_t inst) { abort(); }
void stswx_impl(ppc_inst_t inst) { abort(); }

void stwbrx_impl(ppc_inst_t inst)