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; }