#include <fstream.h>
#include <strstream.h>
#include <string.h>
#include <elf.h>
#include <sym.h>
#include <symconst.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>

#include "rsp2elf.h"

extern char filenamebuf[256], exenamebuf[256];
extern ifstream lineFile;
extern ofstream ELFfile;
extern int stringTableSize, hasLineInfo;
extern int fileGlobals, fileCount, procCount, labelCount, simplified;
extern char * cwd;
extern char hostName[32];
extern struct stat IMEMstat;
extern source * fileList;
extern unsigned int codeBase;
extern int textSectionSize;
extern int constants;

int lineInfoSize, totalLineCount;
char srcBuf[1024];
long debugInfoOffset;
int debugInfoSize;
struct stat sourceStat;

#define TEXT_SECT 1;
#define STRING_SECT 4

extern symbol * symTable;

HDRR dH;	/* Thankfully, initialized to zero */
FDR fileH;
EXTR startSym;
SYMR fileSym;
PDR procDescriptor;

/*
	The functions in this file write a minimal mdebug block as follows:

	mdebug header
	relative file descriptor ( 1 entry )
	aux table ( 2 entries )
	proc table
	local strings
	global strings
	file table
	local symbols
	global symbols

*/

/************************************************************************
Function: writefail
Args: none
Type: void
Purpose: This function complains about failing to write out the ELF file
	and dies.
************************************************************************/
void writefail( int which )
{
	cerr << "Write failed in WriteDebugInfo, called from " << which
		<< endl;
	exit( 1 );
}

int PutDelta( line * ln, int lastLine )
{
	char li;
	int delta;

	delta = ln->LineIs() - lastLine;
	if ( delta > 7 || delta < -7)	/* need alt form */
	{
		ELFfile.put( 0x80 );	/* long form tag */
		ELFfile.put( (delta >> 8) & 0xff );
		ELFfile.put( ( delta & 0xff ) );
		return 3;
	}
	li = delta << 4;
	ELFfile.put( li );
	return 1;
}

/************************************************************************
Function: WriteDebugInfo
Args: none
Type: void
Purpose: This uncomfortably large function does all the interesting work
	by creating the .mdebug section for the output ELF file. This is
	where debuggers really get all their information. Since this
	information does not really exist except in random places, we
	collect it from all possible sources and synthesize what is missing.
	The resulting ELF file .mdebug section thus contains everything we
	have to say about the microcode.
************************************************************************/
void WriteDebugInfo( void )
{
	int genericInt, symIndex;
	long value;
	long localStrings, globStrings, globSyms, maxExtStringIndex, 
		maxLocalStringIndex, localSyms, fileDesc, procTable,
		lineTable, here;
	symbol * sym;
	source * sfp;
	proc * pro;
	int auxEntry = 0, sibling, procsEncountered = 0;;


	debugInfoOffset = ELFfile.tellp();
	cout << "Writing Debug section at offset " << hex <<
		debugInfoOffset << endl;
	if ( simplified )
		procCount = 1;

	/* Step one - write the debug header */

	dH.magic = 0x7009;
	dH.vstamp = 0x312;
	dH.ifdMax = fileCount;
	dH.ipdMax = procCount;
	dH.iauxMax = 2 * procCount;
	dH.isymMax = 2 * fileCount + 2 * procCount + labelCount + constants;
	if ( simplified )
		++dH.isymMax;	// one extra global for synth

	dH.iextMax = fileGlobals;
	dH.crfd = 1;
	dH.cbRfdOffset = debugInfoOffset + sizeof( HDRR );
	dH.cbAuxOffset = debugInfoOffset + sizeof( HDRR ) + sizeof( int );

	ELFfile.write( (char *) &dH, sizeof( HDRR ) );
	if ( ELFfile.fail() ) writefail(1);
	debugInfoSize = sizeof( HDRR );

	/* make a dummy rfd entry (always follows header) */

	genericInt = 0;
	ELFfile.write( (char *) &genericInt, sizeof( int ) );
	if ( ELFfile.fail() ) writefail(2);
	debugInfoSize += sizeof( int );
	
	/* make a very simple aux table (always follows rfd ) */

	if ( simplified )
	{
		genericInt = fileGlobals + 1;
		ELFfile.write( (char *) &genericInt, sizeof( int ) );
		if ( ELFfile.fail() ) writefail(3);
		genericInt = btVoid << 24;
		ELFfile.write( (char *) &genericInt, sizeof( int ) );
		if ( ELFfile.fail() ) writefail(4);
		debugInfoSize += 2 * sizeof( int );
	}
	else	// write two aux records for each proc
	{
		sfp = fileList;
		while ( sfp )
		{
			int relativeAux;

			sfp->AsgAuxBase( auxEntry );
			relativeAux = 0;
			sibling = 1;	// skip entry for the file start symbol
			pro = sfp->GetProcs();
			while ( pro )
			{
				int labels;

				++sibling;	// skip entry for proc start
				labels = 0;
				pro->AsgAux( relativeAux );
				auxEntry += 2;
				relativeAux += 2;
				sym = pro->GetLabels();
				while ( sym )
				{
					++labels;
					sym = sym->pnext;
				}
				genericInt = sibling + labels;
				sibling = genericInt + 1;	// skip over proc end
				ELFfile.write( (char *) &genericInt, sizeof( int ) );
				if ( ELFfile.fail() ) writefail(3);
				genericInt = btVoid << 24;
				ELFfile.write( (char *) &genericInt, sizeof( int ) );
				if ( ELFfile.fail() ) writefail(4);
				debugInfoSize += 2 * sizeof( int );
				pro = pro->next;
			}
			sfp = sfp->next;
		}
	}

	/* Write line info as a function of proc and file info */

	lineTable = ELFfile.tellp();
	if ( hasLineInfo )
	{
		line * ln;
		int lastLine, lineBytes;

		sfp = fileList;
		while ( sfp )
		{
			int size;

			lineBytes = 0;
			sfp->AsgLineBase( lineInfoSize );
			pro = sfp->GetProcs();
			while ( pro )
			{
				ln = pro->GetLines();
				if ( ln )
				{
					lastLine = ln->LineIs();
					pro->AsgLineIndex( lineInfoSize );
				}
				while( ln )
				{
					size = PutDelta( ln, lastLine );
					lineInfoSize += size;
					lineBytes += size;
					lastLine = ln->LineIs();
					ln = ln->next;
					sfp->OneMoreLine();
				}
				pro = pro->next;
			}
			ln = sfp->GetLines();
			if ( ln )
				lastLine = ln->LineIs();
			while ( ln )
			{
				size = PutDelta( ln, lastLine );
				lineInfoSize += size;
				lineBytes += size;
				lastLine = ln->LineIs();
				ln = ln->next;
			}
			sfp->AsgLineBytes( lineBytes );	/* save it */
			sfp = sfp->next;
		}
		genericInt = lineInfoSize;
		while ( genericInt & 3 )
		{
			ELFfile.put( 0 );
			++genericInt;
		}
	}

	/* We also need some local strings information */

	localStrings = ELFfile.tellp();
	stringTableSize = 0;
	sfp = fileList;

	/*
		Write out the file names - the first one gets all the
		information on symbols. The others just get name records.
		We specify the host and name of each file, the time of
		creating of the object (IMEM), and the size of each source
		file if we can stat it.
	*/

	while ( sfp )
	{
		ostrstream fileDate( srcBuf, sizeof( srcBuf ) );

		sfp->AsgStringIndex( stringTableSize );
		WriteString( "" );
		WriteString( sfp->filename() );
		WriteString( "</4Debug/>" );
		WriteString( strcat( strcat( strcat( strcat( strcpy( srcBuf, hostName ),
		 ":" ), cwd ), "/" ), sfp->filename() ) );
		fileDate << IMEMstat.st_mtime << '\0';
		WriteString( srcBuf );
		if ( stat( sfp->filename(), &sourceStat ) )
		{
			cerr << "WARNING: Couldn't stat file " <<
				sfp->filename() << endl;
			WriteString( "0" );
		}
		else
		{
			ostrstream fileSize( srcBuf, sizeof( srcBuf ) );
			fileSize << sourceStat.st_size << '\0';
			WriteString( srcBuf );
		}

		/*
			In the simplified case, we create a string for
			each file, plus a string for each global. In the
			proc oriented case, we create strings for not
			only the file, but for each proc in it and for
			each label in the proc. We do not, however, create
			strings for the globals in this string table.
		*/

		if ( simplified )
		{
			// If this is the first file, write out the globals

			if ( sfp == fileList )
			{
				sym = symTable;
				while ( sym )
				{
					sym->AsgLocalIndex( stringTableSize -
						sfp->StringIndexIs() );
					WriteString( sym->NameIs() );
					sym = sym->next;
				}
			}
		}
		else
		{
			pro = sfp->GetProcs();
			while ( pro )
			{
				pro->AsgLocalIndex( stringTableSize - 
					sfp->StringIndexIs() );
				WriteString( pro->nameIs() );
				sym = pro->GetLabels();
				while ( sym )
				{
					sym->AsgLocalIndex( stringTableSize - 
						sfp->StringIndexIs() );
					WriteString( sym->NameIs() );
					sym = sym->pnext;
				}
				pro = pro->next;
			}

			// Now write out any orphan symbols (those without procs)

	                sym = sfp->GetLabels();
			while ( sym )
			{
				sym->AsgLocalIndex( stringTableSize - 
					sfp->StringIndexIs() );
				WriteString( sym->NameIs() );
				sym = sym->pnext;
			}
		}
		sfp->AsgStringSize( stringTableSize - sfp->StringIndexIs() );
		sfp = sfp->next;
	}

	while ( stringTableSize & 3 )
		WriteString( "" );	/* should be even */
	debugInfoSize += stringTableSize;
	maxLocalStringIndex = stringTableSize;

	/* We also need some global strings information */

	globStrings = ELFfile.tellp();
	stringTableSize = 0;
	WriteString( "" );
	sym = symTable;
	while ( sym )
	{
		sym->AsgGlobalIndex( stringTableSize );
		WriteString( sym->NameIs() );
		sym = sym->next;
	}
	while ( stringTableSize & 3 )
		WriteString( "" );	/* should be even */
	debugInfoSize += stringTableSize;
	maxExtStringIndex = stringTableSize;

	/********************************/
	/* Local symbols section	*/
	/********************************/

	localSyms = ELFfile.tellp();
	sfp = fileList;
	symIndex = 0;
	while ( sfp )
	{
		sfp->AsgFirstSym( symIndex );
		fileSym.iss = 1;	/* relative to base, so always 1 */
		fileSym.st = stFile;
		fileSym.sc = scText;
		fileSym.value = sfp->FirstInst();
		if ( simplified )
		{
			if ( sfp == fileList )
				fileSym.index = 3 + fileGlobals;
			else
				fileSym.index = 2;
		}
		else
			fileSym.index = 2 + 2 * sfp->ProcCountIs() + 
				sfp->LabelCountIs();
		ELFfile.write( (char *) &fileSym, sizeof( SYMR ) );
		if ( ELFfile.fail() ) writefail(0);
		debugInfoSize += sizeof( SYMR );
		++symIndex;
		
		/*
			Now write out the symbols for the procs. For
			the simplified case, there is only the synth proc.
			It contains all the local symbols inside the proc.
			For the general case, there are procs per file and
			each contains labels.
		*/

		if ( simplified )
		{
			if ( sfp == fileList )
			{
				sym = symTable;
				while ( sym )
				{
					fileSym.iss = sym->GetLocalIndex();
					fileSym.sc = scText;
					if ( sym == symTable )	// is synth
					{
						fileSym.st = stProc;
						fileSym.index = 0;	// only one aux
					}
					else
					{
						fileSym.st = sym->GetType();
						if ( fileSym.st == stConstant )
							fileSym.sc = scInfo;
						fileSym.index = (unsigned) -1;
					}
					fileSym.value = sym->GetValue();
					ELFfile.write( (char *) &fileSym, sizeof( SYMR ) );
					if ( ELFfile.fail() ) writefail(0);
					debugInfoSize += sizeof( SYMR );
					sym->AsgSymIndex( symIndex );
					++symIndex;
					sym = sym->next;
				}

				// Write the end of proc symbol

				fileSym.iss = symTable->GetLocalIndex();
				fileSym.st = stEnd;
				fileSym.sc = scText;
				fileSym.value = textSectionSize;
				fileSym.index = 1;				
				ELFfile.write( (char *) &fileSym, sizeof( SYMR ) );
				if ( ELFfile.fail() ) writefail(0);
				debugInfoSize += sizeof( SYMR );
				++symIndex;
			}
		}
		else
		{
			pro = sfp->GetProcs();
			while ( pro )
			{
				long procStartIndex;
				long procSymIndex;

				pro->AsgFirstSym( symIndex );

				// Write start of proc symbol

				procStartIndex = fileSym.iss = pro->GetStringIndex();
				fileSym.st = stProc;
				fileSym.sc = scText;
				fileSym.value = pro->FirstInst();
				fileSym.index = pro->GetAux();
				ELFfile.write( (char *) &fileSym, sizeof( SYMR ) );
				if ( ELFfile.fail() ) writefail(0);
				debugInfoSize += sizeof( SYMR );
				pro->AsgSymIndex( symIndex );
				procSymIndex = symIndex - sfp->FirstSymIs();
				++symIndex;

				// Write out any local labels for this proc

				sym = pro->GetLabels();
				while ( sym )
				{
					fileSym.iss = sym->GetLocalIndex();
					fileSym.st = stLabel;
					fileSym.sc = scText;
					fileSym.value = sym->GetValue();
					fileSym.index = (unsigned) -1;
					ELFfile.write( (char *) &fileSym, sizeof( SYMR ) );
					if ( ELFfile.fail() ) writefail(0);
					debugInfoSize += sizeof( SYMR );
					sym->AsgSymIndex( symIndex );
					++symIndex;
					sym = sym->pnext;
				}

				// Write end of proc symbol

				fileSym.iss = procStartIndex;
				fileSym.st = stEnd;	/* of proc */
				fileSym.sc = scText;
				fileSym.value = pro->NextInst() - pro->FirstInst();
				fileSym.index = procSymIndex;
				ELFfile.write( (char *) &fileSym, sizeof( SYMR ) );
				if ( ELFfile.fail() ) writefail(0);
				debugInfoSize += sizeof( SYMR );
				++symIndex;

				pro = pro->next;
			}

			// Write out any orphan symbols for this file

			sym = sfp->GetLabels();
			while ( sym )
			{
				fileSym.iss = sym->GetLocalIndex();
				fileSym.st = stLabel;
				fileSym.sc = scText;
				fileSym.value = sym->GetValue();
				fileSym.index = (unsigned) -1;
				ELFfile.write( (char *) &fileSym, sizeof( SYMR ) );
				if ( ELFfile.fail() ) writefail(0);
				debugInfoSize += sizeof( SYMR );
				sym->AsgSymIndex( symIndex );
				++symIndex;
				sym = sym->pnext;
			}
		}

		// Write out the end of file symbol

		fileSym.iss = 1;
		fileSym.st = stEnd;	/* of file */
		fileSym.sc = scText;
		fileSym.value = sfp->NextInst() - sfp->FirstInst();
		fileSym.index = 0;
		ELFfile.write( (char *) &fileSym, sizeof( SYMR ) );
		if ( ELFfile.fail() ) writefail(0);
		debugInfoSize += sizeof( SYMR );
		symIndex++;

		sfp = sfp->next;
	}

	/********************************/
	/* Global symbols section	*/
	/********************************/

	globSyms = ELFfile.tellp();
	sym = symTable;
	while ( sym )
	{
		startSym.asym.iss = sym->GetGlobalIndex();
		startSym.asym.st = sym->GetType();
		startSym.asym.sc = sym->GetType() == stConstant ? scInfo : scText;
		startSym.asym.value = sym->GetValue();
		startSym.asym.index = sym->GetType() == stConstant ? -1 : 
			sym->GetSymIndex();
		if ( !startSym.asym.index )	// can't be 0
			startSym.asym.index = (unsigned) -1;
		if ( startSym.asym.st == stProc || startSym.asym.st == stLabel )
		{
			if ( simplified )
			{
				startSym.ifd = 0;
			}
			else
			{
				startSym.ifd = 
					GetFileOfAddr( sym->GetValue() );
				startSym.asym.index = startSym.asym.index - SymBaseOfFile( startSym.ifd );
//				startSym.asym.index -= 
//					SymBaseOfFile( startSym.ifd );
			}
		}
		else
			startSym.ifd = 0;
		if ( startSym.ifd == -1 )
		{
			// label symbol not in range, make it into a const

			startSym.asym.st = stConstant;
			startSym.asym.sc = scInfo;
			startSym.asym.index = (unsigned) -1;
			startSym.ifd = 0;
		}
		ELFfile.write( (char *) &startSym, sizeof( EXTR ) );
		if ( ELFfile.fail() ) writefail(0);
		debugInfoSize += sizeof( EXTR );
		sym = sym->next;
	}

	/********************************/
	/* Procedure info section	*/
	/********************************/

	procTable = ELFfile.tellp();
	sfp = fileList;
	while ( sfp )
	{
		pro = sfp->GetProcs();
		while ( pro )
		{
			procDescriptor.adr = pro->FirstInst();
			procDescriptor.lnLow = pro->FirstLine();
			procDescriptor.lnHigh = pro->LastLine();
			if ( simplified )
			{
				procDescriptor.iline = -1;
				procDescriptor.isym = 1;
			}
			else
			{
				procDescriptor.iline = pro->GetLineIndex()
					- sfp->LineBaseIs();
				procDescriptor.isym = pro->GetFirstSym() -
					sfp->FirstSymIs();	// rel to file
			}
			ELFfile.write( (char *) &procDescriptor, sizeof( PDR ) );
			if ( ELFfile.fail() ) writefail(0);
			debugInfoSize += sizeof( PDR );
			pro = pro->next;
		}
		sfp = sfp->next;
	}

	/********************************/
	/* File descriptor section	*/
	/********************************/

	fileDesc = ELFfile.tellp();
	sfp = fileList;
	while ( sfp )
	{
		fileH.adr = sfp->FirstInst();
		fileH.rss = 1;
		fileH.issBase = sfp->StringIndexIs();
		fileH.cbSs = sfp->StringSizeIs();
		if ( simplified )
		{
			if ( sfp == fileList )
			{
				fileH.csym = 3 + fileGlobals;
				fileH.cpd = 1;
				fileH.caux = 2;
			}
			else
			{
				fileH.csym = 2;
				fileH.cpd = 0;
				fileH.caux = 0;
			}
		}
		else
		{
			fileH.csym = 2 + 2 * sfp->ProcCountIs() + 
				sfp->LabelCountIs();
			fileH.cpd = sfp->ProcCountIs();
			fileH.caux = 2 * sfp->ProcCountIs();
			fileH.iauxBase = fileH.caux ? // there were procs
				sfp->GetAuxBase() : 0;
			fileH.ipdFirst = procsEncountered;
			procsEncountered += sfp->ProcCountIs();
		}
		fileH.isymBase = sfp->FirstSymIs();
		fileH.fBigendian = 1;
		fileH.crfd = 0;
		fileH.lang = langAssembler;
		totalLineCount += sfp->LineCountIs();
		if ( fileH.cpd )	// tell about lines
		{
			fileH.cline = sfp->LineCountIs();
			fileH.cbLine = sfp->LineBytesIs();
			fileH.cbLineOffset = sfp->LineBaseIs();
			fileH.ilineBase = sfp->LineBaseIs();
		}
		else
			fileH.cline = fileH.cbLine = fileH.cbLineOffset = 
				fileH.ilineBase = 0;
		ELFfile.write( (char *) &fileH, sizeof( FDR ) );
		if ( ELFfile.fail() ) writefail(0);
		debugInfoSize += sizeof( FDR );
		sfp = sfp->next;
	}

	here = ELFfile.tellp();

	/* for local strings section, write size and addr */

	value = (char *) &dH.issMax - (char *) &dH;
	ELFfile.seekp( debugInfoOffset + value );
	ELFfile.write( (char *) &maxLocalStringIndex, 4 );
	if ( ELFfile.fail() ) writefail(0);
	ELFfile.write( (char *) &localStrings, 4 );
	if ( ELFfile.fail() ) writefail(0);

	/* for global strings section, write size and addr */

	value = (char *) &dH.issExtMax - (char *) &dH;
	ELFfile.seekp( debugInfoOffset + value );
	ELFfile.write( (char *) &maxExtStringIndex, 4 );
	if ( ELFfile.fail() ) writefail(0);
	ELFfile.write( (char *) &globStrings, 4 );
	if ( ELFfile.fail() ) writefail(0);

	/* point to global symbols section */

	value = (char *) &dH.cbExtOffset - (char *) &dH;
	ELFfile.seekp( debugInfoOffset + value );
	ELFfile.write( (char *) &globSyms, 4 );
	if ( ELFfile.fail() ) writefail(0);

	/* point to local symbols section */

	value = (char *) &dH.cbSymOffset - (char *) &dH;
	ELFfile.seekp( debugInfoOffset + value );
	ELFfile.write( (char *) &localSyms, 4 );
	if ( ELFfile.fail() ) writefail(0);

	/* point to file descriptor */

	value = (char *) &dH.cbFdOffset - (char *) &dH;
	ELFfile.seekp( debugInfoOffset + value );
	ELFfile.write( (char *) &fileDesc, 4 );
	if ( ELFfile.fail() ) writefail(0);

	/* point to proc table */

	value = (char *) &dH.cbPdOffset - (char *) &dH;
	ELFfile.seekp( debugInfoOffset + value );
	ELFfile.write( (char *) &procTable, 4 );
	if ( ELFfile.fail() ) writefail(0);

	/* point to line table */

	value = (char *) &dH.ilineMax - (char *) &dH;
	ELFfile.seekp( debugInfoOffset + value );
	ELFfile.write( (char *) &totalLineCount, 4 );
	if ( ELFfile.fail() ) writefail(0);
	ELFfile.write( (char *) &lineInfoSize, 4 );
	if ( ELFfile.fail() ) writefail(0);
	ELFfile.write( (char *) &lineTable, 4 );
	if ( ELFfile.fail() ) writefail(0);
	ELFfile.seekp( here );
}