char *luaU_dumpchunk_buffer(const Proto* Main, size_t *len) { char *buf; /* First calculate the total size*/ __lua_dumper_size = 0; DumpByte = DumpByte_calc_size; DumpSig = DumpSig_calc_size; DumpBlock = DumpBlock_calc_size; DumpVector = DumpVector_calc_size; DumpHeader(NULL); DumpFunction(Main, NULL); /* Allocate the buffer */ *len = __lua_dumper_size; C_MAKE(buf, __lua_dumper_size, char); /* Now dump it for real */ __lua_dumper_size = 0; DumpByte = DumpByte_buffer; DumpSig = DumpSig_buffer; DumpBlock = DumpBlock_buffer; DumpVector = DumpVector_buffer; DumpHeader(buf); DumpFunction(Main, buf); return buf; }
void Convert(std::string pe_file_name, std::string xky_file_name) { //Creamos el fichero PE PEFile pe_file(pe_file_name); //Testear que exista una seccion ".module" if(!pe_file.GetSectionHeaderByName(MODULE_SECTION_NAME)) throw std::string(".module section doesn't exists"); //Creamos el fichero linkado XFile xky_file(CalculateXkyFileSize(&pe_file, XKY_SECTION_ALIGNMENT, XKY_HEADER_ALIGNMENT)); //Volcamos la cabecera DumpHeader(&xky_file, &pe_file, XKY_HEADER_ALIGNMENT); //Volcamos por este orden: // .import // .data // .code // .export DumpSection(&xky_file, &pe_file, IMPORT_SECTION_NAME, XKY_SECTION_ALIGNMENT); DumpSection(&xky_file, &pe_file, DATA_SECTION_NAME, XKY_SECTION_ALIGNMENT); DumpSection(&xky_file, &pe_file, CODE_SECTION_NAME, XKY_SECTION_ALIGNMENT); DumpSection(&xky_file, &pe_file, EXPORT_SECTION_NAME, XKY_SECTION_ALIGNMENT); //Volcamos las relocs // xky_module_header->relocs_section.offset = xky_file_write_pointer; // xky_module_header->relocs_section.size = xky_file_size - xky_file_write_pointer; DumpRelocs(&xky_file, &pe_file, XKY_SECTION_ALIGNMENT); //Volcamos a disco if(!xky_file.FlushToDisk(xky_file_name)) throw std::string("Cant open dump disk file: ") + xky_file_name; }
int main() { //============== char cmd[128+1]; ProcArgs( getcmd( cmd ) ); if( Initialize() != 0 ) { return( 1 ); } printf( "Building Lists...\n" ); BuildLists(); printf( "Finding Phrases...\n" ); FindPhrases(); printf( "Sorting...\n" ); SortByRef(); printf( "ReNumbering...\n" ); ReNumber(); printf( "Dumping Header...\n" ); DumpHeader(); printf( "Dumping Msgs...\n" ); DumpMsg(); printf( "Dumping GroupTable...\n" ); DumpGroupTable(); printf( "Dumping ErrWords...\n" ); DumpErrWord(); Finalize(); return( 0 ); }
/* ** dump function as precompiled chunk */ void luaU_dump (lua_State* L, const Proto* Main, lua_Chunkwriter w, void* data) { DumpState D; D.L=L; D.write=w; D.data=data; DumpHeader(&D); DumpFunction(Main,NULL,&D); }
void CInstQuoteDay::Dump(const char *sFileName) { FILE *fh; int i; st_quoteitem *pLast; char m_str[1024]; char *p; long lRec; long lBackWritePos; fh = fopen(sFileName,"w"); if (fh == nullptr) { printf("Can not open:%s\n",sFileName); return; } pLast = nullptr; DumpHeader(fh,&lBackWritePos); lRec = 0; for(i=0;i<m_iQuoteArrayCount;i++) { if (m_pQuoteArray[i].m_pQuote == nullptr) { sprintf(m_str,">,%u,%u,",m_pQuoteArray[i].m_dwQuoteTime,m_pQuoteArray[i].m_dwMilliSec); p = m_str+strlen(m_str); if (i == 0) { if (m_bprefilled) { m_preitem.DumpToStr(p); } } else { if (pLast != nullptr) { pLast->DumpToStr(p); } } } else { sprintf(m_str," ,%u,%u,",m_pQuoteArray[i].m_dwQuoteTime,m_pQuoteArray[i].m_dwMilliSec); p = m_str+strlen(m_str); m_pQuoteArray[i].m_pQuote->DumpToStr(p); pLast = m_pQuoteArray[i].m_pQuote; lRec++; } fprintf(fh,"%s\n",m_str); } fseek(fh,lBackWritePos,SEEK_SET); fprintf(fh,"%10ld,%10ld",(long)m_iQuoteArrayCount,lRec); fclose(fh); }
/* * dump ktap function as precompiled chunk */ int ktapc_dump(const ktap_proto *f, ktap_writer w, void *data, int strip) { DumpState D; D.writer = w; D.data = data; D.strip = strip; D.status = 0; DumpHeader(&D); DumpFunction(f, &D); return D.status; }
/* ** dump Lua function as precompiled chunk */ int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip) { DumpState D; D.L=L; D.writer=w; D.data=data; D.strip=strip; D.status=0; DumpHeader(&D); DumpFunction(f,NULL,&D); return D.status; }
/* ** dump Lua function as precompiled chunk with specified target */ int luaU_dump_crosscompile (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip, DumpTargetInfo target) { DumpState D; D.L=L; D.writer=w; D.data=data; D.strip=strip; D.status=0; D.target=target; DumpHeader(&D); DumpFunction(f,NULL,&D); return D.status; }
/* ** dump Lua function as precompiled chunk */ int luaU_dump (LuaThread* L, const LuaProto* f, lua_Writer w, void* data, int strip) { THREAD_CHECK(L); DumpState D; D.L=L; D.writer=w; D.data=data; D.strip=strip; D.status=0; DumpHeader(&D); DumpFunction(f,&D); return D.status; }
void DumpROMImage( PIMAGE_ROM_HEADERS pROMHeader ) { DumpHeader(&pROMHeader->FileHeader); printf("\n"); DumpROMOptionalHeader(&pROMHeader->OptionalHeader); printf("\n"); DumpSectionTable( IMAGE_FIRST_ROM_SECTION(pROMHeader), pROMHeader->FileHeader.NumberOfSections, TRUE); printf("\n"); // Dump COFF symbols out here. Get offsets from the header }
//o--------------------------------------------------------------------------o //| Function - bool Save( ofstream &outStream ) //| Date - 28th July, 2000 //| Programmer - Abaddon //| Modified - //o--------------------------------------------------------------------------o //| Purpose - Saves a multi out to disk //| outStream is the file to write to //o--------------------------------------------------------------------------o bool CMultiObj::Save( std::ofstream &outStream ) { bool rvalue = false; if( !isFree() ) { rvalue = true; MapData_st& mMap = Map->GetMapData( worldNumber ); if( GetCont() != NULL || ( GetX() > 0 && GetX() < mMap.xBlock && GetY() < mMap.yBlock ) ) { DumpHeader( outStream ); DumpBody( outStream ); DumpFooter( outStream ); } } return rvalue; }
/* ** dump Lua function as precompiled chunk */ int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip, char endian) { DumpState D; D.L=L; D.writer=w; D.data=data; D.strip=strip; D.status=0; D.swap=doendian(endian); D.endian=endian; luaZ_initbuffer(L, &D.b); DumpHeader(&D); DumpFunction(f,NULL,&D); luaZ_freebuffer(L, &D.b); return D.status; }
void luaU_dumpchunk_file(const Proto* Main, PHYSFS_file* D) { cptr err; DumpByte = DumpByte_file; DumpSig = DumpSig_file; DumpBlock = DumpBlock_file; DumpVector = DumpVector_file; DumpHeader(D); DumpFunction(Main,D); if ((err = PHYSFS_getLastError()) != NULL) { quit(format("luac: write error: %s", err)); } }
/* ** dump Lua function as precompiled chunk */ int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip) { LuaDumpConfig config; DumpState D; D.L=L; D.writer=w; D.data=data; D.strip=strip; D.status=0; // Dump functions are expecting this config config.endianness = (luaU_getHostOrder() == WWS_LUA_LITTLE_ENDIAN) ? 1 : 0; config.sizeof_int = sizeof(int); config.sizeof_size_t = sizeof(size_t); config.sizeof_lua_Number = sizeof(lua_Number); D.config = &config; DumpHeader(&D); DumpFunction(f,NULL,&D); return D.status; }
void luaU_dumpchunk(const Proto* Main, FILE* D) { DumpHeader(D); DumpFunction(Main,D); }
bool DumpExeFileNE( MPanelItem *pRoot, PIMAGE_DOS_HEADER dosHeader, PIMAGE_OS2_HEADER pOS2Header ) { PBYTE pImageBase = (PBYTE)dosHeader; pRoot->Root()->AddFlags(_T("16BIT")); //MPanelItem* pDos = pRoot->AddFile(_T("DOS_Header"), sizeof(*dosHeader)); //pDos->SetData((const BYTE*)dosHeader, sizeof(*dosHeader)); DumpHeader(pRoot, dosHeader); //MPanelItem* pChild = pRoot->AddFolder(_T("OS2 Header")); MPanelItem* pChild = pRoot->AddFile(_T("OS2_Header.txt")); pChild->AddText(_T("<OS2 Header>\n")); MPanelItem* pOS2 = pRoot->AddFile(_T("OS2_Header"), sizeof(*pOS2Header)); pOS2->SetData((const BYTE*)pOS2Header, sizeof(*pOS2Header)); if (pOS2Header->ne_magic != IMAGE_OS2_SIGNATURE) { pChild->AddText(_T(" IMAGE_OS2_SIGNATURE_LE signature not supported\n")); return true; } pChild->AddText(_T(" Signature: IMAGE_OS2_SIGNATURE\n")); pChild->printf(_T(" Version number: %u\n"), (UINT)pOS2Header->ne_ver); pChild->printf(_T(" Revision number: %u\n"), (UINT)pOS2Header->ne_rev); pChild->printf(_T(" Offset of Entry Table: %u\n"), (UINT)pOS2Header->ne_enttab); pChild->printf(_T(" Number of bytes in Entry Table: %u\n"), (UINT)pOS2Header->ne_cbenttab); pChild->printf(_T(" Checksum of whole file: 0x%08X\n"), (UINT)pOS2Header->ne_crc); pChild->printf(_T(" Flag word: 0x%04X\n"), (UINT)pOS2Header->ne_flags); pChild->printf(_T(" Automatic data segment number: %u\n"), (UINT)pOS2Header->ne_autodata); pChild->printf(_T(" Initial heap allocation: %u\n"), (UINT)pOS2Header->ne_heap); pChild->printf(_T(" Initial stack allocation: %u\n"), (UINT)pOS2Header->ne_stack); pChild->printf(_T(" Initial CS:IP setting: 0x%08X\n"), (UINT)pOS2Header->ne_csip); pChild->printf(_T(" Initial SS:SP setting: 0x%08X\n"), (UINT)pOS2Header->ne_sssp); pChild->printf(_T(" Count of file segments: %u\n"), (UINT)pOS2Header->ne_cseg); pChild->printf(_T(" Entries in Module Reference Table: %u\n"), (UINT)pOS2Header->ne_cmod); pChild->printf(_T(" Size of non-resident name table: %u\n"), (UINT)pOS2Header->ne_cbnrestab); pChild->printf(_T(" Offset of Segment Table: %u\n"), (UINT)pOS2Header->ne_segtab); pChild->printf(_T(" Offset of Resource Table: %u\n"), (UINT)pOS2Header->ne_rsrctab); pChild->printf(_T(" Offset of resident name table: %u\n"), (UINT)pOS2Header->ne_restab); pChild->printf(_T(" Offset of Module Reference Table: %u\n"), (UINT)pOS2Header->ne_modtab); pChild->printf(_T(" Offset of Imported Names Table: %u\n"), (UINT)pOS2Header->ne_imptab); pChild->printf(_T(" Offset of Non-resident Names Table: %u\n"), (UINT)pOS2Header->ne_nrestab); pChild->printf(_T(" Count of movable entries: %u\n"), (UINT)pOS2Header->ne_cmovent); pChild->printf(_T(" Segment alignment shift count: %u\n"), (UINT)pOS2Header->ne_align); pChild->printf(_T(" Count of resource segments: %u\n"), (UINT)pOS2Header->ne_cres); pChild->printf(_T(" Target Operating system: %u\n"), (UINT)pOS2Header->ne_exetyp); pChild->printf(_T(" Other .EXE flags: 0x%02X\n"), (UINT)pOS2Header->ne_flagsothers); pChild->printf(_T(" offset to return thunks: %u\n"), (UINT)pOS2Header->ne_pretthunks); pChild->printf(_T(" offset to segment ref. bytes: %u\n"), (UINT)pOS2Header->ne_psegrefbytes); pChild->printf(_T(" Minimum code swap area size: %u\n"), (UINT)pOS2Header->ne_swaparea); pChild->printf(_T(" Expected Windows version number: %u.%u\n"), (UINT)HIBYTE(pOS2Header->ne_expver), (UINT)LOBYTE(pOS2Header->ne_expver)); pChild->AddText(_T("\n")); if (pOS2Header->ne_rsrctab) { LPBYTE pResourceTable = (((LPBYTE)pOS2Header)+pOS2Header->ne_rsrctab); DumpNEResourceTable(pRoot, dosHeader, pResourceTable); //MPanelItem* pChild = pRoot->AddFolder(_T("Resource Table")); //pChild->AddText(_T("<Resource Table>\n")); } return true; }
/* ========================================================================= */ int main(int argc, char *argv[]) { struct options *o; /* Set our globals to NULL */ gcf = NULL; grf = NULL; #ifndef BIN_NAME CompileFailNoBinaryNameDefined(); #endif /* We want a 64 bit value for size_t - insure it is so */ assert(8 == sizeof(size_t)); /* Read options from the command line into a manageable struct */ if ( NULL == (o = ParseOptions(argc, argv)) ) return(1); /* Does user want usage info? */ if ( o->bHelp ) { usage(); return(0); } /* Does user want about info? */ if ( o->bAbout ) { about(); return(0); } if ( o->bAppend ) { if ( o->iRolling ) { if ( IsCircularFile(o->filename) ) { fprintf(stderr, "WARNING: Unable to convert circular file to rolling - staying circular.\n"); return(ClogAppendSession(o)); } return(RlogAppendSession(o)); } /* No type is specified - assume circular */ if ( IsCircularFile(o->filename) ) { return(ClogAppendSession(o)); } else { if(NULL != (LoadMetaDataFile(o->filename)) ) return(RlogAppendSession(o)); return(ClogSession(o)); } } if ( o->bDumpHeader ) return(DumpHeader(o)); if ( o->bDumpMetadata ) { struct rfile *rf; if ( NULL == (rf = LoadMetaDataFile(o->filename)) ) return(1); return(PrintMetaData(rf)); } if ( o->bDump ) { if ( IsCircularFile(o->filename) ) return(DumpCircularFile(o)); else return(DumpRotatingFile(o)); } if ( o->iRolling ) return(RlogSession(o)); return(ClogSession(o)); }
/** * * This function reads the data at the provided FLASH address and expects * the partition header structure to be present. If the header is not * present (blank FLASH) or does not match expected values, MOVE_IMAGE_FAIL * is returned. * * There are four cases in partition handling: * * 1. If attribute indicates this is a bitstream partition, FPGA is programmed, * and if this is the last partition, FSBL hangs with WDT kicking * 2. If Image word Length != data word length, the partition is encrypted * partition. The partition is decrypted into DDR * 3. Other cases, partition is moved from flash to DDR through copying or DMA * 4. If partition data word length is 0, the partition is to be skipped. Note * that partition header cannot be encrypted for this to work * * Except case 1, the reboot status register is updated to reflect the next * partition. * * @param ImageAddress is the start of the image * @param PartitionNum is the index of the partition to process * * @return * - MOVE_IMAGE_FAIL (0xFFFFFFFF) if image load failed * - Address to begin executing at if successful * * @note * ****************************************************************************/ u32 PartitionMove(u32 ImageAddress, int PartitionNum) { u32 SourceAddr; u32 LoadAddr; u32 ExecAddr; u32 ImageLength; u32 DataLength; u32 SectionCount; u32 PartitionStart; u32 PartitionLength; u32 NextPartitionAddr; int NextPartition; u32 Status; u32 Attribute; /* Flag to determine if image is encrypted or not */ u32 IsEncrypted = 0; struct HeaderArray *Hap; struct PartHeader Header; /* Execution Address */ ExecAddr = MOVE_IMAGE_FAIL; /* Default is not to skip partition execution */ SkipPartition = 0; fsbl_printf(DEBUG_INFO,"image move with partition number %d\r\n", PartitionNum); PartitionStart = GoToPartition(ImageAddress, PartitionNum); GetHeader(PartitionStart, &Header); fsbl_printf(DEBUG_INFO,"Header dump:\n\r"); DumpHeader(&Header); Hap = (struct HeaderArray *)&Header; Status = ValidateHeader(&Header); if(Status != XST_SUCCESS) { return Status; } ImageLength = Header.ImageWordLen; DataLength = Header.DataWordLen; PartitionLength = Header.PartitionWordLen; LoadAddr = Header.LoadAddr; ExecAddr = Header.ExecAddr; SourceAddr = Header.PartitionStart; Attribute = Header.PartitionAttr; SectionCount = Header.SectionCount; /* The offset in header is word offset */ SourceAddr = SourceAddr << WORD_LENGTH_SHIFT; /* Consider image offset */ SourceAddr += ImageAddress; fsbl_printf(DEBUG_INFO,"Partition Start %08x, " "Partition Length %08x\r\n", PartitionStart, PartitionLength); fsbl_printf(DEBUG_INFO,"Source addr %08x, Load addr %08x, " "Exec addr %08x\r\n", SourceAddr, LoadAddr, ExecAddr); /* * If encrypted partition header, will get wrong next partition * address. Next run will fail and invoke FSBL fallback. * WARNING: Cannot handle skipping over encrypted partition header */ if (DataLength == 0) { fsbl_printf(DEBUG_INFO,"PartitionImageMove: skip partition. " "If encrypted partition, will fail\r\n"); SkipPartition = 1; goto update_status_reg; } if (Attribute == ATTRIBUTE_PL_IMAGE_MASK) { /* FSBL user hook call before bitstream download. */ Status = FsblHookBeforeBitstreamDload(); if (Status != XST_SUCCESS) { /* Error Handling here */ fsbl_printf(DEBUG_GENERAL,"FSBL_BEFORE_BSTREAM_HOOK_FAILED\r\n"); OutputStatus(FSBL_BEFORE_BSTREAM_HOOK_FAIL); FsblFallback(); } /* Check if encrypted or non encrypted */ /* If the ImageLength not equal to DataLength, encrypted */ if (ImageLength != DataLength) { IsEncrypted = 1; fsbl_printf(DEBUG_INFO,"Encrypted partition \r \n"); } fsbl_printf(DEBUG_INFO,"Source addr %x, load addr %x, " "exec addr %x\r\n", SourceAddr, LoadAddr, ExecAddr); fsbl_printf(DEBUG_GENERAL,"Bitstream Download Start \r\n"); if (IsEncrypted) { /* Bitstream NAND/SD encrypted */ if (((FlashReadBaseAddress & 0xFF000000) == XPS_NAND_BASEADDR) || (FlashReadBaseAddress == XPS_SDIO0_BASEADDR)) { fsbl_printf(DEBUG_INFO,"Bitstream NAND/SD encrypted \r\n"); Status = WritePcapXferData( (u32 *)(SourceAddr), (u32 *)XDCFG_DMA_INVALID_ADDRESS, (ImageLength), 0, XDCFG_SECURE_PCAP_WRITE); } else { /* Bitstream QSPI/NOR Encrypted */ fsbl_printf(DEBUG_INFO,"Bit stream QSPI/NOR encrypted \r\n"); Status = WritePcapXferData( (u32 *)(FlashReadBaseAddress + SourceAddr), (u32 *)XDCFG_DMA_INVALID_ADDRESS, (ImageLength), 0, XDCFG_SECURE_PCAP_WRITE); } } else { /* Bitstream NAND/SD Unencrypted */ if (((FlashReadBaseAddress & 0xFF000000) == XPS_NAND_BASEADDR) || (FlashReadBaseAddress == XPS_SDIO0_BASEADDR)) { fsbl_printf(DEBUG_INFO,"Bit stream NAND/SD Unencrypted \r\n"); Status = WritePcapXferData( (u32 *)(SourceAddr), (u32 *)XDCFG_DMA_INVALID_ADDRESS, (ImageLength), 0, XDCFG_NON_SECURE_PCAP_WRITE); } else { /* Bitstream QSPI/NOR - unencrypted */ fsbl_printf(DEBUG_INFO,"Bitstream QSPI/NOR Unencrypted \r\n"); Status = WritePcapXferData( (u32 *)(FlashReadBaseAddress + SourceAddr), (u32 *)XDCFG_DMA_INVALID_ADDRESS, (ImageLength), 0, XDCFG_NON_SECURE_PCAP_WRITE); } } if (Status != XST_SUCCESS) { fsbl_printf(DEBUG_GENERAL,"BITSTREAM_DOWNLOAD_FAIL"); OutputStatus(BITSTREAM_DOWNLOAD_FAIL); return MOVE_IMAGE_FAIL; } else { fsbl_printf(DEBUG_GENERAL,"Bitstream download successful!\r\n"); } /* FSBL user hook call after bitstream download. */ Status = FsblHookAfterBitstreamDload(); if (Status != XST_SUCCESS) { fsbl_printf(DEBUG_GENERAL,"FSBL_AFTER_BSTREAM_HOOK_FAIL"); /* Error Handling here */ OutputStatus(FSBL_AFTER_BSTREAM_HOOK_FAIL); FsblFallback(); } /* We will skip soft reset and start loading the next partition */ SkipPartition = 1; /* Go to the next partition */ goto update_status_reg; } /* End of bitstream */ /* Process all the partitions of application */ while(SectionCount-- > 0) { /* If image length not equal to data length, encrypted */ if (ImageLength != DataLength) { IsEncrypted = 1; fsbl_printf(DEBUG_INFO,"Application encrypted\n\r"); /* NAND and SD do not support encrypted partitions */ if (((FlashReadBaseAddress & 0xFF000000) == XPS_NAND_BASEADDR) || (FlashReadBaseAddress == XPS_SDIO0_BASEADDR)) { fsbl_printf(DEBUG_INFO,"Images on NAND or SD encrypted\r\n"); Status = WritePcapXferData( (u32 *)SourceAddr, (u32 *)LoadAddr, ImageLength, DataLength, XDCFG_SECURE_PCAP_WRITE); } else { Status = WritePcapXferData( (u32 *)(FlashReadBaseAddress + SourceAddr), (u32 *)LoadAddr, ImageLength, DataLength, XDCFG_SECURE_PCAP_WRITE); } if (Status != XST_SUCCESS) { fsbl_printf(DEBUG_GENERAL,"DECRYPTION_FAIL \r\n"); OutputStatus(DECRYPTION_FAIL); return MOVE_IMAGE_FAIL; } fsbl_printf(DEBUG_INFO,"Transfer is completed \r\n"); if (SectionCount != 0) { fsbl_printf(DEBUG_INFO,"load_next_partition\n\r"); goto load_next_partition; } goto update_status_reg; } else {/*End of if ImageLength != DataLength */ fsbl_printf(DEBUG_INFO,"Start transfer data into DDR\n\r"); /* Copy the flash contents to DDR */ MoveImage(SourceAddr, LoadAddr, (DataLength << WORD_LENGTH_SHIFT)); } load_next_partition: //JM detect cpu1 boot vector as last partiton and finish up if (LoadAddr == 0xFFFFFFF0) { goto update_status_reg; } PartitionNum += 1; /* Read the next partition */ fsbl_printf(DEBUG_INFO,"Get next partition header\n\r"); NextPartitionAddr = GoToPartition(ImageAddress, PartitionNum); GetHeader(NextPartitionAddr, &Header); fsbl_printf(DEBUG_INFO,"Next partition header dump\r\n"); DumpHeader(&Header); Status = ValidateHeader(&Header); if(Status != XST_SUCCESS) { fsbl_printf(DEBUG_INFO,"Validation of Header failed\r\n"); return Status; } /* Don't re-initialize ExecAddr & SectionCount */ ImageLength = Header.ImageWordLen; DataLength = Header.DataWordLen; PartitionLength = Header.PartitionWordLen; LoadAddr = Header.LoadAddr; SourceAddr = Header.PartitionStart; //JM reinit SectionCount if this is a new sub-partition if (SectionCount == 0) { SectionCount = Header.SectionCount; } /* The offset in header is word offset */ SourceAddr = SourceAddr << WORD_LENGTH_SHIFT; /* Consider image offset */ SourceAddr += ImageAddress; fsbl_printf(DEBUG_INFO,"Partition Start %08x, Partition Length %08x\r\n", PartitionStart, PartitionLength); fsbl_printf(DEBUG_INFO,"Source addr %08x, Load addr %08x, Exec addr %08x\r\n", SourceAddr, LoadAddr, ExecAddr); } /* End of while Section count > 0 */ update_status_reg: NextPartition = PartitionNum + 1; fsbl_printf(DEBUG_INFO,"Get next partition header\n\r"); NextPartitionAddr = GoToPartition(ImageAddress, PartitionNum + 1); GetHeader(NextPartitionAddr, &Header); Hap = (struct HeaderArray *)&Header; fsbl_printf(DEBUG_INFO,"Next Header dump:\n\r"); DumpHeader(&Header); /* If it is the last partition, then we will keep on running this one */ if (IsLastPartition(Hap)) { fsbl_printf(DEBUG_INFO,"There are no more partitions to load\r\n"); NextPartition = PartitionNum; /* * Fix for CR #663277 * Review : Since we donot support OCM remap, * any elf whose execution address is 0x0 * We will do a JTAG exit */ if (ExecAddr == 0) { fsbl_printf(DEBUG_INFO,"No Execution Address JTAG handoff \r\n"); /* Stop the Watchdog before JTAG handoff */ #ifdef XPAR_XWDTPS_0_BASEADDR XWdtPs_Stop(&Watchdog); #endif ClearFSBLIn(); FsblHandoffJtagExit(); } } else if(IsEmptyHeader(Hap)) { fsbl_printf(DEBUG_GENERAL,"Empty partition header \r\n"); OutputStatus(EMPTY_PARTITION_HEADER); return MOVE_IMAGE_FAIL; } Status = FsblSetNextPartition(NextPartition); if (Status != XST_SUCCESS) { fsbl_printf(DEBUG_INFO,"Next partition number %d is not valid\n", NextPartition); OutputStatus(TOO_MANY_PARTITIONS); return MOVE_IMAGE_FAIL; } fsbl_printf(DEBUG_INFO,"end of partition move, reboot status reg %x, " "Next partition %d\r\n", MoverIn32(REBOOT_STATUS_REG), NextPartition); /* Returning Execution Address */ return ExecAddr; } /* End of Partition Move */
MODULE_HEADERS * ExecPE(char *lpszName) { static void *BaseAddress; IMAGE_DOS_HEADER DosHeader; PIMAGE_SECTION_HEADER pSectionHeaders; PIMAGE_NT_HEADERS pNTHeader; static int nNTHeader; int i,len; int index = nNTHeader; char *bp; int ret; HFILE hFile; bp = lpszName; while(*bp) { *bp = tolower(*bp); bp++; } for(i=0;i<nNTHeader;i++) { if(strcmp(NTModules[i].modulename,lpszName) == 0) { return &NTModules[i]; } } hFile = _lopen(lpszName,READ); if(hFile == -1) { char lpszFileName[256]; strcpy(lpszFileName,dirname); strcat(lpszFileName,"/"); strcat(lpszFileName,lpszName); hFile = _lopen(lpszFileName,READ); if(hFile == -1) { logstr(LF_ERROR,"cannot open file %s\n",lpszFileName); return 0; } } /* read the dos image header first */ ret = _lread(hFile,&DosHeader,sizeof(IMAGE_DOS_HEADER)); if(DosHeader.e_magic == IMAGE_DOS_SIGNATURE) { /* now read in the nt header */ _llseek(hFile,DosHeader.e_lfanew,0); pNTHeader = &NTHeader[nNTHeader]; ret = _lread(hFile,pNTHeader, sizeof(IMAGE_NT_HEADERS)); /* yes, it is a win32 header */ if (pNTHeader->Signature != IMAGE_NT_SIGNATURE) { _lclose(hFile); return 0; } bp = strrchr(lpszName,'/'); if(bp) bp++; else bp = lpszName; BaseAddress = VirtualAlloc( (void *) pNTHeader->OptionalHeader.ImageBase, pNTHeader->OptionalHeader.SizeOfImage, MEM_COMMIT, PAGE_EXECUTE_READWRITE); logstr(lf_console,"Load File: %s %p\n",lpszName,BaseAddress); NTModules[nNTHeader].modulename = bp; NTModules[nNTHeader].pNTHeader = pNTHeader; NTModules[nNTHeader].BaseAddress = BaseAddress; nNTHeader++; if (nNTHeader == 1 && usebuiltins) { NTModules[nNTHeader++].modulename = "user32.dll"; NTModules[nNTHeader++].modulename = "gdi32.dll"; NTModules[nNTHeader++].modulename = "kernel32.dll"; NTModules[nNTHeader++].modulename = "shell32.dll"; NTModules[nNTHeader++].modulename = "comctl32.dll"; NTModules[nNTHeader++].modulename = "comdlg32.dll"; NTModules[nNTHeader++].modulename = "rpcrt4.dll"; NTModules[nNTHeader++].modulename = "advapi32.dll"; } /* show the NT header */ //if (index == 0) DumpHeader(&pNTHeader->FileHeader); /* show the Optional header */ //if (index == 0) DumpOptionalHeader((PIMAGE_OPTIONAL_HEADER) &pNTHeader->OptionalHeader); pSectionHeaders = (PIMAGE_SECTION_HEADER)((void *)BaseAddress + sizeof(IMAGE_NT_HEADERS)); /* now read the section headers */ ret = _lread( hFile, pSectionHeaders, sizeof(IMAGE_SECTION_HEADER)* pNTHeader->FileHeader.NumberOfSections); for(i=0; i < pNTHeader->FileHeader.NumberOfSections; i++) { void *LoadAddress; LoadAddress = RVA(BaseAddress,pSectionHeaders->VirtualAddress); //if (index == 0) { DumpSectionTable( LoadAddress,pSectionHeaders,i); } /* load only non-BSS segments */ if(!(pSectionHeaders->Characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA)) { _llseek(hFile,pSectionHeaders->PointerToRawData,SEEK_SET); len = _lread(hFile,(char*) LoadAddress, pSectionHeaders->SizeOfRawData); if( len != pSectionHeaders->SizeOfRawData) { logstr(LF_ERROR,"Failed to load section %x %x\n", i,len); exit(0); } pSectionHeaders++; } /* not needed, memory is zero */ if(strcmp(pSectionHeaders[i].Name, ".bss") == 0) memset((void *)LoadAddress, 0, pSectionHeaders[i].Misc.VirtualSize ? pSectionHeaders[i].Misc.VirtualSize : pSectionHeaders[i].SizeOfRawData); } _lclose(hFile); // we are dependent on other modules, go get and load those //if (index == 0) LoadImportsSection(BaseAddress, pNTHeader,lpszName); if (index == 0) { logstr(lf_header," %32s PE Header BaseAddress\n", "FileName"); for(i=0;i<nNTHeader;i++) { logstr(lf_header,"%.4d: %32s %p %p\n", i, NTModules[i].modulename, NTModules[i].pNTHeader, NTModules[i].BaseAddress); } } if (index == 0) LoadExportsTable(&NTModules[0],pNTHeader,lpszName); if (index == 0) ExecEntryPoint( NTModules[0].BaseAddress, NTModules[0].pNTHeader, lpszName); return &NTModules[index]; } return 0; }
void DumpChunk(TProtoFunc* Main, FILE* D) { DumpHeader(Main,D); DumpFunction(Main,D); }
void dump_lx(std::fstream &file, int hdrOfs, LEHeader &leh) { DumpHeader(leh); std::cout << "Object table: " << leh.object_count << std::endl; file.seekg(hdrOfs + leh.object_table_offset); unsigned buf[6]; int initPages = 0; for (int i=0; i < leh.object_count; i++) { file.read((char *)buf, sizeof(buf)); std::cout << " " << "Object " << i + 1 << ":" << std::endl; std::cout << " " << "Flags: " << std::hex << std::setw(8) << std::setfill('0') << buf[2] << std::endl; std::cout << " " << "Base: " << std::hex << std::setw(8) << std::setfill('0') << buf[1] << std::endl; std::cout << " " << "Size: " << std::hex << std::setw(8) << std::setfill('0') << buf[0] << std::endl; std::cout << " " << "InitSize:" << std::hex << std::setw(8) << std::setfill('0') << buf[4] << std::endl; std::cout << " " << "PageOffs:" << std::hex << std::setw(8) << std::setfill('0') << buf[3] << std::endl; initPages += buf[4]; } std::cout << "Object page table: " << leh.object_count; LXObjectPage::PageData p; file.seekg(hdrOfs + leh.object_page_table_offset); for (int i=0; i < leh.object_count; i++) { if (i %8 == 0) std::cout << std::endl; file.read((char *)&p, sizeof(p)); std::cout << " " << i + 1 << ": " << std::hex << std::setw(2) << std::setfill('0') << (int)p.flags << " " ; std::cout << std::hex << std::setw(8) << std::setfill('0') << (int)p.data_offset << " "; std::cout << std::hex << std::setw(4) << std::setfill('0') << (int)p.data_size << std::endl; } std::cout << std::endl << std::endl; std::cout << "Fixups: " << std::endl; file.seekg(hdrOfs +leh.fixup_page_table_offset); unsigned *pt = new unsigned[initPages + 1]; file.read((char *)pt, (initPages + 1) * sizeof(unsigned)); file.seekg(hdrOfs + leh.fixup_record_table_offset); for (int i=1; i <= initPages; i++) { int offs = pt[i-1]; std::cout << " Page: " << i << ":" << pt[i-1] << ":" << pt[i] << std::endl; while (pt[i] > offs) { // only handling the types of fixups genned by dlle unsigned char bf[9]; file.read((char *)bf, 7); offs += 7; if (bf[1] & LX_FF_TARGET32) { offs += 2; file.read((char *)bf+7, 2); } else { bf[7] = bf[8] = 0; } std::cout << " " << std::hex << std::setw(2) << std::setfill('0') << (int)bf[0] << " "; std::cout << std::hex << std::setw(2) << std::setfill('0') << (int)bf[1] << " "; std::cout << std::hex << std::setw(4) << std::setfill('0') << (int)((unsigned short *)(bf + 2))[0] << " "; std::cout << std::hex << std::setw(2) << std::setfill('0') << (int)bf[4] << " "; std::cout << std::hex << std::setw(8) << std::setfill('0') << (int)((unsigned *)(bf+ 5))[0] << " " << std::endl; } } delete pt; }