[mirror_edk2.git] / Tools / CCode / Source / GenFvMap / GenFvMap.cpp

//****************************************************************************\r
//**\r
//**  Copyright  (C) 2006 Intel Corporation. All rights reserved.\r
//**\r
//** The information and source code contained herein is the exclusive\r
//** property of Intel Corporation and may not be disclosed, examined\r
//** or reproduced in whole or in part without explicit written authorization\r
//** from the company.\r
//**\r
//****************************************************************************\r
#include "ProcessorBind.h"\r
#include <iostream>\r
#include <stdexcept>\r
#include <list>\r
#include <map>\r
#include <vector>\r
#include <iomanip>\r
#include <fstream>\r
#include <sstream>\r
#include <string>\r
#include <utility>\r
#include <algorithm>\r
#include <functional>\r
using namespace std;\r
\r
typedef UINT64 ulonglong_t;\r
\r
#ifdef __GNUC__\r
#if __STDC_VERSION__ < 199901L\r
#define __FUNCTION__ __FILE__\r
#endif\r
#endif\r
\r
template <class T>\r
class CMemoryLeakChecker : public list<T*>\r
{\r
public:\r
    static CMemoryLeakChecker<T>& GetInstance(void);\r
\r
private:\r
    CMemoryLeakChecker(void)\r
    {\r
    }\r
\r
    ~CMemoryLeakChecker(void);\r
};\r
\r
template <class T>\r
CMemoryLeakChecker<T>& CMemoryLeakChecker<T>::GetInstance(void)\r
{\r
    static CMemoryLeakChecker<T> s_memLeakChecker;\r
    return s_memLeakChecker;\r
}\r
\r
template <class T>\r
CMemoryLeakChecker<T>::~CMemoryLeakChecker(void)\r
{\r
    if (!list<T*>::empty())\r
        throw logic_error(__FUNCTION__ ": Memory leak detected!");\r
}\r
\r
class CObjRoot\r
{\r
protected:\r
    CObjRoot(void);\r
    virtual ~CObjRoot(void);\r
};\r
\r
CObjRoot::CObjRoot(void)\r
{\r
    CMemoryLeakChecker<CObjRoot>::GetInstance().push_back(this);\r
}\r
\r
CObjRoot::~CObjRoot(void)\r
{\r
    CMemoryLeakChecker<CObjRoot>::GetInstance().remove(this);\r
}\r
\r
class CIdentity : public CObjRoot\r
{\r
public:\r
    CIdentity(void);\r
    CIdentity(const string&);\r
    CIdentity(const CIdentity&);\r
\r
    bool operator < (const CIdentity&) const;\r
    friend istream& operator >> (istream&, CIdentity&);\r
    friend ostream& operator << (ostream&, const CIdentity&);\r
\r
    static const string::size_type s_nIdStrLen;\r
\r
protected:\r
    ulonglong_t m_ullId[2];\r
};\r
\r
const string::size_type CIdentity::s_nIdStrLen = 36;\r
\r
CIdentity::CIdentity(void)\r
{\r
    memset(m_ullId, 0, sizeof(m_ullId));\r
}\r
\r
CIdentity::CIdentity(const string& strId)\r
{\r
    if (strId.length() != CIdentity::s_nIdStrLen ||\r
        strId[8] != '-' ||\r
        strId[13] != '-' ||\r
        strId[18] != '-' ||\r
        strId[23] != '-')\r
        throw runtime_error(\r
            __FUNCTION__ ": Error GUID format " + strId);\r
\r
    string strIdCopy(strId);\r
    strIdCopy.erase(23, 1);\r
    strIdCopy[18] = ' ';\r
    strIdCopy.erase(13, 1);\r
    strIdCopy.erase(8, 1);\r
\r
    istringstream is(strIdCopy);\r
    is >> hex >> m_ullId[0] >> m_ullId[1];\r
    if (!is)\r
        throw runtime_error(\r
            __FUNCTION__ ": GUID contains invalid characters" + strId);\r
}\r
\r
CIdentity::CIdentity(const CIdentity& idRight)\r
{\r
    memmove(m_ullId, idRight.m_ullId, sizeof(m_ullId));\r
}\r
\r
bool CIdentity::operator < (const CIdentity& idRight) const\r
{\r
    return memcmp(m_ullId, idRight.m_ullId, sizeof(m_ullId)) < 0;\r
}\r
\r
istream& operator >> (istream& is, CIdentity& idRight)\r
{\r
    string strId;\r
    is >> strId;\r
    if (!!is)\r
        idRight = CIdentity(strId);\r
    return is;\r
}\r
\r
ostream& operator << (ostream& os, const CIdentity& idRight)\r
{\r
    return os << hex << setfill('0')\r
        << setw(8) << (unsigned long)(idRight.m_ullId[0] >> 32) << '-'\r
        << setw(4) << (unsigned short)(idRight.m_ullId[0] >> 16) << '-'\r
        << setw(4) << (unsigned short)idRight.m_ullId[0] << '-'\r
        << setw(4) << (unsigned short)(idRight.m_ullId[1] >> 48) << '-'\r
        << setw(12) <<  (idRight.m_ullId[1] & 0xffffffffffffULL);\r
}\r
\r
class CInputFile : public CObjRoot\r
{\r
protected:\r
    CInputFile(const string&);\r
    CInputFile(istream&);\r
    istream& GetLine(string&);\r
\r
private:\r
    CInputFile(const CInputFile&);\r
    CInputFile& operator = (const CInputFile&);\r
\r
private:\r
    auto_ptr<istream> m_pIs;\r
\r
protected:\r
    istream& m_is;\r
};\r
\r
CInputFile::CInputFile(const string& strFName)\r
: m_pIs(new ifstream(strFName.c_str()))\r
, m_is(*m_pIs)\r
{\r
    if (!m_is)\r
        throw runtime_error(__FUNCTION__ ": Error opening input file " + strFName);\r
}\r
\r
CInputFile::CInputFile(istream& is)\r
: m_is(is)\r
{\r
    if (!m_is)\r
        throw runtime_error(__FUNCTION__ ": Error opening input stream");\r
}\r
\r
istream& CInputFile::GetLine(string& strALine)\r
{\r
    if (!!m_is)\r
        while (!!getline(m_is, strALine))\r
        {\r
            string::size_type pos = strALine.find_last_not_of(' ');\r
            if (pos != string::npos)\r
            {\r
                strALine.erase(pos + 1);\r
                strALine.erase(0, strALine.find_first_not_of(' '));\r
                break;\r
            }\r
        }\r
    return m_is;\r
}\r
\r
class CIdAddressPathMap : public CInputFile, public map<CIdentity, pair<ulonglong_t, string> >\r
{\r
public:\r
    CIdAddressPathMap(istream&);\r
};\r
\r
CIdAddressPathMap::CIdAddressPathMap(istream& is)\r
: CInputFile(is)\r
{\r
    key_type k;\r
    mapped_type m;\r
    while (!!(m_is >> hex >> k >> m.first) && !!GetLine(m.second))\r
        if (!insert(value_type(k, m)).second)\r
            throw runtime_error(__FUNCTION__ ": Duplicated files");\r
}\r
\r
class CSymbol : public CObjRoot\r
{\r
public:\r
    string m_strAddress;\r
    string m_strName;\r
    ulonglong_t m_ullRva;\r
    string m_strFrom;\r
    bool m_bStatic;\r
    bool m_bFunction;\r
\r
    CSymbol()\r
    {\r
    }\r
    CSymbol(const string&, bool = false);\r
    friend ostream& operator << (ostream&, const CSymbol&);\r
};\r
\r
CSymbol::CSymbol(const string& strALine, bool bStatic)\r
: m_bStatic(bStatic)\r
{\r
    istringstream is(strALine);\r
\r
    is >> m_strAddress >> m_strName >> hex >> m_ullRva >> m_strFrom;\r
    if (m_strFrom == "F" || m_strFrom == "f")\r
    {\r
        m_bFunction = true;\r
        is >> m_strFrom;\r
    } else m_bFunction = false;\r
}\r
\r
ostream& operator << (ostream& os, const CSymbol& symbol)\r
{\r
    os << hex << setw(16) << setfill('0') << symbol.m_ullRva << setw(0);\r
    os << ' ' << (symbol.m_bFunction ? 'F' : ' ')\r
        << (symbol.m_bStatic ? 'S' : ' ') << ' ';\r
    return os << symbol.m_strName;\r
}\r
\r
class CMapFile : public CInputFile, public list<CSymbol>\r
{\r
public:\r
    CMapFile(const string&);\r
\r
    void SetLoadAddress(ulonglong_t);\r
\r
    string m_strModuleName;\r
    ulonglong_t m_ullLoadAddr;\r
    string m_strEntryPoint;\r
};\r
\r
CMapFile::CMapFile(const string& strFName)\r
: CInputFile(strFName)\r
{\r
    static const char cszLoadAddr[] = "Preferred load address is";\r
    static const char cszGlobal[] = "Address";\r
    static const char cszEntryPoint[] = "entry point at";\r
    static const char cszStatic[] = "Static symbols";\r
\r
    string strALine;\r
\r
    GetLine(m_strModuleName);\r
\r
    while (!!GetLine(strALine) && strALine.compare(0, sizeof(cszLoadAddr) - 1, cszLoadAddr));\r
    if (!m_is)\r
        throw runtime_error(__FUNCTION__ ": Load Address not listed in map file");\r
\r
    istringstream is(strALine.substr(sizeof(cszLoadAddr) - 1));\r
    if (!(is >> hex >> m_ullLoadAddr))\r
        throw runtime_error(__FUNCTION__ ": Unexpected Load Address format");\r
\r
    while (!!GetLine(strALine) && strALine.compare(0, sizeof(cszGlobal) - 1, cszGlobal));\r
    if (!m_is)\r
        throw runtime_error(__FUNCTION__ ": Global symbols not found in map file");\r
\r
    while (!!GetLine(strALine) && strALine.compare(0, sizeof(cszEntryPoint) - 1, cszEntryPoint))\r
        push_back(CSymbol(strALine));\r
    if (!m_is)\r
        throw runtime_error(__FUNCTION__ ": Entry Point not listed in map file");\r
\r
    is.str(strALine.substr(strALine.find_first_not_of(' ', sizeof(cszEntryPoint) - 1)));\r
    is.clear();\r
    if (!getline(is, m_strEntryPoint))\r
        throw runtime_error(__FUNCTION__ ": Unexpected Entry Point format");\r
\r
    while (!!GetLine(strALine) && strALine.compare(0, sizeof(cszStatic) - 1, cszStatic));\r
    while (!!GetLine(strALine))\r
        push_back(CSymbol(strALine, true));\r
}\r
\r
void CMapFile::SetLoadAddress(ulonglong_t ullLoadAddr)\r
{\r
    for (iterator i = begin(); i != end(); i++)\r
        if (i->m_ullRva >= m_ullLoadAddr)\r
            i->m_ullRva += ullLoadAddr - m_ullLoadAddr;\r
    m_ullLoadAddr = ullLoadAddr;\r
}\r
\r
class COutputFile : public CObjRoot\r
{\r
protected:\r
    COutputFile(ostream&);\r
    ostream& m_os;\r
\r
private:\r
    COutputFile(const COutputFile&);\r
    COutputFile& operator = (const COutputFile&);\r
};\r
\r
class CFvMapFile : public CObjRoot, public map<CIdentity, CMapFile*>\r
{\r
public:\r
    CFvMapFile(const CIdAddressPathMap&);\r
    ~CFvMapFile(void);\r
\r
    friend ostream& operator << (ostream&, const CFvMapFile&);\r
\r
private:\r
    void Cleanup(void);\r
};\r
\r
CFvMapFile::CFvMapFile(const CIdAddressPathMap& idAddrPath)\r
{\r
    for (CIdAddressPathMap::const_iterator i = idAddrPath.begin(); i != idAddrPath.end(); i++)\r
    {\r
        if (i->second.second == "*")\r
            continue;\r
\r
        pair<iterator, bool> r = insert(value_type(i->first,\r
            new CMapFile(i->second.second.substr(0, i->second.second.rfind('.')) + ".map")));\r
        r.first->second->SetLoadAddress(i->second.first);\r
    }\r
}\r
\r
CFvMapFile::~CFvMapFile(void)\r
{\r
    Cleanup();\r
}\r
\r
void CFvMapFile::Cleanup(void)\r
{\r
    for (iterator i = begin(); i != end(); i++)\r
        delete i->second;\r
}\r
\r
static bool map_less(const CFvMapFile::const_iterator& l, const CFvMapFile::const_iterator& r)\r
{\r
    return l->second->m_ullLoadAddr < r->second->m_ullLoadAddr;\r
}\r
\r
ostream& operator << (ostream& os, const CFvMapFile& fvMap)\r
{\r
    vector<CFvMapFile::const_iterator> rgIter;\r
    rgIter.reserve(fvMap.size());\r
    for (CFvMapFile::const_iterator i = fvMap.begin(); i != fvMap.end(); i++)\r
        rgIter.push_back(i);\r
    sort(rgIter.begin(), rgIter.end(), map_less);\r
\r
    for (vector<CFvMapFile::const_iterator>::const_iterator i = rgIter.begin(); i != rgIter.end(); i++)\r
    {\r
        CMapFile::const_iterator j = (*i)->second->begin();\r
        while (j != (*i)->second->end() && j->m_strAddress != (*i)->second->m_strEntryPoint) j++;\r
        if (j == (*i)->second->end())\r
            throw runtime_error(\r
                __FUNCTION__ ":Entry point not found for module " +\r
                (*i)->second->m_strModuleName);\r
\r
        os << hex\r
            << (*i)->second->m_strModuleName\r
            << " (EntryPoint=" << j->m_ullRva\r
            << ", BaseAddress=" << (*i)->second->m_ullLoadAddr\r
            << ", GUID=" << (*i)->first\r
            << ")" << endl << endl;\r
\r
        for (j = (*i)->second->begin(); j != (*i)->second->end(); j++)\r
            os << "  " << *j << endl;\r
\r
        os << endl << endl;\r
    }\r
\r
    return os;\r
}\r
\r
class CGenFvMapUsage : public invalid_argument\r
{\r
public:\r
    CGenFvMapUsage(void) : invalid_argument(s_szUsage)\r
    {\r
    }\r
\r
private:\r
    static const char s_szUsage[];\r
};\r
\r
const char CGenFvMapUsage::s_szUsage[] = "Usage: GenFvMap <LOG> <MAP>";\r
\r
class CGenFvMapApp : public CObjRoot\r
{\r
public:\r
    CGenFvMapApp(int, char *[]);\r
    ~CGenFvMapApp(void);\r
\r
    int Run(void);\r
\r
private:\r
    int m_cArgc;\r
    char **m_ppszArgv;\r
};\r
\r
CGenFvMapApp::CGenFvMapApp(int cArgc, char *ppszArgv[])\r
: m_cArgc(cArgc)\r
, m_ppszArgv(ppszArgv)\r
{\r
    if (cArgc != 3)\r
        throw CGenFvMapUsage();\r
}\r
\r
CGenFvMapApp::~CGenFvMapApp(void)\r
{\r
}\r
\r
int CGenFvMapApp::Run(void)\r
{\r
    ifstream isLog(m_ppszArgv[1]);\r
    CIdAddressPathMap idAddrPath(isLog);\r
    CFvMapFile fvMap(idAddrPath);\r
\r
    ofstream osMap(m_ppszArgv[2], ios_base::out | ios_base::trunc);\r
    osMap << fvMap;\r
\r
    if (!osMap)\r
        throw runtime_error(__FUNCTION__ ": Error writing output file");\r
\r
    return 0;\r
}\r
\r
int main(int argc, char *argv[])\r
{\r
    try\r
    {\r
        CGenFvMapApp app(argc, argv);\r
        return app.Run();\r
    }\r
    catch (const exception& e)\r
    {\r
        cerr << e.what() << endl;\r
        return -1;\r
    }\r
}\r
Commit	Line	Data
8733430b	1	//****************************************************************************\r
8733430b	2	//**\r
a3ab2a47	3	//** Copyright (C) 2006 Intel Corporation. All rights reserved.\r
8733430b	4	//**\r
a3ab2a47	5	//** The information and source code contained herein is the exclusive\r
8733430b	6	//** property of Intel Corporation and may not be disclosed, examined\r
a3ab2a47	7	//** or reproduced in whole or in part without explicit written authorization\r
8733430b	8	//** from the company.\r
	9	//**\r
	10	//****************************************************************************\r
327bd141	11	#include "ProcessorBind.h"\r
327bd141	12	#include <iostream>\r
8733430b	13	#include <stdexcept>\r
	14	#include <list>\r
	15	#include <map>\r
93d16c69	16	#include <vector>\r
8733430b	17	#include <iomanip>\r
	18	#include <fstream>\r
	19	#include <sstream>\r
	20	#include <string>\r
	21	#include <utility>\r
	22	#include <algorithm>\r
	23	#include <functional>\r
	24	using namespace std;\r
	25	\r
327bd141	26	typedef UINT64 ulonglong_t;\r
8733430b	27	\r
1b266b0c	28	#ifdef __GNUC__\r
	29	#if __STDC_VERSION__ < 199901L\r
	30	#define __FUNCTION__ __FILE__\r
	31	#endif\r
	32	#endif\r
	33	\r
8733430b	34	template <class T>\r
	35	class CMemoryLeakChecker : public list<T*>\r
	36	{\r
	37	public:\r
	38	static CMemoryLeakChecker<T>& GetInstance(void);\r
	39	\r
	40	private:\r
	41	CMemoryLeakChecker(void)\r
	42	{\r
	43	}\r
	44	\r
	45	~CMemoryLeakChecker(void);\r
	46	};\r
	47	\r
	48	template <class T>\r
	49	CMemoryLeakChecker<T>& CMemoryLeakChecker<T>::GetInstance(void)\r
	50	{\r
	51	static CMemoryLeakChecker<T> s_memLeakChecker;\r
	52	return s_memLeakChecker;\r
	53	}\r
	54	\r
	55	template <class T>\r
	56	CMemoryLeakChecker<T>::~CMemoryLeakChecker(void)\r
	57	{\r
	58	if (!list<T*>::empty())\r
	59	throw logic_error(__FUNCTION__ ": Memory leak detected!");\r
	60	}\r
	61	\r
	62	class CObjRoot\r
	63	{\r
	64	protected:\r
	65	CObjRoot(void);\r
	66	virtual ~CObjRoot(void);\r
	67	};\r
	68	\r
	69	CObjRoot::CObjRoot(void)\r
	70	{\r
	71	CMemoryLeakChecker<CObjRoot>::GetInstance().push_back(this);\r
	72	}\r
	73	\r
	74	CObjRoot::~CObjRoot(void)\r
	75	{\r
	76	CMemoryLeakChecker<CObjRoot>::GetInstance().remove(this);\r
	77	}\r
	78	\r
	79	class CIdentity : public CObjRoot\r
	80	{\r
	81	public:\r
	82	CIdentity(void);\r
	83	CIdentity(const string&);\r
	84	CIdentity(const CIdentity&);\r
	85	\r
	86	bool operator < (const CIdentity&) const;\r
	87	friend istream& operator >> (istream&, CIdentity&);\r
a3ab2a47	88	friend ostream& operator << (ostream&, const CIdentity&);\r
8733430b	89	\r
	90	static const string::size_type s_nIdStrLen;\r
	91	\r
	92	protected:\r
	93	ulonglong_t m_ullId[2];\r
	94	};\r
	95	\r
	96	const string::size_type CIdentity::s_nIdStrLen = 36;\r
	97	\r
	98	CIdentity::CIdentity(void)\r
	99	{\r
	100	memset(m_ullId, 0, sizeof(m_ullId));\r
	101	}\r
	102	\r
	103	CIdentity::CIdentity(const string& strId)\r
	104	{\r
	105	if (strId.length() != CIdentity::s_nIdStrLen \|\|\r
	106	strId[8] != '-' \|\|\r
	107	strId[13] != '-' \|\|\r
	108	strId[18] != '-' \|\|\r
	109	strId[23] != '-')\r
	110	throw runtime_error(\r
	111	__FUNCTION__ ": Error GUID format " + strId);\r
	112	\r
	113	string strIdCopy(strId);\r
	114	strIdCopy.erase(23, 1);\r
	115	strIdCopy[18] = ' ';\r
	116	strIdCopy.erase(13, 1);\r
	117	strIdCopy.erase(8, 1);\r
	118	\r
	119	istringstream is(strIdCopy);\r
	120	is >> hex >> m_ullId[0] >> m_ullId[1];\r
	121	if (!is)\r
	122	throw runtime_error(\r
	123	__FUNCTION__ ": GUID contains invalid characters" + strId);\r
	124	}\r
	125	\r
	126	CIdentity::CIdentity(const CIdentity& idRight)\r
	127	{\r
	128	memmove(m_ullId, idRight.m_ullId, sizeof(m_ullId));\r
	129	}\r
	130	\r
	131	bool CIdentity::operator < (const CIdentity& idRight) const\r
	132	{\r
	133	return memcmp(m_ullId, idRight.m_ullId, sizeof(m_ullId)) < 0;\r
	134	}\r
	135	\r
	136	istream& operator >> (istream& is, CIdentity& idRight)\r
	137	{\r
	138	string strId;\r
	139	is >> strId;\r
	140	if (!!is)\r
	141	idRight = CIdentity(strId);\r
	142	return is;\r
	143	}\r
	144	\r
a3ab2a47	145	ostream& operator << (ostream& os, const CIdentity& idRight)\r
	146	{\r
	147	return os << hex << setfill('0')\r
	148	<< setw(8) << (unsigned long)(idRight.m_ullId[0] >> 32) << '-'\r
	149	<< setw(4) << (unsigned short)(idRight.m_ullId[0] >> 16) << '-'\r
	150	<< setw(4) << (unsigned short)idRight.m_ullId[0] << '-'\r
	151	<< setw(4) << (unsigned short)(idRight.m_ullId[1] >> 48) << '-'\r
327bd141	152	<< setw(12) << (idRight.m_ullId[1] & 0xffffffffffffULL);\r
a3ab2a47	153	}\r
a3ab2a47	154	\r
8733430b	155	class CInputFile : public CObjRoot\r
	156	{\r
	157	protected:\r
	158	CInputFile(const string&);\r
	159	CInputFile(istream&);\r
	160	istream& GetLine(string&);\r
	161	\r
	162	private:\r
	163	CInputFile(const CInputFile&);\r
	164	CInputFile& operator = (const CInputFile&);\r
	165	\r
	166	private:\r
	167	auto_ptr<istream> m_pIs;\r
	168	\r
	169	protected:\r
	170	istream& m_is;\r
	171	};\r
	172	\r
	173	CInputFile::CInputFile(const string& strFName)\r
	174	: m_pIs(new ifstream(strFName.c_str()))\r
	175	, m_is(*m_pIs)\r
	176	{\r
	177	if (!m_is)\r
	178	throw runtime_error(__FUNCTION__ ": Error opening input file " + strFName);\r
	179	}\r
	180	\r
	181	CInputFile::CInputFile(istream& is)\r
	182	: m_is(is)\r
	183	{\r
	184	if (!m_is)\r
	185	throw runtime_error(__FUNCTION__ ": Error opening input stream");\r
	186	}\r
	187	\r
	188	istream& CInputFile::GetLine(string& strALine)\r
	189	{\r
	190	if (!!m_is)\r
	191	while (!!getline(m_is, strALine))\r
	192	{\r
	193	string::size_type pos = strALine.find_last_not_of(' ');\r
	194	if (pos != string::npos)\r
	195	{\r
	196	strALine.erase(pos + 1);\r
	197	strALine.erase(0, strALine.find_first_not_of(' '));\r
	198	break;\r
	199	}\r
	200	}\r
	201	return m_is;\r
	202	}\r
	203	\r
a3ab2a47	204	class CIdAddressPathMap : public CInputFile, public map<CIdentity, pair<ulonglong_t, string> >\r
8733430b	205	{\r
8733430b	206	public:\r
a3ab2a47	207	CIdAddressPathMap(istream&);\r
8733430b	208	};\r
8733430b	209	\r
a3ab2a47	210	CIdAddressPathMap::CIdAddressPathMap(istream& is)\r
8733430b	211	: CInputFile(is)\r
8733430b	212	{\r
a3ab2a47	213	key_type k;\r
	214	mapped_type m;\r
	215	while (!!(m_is >> hex >> k >> m.first) && !!GetLine(m.second))\r
	216	if (!insert(value_type(k, m)).second)\r
8733430b	217	throw runtime_error(__FUNCTION__ ": Duplicated files");\r
	218	}\r
	219	\r
8733430b	220	class CSymbol : public CObjRoot\r
	221	{\r
	222	public:\r
	223	string m_strAddress;\r
	224	string m_strName;\r
	225	ulonglong_t m_ullRva;\r
	226	string m_strFrom;\r
	227	bool m_bStatic;\r
	228	bool m_bFunction;\r
	229	\r
	230	CSymbol()\r
	231	{\r
	232	}\r
	233	CSymbol(const string&, bool = false);\r
	234	friend ostream& operator << (ostream&, const CSymbol&);\r
	235	};\r
	236	\r
	237	CSymbol::CSymbol(const string& strALine, bool bStatic)\r
	238	: m_bStatic(bStatic)\r
	239	{\r
	240	istringstream is(strALine);\r
	241	\r
	242	is >> m_strAddress >> m_strName >> hex >> m_ullRva >> m_strFrom;\r
	243	if (m_strFrom == "F" \|\| m_strFrom == "f")\r
	244	{\r
	245	m_bFunction = true;\r
	246	is >> m_strFrom;\r
	247	} else m_bFunction = false;\r
	248	}\r
	249	\r
	250	ostream& operator << (ostream& os, const CSymbol& symbol)\r
	251	{\r
	252	os << hex << setw(16) << setfill('0') << symbol.m_ullRva << setw(0);\r
	253	os << ' ' << (symbol.m_bFunction ? 'F' : ' ')\r
	254	<< (symbol.m_bStatic ? 'S' : ' ') << ' ';\r
a3ab2a47	255	return os << symbol.m_strName;\r
8733430b	256	}\r
	257	\r
	258	class CMapFile : public CInputFile, public list<CSymbol>\r
	259	{\r
	260	public:\r
	261	CMapFile(const string&);\r
	262	\r
	263	void SetLoadAddress(ulonglong_t);\r
8733430b	264	\r
	265	string m_strModuleName;\r
	266	ulonglong_t m_ullLoadAddr;\r
	267	string m_strEntryPoint;\r
	268	};\r
	269	\r
	270	CMapFile::CMapFile(const string& strFName)\r
	271	: CInputFile(strFName)\r
	272	{\r
	273	static const char cszLoadAddr[] = "Preferred load address is";\r
	274	static const char cszGlobal[] = "Address";\r
	275	static const char cszEntryPoint[] = "entry point at";\r
	276	static const char cszStatic[] = "Static symbols";\r
	277	\r
	278	string strALine;\r
	279	\r
	280	GetLine(m_strModuleName);\r
	281	\r
	282	while (!!GetLine(strALine) && strALine.compare(0, sizeof(cszLoadAddr) - 1, cszLoadAddr));\r
	283	if (!m_is)\r
	284	throw runtime_error(__FUNCTION__ ": Load Address not listed in map file");\r
	285	\r
	286	istringstream is(strALine.substr(sizeof(cszLoadAddr) - 1));\r
	287	if (!(is >> hex >> m_ullLoadAddr))\r
	288	throw runtime_error(__FUNCTION__ ": Unexpected Load Address format");\r
	289	\r
	290	while (!!GetLine(strALine) && strALine.compare(0, sizeof(cszGlobal) - 1, cszGlobal));\r
	291	if (!m_is)\r
	292	throw runtime_error(__FUNCTION__ ": Global symbols not found in map file");\r
	293	\r
	294	while (!!GetLine(strALine) && strALine.compare(0, sizeof(cszEntryPoint) - 1, cszEntryPoint))\r
	295	push_back(CSymbol(strALine));\r
	296	if (!m_is)\r
	297	throw runtime_error(__FUNCTION__ ": Entry Point not listed in map file");\r
	298	\r
	299	is.str(strALine.substr(strALine.find_first_not_of(' ', sizeof(cszEntryPoint) - 1)));\r
	300	is.clear();\r
	301	if (!getline(is, m_strEntryPoint))\r
	302	throw runtime_error(__FUNCTION__ ": Unexpected Entry Point format");\r
	303	\r
	304	while (!!GetLine(strALine) && strALine.compare(0, sizeof(cszStatic) - 1, cszStatic));\r
	305	while (!!GetLine(strALine))\r
	306	push_back(CSymbol(strALine, true));\r
	307	}\r
	308	\r
	309	void CMapFile::SetLoadAddress(ulonglong_t ullLoadAddr)\r
	310	{\r
	311	for (iterator i = begin(); i != end(); i++)\r
a3ab2a47	312	if (i->m_ullRva >= m_ullLoadAddr)\r
8733430b	313	i->m_ullRva += ullLoadAddr - m_ullLoadAddr;\r
	314	m_ullLoadAddr = ullLoadAddr;\r
	315	}\r
	316	\r
8733430b	317	class COutputFile : public CObjRoot\r
	318	{\r
	319	protected:\r
	320	COutputFile(ostream&);\r
	321	ostream& m_os;\r
	322	\r
	323	private:\r
	324	COutputFile(const COutputFile&);\r
	325	COutputFile& operator = (const COutputFile&);\r
	326	};\r
	327	\r
	328	class CFvMapFile : public CObjRoot, public map<CIdentity, CMapFile*>\r
	329	{\r
	330	public:\r
a3ab2a47	331	CFvMapFile(const CIdAddressPathMap&);\r
8733430b	332	~CFvMapFile(void);\r
	333	\r
	334	friend ostream& operator << (ostream&, const CFvMapFile&);\r
	335	\r
	336	private:\r
	337	void Cleanup(void);\r
	338	};\r
	339	\r
a3ab2a47	340	CFvMapFile::CFvMapFile(const CIdAddressPathMap& idAddrPath)\r
8733430b	341	{\r
a3ab2a47	342	for (CIdAddressPathMap::const_iterator i = idAddrPath.begin(); i != idAddrPath.end(); i++)\r
8733430b	343	{\r
a3ab2a47	344	if (i->second.second == "*")\r
a3ab2a47	345	continue;\r
8733430b	346	\r
a3ab2a47	347	pair<iterator, bool> r = insert(value_type(i->first,\r
	348	new CMapFile(i->second.second.substr(0, i->second.second.rfind('.')) + ".map")));\r
	349	r.first->second->SetLoadAddress(i->second.first);\r
8733430b	350	}\r
	351	}\r
	352	\r
93d16c69	353	CFvMapFile::~CFvMapFile(void)\r
	354	{\r
	355	Cleanup();\r
	356	}\r
	357	\r
8733430b	358	void CFvMapFile::Cleanup(void)\r
	359	{\r
	360	for (iterator i = begin(); i != end(); i++)\r
	361	delete i->second;\r
	362	}\r
	363	\r
93d16c69	364	static bool map_less(const CFvMapFile::const_iterator& l, const CFvMapFile::const_iterator& r)\r
	365	{\r
	366	return l->second->m_ullLoadAddr < r->second->m_ullLoadAddr;\r
	367	}\r
	368	\r
8733430b	369	ostream& operator << (ostream& os, const CFvMapFile& fvMap)\r
8733430b	370	{\r
93d16c69	371	vector<CFvMapFile::const_iterator> rgIter;\r
	372	rgIter.reserve(fvMap.size());\r
	373	for (CFvMapFile::const_iterator i = fvMap.begin(); i != fvMap.end(); i++)\r
	374	rgIter.push_back(i);\r
	375	sort(rgIter.begin(), rgIter.end(), map_less);\r
	376	\r
	377	for (vector<CFvMapFile::const_iterator>::const_iterator i = rgIter.begin(); i != rgIter.end(); i++)\r
a3ab2a47	378	{\r
93d16c69	379	CMapFile::const_iterator j = (*i)->second->begin();\r
	380	while (j != (i)->second->end() && j->m_strAddress != (i)->second->m_strEntryPoint) j++;\r
	381	if (j == (*i)->second->end())\r
a3ab2a47	382	throw runtime_error(\r
a3ab2a47	383	__FUNCTION__ ":Entry point not found for module " +\r
93d16c69	384	(*i)->second->m_strModuleName);\r
a3ab2a47	385	\r
a3ab2a47	386	os << hex\r
93d16c69	387	<< (*i)->second->m_strModuleName\r
	388	<< " (EntryPoint=" << j->m_ullRva\r
	389	<< ", BaseAddress=" << (*i)->second->m_ullLoadAddr\r
	390	<< ", GUID=" << (*i)->first\r
a3ab2a47	391	<< ")" << endl << endl;\r
a3ab2a47	392	\r
93d16c69	393	for (j = (i)->second->begin(); j != (i)->second->end(); j++)\r
a3ab2a47	394	os << " " << *j << endl;\r
	395	\r
	396	os << endl << endl;\r
	397	}\r
	398	\r
8733430b	399	return os;\r
	400	}\r
	401	\r
8733430b	402	class CGenFvMapUsage : public invalid_argument\r
	403	{\r
	404	public:\r
	405	CGenFvMapUsage(void) : invalid_argument(s_szUsage)\r
	406	{\r
	407	}\r
	408	\r
	409	private:\r
	410	static const char s_szUsage[];\r
	411	};\r
	412	\r
a3ab2a47	413	const char CGenFvMapUsage::s_szUsage[] = "Usage: GenFvMap <LOG> <MAP>";\r
8733430b	414	\r
	415	class CGenFvMapApp : public CObjRoot\r
	416	{\r
	417	public:\r
	418	CGenFvMapApp(int, char *[]);\r
	419	~CGenFvMapApp(void);\r
	420	\r
	421	int Run(void);\r
	422	\r
	423	private:\r
	424	int m_cArgc;\r
	425	char **m_ppszArgv;\r
	426	};\r
	427	\r
	428	CGenFvMapApp::CGenFvMapApp(int cArgc, char *ppszArgv[])\r
	429	: m_cArgc(cArgc)\r
	430	, m_ppszArgv(ppszArgv)\r
	431	{\r
a3ab2a47	432	if (cArgc != 3)\r
8733430b	433	throw CGenFvMapUsage();\r
	434	}\r
	435	\r
	436	CGenFvMapApp::~CGenFvMapApp(void)\r
	437	{\r
	438	}\r
	439	\r
	440	int CGenFvMapApp::Run(void)\r
	441	{\r
	442	ifstream isLog(m_ppszArgv[1]);\r
a3ab2a47	443	CIdAddressPathMap idAddrPath(isLog);\r
a3ab2a47	444	CFvMapFile fvMap(idAddrPath);\r
8733430b	445	\r
a3ab2a47	446	ofstream osMap(m_ppszArgv[2], ios_base::out \| ios_base::trunc);\r
8733430b	447	osMap << fvMap;\r
	448	\r
	449	if (!osMap)\r
	450	throw runtime_error(__FUNCTION__ ": Error writing output file");\r
	451	\r
	452	return 0;\r
	453	}\r
	454	\r
	455	int main(int argc, char *argv[])\r
	456	{\r
	457	try\r
	458	{\r
	459	CGenFvMapApp app(argc, argv);\r
	460	return app.Run();\r
	461	}\r
	462	catch (const exception& e)\r
	463	{\r
	464	cerr << e.what() << endl;\r
	465	return -1;\r
	466	}\r
	467	}\r