// Copyright (c) 2000-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

#include "analyse.h"

#include "trace.h"

#include "tracer.h"

#include "distribution.h"

#include "activity.h"

#include "nonxip.h"

#ifdef __MSVCDOTNET__

#include <strstream>

#include <iomanip>

#else //!__MSVCDOTNET__

#include <strstrea.h>

#include <iomanip.h>

#endif //__MSVCDOTNET__

#include <ctype.h>

Analyse::TAction Analyse::sAction;

Analyse::TFormat Analyse::sFormat;

Analyse::TPartition Analyse::sPartition;

int Analyse::sOptions;

std::vector<const char*> Analyse::sTraces;

const char* Analyse::sRomFile;

const char* Analyse::sThread;

const char* Analyse::sDll;

const char* Analyse::sFunction;

unsigned Analyse::sBase;

unsigned Analyse::sLim;

unsigned Analyse::sBuckets = 100;

unsigned Analyse::sBucketSize;

double Analyse::sCutOff;

unsigned Analyse::sBeginSample;

unsigned Analyse::sEndSample = 0xffffffffu;

NonXIP gNonXIP; // 

//namespace {

void PartitionByDll::File(const char* aName)

	{

	iCurrentFile = aName;

	}

bool PartitionByDll::Symbol(const char*, PC aPc, int)

	{

	bool is_added = false;

	if (iCurrentFile)

		{

		if (iLastFile && Analyse::Match(iLastFile, iMatch))

			{

			Add(iLastFileAddress, aPc, iLastFile);

			is_added = true;

			}

		iLastFile = iCurrentFile;

		iLastFileAddress = aPc;

		iCurrentFile = 0;

		}

	return is_added;

	}

PartitionByFunction::PartitionByFunction(const char* aFile, const char* aFunction)

	:iFile(aFile), iFunction(aFunction), iActive(false)

	{}

void PartitionByFunction::File(const char* aName)

	{

	iActive = Analyse::Match(aName, iFile);

	}

bool PartitionByFunction::Symbol(const char* aSymbol, PC aPc, int aLength)

	{

	bool is_added = false;

	if (iActive && Analyse::Match(aSymbol, iFunction))

		{

		Add(aPc, aPc + aLength, aSymbol);

		is_added = true;

		}

	return is_added;

	}

class FindFunction : public SymbolFile::Parser

	{

public:

	FindFunction(const char* aFile, const char* aFunction);

	void File(const char* aName);

	bool Symbol(const char* aName, PC aPc, int aLength);

	void Done(PC aFirstPc=0, PC aLastPc=0, int aModuleId=0);

private:

	const char* iFile;

	const char* iFunction;

	bool iActive;

public:

	PC iPc;

	int iLength;

	};

FindFunction::FindFunction(const char* aFile, const char* aFunction)

	:iFile(aFile), iFunction(aFunction), iActive(false), iPc(0)

	{}

void FindFunction::File(const char* aName)

	{

	if (iPc == 0)

		iActive = Analyse::Match(aName, iFile);

	}

bool FindFunction::Symbol(const char* aSymbol, PC aPc, int aLength)

	{

	bool is_added = false;

	if (iPc == 0 && iActive && Analyse::Match(aSymbol, iFunction))

		{

		iPc = aPc;

		iLength = aLength;

		is_added = true;

		}

	return is_added;

	}

void FindFunction::Done(PC aFirstPc, PC aLastPc, int aModuleId)

	{}

//};	// local namepsace

// entry point

int main(int argc,char *argv[])

	{

	switch(Analyse::ProcessCommandLine(argc,argv))

		{

	case 1:

		Analyse::ExplainUsage();

		return 1;

	case 2:

		Analyse::ExplainConfigUsage();

		return 1;

		}

	Analyse::Run();

	return 0;

	}

// Class Analyse

void Analyse::Information()

	{

	cout << "\nEPOC Profile Analyser   Version " << MajorVersion << '.' \

		<< setw(2) << MinorVersion << "(build " << setw(3) << setfill('0') << Build \

		<< ")\nCopyright (c) Symbian Limited 2000. All rights reserved.\n\n" << flush;

	}

void Analyse::ExplainUsage()

	{

	Information();

	cout << "Usage:  Analyse [options] tracefile\n" \

			" -h            display this information\n" \

			" -l            generate a trace listing\n" \

			" -p            generate a profile distribution\n" \

			" -v            generate a activity trace\n" \

			" -r <symbols>  supply a Rom symbol file\n" \

			" -s<range>     restrict the profile to the samples specified\n" \

			"               This is specified either as <start>-<end> or\n" \

			"               as <start>+<length> in decimal\n" \

			" -n            include NULL thread\n" \

			" -t <thread>   profile threads matching the pattern\n" \

			" -d <dll>      profile DLL (or EXE) matching the pattern\n" \

			" -f <function> profile the function matching the pattern\n" \

			" -a<range>     profile the address range specified\n" \

			"               This is specified either as <start>-<end> or\n" \

			"               as <start>+<length> in hexadecimal\n" \

			" -bd           partition the profile by dll/exe\n" \

			" -bf           partition the profile by function\n" \

			" -bs<n>        partition the profile into buckets of size n\n" \

			" -bn<n>        partition the profile into approx. n buckets\n" \

			" -c<n>         set the cutoff value for discarding output\n" \

			" -m...         setformat options:\n" \

			"   p|s|x       use percentages/samples/excel for output\n" \

			"   z           output zero values instead of blanks\n" \

			"   t           do not show thread break-down\n" \

			"   o           do not include the <other> bucket\n" \

			" -z <rofs>     supply a ROFS symbol file\n" \

			" -o <oby>      supply an OBY file\n" \

			" -x <config>   supply a config file\n" \

			" -h config     display an example of config file\n" \

			<< flush;

	}

void Analyse::ExplainConfigUsage()

	{

	Information();

	cout << "Example of config file:"		<< endl	<< endl;

	cout << "[Common]"								<< endl;

	cout << "TraceFile=PROFILER.DAT"				<< endl;

	cout << "Mode=listing|profile|activity"			<< endl;

	cout << "SymbolFile=core4r.bin.symbol"			<< endl;

	cout << "Range=100-200 | 100+100"				<< endl;

	cout << "IncludeNullThread=0|1"					<< endl;

	cout << "[Profile]"								<< endl;

	cout << "Thread="								<< endl;

	cout << "Dll="									<< endl;

	cout << "Function="								<< endl;

	cout << "Range=1f1a+20 | 1f1a-1f3a"				<< endl;

	cout << "[Partition]"							<< endl;

	cout << "Mode=dll|function"						<< endl;

	cout << "BucketSize="							<< endl;

	cout << "NumberOfBuckets="						<< endl;

	cout << "[Format]"								<< endl;

	cout << "Mode=percentages|samples|excel"		<< endl;

	cout << "ZeroValues=0|1"						<< endl;

	cout << "NoOthers=0|1"							<< endl;

	cout << "TotalOnly=0|1"							<< endl;

	cout << "[NonXIP]"								<< endl;

	cout << "ObyFile1=myrofs.oby"					<< endl;

	cout << "RofsSymbolFile1=rofs.bin.symbol"		<< endl;

	cout << flush;

	}

class Options

	{

	struct Entry

		{

		const char* iName;

		int iOption;

		};

	const static Entry KOptions[];

	static int Compare(const char* aLhs, const char* aRhs);

public:

	static int Get(istrstream& aStr);

	};

const Options::Entry Options::KOptions[] = 

	{

	{"activity",'v'},

	{"address",	'a'},

	{"by",		'b'},

	{"cutoff",	'c'},

	{"dll",		'd'},

	{"excel",	'x'},

	{"format",	'm'},

	{"function",'f'},

	{"help",	'h'},

	{"listing",	'l'},

	{"null",	'n'},

	{"number",	'n'},

	{"other",	'o'},

	{"percent",	'p'},

	{"profile",	'p'},

	{"rom",		'r'},

	{"samples",	's'},

	{"size",	's'},

	{"thread",	't'},

	{"total",	't'},

	{"zero",	'z'},

	{"oby",		'o'},

	{"rofs",	'z'},

	{"config",	'x'},

	};

inline int min(int a, int b)

	{

	return a < b ? a : b;

	}

int Options::Compare(const char* aLhs, const char* aRhs)

	{

	int len = min(strlen(aLhs), strlen(aRhs));

	return strnicmp(aLhs, aRhs, len);

	}

int Options::Get(istrstream& aStr)

	{

	int pos = aStr.tellg();

	const char* s = aStr.str() + pos;

	if (strlen(s) >= 3)

		{

		int l = 0, r = sizeof(KOptions)/sizeof(KOptions[0]);

		do

			{

			int m = (l + r ) >> 1;

			const Entry& e = KOptions[m];

			int k = Compare(s, e.iName);

			if (k < 0)

				r = m;

			else if (k > 0)

				l = m + 1;

			else

				{

				// found a match

				aStr.ignore(strlen(e.iName));

				return e.iOption;

				}

			} while (l < r);

		}

	// no match

	return aStr.get();

	}

int Analyse::ProcessCommandLine(int argc, char ** argv)

	{

	int initial_argc = argc;

	char ** initial_argv = argv;

	// added 2-nd pass. on the 1-st just look for config file

	for(int pass = 0;pass < 2;pass++)

		{

		argc = initial_argc;

		argv = initial_argv;

		while (--argc>0)

			{

			istrstream arg(*++argv);

			int c = arg.get();

			if (c != '/' && c != '-')

				{

				if (pass == 0) continue;

				sTraces.clear();

				sTraces.push_back(arg.str());

				continue;

				}

			c = Options::Get(arg);

			if (tolower(c) != 'x' && pass == 0)

				continue;

			switch (c)

				{

			case 'h': case 'H': case '?':

				if (--argc > 0 && !stricmp(*++argv,"config")) 

					return 2;

				return 1;

			case 'l': case 'L':

				sAction = ETrace;

				break;

			case 'p': case 'P':

				sAction = EProfile;

				break;

			case 'v': case 'V':

				sAction = EActivity;

				break;

			case 'r': case 'R':

				if (--argc == 0)

					Abort("No symbol file specified for option '-r'");

				sRomFile = *++argv;

				break;

			case 's': case 'S':

				sOptions |= ERange;

				arg >> sBeginSample;

				c = arg.get();

				arg >> sEndSample;

				if (c == '+')

					sEndSample += sBeginSample;

				else if (c != '-')

					return 1;

				break;

			case 'n': case 'N':

				sOptions|=ENull;

				break;

			case 't': case 'T':

				if (--argc == 0)

					Abort("No thread name specified for option '-t'");

				sThread = *++argv;

				break;

			case 'd': case 'D':

				if (--argc == 0)

					Abort("No DLL name specified for option '-d'");

				sDll = *++argv;

				break;

			case 'f': case 'F':

				if (--argc == 0)

					Abort("No function name specified for option '-f'");

				sFunction = *++argv;

				break;

			case 'a': case 'A':

				sOptions |= EAddress;

				arg >> hex >> sBase;

				c = arg.get();

				arg >> hex >> sLim;

				if (c == '+')

					sLim += sBase;

				else if (c != '-')

					return 1;

				break;

			case 'b': case 'B':

				switch (c = Options::Get(arg))

					{

				case 'd': case 'D':

					sPartition = EDll;

					break;

				case 'f': case 'F':

					sPartition = EFunction;

					break;

				case 'n': case 'N':

					sPartition = EBuckets;

					arg >> dec >> sBuckets;

					break;

				case 's': case 'S':

					sPartition = ESize;

					arg >> dec >> sBucketSize;

					break;

					}

				break;

			case 'c': case 'C':

				arg >> sCutOff;

				break;

			case 'm': case 'M':

				while ((c = Options::Get(arg)) != EOF)

					{

					switch (c)

						{

					case 'p': case 'P':

						sFormat = EPercent;

						break;

					case 's': case 'S':

						sFormat = ESamples;

						break;

					case 'x': case 'X':

						sFormat = EExcel;

						break;

					case 'z': case 'Z':

						sOptions |= EZeros;

						break;

					case 'o': case 'O':

						sOptions |= ENoOther;

						break;

					case 't': case 'T':

						sOptions |= ETotalOnly;

						break;

					default:

						arg.putback(c);

						break;

						}

					}

				break;

			case 'o': case 'O':

				if (--argc == 0)

					Abort("No OBY file name specified for option '-o'");

				gNonXIP.AddObyFile(*++argv);

				break;

			case 'z': case 'Z':

				if (--argc == 0)

					Abort("No ROFS symbol file name specified for option '-z'");

				gNonXIP.AddSymbolFile(*++argv);

				break;

			case 'x': case 'X':

				if (--argc == 0)

					Abort("No config file name specified for option '-x'");

				if (pass == 0)

					{

					switch(ProcessCfgFile(*++argv))

						{

					case ENoCfgFile:

						Abort("Error no config file name specified for option '-x'");

					case EErrorCfgFile:

						Abort("Error in config file");

						}

					}

				else

					++argv;

				break;

			default:			// unrecognised option

				arg.putback(c);

				break;

				}

			if (!arg || arg.get() != EOF)

				{

				cerr << "Unrecognised option \'" << arg.str() << '\'' << endl;

				Abort();

				}

			} // while

		} // for(pass)

	if (sTraces.empty())

		Abort("No trace files specified");

	return sTraces.size() != 1;

	}

CodeSpace* Analyse::CreateCodeSpace(SymbolFile* aSymbols, NonXIP *aNonXIP)

	{

	if (Option(EAddress))

		{

		unsigned size;

		if (Partition() == ESize)

			size = sBucketSize;

		else

			size = (sLim - sBase) / sBuckets;

		return new AddressCodeSpace(sBase, sLim, size, AddressCodeSpace::EAbsolute);

		}

	MappedCodeSpace * mapped_code_space = 0;

	if (aSymbols == 0)

		{

		MappedCodeSpace* mapped_code_space =  new MappedCodeSpace();

		if (aNonXIP) 

			aNonXIP->SetMappedCodeSpace(mapped_code_space);

		return mapped_code_space;

		}

	for (;;)

		{

		switch (Partition())

			{

		case EDefault:

			if (sFunction != 0)

				{

				sPartition = ESize;

				sBucketSize = 4;

				}

			else if (sDll != 0)

				sPartition = EFunction;

			else

				sPartition = EDll;

			break;

		case EDll:

			{

			PartitionByDll p(sDll);

			mapped_code_space =  new MappedCodeSpace(*aSymbols,p);

			if (aNonXIP) 

				aNonXIP->SetMappedCodeSpace(mapped_code_space);

			return mapped_code_space;

			}

		case EFunction:

			{

			PartitionByFunction p(sDll, sFunction);

			mapped_code_space =  new MappedCodeSpace(*aSymbols,p);

			if (aNonXIP) 

				aNonXIP->SetMappedCodeSpace(mapped_code_space);

			return mapped_code_space;

			}

		case ESize:

		case EBuckets:

			if (sFunction == 0)

				sPartition = EFunction;

			else

				{

				FindFunction f(sDll, sFunction);

				aSymbols->Parse(f);

				if (f.iPc == 0)

					{

					cerr << "Cannot find function '" << sFunction << '\'';

					if (sDll)

						cerr << " in '" << sDll << '\'';

					cerr << endl;

					Abort();

					}

				unsigned size = (Partition() == ESize) ? sBucketSize : f.iLength / sBuckets;

				return new AddressCodeSpace(f.iPc, f.iPc + f.iLength, size, AddressCodeSpace::ERelative);

				}

			break;

			}

		}

	}

Sampler* Analyse::CreateSampler(SymbolFile* aSymbols, NonXIP *aNonXIP)

	{

	switch (Action())

		{

	case ETrace:

		{

		MappedCodeSpace * mapped_code_space = 0;

		if (aSymbols == 0)

			//return new Tracer(0);

			mapped_code_space = new MappedCodeSpace();

		else

			{

			PartitionByFunction p(0, 0);

			mapped_code_space = new MappedCodeSpace(*aSymbols,p);

			}

		if (aNonXIP) aNonXIP->SetMappedCodeSpace(mapped_code_space);

		return new Tracer(mapped_code_space);

		}

	case EProfile:

		{

		CodeSpace * code_space = CreateCodeSpace(aSymbols, aNonXIP);

		return new Distribution(*code_space, sCutOff);

		}

	case EActivity:

		return new Activity(Partition() == ESize ? sBucketSize : 100, sBeginSample, sCutOff);

		}

	return 0;

	}

void Analyse::Run()

//

// The main part of the program

//

	{

	Information();

	Trace trace;

	trace.Load(sTraces[0], sBeginSample, sEndSample);

	// create map of original/segment names

	gNonXIP.CreateNamesMap();

	SymbolFile* symbols = 0;

	if (sRomFile)

		symbols = new SymbolFile(sRomFile);

	Sampler* sampler = CreateSampler(symbols, &gNonXIP);

	trace.Decode(*sampler, &gNonXIP);

	// NonXIP footer messages

	cout << endl << "Row buffer errors:" << gNonXIP.iRowBufferErrors;

	cout << " Cook buffer errors:" << gNonXIP.iCookBufferErrors;

	cout << "  Mode:";

	if (gNonXIP.iReportMask & NonXIP::ENonXip)

		cout << "NonXIP";

	else

		cout << "XIP only";

	if (gNonXIP.iReportMask & NonXIP::ENodebugSupport)

		cout << " No debug support from Kernel";

	cout << endl;

	cout << flush;

	}

bool Analyse::Match(const char* aString, const char* aMatch)

//

// Wildcard matching

// If match string is 0, then matches everything

//

	{

	if (aMatch == 0)

		return true;

	const char* star = strchr(aMatch, '*');

	if (star == 0)

		return (stricmp(aString, aMatch) == 0);

	int mlen = star - aMatch;

	if (strnicmp(aString, aMatch, mlen) != 0)

		return false;

	const char* end = aString + strlen(aString);

	for (;;)

		{

		aString += mlen;

		aMatch += mlen + 1;

		star = strchr(aMatch, '*');

		if (star == 0)

			return (stricmp(end - strlen(aMatch), aMatch) == 0);

		mlen = star - aMatch;

		const char* lim = end - mlen;

		for (;;)

			{

			if (aString > lim)

				return false;

			if (strnicmp(aString, aMatch, mlen) == 0)

				break;

			++aString;

			}

		}

	}

void Analyse::Abort(char const* aMessage)

	{

	cerr << aMessage << endl;

	Abort();

	}

void Analyse::Abort()

	{

	exit(3);

	}

void Analyse::Corrupt(char const* aMessage)

//

// terminate after detecting a fatal corruption error

//

	{

	cerr << "\nfatal error: " << aMessage << "\ncannot continue\n" << flush;

	exit(2);

	}

ostream& Analyse::Error()

	{

	return cerr << "error: ";

	}

ostream& Analyse::Warning()

	{

	return cerr << "warning: ";

	}