int main(){
REV(5170984);
REV(406567);
REV(368750);
REV(2369510);
REV(2183293);
return 0;
}
int CBitmap::Save(LPCSTR pszFileName) {
int width = m_image.width;
int height = m_image.height;
int bytesPerPixel = m_bmpInfoHeader.biBitCount / 8;
int bytesPerLine = ( (width + (m_bmpInfoHeader.biBitCount % 32 != 0) ) * bytesPerPixel >> 2) << 2;
int writeSize = bytesPerLine * height;
BitmapFileHeader header = {};
header.bfType = 0x4D42;
header.bfSize = sizeof(BitmapFileHeader) + m_bmpInfoHeader.biSize + writeSize;
header.bfOffBits = sizeof(BitmapFileHeader) + m_bmpInfoHeader.biSize;
//m_bmpInfoHeader.biBitCount = 24;
m_bmpInfoHeader.biClrUsed = 0;
m_bmpInfoHeader.biClrImportant = 0;
m_bmpInfoHeader.biSizeImage = bytesPerLine*height;
FILE *fp = fopen(pszFileName, "wb");
if(!fp) return -1;
fwrite(&header, sizeof(header), 1, fp);
fwrite(&m_bmpInfoHeader, m_bmpInfoHeader.biSize, 1, fp);
u32 *pBuf = (u32 *)&m_image.buf[0];
std::vector<BYTE> imgData(writeSize + 4);
printf("SaveSize:%d, %d\n", width, height);
switch(m_bmpInfoHeader.biBitCount) {
case 24: {
if(m_bmpInfoHeader.biHeight < 0) // Top to bottom
REP(y, height) REP(x, width)
*(u32 *)&imgData[bytesPerLine*y + 3*x] = pBuf[width*y+x];
else // Bottom to top
REV(y, height) REP(x, width)
*(u32 *)&imgData[bytesPerLine*y + 3*x] = pBuf[width*y+x];
} break;
case 32: {
if(m_bmpInfoHeader.biHeight < 0) // Top to bottom
REP(y, height) REP(x, width)
*(u32 *)&imgData[(width*y+x)*4] = pBuf[y * width + x];
else // Bottom to top
REV(y, height) REP(x, width)
*(u32 *)&imgData[(width*y+x)*4] = pBuf[y * width + x];
} break;
}
fwrite(&imgData[0], writeSize, 1, fp);
fclose(fp);
printf("Saved!\n", width, height);
return 0;
}
void JitArm::UnsafeStoreFromReg(ARMReg dest, ARMReg value, int accessSize, s32 offset)
{
// All this gets replaced on backpatch
Operand2 mask(2, 1); // ~(Memory::MEMVIEW32_MASK)
BIC(dest, dest, mask); // 1
MOVI2R(R14, (u32)Memory::base, false); // 2-3
ADD(dest, dest, R14); // 4
switch (accessSize)
{
case 32:
REV(value, value); // 5
break;
case 16:
REV16(value, value);
break;
case 8:
NOP(1);
break;
}
switch (accessSize)
{
case 32:
STR(value, dest); // 6
break;
case 16:
STRH(value, dest);
break;
case 8:
STRB(value, dest);
break;
}
NOP(1); // 7
}
/**
* @fn spi_flash_enable
* @brief Enable spi flash operations
*/
sint8 spi_flash_enable(uint8 enable)
{
sint8 s8Ret = M2M_SUCCESS;
if(REV(nmi_get_chipid()) >= REV_3A0) {
uint32 u32Val;
/* Enable pinmux to SPI flash. */
s8Ret = nm_read_reg_with_ret(0x1410, &u32Val);
if(s8Ret != M2M_SUCCESS) {
goto ERR1;
}
/* GPIO15/16/17/18 */
u32Val &= ~((0x7777ul) << 12);
u32Val |= ((0x1111ul) << 12);
nm_write_reg(0x1410, u32Val);
if(enable) {
spi_flash_leave_low_power_mode();
} else {
spi_flash_enter_low_power_mode();
}
/* Disable pinmux to SPI flash to minimize leakage. */
u32Val &= ~((0x7777ul) << 12);
u32Val |= ((0x0010ul) << 12);
nm_write_reg(0x1410, u32Val);
}
ERR1:
return s8Ret;
}
static void add_hash(struct EngineThread *eng, const void *hash)
{
SHA1_CTX *ctx = eng->priv;
const uint32_t *h = hash;
ssresult_add32(ctx->sres, REV(ntohl(h[4])));
result160_add(ctx->res, hash);
}
void JitArm::stmw(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(bJITLoadStoreOff);
FALLBACK_IF(!Core::g_CoreStartupParameter.bFastmem);
u32 a = inst.RA;
ARMReg rA = gpr.GetReg();
ARMReg rB = gpr.GetReg();
ARMReg rC = gpr.GetReg();
MOVI2R(rA, inst.SIMM_16);
if (a)
ADD(rA, rA, gpr.R(a));
Operand2 mask(2, 1); // ~(Memory::MEMVIEW32_MASK)
BIC(rA, rA, mask); // 3
MOVI2R(rB, (u32)Memory::base, false); // 4-5
ADD(rA, rA, rB); // 6
for (int i = inst.RD; i < 32; i++)
{
ARMReg RX = gpr.R(i);
REV(rC, RX);
STR(rC, rA, (i - inst.RD) * 4);
}
gpr.Unlock(rA, rB, rC);
}
void next0() {
uint64_t s0 = s[ p ];
uint64_t s1 = s[ p = ( p + 1 ) & 63 ];
s1 ^= s1 << A;
s1 ^= s1 >> B;
s0 ^= s0 >> C;
y = REV( ( s[ p ] = s0 ^ s1 ) * M );
}
sint8 wait_for_bootrom(uint8 arg)
{
sint8 ret = M2M_SUCCESS;
uint32 reg = 0, cnt = 0;
reg = 0;
while(1) {
reg = nm_read_reg(0x1014); /* wait for efuse loading done */
if (reg & 0x80000000) {
break;
}
nm_bsp_sleep(1); /* TODO: Why bus error if this delay is not here. */
}
reg = nm_read_reg(M2M_WAIT_FOR_HOST_REG);
reg &= 0x1;
/* check if waiting for the host will be skipped or not */
if(reg == 0)
{
reg = 0;
while(reg != M2M_FINISH_BOOT_ROM)
{
nm_bsp_sleep(1);
reg = nm_read_reg(BOOTROM_REG);
if(++cnt > TIMEOUT)
{
M2M_DBG("failed to load firmware from flash.\n");
ret = M2M_ERR_INIT;
goto ERR2;
}
}
}
if(2 == arg) {
nm_write_reg(NMI_REV_REG, M2M_ATE_FW_START_VALUE);
} else {
/*bypass this step*/
}
if(REV(nmi_get_chipid()) == REV_3A0)
{
chip_apply_conf(rHAVE_USE_PMU_BIT);
}
else
{
chip_apply_conf(0);
}
nm_write_reg(BOOTROM_REG,M2M_START_FIRMWARE);
#ifdef __ROM_TEST__
rom_test();
#endif /* __ROM_TEST__ */
ERR2:
return ret;
}
int CBitmap::SetClipboard() {
HANDLE hGMem = GlobalAlloc(GHND, m_bmpInfoHeader.biSize + m_image.buf.size());
BITMAPINFOHEADER *pBih = (BITMAPINFOHEADER *)GlobalLock(hGMem);
*pBih = *(BITMAPINFOHEADER *)&m_bmpInfoHeader;
//pBih->biBitCount = 32;
//pBih->biCompression = BI_RGB;
int width = m_image.width;
int height = m_image.height;
int bytesPerPixel = m_bmpInfoHeader.biBitCount / 8;
int bytesPerLine = ( (width + (m_bmpInfoHeader.biBitCount % 32 != 0) ) * bytesPerPixel >> 2) << 2;
// int writeSize = bytesPerLine * height;
printf("Setting... w=%d, h=%d", width, height);
int offset = pBih->biSize + pBih->biClrUsed * (pBih->biBitCount > 24 ? sizeof(RGBQuad) : sizeof(RGBTriple));
u8 *imgData = (u8 *)pBih + offset;
u32 *pBuf = (u32 *)&m_image.buf[0];
switch(m_bmpInfoHeader.biBitCount) {
case 24: {
if(m_bmpInfoHeader.biHeight < 0) // Top to bottom
REP(y, height) REP(x, width) *(RGBTriple *)&imgData[bytesPerLine*y + 3*x] = *(RGBTriple *)&pBuf[width*y+x];
else // Bottom to top
REV(y, height) REP(x, width) *(RGBTriple *)&imgData[bytesPerLine*y + 3*x] = *(RGBTriple *)&pBuf[width*y+x];
} break;
case 32: {
if(m_bmpInfoHeader.biHeight < 0) // Top to bottom
REP(y, height) REP(x, width) *(u32 *)&imgData[(width*y+x)*4] = pBuf[width*y+x];
else // Bottom to top
REV(y, height) REP(x, width) *(u32 *)&imgData[(width*y+x)*4] = pBuf[width*y+x];
} break;
}
GlobalUnlock(hGMem);
if( !OpenClipboard(NULL) ) return -1;
EmptyClipboard();
SetClipboardData(CF_DIB, hGMem);
CloseClipboard();
puts("OK");
return 0;
}
void restore_pmu_settings_after_global_reset(void)
{
/*
* Must restore PMU register value after
* global reset if PMU toggle is done at
* least once since the last hard reset.
*/
if(REV(nmi_get_chipid()) >= REV_2B0) {
nm_write_reg(0x1e48, 0xb78469ce);
}
}
void JitArm::SafeLoadToReg(bool fastmem, u32 dest, s32 addr, s32 offsetReg, int accessSize, s32 offset, bool signExtend, bool reverse)
{
ARMReg RD = gpr.R(dest);
if (Core::g_CoreStartupParameter.bFastmem && fastmem)
{
if (addr != -1)
MOV(R10, gpr.R(addr));
else
MOV(R10, 0);
UnsafeLoadToReg(RD, R10, accessSize, offset);
return;
}
ARMReg rA = gpr.GetReg();
ARMReg rB = gpr.GetReg();
if (offsetReg == -1)
MOVI2R(rA, offset);
else
MOV(rA, gpr.R(offsetReg));
if (addr != -1)
ADD(rA, rA, gpr.R(addr));
switch (accessSize)
{
case 8:
MOVI2R(rB, (u32)&Memory::Read_U8);
break;
case 16:
MOVI2R(rB, (u32)&Memory::Read_U16);
break;
case 32:
MOVI2R(rB, (u32)&Memory::Read_U32);
break;
}
PUSH(4, R0, R1, R2, R3);
MOV(R0, rA);
BL(rB);
MOV(rA, R0);
POP(4, R0, R1, R2, R3);
MOV(RD, rA);
if (signExtend) // Only on 16 loads
SXTH(RD, RD);
if (reverse)
{
if (accessSize == 32)
REV(RD, RD);
else if (accessSize == 16)
REV16(RD, RD);
}
gpr.Unlock(rA, rB);
}
void JitArm::UnsafeLoadToReg(ARMReg dest, ARMReg addr, int accessSize, s32 offsetReg, s32 offset)
{
ARMReg rA = gpr.GetReg();
if (offsetReg == -1)
{
MOVI2R(rA, offset, false); // -3
ADD(addr, addr, rA); // - 1
}
else
{
NOP(2); // -3, -2
// offsetReg is preloaded here
ADD(addr, addr, gpr.R(offsetReg)); // -1
}
// All this gets replaced on backpatch
Operand2 mask(2, 1); // ~(Memory::MEMVIEW32_MASK)
BIC(addr, addr, mask); // 1
MOVI2R(rA, (u32)Memory::base, false); // 2-3
ADD(addr, addr, rA); // 4
switch (accessSize)
{
case 32:
LDR(dest, addr); // 5
break;
case 16:
LDRH(dest, addr);
break;
case 8:
LDRB(dest, addr);
break;
}
switch (accessSize)
{
case 32:
REV(dest, dest); // 6
break;
case 16:
REV16(dest, dest);
break;
case 8:
NOP(1);
break;
}
NOP(2); // 7-8
gpr.Unlock(rA);
}
int main(void)
{
static uint32_t testcase[] =
{
0x12345678, 0x0000FFFF, 0x00FF00FF
} ;
InitializeHardware(HEADER, PROJECT_NAME) ;
for (;;)
{
int k ;
for (k = 0; k < ENTRIES(testcase); k++)
{
uint32_t word = testcase[k] ;
uint32_t result, answer = REV(word) ;
uint32_t before, after, cycles ;
before = GetClockCycleCount() ;
result = ReverseByteOrder(word) ;
after = GetClockCycleCount() ;
cycles = after - before ;
printf(" Test Case %d: %08X (hex)\n", k+1, (unsigned) word) ;
printf("Correct Result: %08X\n", (unsigned) answer) ;
printf(" Your Result: %08X", (unsigned) result) ;
if (result != answer) printf(" %s", ERROR_FLAG) ;
printf("\n") ;
printf(" Clock Cycles: %lu\n\n", cycles) ;
WaitForPushButton() ;
}
printf("Press button to start over.\n") ;
WaitForPushButton() ;
ClearDisplay() ;
}
}
const int64_t M = 8372773778140471301LL;
#endif
static int p;
void next0() {
uint64_t s0 = s[ p ];
uint64_t s1 = s[ p = ( p + 1 ) & 63 ];
s1 ^= s1 << A;
s1 ^= s1 >> B;
s0 ^= s0 >> C;
y = REV( ( s[ p ] = s0 ^ s1 ) * M );
}
static uint64_t x; // Just to compile
void next1() { x ^= x >> A; x ^= x << B; x ^= x >> C; y = REV( x * M ); } // X3
void next2() { x ^= x << C; x ^= x >> B; x ^= x << A; y = REV( x * M ); } // X2
void next3() { x ^= x >> C; x ^= x << B; x ^= x >> A; y = REV( x * M ); } // X4
void next4() { x ^= x << A; x ^= x << C; x ^= x >> B; y = REV( x * M ); } // X5
void next5() { x ^= x >> A; x ^= x >> C; x ^= x << B; y = REV( x * M ); } // X6
void next6() { x ^= x >> B; x ^= x << A; x ^= x << C; y = REV( x * M ); } // X7
void next7() { x ^= x << B; x ^= x >> A; x ^= x >> C; y = REV( x * M ); } // X8
/* True if the lower part of y has already been returned. */
static int lower;
static void (*next)();
/* Note that this function returns a 32-bit number. */
unsigned long xorshift( void *unused0, void *unused1 ) {
if ( lower ^= 1 ) return (uint32_t)y;
const uint32_t result = y >> 32;
int CBitmap::LoadFromBuf(u8 *pImg, BitmapInfoHeader *pBih) {
//m_bmpInfoHeader = *(BITMAPINFOHEADER *)pBih;
m_bmpInfoHeader = *pBih;
int width = pBih->biWidth;
int height = (pBih->biHeight < 0) ? -pBih->biHeight : pBih->biHeight;
m_image.SetSize(width, height);
u32 *pBuf = (u32 *)&m_image.buf[0];
int bytesPerPixel = pBih->biBitCount / 8;
int bytesPerLine = ( (width + (m_bmpInfoHeader.biBitCount % 32 != 0) ) * bytesPerPixel >> 2) << 2; // ceil(.../4)*4, this value must be divisible by 4!
printf("(size, w, h, p, bc, cp, si, x, y, cu, ci)=(%x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x)\n", pBih->biSize,
pBih->biWidth, pBih->biHeight, pBih->biPlanes, pBih->biBitCount, pBih->biCompression, pBih->biSizeImage, pBih->biXPelsPerMeter, pBih->biYPelsPerMeter, pBih->biClrUsed, pBih->biClrImportant);
switch(pBih->biBitCount) {
case 1: {
m_palettes.resize(2);
} break;
case 4: {
m_palettes.resize(16);
} break;
case 16:
case 32: {
puts("32bit");
m_bmpInfoHeader.biCompression = BI_RGB;
m_bmpInfoHeader.biSize = 40;
u32 mask = 0xFFFFFFFF;
if(pBih->biCompression == BI_BITFIELDS) {
puts("Masked");
u32 *pMasks = (u32 *)(pBih+1);
mask = pMasks[0] | pMasks[1] | pMasks[2] | pMasks[3];
}
if(pBih->biHeight < 0) // upper to lower
REP(y, height) REV(x, width)
pBuf[width*y+x] = mask & *(u32 *)&pImg[(width*y+x)*4];
else // lower to upper
REV(y, height) REP(x, width)
pBuf[width*y+x] = mask & *(u32 *)&pImg[(width*y+x)*4];
} break;
case 8: {
puts("8bit");
m_bmpInfoHeader.biBitCount = 24;
u32 *pPalettes = (u32 *)( (u8 *)pBih + pBih->biSize );
if(pBih->biHeight < 0) // start writing upper to lower
REP(y, height) REP(x, width) pBuf[width*y+x] = pPalettes[ pImg[bytesPerLine*y + x] ];
else // start writing lower to upper
REV(y, height) REP(x, width) pBuf[width*y+x] = pPalettes[ pImg[bytesPerLine*y + x] ];
} break;
case 24: {
puts("24bit");
if(pBih->biHeight < 0) // upper to lower
REP(y, height) REP(x, width)
pBuf[width*y+x] = 0x00FFFFFF & *(u32 *)&pImg[bytesPerLine*y + 3*x];
else // lower to upper
REV(y, height) REP(x, width)
pBuf[width*y+x] = 0x00FFFFFF & *(u32 *)&pImg[bytesPerLine*y + 3*x];
} break;
}
return 0;
}
/* Crack callback */
static void ocl_lastpass_crack_callback(char *line, int self)
{
int a;
int *found;
int err;
struct hash_list_s *mylist, *addlist;
char plain[MAX];
char hex1[16];
cl_uint16 addline;
cl_uint16 salt;
cl_uint16 singlehash;
unsigned char mhash[64];
size_t gws,gws1;
mylist = hash_list;
while (mylist)
{
if (mylist->salt2[0]==1) {mylist=mylist->next;continue;}
/* setup addline */
addline.s0=addline.s1=addline.s2=addline.s3=addline.s4=addline.s5=addline.s6=addline.s7=addline.sF=0;
addline.sF=strlen(line);
addline.s0=line[0]|(line[1]<<8)|(line[2]<<16)|(line[3]<<24);
addline.s1=line[4]|(line[5]<<8)|(line[6]<<16)|(line[7]<<24);
addline.s2=line[8]|(line[9]<<8)|(line[10]<<16)|(line[11]<<24);
addline.s3=line[12]|(line[13]<<8)|(line[14]<<16)|(line[15]<<24);
memcpy(mhash,mylist->hash,16);
unsigned int A,B,C,D;
memcpy(hex1,mhash,4);
memcpy(&A, hex1, 4);
memcpy(hex1,mhash+4,4);
memcpy(&B, hex1, 4);
memcpy(hex1,mhash+8,4);
memcpy(&C, hex1, 4);
memcpy(hex1,mhash+12,4);
memcpy(&D, hex1, 4);
singlehash.s0=A;
singlehash.s1=B;
singlehash.s2=C;
singlehash.s3=D;
if (attack_over!=0) pthread_exit(NULL);
pthread_mutex_lock(&wthreads[self].tempmutex);
pthread_mutex_unlock(&wthreads[self].tempmutex);
/* setup salt */
char mysalt[512];
char myuser[512];
char *tok;
char *save;
int iterations;
int len;
strcpy(mysalt,mylist->salt);
tok = strtok_r(mysalt,":",&save);
tok = strtok_r(NULL,":",&save);
if (!tok) return;
strcpy(myuser,tok);
tok = strtok_r(NULL,":",&save);
if (!tok) return;
tok = strtok_r(NULL,":",&save);
if (!tok) return;
iterations = atoi(tok);
len = strlen(myuser);
bzero(mhash,64);
strcpy((char*)mhash,myuser);
memcpy(mhash+len,"\x00\x00\x00\x01\x80",5);
unsigned int tmp,tmp1,tmp2;
salt.s0=(mhash[0])|(mhash[1]<<8)|(mhash[2]<<16)|(mhash[3]<<24);
salt.s1=(mhash[4])|(mhash[5]<<8)|(mhash[6]<<16)|(mhash[7]<<24);
salt.s2=(mhash[8])|(mhash[9]<<8)|(mhash[10]<<16)|(mhash[11]<<24);
salt.s3=(mhash[12])|(mhash[13]<<8)|(mhash[14]<<16)|(mhash[15]<<24);
salt.s4=(mhash[16])|(mhash[17]<<8)|(mhash[18]<<16)|(mhash[19]<<24);
salt.s5=(mhash[20])|(mhash[21]<<8)|(mhash[22]<<16)|(mhash[23]<<24);
salt.s6=(mhash[24])|(mhash[25]<<8)|(mhash[26]<<16)|(mhash[27]<<24);
salt.s7=(mhash[28])|(mhash[29]<<8)|(mhash[30]<<16)|(mhash[31]<<24);
salt.s8=(mhash[32])|(mhash[33]<<8)|(mhash[34]<<16)|(mhash[35]<<24);
salt.s9=(mhash[36])|(mhash[37]<<8)|(mhash[38]<<16)|(mhash[39]<<24);
salt.sA=(mhash[40])|(mhash[41]<<8)|(mhash[42]<<16)|(mhash[43]<<24);
salt.sB=(mhash[44])|(mhash[45]<<8)|(mhash[46]<<16)|(mhash[47]<<24);
salt.sC=(mhash[48])|(mhash[49]<<8)|(mhash[50]<<16)|(mhash[51]<<24);
salt.sD=(mhash[52])|(mhash[53]<<8)|(mhash[54]<<16)|(mhash[55]<<24);
REV(salt.s0);
REV(salt.s1);
REV(salt.s2);
REV(salt.s3);
REV(salt.s4);
REV(salt.s5);
REV(salt.s6);
REV(salt.s7);
REV(salt.s8);
REV(salt.s9);
REV(salt.sA);
REV(salt.sB);
REV(salt.sC);
REV(salt.sD);
salt.sF=len+4;
_clSetKernelArg(rule_kernelmod[self], 0, sizeof(cl_mem), (void*) &rule_images2_buf[self]);
_clSetKernelArg(rule_kernelmod[self], 1, sizeof(cl_mem), (void*) &rule_images_buf[self]);
_clSetKernelArg(rule_kernelmod[self], 2, sizeof(cl_mem), (void*) &rule_sizes_buf[self]);
_clSetKernelArg(rule_kernelmod[self], 3, sizeof(cl_uint16), (void*) &addline);
_clSetKernelArg(rule_kernelmod[self], 4, sizeof(cl_uint16), (void*) &salt);
_clSetKernelArg(rule_kernelpre1[self], 0, sizeof(cl_mem), (void*) &rule_images3_buf[self]);
_clSetKernelArg(rule_kernelpre1[self], 1, sizeof(cl_mem), (void*) &rule_images2_buf[self]);
_clSetKernelArg(rule_kernelpre1[self], 2, sizeof(cl_mem), (void*) &rule_sizes_buf[self]);
_clSetKernelArg(rule_kernelpre1[self], 3, sizeof(cl_mem), (void*) &rule_found_ind_buf[self]);
_clSetKernelArg(rule_kernelpre1[self], 4, sizeof(cl_mem), (void*) &rule_found_buf[self]);
_clSetKernelArg(rule_kernelpre1[self], 5, sizeof(cl_uint16), (void*) &singlehash);
_clSetKernelArg(rule_kernelpre1[self], 6, sizeof(cl_uint16), (void*) &salt);
_clSetKernelArg(rule_kernelbl1[self], 0, sizeof(cl_mem), (void*) &rule_images3_buf[self]);
_clSetKernelArg(rule_kernelbl1[self], 1, sizeof(cl_mem), (void*) &rule_images2_buf[self]);
_clSetKernelArg(rule_kernelbl1[self], 2, sizeof(cl_mem), (void*) &rule_sizes_buf[self]);
_clSetKernelArg(rule_kernelbl1[self], 3, sizeof(cl_mem), (void*) &rule_found_ind_buf[self]);
_clSetKernelArg(rule_kernelbl1[self], 4, sizeof(cl_mem), (void*) &rule_found_buf[self]);
_clSetKernelArg(rule_kernelbl1[self], 5, sizeof(cl_uint16), (void*) &singlehash);
_clSetKernelArg(rule_kernelbl1[self], 6, sizeof(cl_uint16), (void*) &salt);
_clSetKernelArg(rule_kernellast[self], 0, sizeof(cl_mem), (void*) &rule_buffer[self]);
_clSetKernelArg(rule_kernellast[self], 1, sizeof(cl_mem), (void*) &rule_images3_buf[self]);
_clSetKernelArg(rule_kernellast[self], 2, sizeof(cl_mem), (void*) &rule_sizes_buf[self]);
_clSetKernelArg(rule_kernellast[self], 3, sizeof(cl_mem), (void*) &rule_found_ind_buf[self]);
_clSetKernelArg(rule_kernellast[self], 4, sizeof(cl_mem), (void*) &rule_found_buf[self]);
_clSetKernelArg(rule_kernellast[self], 5, sizeof(cl_uint16), (void*) &singlehash);
_clSetKernelArg(rule_kernellast[self], 6, sizeof(cl_uint16), (void*) &salt);
gws = (rule_counts[self][0] / wthreads[self].vectorsize);
while ((gws%64)!=0) gws++;
gws1 = gws*wthreads[self].vectorsize;
if (gws1==0) gws1=64;
if (gws==0) gws=64;
_clEnqueueNDRangeKernel(rule_oclqueue[self], rule_kernelmod[self], 1, NULL, &gws1, rule_local_work_size, 0, NULL, NULL);
_clFinish(rule_oclqueue[self]);
_clEnqueueNDRangeKernel(rule_oclqueue[self], rule_kernelpre1[self], 1, NULL, &gws, rule_local_work_size, 0, NULL, NULL);
_clFinish(rule_oclqueue[self]);
for (a=1;a<iterations;a+=100)
{
salt.sA=a;
salt.sB=a+100;
if (salt.sB>iterations) salt.sB=iterations;
_clSetKernelArg(rule_kernelbl1[self], 6, sizeof(cl_uint16), (void*) &salt);
_clEnqueueNDRangeKernel(rule_oclqueue[self], rule_kernelbl1[self], 1, NULL, &gws, rule_local_work_size, 0, NULL, NULL);
_clFinish(rule_oclqueue[self]);
wthreads[self].tries+=(gws1)/(get_hashes_num()*(iterations/100));
}
bzero(mhash,64);
strcpy((char*)mhash,"lastpass rocks\x02\x02");
salt.s0=(mhash[0])|(mhash[1]<<8)|(mhash[2]<<16)|(mhash[3]<<24);
salt.s1=(mhash[4])|(mhash[5]<<8)|(mhash[6]<<16)|(mhash[7]<<24);
salt.s2=(mhash[8])|(mhash[9]<<8)|(mhash[10]<<16)|(mhash[11]<<24);
salt.s3=(mhash[12])|(mhash[13]<<8)|(mhash[14]<<16)|(mhash[15]<<24);
_clSetKernelArg(rule_kernellast[self], 6, sizeof(cl_uint16), (void*) &salt);
_clSetKernelArg(rule_kernellast[self], 6, sizeof(cl_uint16), (void*) &salt);
_clEnqueueNDRangeKernel(rule_oclqueue[self], rule_kernellast[self], 1, NULL, &gws1, rule_local_work_size, 0, NULL, NULL);
found = _clEnqueueMapBuffer(rule_oclqueue[self], rule_found_buf[self], CL_TRUE,CL_MAP_READ, 0, 4, 0, 0, NULL, &err);
if (err!=CL_SUCCESS) continue;
if (*found>0)
{
_clEnqueueReadBuffer(rule_oclqueue[self], rule_found_ind_buf[self], CL_TRUE, 0, ocl_rule_workset[self]*sizeof(cl_uint)*wthreads[self].vectorsize, rule_found_ind[self], 0, NULL, NULL);
for (a=0;a<gws1;a++)
if (rule_found_ind[self][a]==1)
{
_clEnqueueReadBuffer(rule_oclqueue[self], rule_buffer[self], CL_TRUE, a*hash_ret_len1, hash_ret_len1, rule_ptr[self]+a*hash_ret_len1, 0, NULL, NULL);
if (memcmp("lastpass rocks\x02\x02", (char *)rule_ptr[self]+(a)*hash_ret_len1, 16) == 0)
{
int flag = 0;
strcpy(plain,&rule_images[self][0]+(a*MAX));
strcat(plain,line);
pthread_mutex_lock(&crackedmutex);
addlist = cracked_list;
while (addlist)
{
if ((strcmp(addlist->username, mylist->username) == 0) && (memcmp(addlist->hash, mylist->hash, hash_ret_len1) == 0))
flag = 1;
addlist = addlist->next;
}
pthread_mutex_unlock(&crackedmutex);
if (flag == 0)
{
add_cracked_list(mylist->username, mylist->hash, mylist->salt, plain);
mylist->salt2[0]=1;
}
}
}
bzero(rule_found_ind[self],ocl_rule_workset[self]*sizeof(cl_uint));
_clEnqueueWriteBuffer(rule_oclqueue[self], rule_found_ind_buf[self], CL_FALSE, 0, ocl_rule_workset[self]*sizeof(cl_uint), rule_found_ind[self], 0, NULL, NULL);
*found = 0;
_clEnqueueWriteBuffer(rule_oclqueue[self], rule_found_buf[self], CL_FALSE, 0, 4, found, 0, NULL, NULL);
}
_clEnqueueUnmapMemObject(rule_oclqueue[self],rule_found_buf[self],(void *)found,0,NULL,NULL);
mylist = mylist->next;
}
}
/* crc32.c -- compute the CRC-32 of a data stream
* Copyright (C) 1995-2005 Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*
* Thanks to Rodney Brown <*****@*****.**> for his contribution of faster
and then the byte reversal of those as well as the first table */
for (n = 0; n < 256; n++) {
c = crc_table[0][n];
crc_table[4][n] = REV(c);
for (k = 1; k < 4; k++) {
c = crc_table[0][c & 0xff] ^ (c >> 8);
crc_table[k][n] = c;
crc_table[k + 4][n] = REV(c);
}
}
c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8);
} while (--len);
c = ~c;
return (unsigned long)(REV(c));
}
void decodeInstruction(instruction_t instruction, uint32_t *dir_reg, char *dir_flags, uint8_t *SRAM, uint16_t *dec)
{
uint8_t *R_activos=instruction.registers_list;
/* Comparacion de mnemonic y Llamado de las funciones */
if( strcmp(instruction.mnemonic,"ADC") == 0 || strcmp(instruction.mnemonic,"ADCS") == 0){
dir_reg[PC]++;
*dec=16704;
*dec=*dec|instruction.op3_value<<3|instruction.op1_value;
dir_reg[instruction.op1_value]=ADC(dir_reg[instruction.op2_value],dir_reg[instruction.op3_value],dir_flags);
}
if( strcmp(instruction.mnemonic,"ADDS") == 0 || strcmp(instruction.mnemonic,"ADD") == 0){
dir_reg[PC]++;
if(instruction.op2_type=='S'){
*dec=45056;
dir_reg[SP]=ADD(dir_reg[SP],instruction.op3_value,dir_flags);
*dec=*dec|instruction.op3_value;}
else if(instruction.op3_type=='#'){
*dec=7168;
*dec=*dec|instruction.op3_value<<6|instruction.op2_value<<3|instruction.op1_value;
dir_reg[instruction.op1_value]=ADD(dir_reg[instruction.op2_value], instruction.op3_value,dir_flags);
mvprintw(4,20,"%X",*dec);}
else{
*dec=6144;
*dec=*dec|instruction.op3_value<<6|instruction.op2_value<<3|instruction.op1_value;
dir_reg[instruction.op1_value]=ADD(dir_reg[instruction.op2_value],dir_reg[instruction.op3_value],dir_flags);}
}
if( strcmp(instruction.mnemonic,"AND") == 0 || strcmp(instruction.mnemonic,"ANDS") == 0){
dir_reg[PC]++;
*dec=16384;
if(instruction.op3_type=='#'){
dir_reg[instruction.op1_value]=AND(dir_reg[instruction.op2_value],instruction.op3_value,dir_flags);}
else
dir_reg[instruction.op1_value]=AND(dir_reg[instruction.op2_value],dir_reg[instruction.op3_value],dir_flags);
}
if( strcmp(instruction.mnemonic,"ASR") == 0 || strcmp(instruction.mnemonic,"ASRS") == 0){
dir_reg[PC]++;
if(instruction.op3_type=='#'){
*dec=4096;
*dec=*dec|instruction.op3_value<<6|instruction.op2_value<<3|instruction.op1_value;
dir_reg[instruction.op1_value]=ASR(dir_reg[instruction.op2_value],instruction.op3_value,dir_flags);}
else{
*dec=16640;
*dec=*dec|instruction.op3_value<<3|instruction.op1_value;
dir_reg[instruction.op1_value]=ASR(dir_reg[instruction.op2_value],dir_reg[instruction.op3_value],dir_flags);}
}
if( strcmp(instruction.mnemonic,"BICS") == 0 || strcmp(instruction.mnemonic,"BICS") == 0){
dir_reg[PC]++;
if(instruction.op3_type=='#')
dir_reg[instruction.op1_value]=BIC(dir_reg[instruction.op2_value],instruction.op3_value,dir_flags);
else{
*dec=17280;
dir_reg[instruction.op1_value]=BIC(dir_reg[instruction.op2_value],dir_reg[instruction.op3_value],dir_flags);
*dec=*dec|instruction.op3_value<<3|instruction.op1_value;}
}
if( strcmp(instruction.mnemonic,"CMN" ) == 0 || strcmp(instruction.mnemonic,"CMNS") == 0){
dir_reg[PC]++;
CMN(dir_reg[instruction.op1_value], dir_reg[instruction.op2_value],dir_flags);
*dec=17088;
*dec=*dec|instruction.op2_value<<3|instruction.op1_value;
mvprintw(4,20,"%X",*dec);
}
if( strcmp(instruction.mnemonic,"CMP") == 0 || strcmp(instruction.mnemonic,"CMPS") == 0){
dir_reg[PC]++;
CMP(dir_reg[instruction.op1_value],dir_reg[instruction.op2_value],dir_flags);
*dec=17024;
*dec=*dec|instruction.op2_value<<3|instruction.op1_value;
mvprintw(4,20,"%X",*dec);
}
if( strcmp(instruction.mnemonic,"EOR") == 0 || strcmp(instruction.mnemonic,"EORS") == 0){
dir_reg[PC]++;
*dec=16448;
if(instruction.op3_type=='#')
dir_reg[instruction.op1_value]=EOR(dir_reg[instruction.op2_value],instruction.op3_value,dir_flags);
else
dir_reg[instruction.op1_value]=EOR(dir_reg[instruction.op2_value],dir_reg[instruction.op3_value],dir_flags);
}
if( strcmp(instruction.mnemonic,"LSLS") == 0 || strcmp(instruction.mnemonic,"LSL") == 0){
dir_reg[PC]++;
if(instruction.op3_type=='#'){
*dec=0;
dir_reg[instruction.op1_value]=LSL(dir_reg[instruction.op2_value],instruction.op3_value,dir_flags);
*dec=*dec|instruction.op3_value<<6|instruction.op2_value<<3|instruction.op1_value;}
else{
*dec=16512;
dir_reg[instruction.op1_value]=LSL(dir_reg[instruction.op2_value],dir_reg[instruction.op3_value],dir_flags);
*dec=*dec|instruction.op3_value<<3|instruction.op1_value;}
}
if( strcmp(instruction.mnemonic,"LSRS") == 0 || strcmp(instruction.mnemonic,"LSR") == 0){
dir_reg[PC]++;
if(instruction.op3_type=='#'){
*dec=2048;
dir_reg[instruction.op1_value]=LSR(dir_reg[instruction.op2_value],instruction.op3_value,dir_flags);
*dec=*dec|instruction.op3_value<<6|instruction.op2_value<<3|instruction.op1_value;}
else{
*dec=16576;
dir_reg[instruction.op1_value]=LSR(dir_reg[instruction.op2_value],dir_reg[instruction.op3_value],dir_flags);
*dec=*dec|instruction.op3_value<<3|instruction.op1_value;}
}
if( strcmp(instruction.mnemonic,"MOV") == 0 || strcmp(instruction.mnemonic,"MOVS") == 0){
dir_reg[PC]++;
if(instruction.op2_type=='#'){
*dec=8192;
dir_reg[instruction.op1_value]=MOV(instruction.op2_value,dir_flags);
*dec=*dec|instruction.op1_value<<8|instruction.op2_value;}
else{
*dec=0;
dir_reg[instruction.op1_value]=MOV(dir_reg[instruction.op2_value],dir_flags);
*dec=*dec|instruction.op2_value<<3|instruction.op1_value;}
}
if( strcmp(instruction.mnemonic,"MUL") == 0 || strcmp(instruction.mnemonic,"MULS") == 0){
dir_reg[PC]++;
*dec=17216;
if(instruction.op3_type=='#'){
dir_reg[instruction.op1_value]=MUL(dir_reg[instruction.op2_value],instruction.op3_value,dir_flags);}
else{
dir_reg[instruction.op1_value]=MUL(dir_reg[instruction.op2_value],dir_reg[instruction.op3_value],dir_flags);
*dec=*dec|instruction.op2_value<<3|instruction.op1_value;}
}
if( strcmp(instruction.mnemonic,"MVN") == 0 || strcmp(instruction.mnemonic,"MVNS") == 0){
dir_reg[PC]++;
*dec=17344;
dir_reg[instruction.op1_value]=MVN(dir_reg[instruction.op2_value], dir_flags);
*dec=*dec|instruction.op2_value<<3|instruction.op1_value;
}
if( strcmp(instruction.mnemonic,"ORR") == 0 || strcmp(instruction.mnemonic,"ORRS") == 0){
dir_reg[PC]++;
*dec=17152;
if(instruction.op3_type=='#'){
dir_reg[instruction.op1_value]=ORR(dir_reg[instruction.op2_value],instruction.op3_value,dir_flags);}
else{
dir_reg[instruction.op1_value]=ORR(dir_reg[instruction.op2_value],dir_reg[instruction.op3_value],dir_flags);
*dec=*dec|instruction.op3_value<<3|instruction.op1_value;}
}
if( strcmp(instruction.mnemonic,"REV") == 0 || strcmp(instruction.mnemonic,"REVS") == 0){
dir_reg[PC]++;
*dec=47616;
dir_reg[instruction.op1_value]=REV(dir_reg[instruction.op2_value]);
*dec=*dec|instruction.op2_value<<3|instruction.op1_value;
}
if( strcmp(instruction.mnemonic,"REVG") == 0 || strcmp(instruction.mnemonic,"REVGS") == 0){
dir_reg[PC]++;
*dec=47680;
dir_reg[instruction.op1_value]=REVG(dir_reg[instruction.op2_value]);
*dec=*dec|instruction.op2_value<<3|instruction.op1_value;
}
if( strcmp(instruction.mnemonic,"REVSH") == 0 || strcmp(instruction.mnemonic,"REVSHS") == 0){
dir_reg[PC]++;
*dec=47808;
dir_reg[instruction.op1_value]=REVSH(dir_reg[instruction.op2_value]);
*dec=*dec|instruction.op2_value<<3|instruction.op1_value;
}
if( strcmp(instruction.mnemonic,"ROR") == 0 || strcmp(instruction.mnemonic,"RORS") == 0){
dir_reg[PC]++;
*dec=16832;
if(instruction.op3_type=='#'){
dir_reg[instruction.op1_value]=ROR(dir_reg[instruction.op2_value],instruction.op3_value,dir_flags);}
else{
dir_reg[instruction.op1_value]=ROR(dir_reg[instruction.op2_value],dir_reg[instruction.op3_value],dir_flags);
*dec=*dec|instruction.op3_value<<3|instruction.op1_value;}
}
if( strcmp(instruction.mnemonic,"RSB") == 0 || strcmp(instruction.mnemonic,"RSBS") == 0){
dir_reg[PC]++;
*dec=16690;
dir_reg[instruction.op1_value]=RSB(dir_reg[instruction.op2_value], dir_flags);
*dec=*dec|instruction.op2_value<<3|instruction.op1_value;
}
if( strcmp(instruction.mnemonic,"SBC") == 0 || strcmp(instruction.mnemonic,"SBCS") == 0){
dir_reg[PC]++;
*dec=16768;
SBC(dir_reg[instruction.op1_value],dir_reg[instruction.op2_value], dir_flags);
*dec=*dec|instruction.op2_value<<3|instruction.op1_value;
}
if( strcmp(instruction.mnemonic,"SUBS") == 0 || strcmp(instruction.mnemonic,"SUB") == 0){
dir_reg[PC]++;
if(instruction.op2_type=='S'){
*dec=45184;
dir_reg[SP]=SUB(dir_reg[SP],instruction.op3_value,dir_flags);
*dec=*dec|instruction.op3_value;}
else if(instruction.op3_type=='#'){
*dec=7680;
dir_reg[instruction.op1_value]=SUB(dir_reg[instruction.op2_value],instruction.op3_value,dir_flags);
*dec=*dec|instruction.op3_value<<6|instruction.op2_value<<3|instruction.op1_value;}
else{
*dec=6656;
dir_reg[instruction.op1_value]=SUB(dir_reg[instruction.op2_value],dir_reg[instruction.op3_value],dir_flags);
*dec=*dec|instruction.op3_value<<6|instruction.op2_value<<3|instruction.op1_value;}
}
if( strcmp(instruction.mnemonic,"TST") == 0 || strcmp(instruction.mnemonic,"TSTS") == 0){
dir_reg[PC]++;
*dec=16896;
TST(dir_reg[instruction.op1_value], dir_reg[instruction.op2_value], dir_flags);
*dec=*dec|instruction.op2_value<<3|instruction.op1_value;
}
if( strcmp(instruction.mnemonic,"NOP") == 0 ){
NOP(dir_reg);
*dec=48896;
}
if( strcmp(instruction.mnemonic,"B") == 0 ){
*dec=57344;
*dec=*dec|instruction.op1_value;
B(instruction.op1_value, dir_reg);
}
if( strcmp(instruction.mnemonic,"BL") == 0 ){
*dec=0;
BL(instruction.op1_value, dir_reg);
}
if( strcmp(instruction.mnemonic,"BX") == 0 ){
*dec=18176;
BX(dir_reg);
}
if( strcmp(instruction.mnemonic,"BEQ") == 0 ){
*dec=0;
BEQ(instruction.op1_value, dir_reg, dir_flags);
}
if( strcmp(instruction.mnemonic,"BNE") == 0 ){
*dec=0;
BNE(instruction.op1_value, dir_reg, dir_flags);
}
if( strcmp(instruction.mnemonic,"BCS") == 0 ){
*dec=0;
BCS(instruction.op1_value, dir_reg, dir_flags);
}
if( strcmp(instruction.mnemonic,"BCC") == 0 ){
*dec=0;
BCC(instruction.op1_value, dir_reg, dir_flags);
}
if( strcmp(instruction.mnemonic,"BMI") == 0 ){
*dec=0;
BMI(instruction.op1_value, dir_reg, dir_flags);
}
if( strcmp(instruction.mnemonic,"BPL") == 0 ){
*dec=0;
BPL(instruction.op1_value, dir_reg, dir_flags);
}
if( strcmp(instruction.mnemonic,"BVS") == 0 ){
*dec=0;
BVS(instruction.op1_value, dir_reg, dir_flags);
}
if( strcmp(instruction.mnemonic,"BVC") == 0 ){
*dec=0;
BVC(instruction.op1_value, dir_reg, dir_flags);
}
if( strcmp(instruction.mnemonic,"BHI") == 0 ){
*dec=0;
BHI(instruction.op1_value, dir_reg, dir_flags);
}
if( strcmp(instruction.mnemonic,"BLS") == 0 ){
*dec=0;
BLS(instruction.op1_value, dir_reg, dir_flags);
}
if( strcmp(instruction.mnemonic,"BGE") == 0 ){
*dec=0;
BGE(instruction.op1_value, dir_reg, dir_flags);
}
if( strcmp(instruction.mnemonic,"BLT") == 0 ){
*dec=0;
BLT(instruction.op1_value, dir_reg, dir_flags);
}
if( strcmp(instruction.mnemonic,"BGT") == 0 ){
*dec=0;
BGT(instruction.op1_value, dir_reg, dir_flags);
}
if( strcmp(instruction.mnemonic,"BLE") == 0 ){
*dec=0;
BLE(instruction.op1_value, dir_reg, dir_flags);
}
if( strcmp(instruction.mnemonic,"BAL") == 0 ){
*dec=0;
BAL(instruction.op1_value, dir_reg);
}
if(strcmp(instruction.mnemonic,"PUSH")==0){
dir_reg[PC]++;
*dec=46080;
PUSH(SRAM, dir_reg,R_activos);
}
if(strcmp(instruction.mnemonic,"POP")==0){
dir_reg[PC]++;
*dec=48128;
POP(SRAM,dir_reg,R_activos);
}
data=(uint8_t)dir_reg[instruction.op1_value];
if(strcmp(instruction.mnemonic,"LDR")==0){
dir_reg[PC]++;
if(instruction.op2_type=='=' && instruction.op3_type=='N'){
*dec=0;
dir_reg[instruction.op1_value]=instruction.op2_value;}
else if(instruction.op2_type=='S'){
*dec=38912;
dir_reg[instruction.op1_value]=LDR(dir_reg[SP], instruction.op3_value<<2, SRAM);
*dec=*dec|instruction.op3_value|instruction.op1_value<<8;}
else if(instruction.op3_type=='#' || instruction.op3_type=='N'){
*dec=26624;
if((dir_reg[instruction.op2_value]+(instruction.op3_value<<2))>=0x40000000)
IOAccess((uint8_t)(dir_reg[instruction.op2_value]+(instruction.op3_value<<2)), &data,Read);
else
dir_reg[instruction.op1_value]=LDR(dir_reg[instruction.op2_value], instruction.op3_value<<2, SRAM);
*dec=*dec|instruction.op3_value<<6|instruction.op2_value|instruction.op1_value;}
else{
*dec=22528;
if((dir_reg[instruction.op2_value]+dir_reg[instruction.op3_value])>=0x40000000)
IOAccess((uint8_t)(dir_reg[instruction.op2_value]+dir_reg[instruction.op3_value]), &data,Read);
else
dir_reg[instruction.op1_value]=LDR(dir_reg[instruction.op2_value], dir_reg[instruction.op3_value], SRAM);
*dec=*dec|instruction.op3_value<<6|instruction.op2_value<<3|instruction.op1_value;}
}
if(strcmp(instruction.mnemonic,"LDRB")==0){
dir_reg[PC]++;
if(instruction.op3_type=='#' || instruction.op3_type=='N'){
*dec=30720;
if((dir_reg[instruction.op2_value]+instruction.op3_value)>=0x40000000)
IOAccess((uint8_t)(dir_reg[instruction.op2_value]+instruction.op3_value), &data,Read);
else
dir_reg[instruction.op1_value]=LDRB(dir_reg[instruction.op2_value], instruction.op3_value, SRAM);
*dec=*dec|instruction.op3_value<<6|instruction.op2_value<<3|instruction.op1_value;}
else{
*dec=23552;
if((dir_reg[instruction.op2_value]+dir_reg[instruction.op3_value])>=0x40000000)
IOAccess((uint8_t)(dir_reg[instruction.op2_value]+dir_reg[instruction.op3_value]), &data,Read);
else
dir_reg[instruction.op1_value]=LDRB(dir_reg[instruction.op2_value], dir_reg[instruction.op3_value], SRAM);
*dec=*dec|instruction.op3_value<<6|instruction.op2_value<<3|instruction.op1_value;}
}
if(strcmp(instruction.mnemonic,"LDRH")==0){
dir_reg[PC]++;
if(instruction.op3_type=='#' || instruction.op3_type=='N'){
*dec=34816;
if((dir_reg[instruction.op2_value]+(instruction.op3_value<<1))>=0x40000000)
IOAccess((uint8_t)(dir_reg[instruction.op2_value]+(instruction.op3_value<<1)), &data,Read);
else
dir_reg[instruction.op1_value]=LDRH(dir_reg[instruction.op2_value], instruction.op3_value<<1, SRAM);
*dec=*dec|instruction.op3_value<<6|instruction.op2_value<<3|instruction.op1_value;}
else{
*dec=23040;
if((dir_reg[instruction.op2_value]+dir_reg[instruction.op3_value])>=0x40000000)
IOAccess((uint8_t)(dir_reg[instruction.op2_value]+dir_reg[instruction.op3_value]), &data,Read);
else
dir_reg[instruction.op1_value]=LDRH(dir_reg[instruction.op2_value], dir_reg[instruction.op3_value], SRAM);
*dec=*dec|instruction.op3_value<<6|instruction.op2_value<<3|instruction.op1_value;}
}
if(strcmp(instruction.mnemonic,"LDRSB")==0){
dir_reg[PC]++;
*dec=22016;
*dec=*dec|instruction.op3_value<<6|instruction.op2_value<<3|instruction.op1_value;
if((dir_reg[instruction.op2_value]+dir_reg[instruction.op3_value])>=0x40000000)
IOAccess((uint8_t)(dir_reg[instruction.op2_value]+dir_reg[instruction.op3_value]), &data,Read);
else
dir_reg[instruction.op1_value]=LDRSB(dir_reg[instruction.op2_value], dir_reg[instruction.op3_value], SRAM);
}
if(strcmp(instruction.mnemonic,"LDRSH")==0){
dir_reg[PC]++;
*dec=24064;
*dec=*dec|instruction.op3_value<<6|instruction.op2_value<<3|instruction.op1_value;
if((dir_reg[instruction.op2_value]+dir_reg[instruction.op3_value])>=0x40000000)
IOAccess((uint8_t)(dir_reg[instruction.op2_value]+dir_reg[instruction.op3_value]), &data,Read);
else
dir_reg[instruction.op1_value]=LDRSH(dir_reg[instruction.op2_value], dir_reg[instruction.op3_value], SRAM);
}
if(strcmp(instruction.mnemonic,"STR")==0){
dir_reg[PC]++;
if(instruction.op2_type=='S'){
*dec=38912;
STR(dir_reg[instruction.op1_value],dir_reg[SP], instruction.op3_value<<2, SRAM);
*dec=*dec|instruction.op3_value|instruction.op1_value<<8;}
else if(instruction.op3_type=='#' || instruction.op3_type=='N'){
*dec=24576;
if((dir_reg[instruction.op2_value]+(instruction.op3_value<<2))>=0x40000000){
IOAccess((uint8_t)(dir_reg[instruction.op2_value]+(instruction.op3_value<<2)), &data,Write);}
else{
STR(dir_reg[instruction.op1_value], dir_reg[instruction.op2_value], instruction.op3_value<<2, SRAM);}
*dec=*dec|instruction.op3_value<<6|instruction.op2_value<<3|instruction.op1_value;
mvprintw(1,3,"Hola");}
else{
*dec=20480;
if((dir_reg[instruction.op2_value]+dir_reg[instruction.op2_value])>=0x40000000)
IOAccess((uint8_t)(dir_reg[instruction.op2_value]+(dir_reg[instruction.op3_value])), &data,Write);
else{
STR(dir_reg[instruction.op1_value], instruction.op2_value, instruction.op3_value, SRAM);}
*dec=*dec|instruction.op3_value<<6|instruction.op2_value<<3|instruction.op1_value;}
}
if(strcmp(instruction.mnemonic,"STRB")==0){
dir_reg[PC]++;
if(instruction.op3_type=='#' || instruction.op3_type=='N'){
*dec=28672;
if(dir_reg[instruction.op2_value]+instruction.op3_value>=0x40000000){
IOAccess((uint8_t)(dir_reg[instruction.op2_value]+instruction.op3_value), &data,Write);}
else{
STRB(dir_reg[instruction.op1_value], dir_reg[instruction.op2_value], instruction.op3_value, SRAM);}
*dec=*dec|instruction.op3_value<<6|instruction.op2_value<<3|instruction.op1_value;}
else{
*dec=21504;
if((dir_reg[instruction.op2_value]+dir_reg[instruction.op3_value])>=0x40000000){
IOAccess((uint8_t)(dir_reg[instruction.op2_value]+(dir_reg[instruction.op3_value])), &data,Write);}
else{
STRB(dir_reg[instruction.op1_value], dir_reg[instruction.op2_value], dir_reg[instruction.op3_value], SRAM);}
*dec=*dec|instruction.op3_value<<6|instruction.op2_value<<3|instruction.op1_value;}
}
if(strcmp(instruction.mnemonic,"STRH")==0){
dir_reg[PC]++;
if(instruction.op3_type=='#' || instruction.op3_type=='N'){
*dec=32768;
if(((dir_reg[instruction.op2_value])+(instruction.op3_value<<1))>=0x40000000)
IOAccess((uint8_t)(dir_reg[instruction.op2_value]+(instruction.op3_value<<1)),&data,Write);
else
STRH(dir_reg[instruction.op1_value], dir_reg[instruction.op2_value], instruction.op3_value<<1, SRAM);
*dec=*dec|instruction.op3_value<<6|instruction.op2_value<<3|instruction.op1_value;}
else{
*dec=20992;
if((dir_reg[instruction.op2_value]+dir_reg[instruction.op3_value])>=0x40000000)
IOAccess((uint8_t)(dir_reg[instruction.op2_value]+(dir_reg[instruction.op3_value])), &data,Write);
else
STRH(dir_reg[instruction.op1_value], dir_reg[instruction.op2_value], dir_reg[instruction.op3_value], SRAM);
*dec=*dec|instruction.op3_value<<6|instruction.op2_value<<3|instruction.op1_value;}
}
}
void decodeInstruction(instruction_t instruction,uint32_t *registro,flags_t *bandera, uint8_t *SRAM, uint16_t *codificacion, char **Flash)
{
int i;
*codificacion=0; // valor incial
// comparar el mnemonic con el nombre de cada una de las funciones, y asi ejecutar la adecuada
if( strcmp(instruction.mnemonic,"LDR") ==0)
{
if((instruction.op1_type=='R') && (instruction.op2_type=='R') && (instruction.op3_type=='#'))
{
*codificacion=(13<<11)+(instruction.op3_value<<6)+(instruction.op2_value<<3)+instruction.op1_value;
instruction.op3_value<<=2;
if(((*(registro+instruction.op2_value)+instruction.op3_value)>=0x20000000)&&((*(registro+instruction.op2_value)+instruction.op3_value)<0x40000000))
{
LDR(registro+instruction.op1_value,*(registro+instruction.op2_value),instruction.op3_value,SRAM);
}
if((*(registro+instruction.op2_value)+instruction.op3_value)<0x20000000)
{
}
if((*(registro+instruction.op2_value)+instruction.op3_value)>=0x40000000)
{
//IOAccess((*(registro+instruction.op2_value)+instruction.op3_value)&0xFF,registro+instruction.op1_value,Read);
}
}
if((instruction.op1_type=='R') && (instruction.op2_type=='S') && (instruction.op3_type=='#'))
{
*codificacion=(19<<11)+(instruction.op1_value<<8)+instruction.op3_value;
instruction.op3_value<<=2;
if(((*(registro+13)+instruction.op3_value)>=0x20000000)&&((*(registro+13)+instruction.op3_value)<0x40000000))
{
LDR(registro+instruction.op1_value,*(registro+13),instruction.op3_value,SRAM);
}
if((*(registro+13)+instruction.op3_value)<0x20000000)
{
}
if((*(registro+13)+instruction.op3_value)>=0x40000000)
{
//IOAccess((*(registro+13)+instruction.op3_value)&0xFF,registro+instruction.op1_value,Read);
}
}
if((instruction.op1_type=='R') && (instruction.op2_type=='P') && (instruction.op3_type=='#')) // label
{
*codificacion=(9<<11)+(instruction.op1_value<<8)+instruction.op3_value;
instruction.op3_value<<=2;
if(((*(registro+15)+instruction.op3_value)>=0x20000000)&&((*(registro+15)+instruction.op3_value)<0x40000000))
{
LDR(registro+instruction.op1_value,*(registro+15),instruction.op3_value,SRAM);
}
if((*(registro+15)+instruction.op3_value)<0x20000000)
{
}
if((*(registro+15)+instruction.op3_value)>=0x40000000)
{
//IOAccess((*(registro+15)+instruction.op3_value)&0xFF,registro+instruction.op1_value,Read);
}
}
if((instruction.op1_type=='R') && (instruction.op2_type=='R') && (instruction.op3_type=='R'))
{
*codificacion=(11<<11)+(instruction.op3_value<<6)+(instruction.op2_value<<3)+instruction.op1_value;
if(((*(registro+instruction.op2_value)+*(registro+instruction.op3_value))>=0x20000000)&&((*(registro+instruction.op2_value)+*(registro+instruction.op3_value))<0x40000000))
{
LDR(registro+instruction.op1_value,*(registro+instruction.op2_value),*(registro+instruction.op3_value),SRAM);
}
if((*(registro+instruction.op2_value)+*(registro+instruction.op3_value))<0x20000000)
{
}
if((*(registro+instruction.op2_value)+*(registro+instruction.op3_value))>=0x40000000)
{
//IOAccess((*(registro+instruction.op2_value)+*(registro+instruction.op3_value))&0xFF,registro+instruction.op1_value,Read);
}
}
registro[15]++;
}
if( strcmp(instruction.mnemonic,"LDRB") ==0)
{
if((instruction.op1_type=='R') && (instruction.op2_type=='R') && (instruction.op3_type=='#'))
{
*codificacion=(15<<11)+(instruction.op3_value<<6)+(instruction.op2_value<<3)+instruction.op1_value;
if(((*(registro+instruction.op2_value)+instruction.op3_value)>=0x20000000)&&((*(registro+instruction.op2_value)+instruction.op3_value)<0x40000000))
{
LDRB(registro+instruction.op1_value,*(registro+instruction.op2_value),instruction.op3_value,SRAM);
}
if((*(registro+instruction.op2_value)+instruction.op3_value)<0x20000000)
{
}
if((*(registro+instruction.op2_value)+instruction.op3_value)>=0x40000000)
{
uint8_t data;
IOAccess((*(registro+instruction.op2_value)+instruction.op3_value)&0xFF,&data,Read);
*(registro+instruction.op1_value)= (uint32_t)data;
}
}
if((instruction.op1_type=='R') && (instruction.op2_type=='R') && (instruction.op3_type=='R'))
{
*codificacion=(1<<14)+(7<<10)+(instruction.op3_value<<6)+(instruction.op2_value<<3)+instruction.op1_value;
if(((*(registro+instruction.op2_value)+*(registro+instruction.op3_value))>=0x20000000)&&((*(registro+instruction.op2_value)+*(registro+instruction.op3_value))<0x40000000))
{
LDRB(registro+instruction.op1_value,*(registro+instruction.op2_value),*(registro+instruction.op3_value),SRAM);
}
if((*(registro+instruction.op2_value)+*(registro+instruction.op3_value))<0x20000000)
{
}
if((*(registro+instruction.op2_value)+*(registro+instruction.op3_value))>=0x40000000)
{
uint8_t data;
IOAccess((*(registro+instruction.op2_value)+*(registro+instruction.op3_value))&0xFF,&data,Read);
*(registro+instruction.op1_value)=(uint32_t) data;
}
}
registro[15]++;
}
if( strcmp(instruction.mnemonic,"LDRH") ==0)
{
if((instruction.op1_type=='R') && (instruction.op2_type=='R') && (instruction.op3_type=='#'))
{
*codificacion=(1<<15)+(1<<11)+(instruction.op3_value<<6)+(instruction.op2_value<<3)+instruction.op1_value;
instruction.op3_value<<=1;
if(((*(registro+instruction.op2_value)+instruction.op3_value)>=0x20000000)&&((*(registro+instruction.op2_value)+instruction.op3_value)<0x40000000))
{
LDRH(registro+instruction.op1_value,*(registro+instruction.op2_value),instruction.op3_value,SRAM);
}
if((*(registro+instruction.op2_value)+instruction.op3_value)<0x20000000)
{
}
if((*(registro+instruction.op2_value)+instruction.op3_value)>=0x40000000)
{
//IOAccess((*(registro+instruction.op2_value)+instruction.op3_value)&0xFF,registro+instruction.op1_value,Read);
}
}
if((instruction.op1_type=='R') && (instruction.op2_type=='R') && (instruction.op3_type=='R'))
{
*codificacion=(5<<12)+(5<<9)+(instruction.op3_value<<6)+(instruction.op2_value<<3)+instruction.op1_value;
if(((*(registro+instruction.op2_value)+*(registro+instruction.op3_value))>=0x20000000)&&((*(registro+instruction.op2_value)+*(registro+instruction.op3_value))<0x40000000))
{
LDRH(registro+instruction.op1_value,*(registro+instruction.op2_value),*(registro+instruction.op3_value),SRAM);
}
}
if((*(registro+instruction.op2_value)+*(registro+instruction.op3_value))<0x20000000)
{
}
if((*(registro+instruction.op2_value)+*(registro+instruction.op3_value))>=0x40000000)
{
//IOAccess((*(registro+instruction.op2_value)+*(registro+instruction.op3_value))&0xFF,registro+instruction.op1_value,Read);
}
registro[15]++;
}
if( strcmp(instruction.mnemonic,"LDRSB") ==0)
{
*codificacion=(5<<12)+(3<<9)+(instruction.op3_value<<6)+(instruction.op2_value<<3)+instruction.op1_value;
if(((*(registro+instruction.op2_value)+*(registro+instruction.op3_value))>=0x20000000)&&((*(registro+instruction.op2_value)+*(registro+instruction.op3_value))<0x40000000))
{
LDRSB(registro+instruction.op1_value,*(registro+instruction.op2_value),*(registro+instruction.op3_value),SRAM);
}
if((*(registro+instruction.op2_value)+*(registro+instruction.op3_value))<0x20000000)
{
}
if((*(registro+instruction.op2_value)+*(registro+instruction.op3_value))>=0x40000000)
{
//IOAccess((*(registro+instruction.op2_value)+*(registro+instruction.op3_value))&0xFF,registro+instruction.op1_value,Read);
}
registro[15]++;
}
if( strcmp(instruction.mnemonic,"LDRSH") ==0)
{
*codificacion=(5<<12)+(7<<9)+(instruction.op3_value<<6)+(instruction.op2_value<<3)+instruction.op1_value;
if(((*(registro+instruction.op2_value)+*(registro+instruction.op3_value))>=0x20000000)&&((*(registro+instruction.op2_value)+*(registro+instruction.op3_value))<0x40000000))
{
LDRSH(registro+instruction.op1_value,*(registro+instruction.op2_value),*(registro+instruction.op3_value),SRAM);
}
if((*(registro+instruction.op2_value)+*(registro+instruction.op3_value))<0x20000000)
{
}
if((*(registro+instruction.op2_value)+*(registro+instruction.op3_value))>=0x40000000)
{
//IOAccess((*(registro+instruction.op2_value)+*(registro+instruction.op3_value))&0xFF,registro+instruction.op1_value,Read);
}
registro[15]++;
}
if( strcmp(instruction.mnemonic,"STR") ==0)
{
if((instruction.op1_type=='R') && (instruction.op2_type=='R') && (instruction.op3_type=='#'))
{
*codificacion=(3<<13)+(instruction.op3_value<<6)+(instruction.op2_value<<3)+instruction.op1_value;
instruction.op3_value<<=2;
if(((*(registro+instruction.op2_value)+instruction.op3_value)>=0x20000000)&&((*(registro+instruction.op2_value)+instruction.op3_value)<0x40000000))
{
STR(*(registro+instruction.op1_value),*(registro+instruction.op2_value),instruction.op3_value,SRAM);
}
if((*(registro+instruction.op2_value)+instruction.op3_value)<0x20000000)
{
}
if((*(registro+instruction.op2_value)+instruction.op3_value)>=0x40000000)
{
//IOAccess((*(registro+instruction.op2_value)+instruction.op3_value)&0xFF,registro+instruction.op1_value,Write);
}
}
if((instruction.op1_type=='R') && (instruction.op2_type=='S') && (instruction.op3_type=='#'))
{
*codificacion=(9<<12)+(instruction.op1_value<<8)+instruction.op3_type;
instruction.op3_value<<=2;
if(((*(registro+13)+instruction.op3_value)>=0x20000000)&&((*(registro+13)+instruction.op3_value)<0x40000000))
{
STR(*(registro+instruction.op1_value),*(registro+13),instruction.op3_value,SRAM);
}
if((*(registro+13)+instruction.op3_value)<0x20000000)
{
}
if((*(registro+13)+instruction.op3_value)>=0x40000000)
{
//IOAccess((*(registro+13)+instruction.op3_value)&0xFF,registro+instruction.op1_value,Write);
}
}
if((instruction.op1_type=='R') && (instruction.op2_type=='R') && (instruction.op3_type=='R'))
{
*codificacion=(5<<12)+(instruction.op3_value<<6)+(instruction.op2_value<<3)+instruction.op1_value;
if(((*(registro+instruction.op2_value)+*(registro+instruction.op3_value))>=0x20000000)&&((*(registro+instruction.op2_value)+*(registro+instruction.op3_value))<0x40000000))
{
STR(*(registro+instruction.op1_value),*(registro+instruction.op2_value),*(registro+instruction.op3_value),SRAM);
}
if((*(registro+instruction.op2_value)+*(registro+instruction.op3_value))<0x20000000)
{
}
if((*(registro+instruction.op2_value)+*(registro+instruction.op3_value))>=0x40000000)
{
//IOAccess((*(registro+instruction.op2_value)+*(registro+instruction.op3_value))&0xFF,registro+instruction.op1_value,Write);
}
}
registro[15]++;
}
if( strcmp(instruction.mnemonic,"STRB") ==0)
{
if((instruction.op1_type=='R') && (instruction.op2_type=='R') && (instruction.op3_type=='#'))
{
*codificacion=(7<<12)+(instruction.op3_value<<6)+(instruction.op2_value<<3)+instruction.op1_value;
if(((*(registro+instruction.op2_value)+instruction.op3_value)>=0x20000000)&&((*(registro+instruction.op2_value)+instruction.op3_value)<0x40000000))
{
STRB(*(registro+instruction.op1_value),*(registro+instruction.op2_value),instruction.op3_value,SRAM);
}
if((*(registro+instruction.op2_value)+instruction.op3_value)<0x20000000)
{
}
if((*(registro+instruction.op2_value)+instruction.op3_value)>=0x40000000)
{
uint8_t data;
data=(uint8_t)(*(registro+instruction.op1_value));
IOAccess((*(registro+instruction.op2_value)+instruction.op3_value)&0xFF,&data,Write);
}
}
if((instruction.op1_type=='R') && (instruction.op2_type=='R') && (instruction.op3_type=='R'))
{
*codificacion=(21<<10)+(instruction.op3_value<<6)+(instruction.op2_value<<3)+instruction.op1_value;
if(((*(registro+instruction.op2_value)+*(registro+instruction.op3_value))>=0x20000000)&&((*(registro+instruction.op2_value)+*(registro+instruction.op3_value))<0x40000000))
{
STRB(*(registro+instruction.op1_value),*(registro+instruction.op2_value),*(registro+instruction.op3_value),SRAM);
}
if((*(registro+instruction.op2_value)+*(registro+instruction.op3_value))<0x20000000)
{
}
if((*(registro+instruction.op2_value)+*(registro+instruction.op3_value))>=0x40000000)
{
uint8_t data;
data=(uint8_t)(*(registro+instruction.op1_value));
IOAccess((*(registro+instruction.op2_value)+*(registro+instruction.op3_value))&0xFF,&data,Write);
}
}
registro[15]++;
}
if( strcmp(instruction.mnemonic,"STRH") ==0)
{
if((instruction.op1_type=='R') && (instruction.op2_type=='R') && (instruction.op3_type=='#'))
{
*codificacion=(1<<15)+(instruction.op3_value<<6)+(instruction.op2_value<<3)+instruction.op1_value;
instruction.op3_value<<=1;
if(((*(registro+instruction.op2_value)+instruction.op3_value)>=0x20000000)&&((*(registro+instruction.op2_value)+instruction.op3_value)<0x40000000))
{
STRH(*(registro+instruction.op1_value),*(registro+instruction.op2_value),instruction.op3_value,SRAM);
}
if((*(registro+instruction.op2_value)+instruction.op3_value)<0x20000000)
{
}
if((*(registro+instruction.op2_value)+instruction.op3_value)>=0x40000000)
{
//IOAccess((*(registro+instruction.op2_value)+instruction.op3_value)&0xFF,registro+instruction.op1_value,Write);
}
}
if((instruction.op1_type=='R') && (instruction.op2_type=='R') && (instruction.op3_type=='R'))
{
*codificacion=(5<<12)+(1<<9)+(instruction.op3_value<<6)+(instruction.op2_value<<3)+instruction.op1_value;
if(((*(registro+instruction.op2_value)+*(registro+instruction.op3_value))>=0x20000000)&&((*(registro+instruction.op2_value)+*(registro+instruction.op3_value))<0x40000000))
{
STRH(*(registro+instruction.op1_value),*(registro+instruction.op2_value),*(registro+instruction.op3_value),SRAM);
}
if((*(registro+instruction.op2_value)+*(registro+instruction.op3_value))<0x20000000)
{
}
if((*(registro+instruction.op2_value)+*(registro+instruction.op3_value))>=0x40000000)
{
//IOAccess((*(registro+instruction.op2_value)+*(registro+instruction.op3_value))&0xFF,registro+instruction.op1_value,Write);
}
}
registro[15]++;
}
if( strcmp(instruction.mnemonic,"PUSH") ==0)
{
for(i=0;i<8;i++)
{
*codificacion+=(instruction.registers_list[i]<<i);
}
*codificacion+=(11<<12)+(1<<10)+(instruction.registers_list[14]<<8);
PUSH(registro,SRAM,&instruction.registers_list[0]);
registro[15]++;
}
if( strcmp(instruction.mnemonic,"POP") ==0)
{
for(i=0;i<8;i++)
{
*codificacion+=(instruction.registers_list[i]<<i);
}
*codificacion=(11<<12)+(3<<10)+(instruction.registers_list[15]<<8);
POP(registro,SRAM,&instruction.registers_list[0]);
registro[15]++;
}
if( strcmp(instruction.mnemonic,"ADCS") ==0)
{
*codificacion=(1<<14)+(5<<6)+(instruction.op2_value<<3)+instruction.op1_value;
ADCS(registro+instruction.op1_value,*(registro+instruction.op1_value),*(registro+instruction.op2_value), bandera);
registro[15]++;
}
if( strcmp(instruction.mnemonic,"ADD") ==0)
{
if((instruction.op1_type=='R') && (instruction.op2_type=='R'))
{
ADD(registro+instruction.op1_value,*(registro+instruction.op1_value),*(registro+instruction.op2_value));
*codificacion=(1<<14)+(1<<10)+(instruction.op2_value<<3)+((8&instruction.op1_value)<<4)+(7&instruction.op1_value);
}
if((instruction.op1_type=='R') && (instruction.op2_type=='S') && (instruction.op3_type=='#'))
{
ADD(registro+instruction.op1_value,*(registro+13),instruction.op2_value);
*codificacion=(21<<11)+(instruction.op1_value<<8)+instruction.op3_value;
}
if((instruction.op1_type=='S') && (instruction.op2_type=='S') && (instruction.op3_type=='#'))
{
ADD(registro+13,*(registro+13),instruction.op3_value);
*codificacion=(11<<12)+instruction.op3_value;
}
if((instruction.op1_type=='R') && (instruction.op2_type=='S') && (instruction.op3_type=='R'))
{
ADD(registro+instruction.op1_value,*(registro+13),*(registro+instruction.op3_value));
*codificacion=(1<<14)+(1<<10)+(13<<3)+((8&instruction.op1_value)<<4)+(7&instruction.op1_value);
}
if((instruction.op1_type=='S') && (instruction.op2_type=='R'))
{
ADD(registro+13,*(registro+13),*(registro+instruction.op2_value));
*codificacion=(1<<14)+(9<<7)+5+(instruction.op2_value<<3);
}
registro[15]++;
}
if( strcmp(instruction.mnemonic,"ADDS") ==0)
{
if((instruction.op1_type=='R') && (instruction.op2_type=='R') && (instruction.op3_type=='#'))
{
ADDS(registro+instruction.op1_value,*(registro+instruction.op2_value),instruction.op3_value,bandera);
*codificacion=(7<<10)+(instruction.op3_value<<6)+(instruction.op2_value<<3)+instruction.op1_value;
}
if((instruction.op1_type=='R') && (instruction.op2_type=='#'))
{
ADDS(registro+instruction.op1_value,*(registro+instruction.op1_value),instruction.op2_value,bandera);
*codificacion=(3<<12)+(instruction.op1_value<<8)+instruction.op2_value;
}
if((instruction.op1_type=='R') && (instruction.op2_type=='R') && (instruction.op3_type=='R'))
{
ADDS(registro+instruction.op1_value,*(registro+instruction.op2_value),*(registro+instruction.op3_value), bandera);
*codificacion=(3<<11)+(instruction.op3_value<<6)+(instruction.op2_value<<3)+instruction.op1_value;
}
registro[15]++;
}
// los parametros de las demas funciones aritmeticas, de desplazamiento y logicas son similares
if( strcmp(instruction.mnemonic,"ANDS") ==0)
{
*codificacion=(1<<14)+(instruction.op2_value<<3)+instruction.op1_value;
ANDS(registro+instruction.op1_value,*(registro+instruction.op1_value),*(registro+instruction.op2_value), bandera);
registro[15]++;
}
if( strcmp(instruction.mnemonic,"ASRS") ==0)
{
if((instruction.op1_type=='R') && (instruction.op2_type=='R'))
{
ASRS(registro+instruction.op1_value,*(registro+instruction.op1_value),*(registro+instruction.op2_value), bandera);
*codificacion=(1<<14)+(1<<8)+(instruction.op2_value<<3)+instruction.op1_value;
}
if((instruction.op1_type=='R') && (instruction.op2_type=='R') && (instruction.op3_type=='#'))
{
ASRS(registro+instruction.op1_value,*(registro+instruction.op2_value),instruction.op3_value,bandera);
*codificacion=(1<<12)+(instruction.op3_value<<6)+(instruction.op2_value<<3)+instruction.op1_value;
}
registro[15]++;
}
if( strcmp(instruction.mnemonic,"BICS") ==0)
{
*codificacion=(1<<14)+(14<<6)+(instruction.op2_value<<3)+instruction.op1_value;
BICS(registro+instruction.op1_value,*(registro+instruction.op1_value),*(registro+instruction.op2_value), bandera);
registro[15]++;
}
if( strcmp(instruction.mnemonic,"CMN") ==0)
{
*codificacion=(1<<14)+(11<6)+(instruction.op2_value<<3)+instruction.op1_value;
CMN(*(registro+instruction.op1_value),*(registro+instruction.op2_value), bandera); // En diferencia a las demas funciones, se envian como parametros 2 valores
registro[15]++;
}
if( strcmp(instruction.mnemonic,"CMP") ==0)
{
if((instruction.op1_type=='R') && (instruction.op2_type=='R'))
{
if(instruction.op1_value>=8)
{
CMP(*(registro+instruction.op1_value),*(registro+instruction.op2_value), bandera); // En diferencia a las demas funciones, se envian como parametros 2 valores
*codificacion=(1<<14)+(5<<8)+(instruction.op2_value<<3)+(7&instruction.op1_value)+((8&instruction.op1_value)<<4);
}
else
{
CMP(*(registro+instruction.op1_value),*(registro+instruction.op2_value), bandera); // En diferencia a las demas funciones, se envian como parametros 2 valores
*codificacion=(1<<14)+(10<<6)+(instruction.op2_value<<3)+instruction.op1_value;
}
}
if((instruction.op1_type=='R') && (instruction.op2_type=='#'))
{
CMP(*(registro+instruction.op1_value),instruction.op2_value, bandera); // Como parametros se tienen el contenido de un registro y un valor
*codificacion=(5<<11)+(instruction.op1_value<<8)+instruction.op2_value;
}
registro[15]++;
}
if( strcmp(instruction.mnemonic,"EORS") ==0)
{
*codificacion=(1<<14)+(1<<6)+(instruction.op2_value<<3)+instruction.op1_value;
EORS(registro+instruction.op1_value,*(registro+instruction.op1_value),*(registro+instruction.op2_value),bandera);
registro[15]++;
}
if( strcmp(instruction.mnemonic,"LSLS") ==0)
{
if((instruction.op1_type=='R') && (instruction.op2_type=='R'))
{
LSLS(registro+instruction.op1_value,*(registro+instruction.op1_value),*(registro+instruction.op2_value), bandera);
*codificacion=(1<<14)+(1<<7)+(instruction.op2_value<<3)+instruction.op1_value;
}
if((instruction.op1_type=='R') && (instruction.op2_type=='R') && (instruction.op3_type=='#'))
{
LSLS(registro+instruction.op1_value,*(registro+instruction.op2_value),instruction.op3_value,bandera);
*codificacion=(instruction.op3_value<<6)+(instruction.op2_value<<3)+instruction.op1_value;
}
registro[15]++;
}
if( strcmp(instruction.mnemonic,"LSRS") ==0)
{
if((instruction.op1_type=='R') && (instruction.op2_type=='R'))
{
LSRS(registro+instruction.op1_value,*(registro+instruction.op1_value),*(registro+instruction.op2_value), bandera);
*codificacion=(1<<14)+(3<<6)+(instruction.op2_value<<3)+instruction.op1_value;
}
if((instruction.op1_type=='R') && (instruction.op2_type=='R') && (instruction.op3_type=='#'))
{
LSRS(registro+instruction.op1_value,*(registro+instruction.op2_value),instruction.op3_value,bandera);
*codificacion=(1<<11)+(instruction.op3_value<<6)+(instruction.op2_value<<3)+instruction.op1_value;
}
registro[15]++;
}
if( strcmp(instruction.mnemonic,"MOV") ==0)
{
*codificacion=(1<<14)+(3<<9)+(instruction.op2_value<<3)+(7&instruction.op1_value)+((8&instruction.op1_value)<<4);
MOV(registro+instruction.op1_value,*(registro+instruction.op2_value)); // Envio como parametros una direccion y el contenido de un registro
registro[15]++;
}
if( strcmp(instruction.mnemonic,"MOVS") ==0)
{
if((instruction.op1_type=='R') && (instruction.op2_type=='#'))
{
MOVS(registro+instruction.op1_value,instruction.op2_value, bandera);
*codificacion=(1<<13)+(instruction.op1_value<<8)+instruction.op2_value;
}
if((instruction.op1_type=='R') && (instruction.op2_type=='R'))
{
MOVS(registro+instruction.op1_value,*(registro+instruction.op2_value),bandera);
*codificacion=(instruction.op2_value<<3)+instruction.op1_value;
}
registro[15]++;
}
if( strcmp(instruction.mnemonic,"MULS") ==0)
{
*codificacion=(1<<14)+(13<<6)+(instruction.op2_value<<3)+instruction.op3_value;
MULS(registro+instruction.op1_value,*(registro+instruction.op2_value),*(registro+instruction.op3_value), bandera);
registro[15]++;
}
if( strcmp(instruction.mnemonic,"MVNS") ==0)
{
*codificacion=(1<<14)+(15<<6)+(instruction.op2_value<<3)+instruction.op1_value;
RSBS(registro+instruction.op1_value,*(registro+instruction.op2_value), bandera);
registro[15]++;
}
if( strcmp(instruction.mnemonic,"NOP") ==0)
{
*codificacion=(11<<12)+(15<<8);
registro[15]++;
}
if( strcmp(instruction.mnemonic,"ORRS") ==0)
{
*codificacion=(1<<14)+(3<<8)+(instruction.op2_value<<3)+instruction.op1_value;
ORRS(registro+instruction.op1_value,*(registro+instruction.op1_value),*(registro+instruction.op2_value), bandera);
registro[15]++;
}
if( strcmp(instruction.mnemonic,"REV") ==0)
{
*codificacion=(11<<12)+(5<<9)+(instruction.op2_value<<3)+instruction.op1_value;
REV(registro+instruction.op1_value, *(registro+instruction.op2_value));
registro[15]++;
}
if( strcmp(instruction.mnemonic,"REV16") ==0)
{
*codificacion=(11<<12)+(5<<9)+(1<<6)+(instruction.op2_value<<3)+instruction.op1_value;
REV16(registro+instruction.op1_value,*(registro+instruction.op2_value));
registro[15]++;
}
if( strcmp(instruction.mnemonic,"REVSH") ==0)
{
*codificacion=(11<<12)+(5<<9)+(3<<6)+(instruction.op2_value<<3)+instruction.op1_value;
REVSH(registro+instruction.op1_value,*(registro+instruction.op2_value));
registro[15]++;
}
if( strcmp(instruction.mnemonic,"RORS") ==0)
{
*codificacion=(1<<14)+(7<<6)+(instruction.op2_value<<3)+instruction.op1_value;
RORS(registro+instruction.op1_value,*(registro+instruction.op2_value), bandera);
registro[15]++;
}
if( strcmp(instruction.mnemonic,"RSBS") ==0)
{
*codificacion=(1<<14)+(9<<6)+(instruction.op2_value<<3)+instruction.op1_value;
RSBS(registro+instruction.op1_value,*(registro+instruction.op2_value), bandera);
registro[15]++;
}
if( strcmp(instruction.mnemonic,"SBCS") ==0)
{
*codificacion=(1<<14)+(3<<7)+(instruction.op2_value<<3)+instruction.op1_value;
SBCS(registro+instruction.op1_value,*(registro+instruction.op1_value),*(registro+instruction.op2_value), bandera);
registro[15]++;
}
if( strcmp(instruction.mnemonic,"SUB") ==0)
{
if((instruction.op1_type=='S') && (instruction.op2_type=='S') && (instruction.op3_type=='#'))
{
SUB(registro+13,*(registro+13),instruction.op3_value);
*codificacion=(11<<12)+(1<<7)+instruction.op3_value;
}
registro[15]++;
}
if( strcmp(instruction.mnemonic,"SUBS") ==0)
{
if((instruction.op1_type=='R') && (instruction.op2_type=='R') && (instruction.op3_type=='#'))
{
SUBS(registro+instruction.op1_value,*(registro+instruction.op2_value),instruction.op3_value,bandera);
*codificacion=(15<<9)+(instruction.op3_value<<6)+(instruction.op2_value<<3)+instruction.op1_value;
}
if((instruction.op1_type=='R') && (instruction.op2_type=='#'))
{
SUBS(registro+instruction.op1_value,*(registro+instruction.op1_value),instruction.op2_value,bandera);
*codificacion=(7<<11)+(instruction.op1_value<<8)+instruction.op2_value;
}
if((instruction.op1_type=='R') && (instruction.op2_type=='R') && (instruction.op3_type=='R'))
{
SUBS(registro+instruction.op1_value,*(registro+instruction.op2_value),*(registro+instruction.op3_value), bandera);
*codificacion=(13<<9)+(instruction.op3_value<<6)+(instruction.op2_value<<3)+instruction.op1_value;
}
registro[15]++;
}
if( strcmp(instruction.mnemonic,"TST") ==0)
{
*codificacion=(1<<14)+(1<<9)+(instruction.op2_value<<3)+instruction.op1_value;
TST(*(registro+instruction.op1_value),*(registro+instruction.op2_value), bandera); // Como parametros se tienen el contenido de un registro y un valor
registro[15]++;
}
// Las siguientes funciones, son funciones de saltos
if( strcmp(instruction.mnemonic,"B") ==0)
{
*codificacion=(7<<13)+instruction.op1_value;
B(registro,instruction.op1_value); // Envio como parametroa la direccion de registro y el valor del salto
}
if( strcmp(instruction.mnemonic,"BL") ==0)
{
*codificacion=(31<<11)+(2047&instruction.op1_value);
BL(registro,instruction.op1_value); // Envio como parametroa la direccion de registro y el valor del salto
}
if( strcmp(instruction.mnemonic,"BLX") ==0)
{
*codificacion=(1<<14)+(15<<7)+(instruction.op1_value<<3);
BLX(registro,*(registro+instruction.op1_value)); // Envio como parametroa la direccion de registro y el contenido de un registro
}
if( strcmp(instruction.mnemonic,"BX") ==0)
{
*codificacion=(1<<14)+(14<<7)+(instruction.op1_value<<3);
if(instruction.op1_type=='L') // Sucede cuando
{
BX(registro,registro[14]); // PC=LR
}
if(instruction.op1_type=='R') // Sucede cuando se tiene como parametro un registro diferente a LR
{
BX(registro,*(registro+instruction.op1_value));
}
}
if( strcmp(instruction.mnemonic,"BEQ") ==0)
{
*codificacion=(13<<12)+instruction.op1_value;
BEQ(registro,instruction.op1_value,*bandera); // Envio como parametros la direccion de registro, el valor del salto y las banderas
}
// Todas las siguientes funciones de salto tienen los mismos parametro que BEQ
if( strcmp(instruction.mnemonic,"BNE") ==0)
{
*codificacion=(13<<12)+(1<<8)+instruction.op1_value;
BNE(registro,instruction.op1_value,*bandera);
}
if( strcmp(instruction.mnemonic,"BCS") ==0)
{
*codificacion=(13<<12)+(2<<8)+instruction.op1_value;
BCS(registro,instruction.op1_value,*bandera);
}
if( strcmp(instruction.mnemonic,"BCC") ==0)
{
*codificacion=(13<<12)+(3<<8)+instruction.op1_value;
BCC(registro,instruction.op1_value,*bandera);
}
if( strcmp(instruction.mnemonic,"BMI") ==0)
{
*codificacion=(13<<12)+(4<<8)+instruction.op1_value;
BMI(registro,instruction.op1_value,*bandera);
}
if( strcmp(instruction.mnemonic,"BPL") ==0)
{
*codificacion=(13<<12)+(5<<8)+instruction.op1_value;
BPL(registro,instruction.op1_value,*bandera);
}
if( strcmp(instruction.mnemonic,"BVS") ==0)
{
*codificacion=(13<<12)+(6<<8)+instruction.op1_value;
BVS(registro,instruction.op1_value,*bandera);
}
if( strcmp(instruction.mnemonic,"BVC") ==0)
{
*codificacion=(13<<12)+(7<<8)+instruction.op1_value;
BVC(registro,instruction.op1_value,*bandera);
}
if( strcmp(instruction.mnemonic,"BHI") ==0)
{
*codificacion=(13<<12)+(8<<8)+instruction.op1_value;
BHI(registro,instruction.op1_value,*bandera);
}
if( strcmp(instruction.mnemonic,"BLS") ==0)
{
*codificacion=(13<<12)+(9<<8)+instruction.op1_value;
BLS(registro,instruction.op1_value,*bandera);
}
if( strcmp(instruction.mnemonic,"BGE") ==0)
{
*codificacion=(13<<12)+(10<<8)+instruction.op1_value;
BGE(registro,instruction.op1_value,*bandera);
}
if( strcmp(instruction.mnemonic,"BLT") ==0)
{
*codificacion=(13<<12)+(11<<8)+instruction.op1_value;
BLT(registro,instruction.op1_value,*bandera);
}
if( strcmp(instruction.mnemonic,"BGT") ==0)
{
*codificacion=(13<<12)+(12<<8)+instruction.op1_value;
BGT(registro,instruction.op1_value,*bandera);
}
if( strcmp(instruction.mnemonic,"BLE") ==0)
{
*codificacion=(13<<12)+(13<<8)+instruction.op1_value;
BLE(registro,instruction.op1_value,*bandera);
}
if( strcmp(instruction.mnemonic,"BAL") ==0)
{
*codificacion=(13<<12)+(14<<8)+instruction.op1_value;
BAL(registro,instruction.op1_value,*bandera);
}
}
int main()
{
int op;
uint32_t registro[16]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
char banderas[4];
do{
system("cls");
printf("seleccione la opcion 1 para mostrar los valores de los registros\n");
printf("seleccione la opcion 2 para sumar registros \n");
printf("seleccione la opcion 3 para multiplicacion logica (AND) de registros \n");
printf("seleccione la opcion 4 para Eor a nivel de bits \n");
printf("seleccione la opcion 5 para desplazar de un registro a otro \n");
printf("seleccione la opcion 6 para suma logica (OR) de registro\n");
printf("seleccione la opcion 7 para ADN sin almacenar, solo modifica banderas \n");
printf("seleccione la opcion 8 para comparar (SUB sin almacenar), solo modifica banderas\n");
printf("seleccione la opcion 9 Multiplicacion de registros, solo se alacenan 32 bits menos significativos\n");
printf("seleccione la opcion 10 AND sin almacenacmiento, solo modifica banderas\n");
printf("seleccione la opcion 11 para LSL desplazamiento logico a la izquierda \n");
printf("seleccione la opcion 12 para LSR desplazamiento logico a la derecha \n");
printf("seleccione la opcion 13 para ROR rotacion a la derecha \n");
printf("seleccione la opcion 14 para ASR desplazamiento aritmetico a la derecha \n");
printf("seleccione la opcion 15 para BIC Realiza una AND de un registro con otro negado \n");
printf("seleccione la opcion 16 para MUN guarda en un registro la negacion de otro\n");
printf("seleccione la opcion 17 para RSB niega un valor de registro\n");
printf("seleccione la opcion 18 para NOP da un retardo de un ciclo de reloj (no hace nada) \n");
printf("seleccione la opcion 19 para REV toma grupos de 8 bits y los desplaza \n");
printf("seleccione la opcion 20 para REVIG toma grupos de 16 bits y los agrupa en grupos de dos bytes\n");
printf("seleccione la opcion 21 para REVSH extencion con signo\n\n");
scanf("%d",&op);
system("cls");
switch(op){
case 1:
//mostrar_valores(registro);
break;
case 2:
printf("ingrese el valor del primer registro:\n");
scanf("%d",®istro[1]);
printf("ingrese el valor del segundo registro:\n");
scanf("%d",®istro[2]);
ADD(registro,®istro[0],registro[1],registro[2],&banderas[0]);
printf("%d valor del resultado \n",registro[0]);
printf("%d valor del resultado bandera n \n",banderas[N]);
printf("%d valor del resultado bandera z \n",banderas[Z]);
printf("%d valor del resultado bandera c \n",banderas[C]);
printf("%d valor del resultado bandera v \n",banderas[V]);
break;
case 3:
printf("ingrese el valor del primer registro:\n");
scanf("%d",®istro[1]);
printf("ingrese el valor del segundo registro:\n");
scanf("%d",®istro[2]);
AND(registro,®istro[0],registro[1],registro[2],&banderas[0]);
printf("%d valor del resultado \n",registro[0]);
printf("%d valor del resultado bandera n \n",banderas[N]);
printf("%d valor del resultado bandera z \n",banderas[Z]);
printf("%d valor del resultado bandera c \n",banderas[C]);
printf("%d valor del resultado bandera v \n",banderas[V]);
break;
case 4:
printf("ingrese el valor del primer registro:\n");
scanf("%d",®istro[1]);
printf("ingrese el valor del segundo registro:\n");
scanf("%d",®istro[2]);
EOR(registro,®istro[0],registro[1],registro[2],&banderas[0]);
printf("%d valor del resultado \n",registro[0]);
printf("%d valor del resultado bandera n \n",banderas[N]);
printf("%d valor del resultado bandera z \n",banderas[Z]);
printf("%d valor del resultado bandera c \n",banderas[C]);
printf("%d valor del resultado bandera v \n",banderas[V]);
break;
case 5:
printf("ingrese el valor del registro origen:\n");
scanf("%d",®istro[1]);
MOV(registro,®istro[0],registro[1],banderas);
printf("%d valor del resultado \n",registro[0]);
break;
case 7:
printf("ingrese el valor del primer registro:\n");
scanf("%d",®istro[1]);
printf("ingrese el valor del segundo registro:\n");
scanf("%d",®istro[2]);
CMN(registro,registro[1],registro[2],&banderas[0]);
printf("%d valor del resultado \n",registro[0]);
printf("%d valor del resultado bandera n \n",banderas[N]);
printf("%d valor del resultado bandera z \n",banderas[Z]);
printf("%d valor del resultado bandera c \n",banderas[C]);
printf("%d valor del resultado bandera v \n",banderas[V]);
break;
case 8:
printf("ingrese el valor del primer registro:\n");
scanf("%d",®istro[1]);
printf("ingrese el valor del segundo registro:\n");
scanf("%d",®istro[2]);
CMP(registro,registro[1],registro[2],&banderas[0]);
printf("%d valor del resultado \n",registro[0]);
printf("%d valor del resultado bandera n \n",banderas[N]);
printf("%d valor del resultado bandera z \n",banderas[Z]);
printf("%d valor del resultado bandera c \n",banderas[C]);
printf("%d valor del resultado bandera v \n",banderas[V]);
break;
case 9:
printf("ingrese el valor del primer registro:\n");
scanf("%d",®istro[1]);
printf("ingrese el valor del segundo registro:\n");
scanf("%d",®istro[2]);
MUL(registro,®istro[0],registro[1],registro[2],&banderas[0]);
printf("%d valor del resultado \n",registro[0]);
printf("%d valor del resultado bandera n \n",banderas[N]);
printf("%d valor del resultado bandera z \n",banderas[Z]);
printf("%d valor del resultado bandera c \n",banderas[C]);
printf("%d valor del resultado bandera v \n",banderas[V]);
break;
case 10:
printf("ingrese el valor del primer registro:\n");
scanf("%d",®istro[1]);
printf("ingrese el valor del segundo registro:\n");
scanf("%d",®istro[2]);
TST(registro,registro[1],registro[2],&banderas[0]);
printf("%d valor del resultado \n",registro[0]);
printf("%d valor del resultado bandera n \n",banderas[N]);
printf("%d valor del resultado bandera z \n",banderas[Z]);
printf("%d valor del resultado bandera c \n",banderas[C]);
printf("%d valor del resultado bandera v \n",banderas[V]);
break;
case 11:
printf("ingrese el valor del registro:\n");
scanf("%d",®istro[1]);
printf("ingrese el numero de desplazamientos:\n");
scanf("%d",®istro[2]);
LSL(registro,®istro[0],registro[1],registro[2],banderas);
printf("%d valor del resultado \n",registro[0]);
break;
case 12:
printf("ingrese el valor del primer registro:\n");
scanf("%d",®istro[1]);
printf("ingrese elnumero de desplazamientos:\n");
scanf("%d",®istro[2]);
LSR(registro,®istro[0],registro[1],registro[2],banderas);
printf("%d valor del resultado \n",registro[0]);
break;
case 13:
printf("ingrese el valor del primer registro:\n");
scanf("%d",®istro[1]);
printf("ingrese elnumero de desplazamientos:\n");
scanf("%d",®istro[2]);
ROR(registro,®istro[0],registro[1],registro[2],banderas);
printf("%d valor del resultado \n",registro[0]);
break;
case 14:
printf("ingrese el valor del primer registro:\n");
scanf("%d",®istro[1]);
printf("ingrese elnumero de desplazamientos:\n");
scanf("%d",®istro[2]);
ASR(registro,®istro[0],registro[1],registro[2],banderas);
printf("%d valor del resultado \n",registro[0]);
break;
case 15:
printf("ingrese el valor del primer registro:\n");
scanf("%d",®istro[0]);
printf("ingrese el valor del segundo registro:\n");
scanf("%d",®istro[1]);
BIC(registro,®istro[0],registro[1],banderas);
printf("%d valor del resultado \n",registro[0]);
break;
case 16:
printf("ingrese un valor del registro origen\n");
scanf("%d",®istro[1]);
MVN(registro,®istro[0],registro[1],banderas);
printf("%d valor del resultado \n",registro[0]);
break;
case 17:
printf("ingrese un valor de registro\n");
scanf("%d",®istro[1]);
RSB(registro,®istro[0],registro[1],0,banderas);
printf("%d valor del resultado \n",registro[0]);
break;
case 18:
NOP(registro);
break;
case 19:
printf("ingrese un valor de registro \n");
scanf("%d",®istro[0]);
REV(registro,®istro[0]);
printf("%d valor del resultado \n",registro[0]);
break;
case 20:
printf("ingrese un valor de registro \n");
scanf("%d",®istro[0]);
REVIG(registro,®istro[0]);
printf("%d valor del resultado \n",registro[0]);
break;
case 21:
printf("ingrese un valor de registro \n");
scanf("%d",®istro[0]);
REVSH(registro,®istro[0]);
printf("%d valor del resultado \n",registro[0]);
break;
default:
printf("Opcion invalida\n\n");
break;
}
printf("\nDesea realizar otra operacion?\n<1>-si\n<0>-no\n");
scanf("%d",&op);
system("cls");
}while(op);
return 0;
}
int
dv_num_compare (numeric_t dn1, numeric_t dn2, dtp_t dtp1, dtp_t dtp2)
{
if (DV_SINGLE_FLOAT == dtp1)
{
*(double *)dn1 = *(float *)dn1;
dtp1 = DV_DOUBLE_FLOAT;
}
if (DV_SINGLE_FLOAT == dtp2)
{
*(double *)dn2 = *(float *)dn2;
dtp2 = DV_DOUBLE_FLOAT;
}
if (dtp1 == dtp2)
{
switch (dtp1)
{
case DV_LONG_INT:
return NUM_COMPARE (*(int64*)dn1, *(int64*)dn2);
case DV_DOUBLE_FLOAT:
return NUM_COMPARE (*(double *) dn1, *(double *) dn2);
case DV_NUMERIC:
return (numeric_compare_dvc ((numeric_t) dn1, (numeric_t) dn2));
default:
GPF_T; /* Impossible num type combination */
}
}
switch (dtp1)
{
case DV_LONG_INT:
switch (dtp2)
{
case DV_NUMERIC:
return dvc_int_num (*(int64*)dn1, dn2);
case DV_DOUBLE_FLOAT:
return dvc_int_double (*(int64*)dn1, *(double*)dn2);
default: GPF_T1 ("bad num compare combination");
}
case DV_DOUBLE_FLOAT:
switch (dtp2)
{
case DV_LONG_INT:
REV (dvc_int_double (*(int64*)dn2, *(double*) dn1));
case DV_NUMERIC:
REV (dvc_num_double (dn2, *(double*)dn1));
default: GPF_T1 ("bad num compare combination");
}
case DV_NUMERIC:
switch (dtp2)
{
case DV_LONG_INT:
REV (dvc_int_num (*(int64*)dn2, (numeric_t)dn1));
case DV_DOUBLE_FLOAT:
return dvc_num_double ((numeric_t)dn1, *(double*)dn2);
default: GPF_T1 ("bad num compare combination");
}
default: GPF_T1 ("bad num compare combination");
}
return 0;
}
