void test_ldw_x_shortoff_sp(void){
SET_SP(0X2B11);
uint8_t instr[] = {0XFB, 0X11};
MEM_WRITE_WORD(0X2B22 , 0xAE11); //0x2B11 + 0X11 = 0X2B22
TEST_ASSERT_EQUAL_INT8(2, ldw_x_shortoff_sp(instr));
TEST_ASSERT_EQUAL_INT16(0xAE11, X);
}
void test_ldw_x_shortmem(void){
uint8_t shortMEM = 0xAD;
MEM_WRITE_WORD(shortMEM, 0xAE11);
uint8_t instr[] = {0XBB, shortMEM};
TEST_ASSERT_EQUAL_INT8(2, ldw_x_shortmem(instr));
TEST_ASSERT_EQUAL_INT16(0xAE11, X);
}
void test_ldw_x_longoff_x(void){
SET_X(0X2B11);
uint8_t instr[] = {0XFB, 0X11, 0x11};
MEM_WRITE_WORD(0X3c22 , 0xAE11); //0x2B11 + 0X1111 = 0X3c22
TEST_ASSERT_EQUAL_INT8(3, ldw_x_longoff_x(instr));
TEST_ASSERT_EQUAL_INT8(0xAE11, X );
}
void test_ldw_x_longmem(void){
uint16_t longmem = 0x1101;
MEM_WRITE_WORD(longmem, 0xAE11);
uint8_t instr[] = {0XBB, 0x11, 0x01};
TEST_ASSERT_EQUAL_INT8(3, ldw_x_longmem(instr));
TEST_ASSERT_EQUAL_INT8(0xAE11, X );
}
void test_ldw_y_shortoff_y(void){
SET_Y(0X2B11);
uint8_t instr[] = {0XFB, 0X11};
MEM_WRITE_WORD(0X2B22 , 0xAE11); //0x2B11 + 0X11 = 0X2B22
TEST_ASSERT_EQUAL_INT8(3, ldw_y_shortoff_y(instr));
TEST_ASSERT_EQUAL_INT8(0xAE11, Y );
}
void test_ldw_x_shortptr_w(void){
uint8_t instr[] = {0XFB, 0X13};
MEM_WRITE_BYTE(0X13 , 0xAA );
MEM_WRITE_BYTE(0X14 , 0xBB);
MEM_WRITE_WORD(0xAABB , 0xAE11);
TEST_ASSERT_EQUAL_INT8(3, ldw_x_shortptr_w(instr));
TEST_ASSERT_EQUAL_INT8(0xAE11, X );
}
void test_ldw_x_x(void){
SET_X(0X102B);
uint8_t instr[] = {0XFB};
MEM_WRITE_WORD(0X102B , 0xAE11);
TEST_ASSERT_EQUAL_INT8(1, ldw_x_x(instr));
TEST_ASSERT_EQUAL_INT8(0xAE11, X );
}
void test_ldw_y_y(void){
SET_Y(0X102B);
uint8_t instr[] = {0XFB};
MEM_WRITE_WORD(0X102B , 0xAE11);
TEST_ASSERT_EQUAL_INT8(2, ldw_y_y(instr));
TEST_ASSERT_EQUAL_INT8(0xAE11, Y );
}
void test_ldw_x_longptr_w(void){
uint8_t instr[] = {0XFB, 0X13, 0X15};
MEM_WRITE_BYTE(0X1315 , 0xAA );
MEM_WRITE_BYTE(0X1316 , 0xBB);
MEM_WRITE_WORD(0xAABB , 0xAE11);
TEST_ASSERT_EQUAL_INT8(4, ldw_x_longptr_w(instr));
TEST_ASSERT_EQUAL_INT8(0xAE11, X );
}
void test_ldw_y_shortptr_w_y(void){
SET_Y(0X0011);
uint8_t instr[] = {0XFB, 0X13};
MEM_WRITE_BYTE(0X13 , 0x11);
MEM_WRITE_BYTE(0X14 , 0x11);
MEM_WRITE_WORD(0x1122 , 0xAE11); // 0X1111 + 0X11 = 0X1122
TEST_ASSERT_EQUAL_INT8(3, ldw_y_shortptr_w_y(instr));
TEST_ASSERT_EQUAL_INT16(0xAE11, Y);
}
void test_ldw_x_longptr_w_x(void){
SET_X(0X0011);
uint8_t instr[] = {0XFB, 0X13, 0X00};
MEM_WRITE_BYTE(0X1300 , 0xAA );
MEM_WRITE_BYTE(0X1301 , 0xBB);
MEM_WRITE_WORD(0xAACC , 0xAE11); // 0XAABB + 0X11 = 0XAACC
TEST_ASSERT_EQUAL_INT8(4, ldw_x_longptr_w_x(instr));
TEST_ASSERT_EQUAL_INT16(0xAE11, X );
}
/* load program into simulated state */
void
sim_load_prog(char *fname, /* program to load */
int argc, char **argv, /* program arguments */
char **envp) /* program environment */
{
/* load program text and data, set up environment, memory, and regs */
ld_load_prog(fname, argc, argv, envp, ®s, mem, TRUE);
#ifdef TARGET_ALPHA
/* pre-decode text segment */
{
unsigned i, num_insn = (ld_text_size + 3) / 4;
fprintf(stderr, "** pre-decoding %u insts...", num_insn);
/* allocate decoded text space */
dec = mem_create("dec");
for (i=0; i < num_insn; i++)
{
enum md_opcode op;
md_inst_t inst;
md_addr_t PC;
/* compute PC */
PC = ld_text_base + i * sizeof(md_inst_t);
/* get instruction from memory */
MD_FETCH_INST(inst, mem, PC);
/* decode the instruction */
MD_SET_OPCODE(op, inst);
/* insert into decoded opcode space */
MEM_WRITE_WORD(dec, PC << 1, (word_t)op);
MEM_WRITE_WORD(dec, (PC << 1)+sizeof(word_t), inst);
}
fprintf(stderr, "done\n");
}
#endif /* TARGET_ALPHA */
}
/* generic memory access function, it's safe because alignments and permissions
are checked, handles any natural transfer sizes; note, faults out if nbytes
is not a power-of-two or larger then MD_PAGE_SIZE */
enum md_fault_type
mem_access(struct mem_t *mem, /* memory space to access */
enum mem_cmd cmd, /* Read (from sim mem) or Write */
md_addr_t addr, /* target address to access */
void *vp, /* host memory address to access */
int nbytes) /* number of bytes to access */
{
byte_t *p = vp;
/* check alignments */
if (/* check size */(nbytes & (nbytes-1)) != 0
|| /* check max size */nbytes > MD_PAGE_SIZE)
return md_fault_access;
if (/* check natural alignment */(addr & (nbytes-1)) != 0)
return md_fault_alignment;
/* perform the copy */
switch (nbytes)
{
case 1:
if (cmd == Read)
*((byte_t *)p) = MEM_READ_BYTE(mem, addr);
else
MEM_WRITE_BYTE(mem, addr, *((byte_t *)p));
break;
case 2:
if (cmd == Read)
*((half_t *)p) = MEM_READ_HALF(mem, addr);
else
MEM_WRITE_HALF(mem, addr, *((half_t *)p));
break;
case 4:
if (cmd == Read)
*((word_t *)p) = MEM_READ_WORD(mem, addr);
else
MEM_WRITE_WORD(mem, addr, *((word_t *)p));
break;
#ifdef HOST_HAS_QUAD
case 8:
if (cmd == Read)
*((quad_t *)p) = MEM_READ_QUAD(mem, addr);
else
MEM_WRITE_QUAD(mem, addr, *((quad_t *)p));
break;
#endif /* HOST_HAS_QUAD */
default:
{
/* nbytes >= 8/16 and power of two */
unsigned words = nbytes >> 2;
if (cmd == Read)
{
while (words-- > 0)
{
*((word_t *)p) = MEM_READ_WORD(mem, addr);
p += sizeof(word_t);
addr += sizeof(word_t);
}
}
else
{
while (words-- > 0)
{
MEM_WRITE_WORD(mem, addr, *((word_t *)p));
p += sizeof(word_t);
addr += sizeof(word_t);
}
}
}
break;
}
/* no fault... */
return md_fault_none;
}
