FCL/sftools/dev/build: comparison imgtools/romtools/rombuild/r

equal deleted inserted replaced

-:c7c26511138f
+:360bd6b35136
 #include <e32std_private.h>
 #include <e32uid.h>
 #include "h_utl.h"
 #include <string.h>
 #include <stdlib.h>
+#include <iomanip>
-#if defined(__MSVCDOTNET__) || defined(__TOOLS2__)
-#include <iomanip>
-#else //!__MSVCDOTNET__
-#include <iomanip.h>
-#endif //__MSVCDOTNET__
 #include "r_global.h"
 #include "r_obey.h"
 #include "r_rom.h"
 #include "r_dir.h"
 #include "patchdataprocessor.h"
 #include "memmap.h"
 #include "byte_pair.h"
+#include "symbolgenerator.h"
 const TInt KSpareExports=16;
 extern TInt gThreadNum;
-extern char* gDepInfoFile;
+extern string gDepInfoFile;
 extern TBool gGenDepGraph;
 TUint32 DeflateCompressCheck(char *bytes,TInt size,ostream &os);
 void DeflateCompress(char *bytes,TInt size,ostream &os);
 void InflateUnCompress(unsigned char* source, int sourcesize,unsigned char* dest, int destsize);
 			{
 			TRomBuilderEntry * current = m_queue->front();
 			m_queue->pop();
 			m_mutex.unlock();
 			TInt err = current->OpenImageFile();
+			m_mutex.lock();
+			err = current->GetImageFileInfo(err);
+			m_mutex.unlock();
 			if(err)
 				{
 				m_mutex.lock();
 				++m_errors;
 				m_mutex.unlock();
 	m_nextpage = aNextPage;
 	}
 void CompressPageWorker::operator()()
 	{
 	SRomPageInfo* pPageBase = (SRomPageInfo*)((TInt)m_rom->iHeader + m_rom->iHeader->iRomPageIndex);
-	CBytePair bpe(gFastCompress);
+	CBytePair bpe;
 	while(1)
 		{
 		m_mutex.lock();
 		TInt currentPageIndex = m_nextpage++;
 		m_mutex.unlock();
 	{}
 COrderedFileList::~COrderedFileList()
 	{
 	iCount=0;
-	delete[] iOrderedFiles;
+	if(iOrderedFiles)
+		delete[] iOrderedFiles;
 	}
 COrderedFileList* COrderedFileList::New(TInt aMaxFiles)
 	{
 	COrderedFileList *pL=new COrderedFileList(aMaxFiles);
 	if ((start!=KErrNotFound) && (end!=KErrNotFound) && (end>start))
 		{
 		// Importing from DLL with Uid
 		char uidStr[0x100];
 		strcpy(uidStr, "0x");
 		strncat(uidStr, aExportName+start+1, end-start-1);
-		#ifdef __TOOLS2__
-		istringstream val(uidStr);
-		#else
+		if (IsValidNumber(uidStr)){
-		istrstream val(uidStr,strlen(uidStr));
+			TUint32 u = 0;
-		#endif
+			Val(u,uidStr);
-#if defined(__MSVCDOTNET__) || defined(__TOOLS2__)
-		val >> setbase(0);
-#endif //__MSVCDOTNET__
-		TUint32 u;
-		val >> u;
-		val.peek();
-		if (val.eof())
-			{
 			aDllUid=TUid::Uid(u);
 			char *dot=aExportName+strlen(aExportName)-1;
 			while (dot>=aExportName)
 				{
 				if (*dot=='.')
 				}
 			}
 		}
 	}
-E32Rom::E32Rom(CObeyFile *aObey)
+E32Rom::E32Rom(CObeyFile *aObey) {
-//
-// Constructor
-//
-	{
 	iSize=sizeof(TRomLoaderHeader)+aObey->iRomSize;
 	iObey=aObey;
 	iPeFiles=NULL;
+	iSymGen = NULL ;
 	if(gLowMem)
 	{
 		iImageMap = new Memmap();
 		if(iImageMap == NULL)
 	iBranchesFixedUp=0;
 	iVtableEntriesFixedUp=0;
 	iOverhead=0;
 	}
-E32Rom::~E32Rom()
+E32Rom::~E32Rom() {
-//
+	if(iSymGen){
-// Destructor
+		delete iSymGen;
-//
+		iSymGen = NULL ;
-	{
+	}
 	if(gLowMem)
 	{
 		iImageMap->CloseMemoryMap(ETrue);
 		delete iImageMap;
 	}
 	char* addr = anAddr;
 	TRomExceptionSearchTable* exceptionSearchTable = 0;
 	if(gPagedRom)
 		{
-		gDepInfoFile = (char* )malloc(strlen((char *)iObey->iRomFileName) + 1);
+		gDepInfoFile = iObey->iRomFileName;
-		strcpy(gDepInfoFile, (char *)iObey->iRomFileName);
 		iObey->SetArea().DefaultArea()->SortFilesForPagedRom();
 		// exception search table needs to go at start of ROM to make it not demand paged...
 		addr = ReserveRomExceptionSearchTable(addr,exceptionSearchTable);
 		}
 	else if(gGenDepGraph)
 	TRomHeader dummy;
 	TInt r=LoadContents(addr, &dummy);
 	if (r!=KErrNone)
 		{
 		Print(EError, "LoadContents failed - return code %d\n", r);
+		if(iSymGen)
+			iSymGen->WaitThreads();
 		return r;
 		}
 	iExtensionRomHeader->iRomRootDirectoryList = dummy.iRomRootDirectoryList;
 	iLoaderHeader->SetUp(iObey);
 	FinaliseExtensionHeader(aKernelRom);
 	DisplayExtensionHeader();
+	if(iSymGen)
+		iSymGen->WaitThreads();
 	return KErrNone;
 	}
 TInt E32Rom::Create()
 	{
 	TInt r=LoadContents(addr, iHeader);
 	if (r!=KErrNone)
 		{
 		Print(EError, "LoadContents failed - return code %d\n", r);
+		if(iSymGen)
+			iSymGen->WaitThreads();
 		return r;
 		}
 	r = SetupPages(); // initialize ROM paging info...
 	if(r!=KErrNone)
 		{
 		Print(EError, "Setup pages information failed - return code %d\n", r);
+		if(iSymGen)
+			iSymGen->WaitThreads();
 		return r;
 		}
 	r = CheckUnpagedMemSize(); // check for unpaged memory overflow
 	if(r!=KErrNone)
 	{
+		if(iSymGen)
+			iSymGen->WaitThreads();
 		return r;
 	}
 	r = CompressPages(); // setup ROM paging info...
 	if(r!=KErrNone)
 		{
 		Print(EError, "CompressPages failed - return code %d\n", r);
+		if(iSymGen)
+			iSymGen->WaitThreads();
 		return r;
 		}
 	iLoaderHeader->SetUp(iObey);
 	ImpTRomHeader* header = (ImpTRomHeader *)iHeader;
 	header->Display();
 	TUint testCheckSum = HMem::CheckSum((TUint *)iHeader, iHeader->iRomSize);
 	Print(ELog, "Rom 32bit words sum to   %08x\n", testCheckSum);
-	if (testCheckSum != iObey->iCheckSum)
+	if (testCheckSum != iObey->iCheckSum){
+		if(iSymGen)
+			iSymGen->WaitThreads();
 		return Print(EError, "Rom checksum is incorrect: %08x should be %08x\n",
 					testCheckSum, iObey->iCheckSum);
+	}
 	// 8bit checksum = sum of bytes
 	// odd/even checksum = checksum of the odd and even halfwords of the image
 	Print(ELog, "Rom 8bit checksum        %08x\n", HMem::CheckSum8((TUint8 *)iHeader, iHeader->iRomSize));
 					r=(TRomEntry*)(hdr->iNextExtension-iObey->iRomLinearBase+(char*)iHeader);
 					n++;
 					}
 			}
 		}
+	if(iSymGen)
+			iSymGen->WaitThreads();
 	return KErrNone;
 	}
 char *E32Rom::WriteDirectory(char *aAddr, TRomHeader* aHeader)
 //
 	TInt sum=0;
 	TRomBuilderEntry *current=iObey->FirstFile();
 	while (current)
 		{
 		if (current->iResource || current->HCRDataFile())
-			sum+=Align(HFile::GetLength((TText*)current->iFileName));
+			sum+=Align(HFile::GetLength(current->iFileName));
 		else
 			sum+=Align(current->SizeInRom());
 		current=iObey->NextFile();
 		}
 	return sum+iOverhead+Align(iDirectorySize);
 			}
 		}
 	return total_errors ? KErrGeneral : KErrNone;
 	}
-const TText FileTypeFile[]=		"File     ";
+const char FileTypeFile[]=		"File     ";
-const TText FileTypePrimary[]=	"Primary  ";
+const char FileTypePrimary[]=	"Primary  ";
-const TText FileTypeVariant[]=	"Variant  ";
+const char FileTypeVariant[]=	"Variant  ";
-const TText FileTypeExtension[]="Extension";
+const char FileTypeExtension[]="Extension";
-const TText FileTypeDevice[]=	"Device   ";
+const char FileTypeDevice[]=	"Device   ";
 void E32Rom::EnumerateVariants()
 	{
 	TInt vIndex;
 	TInt nFiles=iObey->iNumberOfExtensions+iObey->iNumberOfDevices+3;
 			E32ImageHeader *pH=pF->iHdr;
 			if (pF->iDataBssOffset!=0xffffffff && pF->iDataBssOffset!=dataOffset)
 				Print(EError,"Conflicting DataBss addresses\n");
 			pF->iDataBssOffset=dataOffset;
 			TInt dataSize=AlignData(pH->iDataSize+pH->iBssSize);
-			const TText* pT=FileTypeFile;
+			const char* pT=FileTypeFile;
 			if (pF->Primary())
 				pT=FileTypePrimary;
 			if (pF->Variant())
 				pT=FileTypeVariant;
 			if (pF->Extension())
 	const char* tn = "resource";
 	if (aFile->iNonXIP)
 		tn = (aFile->iCompression) ? "compressed executable" : "uncompressed executable";
 	Print(ELog,"Reading %s %s to rom linear address %08x\n", tn, aFile->iFileName, aAddress.iImageAddr);
-	TUint32 size=HFile::GetLength((TText*)aFile->iFileName);
+	TUint32 size=HFile::GetLength(aFile->iFileName);
 	if (size==0)
 		{
 		Print(EWarning, "File %s does not exist or is 0 bytes in length.\n",aFile->iFileName);
 		return size;
 		}
 	aFile->iHeaderRange=aAddress;
 	char* addr = (char*)aFile->iHeaderRange.iImagePtr;
 	const char* src = NULL;
-	#ifdef __TOOLS2__
+	ostringstream os;
-	ostringstream os;
-	#else
-	ostrstream os;
-	#endif
 	if (aFile->iNonXIP)
 		{
 		E32ImageFile f(aBPE);
 		TInt r = f.Open(aFile->iFileName);
 		// is it really a valid E32ImageFile?
 					f.iHdr->iModuleVersion |= 0x8000u;
 					}
 				f.UpdateHeaderCrc();
 				}
 			Print(ELog, "Compression Method:0x%08x/0x%08x \n", f.iHdr->CompressionType(), aFile->iCompression);
 			os << f;
-			#ifdef __TOOLS2__
 			size = (os.str()).length();
 			src = (os.str()).c_str();
-			#else
-			size = os.pcount();
-			src = os.str();
-			#endif
 			}
 		}
 	if (addr+size>iData+iSize)
 		{
 		Print(EError, "Can't fit '%s' in Rom.\n", aFile->iFileName);
 		exit(667);
 		}
 	if (src)
 		memcpy(addr, src, size);
 	else
-		size = HFile::Read((TText*)aFile->iFileName, (TAny *)addr);
+		size = HFile::Read(aFile->iFileName, (TAny *)addr);
 	Print(ELog,"Size:                    %08x\n", size);
 	aFile->iHeaderRange.iSize=size;
 	aAddress.Extend(aFile->iHeaderRange.iSize);
 	return size;
 		SetImageAddr(second,iSectionPtr);
 		secondptr = &second;
 		}
 	TInt fileCount=0;
+	if(gGenSymbols && !iSymGen) {
+		string filename(iObey->GetFileName());
+		filename.erase(filename.length() - 3,3);
+		filename.append("symbol");
+		iSymGen = new SymbolGenerator(filename.c_str(),gThreadNum - 1);
+	}
 	//
 	// Process files in non default areas
 	//
-CBytePair bpe(gFastCompress);
+CBytePair bpe;
 	for (NonDefaultAreasIterator areaIt(iObey->SetArea());
 		 ! areaIt.IsDone();
 		 areaIt.GoToNext())
 		{
 		Area& currentArea = areaIt.Current();
 	// align to likely position of next file
 	TInt offset=(char*)mainptr->iImagePtr-romaddr;
 	offset = Align(offset)-offset;
 	mainptr->Extend(offset);
 	iOverhead +=offset;
+	if(iSymGen){
+		SymGenContext context ;
+		memset(&context,0,sizeof(SymGenContext));
+		iSymGen->AddEntry(context);
+	}
 	return (char*)mainptr->iImagePtr;
 	}
 void E32Rom::LayoutFile(TRomBuilderEntry* current, TAddressRange& aMain, TAddressRange* aSecond, CBytePair * aBPE)
 //
 	Print(ELog,"\n********************************************************************\n");
 	if (current->iPatched)
 		Print(ELog, "[Patched file]\n");
+	TLinAddr savedAddr = aMain.iImageAddr;
 	if (current->iResource)
 		{
 		TInt size=LoadDataToRom(current, aMain, aBPE);
 		if (aSecond != 0 && aMain.iImageAddr > iObey->iSectionStart)
 			return;		// first section has overflowed
 		current->FixupRomEntries(size);
+		if(iSymGen) {
+			SymGenContext context ;
+			memset(&context,0,sizeof(SymGenContext));
+			context.iFileName = current->iFileName ;
+			context.iDataAddress = savedAddr ;
+			iSymGen->AddEntry(context);
+		}
 		return;
 		}
 	if(current->HCRDataFile()){
 		TInt size=LoadDataToRom(current, aMain, aBPE);
 		if (aSecond != 0 && aMain.iImageAddr > iObey->iSectionStart)
 			return;		// first section has overflowed
 		current->FixupRomEntries(size);
 		iHeader->iHcrFileAddress =  current->iHeaderRange.iImageAddr ;
 		TRACE(TAREA, Print(ELog, "iHeader->iHcrFileAddress = %08x\n", iHeader->iHcrFileAddress));
+		if(iSymGen) {
+			SymGenContext context ;
+			memset(&context,0,sizeof(SymGenContext));
+			context.iFileName = current->iFileName ;
+			context.iDataAddress = savedAddr ;
+			iSymGen->AddEntry(context);
+		}
 		return ;
 	}
 	Print(ELog,"Processing file %s\n",current->iFileName);
 	if (current->Primary())
 	if (aSecond != 0 && aMain.iImageAddr > iObey->iSectionStart)
 		return;		// first section has overflowed
 	LoadFileToRom(current);
-	Display(current->iRomImageHeader);
+	TRomImageHeader *header = current->iRomImageHeader;
+	if(iSymGen){
+		SymGenContext context  ;
+		context.iFileName = current->iFileName ;
+		context.iTotalSize = section1size;
+		context.iCodeAddress = header->iCodeAddress;
+		context.iDataAddress = header->iDataAddress;
+		context.iDataBssLinearBase = header->iDataBssLinearBase;
+		context.iTextSize = header->iTextSize;
+		context.iDataSize = header->iDataSize;
+		context.iBssSize = header->iBssSize;
+		context.iTotalDataSize = header->iTotalDataSize;
+		context.iExecutable = ETrue ;
+		iSymGen->AddEntry(context);
+	}
+	Display(header);
 	Print(ELog,     "Dll ref table size:      %08x\n", current->iDllRefTableRange.iSize);
 	Print(ELog,     "Compression:             %08x\n", current->iCompression);
 	Print(ELog,     "\n");
 	current->FixupRomEntries(section1size);
 TInt E32Rom::WriteImages(TInt aHeaderType)
 	{
 	if (aHeaderType < 0)
 		aHeaderType = 1;
-	ofstream romFile((const char *)iObey->iRomFileName,ios::binary);
+	ofstream romFile((const char *)iObey->iRomFileName,ios_base::binary);
 	if (!romFile)
 		return Print(EError,"Cannot open ROM file %s for output\n",iObey->iRomFileName);
 	Write(romFile, aHeaderType);
 	romFile.close();
 		if (strcmp(sname, "*")==0)
 			{
 			// use romname with ".odd" appended.
 			sprintf(sname,"%s.odd",(const char *)iObey->iRomFileName);
 			}
-		ofstream oFile(sname,ios::binary);
+		ofstream oFile(sname,ios_base::binary);
 		if (!oFile)
 			return Print(EError,"Cannot open file %s for output\n",sname);
 		Print(EAlways, "Writing odd half words to file %s\n",sname);
 		WriteOdd(oFile);
 		oFile.close();
 		if (strcmp(sname, "*")==0)
 			{
 			// use romname with ".even" appended.
 			sprintf(sname,"%s.even",(const char *)iObey->iRomFileName);
 			}
-		ofstream oFile(sname,ios::binary);
+		ofstream oFile(sname,ios_base::binary);
 		if (!oFile)
 			return Print(EError,"Cannot open file %s for output\n",sname);
 		Print(EAlways, "Writing even half words to file %s\n",sname);
 		WriteEven(oFile);
 		oFile.close();
 		if (strcmp(sname, "*")==0)
 			{
 			// use romname with ".srec" appended.
 			sprintf(sname,"%s.srec",(const char *)iObey->iRomFileName);
 			}
-		ofstream sFile(sname,ios::binary);
+		ofstream sFile(sname,ios_base::binary);
 		if (!romFile)
 			return Print(EError,"Cannot open file %s for output\n",sname);
 		Print(EAlways, "Writing S record format to file %s\n",sname);
 		WriteSRecord(sFile);
 		sFile.close();
 		// Rewrite the header with updated info
 		#ifdef __TOOLS2__
 		os.seekp(headerpos);
 		#else
-		os.seekp(headerpos,ios::beg);
+		os.seekp(headerpos,ios_base::beg);
 		#endif
 		// Rewrite uncompressed un-paged part (bootstrap + Page Index Table)
 		os.write((char *)(iHeader), iHeader->iCompressedUnpagedStart);
 	iHeader->iUnpagedUncompressedSize = srcsize;
 	#ifdef __TOOLS2__
 	os.seekp(headerpos);
 	#else
-	os.seekp(headerpos,ios::beg);
+	os.seekp(headerpos,ios_base::beg);
 	#endif
 	os.write(reinterpret_cast<char*>(iHeader), headersize);	// write header again with (compressed) size info
 	if (gLogLevel & LOG_LEVEL_COMPRESSION_INFO)
 		Print(ELog, "\tiSizeUsed:%d, iUncompressedSize:%d, headersize:%d, srcsize:%d, rawimagelen:%d \n",iSizeUsed, iUncompressedSize, headersize, srcsize, rawimagelen);
 	}
-TInt E32Rom::Compare(char *anImage, TInt aHeaderType)
+TInt E32Rom::Compare(const char *aImage, TInt aHeaderType)
 	{
 	if (aHeaderType < 0)
 		aHeaderType = 1;
-	ifstream file(anImage, ios::binary);
+	ifstream file(aImage, ios_base::binary);
 	if (!file)
-		return Print(EError, "Cannot open Rom image '%s' for verification\n", anImage);
+		return Print(EError, "Cannot open Rom image '%s' for verification\n", aImage);
-	Print(ELog, "\nVerifying ROM against image in %s\n", anImage);
+	Print(ELog, "\nVerifying ROM against image in %s\n", aImage);
 	switch (aHeaderType)
 		{
 	case 0:
 		break;
 	case 1:
 		{
 		Print(EWarning, "The size of unpaged memory is not available. The unpaged memory overflow checking is skipped.\n");
 		}
 	return KErrNone;
-	}
+}
+TRomNode* E32Rom::RootDirectory() const {
-TRomNode* E32Rom::RootDirectory()
-{
 	return iObey->iRootDirectory;
 }
+const char* E32Rom::RomFileName() const {
-TText* E32Rom::RomFileName()
-{
 	return iObey->iRomFileName;
 }
+TUint32 E32Rom::RomBase() const {
-TUint32 E32Rom::RomBase()
+	return iHeader->iRomBase;
-{
-	return iHeader->iRomBase;
 }
+TUint32 E32Rom::RomSize() const {
-TUint32 E32Rom::RomSize()
-{
 	return iHeader->iRomSize;
 }
+TVersion E32Rom::Version() const {
-TVersion E32Rom::Version()
-{
 	return iHeader->iVersion;
 }
+TInt64 E32Rom::Time() const {
-TInt64 E32Rom::Time()
-{
 	return iHeader->iTime;
 }
+TUint32 E32Rom::CheckSum() const {
-TUint32 E32Rom::CheckSum()
-{
 	return iHeader->iCheckSum;
 }
+TUint32 E32Rom::DataRunAddress() const {
-TUint32 E32Rom::DataRunAddress()
-{
 	return iObey->iDataRunAddress;
 }
+TUint32 E32Rom::RomAlign() const {
-TUint32 E32Rom::RomAlign()
-{
 	return iObey->iRomAlign;
 }

changeset 590	360bd6b35136
parent 0	044383f39525
child 617	3a747a240983