T32 Simulator: Basic Instruction set sim for ARMM3

The T32 can simulate bare instruction sets without periphery.
For the Cortex-M3 we have complete NVIC model including Systick Timer.
Currently a simple CiAO can run on the simulator.

TODO:
 - Let memlogger log all memory accesses.
 - Interact with FailT32 for a complete simulation/FI
This commit is contained in:
Martin Hoffmann
2013-03-20 17:17:38 +01:00
parent f0e26a9b63
commit 96bc39c05d
42 changed files with 5880 additions and 46 deletions

View File

@ -0,0 +1,532 @@
#include "simul.h"
/**************************************************************************
Model entry
**************************************************************************/
int SIMULAPI SIMUL_Interface(simulProcessor processor, simulCallbackStruct * cbs)
{
cbs->x.init.version = SIMUL_VERSION;
#if SIMUL_ARCHITECTURE_WIDTH == 8
cbs->x.init.argpword = cbs->x.init.argpword64;
cbs->x.init.argpaddress = cbs->x.init.argpaddress64;
#else
cbs->x.init.argpword = cbs->x.init.argpword32;
cbs->x.init.argpaddress = cbs->x.init.argpaddress32;
#endif
return SIMUL_Init(processor, cbs);
}
/**************************************************************************
Generic configuration functions
**************************************************************************/
void SIMULAPI SIMUL_Printf(simulProcessor processor, const char *format, ...)
{
va_list ap;
va_start(ap, format);
(*((simulProcInfo *) processor)->printf) (processor, format, ap);
va_end(ap);
}
void SIMULAPI SIMUL_Warning(simulProcessor processor, const char *format, ...)
{
va_list ap;
va_start(ap, format);
(*((simulProcInfo *) processor)->warning) (processor, format, ap);
va_end(ap);
}
void SIMULAPI SIMUL_Stop(simulProcessor processor)
{
(*((simulProcInfo *) processor)->stop) (processor);
}
void SIMULAPI SIMUL_Update(simulProcessor processor, int flags)
{
(*((simulProcInfo *) processor)->update) (processor, flags);
}
void * SIMULAPI SIMUL_Alloc(simulProcessor processor, int size)
{
return (*((simulProcInfo *) processor)->alloc)(processor, size);
}
void SIMULAPI SIMUL_Free(simulProcessor processor, void * ptr)
{
(*((simulProcInfo *) processor)->free)(processor, ptr);
}
int SIMULAPI SIMUL_GetEndianess(simulProcessor processor)
{
return ((simulProcInfo *) processor)->endianess;
}
void * SIMULAPI SIMUL_RegisterCommandCallback(simulProcessor processor, simulCallbackFunctionPtr func, simulPtr private)
{
return (*((simulProcInfo *) processor)->registerCommandCallback) (processor, func, private, SIMUL_ARCHITECTURE_WIDTH);
}
void * SIMULAPI SIMUL_RegisterResetCallback(simulProcessor processor, simulCallbackFunctionPtr func, simulPtr private)
{
return (*((simulProcInfo *) processor)->registerResetCallback)(processor, func, private);
}
void * SIMULAPI SIMUL_RegisterExitCallback(simulProcessor processor, simulCallbackFunctionPtr func, simulPtr private)
{
return (*((simulProcInfo *) processor)->registerExitCallback)(processor, func, private);
}
void * SIMULAPI SIMUL_RegisterGoCallback(simulProcessor processor, simulCallbackFunctionPtr func, simulPtr private)
{
return (*((simulProcInfo *) processor)->registerGoCallback)(processor, func, private);
}
void * SIMULAPI SIMUL_RegisterBreakCallback(simulProcessor processor, simulCallbackFunctionPtr func, simulPtr private)
{
return (*((simulProcInfo *) processor)->registerBreakCallback)(processor, func, private);
}
/**************************************************************************
Clocks and Timers
**************************************************************************/
void SIMULAPI SIMUL_GetClockFrequency(simulProcessor processor, int id, simulWord64 * pfrequency)
{
(*((simulProcInfo *) processor)->getClockFrequency)(processor, id, pfrequency);
}
void SIMULAPI SIMUL_SetClockFrequency(simulProcessor processor, int id, simulWord64 * pfrequency)
{
(*((simulProcInfo *) processor)->setClockFrequency)(processor, id, pfrequency);
}
void SIMULAPI SIMUL_GetClockCycle(simulProcessor processor, int id, simulTime * ptime)
{
(*((simulProcInfo *) processor)->getClockCycle)(processor, id, ptime);
}
void SIMULAPI SIMUL_SetClockCycle(simulProcessor processor, int id, simulTime * ptime)
{
(*((simulProcInfo *) processor)->setClockCycle)(processor, id, ptime);
}
void SIMULAPI SIMUL_GetTime(simulProcessor processor, simulTime * ptime)
{
(*((simulProcInfo *) processor)->getTime)(processor, ptime);
}
void SIMULAPI SIMUL_GetClock(simulProcessor processor, int timerid, simulTime * ptime)
{
(*((simulProcInfo *) processor)->getClock) (processor, timerid, ptime);
}
void SIMULAPI SIMUL_Stall(simulProcessor processor, int mode, simulTime * ptime)
{
(*((simulProcInfo *) processor)->stall) (processor, mode, ptime);
}
void SIMULAPI SIMUL_StartTimer(simulProcessor processor, void * timerid, int mode, simulTime * ptime)
{
(*((simulProcInfo *) processor)->startTimer)(processor, timerid, mode, ptime);
}
void SIMULAPI SIMUL_StopTimer(simulProcessor processor, void * timerid)
{
(*((simulProcInfo *) processor)->stopTimer)(processor, timerid);
}
void SIMULAPI SIMUL_StopAllTimer(simulProcessor processor)
{
(*((simulProcInfo *) processor)->stopTimer) (processor);
}
void * SIMULAPI SIMUL_RegisterTimerCallback(simulProcessor processor, simulCallbackFunctionPtr func, simulPtr private)
{
return (*((simulProcInfo *) processor)->registerTimerCallback)(processor, func, private);
}
/**************************************************************************
Buses and Memories
**************************************************************************/
int SIMULAPI SIMUL_ReadMemory(simulProcessor processor, int bustype, simulWord * paddress, int width, int cycletype, simulWord * pdata)
{
#if SIMUL_ARCHITECTURE_WIDTH == 8
return (*((simulProcInfo *) processor)->readMemory64) (processor, bustype, paddress, width, cycletype, pdata);
#else
return (*((simulProcInfo *) processor)->readMemory32) (processor, bustype, paddress, width, cycletype, pdata);
#endif
}
int SIMULAPI SIMUL_WriteMemory(simulProcessor processor, int bustype, simulWord * paddress, int width, int cycletype, simulWord * pdata)
{
#if SIMUL_ARCHITECTURE_WIDTH == 8
return (*((simulProcInfo *) processor)->writeMemory64) (processor, bustype, paddress, width, cycletype, pdata);
#else
return (*((simulProcInfo *) processor)->writeMemory32) (processor, bustype, paddress, width, cycletype, pdata);
#endif
}
void * SIMULAPI SIMUL_RegisterBusWriteCallback(simulProcessor processor, simulCallbackFunctionPtr func, simulPtr private, int bustype, simulWord * paddressFrom, simulWord * paddressTo)
{
return (*((simulProcInfo *) processor)->registerBusWriteCallback)(processor, func, private, bustype, paddressFrom, paddressTo, SIMUL_ARCHITECTURE_WIDTH);
}
void * SIMULAPI SIMUL_RegisterBusReadCallback(simulProcessor processor, simulCallbackFunctionPtr func, simulPtr private, int bustype, simulWord * paddressFrom, simulWord * paddressTo)
{
return (*((simulProcInfo *) processor)->registerBusReadCallback)(processor, func, private, bustype, paddressFrom, paddressTo, SIMUL_ARCHITECTURE_WIDTH);
}
void SIMULAPI SIMUL_RelocateBusCallback(simulProcessor processor, void * callbackid, int bustype, simulWord * paddressFrom, simulWord * paddressTo)
{
(*((simulProcInfo *) processor)->relocateBusCallback)(processor, callbackid, bustype, paddressFrom, paddressTo, SIMUL_ARCHITECTURE_WIDTH);
}
void SIMULAPI SIMUL_InsertWord(simulProcessor processor, simulWord * ptarget , int wordwidth, simulWord * paddress, int width, simulWord * pdata)
{
int offset;
if (width >= wordwidth) {
*ptarget = *pdata;
} else if (width == 8) {
if (((simulProcInfo *) processor)->endianess) {
offset = wordwidth - 8 - ((*paddress << 3) & (wordwidth - 1));
} else {
offset = (*paddress << 3) & (wordwidth - 1);
}
*ptarget = (*ptarget & ~(0xff << offset)) | ((*pdata & 0xff) << offset);
} else if (width == 16) {
if (((simulProcInfo *) processor)->endianess) {
offset = wordwidth - 16 - ((*paddress << 3) & (wordwidth - 1));
} else {
offset = (*paddress << 3) & (wordwidth - 1);
}
*ptarget = (*ptarget & ~(0xffff << offset)) | ((*pdata & 0xffff) << offset);
#if SIMUL_ARCHITECTURE_WIDTH == 8
} else if (width == 32) {
if (((simulProcInfo *) processor)->endianess) {
offset = wordwidth - 32 - ((*paddress << 3) & (wordwidth - 1));
} else {
offset = (*paddress << 3) & (wordwidth - 1);
}
*ptarget = (*ptarget & ~(0xffffffff << offset)) | ((*pdata & 0xffffffff) << offset);
#endif
}
}
void SIMULAPI SIMUL_ExtractWord(simulProcessor processor, simulWord * psource, int wordwidth, simulWord * paddress, int width, simulWord * pdata)
{
int offset;
if (width >= wordwidth) {
*pdata = *psource;
} else if (width == 8) {
if (((simulProcInfo *) processor)->endianess) {
offset = wordwidth - 8 - ((*paddress << 3) & (wordwidth - 1));
} else {
offset = (*paddress << 3) & (wordwidth - 1);
}
*pdata = (*psource >> offset) & 0xff;
} else if (width == 16) {
if (((simulProcInfo *) processor)->endianess) {
offset = wordwidth - 16 - ((*paddress << 3) & (wordwidth - 1));
} else {
offset = (*paddress << 3) & (wordwidth - 1);
}
*pdata = (*psource >> offset) & 0xffff;
#if SIMUL_ARCHITECTURE_WIDTH == 8
} else if (width == 32) {
if (((simulProcInfo *) processor)->endianess) {
offset = wordwidth - 32 - ((*paddress << 3) & (wordwidth - 1));
} else {
offset = (*paddress << 3) & (wordwidth - 1);
}
*pdata = (*psource >> offset) & 0xffffffff;
#endif
}
}
void SIMULAPI SIMUL_SaveWord(simulProcessor processor, void * ptarget, int width, simulWord * pdata)
{
if (((simulProcInfo *) processor)->endianess) {
switch (width>>3) {
#if SIMUL_ARCHITECTURE_WIDTH == 8
case 8:
((unsigned char *) ptarget)[0] = *pdata >> 56;
((unsigned char *) ptarget)[1] = *pdata >> 48;
((unsigned char *) ptarget)[2] = *pdata >> 40;
((unsigned char *) ptarget)[3] = *pdata >> 32;
((unsigned char *) ptarget)[4] = *pdata >> 24;
((unsigned char *) ptarget)[5] = *pdata >> 16;
((unsigned char *) ptarget)[6] = *pdata >> 8;
((unsigned char *) ptarget)[7] = *pdata;
break;
#endif
case 4:
((unsigned char *) ptarget)[0] = *pdata >> 24;
((unsigned char *) ptarget)[1] = *pdata >> 16;
((unsigned char *) ptarget)[2] = *pdata >> 8;
((unsigned char *) ptarget)[3] = *pdata;
break;
case 2:
((unsigned char *) ptarget)[0] = *pdata >> 8;
((unsigned char *) ptarget)[1] = *pdata;
break;
default:
((unsigned char *) ptarget)[0] = *pdata;
break;
}
} else {
switch (width>>3) {
#if SIMUL_ARCHITECTURE_WIDTH == 8
case 8:
((unsigned char *) ptarget)[7] = *pdata >> 56;
((unsigned char *) ptarget)[6] = *pdata >> 48;
((unsigned char *) ptarget)[5] = *pdata >> 40;
((unsigned char *) ptarget)[4] = *pdata >> 32;
#endif
case 4:
((unsigned char *) ptarget)[3] = *pdata >> 24;
((unsigned char *) ptarget)[2] = *pdata >> 16;
case 2:
((unsigned char *) ptarget)[1] = *pdata >> 8;
default:
((unsigned char *) ptarget)[0] = *pdata;
}
}
}
void SIMULAPI SIMUL_LoadWord(simulProcessor processor, void * psource, int width, simulWord * pdata)
{
if (((simulProcInfo *) processor)->endianess) {
switch (width>>3) {
#if SIMUL_ARCHITECTURE_WIDTH == 8
case 8:
{
simulWord low, high;
low = (((unsigned char *) psource)[7]) | (((unsigned char *) psource)[6] << 8)
| (((unsigned char *) psource)[5] << 16) | (((unsigned char *) psource)[4] << 24);
high = (((unsigned char *) psource)[3]) | (((unsigned char *) psource)[2] << 8)
| (((unsigned char *) psource)[1] << 16) | (((unsigned char *) psource)[0] << 24);
*pdata = low | (high << 32);
}
break;
#endif
case 4:
*pdata = (((unsigned char *) psource)[3]) | (((unsigned char *) psource)[2] << 8)
| (((unsigned char *) psource)[1] << 16) | (((unsigned char *) psource)[0] << 24);
break;
case 2:
*pdata = (((unsigned char *) psource)[1]) | (((unsigned char *) psource)[0] << 8);
break;
default:
*pdata = ((unsigned char *) psource)[0];
}
} else {
switch (width>>3) {
#if SIMUL_ARCHITECTURE_WIDTH == 8
case 8:
{
simulWord low, high;
low = (((unsigned char *) psource)[0]) | (((unsigned char *) psource)[1] << 8)
| (((unsigned char *) psource)[2] << 16) | (((unsigned char *) psource)[3] << 24);
high = (((unsigned char *) psource)[4]) | (((unsigned char *) psource)[5] << 8)
| (((unsigned char *) psource)[6] << 16) | (((unsigned char *) psource)[7] << 24);
*pdata = low | (high << 32);
}
break;
#endif
case 4:
*pdata = (((unsigned char *) psource)[0]) | (((unsigned char *) psource)[1] << 8)
| (((unsigned char *) psource)[2] << 16) | (((unsigned char *) psource)[3] << 24);
break;
case 2:
*pdata = (((unsigned char *) psource)[0]) | (((unsigned char *) psource)[1] << 8);
break;
default:
*pdata = ((unsigned char *) psource)[0];
}
}
}
/**************************************************************************
Ports
**************************************************************************/
int SIMULAPI SIMUL_GetPort(simulProcessor processor, int offset, int width, simulWord * pdata)
{
#if SIMUL_ARCHITECTURE_WIDTH == 8
return (*((simulProcInfo *) processor)->getPort64) (processor, offset, width, pdata);
#else
return (*((simulProcInfo *) processor)->getPort32) (processor, offset, width, pdata);
#endif
}
int SIMULAPI SIMUL_SetPort(simulProcessor processor, int offset, int width, simulWord * pdata)
{
#if SIMUL_ARCHITECTURE_WIDTH == 8
return (*((simulProcInfo *) processor)->setPort64) (processor, offset, width, pdata);
#else
return (*((simulProcInfo *) processor)->setPort32) (processor, offset, width, pdata);
#endif
}
void * SIMULAPI SIMUL_RegisterPortChangeCallback(simulProcessor processor, simulCallbackFunctionPtr func, simulPtr private, int offset, int width)
{
return (*((simulProcInfo *) processor)->registerPortChangeCallback)(processor, func, private, offset, width, SIMUL_ARCHITECTURE_WIDTH);
}
/**************************************************************************
Shared Resources
**************************************************************************/
int SIMULAPI SIMUL_CreateSharedResource(simulProcessor processor, int size)
{
return (*((simulProcInfo *) processor)->createSharedResource) (processor, size);
}
int SIMULAPI SIMUL_ReadSharedResource(simulProcessor processor, int offset, int len, void * pdata)
{
return (*((simulProcInfo *) processor)->readSharedResource) (processor, offset, len, pdata);
}
int SIMULAPI SIMUL_WriteSharedResource(simulProcessor processor, int offset, int len, void * pdata)
{
return (*((simulProcInfo *) processor)->writeSharedResource) (processor, offset, len, pdata);
}
/**************************************************************************
File I/O
**************************************************************************/
void * SIMULAPI SIMUL_OpenFile(simulProcessor processor, const char * filename, int mode)
{
return (*((simulProcInfo *) processor)->openFile) (processor, filename, mode);
}
void SIMULAPI SIMUL_CloseFile(simulProcessor processor, void * file)
{
(*((simulProcInfo *) processor)->closeFile) (processor, file);
}
int SIMULAPI SIMUL_ReadFile(simulProcessor processor, void * file, void * pdata, int length)
{
return (*((simulProcInfo *) processor)->readFile) (processor, file, pdata, length);
}
int SIMULAPI SIMUL_WriteFile(simulProcessor processor, void * file, void * pdata, int length)
{
return (*((simulProcInfo *) processor)->writeFile) (processor, file, pdata, length);
}
int SIMULAPI SIMUL_ReadlineFile(simulProcessor processor, void * file, void * pdata, int length)
{
return (*((simulProcInfo *) processor)->readlineFile) (processor, file, pdata, length);
}
int SIMULAPI SIMUL_WritelineFile(simulProcessor processor, void * file, void * pdata)
{
return (*((simulProcInfo *) processor)->writelineFile) (processor, file, pdata);
}
long SIMULAPI SIMUL_SeekFile(simulProcessor processor, void * file, long pos, int mode)
{
return (*((simulProcInfo *) processor)->seekFile) (processor, file, pos, mode);
}
/**************************************************************************
Terminal I/O
**************************************************************************/
int SIMULAPI SIMUL_StateTerminal(simulProcessor processor, int id)
{
return (*((simulProcInfo *) processor)->stateTerminal) (processor, id);
}
int SIMULAPI SIMUL_ReadTerminal(simulProcessor processor, int id)
{
return (*((simulProcInfo *) processor)->readTerminal) (processor, id);
}
int SIMULAPI SIMUL_WriteTerminal(simulProcessor processor, int id, int ch)
{
return (*((simulProcInfo *) processor)->writeTerminal) (processor, id, ch);
}
void * SIMUL_RegisterTerminalCallback(simulProcessor processor, simulCallbackFunctionPtr func, simulPtr private, int id)
{
return (*((simulProcInfo *) processor)->registerTerminalCallback) (processor, func, private, id, SIMUL_ARCHITECTURE_WIDTH);
}