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

equal deleted inserted replaced

-:c7c26511138f
+:360bd6b35136
 #include <stdlib.h>
 #include "r_obey.h"
 #include "r_rofs.h"
 #include "r_coreimage.h"
 #include "memmap.h"
+#include "symbolgenerator.h"
 extern TInt gLogLevel;
 extern TBool gLowMem;
-extern TBool gFastCompress;
 extern TInt gThreadNum;
+extern TBool gGenSymbols;
 ////////////////////////////////////////////////////////////////////////
-inline TUint32 AlignData(TUint32 anAddr)
+inline TUint32 AlignData(TUint32 anAddr) {
-	{
 	return ((anAddr+0x0f)&~0x0f);
-	}
+}
 ////////////////////////////////////////////////////////////////////////
 E32Rofs::E32Rofs(CObeyFile *aObey)
 //
 // Constructor
 //
 	: iObey( aObey ), iOverhead(0)
 	{
+	if(gGenSymbols)
+		iSymGen = SymbolGenerator::GetInstance();
+	else
+		iSymGen = NULL;
 	iSize=aObey->iRomSize;
-	if(gLowMem)
+	if(gLowMem) {
-	{
 		iImageMap = new Memmap();
-		if(iImageMap == NULL)
+		if(iImageMap == NULL) {
-		{
 			iSize = 0;
 			Print(EError, "Out of memory.\n");
 		}
-		else
+		else {
-		{
 			iImageMap->SetMaxMapSize(iSize);
-			if(iImageMap->CreateMemoryMap(0, 0xff) == EFalse)
+			if(iImageMap->CreateMemoryMap(0, 0xff) == EFalse) {
-			{
 				iSize = 0;
 				Print(EError, "Failed to create image map object");
 				iImageMap->CloseMemoryMap(ETrue);
 				delete iImageMap;
 				iImageMap = NULL;
 			}
-			else
+			else {
-			{
 				iData = iImageMap->GetMemoryMapPointer();
 			}
 		}
 	}
-	else
+	else {
-	{
 		iData=new char [iSize];
 		if (iData==NULL)
 			iSize=0;
 		HMem::Set(iData, 0xff, iSize);
 	}
-	}
+}
-E32Rofs::~E32Rofs()
+E32Rofs::~E32Rofs()  {
-//
-// Destructor
+	if(gLowMem) {
-//
-	{
-	if(gLowMem)
-	{
 		iImageMap->CloseMemoryMap(ETrue);
 		delete iImageMap;
 	}
-	else
+	else if(iData)
-		delete iData;
+		delete []iData;
-	}
+}
-TInt E32Rofs::CreateExtension(MRofsImage* aImage)
+TInt E32Rofs::CreateExtension(MRofsImage* aImage)  {
-	{
 	TUint8* addr=(TUint8*)iData;
 	TRomNode* pRootDir = aImage->RootDirectory();
 	const TInt extensionRofsheaderSize = KExtensionRofsHeaderSize;
 	// aImage->iSize contains the max size of the core image
 	// Layout the directory structure. Does not actually write it
 	// to the image. Returns the number of bytes used for the directory
 	// structure within the image.
 	TInt directoryOffset = extensionRofsheaderSize;
 	const TInt directorySize = LayoutDirectory( pRootDir, aImage->Size()+directoryOffset );
-	if( directorySize <= 0 )
+	if( directorySize <= 0 ) {
-		{
 		Print(EError, "Failed laying out directories - return code %d\n", directorySize);
 		return KErrGeneral;
-		}
+	}
 	// get offset to start of file data, rounded up to next word boundary
 	TInt offs = extensionRofsheaderSize + directorySize;
 	const TInt fileDataStartOffset = offs + ( (4 - offs) & 3);
 	// Now we traverse the list of entries placing each file
 	// This updates the directory entries to point to the correct offset
 	// to the start of the file
 	const TInt fileDataSize = PlaceFiles( pRootDir, addr + fileDataStartOffset, fileDataStartOffset + aImage->Size(), aImage->Size());
-	if( fileDataSize <= 0 )
+	if( fileDataSize <= 0 ) {
-		{
 		Print(EError, "Failed placing files - return code %d\n", fileDataSize);
 		return KErrGeneral;
-		}
+	}
 	// and then put the directory into the image
 	TInt err = PlaceDirectory( pRootDir, addr - aImage->Size() ); // offset pointer by size of core image
-	if( err != KErrNone )
+	if( err != KErrNone ) {
-		{
 		Print(EError, "Failed placing directory - return code %d\n", err);
 		return err;
-		}
+	}
 	directoryOffset+=aImage->Size(); // offset offset by size of core image
 	// Now write the header
 	TExtensionRofsHeader * pHeader = (TExtensionRofsHeader*)iData;
 	pHeader->iIdentifier[0] = 'R';
 	pHeader->iIdentifier[1] = 'O';
 		MakeAutomaticSize(iObey->AutoPageSize()); // change iSize to nearest page size
 	pHeader->iMaxImageSize = iSize;
 	pHeader->iCheckSum = 0;		// not used yet
 	return KErrNone;
-	}
+}
-void E32Rofs::MakeAutomaticSize(TUint32 aPageSize)
+void E32Rofs::MakeAutomaticSize(TUint32 aPageSize) {
-		{
+	TUint32 size = iSizeUsed;
-		TUint32 size = iSizeUsed;
+	if (iSizeUsed % aPageSize > 0) {
-		if (iSizeUsed % aPageSize > 0)
+		//used size needs to be rounded up to nearest page size
-			{
+		size = (iSizeUsed/aPageSize + 1)*aPageSize;
-			//used size needs to be rounded up to nearest page size
+	}
-			size = (iSizeUsed/aPageSize + 1)*aPageSize;
+	iSize = size;
-			}
+}
-		iSize = size;
-		}
-TInt E32Rofs::Create()
 //
 // This is the main entry point to the ROFS image creation
 //
-	{
+TInt E32Rofs::Create() {
 	TUint8* addr=(TUint8*)iData;
 	TRomNode* pRootDir = iObey->iRootDirectory;
 	const TInt headerSize = KRofsHeaderSize;
 	// Layout the directory structure. Does not actually write it
 	// to the image. Returns the number of bytes used for the directory
 	// structure within the image.
 	const TInt directoryOffset = headerSize;
 	const TInt directorySize = LayoutDirectory( pRootDir, directoryOffset );
-	if( directorySize <= 0 )
+	if( directorySize <= 0 ) {
-		{
 		Print(EError, "Failed laying out directories - return code %d\n", directorySize);
 		return KErrGeneral;
-		}
+	}
 	// get offset to start of file data, rounded up to next word boundary
 	TInt offs = headerSize + directorySize;
 	const TInt fileDataStartOffset = offs + ( (4 - offs) & 3);
 	// Now we traverse the list of entries placing each file
 	// This updates the directory entries to point to the correct offset
 	// to the start of the file
 	const TInt fileDataSize = PlaceFiles( pRootDir, addr + fileDataStartOffset, fileDataStartOffset );
-	if( fileDataSize < 0 )
+	if( fileDataSize < 0 ) {
-		{
+		Print(EError, "Failed placing files - rofssize is too small\n", fileDataSize);
-		Print(EError, "Failed placing files - return code %d\n", fileDataSize);
 		return KErrGeneral;
-		}
+	}
 	// and then put the directory into the image
 	TInt err = PlaceDirectory( pRootDir, addr );
-	if( err != KErrNone )
+	if( err != KErrNone ) {
-		{
 		Print(EError, "Failed placing directory - return code %d\n", err);
 		return err;
-		}
+	}
 	// Now write the header
 	TRofsHeader* pHeader = (TRofsHeader*)iData;
 	pHeader->iIdentifier[0] = 'R';
 	pHeader->iIdentifier[1] = 'O';
 	pHeader->iIdentifier[2] = 'F';
 	iSizeUsed = fileDataSize + fileDataStartOffset;
 	pHeader->iImageSize = iSizeUsed;
 	pHeader->iImageVersion = iObey->iVersion;
 	if (iObey->AutoSize())
 		MakeAutomaticSize(iObey->AutoPageSize()); // change iSize to nearest page size
 	pHeader->iMaxImageSize = iSize;
 	pHeader->iCheckSum = 0;		// not used yet
 	return KErrNone;
-	}
+}
-void E32Rofs::DisplaySizes(TPrintType aWhere)
+void E32Rofs::DisplaySizes(TPrintType aWhere) {
-{
 	Print(aWhere, "Summary of file sizes in rofs:\n");
 	TRomBuilderEntry *file=iObey->FirstFile();
-	while(file)
+	while(file) {
-		{
 		file->DisplaySize(aWhere);
 		file=iObey->NextFile();
-		}
+	}
 	Print( aWhere, "Directory block size: %d\n"
-					"File block size:      %d\n"
+		"File block size:      %d\n"
-					"Total directory size: %d\n"
+		"Total directory size: %d\n"
-					"Total image size:     %d\n",
+		"Total image size:     %d\n",
-					iTotalDirectoryBlockSize,
+		iTotalDirectoryBlockSize,
-					iTotalFileBlockSize,
+		iTotalFileBlockSize,
-					iTotalDirectoryBlockSize + iTotalFileBlockSize,
+		iTotalDirectoryBlockSize + iTotalFileBlockSize,
-					iSizeUsed );
+		iSizeUsed );
 }
-void E32Rofs::LogExecutableAttributes(E32ImageHeaderV *aHdr)
+void E32Rofs::LogExecutableAttributes(E32ImageHeaderV *aHdr) {
-{
 	Print(ELog, "Uids:                    %08x %08x %08x %08x\n", aHdr->iUid1, aHdr->iUid2, aHdr->iUid3, aHdr->iUidChecksum);
 	Print(ELog, "Data size:               %08x\n", aHdr->iDataSize);
 	Print(ELog, "Heap min:                %08x\n", aHdr->iHeapSizeMin);
 	Print(ELog, "Heap max:                %08x\n", aHdr->iHeapSizeMax);
 	Print(ELog, "Stack size:              %08x\n", aHdr->iStackSize);
 	Print(ELog, "Priority:                %d\n\n", aHdr->iProcessPriority);
 }
 class Worker : public boost::thread {
 public:
 static void thrd_func(E32Rofs* rofs){
-CBytePair bpe(gFastCompress);
+CBytePair bpe;
 bool deferred = false;
 TPlacingSection* p = rofs->GetFileNode(deferred);
 while(p) {
-if(!deferred)
+if(!deferred) {
 p->len = p->node->PlaceFile(p->buf, (TUint32)-1, 0, &bpe);
+//no symbol for hidden file
+if(rofs->iSymGen && !p->node->iEntry->iHidden)
+rofs->iSymGen->AddFile(p->node->iEntry->iFileName,(p->node->iEntry->iCompressEnabled|| p->node->iEntry->iExecutable));
+}
 p = rofs->GetFileNode(deferred);
 }
 rofs->ArriveDeferPoint();
 p = rofs->GetDeferredJob();
 while(p) {
 Worker(E32Rofs* rofs) : boost::thread(thrd_func,rofs) {
 }
 };
 TPlacingSection* E32Rofs::GetFileNode(bool &aDeferred) {
-//get a node from the node list, the node list is protected by mutex iMuxTree.
+	//get a node from the node list, the node list is protected by mutex iMuxTree.
-//The iMuxTree also helps to make sure the order in iVPS is consistent with the node list.
+	//The iMuxTree also helps to make sure the order in iVPS is consistent with the node list.
-//And this is the guarantee of same outputs regardless of how many threads being used.
+	//And this is the guarantee of same outputs regardless of how many threads being used.
-boost::mutex::scoped_lock lock(iMuxTree);
+	boost::mutex::scoped_lock lock(iMuxTree);
-aDeferred = false;
+	aDeferred = false;
-TRomNode* node = iLastNode;
+	TRomNode* node = iLastNode;
-while(node) {
+	while(node) {
-if( node->IsFile()) {
+		if( node->IsFile()) {
-if(!node->iHidden) {
+			if(!node->iHidden) {
-iLastNode = node->NextNode();
+				iLastNode = node->NextNode();
-break;
+				break;
-}
+			}
-}
+		}
-node = node->NextNode();
+		node = node->NextNode();
-}
+	}
-if(node && node->IsFile() && !node->iHidden) {
+	if(node && node->IsFile() && !node->iHidden) {
-TPlacingSection* pps = new TPlacingSection(node);
+		TPlacingSection* pps = new TPlacingSection(node);
-iVPS.push_back(pps);
+		iVPS.push_back(pps);
-if(node->iAlias) {
+		if(node->iAlias) {
-iQueueAliasNode.push(pps);
+			iQueueAliasNode.push(pps);
-aDeferred =  true;
+			aDeferred =  true;
-}
+		}
-return pps;
+		return pps;
-}
+	}
-return NULL;
+	return NULL;
 }
 TPlacingSection* E32Rofs::GetDeferredJob() {
-// waiting all the normal node have been placed.
+	// waiting all the normal node have been placed.
-while(iWorkerArrived < gThreadNum)
+	while(iWorkerArrived < gThreadNum)
-boost::this_thread::sleep(boost::posix_time::milliseconds(10));
+		boost::this_thread::sleep(boost::posix_time::milliseconds(10));
-// now we can safely handle the alias nodes.
+	// now we can safely handle the alias nodes.
-boost::mutex::scoped_lock lock(iMuxTree);
+	boost::mutex::scoped_lock lock(iMuxTree);
-TPlacingSection* p = NULL;
+	TPlacingSection* p = NULL;
-if(!iQueueAliasNode.empty()) {
+	if(!iQueueAliasNode.empty()) {
-p = iQueueAliasNode.front();
+		p = iQueueAliasNode.front();
-iQueueAliasNode.pop();
+		iQueueAliasNode.pop();
-}
+	}
-return p;
+	return p;
 }
 void E32Rofs::ArriveDeferPoint() {
-boost::mutex::scoped_lock lock(iMuxTree);
+	boost::mutex::scoped_lock lock(iMuxTree);
-++iWorkerArrived;
+	++iWorkerArrived;
 }
 TInt E32Rofs::PlaceFiles( TRomNode* /*aRootDir*/, TUint8* aDestBase, TUint aBaseOffset, TInt aCoreSize )
 	//
 	// Traverses all entries placing all files and updating directory entry pointers.
 	// Returns number of bytes placed or -ve error code.
 	//
 	{
+if(iSymGen)
+iSymGen->SetSymbolFileName((const char *)iObey->iRomFileName);
 iLastNode = TRomNode::FirstNode();
 iWorkerArrived = 0;
 boost::thread_group thrds;
 Worker** workers = new Worker*[gThreadNum];
 thrds.add_thread(workers[i]);
 }
 thrds.join_all();
 delete [] workers;
+if(iSymGen)
+iSymGen->AddFile("",false);
 TUint offset = aBaseOffset;
 TUint8* dest = aDestBase;
 TBool aIgnoreHiddenAttrib = ETrue;
 TInt len = iVPS.size();
 if(maxSize <= 0) {
 // Image size is too low to proceed.
 return maxSize;
 }
 if(iVPS[i]->node->iFileStartOffset != (TUint)KFileHidden) {
+if (iVPS[i]->len > maxSize) {
+// Image size is too low to proceed.
+return maxSize - iVPS[i]->len;
+}
 memcpy(dest,iVPS[i]->buf,iVPS[i]->len);
 if(iVPS[i]->node->iEntry->iFileOffset == -1) {
 iVPS[i]->node->iEntry->iFileOffset = offset;
 iVPS[i]->node->iFileStartOffset = iVPS[i]->node->iEntry->iFileOffset;
 }
-TInt E32Rofs::LayoutDirectory( TRomNode* /*aRootDir*/, TUint aBaseOffset )
+//
-	//
+// Creates the directory layout but does not write it to the image.
-	// Creates the directory layout but does not write it to the image.
+// All directories are given a location in the image.
-	// All directories are given a location in the image.
+// Returns the total number of bytes used for the directory (rounded
-	// Returns the total number of bytes used for the directory (rounded
+// up to the nearest word) or a -ve error code.
-	// up to the nearest word) or a -ve error code.
+//
-	//
+TInt E32Rofs::LayoutDirectory( TRomNode* /*aRootDir*/, TUint aBaseOffset )  {
-	{
 	TRomNode* node = TRomNode::FirstNode();
 	TUint offset = aBaseOffset;
-	while( node )
+	while( node ) {
-		{
+		if( node->IsDirectory()) {
-		if( node->IsDirectory())
-			{
 			// it is a directory block so we have to give it a location
 			node->SetImagePosition( offset );
 			// work out how much space it requires for the directory block
 			TInt dirLen;
 			TInt fileLen;
 			TInt err = node->CalculateDirectoryEntrySize( dirLen, fileLen );
-			if( err != KErrNone )
+			if( err != KErrNone ) {
-				{
 				return err;
-				}
+			}
 			Print( ELog, "Directory '%s' @offs=0x%x, size=%d\n", node->iName, offset, dirLen );
 			dirLen += (4-dirLen) & 3;	// round up to next word boundary
 			offset += dirLen;
-			}
+		}
 		node = node->NextNode();
-		}
+	}
 	TInt totalDirectoryBlockSize = offset - aBaseOffset;	// number of bytes used
 	totalDirectoryBlockSize += (4 - totalDirectoryBlockSize) & 3;		// round up
 	// Now go round again placing the file blocks
 	offset = aBaseOffset + totalDirectoryBlockSize;
 	const TUint fileBlockStartOffset = offset;
 	node = TRomNode::FirstNode();
-	while( node )
+	while( node ) {
-		{
+		if( node->IsDirectory() ) {
-		if( node->IsDirectory() )
-			{
 			// work out how much space it requires for the file block
 			TInt dummy;
 			TInt fileLen;
 			TInt err = node->CalculateDirectoryEntrySize( dummy, fileLen );
-			if( err != KErrNone )
+			if( err != KErrNone ) {
-				{
 				return fileLen;
-				}
+			}
-			if( fileLen )
+			if( fileLen ) {
-				{
 				node->SetFileBlockPosition( offset );
 				Print( ELog, "File block for dir '%s' @offs=0x%x, size=%d\n", node->iName, offset, fileLen );
-				}
+			}
 			fileLen += (4-fileLen) & 3;	// round up to next word boundary
 			offset += fileLen;
-			}
+		}
 		node = node->NextNode();
-		}
+	}
 	TInt totalFileBlockSize = offset - fileBlockStartOffset;	// number of bytes used
 	totalFileBlockSize += (4 - totalFileBlockSize) & 3;		// round up
 	iTotalDirectoryBlockSize = totalDirectoryBlockSize;
 	iTotalFileBlockSize = totalFileBlockSize;
 	return totalDirectoryBlockSize + totalFileBlockSize;
-	}
+}
+//
+// Writes the directory into the image.
-TInt E32Rofs::PlaceDirectory( TRomNode* /*aRootDir*/, TUint8* aDestBase )
+// Returns KErrNone on success, or error code
-	//
+//
-	// Writes the directory into the image.
-	// Returns KErrNone on success, or error code
+TInt E32Rofs::PlaceDirectory( TRomNode* /*aRootDir*/, TUint8* aDestBase )  {
-	//
-	{
 	TRomNode* node = TRomNode::FirstNode();
-	while( node )
+	while( node ) {
-		{
+		if( node->IsDirectory() ) {
-		if( node->IsDirectory() )
-			{
 			TInt err = node->Place( aDestBase );
-			if( err != KErrNone )
+			if( err != KErrNone ) {
-				{
 				return err;
-				}
+			}
-			}
+		}
 		node = node->NextNode();
-		}
+	}
 	return KErrNone;
-	}
+}
-TInt E32Rofs::WriteImage( TInt aHeaderType )
+TInt E32Rofs::WriteImage( TInt aHeaderType ) {
-	{
+	ofstream romFile((const char *)iObey->iRomFileName,ios_base::binary);
-	ofstream romFile((const char *)iObey->iRomFileName,ios::binary);
 	if (!romFile)
 		return Print(EError,"Cannot open ROM file %s for output\n",iObey->iRomFileName);
 	Write(romFile, aHeaderType);
 	romFile.close();
+if(iSymGen)
+SymbolGenerator::Release();
 	return KErrNone;
-	}
+}
-TRomNode* E32Rofs::CopyDirectory(TRomNode*& aLastExecutable)
+TRomNode* E32Rofs::CopyDirectory(TRomNode*& aLastExecutable) {
-	{
 	return iObey->iRootDirectory->CopyDirectory(aLastExecutable);
-	}
+}
-void E32Rofs::Write(ofstream &os, TInt aHeaderType)
 // Output a rom image
+void E32Rofs::Write(ofstream &os, TInt aHeaderType) {
-	{
+	switch (aHeaderType) {
-	switch (aHeaderType)
-		{
 	default:
 	case 0:
 		Print(EAlways, "\nWriting Rom image without");
 		break;
 	case 2:
-		Print(EAlways, "\nWriting Rom image with PE-COFF");
+		Print(EAlways, "\nWriting Rom image with PE-COFF"); {
-			{
 			unsigned char coffhead[0x58] = {0};  // zero all the elements
 			// fill in the constant bits
 			// this is supposed to be simple, remember
 			coffhead[1] = 0x0a;
 			// now fill in the text segment size
 			*(TUint32 *) (&coffhead[0x18]) = ALIGN4K(iSizeUsed);
 			*(TUint32 *) (&coffhead[0x40]) = ALIGN4K(iSizeUsed);
 			os.write(reinterpret_cast<char *>(coffhead), sizeof(coffhead));
-			}
+		}
 		break;
-		}
+	}
 	Print(EAlways, " header to file %s\n", iObey->iRomFileName);
 	os.write( iData, iSizeUsed );
-	}
+}
-TRomNode* E32Rofs::RootDirectory()
+TRomNode* E32Rofs::RootDirectory() {
-	{
 	return iObey->iRootDirectory;
-	}
+}
-void E32Rofs::SetRootDirectory(TRomNode* aDir)
+void E32Rofs::SetRootDirectory(TRomNode* aDir) {
-	{
 	iObey->iRootDirectory = aDir;
-	}
+}
-TText* E32Rofs::RomFileName()
+const char* E32Rofs::RomFileName() const  {
-	{
 	return iObey->iRomFileName;
-	}
+}
-TInt E32Rofs::Size()
+TInt E32Rofs::Size() const  {
-	{
 	return iSize;
-	}
+}
 ///////////////////

changeset 590	360bd6b35136
parent 0	044383f39525
child 654	7c11c3d8d025