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