OpenE2K
/
binutils-gdb
12
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

First pass at moving sky stuff from ../txvu to mips dir.

This commit is contained in:
Doug Evans 1998-02-06 02:29:22 +00:00
parent 587c41ae20
commit aea481da17
7 changed files with 923 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
sim/mips/.Sanitize
View File

@ -24,6 +24,17 @@ else
lose_these_too="${r5900_files} ${lose_these_too}"
fi
sky_files="ChangeLog.sky sky-device.c sky-device.h sky-dma.c sky-dma.h"
sky_files="$sky_files sky-engine.c sky-gpuif.c sky-gpuif.h"
sky_files="$sky_files sky-hardware.c sky-hardware.h"
sky_files="$sky_files sky-libvpe.c sky-libvpe.h sky-pke.c sky-pke.h"
sky_files="$sky_files sky-vpe.h sky-vu.h sky-vu0.c sky-vu0.h sky-vu1.c sky-vu1.h"
if ( echo $* | grep keep\-sky > /dev/null ) ; then
keep_these_too="${sky_files} ${keep_these_too}"
else
lose_these_too="${sky_files} ${lose_these_too}"
fi
vr5400_files="vr5400.igen mdmx.igen"
if ( echo $* | grep keep\-vr5400 > /dev/null ) ; then
keep_these_too="${vr5400_files} ${keep_these_too}"

306
sim/mips/sky-pke.c Normal file
View File

@ -0,0 +1,306 @@
/* Copyright (C) 1998, Cygnus Solutions */
#include "pke.h"
#include <stdlib.h>
/* Imported functions */
void device_error (device *me, char* message); /* device.c */
/* Internal function declarations */
static int pke_io_read_buffer(device*, void*, int, address_word,
unsigned, sim_cpu*, sim_cia);
static int pke_io_write_buffer(device*, const void*, int, address_word,
unsigned, sim_cpu*, sim_cia);
static void pke_issue(struct pke_device*);
/* Static data */
struct pke_device pke0_device =
{
{ "pke0", &pke_io_read_buffer, &pke_io_write_buffer }, /* device */
0, 0, /* ID, flags */
PKE0_REGISTER_WINDOW_START, PKE0_FIFO_START, /* memory-mapping addresses */
{}, /* regs */
NULL, 0, 0, NULL, /* FIFO */
0 /* pc */
};
struct pke_device pke1_device =
{
{ "pke1", &pke_io_read_buffer, &pke_io_write_buffer }, /* device */
1, 0, /* ID, flags */
PKE1_REGISTER_WINDOW_START, PKE1_FIFO_START, /* memory-mapping addresses */
{}, /* regs */
NULL, 0, 0, NULL, /* FIFO */
0 /* pc */
};
/* External functions */
/* Attach PKE0 addresses to main memory */
void
pke0_attach(SIM_DESC sd)
{
sim_core_attach (sd,
NULL,
0 /*level*/,
access_read_write,
0 /*space ???*/,
pke0_device.register_memory_addr,
PKE_REGISTER_WINDOW_SIZE /*nr_bytes*/,
0 /*modulo*/,
(device*) &pke0_device,
NULL /*buffer*/);
sim_core_attach (sd,
NULL,
0 /*level*/,
access_read_write,
0 /*space ???*/,
pke0_device.fifo_memory_addr,
sizeof(quadword) /*nr_bytes*/,
0 /*modulo*/,
(device*) &pke1_device,
NULL /*buffer*/);
}
/* Attach PKE1 addresses to main memory */
void
pke1_attach(SIM_DESC sd)
{
sim_core_attach (sd,
NULL,
0 /*level*/,
access_read_write,
0 /*space ???*/,
pke1_device.register_memory_addr,
PKE_REGISTER_WINDOW_SIZE /*nr_bytes*/,
0 /*modulo*/,
(device*) &pke1_device,
NULL /*buffer*/);
sim_core_attach (sd,
NULL,
0 /*level*/,
access_read_write,
0 /*space ???*/,
pke1_device.fifo_memory_addr,
sizeof(quadword) /*nr_bytes*/,
0 /*modulo*/,
(device*) &pke1_device,
NULL /*buffer*/);
}
/* Issue a PKE0 instruction if possible */
void
pke0_issue()
{
pke_issue(& pke0_device);
}
/* Issue a PKE1 instruction if possible */
void
pke1_issue()
{
pke_issue(& pke0_device);
}
/* Internal functions */
/* Handle a PKE read; return no. of bytes read */
int
pke_io_read_buffer(device *me_,
void *dest,
int space,
address_word addr,
unsigned nr_bytes,
sim_cpu *processor,
sim_cia cia)
{
/* downcast to gather embedding pke_device struct */
struct pke_device* me = (struct pke_device*) me_;
/* enforce that an access does not span more than one quadword */
address_word low = ADDR_TRUNC_QW(addr);
address_word high = ADDR_TRUNC_QW(addr + nr_bytes - 1);
if(low != high)
return 0;
/* classify address & handle */
if(addr >= me->register_memory_addr &&
addr < me->register_memory_addr + PKE_REGISTER_WINDOW_SIZE)
{
/* register bank */
int reg_num = ADDR_TRUNC_QW(addr - me->register_memory_addr) >> 4;
int readable = 1;
/* ensure readibility of register: all okay except PKE1-only ones read on PKE0 */
switch(reg_num)
{
case PKE_REG_BASE:
case PKE_REG_OFST:
case PKE_REG_TOPS:
case PKE_REG_TOP:
case PKE_REG_DBF:
if(me->pke_number == 0) /* PKE0 cannot access these registers */
readable = 0;
}
/* perform read & return */
if(readable)
{
/* find byte-offset inside register bank */
int reg_byte = ADDR_OFFSET_QW(addr);
void* src = ((unsigned_1*) (& me->regs[reg_num])) + reg_byte;
/* copy the bits */
memcpy(dest, src, nr_bytes);
/* okay */
return nr_bytes;
}
else
{
/* error */
return 0;
}
/* NOTREACHED */
}
else if(addr >= me->fifo_memory_addr &&
addr < me->fifo_memory_addr + sizeof(quadword))
{
/* FIFO */
/* XXX: FIFO is not readable. */
return 0;
}
/* NOTREACHED */
}
/* Handle a PKE read; return no. of bytes written */
int
pke_io_write_buffer(device *me_,
const void *src,
int space,
address_word addr,
unsigned nr_bytes,
sim_cpu *processor,
sim_cia cia)
{
/* downcast to gather embedding pke_device struct */
struct pke_device* me = (struct pke_device*) me_;
/* enforce that an access does not span more than one quadword */
address_word low = ADDR_TRUNC_QW(addr);
address_word high = ADDR_TRUNC_QW(addr + nr_bytes - 1);
if(low != high)
return 0;
/* classify address & handle */
if(addr >= me->register_memory_addr &&
addr < me->register_memory_addr + PKE_REGISTER_WINDOW_SIZE)
{
/* register bank */
int reg_num = ADDR_TRUNC_QW(addr - me->register_memory_addr) >> 4;
int writeable = 1;
/* ensure readibility of register: all okay except PKE1-only ones read on PKE0 */
switch(reg_num)
{
case PKE_REG_BASE:
case PKE_REG_OFST:
case PKE_REG_TOPS:
case PKE_REG_TOP:
case PKE_REG_DBF:
if(me->pke_number == 0) /* PKE0 cannot access these registers */
writeable = 0;
}
/* perform write & return */
if(writeable)
{
/* find byte-offset inside register bank */
int reg_byte = ADDR_OFFSET_QW(addr);
void* dest = ((unsigned_1*) (& me->regs[reg_num])) + reg_byte;
/* copy the bits */
memcpy(dest, src, nr_bytes);
return nr_bytes;
}
else
{
/* error */
return 0;
}
/* NOTREACHED */
}
else if(addr >= me->fifo_memory_addr &&
addr < me->fifo_memory_addr + sizeof(quadword))
{
/* FIFO */
/* assert transfer size == 128 bits */
if(nr_bytes != sizeof(quadword))
return 0;
/* ensure FIFO has enough elements */
if(me->fifo_num_elements == me->fifo_buffer_size)
{
/* time to grow */
int new_fifo_buffer_size = me->fifo_buffer_size + 20;
void* ptr = realloc((void*) me->fifo, new_fifo_buffer_size*sizeof(quadword));
if(ptr == NULL)
{
/* oops, cannot enlarge FIFO any more */
device_error(me_, "Cannot enlarge FIFO buffer\n");
return 0;
}
me->fifo_buffer_size = new_fifo_buffer_size;
}
/* add new quadword at end of FIFO */
memcpy(& me->fifo[++me->fifo_num_elements], src, nr_bytes);
/* okay */
return nr_bytes;
}
/* NOTREACHED */
}
/* Issue & swallow one PKE opcode if possible */
void
pke_issue(struct pke_device* me)
{
}

117
sim/mips/sky-pke.h Normal file
View File

@ -0,0 +1,117 @@
/* Copyright (C) 1998, Cygnus Solutions */
#ifndef H_PKE_H
#define H_PKE_H
#include "sim-main.h"
#include "device.h"
/* External functions */
void pke0_attach(SIM_DESC sd);
void pke0_issue();
void pke1_attach(SIM_DESC sd);
void pke1_issue();
/* Quadword data type */
typedef unsigned int quadword[4];
/* truncate address to quadword */
#define ADDR_TRUNC_QW(addr) ((addr) & ~0x0f)
/* extract offset in quadword */
#define ADDR_OFFSET_QW(addr) ((addr) & 0x0f)
/* SCEI memory mapping information */
#define PKE0_REGISTER_WINDOW_START 0x10000800
#define PKE1_REGISTER_WINDOW_START 0x10000A00
#define PKE0_FIFO_START 0x10008000
#define PKE1_FIFO_START 0x10008010
/* Quadword indices of PKE registers. Actual registers sit at bottom
32 bits of each quadword. */
#define PKE_REG_STAT 0x00
#define PKE_REG_FBRST 0x01
#define PKE_REG_ERR 0x02
#define PKE_REG_MARK 0x03
#define PKE_REG_CYCLE 0x04
#define PKE_REG_MODE 0x05
#define PKE_REG_NUM 0x06
#define PKE_REG_MASK 0x07
#define PKE_REG_CODE 0x08
#define PKE_REG_ITOPS 0x09
#define PKE_REG_BASE 0x0a /* pke1 only */
#define PKE_REG_OFST 0x0b /* pke1 only */
#define PKE_REG_TOPS 0x0c /* pke1 only */
#define PKE_REG_ITOP 0x0d
#define PKE_REG_TOP 0x0e /* pke1 only */
#define PKE_REG_DBF 0x0f /* pke1 only */
#define PKE_REG_R0 0x10
#define PKE_REG_R1 0x11
#define PKE_REG_R2 0x12
#define PKE_REG_R3 0x13
#define PKE_REG_C0 0x14
#define PKE_REG_C1 0x15
#define PKE_REG_C2 0x16
#define PKE_REG_C3 0x17
/* one plus last index */
#define PKE_NUM_REGS 0x18
#define PKE_REGISTER_WINDOW_SIZE (sizeof(quadword) * PKE_NUM_REGS)
/* virtual addresses for source-addr tracking */
#define PKE0_SRCADDR 0x20000020
#define PKE1_SRCADDR 0x20000024
/* One row in the FIFO */
struct fifo_quadword
{
/* 128 bits of data */
quadword data;
/* source main memory address (or 0: unknown) */
address_word source_address;
};
/* PKE internal state: FIFOs, registers, handle to VU friend */
struct pke_device
{
/* common device info */
device dev;
/* identity: 0=PKE0, 1=PKE1 */
int pke_number;
int flags;
address_word register_memory_addr;
address_word fifo_memory_addr;
/* quadword registers */
quadword regs[PKE_NUM_REGS];
/* FIFO */
struct fifo_quadword* fifo;
int fifo_num_elements; /* no. of quadwords occupied in FIFO */
int fifo_buffer_size; /* no. of quadwords of space in FIFO */
FILE* fifo_trace_file; /* or 0 for no trace */
/* index into FIFO of current instruction */
int program_counter;
};
/* Flags for PKE.flags */
#define PKE_FLAG_NONE 0
/* none at present */
#endif /* H_PKE_H */

86
sim/mips/sky-vu0.c Normal file
View File

@ -0,0 +1,86 @@
/* Copyright (C) 1998, Cygnus Solutions
*/
#include "sim-main.h"
#include "device.h"
#include "vu0.h"
static char vu0_mem0_buffer[VU0_MEM0_SIZE];
static char vu0_mem1_buffer[VU0_MEM1_SIZE];
void
vu0_issue()
{
}
int
vu0_io_read_buffer(device *me,
void *dest,
int space,
address_word addr,
unsigned nr_bytes,
sim_cpu *processor,
sim_cia cia)
{
printf("%s: Read!\n", me->name);
return nr_bytes;
}
int
vu0_io_write_buffer(device *me,
const void *source,
int space,
address_word addr,
unsigned nr_bytes,
sim_cpu *processor,
sim_cia cia)
{
printf("%s: Write!\n", me->name);
return nr_bytes;
}
device vu0_device =
{
"vu0",
&vu0_io_read_buffer,
&vu0_io_write_buffer
};
void
vu0_attach(SIM_DESC sd)
{
sim_core_attach (sd,
NULL,
0 /*level*/,
access_read_write,
0 /*space ???*/,
VU0_REGISTER_WINDOW_START,
VU0_REGISTER_WINDOW_SIZE /*nr_bytes*/,
0 /*modulo*/,
&vu0_device,
NULL /*buffer*/);
sim_core_attach (sd,
NULL,
0 /*level*/,
access_read_write,
0 /*space ???*/,
VU0_MEM0_WINDOW_START,
VU0_MEM0_SIZE /*nr_bytes*/,
0 /*modulo*/,
0 /*device*/,
&vu0_mem0_buffer /*buffer*/);
sim_core_attach (sd,
NULL,
0 /*level*/,
access_read_write,
0 /*space ???*/,
VU0_MEM1_WINDOW_START,
VU0_MEM1_SIZE /*nr_bytes*/,
0 /*modulo*/,
0 /*device*/,
&vu0_mem1_buffer /*buffer*/);
}

37
sim/mips/sky-vu0.h Normal file
View File

@ -0,0 +1,37 @@
/* Copyright (C) 1998, Cygnus Solutions
*/
#ifndef VU0_H_
#define VU0_H_
#include "sim-main.h"
void vu0_attach(SIM_DESC sd);
void vu0_issue();
#define VU0_MEM0_WINDOW_START 0x11000000
#define VU0_MEM0_SIZE 0x1000 /* 4K = 4096 */
#define VU0_MEM1_WINDOW_START 0x11004000
#define VU0_MEM1_SIZE 0x1000 /* 4K = 4096 */
#define VU0_REGISTER_WINDOW_START 0x10000c00
#define VU0_VF00 0x10000c00
/* ... */
#define VU0_VF31 0x10000df0
#define VU0_VI00 0x10000e00
/* ... */
#define VU0_VI15 0x10000ef0
/* ... */
#define VPE0_STAT 0x10000fd0
#define VU0_REGISTER_WINDOW_END 0x10000fe0
#define VU0_REGISTER_WINDOW_SIZE (VU0_REGISTER_WINDOW_END - VU0_REGISTER_WINDOW_START)
#endif

323
sim/mips/sky-vu1.c Normal file
View File

@ -0,0 +1,323 @@
/* Copyright (C) 1998, Cygnus Solutions
*/
#include "sim-main.h"
#include "device.h"
#include "vu1.h"
#include "libvpe.h"
#include "vu.h"
VectorUnitState vu1_state;
static char vu1_umem_buffer[VU1_MEM0_SIZE];
static char vu1_mem_buffer[VU1_MEM1_SIZE];
void init_vu1();
void init_vu(VectorUnitState *state, char* umem_buffer, char* mem_buffer);
void
vu1_issue()
{
if (vu1_state.runState == VU_RUN)
vpecallms_cycle(&vu1_state);
}
int
vu1_io_read_register_window(device *me,
void *dest,
int space,
address_word addr,
unsigned nr_bytes,
sim_cpu *processor,
sim_cia cia)
{
/* Slow and crappy hack ... */
int i;
char source_buffer[VU1_REGISTER_WINDOW_SIZE];
char* src;
memcpy(source_buffer, &vu1_state.regs.VF[0][0], 0x200); /* copy VF registers */
for (i = 0; i<16; i++ ) {
*(short*)&source_buffer[0x200 + i*16] = vu1_state.regs.VI[i];
}
*(u_long*)&source_buffer[VU1_MST - VU1_REGISTER_WINDOW_START] = vu1_state.regs.MST;
*(u_long*)&source_buffer[VU1_MMC - VU1_REGISTER_WINDOW_START] = vu1_state.regs.MMC;
*(u_long*)&source_buffer[VU1_MCP - VU1_REGISTER_WINDOW_START] = vu1_state.regs.MCP;
*(u_long*)&source_buffer[VU1_MR - VU1_REGISTER_WINDOW_START] = vu1_state.regs.MR;
*(u_long*)&source_buffer[VU1_MI - VU1_REGISTER_WINDOW_START] = vu1_state.regs.MI;
*(u_long*)&source_buffer[VU1_MQ - VU1_REGISTER_WINDOW_START] = vu1_state.regs.MQ;
*(u_long*)&source_buffer[VU1_MP - VU1_REGISTER_WINDOW_START] = vu1_state.regs.MP;
*(u_long*)&source_buffer[VU1_MTPC - VU1_REGISTER_WINDOW_START] = vu1_state.regs.MTPC;
*(VpeStat*)&source_buffer[VPE1_STAT - VU1_REGISTER_WINDOW_START] = vu1_state.regs.VPE_STAT;
printf("%s: Read: %x, %d, dest: %x, space: %d, %x!\n", me->name, addr, nr_bytes, dest, space, vu1_state.regs.VPE_STAT);
printf(" vu1_state.regs.VPE_STAT = %x\n", vu1_state.regs.VPE_STAT);
if (addr + nr_bytes > VU1_REGISTER_WINDOW_END) {
fprintf(stderr, "Error: Read past end of vu1 register window!!!\n");
exit(1);
}
src = &source_buffer[0] + (addr - VU1_REGISTER_WINDOW_START);
memcpy(dest, src, nr_bytes);
return nr_bytes;
}
int
vu1_io_write_register_window(device *me,
const void *source,
int space,
address_word addr,
unsigned nr_bytes,
sim_cpu *processor,
sim_cia cia)
{
char *dest;
if (addr == VPE1_STAT && nr_bytes == 4) {
/* Magic to switch VU to run state, until other methods are available. */
vu1_state.runState = VU_RUN;
vu1_state.regs.VPE_STAT.vbs = 1;
printf("Magic start run...\n");
printf("%x,%x,%x,%x\n", &vu1_state.regs.VF[0][0], &vu1_state.regs.VPE_STAT,
((char*)&vu1_state.regs.VPE_STAT) - ((char*)&vu1_state.regs.VF[0][0]),
((char*)&vu1_state.regs.VPE_STAT) - ((char*)&vu1_state.regs.VF[0][0]) + VU1_REGISTER_WINDOW_START
);
printf("%x,%x,%x,%x\n", &vu1_state.regs.VF[0][0], &vu1_state.regs.VI[0],
((char*)&vu1_state.regs.VI[0]) - ((char*)&vu1_state.regs.VF[0][0]),
((char*)&vu1_state.regs.VI[0]) - ((char*)&vu1_state.regs.VF[0][0]) + VU1_REGISTER_WINDOW_START
);
printf("%x,%x,%x,%x\n", &vu1_state.regs.VF[0][0], &vu1_state.regs.MST,
((char*)&vu1_state.regs.MST) - ((char*)&vu1_state.regs.VF[0][0]),
((char*)&vu1_state.regs.MST) - ((char*)&vu1_state.regs.VF[0][0]) + VU1_REGISTER_WINDOW_START
);
return nr_bytes;
}
printf("%s: Write: %x, %d, source: %x, space: %d!\n", me->name, addr, nr_bytes, source, space);
if (addr + nr_bytes > VU1_REGISTER_WINDOW_END) {
fprintf(stderr, "Error: Read past end of vu1 register window!!!\n");
exit(1);
}
dest = ((char*) (&vu1_state.regs)) + (addr - VU1_REGISTER_WINDOW_START);
memcpy(dest, source, nr_bytes);
return nr_bytes;
}
device vu1_device =
{
"vu1",
&vu1_io_read_register_window,
&vu1_io_write_register_window
};
void
vu1_init(SIM_DESC sd)
{
sim_core_attach (sd,
NULL,
0 /*level*/,
access_read_write,
0 /*space ???*/,
VU1_REGISTER_WINDOW_START,
VU1_REGISTER_WINDOW_SIZE /*nr_bytes*/,
0 /*modulo*/,
&vu1_device,
NULL /*buffer*/);
sim_core_attach (sd,
NULL,
0 /*level*/,
access_read_write,
0 /*space ???*/,
VU1_MEM0_WINDOW_START,
VU1_MEM0_SIZE /*nr_bytes*/,
0 /*modulo*/,
0 /*device*/,
&vu1_umem_buffer /*buffer*/);
sim_core_attach (sd,
NULL,
0 /*level*/,
access_read_write,
0 /*space ???*/,
VU1_MEM1_WINDOW_START,
VU1_MEM1_SIZE /*nr_bytes*/,
0 /*modulo*/,
0 /*device*/,
&vu1_mem_buffer /*buffer*/);
init_vu1();
/*initvpe();*/
vpecallms_init(&vu1_state);
}
/****************************************************************************/
/* */
/* Sony Computer Entertainment CONFIDENTIAL */
/* (C) 1997 Sony Computer Entertainment Inc. All Rights Reserved */
/* */
/* VPE1 simulator */
/* */
/****************************************************************************/
#include <stdio.h>
#include <sys/types.h>
#include <strings.h>
#include "libvpe.h"
char ifilename[64] = "vu.bin";
char ofilename[64] = "";
char pfilename[64] = "";
void abend2(char *fmt, char* p) {
fprintf(stderr, fmt, p);
exit(1);
}
void getoption();
void init_vu1() {
init_vu(&vu1_state, &vu1_umem_buffer[0], &vu1_mem_buffer[0]);
}
void init_vu(VectorUnitState *state, char* umem_buffer, char* mem_buffer)
{
FILE *fp;
int i, j;
u_long data[4];
/* set up memory buffers */
state->uMEM = (uMEM_Entry_Type *) umem_buffer;
state->MEM = (MEM_Entry_Type*) mem_buffer;
/* set up run state */
state->runState = VU_READY;
/* read option */
getoption();
/* read instruction file (mandatory) */
if (*ifilename) {
if((fp = fopen(ifilename, "r")) == NULL)
abend2("%s: can not open\n", ifilename);
for (i = 0; fread(&data[0], 4, 1, fp) != 0; i++) {
fread(&data[1], 4, 1, fp);
LoadMMem(state, i, data, 1);
}
fclose(fp);
}
/* PKE dirven simvpe */
if (*pfilename) {
/* initpke(pfilename); */
initvpe(&vu1_state);
/* while (simpke() != -1)
simvpe(); */
}
/* conventional simvpe */
else {
initvpe(&vu1_state);
/*simvpe();*/
}
/* write result memory image (optional) */
if (*ofilename) {
if((fp = fopen(ofilename, "w")) == NULL)
abend2("%s: can not open\n", ofilename);
for(i = 0; i < 2048; i++){
StoreVUMem(i, data, 1);
for(j = 0; j < 4; j++)
fwrite(&data[j], 4, 1, fp);
}
fclose(fp);
}
}
static void Usage(void)
{
fprintf(stderr, "Usage: simvpe [options]\n");
fprintf(stderr, "\t\t-i instruction-file\n");
fprintf(stderr, "\t\t-o output-memory-file\n");
fprintf(stderr, "\t\t-t PKE-file (text type)\n");
fprintf(stderr, "\t\t-s start-address [default = 0]\n");
fprintf(stderr, "\t\t-d [interactive mode enable: default desable]\n");
fprintf(stderr, "\t\t-v [statistics mode enable: default desable]\n");
fprintf(stderr, "\t\t-p [debug print mode enable: default desable]\n");
}
void getoption()
{
int startline = 0;
int count = 1;
_is_dbg = 1;
_vpepc = 0;
_is_verb = 0;
_is_dump = 0;
_pgpuif = 2;
_ITOP = 20;
_TOP = 10;
#if 0
while(argc - count){
if(argv[count][0] == '-'){
switch(argv[count][1]){
case 'i':
strcpy(ifilename, argv[count+1]);
count += 2;
break;
case 'o':
strcpy(ofilename, argv[count+1]);
count += 2;
break;
case 't':
strcpy(pfilename, argv[count+1]);
count += 2;
break;
case 's':
sscanf(argv[count+1], "%d", &startline);
_vpepc = startline;
count += 2;
break;
case 'd':
_is_dbg = 1;
count += 1;
break;
case 'v':
_is_verb = 1;
count += 1;
break;
case 'p':
_is_dump = 1;
count += 1;
break;
case 'h':
case '?':
Usage();
exit(1);
break;
default:
Usage();
exit(1);
}
}else{
Usage();
exit(1);
}
}
#endif
}

43
sim/mips/sky-vu1.h Normal file
View File

@ -0,0 +1,43 @@
/* Copyright (C) 1998, Cygnus Solutions
*/
#ifndef VU1_H_
#define VU1_H_
#include "sim-main.h"
void vu1_attach(SIM_DESC sd);
void vu1_issue();
#define VU1_MEM0_WINDOW_START 0x11008000
#define VU1_MEM0_SIZE 0x4000 /* 16K = 16384 */
#define VU1_MEM1_WINDOW_START 0x1100c000
#define VU1_MEM1_SIZE 0x4000 /* 16K = 16384 */
#define VU1_REGISTER_WINDOW_START 0x11007000
#define VU1_VF00 0x11007000
/* ... */
#define VU1_VF31 0x110071f0
#define VU1_VI00 0x11007200
/* ... */
#define VU1_VI15 0x110072f0
#define VU1_MST 0x11007300
#define VU1_MMC 0x11007310
#define VU1_MCP 0x11007320
#define VU1_MR 0x11007330
#define VU1_MI 0x11007340
#define VU1_MQ 0x11007350
#define VU1_MP 0x11007360
#define VU1_MTPC 0x110073a0
#define VPE1_STAT 0x110073d0
#define VU1_REGISTER_WINDOW_END 0x110073e0
#define VU1_REGISTER_WINDOW_SIZE (VU1_REGISTER_WINDOW_END - VU1_REGISTER_WINDOW_START)
#endif