Extern/Beef
1
0
Fork 0
mirror of https://github.com/beefytech/Beef.git synced 2025-06-08 11:38:21 +02:00
Code Activity
Beef/IDEHelper/Linker/BlContext.cpp
Brian Fiete 078564ac9e Initial checkin
2019-08-23 11:56:54 -07:00

3929 lines
110 KiB
C++
Raw Blame History

#pragma warning(disable:4996)
#define MAX_SEG_COUNT 1024
#include "BlContext.h"
#include "BlCvParser.h"
#include "BlCodeView.h"
#include "BeefySysLib/util/PerfTimer.h"
#include "../Compiler/BfAstAllocator.h"
#include "../COFFData.h"
#include "BeefySysLib/FileStream.h"
#include "BeefySysLib/CachedDataStream.h"
#include "../Backend/BeCOFFObject.h"
#include "../Compiler/BfDemangler.h"
#include <time.h>
#include <iostream>
#include <stdlib.h>
#include <direct.h>
#include "codeview/cvinfo.h"
#define GET(T) *((T*)(data += sizeof(T)) - 1)
#define PTR_ALIGN(ptr, origPtr, alignSize) ptr = ( (origPtr)+( ((ptr - origPtr) + (alignSize - 1)) & ~(alignSize - 1) ) )
USING_NS_BF;
//#include "BeefySysLib/third_party/sparsehash/google/sparsehash/densehashtable.h"
//////////////////////////////////////////////////////////////////////////
BlChunk* BlSegment::AddChunk(void* data, int size, int characteristics, int& offset)
{
if (size == 0)
return NULL;
if ((characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA) != 0)
{
BF_ASSERT(data == NULL);
}
else
{
BF_ASSERT(data != NULL);
}
int align = 1;
int chAlign = characteristics & IMAGE_SCN_ALIGN_MASK;
if (chAlign == IMAGE_SCN_ALIGN_8192BYTES)
align = 8192;
else if (chAlign == IMAGE_SCN_ALIGN_4096BYTES)
align = 4096;
else if (chAlign == IMAGE_SCN_ALIGN_2048BYTES)
align = 2048;
else if (chAlign == IMAGE_SCN_ALIGN_1024BYTES)
align = 1024;
else if (chAlign == IMAGE_SCN_ALIGN_512BYTES)
align = 512;
else if (chAlign == IMAGE_SCN_ALIGN_256BYTES)
align = 256;
else if (chAlign == IMAGE_SCN_ALIGN_128BYTES)
align = 128;
else if (chAlign == IMAGE_SCN_ALIGN_64BYTES)
align = 64;
else if (chAlign == IMAGE_SCN_ALIGN_32BYTES)
align = 32;
else if (chAlign == IMAGE_SCN_ALIGN_16BYTES)
align = 16;
else if (chAlign == IMAGE_SCN_ALIGN_8BYTES)
align = 8;
else if (chAlign == IMAGE_SCN_ALIGN_4BYTES)
align = 4;
else if (chAlign == IMAGE_SCN_ALIGN_2BYTES)
align = 2;
int prevSize = mCurSize;
mCurSize = (mCurSize + (align - 1)) & ~(align - 1);
offset = mCurSize;
mCurSize += size;
mAlign = std::max(mAlign, align);
if (data == NULL)
return NULL;
BlChunk blChunk;
blChunk.mOffset = offset;
blChunk.mAlignPad = offset - prevSize;
blChunk.mSize = size;
blChunk.mData = data;
blChunk.mObjectDataIdx = -1;
mChunks.push_back(blChunk);
auto blChunkPtr = &mChunks.back();
return blChunkPtr;
}
//////////////////////////////////////////////////////////////////////////
void BlPeRelocs::Add(uint32 addr, int fixupType)
{
int ofs = addr - mBlockAddr;
if ((mLenPtr == NULL) || (ofs >= 0x1000))
{
if ((mLenPtr != NULL) && (*mLenPtr % 4 == 2))
{
(*mLenPtr) += 2;
int16 alignVal = 0;
mData.Write(&alignVal, 2);
}
mBlockAddr = addr;
mData.Write(&mBlockAddr, 4);
mLenPtr = (int32*)mData.mWriteCurPtr;
int32 len = 8 + 2;
mData.Write(&len, 4);
int16 val = fixupType << 12;
mData.Write(&val, 2);
}
else
{
int16 val = (ofs) | (fixupType << 12);
mData.Write(&val, 2);
(*mLenPtr) += 2;
}
}
//////////////////////////////////////////////////////////////////////////
static void FixLibName(String& libName)
{
if ((libName.length() > 4) && (stricmp(libName.c_str() + libName.length() - 4, ".lib") != 0))
libName += ".lib";
}
//////////////////////////////////////////////////////////////////////////
BlContext::BlContext()
{
mNumObjFiles = 0;
mNumLibs = 0;
mNumImportedObjs = 0;
mNumWeakSymbols = 0;
#ifdef BL_PERFTIME
gPerfManager = new PerfManager();
gPerfManager->StartRecording();
#endif
//mOutName = "c:\\temp\\out.exe";
//mOutName = "c:\\temp\\TestDLL2.dll";
//mOutName = "c:\\temp\\TestDLL2ABCDEFGHIJKMNOPQRSTUVWXYZ.dll";
mCodeView = NULL;
mSymTable.mContext = this;
mDebugKind = 0;
mImageBase = 0x140000000LL;
mVerbose = false;
mNoDefaultLib = false;
mHasFixedBase = false;
mHasDynamicBase = true;
mHighEntropyVA = true;
mIsNXCompat = true;
mIsTerminalServerAware = true;
mPeVersionMajor = 0;
mPeVersionMinor = 0;
mFailed = false;
mErrorCount = 0;
mIsDLL = false;
mPeSubsystem = IMAGE_SUBSYSTEM_WINDOWS_CUI;
mStackReserve = 0x100000;
mStackCommit = 0x1000;
mHeapReserve = 0x100000;
mHeapCommit = 0x1000;
mTimestamp = (int)time(0);
mProcessingSegIdx = 0;
mIDataSeg = NULL;
mBSSSeg = NULL;
mNumFixedSegs = 0;
mDbgSymSectsFound = 0;
mDbgSymSectsUsed = 0;
mTextSeg = NULL;
mRDataSeg = NULL;
mDataSeg = NULL;
mSegments.reserve(MAX_SEG_COUNT);
}
BlContext::~BlContext()
{
if (mCodeView != NULL)
{
mCodeView->StopWorkThreads();
delete mCodeView;
}
#ifdef BL_PERFTIME
if (gPerfManager->IsRecording())
{
gPerfManager->StopRecording(true);
}
#endif
}
BlSymHash BlContext::Hash(const char* symName)
{
BlSymHash symHash;
Hash128(symName, (int)strlen(symName));
symHash.mName = symName;
return symHash;
}
String BlContext::ObjectDataIdxToString(int objectDataIdx)
{
if (objectDataIdx == -1)
return "<unknown>";
auto objectData = mObjectDatas[objectDataIdx];
String name;
if (objectData->mLib != NULL)
{
name = "\"";
name += GetFileName(objectData->mLib->mFileName);
name += "\" (";
name += GetFileName(objectData->mName);
name += ")";
}
else
{
name = "\"";
name += GetFileName(objectData->mName);
name += "\"";
}
return name;
}
String BlContext::GetSymDisp(const StringImpl&name)
{
String str;
if ((name.empty()) || (name[0] != '?'))
{
str += "\"";
str += name;
str += "\"";
return str;
}
str += "\"";
str += BfDemangler::Demangle(name, DbgLanguage_Unknown);
str += "\" (";
str += name;
str += ")";
return str;
}
String BlContext::FixFilePath(const StringImpl& path, const StringImpl& actualFileName)
{
String actualPath;
int lastSlash = BF_MAX((int)path.LastIndexOf('\\'), (int)path.LastIndexOf('/'));
if (lastSlash != -1)
actualPath.Append(path.c_str(), lastSlash);
for (int i = 0; i < (int)actualPath.length(); i++)
if (actualPath[i] == '/')
actualPath[i] = '\\';
actualPath += actualFileName;
return actualPath;
}
void BlContext::Fail(const StringImpl& error)
{
AutoCrit autoCrit(mCritSect);
mErrorCount++;
if (mErrorCount > 100)
return;
std::cerr << "ERROR: " << error.c_str() << std::endl;
mFailed = true;
}
void BlContext::Warn(const StringImpl& error)
{
AutoCrit autoCrit(mCritSect);
mErrorCount++;
std::cerr << "WARNING: " << error.c_str() << std::endl;
}
void BlContext::Fail(BlObjectData* objectData, const StringImpl& error)
{
AutoCrit autoCrit(mCritSect);
Fail(StrFormat("%s in %s", error.c_str(), ObjectDataIdxToString(objectData->mIdx).c_str()));
}
void BlContext::AssertFailed()
{
BF_ASSERT(mFailed);
}
void BlContext::NotImpl()
{
BF_FATAL("Not implemented");
}
void BlContext::AddSegment(BlSegment* seg)
{
seg->mContext = this;
seg->mSegmentIdx = (int)mSegments.size();
if (mSegments.size() >= MAX_SEG_COUNT)
{
Fail("Maximum segment count exceeded");
return;
}
mSegments.push_back(seg);
mOrderedSegments.push_back(seg);
}
void BlContext::LoadFiles()
{
BL_AUTOPERF("BlContext::LoadFiles");
BfSizedVector<BlObjectDataSectInfo, 16> sectInfos;
BfSizedVector<BlObjectDataSymInfo, 256> symInfos;
String tempStr;
BfSizedVector<int, 16> orderedRelocSects;
while (true)
{
orderedRelocSects.clear();
if (mObjectDataWorkQueue.empty())
break;
auto objectData = mObjectDataWorkQueue.back();
mObjectDataWorkQueue.pop_back();
uint8* data = (uint8*)objectData->mData;
PEFileHeader* fileHeader = (PEFileHeader*)data;
int nameLen = (int)strlen(objectData->mName);
if (nameLen > 4)
{
const char* ext = objectData->mName + nameLen - 4;
if (stricmp(ext, ".res") == 0)
{
LoadResourceData(objectData);
continue;
}
else if (stricmp(ext, ".def") == 0)
{
LoadDefData(objectData);
continue;
}
}
bool dbgTestFile = false;//strcmp(objectData->mName, "Internal.obj") == 0;
if (fileHeader->mMachine != PE_MACHINE_X64)
{
if ((fileHeader->mMachine == 0) && (fileHeader->mNumberOfSections <= 1))
{
// This is an object that contains no code - probably just weak externals
}
else
{
Fail(objectData, "Invalid object file format");
continue;
}
}
data += sizeof(PEFileHeader);
PESectionHeader* sectionHeaderArr = (PESectionHeader*)data;
data += fileHeader->mNumberOfSections * sizeof(PESectionHeader);
BlCvParser cvParser(this);
auto _CommitSection = [&](int objSectionNum, BlObjectDataSectInfo& sectInfo)
{
auto sectionHeader = &sectionHeaderArr[objSectionNum];
if (sectInfo.mSegmentIdx == -1)
{
if (sectInfo.mState == BlSectInfoState_QueuedDebugT)
{
cvParser.AddTypeData(sectionHeader);
sectInfo.mState = (BlSectInfoState)0;
}
else if (sectInfo.mState == BlSectInfoState_QueuedDebugS)
{
mDbgSymSectsUsed++;
cvParser.AddSymbolData(sectionHeader);
sectInfo.mState = (BlSectInfoState)0;
}
else
BF_FATAL("Error");
return;
}
auto section = mSegments[sectInfo.mSegmentIdx];
uint8* sectData = NULL;
if (sectionHeader->mPointerToRawData != NULL)
sectData = (uint8*)objectData->mData + sectionHeader->mPointerToRawData;
BlChunk* blChunk = section->AddChunk(sectData, sectionHeader->mSizeOfRawData, sectionHeader->mCharacteristics, sectInfo.mSegmentOffset);
if (blChunk != NULL)
{
sectInfo.mChunkData = blChunk->mData;
blChunk->mObjectDataIdx = objectData->mIdx;
}
orderedRelocSects.push_back(objSectionNum);
if ((sectionHeader->mCharacteristics & IMAGE_SCN_MEM_EXECUTE) != 0)
{
if (mCodeView != NULL)
cvParser.AddContribution(sectInfo.mSegmentIdx, sectInfo.mSegmentOffset, sectionHeader->mSizeOfRawData, sectionHeader->mCharacteristics);
}
};
BlSegmentInfo sectionInfo;
char* strTab = (char*)objectData->mData + fileHeader->mPointerToSymbolTable + fileHeader->mNumberOfSymbols * sizeof(PE_SymInfo);
if (mCodeView != NULL)
cvParser.AddModule(objectData, strTab);
sectInfos.clear();
for (int sectIdx = 0; sectIdx < fileHeader->mNumberOfSections; sectIdx++)
{
BlSegment* section = NULL;
BlObjectDataSectInfo sectInfo = { -1 };
auto sectionHeader = &sectionHeaderArr[sectIdx];
bool isComdat = (sectionHeader->mCharacteristics & IMAGE_SCN_LNK_COMDAT) != 0;
if (sectionHeader->mPointerToRawData != 0)
data = (uint8*)objectData->mData + sectionHeader->mPointerToRawData;
char* sectionName = sectionHeader->mName;
if (sectionName[0] == '/')
{
int idx = atoi(sectionName + 1);
sectionName = &strTab[idx];
}
if (strncmp(sectionName, ".xdata", 6) == 0)
{
}
if (strncmp(sectionName, ".drectve", 5) == 0)
{
char* cmdStart = NULL;
auto _HandleParam = [&] (const StringImpl& cmd, const StringImpl& arg)
{
if (cmd == "/DEFAULTLIB")
{
String libName = arg;
int lastDot = (int)libName.LastIndexOf('.');
if (lastDot == -1)
libName += ".lib";
AddFile(libName, BlObjectDataKind_DirectiveLib);
}
else if (cmd == "/DISALLOWLIB")
{
String libName = arg;
FixLibName(libName);
String libCanonName = FixPathAndCase(libName);
// Make sure we haven't already used this library, if so then throw an error, otherwise
// just add it to the seen-list so we don't add it later
auto itr = mSeenLibs.find(libCanonName);
if (itr != mSeenLibs.end())
{
Fail(StrFormat("Disallowed lib '%s', disallowed in %s, has been used", arg.c_str(), ObjectDataIdxToString(objectData->mIdx).c_str()));
}
auto insertPair = mNoDefaultLibs.insert(libCanonName);
}
else if (cmd == "/MERGE")
{
int equalIdx = (int)arg.IndexOf('=');
if (equalIdx == -1)
return;
String fromName = arg.Substring(0, equalIdx);
String toName = arg.Substring(equalIdx + 1);
mSectionMerges[fromName] = toName;
}
else if (cmd == "/ALTERNATENAME")
{
int equalIdx = (int)arg.IndexOf('=');
if (equalIdx == -1)
return;
String fromName = arg.Substring(0, equalIdx);
String toName = arg.Substring(equalIdx + 1);
mSectionMerges[fromName] = toName;
auto blSymbol = mSymTable.Add(fromName.c_str());
if (blSymbol->mKind == BlSymKind_Undefined)
{
int remapIdx = (int)mRemapStrs.size();
mRemapStrs.push_back(toName);
blSymbol->mKind = BlSymKind_WeakSymbol;
blSymbol->mParam = remapIdx;
blSymbol->mObjectDataIdx = objectData->mIdx;
}
}
else if (cmd == "/EXPORT")
{
const StringImpl& exportName = arg;
auto pair = mExports.insert(std::make_pair(exportName, BlExport()));
if (!pair.second)
{
Warn(StrFormat("Export '%s' specified multiple times; using first specification", exportName.c_str()));
}
}
else if (cmd == "/FAILIFMISMATCH")
{
}
else if (cmd == "/EDITANDCONTINUE")
{
}
else if (cmd == "/THROWINGNEW")
{
}
else if (cmd == "/GUARDSYM")
{
}
else if (cmd == "/INCLUDE")
{
mForcedSyms.push_back(arg);
}
else
{
Fail(StrFormat("Invalid link option \"%s\" in %s", cmd.c_str(), ObjectDataIdxToString(objectData->mIdx).c_str()));
}
};
/*#ifdef _DEBUG
String dbgOut = "Directives for ";
dbgOut += ObjectDataIdxToString(objectData->mIdx);
dbgOut += ": ";
dbgOut.insert(dbgOut.end(), (char*)data, (char*)data + sectionHeader->mSizeOfRawData);
dbgOut += "\n";
OutputDebugStrF(dbgOut.c_str());
#endif*/
StringT<256> curCmd;
StringT<256> curArg;
bool inArg = false;
bool inQuote = false;
bool prevSlash = false;
for (char* cPtr = (char*)data; cPtr < (char*)data + sectionHeader->mSizeOfRawData; cPtr++)
{
char c = *cPtr;
if (c == 0)
break;
if (c == '"')
{
inQuote = !inQuote;
}
else if ((c == ' ') && (!inQuote))
{
if (!curCmd.empty())
{
_HandleParam(curCmd, curArg);
curCmd.clear();
curArg.clear();
inArg = false;
}
}
else if ((c == ':') && (!inQuote))
{
inArg = true;
}
else if (inArg)
curArg += c;
else
curCmd += toupper(c);
}
if (!curCmd.empty())
_HandleParam(curCmd, curArg);
}
else if (strcmp(sectionName, ".debug$T") == 0)
{
if (mCodeView != NULL)
{
sectInfo.mState = BlSectInfoState_QueuedDebugT;
if (!isComdat)
_CommitSection(sectIdx, sectInfo);
}
}
else if (strcmp(sectionName, ".debug$S") == 0)
{
mDbgSymSectsFound++;
if (mCodeView != NULL)
{
sectInfo.mState = BlSectInfoState_QueuedDebugS;
if (!isComdat)
_CommitSection(sectIdx, sectInfo);
}
}
else
{
if (strcmp(sectionName, ".bss") == 0)
{
sectionName = (char*)mBSSSeg->mName.c_str();
}
auto _CompareSectionInfo = [] (BlSegmentInfo* lhs, BlSegmentInfo* rhs)
{
return lhs->mName < rhs->mName;
};
sectionInfo.mName = sectionName;
auto itr = std::lower_bound(mOrderedSegments.begin(), mOrderedSegments.end(), &sectionInfo, _CompareSectionInfo);
if (itr != mOrderedSegments.end())
{
section = *itr;
if (section->mName != sectionName)
section = NULL;
}
if (section == NULL)
{
section = mDynSegments.Alloc();
section->mName = sectionName;
section->mContext = this;
section->mSegmentIdx = (int)mSegments.size();
mSegments.push_back(section);
mOrderedSegments.push_back(section);
std::sort(mOrderedSegments.begin(), mOrderedSegments.end(), _CompareSectionInfo);
}
}
/*else if (strncmp(sectionHeader->mName, ".text", 5) == 0)
{
section = &mTextSect;
}
else if (strncmp(sectionHeader->mName, ".rdata", 6) == 0)
{
section = &mRDataSect;
}
else if (strncmp(sectionHeader->mName, ".bss", 4) == 0)
{
section = &mBSSSect;
}*/
if (section != NULL)
{
// Add the alignment flags later
section->mCharacteristics |= (sectionHeader->mCharacteristics & ~IMAGE_SCN_ALIGN_MASK);
sectInfo.mSegmentIdx = section->mSegmentIdx;
if (isComdat)
{
sectInfo.mState = BlSectInfoState_QueuedData;
}
else
{
/*uint8* sectData = NULL;
if (sectionHeader->mPointerToRawData != NULL)
sectData = (uint8*)objectData->mData + sectionHeader->mPointerToRawData;
BlChunk* blChunk = section->AddChunk(sectData, sectionHeader->mSizeOfRawData, sectionHeader->mCharacteristics, sectInfo.mSectionOffset);
if (blChunk != NULL)
sectInfo.mChunkData = blChunk->mData;
orderedRelocSects.push_back(sectIdx);*/
_CommitSection(sectIdx, sectInfo);
}
}
data += sectionHeader->mSizeOfRawData;
if (sectionHeader->mPointerToRawData != 0)
sectInfo.mRelocData = (uint8*)objectData->mData + sectionHeader->mPointerToRelocations;
sectInfos.push_back(sectInfo);
}
data = (uint8*)objectData->mData + fileHeader->mPointerToSymbolTable;
PE_SymInfo* symInfoArr = (PE_SymInfo*)data;
//////// Read symbols
// This is the primary symbol creation loop
{
BL_AUTOPERF("BlContext::LoadFiles ReadSymbols");
symInfos.clear();
symInfos.resize(fileHeader->mNumberOfSymbols);
for (int symIdx = 0; symIdx < (int)fileHeader->mNumberOfSymbols; symIdx++)
{
auto& symInfo = symInfos[symIdx];
PE_SymInfo* objSym = (PE_SymInfo*)data;
data += sizeof(PE_SymInfo);
if ((objSym->mNumOfAuxSymbols != 0) && (objSym->mStorageClass == IMAGE_SYM_CLASS_STATIC))
{
BF_ASSERT(objSym->mSectionNum >= 1);
auto& sectInfo = sectInfos[objSym->mSectionNum - 1];
PE_SymInfoAux* symAuxInfo = (PE_SymInfoAux*)data;
sectInfo.mSelectNum = symAuxInfo->mNumber;
sectInfo.mSelection = symAuxInfo->mSelection;
symInfo.mKind = BlObjectDataSymInfo::Kind_Section;
symInfo.mSectionNum = objSym->mSectionNum;
symIdx += objSym->mNumOfAuxSymbols;
data += sizeof(PE_SymInfo) * objSym->mNumOfAuxSymbols;
continue;
}
if (objSym->mSectionNum == 0xFFFF)
{
symInfo.mSegmentIdx = -1;
symInfo.mSegmentOffset = objSym->mValue;
// Do anything with this? @comp.id, @feat.00
// Rich Signature stuff.
}
else if (objSym->mSectionNum != 0)
{
auto& sectInfo = sectInfos[objSym->mSectionNum - 1];
symInfo.mSegmentIdx = sectInfo.mSegmentIdx;
int sectOffset = sectInfo.mSegmentOffset;
symInfo.mSegmentOffset = sectInfo.mSegmentOffset + objSym->mValue;
}
if (objSym->mStorageClass == IMAGE_SYM_CLASS_LABEL)
{
auto& sectInfo = sectInfos[objSym->mSectionNum - 1];
if (sectInfo.mChunkData == (void*)-1)
{
// Don't let labels cause COMDAT commits
continue;
}
}
if ((objSym->mStorageClass != IMAGE_SYM_CLASS_EXTERNAL) &&
(objSym->mStorageClass != IMAGE_SYM_CLASS_EXTERNAL_DEF) &&
(objSym->mStorageClass != IMAGE_SYM_CLASS_WEAK_EXTERNAL))
{
if (objSym->mSectionNum != 0xFFFF)
{
auto& sectInfo = sectInfos[objSym->mSectionNum - 1];
if (sectInfo.mChunkData == (void*)-1)
{
_CommitSection(objSym->mSectionNum - 1, sectInfo);
symInfo.mSegmentOffset += sectInfo.mSegmentOffset;
}
}
BF_ASSERT(objSym->mSectionNum != 0);
continue;
}
char* symName;
if (objSym->mName[0] == 0)
{
symName = strTab + objSym->mNameOfs[1];
}
else
{
symName = objSym->mName;
if (symName[7] != 0) // Do we have to zero-terminate ourselves?
{
symName = (char*)mAlloc.AllocBytes(9);
memcpy(symName, objSym->mName, 8);
}
}
if ((objSym->mSectionNum == 0) && (objSym->mStorageClass != IMAGE_SYM_CLASS_WEAK_EXTERNAL))
{
if (objSym->mValue > 0)
{
// Zero-initialized value, where mValue is the size. I've only seen this occur in C
// files with zero-initialized local static variables
auto blSymbol = mSymTable.Add(symName);
if (blSymbol->mObjectDataIdx != -1)
continue;
int align = std::min(objSym->mValue, 16);
mBSSSeg->mAlign = std::max(mBSSSeg->mAlign, align);
mBSSSeg->mCurSize = BF_ALIGN(mBSSSeg->mCurSize, align);
symInfo.mSegmentIdx = mBSSSeg->mSegmentIdx;
symInfo.mSegmentOffset = mBSSSeg->mCurSize;
mBSSSeg->mCurSize += objSym->mValue;
blSymbol->mObjectDataIdx = objectData->mIdx;
blSymbol->mSegmentIdx = symInfo.mSegmentIdx;
blSymbol->mSegmentOffset = symInfo.mSegmentOffset;
continue;
}
else
{
// External reference
symInfo.mSym = mSymTable.Add(symName);
if (symInfo.mSym->mKind >= 0)
{
symInfo.mSegmentIdx = symInfo.mSym->mSegmentIdx;
symInfo.mSegmentOffset = symInfo.mSym->mSegmentOffset;
}
else
{
symInfo.mSegmentIdx = -1;
}
continue;
}
}
// Export
auto blSymbol = mSymTable.Add(symName);
if (blSymbol->mObjectDataIdx != -1)
{
bool usePrevSymbol = false;
if (objSym->mStorageClass == IMAGE_SYM_CLASS_WEAK_EXTERNAL)
{
symIdx += objSym->mNumOfAuxSymbols;
data += sizeof(PE_SymInfo) * objSym->mNumOfAuxSymbols;
usePrevSymbol = true; // Everything is higher priority than a weak external
}
else
{
BlObjectData* prevObjectData = mObjectDatas[blSymbol->mObjectDataIdx];
if (blSymbol->mKind == BlSymKind_WeakSymbol)
usePrevSymbol = false; // Always prefer a non-weak symbol
else if (prevObjectData->mKind > objectData->mKind)
usePrevSymbol = true; // Previous has higher priority, leave it
else if ((mBSSSeg != NULL) && (blSymbol->mSegmentIdx == mBSSSeg->mSegmentIdx))
{
// This came from an implicit "sized UNDEF" symbol, so allow it to be overriden with
// actual data
usePrevSymbol = false;
}
else if (prevObjectData->mKind == objectData->mKind)
{
auto& sectInfo = sectInfos[objSym->mSectionNum - 1];
if (sectInfo.mSelection == IMAGE_COMDAT_SELECT_ANY)
{
usePrevSymbol = true;
}
else if (sectInfo.mSelection == IMAGE_COMDAT_SELECT_LARGEST)
{
//TODO: Find actual chunk
usePrevSymbol = true;
}
else if (sectInfo.mSelection > 2)
{
Fail(StrFormat("Unsupported COMDAT selection '%d' found on symbol '%s' in %s", sectInfo.mSelection, GetSymDisp(symName).c_str(), ObjectDataIdxToString(objectData->mIdx).c_str()));
}
else
{
// Ambiguous priority, throw error
Fail(StrFormat("Duplicate symbol %s found in %s, first defined in %s", GetSymDisp(symName).c_str(), ObjectDataIdxToString(objectData->mIdx).c_str(),
ObjectDataIdxToString(blSymbol->mObjectDataIdx).c_str()));
}
}
}
if (usePrevSymbol)
{
if (blSymbol->mSegmentIdx >= 0)
{
symInfo.mSegmentIdx = blSymbol->mSegmentIdx;
symInfo.mSegmentOffset = blSymbol->mSegmentOffset;
}
else
{
symInfo.mSym = blSymbol;
}
continue;
}
}
if (objSym->mStorageClass == IMAGE_SYM_CLASS_WEAK_EXTERNAL)
{
struct _WeakExtern
{
int32 mTagIndex;
int32 mCharacteristics;
};
_WeakExtern* weakExtern = (_WeakExtern*)data;
PE_SymInfo* refSymInfo = &symInfoArr[weakExtern->mTagIndex];
char* refSymName;
if (refSymInfo->mName[0] == 0)
{
refSymName = strTab + refSymInfo->mNameOfs[1];
}
else
{
refSymName = refSymInfo->mName;
if (refSymName[7] != 0) // Do we have to zero-terminate ourselves?
{
refSymName = (char*)mAlloc.AllocBytes(9);
memcpy(refSymName, refSymInfo->mName, 8);
}
}
symInfo.mSym = blSymbol;
int remapIdx = (int)mRemapStrs.size();
mRemapStrs.push_back(refSymName);
mNumWeakSymbols++;
mForcedSyms.push_back(refSymName);
blSymbol->mKind = BlSymKind_WeakSymbol;
blSymbol->mParam = remapIdx;
blSymbol->mObjectDataIdx = objectData->mIdx;
symIdx += objSym->mNumOfAuxSymbols;
data += sizeof(PE_SymInfo) * objSym->mNumOfAuxSymbols;
continue;
}
auto& sectInfo = sectInfos[objSym->mSectionNum - 1];
if (sectInfo.mChunkData == (void*)-1)
{
_CommitSection(objSym->mSectionNum - 1, sectInfo);
symInfo.mSegmentOffset += sectInfo.mSegmentOffset;
}
blSymbol->mObjectDataIdx = objectData->mIdx;
blSymbol->mSegmentIdx = symInfo.mSegmentIdx;
blSymbol->mSegmentOffset = symInfo.mSegmentOffset;
}
}
// Any loaded COMDAT section with section associativities need to load those associated sections now
// This most often occurs with a debug$S entry for a COMDAT function, such as a template method.
// We only want to include the static debug info if the function is chosen.
while (true)
{
// We may need to iterate multiple times, if there are chained dependencies and a new commited
// depdency occurs after a pending dependent entry
bool commitedNew = false;
for (int sectIdx = 0; sectIdx < fileHeader->mNumberOfSections; sectIdx++)
{
auto sectionHeader = &sectionHeaderArr[sectIdx];
bool isComdat = (sectionHeader->mCharacteristics & IMAGE_SCN_LNK_COMDAT) != 0;
if (!isComdat)
continue;
auto& sectInfo = sectInfos[sectIdx];
if (sectInfo.IsUsed())
continue;
if (sectInfo.mSelection == IMAGE_COMDAT_SELECT_ASSOCIATIVE)
{
auto checkSelectInfo = sectInfos[sectInfo.mSelectNum - 1];
if (checkSelectInfo.IsUsed())
{
_CommitSection(sectIdx, sectInfo);
commitedNew = true;
}
}
}
if (!commitedNew)
break;
}
// Queue relocs
{
BL_AUTOPERF("BlContext::LoadFiles Relocs");
for (int ordIdx = 0; ordIdx < (int)orderedRelocSects.size(); ordIdx++)
{
int sectIdx = orderedRelocSects[ordIdx];
auto sectionHeader = &sectionHeaderArr[sectIdx];
auto& sectInfo = sectInfos[sectIdx];
if (sectInfo.mSegmentIdx == -1)
continue;
if (sectInfo.mChunkData == (void*)-1)
{
// Unused COMDAT, or is data
continue;
}
auto seg = mSegments[sectInfo.mSegmentIdx];
data = (uint8*)sectInfo.mRelocData;
bool isDebugSymSect = seg->mName == ".debug$S";
bool hadDeferredSyms = false;
int lastRelocOffset = 0;
if (!seg->mRelocs.empty())
lastRelocOffset = seg->mRelocs.back().mOutOffset;
for (int relocIdx = 0; relocIdx < sectionHeader->mNumberOfRelocations; relocIdx++)
{
COFFRelocation* reloc = (COFFRelocation*)data;
data += sizeof(COFFRelocation);
auto& sym = symInfos[reloc->mSymbolTableIndex];
int outOffset = sectInfo.mSegmentOffset + (int)reloc->mVirtualAddress;
if (sym.mSegmentIdx == -1)
{
//NotImpl();
/*auto symInfo = &symInfoArr[reloc->mSymbolTableIndex];
auto targetSectInfo = sectInfos[symInfo->mSectionNum - 1];
sym.mSectionIdx = targetSectInfo.mSectionIdx;
if (targetSectInfo.mChunkData == (void*)-1)
{
_CommitComdat(symInfo->mSectionNum - 1, targetSectInfo);
sym.mSectionOffset += targetSectInfo.mSectionOffset;
}*/
}
if (outOffset < lastRelocOffset)
{
NotImpl();
}
BlReloc blReloc;
blReloc.mOutOffset = outOffset;
if (sym.mSym != NULL)
{
/*if ((isDebugSymSect) && (sym.mSym->mSegmentIdx >= 0) && (sym.mSym->mSegmentIdx < mNumFixedSegs))
{
blReloc.mSegmentIdx = sym.mSym->mSegmentIdx;
blReloc.mSegmentOffset = sym.mSym->mSegmentOffset;
blReloc.mFlags = BeRelocFlags_Loc;
}
else*/
{
hadDeferredSyms = true;
blReloc.mSym = sym.mSym;
blReloc.mFlags = (BeRelocFlags)(BeRelocFlags_Sym | BeRelocFlags_SymIsNew);
}
}
else
{
BF_ASSERT(sym.mSegmentIdx != -1);
if (sym.mKind == BlObjectDataSymInfo::Kind_Section)
{
auto& sectInfo = sectInfos[sym.mSectionNum - 1];
blReloc.mSegmentIdx = sectInfo.mSegmentIdx;
blReloc.mSegmentOffset = sectInfo.mSegmentOffset;
}
else
{
blReloc.mSegmentIdx = sym.mSegmentIdx;
blReloc.mSegmentOffset = sym.mSegmentOffset;
}
blReloc.mFlags = BeRelocFlags_Loc;
}
/*if (sym.mIsFunc)
blReloc.mFlags = (BeRelocFlags)(blReloc.mFlags | BeRelocFlags_Func);*/
switch (reloc->mType)
{
case IMAGE_REL_AMD64_ADDR32NB:
blReloc.mKind = BlRelocKind_ADDR32NB;
//blReloc.mParam = *(int32*)((uint8*)sectInfo.mChunkData + reloc->mVirtualAddress);
break;
case IMAGE_REL_AMD64_ADDR64:
//TODO:
blReloc.mKind = BlRelocKind_ADDR64;
//blReloc.mParam = *(int64*)((uint8*)sectInfo.mChunkData + reloc->mVirtualAddress);
break;
case IMAGE_REL_AMD64_REL32:
blReloc.mKind = BlRelocKind_REL32;
//blReloc.mParam = *(int32*)((uint8*)sectInfo.mChunkData + reloc->mVirtualAddress);
break;
case IMAGE_REL_AMD64_REL32_1:
blReloc.mKind = BlRelocKind_REL32_1;
//blReloc.mParam = *(int32*)((uint8*)sectInfo.mChunkData + reloc->mVirtualAddress);
break;
case IMAGE_REL_AMD64_REL32_4:
blReloc.mKind = BlRelocKind_REL32_4;
//blReloc.mParam = *(int32*)((uint8*)sectInfo.mChunkData + reloc->mVirtualAddress);
break;
case IMAGE_REL_AMD64_SECREL:
blReloc.mKind = BlRelocKind_SECREL;
//blReloc.mParam = *(int32*)((uint8*)sectInfo.mChunkData + reloc->mVirtualAddress);
break;
case IMAGE_REL_AMD64_SECTION:
NotImpl();
break;
default:
NotImpl();
break;
}
lastRelocOffset = outOffset;
seg->mRelocs.push_back(blReloc);
}
}
}
if (mCodeView != NULL)
{
BL_AUTOPERF("BlContext::LoadFiles Cv FinishModule");
cvParser.FinishModule(sectionHeaderArr, sectInfos, symInfoArr, symInfos);
}
//TODO: Make so we can unmap memory-mapped data. Currently we can't do that because of string pointers in symbols
}
}
bool BlContext::HandleLibSymbolRef(BlSymbol* sym, int objectDataIds)
{
const char* name = sym->mName;
BlObjectData* objectData = mObjectDatas[objectDataIds];
if ((objectData->mLoadState == BlObjectDataLoadState_UnloadedLib) || (objectData->mLoadState == BlObjectDataLoadState_UnloadedThinLib))
{
mNumImportedObjs++;
bool isThinLib = objectData->mLoadState == BlObjectDataLoadState_UnloadedThinLib;
BlLibMemberHeader* header = (BlLibMemberHeader*)objectData->mData;
if ((header->mName[0] == '/') || (header->mName[0] == '\\'))
{
objectData->mName = objectData->mLib->mStrTable + atoi(header->mName + 1);
for (char* cPtr = objectData->mName; true; cPtr++)
{
// Thin string table entries end with "/\n" for some reason.
char c = *cPtr;
if (c == 0)
break;
if (c == '\n')
{
char* endC = cPtr;
if (cPtr[-1] == '/')
endC = cPtr - 1;
char* newStr = (char*)mAlloc.AllocBytes((int)(endC - objectData->mName + 1));
memcpy(newStr, objectData->mName, (int)(endC - objectData->mName));
newStr[endC - objectData->mName] = 0;
objectData->mName = newStr;
break;
}
}
}
else
{
char* slashPos = strchr(header->mName, '/');
BF_ASSERT(slashPos != NULL);
int len = (int)(slashPos - header->mName);
objectData->mName = (char*)mAlloc.AllocBytes(len + 1);
memcpy(objectData->mName, header->mName, len);
}
if (isThinLib)
{
auto mappedFile = mMappedFiles.Alloc();
String objPath = GetAbsPath(objectData->mName, GetFileDir(objectData->mLib->mFileName));
if (!mappedFile->Open(objPath))
{
Fail(StrFormat("Failed to open thin archive member \"%s\" from \"%s\"", objectData->mName, objectData->mLib->mFileName.c_str()));
}
else
{
objectData->mData = mappedFile->mData;
objectData->mSize = mappedFile->mFileSize;
BF_ASSERT(objectData->mData != NULL);
mObjectDataWorkQueue.push_back(objectData);
}
}
else
{
objectData->mSize = atoi(header->mSize);
objectData->mData = (uint8*)objectData->mData + sizeof(BlLibMemberHeader);
PEImportObjectHeader* importObjectHeader = (PEImportObjectHeader*)objectData->mData;
if ((importObjectHeader->mSig1 == 0) && (importObjectHeader->mSig2 == IMPORT_OBJECT_HDR_SIG2))
{
uint8* data = (uint8*)objectData->mData;
data += sizeof(PEImportObjectHeader);
char* symName = (char*)data;
char* dllName = symName + strlen(symName) + 1;
String dllFixedName = FixPathAndCase(dllName);
BlImportFile* blImportFile;
auto itr = mImportFiles.find(dllFixedName);
if (itr != mImportFiles.end())
{
blImportFile = &itr->second;
}
else
{
blImportFile = &(mImportFiles.insert(std::make_pair(dllFixedName, BlImportFile())).first->second);
}
//OutputDebugStrF("Imported: %s:%s\n", dllName, symName);
int objType = (importObjectHeader->mType) & 3;
int nameType = importObjectHeader->mType >> 2;
auto blLookup = blImportFile->mLookups.Alloc();
if (nameType != IMPORT_OBJECT_ORDINAL)
blLookup->mName = symName;
blLookup->mHint = importObjectHeader->mHint;
if (strncmp(name, "__imp_", 6) == 0)
sym->mKind = BlSymKind_ImportImp;
else
sym->mKind = BlSymKind_Import;
sym->mParam = (int)mImportLookups.size();
mImportLookups.push_back(blLookup);
objectData->mLoadState = BlObjectDataLoadState_ImportObject;
objectData->mImportSym = sym;
}
else
{
BF_ASSERT(objectData->mData != NULL);
mObjectDataWorkQueue.push_back(objectData);
}
}
return true;
}
else if (objectData->mLoadState == BlObjectDataLoadState_ImportObject)
{
// We have both a "_imp_<X>" and "<X>" import name, so link those together
BF_ASSERT((objectData->mImportSym->mKind == BlSymKind_Import) || (objectData->mImportSym->mKind == BlSymKind_ImportImp));
if (strncmp(name, "__imp_", 6) == 0)
sym->mKind = BlSymKind_ImportImp;
else
sym->mKind = BlSymKind_Import;
sym->mParam = objectData->mImportSym->mParam;
return true;
}
else
{
return false;
}
}
BlSymbol* BlContext::ProcessSymbol(BlSymbol* sym)
{
// Try to load symbol from a lib if we need to
bool madeProgress = false;
while (sym->mKind == BlSymKind_WeakSymbol)
{
sym = mSymTable.Add(mRemapStrs[sym->mParam].c_str());
madeProgress = true;
}
if (sym->mKind == BlSymKind_LibSymbolRef)
{
madeProgress |= HandleLibSymbolRef(sym, sym->mParam);
}
else if (sym->mKind == BlSymKind_LibSymbolGroupRef)
{
// This symbol is reported in multiple libraries
for (auto objectDataIdx : mImportGroups[sym->mParam]->mObjectDatas)
{
madeProgress |= HandleLibSymbolRef(sym, objectDataIdx);
if (madeProgress)
{
// We only want to load ONE new object file, otherwise we could end up with multiple definitions
break;
}
}
}
else
madeProgress = true;
if ((!madeProgress) && (mObjectDataWorkQueue.empty()))
{
// If the mObjectDataWorkQueue is empty, that means we already tried to load a lib's object file
// that was supposed to define this symbol, but it didn't. This shouldn't happen in a well-formed lib
// unless we have a bug.
BF_ASSERT("Library error?" == 0);
sym->mKind = BlSymKind_Undefined;
}
return sym;
}
BlSymbol* BlContext::ResolveSym(const char* name, bool throwError)
{
auto sym = mSymTable.Add(name);
if ((throwError) && (sym->mKind == BlSymKind_Undefined))
{
BlSymNotFound symNotFound;
symNotFound.mSym = sym;
symNotFound.mOutOffset = -1;
symNotFound.mSegmentIdx = -1;
mSymNotFounds.push_back(symNotFound);
return sym;
}
sym = ProcessSymbol(sym);
return sym;
}
uint64 BlContext::GetSymAddr(BlSymbol* sym)
{
if (sym->mSegmentIdx < 0)
{
if (sym->mKind == BlSymKind_Absolute)
return sym->mSegmentOffset;
return 0;
}
auto segment = mSegments[sym->mSegmentIdx];
return segment->mRVA + sym->mSegmentOffset;
}
void BlContext::AddAbsoluteSym(const char * name, int val)
{
auto sym = mSymTable.Add(name);
sym->mObjectDataIdx = -1;
sym->mKind = BlSymKind_Absolute;
sym->mParam = val;
}
void BlContext::PlaceSections()
{
std::multimap<String, BlSegment*> groupedSections;
mSectionMerges[".text"] = "!0.text";
mSectionMerges[".rdata"] = "!1.rdata";
mSectionMerges[".data"] = "!2.data";
mSectionMerges[".bss"] = "!3.bss";
mSectionMerges[".pdata"] = "!4.pdata";
mSectionMerges[".idata"] = "!5.idata";
mSectionMerges[".gfids"] = "!6.gfids";
mSectionMerges[".00cfg"] = "!7.00cfg";
mSectionMerges[".rsrc"] = "!9.rsrc";
mSectionMerges[".reloc"] = "!9.reloc";
mSectionMerges[".tls"] = "!A.tls";
mSectionMerges[".xdata"] = "!B.xdata";
for (auto sect : mOrderedSegments)
{
auto sectName = sect->mName;
int dollarPos = (int)sectName.IndexOf('$');
if (dollarPos != -1)
sectName.RemoveToEnd(dollarPos);
while (true)
{
auto mergeItr = mSectionMerges.find(sectName);
if (mergeItr == mSectionMerges.end())
break;
sectName = mergeItr->second;
}
groupedSections.insert(std::make_pair(sectName, sect));
}
BlOutSection* outSection = NULL;
int outSectionIdx = -1;
for (auto pair : groupedSections)
{
auto baseName = pair.first;
auto sect = pair.second;
if (baseName[0] == '!')
baseName.Remove(0, 2);
if ((outSection == NULL) || (outSection->mName != baseName))
{
outSection = mOutSections.Alloc();
outSection->mName = baseName;
outSectionIdx++;
outSection->mIdx = outSectionIdx;
}
BF_ASSERT((sect->mOutSectionIdx == -1) || (sect->mOutSectionIdx == outSectionIdx));
sect->mOutSectionIdx = outSectionIdx;
outSection->mSegments.push_back(sect);
outSection->mCharacteristics |= sect->mCharacteristics;
//outSection->mRawSize = (outSection->mRawSize + (sect->mAlign - 1)) & ~(sect->mAlign - 1);
outSection->mAlign = std::max(outSection->mAlign, sect->mAlign);
//outSection->mRawSize += sect->mCurSize;
}
int32 curRVA = 0x1000;
int rawDataPos = (int)sizeof(PEHeader);
rawDataPos += 0xB0; // DOS program
rawDataPos += (int)sizeof(PE_NTHeaders64);
rawDataPos += (int)mOutSections.size() * sizeof(PESectionHeader);
rawDataPos = (rawDataPos + (512 - 1)) & ~(512 - 1);
for (auto outSection : mOutSections)
{
bool isUninitialized = false;
outSection->mRawDataPos = rawDataPos;
outSection->mRVA = curRVA;
for (auto sect : outSection->mSegments)
{
if ((!isUninitialized) && ((sect->mCharacteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA) != 0))
{
// This is for when transition from .data to .bss
int endRVA = (curRVA + (512 - 1)) & ~(512 - 1);
outSection->mRawSize = endRVA - outSection->mRVA;
isUninitialized = true;
}
curRVA = (curRVA + (sect->mAlign - 1)) & ~(sect->mAlign - 1);
sect->mRVA = curRVA;
curRVA += sect->mCurSize;
}
// Virtual size is NOT size-aligned
outSection->mVirtualSize = curRVA - outSection->mRVA;
if (!isUninitialized)
{
curRVA = (curRVA + (512 - 1)) & ~(512 - 1);
outSection->mRawSize = curRVA - outSection->mRVA;
}
curRVA = (curRVA + (4096 - 1)) & ~(4096 - 1);
rawDataPos += outSection->mRawSize;
int characteristics = outSection->mCharacteristics;
if (outSection->mAlign == 8192) characteristics |= IMAGE_SCN_ALIGN_8192BYTES;
else if (outSection->mAlign == 4096) characteristics |= IMAGE_SCN_ALIGN_4096BYTES;
else if (outSection->mAlign == 2048) characteristics |= IMAGE_SCN_ALIGN_2048BYTES;
else if (outSection->mAlign == 1024) characteristics |= IMAGE_SCN_ALIGN_1024BYTES;
else if (outSection->mAlign == 512) characteristics |= IMAGE_SCN_ALIGN_512BYTES;
else if (outSection->mAlign == 256) characteristics |= IMAGE_SCN_ALIGN_256BYTES;
else if (outSection->mAlign == 128) characteristics |= IMAGE_SCN_ALIGN_128BYTES;
else if (outSection->mAlign == 64) characteristics |= IMAGE_SCN_ALIGN_64BYTES;
else if (outSection->mAlign == 32) characteristics |= IMAGE_SCN_ALIGN_32BYTES;
else if (outSection->mAlign == 16) characteristics |= IMAGE_SCN_ALIGN_16BYTES;
else if (outSection->mAlign == 8) characteristics |= IMAGE_SCN_ALIGN_8BYTES;
else if (outSection->mAlign == 4) characteristics |= IMAGE_SCN_ALIGN_4BYTES;
else if (outSection->mAlign == 2) characteristics |= IMAGE_SCN_ALIGN_2BYTES;
outSection->mCharacteristics = characteristics;
}
}
void BlContext::ResolveRelocs()
{
BL_AUTOPERF("BlContext::ResolveRelocs");
int startProcessingSegIdx = mProcessingSegIdx;
while (true)
{
auto seg = mSegments[mProcessingSegIdx];
//for (auto& reloc : seg->mRelocs)
while (seg->mResolvedRelocIdx < (int)seg->mRelocs.size())
{
auto& reloc = seg->mRelocs[seg->mResolvedRelocIdx];
if ((reloc.mFlags & BeRelocFlags_Sym) != 0)
{
}
if ((reloc.mFlags & (BeRelocFlags_SymIsNew | BeRelocFlags_Sym)) == (BeRelocFlags_SymIsNew | BeRelocFlags_Sym))
{
auto sym = reloc.mSym;
sym = ProcessSymbol(sym);
reloc.mSym = sym;
if (sym->mKind == BlSymKind_Undefined)
{
BlSymNotFound symNotFound;
symNotFound.mOutOffset = reloc.mOutOffset;
symNotFound.mSegmentIdx = seg->mSegmentIdx;
symNotFound.mSym = sym;
mSymNotFounds.push_back(symNotFound);
//reloc.mFlags = (BeRelocFlags)(reloc.mFlags & ~BeRelocFlags_SymIsN | BeRelocFlags_Sym);
//reloc.mSym = sym;
}
else
{
bool didLocSet = false;
if ((sym->mObjectDataIdx != -1) && (sym->mSegmentIdx >= 0))
{
BlObjectData* symObjectData = mObjectDatas[sym->mObjectDataIdx];
if (symObjectData->mKind == BlObjectDataKind_SpecifiedObj)
{
// If this sym comes from a specified object file then it can't be overwritten, we can resolve now
reloc.mFlags = (BeRelocFlags)(reloc.mFlags & ~BeRelocFlags_Sym | BeRelocFlags_Loc);
reloc.mSegmentIdx = sym->mSegmentIdx;
reloc.mSegmentOffset = sym->mSegmentOffset;
didLocSet = true;
}
}
/*if (!didLocSet)
{
reloc.mFlags = (BeRelocFlags)(reloc.mFlags & ~BeRelocFlags_SymName | BeRelocFlags_Sym);
reloc.mSym = sym;
}*/
}
}
if ((reloc.mFlags & BeRelocFlags_SymIsNew) != 0)
reloc.mFlags = (BeRelocFlags)(reloc.mFlags & ~BeRelocFlags_SymIsNew);
// Handle any work queue items and then retry this reloc on next pass through ResolveRelocs
if (!mObjectDataWorkQueue.empty())
return;
seg->mResolvedRelocIdx++;
}
mProcessingSegIdx = (mProcessingSegIdx + 1) % (int)mSegments.size();
if (mProcessingSegIdx == startProcessingSegIdx)
break;
}
}
static bool IsResIdNamed(const char16_t* id)
{
return ((uintptr)id >= 0x10000);
}
static const char16_t* ParseResStr(uint8*& data)
{
char16_t& firstC = GET(char16_t);
if (firstC == 0xFFFF)
{
int16 id = GET(int16);
return (const char16_t*)(intptr)id;
}
while (true)
{
char16_t& nextC = GET(char16_t);
if (nextC == 0)
break;
}
return &firstC;
}
void BlContext::LoadResourceData(BlObjectData* objectData)
{
uint8* data = (uint8*)objectData->mData;
uint8* dataEnd = data + objectData->mSize;
while (data < dataEnd)
{
uint32 dataSize = GET(uint32);
uint32 headerSize = GET(uint32);
const char16_t* resType = ParseResStr(data);
const char16_t* resName = ParseResStr(data);
PTR_ALIGN(data, (uint8*)objectData->mData, 4);
uint32 dataVersion = GET(uint32);
uint16 memoryFlags = GET(uint16);
uint16 languageId = GET(uint16);
uint32 version = GET(uint32);
uint32 characteristics = GET(uint32);
if (dataSize == 0)
{
PTR_ALIGN(data, (uint8*)objectData->mData, 4);
continue;
}
// Index by type
BlResDirectory* typeResDir;
auto pair = mRootResDirectory.mEntries.insert(std::make_pair(resType, (BlResEntry*)NULL));
if (pair.second)
{
typeResDir = mResEntries.Alloc<BlResDirectory>();
typeResDir->mIsDir = true;
pair.first->second = typeResDir;
}
else
typeResDir = (BlResDirectory*)pair.first->second;
// Index by name
BlResDirectory* nameResDir;
pair = typeResDir->mEntries.insert(std::make_pair(resName, (BlResEntry*)NULL));
if (pair.second)
{
nameResDir = mResEntries.Alloc<BlResDirectory>();
nameResDir->mIsDir = true;
pair.first->second = nameResDir;
}
else
nameResDir = (BlResDirectory*)pair.first->second;
// Index by language
pair = nameResDir->mEntries.insert(std::make_pair((const char16_t*)(intptr)languageId, (BlResEntry*)NULL));
if (pair.second)
{
auto resData = mResEntries.Alloc<BlResData>();
resData->mIsDir = false;
pair.first->second = resData;
resData->mData = (uint8*)data;
resData->mSize = dataSize;
}
data += dataSize;
PTR_ALIGN(data, (uint8*)objectData->mData, 4);
}
}
void BlContext::LoadDefData(BlObjectData* objectData)
{
uint8* data = (uint8*)objectData->mData;
uint8* dataEnd = data + objectData->mSize;
char* cmdStart = (char*)data;
bool isSep = false;
std::vector<String> args;
int lineNum = 1;
auto _Fail = [&] (const StringImpl& err)
{
Fail(StrFormat("%s in %s on line %d", err.c_str(), ObjectDataIdxToString(objectData->mIdx).c_str(), lineNum));
};
bool inExports = false;
while (true)
{
char c;
auto cPtr = (char*)data;
if (data == dataEnd)
c = 0;
else
c = GET(char);
bool newIsSep = (c == ',') || (c == '=') || (c == '.');
if ((isspace(c)) || (c == 0) || (newIsSep) || (isSep))
{
if (cmdStart != NULL)
{
String str((char*)cmdStart, cPtr);
args.emplace_back(str);
cmdStart = NULL;
}
}
isSep = newIsSep;
if ((cmdStart == NULL) && (!isspace(c)))
{
cmdStart = cPtr;
}
if (((c == '\r') || (c == '\n') || (c == 0)) &&
(!args.empty()))
{
if (args[0] == "LIBRARY")
{
// Ignore
}
else if (args[0] == "EXPORTS")
{
inExports = true;
if (args.size() != 1)
_Fail("Invalid argument");
}
else if (args[0] == "HEAPSIZE")
{
if (args.size() == 2)
{
int reserve = strtol(args[1].c_str(), NULL, 0);
if (reserve != 0)
mHeapReserve = BF_ALIGN(reserve, 4);
}
else if (args.size() == 4)
{
int reserve = strtol(args[1].c_str(), NULL, 0);
if (args[2] != ",")
_Fail("Invalid arguments");
int commit = strtol(args[3].c_str(), NULL, 0);
if (reserve != 0)
mHeapReserve = BF_ALIGN(reserve, 4);
if (commit != 0)
mHeapCommit = BF_ALIGN(commit, 4);
}
else
{
_Fail("Invalid number of arguments for HEAPSIZE");
}
}
else if (args[0] == "STACKSIZE")
{
if (args.size() == 2)
{
int reserve = strtol(args[1].c_str(), NULL, 0);
if (reserve != 0)
mHeapReserve = BF_ALIGN(reserve, 4);
}
else if (args.size() == 4)
{
int reserve = strtol(args[1].c_str(), NULL, 0);
if (args[2] != ",")
_Fail("Invalid arguments");
int commit = strtol(args[3].c_str(), NULL, 0);
if (reserve != 0)
mStackReserve = BF_ALIGN(reserve, 4);
if (commit != 0)
mStackCommit = BF_ALIGN(commit, 4);
}
else
{
_Fail("Invalid number of arguments for STACKSIZE");
}
}
else if (args[0] == "VERSION")
{
if (args.size() == 2)
{
mPeVersionMajor = strtol(args[1].c_str(), NULL, 0);
}
else if (args.size() == 4)
{
mPeVersionMajor = strtol(args[1].c_str(), NULL, 0);
if (args[2] != ".")
_Fail("Invalid arguments");
mPeVersionMinor = strtol(args[3].c_str(), NULL, 0);
}
else
{
_Fail("Invalid number of arguments for VERSION");
}
}
else if (inExports)
{
BlExport blExport;
String name = args[0];
for (int argIdx = 1; argIdx < (int)args.size(); argIdx++)
{
auto& arg = args[argIdx];
if ((argIdx == 1) && (arg == "="))
{
argIdx++;
blExport.mSrcName = args[argIdx];
continue;
}
if (arg[0] == '@')
{
blExport.mOrdinal = strtol(arg.c_str() + 1, NULL, 0);
blExport.mOrdinalSpecified = true;
}
else if (arg == "NONAME")
{
blExport.mNoName = true;
}
else if (arg == "PRIVATE")
{
blExport.mIsPrivate = true;
}
else if (arg == "DATA")
{
blExport.mIsData = true;
}
else
_Fail("Invalid export argument");
}
auto pair = mExports.insert(std::make_pair(name, blExport));
if (!pair.second)
{
Warn(StrFormat("Export '%s' specified multiple times; using first specification", name.c_str()));
}
//mExports[name] = export;
}
else
{
_Fail("Unrecognized command");
}
// Process
args.clear();
}
if (c == '\n')
lineNum++;
if (c == 0)
break;
}
}
void BlContext::Init(bool is64Bit, bool isDebug)
{
char cwd[MAX_PATH];
_getcwd(cwd, MAX_PATH);
AddSearchPath(cwd);
AddSearchPath("C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\lib\\amd64\\");
AddSearchPath("C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\atlmfc\\lib\\amd64\\");
AddSearchPath("C:\\Program Files (x86)\\Windows Kits\\10\\lib\\10.0.10240.0\\ucrt\\x64\\");
AddSearchPath("C:\\Program Files (x86)\\Windows Kits\\8.1\\lib\\winv6.3\\um\\x64\\");
if (!mNoDefaultLib)
{
for (auto& libNameSrc : mDefaultLibs)
{
String libName = libNameSrc;
FixLibName(libName);
String libCanonName = FixPathAndCase(libName);
auto itr = mNoDefaultLibs.find(libCanonName);
if (itr == mNoDefaultLibs.end())
AddFile(libName, BlObjectDataKind_DefaultLib);
}
/*AddFile("libcmtd.lib", BlObjectDataKind_DefaultLib);
AddFile("oldnames.lib", BlObjectDataKind_DefaultLib);
AddFile("vcruntimed.lib", BlObjectDataKind_DefaultLib);
AddFile("ucrtd.lib", BlObjectDataKind_DefaultLib);*/
}
}
void BlContext::AddSearchPath(const StringImpl& directory)
{
String dir = directory;
if (!dir.empty())
{
char endC = dir[dir.length() - 1];
if ((endC != '\\') && (endC != '/'))
dir += "\\";
}
mSearchPaths.push_back(dir);
}
bool BlContext::DoAddFile(const StringImpl& path, BlObjectDataKind objectDataKind)
{
auto mappedFile = mMappedFiles.Alloc();
if (!mappedFile->Open(path))
{
Fail(StrFormat("Failed to open file: %s", path.c_str()));
return false;
}
BF_ASSERT(mappedFile->mData != NULL);
bool isLib = (objectDataKind != BlObjectDataKind_SpecifiedObj);
if (isLib)
{
BL_AUTOPERF("BlContext::AddFile ReadLib");
mNumLibs++;
bool isThinLib = (isLib) && (strncmp((char*)mappedFile->mData, "!<thin>\n", 8) == 0);
if ((!isThinLib) && (strncmp((char*)mappedFile->mData, "!<arch>\n", 8) != 0))
{
Fail(StrFormat("Invalid lib file format: %s", path.c_str()));
return false;
}
uint8* data = (uint8*)mappedFile->mData;
uint8* dataEnd = data + mappedFile->mFileSize;
data += 8;
std::vector<int> objectDataIndices;
const int minMemberSize = sizeof(BlLibMemberHeader);
objectDataIndices.resize(mappedFile->mFileSize / minMemberSize + 1, -1);
auto blLib = mLibs.Alloc();
blLib->mFileName = path;
int memberIdx = 0;
while (data < dataEnd)
{
BlLibMemberHeader* header = (BlLibMemberHeader*)data;
//BfBitSet archUsed;
//archUsed.Init(mappedFile->mFileSize);
data += sizeof(BlLibMemberHeader);
if ((strncmp(header->mName, "/ ", 2) == 0) && (memberIdx == 0))
{
int numSymbols = FromBigEndian(*(int32*)data);
data += 4;
uint8* strTab = data + numSymbols * 4;
for (int symIdx = 0; symIdx < numSymbols; symIdx++)
{
//OutputDebugStrF("LibSym: %s:%s\n", fileName.c_str(), (const char*)strTab);
auto blSymbol = mSymTable.Add((const char*)strTab);
strTab += strlen((char*)strTab) + 1;
if (blSymbol->mKind == BlSymKind_LibSymbolRef)
{
int groupId = (int)mImportGroups.size();
auto importGroup = mImportGroups.Alloc();
importGroup->mObjectDatas.push_back(blSymbol->mParam);
blSymbol->mKind = BlSymKind_LibSymbolGroupRef;
blSymbol->mParam = groupId;
}
if ((blSymbol->mKind != BlSymKind_Undefined) && (blSymbol->mKind != BlSymKind_WeakSymbol) &&
(blSymbol->mKind != BlSymKind_LibSymbolGroupRef))
continue;
int offset = FromBigEndian(((int32*)data)[symIdx]);
int memberNum = offset / minMemberSize;
int objectDataIdx = objectDataIndices[memberNum];
if (objectDataIdx == -1)
{
objectDataIdx = (int)mObjectDatas.size();
auto objectData = mObjectDatas.Alloc();
if (objectDataKind == BlObjectDataKind_SpecifiedObj)
objectData->mKind = BlObjectDataKind_SpecifiedLib;
else
objectData->mKind = objectDataKind;
objectData->mIdx = objectDataIdx;
objectData->mLib = blLib;
objectData->mData = (uint8*)mappedFile->mData + offset;
objectData->mLoadState = isThinLib ? BlObjectDataLoadState_UnloadedThinLib : BlObjectDataLoadState_UnloadedLib;
objectDataIndices[memberNum] = objectDataIdx;
}
if (blSymbol->mKind == BlSymKind_LibSymbolGroupRef)
{
auto importGroup = mImportGroups[blSymbol->mParam];
importGroup->mObjectDatas.push_back(objectDataIdx);
}
else
{
blSymbol->mKind = BlSymKind_LibSymbolRef;
blSymbol->mParam = objectDataIdx;
blSymbol->mObjectDataIdx = -1;
}
}
}
if (strncmp(header->mName, "// ", 3) == 0)
{
blLib->mStrTable = (char*)data;
break;
}
int len = atoi(header->mSize);
len = (len + 1) & ~1; // Even addr
data = (uint8*)header + sizeof(BlLibMemberHeader) + len;
memberIdx++;
}
}
else
{
mNumObjFiles++;
int objectDataIdx = (int)mObjectDatas.size();
auto objectData = mObjectDatas.Alloc();
objectData->mKind = objectDataKind;
objectData->mIdx = objectDataIdx;
objectData->mName = (char*)mAlloc.AllocBytes((int)path.length() + 1);
memcpy(objectData->mName, path.c_str(), path.length() + 1);
objectData->mData = mappedFile->mData;
objectData->mSize = mappedFile->mFileSize;
BF_ASSERT(objectData->mData != NULL);
mObjectDataWorkQueue.push_back(objectData);
}
return true;
}
bool BlContext::AddFile(const StringImpl& fileName, BlObjectDataKind objectDataKind)
{
BL_AUTOPERF("BlContext::AddFile");
bool isLib = false;
int dotPos = (int)fileName.LastIndexOf('.');
if ((dotPos != -1) && (strncmp(fileName.c_str() + dotPos, ".lib", 4) == 0))
{
String lookupStr = FixPathAndCase(fileName);
if (!mSeenLibs.insert(lookupStr).second)
return true; // Already seen
isLib = true;
if (objectDataKind == BlObjectDataKind_SpecifiedObj)
objectDataKind = BlObjectDataKind_SpecifiedLib;
}
bool isAbsPath = (fileName.length() >= 2) &&
((fileName[0] == '/') || (fileName[0] == '\\') || (fileName[1] == ':'));
if (isAbsPath)
{
if (FileExists(fileName))
return DoAddFile(fileName, objectDataKind);
}
else
{
String path;
String actualFileName;
for (auto& searchPath : mSearchPaths)
{
path = searchPath;
path += fileName;
if (FileExists(path, &actualFileName))
{
path = FixFilePath(path, actualFileName);
return DoAddFile(path, objectDataKind);
}
}
}
Fail(StrFormat("Unable to locate file: %s", fileName.c_str()));
return false;
}
void BlContext::PopulateIData_LookupTable(BlSegment* iDataSect, int& hintNameTableSize)
{
int importLookupTableSize = ((int)mImportLookups.size() + (int)mImportFiles.size()) * 8;
int importDirectoryTableSize = ((int)mImportFiles.size() + 1) * 20;
int hintNameTableOfs = importLookupTableSize + importDirectoryTableSize + importLookupTableSize;
// Import lookup table
for (auto& importFilePair : mImportFiles)
{
auto& importFile = importFilePair.second;
for (auto lookup : importFile.mLookups)
{
if (lookup->mName.empty())
{
mImportStream.Write((int64)0x8000000000000000LL | lookup->mHint);
}
else
{
mImportStream.Write((int64)iDataSect->mRVA + hintNameTableOfs + hintNameTableSize);
hintNameTableSize += 2;
hintNameTableSize += (int)lookup->mName.length() + 1;
if ((hintNameTableSize % 2) == 1)
hintNameTableSize++;
}
}
mImportStream.Write((int64)0);
}
}
void BlContext::PopulateIData(BlSegment* iDataSect)
{
int importLookupTableSize = ((int)mImportLookups.size() + (int)mImportFiles.size()) * 8;
int hintNameTableSize = 0;
PopulateIData_LookupTable(iDataSect, hintNameTableSize);
int idataIdx = 0;
int thunkIdx = 0;
for (auto& importFilePair : mImportFiles)
{
auto& importFile = importFilePair.second;
for (auto lookup : importFile.mLookups)
{
lookup->mThunkIdx = thunkIdx++;
lookup->mIDataIdx = idataIdx++;
}
idataIdx++; // For NULL entry
}
int importDirectoryTableSize = ((int)mImportFiles.size() + 1) * 20;
int importDirOfs = importLookupTableSize;
int importLookupOfs = importDirOfs + importDirectoryTableSize;
int hintNameTableOfs = importLookupTableSize + importDirectoryTableSize + importLookupTableSize;
int strTableOfs = hintNameTableOfs + hintNameTableSize;
// Import directory
int curLookupIdx = 0;
for (auto& importFilePair : mImportFiles)
{
auto& importFileName = importFilePair.first;
auto& importFile = importFilePair.second;
mImportStream.Write((int32)(iDataSect->mRVA + importLookupOfs + curLookupIdx*8)); // Import lookup table RVA
mImportStream.Write((int32)0); // Timestamp
mImportStream.Write((int32)0); // Forwarder chain
mImportStream.Write((int32)(iDataSect->mRVA + strTableOfs)); // Name RVA
mImportStream.Write((int32)(iDataSect->mRVA + curLookupIdx * 8)); // Import address table RVA
curLookupIdx += (int)importFile.mLookups.size() + 1;
strTableOfs += (int)importFileName.length() + 1;
}
// Empty import directory entry terminates
mImportStream.WriteZeros(20);
hintNameTableSize = 0;
PopulateIData_LookupTable(iDataSect, hintNameTableSize);
// Hint/Name Table
for (auto& importFilePair : mImportFiles)
{
auto& importFile = importFilePair.second;
for (auto lookup : importFile.mLookups)
{
if (!lookup->mName.empty())
{
mImportStream.Write((int16)lookup->mHint);
mImportStream.Write((void*)lookup->mName.c_str(), (int)lookup->mName.length() + 1);
if ((mImportStream.GetPos() % 2) == 1)
mImportStream.Write((uint8)0);
}
}
}
// Str table
for (auto& importFilePair : mImportFiles)
{
auto& importFileName = importFilePair.first;
mImportStream.Write((void*)importFileName.c_str(), (int)importFileName.length() + 1);
}
BF_ASSERT(mImportStream.GetPos() == strTableOfs);
BlChunk chunk;
chunk.mOffset = 0;
chunk.mAlignPad = 0;
chunk.mData = (void*)&mImportStream.mData[0];
chunk.mSize = mImportStream.GetSize();
iDataSect->mChunks.push_back(chunk);
BF_ASSERT(iDataSect->mCurSize == chunk.mSize);
}
BlSegment* BlContext::CreateIData()
{
auto iDataSect = mDynSegments.Alloc();
iDataSect->mName = ".idata";
iDataSect->mContext = this;
iDataSect->mSegmentIdx = (int)mSegments.size();
iDataSect->mAlign = 8;
iDataSect->mCharacteristics = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ;
mSegments.push_back(iDataSect);
mOrderedSegments.push_back(iDataSect);
int hintNameTableSize = 0;
for (auto& importFilePair : mImportFiles)
{
auto& importFile = importFilePair.second;
for (auto lookup : importFile.mLookups)
{
if (!lookup->mName.empty())
{
hintNameTableSize += 2;
hintNameTableSize += (int)lookup->mName.length() + 1;
if ((hintNameTableSize % 2) == 1)
hintNameTableSize++;
}
}
}
int importLookupTableSize = ((int)mImportLookups.size() + (int)mImportFiles.size()) * 8;
int importDirectoryTableSize = ((int)mImportFiles.size() + 1) * 20;
int hintNameTableOfs = importLookupTableSize + importDirectoryTableSize + importLookupTableSize;
int strTableOfs = hintNameTableOfs + hintNameTableSize;
// Import directory
int curLookupIdx = 0;
for (auto& importFilePair : mImportFiles)
{
auto& importFileName = importFilePair.first;
strTableOfs += (int)importFileName.length() + 1;
}
iDataSect->mCurSize = strTableOfs;
return iDataSect;
}
BlSegment* BlContext::CreateThunkData()
{
if (mImportLookups.empty())
return NULL;
auto thunkSect = mDynSegments.Alloc();
thunkSect->mName = ".text$thunk";
thunkSect->mContext = this;
thunkSect->mSegmentIdx = (int)mSegments.size();
thunkSect->mAlign = 8;
thunkSect->mCharacteristics = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_EXECUTE;
mSegments.push_back(thunkSect);
mOrderedSegments.push_back(thunkSect);
thunkSect->mCurSize = (int)mImportLookups.size() * 6;
return thunkSect;
}
void BlContext::PopulateExportData(BlSegment* exportSeg)
{
std::vector<uint32> rvaMap;
String libName = GetFileName(mOutName);
DynMemStream strTab;
int numNames = 0;
int maxOrdinal = 0;
for (auto& exportPair : mExports)
{
const StringImpl& name = exportPair.first;
auto& blExport = exportPair.second;
String symName;
if (!blExport.mSrcName.empty())
symName = blExport.mSrcName;
else
symName = name;
if (!blExport.mNoName)
numNames++;
int ordIdx = blExport.mOrdinal - 1;
while (ordIdx >= rvaMap.size())
rvaMap.push_back(0);
auto sym = ResolveSym(symName.c_str(), false);
if (sym == NULL)
{
Fail(StrFormat("Unable to find exported symbol '%s'", symName.c_str()));
}
else
{
rvaMap[ordIdx] = (uint32)GetSymAddr(sym);
}
}
int numEntries = maxOrdinal - 1;
int32 funcRVA = exportSeg->mRVA + (int)sizeof(IMAGE_EXPORT_DIRECTORY);
int32 namePtrTabRVA = funcRVA + (int)rvaMap.size() * 4;
int32 ordTabRVA = namePtrTabRVA + numNames * 4;
int32 strTabRVA = ordTabRVA + numNames * 2;
// Export Directory Table
IMAGE_EXPORT_DIRECTORY exportDir = { 0 };
exportDir.Name = strTabRVA + strTab.GetSize();
strTab.Write((void*)libName.c_str(), (int)libName.length() + 1);
exportDir.Base = 1;
exportDir.NumberOfFunctions = (uint32)rvaMap.size();
exportDir.NumberOfNames = numNames;
exportDir.AddressOfFunctions = funcRVA;
exportDir.AddressOfNames = namePtrTabRVA;
exportDir.AddressOfNameOrdinals = ordTabRVA;
mExportStream.WriteT(exportDir);
// Export Address Table
mExportStream.Write((void*)&rvaMap[0], (int)rvaMap.size() * 4);
// Name Pointer Table
for (auto& exportPair : mExports)
{
const StringImpl& name = exportPair.first;
auto& blExport = exportPair.second;
if (!blExport.mNoName)
{
mExportStream.Write((int32)(strTabRVA + strTab.GetSize()));
strTab.Write((void*)name.c_str(), (int)name.length() + 1);
}
}
// Export Ordinal Table
for (auto& exportPair : mExports)
{
auto& blExport = exportPair.second;
if (!blExport.mNoName)
mExportStream.Write((int16)(blExport.mOrdinal - 1));
}
// String table data
mExportStream.Write(strTab.GetPtr(), strTab.GetSize());
BlChunk chunk;
chunk.mOffset = 0;
chunk.mAlignPad = 0;
chunk.mData = mExportStream.GetPtr();
chunk.mSize = mExportStream.GetSize();
exportSeg->mChunks.push_back(chunk);
BF_ASSERT(exportSeg->mCurSize == chunk.mSize);
}
BlSegment* BlContext::CreateExportData()
{
if (mExports.size() == 0)
return NULL;
String libName = GetFileName(mOutName);
int curOrdinal = 1;
int maxOrdinal = 0;
std::unordered_map<int, const String*> usedIds;
std::vector<int> ordinalMap;
int strTableSize = (int)libName.length() + 1;
int numNames = 0;
for (auto& exportPair : mExports)
{
auto& name = exportPair.first;
auto& blExport = exportPair.second;
if (blExport.mOrdinal > 0)
{
maxOrdinal = std::max(maxOrdinal, blExport.mOrdinal);
auto pair = usedIds.insert(std::make_pair(blExport.mOrdinal, &name));
if (!pair.second)
{
Fail(StrFormat("Export '%s' and export '%s' both specified ordinal %d", pair.first->second->c_str(), exportPair.first.c_str(), blExport.mOrdinal));
blExport.mOrdinal = -1;
}
}
if (!blExport.mNoName)
{
strTableSize += (int)name.length() + 1;
numNames++;
}
}
for (auto& exportPair : mExports)
{
const StringImpl& name = exportPair.first;
auto& blExport = exportPair.second;
if (blExport.mOrdinal <= 0)
{
while (usedIds.find(curOrdinal) != usedIds.end())
curOrdinal++;
blExport.mOrdinal = curOrdinal++;
maxOrdinal = std::max(maxOrdinal, blExport.mOrdinal);
}
}
int numEntries = maxOrdinal;
auto thunkSect = mDynSegments.Alloc();
thunkSect->mName = ".rdata$export";
thunkSect->mContext = this;
thunkSect->mSegmentIdx = (int)mSegments.size();
thunkSect->mAlign = 8;
thunkSect->mCharacteristics = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ;
mSegments.push_back(thunkSect);
mOrderedSegments.push_back(thunkSect);
thunkSect->mCurSize = sizeof(IMAGE_EXPORT_DIRECTORY) + (numEntries * 4) + (numNames * 4) + (numNames * 2) + strTableSize;
return thunkSect;
}
void BlContext::PopulateCvInfoData(BlSegment* cvInfoSect)
{
mCvInfoStream.Write((int32)'SDSR');
mCvInfoStream.WriteT(mCodeView->mSignature);
mCvInfoStream.Write(mCodeView->mAge);
String pdbName = mCodeView->mMsf.mFileName;
//String pdbName = "C:\\proj\\TestCPP\\x64\\Debug\\TestCPP.pdb";
mCvInfoStream.Write((void*)pdbName.c_str(), (int)pdbName.length() + 1);
BlChunk chunk;
chunk.mOffset = 0;
chunk.mAlignPad = 0;
chunk.mData = (void*)&mCvInfoStream.mData[0];
chunk.mSize = mCvInfoStream.GetSize();
cvInfoSect->mChunks.push_back(chunk);
}
BlSegment* BlContext::CreateCvInfoData()
{
auto cvInfoSect = mDynSegments.Alloc();
cvInfoSect->mName = ".rdata$cvInfo";
cvInfoSect->mContext = this;
cvInfoSect->mSegmentIdx = (int)mSegments.size();
cvInfoSect->mAlign = 8;
cvInfoSect->mCharacteristics = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ;
mSegments.push_back(cvInfoSect);
mOrderedSegments.push_back(cvInfoSect);
cvInfoSect->mCurSize = 4 + 4 + 16 + (int)mCodeView->mMsf.mFileName.length() + 1;
return cvInfoSect;
}
void BlContext::PopulateDebugDirData(BlSegment* debugDirSect, BlSegment* cvInfoSect)
{
IMAGE_DEBUG_DIRECTORY debugDir = { 0 };
debugDir.TimeDateStamp = mTimestamp;
debugDir.Type = 2;
debugDir.SizeOfData = cvInfoSect->mCurSize;
debugDir.AddressOfRawData = cvInfoSect->mRVA;
auto outSection = mOutSections[cvInfoSect->mOutSectionIdx];
debugDir.PointerToRawData = (cvInfoSect->mRVA - outSection->mRVA) + outSection->mRawDataPos;
mDebugDirStream.WriteT(debugDir);
BlChunk chunk;
chunk.mOffset = 0;
chunk.mAlignPad = 0;
chunk.mData = (void*)&mDebugDirStream.mData[0];
chunk.mSize = mDebugDirStream.GetSize();
debugDirSect->mChunks.push_back(chunk);
BF_ASSERT(debugDirSect->mCurSize == chunk.mSize);
}
BlSegment* BlContext::CreateDebugDirData()
{
auto debugDirSect = mDynSegments.Alloc();
debugDirSect->mName = ".rdata$debugDir";
debugDirSect->mContext = this;
debugDirSect->mSegmentIdx = (int)mSegments.size();
debugDirSect->mAlign = 8;
debugDirSect->mCharacteristics = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ;
mSegments.push_back(debugDirSect);
mOrderedSegments.push_back(debugDirSect);
debugDirSect->mCurSize = sizeof(IMAGE_DEBUG_DIRECTORY);
return debugDirSect;
}
void BlContext::GetResDataStats(BlResDirectory* resDir, int& dirCount, int& dataCount, int& symsStrsSize, int& dataSize)
{
for (auto& pair : resDir->mEntries)
{
auto resId = pair.first;
if (IsResIdNamed(resId))
symsStrsSize += 2 + (int)wcslen((wchar_t*)resId) * 2;
auto entry = pair.second;
if (entry->mIsDir)
{
dirCount++;
GetResDataStats((BlResDirectory*)entry, dirCount, dataCount, symsStrsSize, dataSize);
}
else
{
BlResData* resData = (BlResData*)entry;
dataCount++;
dataSize += resData->mSize;
}
}
}
void BlContext::CreateResData(BlSegment* resSeg, BlResDirectory* resDir, int resDirSize, int symsStrSize, DynMemStream& symStrsStream, DynMemStream& dataEntryStream)
{
int numNamedEntries = 0;
int numIdEntries = 0;
for (auto& pair : resDir->mEntries)
{
auto resId = pair.first;
if (IsResIdNamed(resId))
numNamedEntries++;
else
numIdEntries++;
}
mResDataStream.Write(0); // Characteristics (always 0)
mResDataStream.Write(0); // Timestamp
mResDataStream.Write(0); // Version
mResDataStream.Write((int16)numNamedEntries); // Number of named entries
mResDataStream.Write((int16)numIdEntries); // Number of id entries
int curEntriesPos = mResDataStream.GetPos();
mResDataStream.WriteZeros((int)resDir->mEntries.size() * 8);
for (int pass = 0; pass < 2; pass++)
{
for (auto& pair : resDir->mEntries)
{
auto resId = pair.first;
if ((IsResIdNamed(resId)) == (pass == 0))
{
if (pass == 0)
{
// Name
*(int32*)(&mResDataStream.mData[curEntriesPos]) = 0x80000000 | (resDirSize + symStrsStream.GetSize());
int strLen = (int)wcslen((wchar_t*)resId);
symStrsStream.Write((int16)strLen);
symStrsStream.Write((uint8*)resId, strLen * 2);
}
else
*(int32*)(&mResDataStream.mData[curEntriesPos]) = (int16)(intptr)resId;
auto resEntry = pair.second;
if (resEntry->mIsDir)
{
*(int32*)(&mResDataStream.mData[curEntriesPos + 4]) = 0x80000000 | mResDataStream.GetPos();
CreateResData(resSeg, (BlResDirectory*)resEntry, resDirSize, symsStrSize, symStrsStream, dataEntryStream);
}
else
{
BlResData* resData = (BlResData*)resEntry;
*(int32*)(&mResDataStream.mData[curEntriesPos + 4]) = (resDirSize + symsStrSize) + dataEntryStream.GetSize();
dataEntryStream.Write((int32)(resSeg->mRVA + resSeg->mCurSize));
dataEntryStream.Write((int32)resData->mSize);
dataEntryStream.Write((int32)0); // Codepage
dataEntryStream.Write((int32)0); // Reserved
BlChunk chunk;
chunk.mOffset = -1;
chunk.mAlignPad = 0;
chunk.mData = resData->mData;
chunk.mSize = resData->mSize;
resSeg->mChunks.push_back(chunk);
resSeg->mCurSize += resData->mSize;
}
curEntriesPos += 8;
}
}
}
}
void BlContext::PopulateResData(BlSegment* resSeg)
{
int prevSize = resSeg->mCurSize;
// Insert fake chunk
{
BlChunk chunk;
chunk.mOffset = 0;
chunk.mAlignPad = 0;
chunk.mData = 0;
chunk.mSize = 0;
resSeg->mChunks.push_back(chunk);
}
int dirCount = 0;
int dataCount = 0;
int symsStrSize = 0;
int dataSize = 0;
GetResDataStats(&mRootResDirectory, dirCount, dataCount, symsStrSize, dataSize);
int resDirSize = 16 + ((16 + 8) * dirCount) + ((8) * dataCount);
resSeg->mCurSize = resDirSize + symsStrSize + (dataCount * 16);
DynMemStream symStrsStream;
DynMemStream dataEntryStream;
CreateResData(resSeg, &mRootResDirectory, resDirSize, symsStrSize, symStrsStream, dataEntryStream);
BF_ASSERT(mResDataStream.GetSize() == resDirSize);
if (symStrsStream.GetSize() != 0)
mResDataStream.Write(symStrsStream.GetPtr(), symStrsStream.GetSize());
if (dataEntryStream.GetSize() != 0)
mResDataStream.Write(dataEntryStream.GetPtr(), dataEntryStream.GetSize());
BlChunk& chunk = resSeg->mChunks.front();
chunk.mData = (void*)&mResDataStream.mData[0];
chunk.mSize = mResDataStream.GetSize();
BF_ASSERT(resSeg->mCurSize == prevSize);
}
BlSegment* BlContext::CreateSegment(const StringImpl& name, int characteristics, int align)
{
auto seg = mDynSegments.Alloc();
seg->mName = name;
seg->mContext = this;
seg->mSegmentIdx = (int)mSegments.size();
seg->mAlign = align;
seg->mCharacteristics = characteristics;
AddSegment(seg);
return seg;
}
BlSegment* BlContext::CreateResData()
{
String manifest;
manifest += "<?xml version='1.0' encoding='UTF-8' standalone='yes'?>\n";
manifest += "<assembly xmlns='urn:schemas-microsoft-com:asm.v1' manifestVersion='1.0'>\n";
manifest += " <trustInfo xmlns=\"urn:schemas-microsoft-com:asm.v3\">\n";
manifest += " <security>\n";
manifest += " <requestedPrivileges>\n";
manifest += " <requestedExecutionLevel ";
manifest += mManifestUAC;
manifest += " />\n";
manifest += " </requestedPrivileges>\n";
manifest += " </security>\n";
manifest += " </trustInfo>\n";
manifest += "</assembly>\n";
mManifestData = manifest;
auto idResDir = mResEntries.Alloc<BlResDirectory>();
auto langDir = mResEntries.Alloc<BlResDirectory>();
auto manifestData = mResEntries.Alloc<BlResData>();
manifestData->mIsDir = false;
manifestData->mData = (void*)mManifestData.c_str();
manifestData->mSize = (int)mManifestData.length();
mRootResDirectory.mEntries[(const char16_t*)(intptr)24] = idResDir;
idResDir->mEntries[(const char16_t*)(intptr)0] = langDir;
langDir->mEntries[(const char16_t*)(intptr)1033] = manifestData;
auto resSeg = CreateSegment(".rsrc", IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ, 8);
int dirCount = 0;
int dataCount = 0;
int symsStrSize = 0;
int dataSize = 0;
GetResDataStats(&mRootResDirectory, dirCount, dataCount, symsStrSize, dataSize);
int resDirSize = 16 + ((16 + 8) * dirCount) + ((8) * dataCount);
resSeg->mCurSize = resDirSize + symsStrSize + (dataCount * 16) + dataSize;
return resSeg;
}
void BlContext::PopulateThunkData(BlSegment* thunkSect, BlSegment* iDataSect)
{
for (auto& importFilePair : mImportFiles)
{
auto& importFile = importFilePair.second;
for (auto lookup : importFile.mLookups)
{
// jmp qword ptr [Rel32]
mThunkStream.Write((uint8)0xFF);
mThunkStream.Write((uint8)0x25);
int32 targetAddr = iDataSect->mRVA + (lookup->mIDataIdx * 8);
targetAddr -= thunkSect->mRVA + (lookup->mThunkIdx * 6) + 6;
mThunkStream.Write((int32)targetAddr);
}
}
BlChunk chunk;
chunk.mOffset = 0;
chunk.mAlignPad = 0;
chunk.mData = (void*)&mThunkStream.mData[0];
chunk.mSize = mThunkStream.GetSize();
thunkSect->mChunks.push_back(chunk);
BF_ASSERT(thunkSect->mCurSize == chunk.mSize);
}
namespace BeefyDbg64
{
void TestPDB(const StringImpl& fileName);
}
void BlContext::WriteOutSection(BlOutSection* outSection, DataStream* st)
{
int startPos = st->GetPos();
auto _FillBytes = [&](int size)
{
if ((outSection->mCharacteristics & IMAGE_SCN_MEM_EXECUTE) != 0)
{
uint64 fillData = 0xCCCCCCCCCCCCCCCCLL;
int alignLeft = size;
while (alignLeft > 0)
{
int alignWrite = std::min(alignLeft, 8);
st->Write(&fillData, alignWrite);
alignLeft -= alignWrite;
}
}
else
{
st->WriteZeros(size);
}
};
for (auto sect : outSection->mSegments)
{
int curPos = st->GetPos();
int wantPos = (curPos + (sect->mAlign - 1)) & ~(sect->mAlign - 1);
_FillBytes(wantPos - curPos);
int sectStartPos = wantPos;
BF_ASSERT(outSection->mRVA + sectStartPos - startPos == sect->mRVA);
BlReloc* nextReloc = NULL;
int curRelocIdx = 0;
if (!sect->mRelocs.empty())
nextReloc = &sect->mRelocs[0];
int curSectOfs = 0;
for (auto& chunk : sect->mChunks)
{
BF_ASSERT(st->GetPos() == sectStartPos + curSectOfs);
_FillBytes(chunk.mAlignPad);
curSectOfs += chunk.mAlignPad;
BF_ASSERT((chunk.mOffset == curSectOfs) || (chunk.mOffset == -1));
uint8* data = (uint8*)chunk.mData;
int sizeLeft = chunk.mSize;
while (sizeLeft > 0)
{
if (nextReloc != NULL)
{
int relocOfs = nextReloc->mOutOffset - curSectOfs;
BF_ASSERT(relocOfs >= 0);
if (relocOfs < sizeLeft)
{
st->Write(data, relocOfs);
curSectOfs += relocOfs;
data += relocOfs;
sizeLeft -= relocOfs;
int64 relocOutVal = 0;
int relocOutSize = 0;
int resolvedAddr;
bool wasAbs = false;
if (nextReloc->mSegmentIdx == (int)BlSymKind_ImageBaseRel)
{
resolvedAddr = nextReloc->mSegmentOffset;
}
else if (nextReloc->mSegmentIdx == (int)BlSymKind_Absolute)
{
resolvedAddr = nextReloc->mSegmentOffset;
wasAbs = true;
}
else
{
if (nextReloc->mKind == BlRelocKind_SECREL)
{
BlSegment* resolvedSect = mSegments[nextReloc->mSegmentIdx];
auto outSection = mOutSections[resolvedSect->mOutSectionIdx];
relocOutSize = 4;
relocOutVal = (resolvedSect->mRVA - outSection->mRVA) + nextReloc->mSegmentOffset + *(int32*)data;
}
else
{
BlSegment* resolvedSect = mSegments[nextReloc->mSegmentIdx];
resolvedAddr = resolvedSect->mRVA + nextReloc->mSegmentOffset;
}
}
switch (nextReloc->mKind)
{
case BlRelocKind_ADDR32NB:
relocOutVal = resolvedAddr + *(int32*)data;
relocOutSize = 4;
break;
case BlRelocKind_ADDR64:
if (wasAbs)
{
relocOutVal = resolvedAddr + *(int32*)data;
// In cases like loadcfg.obj, __guard_flags gets truncated at the end
relocOutVal = std::min(8, sizeLeft);
}
else
{
if (!mHasFixedBase)
mPeRelocs.Add(sect->mRVA + nextReloc->mOutOffset, IMAGE_REL_BASED_DIR64);
relocOutVal = mImageBase + resolvedAddr + *(int32*)data;
relocOutSize = 8;
}
break;
case BlRelocKind_REL32:
relocOutVal = resolvedAddr + *(int32*)data;
relocOutVal -= sect->mRVA + curSectOfs + 4;
relocOutSize = 4;
break;
case BlRelocKind_REL32_1:
relocOutVal = resolvedAddr + *(int32*)data;
relocOutVal -= sect->mRVA + curSectOfs + 5;
relocOutSize = 4;
break;
case BlRelocKind_REL32_4:
relocOutVal = resolvedAddr + *(int32*)data;
relocOutVal -= sect->mRVA + curSectOfs + 8;
relocOutSize = 4;
break;
case BlRelocKind_SECREL:
// Handled
break;
default:
NotImpl();
break;
}
st->Write(&relocOutVal, relocOutSize);
curSectOfs += relocOutSize;
data += relocOutSize;
sizeLeft -= relocOutSize;
curRelocIdx++;
if (curRelocIdx < (int)sect->mRelocs.size())
nextReloc = &sect->mRelocs[curRelocIdx];
else
nextReloc = NULL;
continue;
}
}
st->Write(data, sizeLeft);
curSectOfs += sizeLeft;
sizeLeft = 0;
break;
}
BF_ASSERT(sizeLeft == 0);
//TODO:
}
}
}
static void FormatNZ(char* toStr, const char* fmt ...)
{
char buffer[32];
va_list argList;
va_start(argList, fmt);
int result = _vsprintf_l(buffer, fmt, NULL, argList);
va_end(argList);
memcpy(toStr, buffer, result);
}
// If this fails, then investigate the SectionRef vs SectionDef rules in BeCOFFObject::MarkSectionUsed
void BlContext::WriteDLLLib(const StringImpl& libName)
{
FileStream fs;
if (!fs.Open(libName, "wb"))
{
Fail(StrFormat("Unable to create file \"%s\"", libName.c_str()));
return;
}
//mExports.clear();
struct _LibSym
{
int mOfsIdx;
int mDataPos;
BlExport* mExport;
String mName;
String mExportName;
_LibSym* mImp;
void* mData;
int mDataSize;
_LibSym()
{
mOfsIdx = -1;
mDataPos = -1;
mExport = NULL;
mImp = NULL;
mData = NULL;
mDataSize = 0;
}
};
OwnedVector<_LibSym> libSyms;
String dllName = GetFileName(mOutName);
String baseName = dllName.Substring(0, dllName.length() - 4);
auto _CreateDebugSect = [] (BeCOFFObject& coffObject)
{
// Not actually needed
return;
/*auto debugSect = coffObject.CreateSect(".debug$S", IMAGE_SCN_ALIGN_1BYTES | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_DISCARDABLE, false);
unsigned char hexData[66] = {
0x02, 0x00, 0x00, 0x00, 0x13, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x54, 0x65, 0x73,
0x74, 0x44, 0x6C, 0x6C, 0x32, 0x2E, 0x64, 0x6C, 0x6C, 0x27, 0x00, 0x13, 0x10, 0x07, 0x00, 0x00,
0x00, 0xD0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x97, 0x5E, 0x12,
0x4D, 0x69, 0x63, 0x72, 0x6F, 0x73, 0x6F, 0x66, 0x74, 0x20, 0x28, 0x52, 0x29, 0x20, 0x4C, 0x49,
0x4E, 0x4B
};
debugSect->mData.Write(hexData, 0x42);*/
};
String importDescriptorName = "__IMPORT_DESCRIPTOR_" + baseName;
String nullImportDescriptorName = "__NULL_IMPORT_DESCRIPTOR";
String nullThunkDataName = "\x7F";
nullThunkDataName += baseName;
nullThunkDataName += "_NULL_THUNK_DATA";
//
DynMemStream importDescriptorStream;
{
BeCOFFObject coffObject;
coffObject.mStream = &importDescriptorStream;
coffObject.mTimestamp = mTimestamp;
// iData entry
auto idata2Sect = coffObject.CreateSect(".idata$2", IMAGE_SCN_ALIGN_4BYTES | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE);
idata2Sect->mData.WriteZeros(0x14);
// Dll name entry
auto idata6Sect = coffObject.CreateSect(".idata$6", IMAGE_SCN_ALIGN_2BYTES | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE, false);
idata6Sect->mData.WriteSZ(dllName);
idata6Sect->mData.Align(2);
BeMCSymbol* nameSectSym = coffObject.mSymbols.Alloc();
nameSectSym->mSymKind = BeMCSymbolKind_External;
nameSectSym->mIsStatic = true;
nameSectSym->mSectionNum = idata6Sect->mSectionIdx + 1;
nameSectSym->mName = ".idata$6";
nameSectSym->mIdx = (int)coffObject.mSymbols.size() - 1;
BeMCSymbol* coffSym = coffObject.mSymbols.Alloc();
coffSym->mSymKind = BeMCSymbolKind_External;
coffSym->mSectionNum = idata2Sect->mSectionIdx + 1;
coffSym->mName = importDescriptorName;
coffSym->mIsStatic = false;
BeMCSymbol* idata4Sym = coffObject.mSymbols.Alloc();
idata4Sym->mSymKind = BeMCSymbolKind_SectionRef;
idata4Sym->mName = ".idata$4";
idata4Sym->mIdx = (int)coffObject.mSymbols.size() - 1;
BeMCSymbol* idata5Sym = coffObject.mSymbols.Alloc();
idata5Sym->mSymKind = BeMCSymbolKind_SectionRef;
idata5Sym->mName = ".idata$5";
idata5Sym->mIdx = (int)coffObject.mSymbols.size() - 1;
BeMCSymbol* nullImportDescSym = coffObject.mSymbols.Alloc();
nullImportDescSym->mSymKind = BeMCSymbolKind_External;
nullImportDescSym->mName = nullImportDescriptorName;
BeMCSymbol* nullThunkDataSym = coffObject.mSymbols.Alloc();
nullThunkDataSym->mSymKind = BeMCSymbolKind_External;
nullThunkDataSym->mName = nullThunkDataName;
BeMCRelocation reloc;
reloc.mKind = BeMCRelocationKind_ADDR32NB;
reloc.mOffset = 0x0C;
//reloc.mSymTableIdx = idata6Sect->mSymbolIdx;
reloc.mSymTableIdx = nameSectSym->mIdx;
idata2Sect->mRelocs.push_back(reloc);
reloc.mKind = BeMCRelocationKind_ADDR32NB;
reloc.mOffset = 0x00;
reloc.mSymTableIdx = idata4Sym->mIdx;
idata2Sect->mRelocs.push_back(reloc);
reloc.mKind = BeMCRelocationKind_ADDR32NB;
reloc.mOffset = 0x10;
reloc.mSymTableIdx = idata5Sym->mIdx;
idata2Sect->mRelocs.push_back(reloc);
_CreateDebugSect(coffObject);
coffObject.Finish();
_LibSym* libSym = libSyms.Alloc();
libSym->mName = importDescriptorName;
libSym->mData = importDescriptorStream.GetPtr();
libSym->mDataSize = importDescriptorStream.GetSize();
}
DynMemStream nullImportDescriptorStream;
{
BeCOFFObject coffObject;
coffObject.mStream = &nullImportDescriptorStream;
coffObject.mTimestamp = mTimestamp;
// iData entry terminator
auto idata3Sect = coffObject.CreateSect(".idata$3", IMAGE_SCN_ALIGN_4BYTES | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE);
idata3Sect->mData.WriteZeros(0x14);
BeMCSymbol* coffSym = coffObject.mSymbols.Alloc();
coffSym->mSymKind = BeMCSymbolKind_External;
coffSym->mSectionNum = idata3Sect->mSectionIdx + 1;
coffSym->mName = nullImportDescriptorName;
coffSym->mIsStatic = false;
_CreateDebugSect(coffObject);
coffObject.Finish();
_LibSym* libSym = libSyms.Alloc();
libSym->mName = nullImportDescriptorName;
libSym->mData = nullImportDescriptorStream.GetPtr();
libSym->mDataSize = nullImportDescriptorStream.GetSize();
}
DynMemStream nullThunkDataStream;
{
BeCOFFObject coffObject;
coffObject.mStream = &nullThunkDataStream;
coffObject.mTimestamp = mTimestamp;
// iData entry terminator
auto idata5Sect = coffObject.CreateSect(".idata$5", IMAGE_SCN_ALIGN_8BYTES | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE);
idata5Sect->mData.WriteZeros(0x8);
auto idata4Sect = coffObject.CreateSect(".idata$4", IMAGE_SCN_ALIGN_8BYTES | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE);
idata4Sect->mData.WriteZeros(0x8);
BeMCSymbol* coffSym = coffObject.mSymbols.Alloc();
coffSym->mSymKind = BeMCSymbolKind_External;
coffSym->mSectionNum = idata5Sect->mSectionIdx + 1;
coffSym->mName = nullThunkDataName;
coffSym->mIsStatic = false;
_CreateDebugSect(coffObject);
coffObject.Finish();
_LibSym* libSym = libSyms.Alloc();
libSym->mName = nullThunkDataName;
libSym->mData = nullThunkDataStream.GetPtr();
libSym->mDataSize = nullThunkDataStream.GetSize();
}
for (auto& exportPair : mExports)
{
auto& blExport = exportPair.second;
if (blExport.mIsPrivate)
continue;
_LibSym* impSym = libSyms.Alloc();
impSym->mExport = &exportPair.second;
impSym->mName = "__imp_" + exportPair.first;
impSym->mExportName = exportPair.first;
impSym->mExport = &blExport;
impSym->mDataSize = (int)sizeof(PEImportObjectHeader) + (int)dllName.length() + 1 + (int)impSym->mExportName.length() + 1;
if (!blExport.mIsData)
{
_LibSym* refSym = libSyms.Alloc();
refSym->mName = exportPair.first;
refSym->mImp = impSym;
}
}
// Sort symbol names, required by Second Linker Member
std::sort(libSyms.begin(), libSyms.end(), [] (const _LibSym* lhs, const _LibSym* rhs)
{
return lhs->mName < rhs->mName;
});
int numExports = (int)libSyms.size();
int namesLen = 0;
DynMemStream syms0;
int ofsIdx = 0;
for (auto& libSym : libSyms)
{
namesLen += (int)libSym->mName.length() + 1;
if (libSym->mDataSize > 0)
libSym->mOfsIdx = ofsIdx++;
}
syms0.Write(numExports);
int headerSize = 8;
fs.WriteSNZ("!<arch>\n");
int expectedPos = headerSize;
int member0Size = sizeof(BlLibMemberHeader) + 4 + (numExports * 4) + (namesLen);
int member1Size = sizeof(BlLibMemberHeader) + 4 + (ofsIdx * 4) + 4 + (numExports * 2) + (namesLen);
int nameMemberSize = 0;
if (dllName.length() > 16)
{
nameMemberSize = sizeof(BlLibMemberHeader) + dllName.length() + 1;
}
int startExpOfs = expectedPos + BF_ALIGN(member0Size, 2) + BF_ALIGN(member1Size, 2) + BF_ALIGN(nameMemberSize, 2);
int curExpOfs = startExpOfs;
for (auto& libSym : libSyms)
{
if (libSym->mDataSize > 0)
{
int exportSize = (int)sizeof(BlLibMemberHeader) + libSym->mDataSize;
libSym->mDataPos = curExpOfs;
curExpOfs += BF_ALIGN(exportSize, 2);
}
}
BlLibMemberHeader member;
// First Linker Member (unordered symbol list)
member.Init();
FormatNZ(member.mName, "/");
FormatNZ(member.mDate, "%d", mTimestamp);
FormatNZ(member.mMode, "0");
FormatNZ(member.mSize, "%d", member0Size - (int)sizeof(BlLibMemberHeader));
fs.WriteT(member);
fs.Write(ToBigEndian(numExports));
for (auto libSym : libSyms)
{
if (libSym->mDataPos >= 0)
fs.Write(ToBigEndian(libSym->mDataPos));
else
fs.Write(ToBigEndian(libSym->mImp->mDataPos));
}
for (auto& libSym : libSyms)
{
fs.WriteSZ(libSym->mName);
}
expectedPos += member0Size;
BF_ASSERT(fs.GetPos() == expectedPos);
fs.Align(2);
expectedPos = fs.GetPos();
// Second Linker Member (ordered symbol map)
curExpOfs = startExpOfs;
member.Init();
FormatNZ(member.mName, "/");
FormatNZ(member.mDate, "%d", mTimestamp);
FormatNZ(member.mMode, "0");
FormatNZ(member.mSize, "%d", member1Size - (int)sizeof(BlLibMemberHeader));
fs.WriteT(member);
fs.Write(ofsIdx);
for (auto libSym : libSyms)
{
if (libSym->mDataSize <= 0)
continue;
int exportSize = (int)sizeof(BlLibMemberHeader) + libSym->mDataSize;
fs.Write(curExpOfs);
curExpOfs += BF_ALIGN(exportSize, 2);
}
fs.Write(numExports);
for (auto libSym : libSyms)
{
if (libSym->mOfsIdx >= 0)
fs.Write((int16)(libSym->mOfsIdx + 1));
else
{
BF_ASSERT(libSym->mImp != NULL);
fs.Write((int16)(libSym->mImp->mOfsIdx + 1));
}
}
for (auto libSym : libSyms)
{
fs.WriteSZ(libSym->mName);
}
expectedPos += member1Size;
BF_ASSERT(fs.GetPos() == expectedPos);
fs.Align(2);
expectedPos = fs.GetPos();
if (nameMemberSize != 0)
{
member.Init();
FormatNZ(member.mName, "//");
FormatNZ(member.mDate, "%d", mTimestamp);
FormatNZ(member.mMode, "0");
FormatNZ(member.mSize, "%d", nameMemberSize - (int)sizeof(BlLibMemberHeader));
fs.WriteT(member);
fs.WriteSZ(dllName);
fs.Align(2);
}
// Create import entries
curExpOfs = startExpOfs;
for (auto libSym : libSyms)
{
if (libSym->mDataSize <= 0)
continue;
BF_ASSERT(fs.GetPos() == curExpOfs);
int exportSize = (int)sizeof(BlLibMemberHeader) + libSym->mDataSize;
member.Init();
if (nameMemberSize != 0)
FormatNZ(member.mName, "/0"); // Reference name in string table
else
FormatNZ(member.mName, "%s/", dllName.c_str());
FormatNZ(member.mDate, "%d", mTimestamp);
FormatNZ(member.mMode, "0");
FormatNZ(member.mSize, "%d", exportSize - (int)sizeof(BlLibMemberHeader));
fs.WriteT(member);
if (libSym->mData != NULL)
{
fs.Write(libSym->mData, libSym->mDataSize);
}
else
{
BF_ASSERT(libSym->mExport != NULL);
PEImportObjectHeader importHdr = { 0 };
importHdr.mSig1 = 0;
importHdr.mSig2 = IMPORT_OBJECT_HDR_SIG2;
importHdr.mVersion = 0;
importHdr.mMachine = PE_MACHINE_X64;
importHdr.mTimeDateStamp = mTimestamp;
importHdr.mDataSize = (int)libSym->mExportName.length() + 1 + (int)dllName.length() + 1;
importHdr.mHint = libSym->mExport->mOrdinal;
if (!libSym->mExport->mOrdinalSpecified)
importHdr.mType |= IMPORT_OBJECT_NAME << 2;
if (libSym->mExport->mIsData)
importHdr.mType |= IMPORT_OBJECT_DATA;
fs.WriteT(importHdr);
fs.WriteSZ(libSym->mExportName);
fs.WriteSZ(dllName);
}
if ((exportSize % 2) == 1)
fs.Write((uint8)0xA);
curExpOfs += BF_ALIGN(exportSize, 2);
}
}
void BlContext::PrintStats()
{
OutputDebugStrF("Symbols: %d\n", mSymTable.mMap.size());
OutputDebugStrF("Obj files: %d\n", mNumObjFiles);
OutputDebugStrF("Libs: %d\n", mNumLibs);
OutputDebugStrF("Imported objs: %d\n", mNumImportedObjs);
OutputDebugStrF("Weak symbols: %d\n", mNumWeakSymbols);
OutputDebugStrF("Syms not found: %d\n", mSymNotFounds.size());
OutputDebugStrF("Import Groups: %d\n", mImportGroups.size());
if (mCodeView != NULL)
{
OutputDebugStrF("PDB TPI Types: %d\n", mCodeView->mTPI.mCurTagId - 0x1000);
OutputDebugStrF("PDB IPI Types: %d\n", mCodeView->mIPI.mCurTagId - 0x1000);
OutputDebugStrF("PDB Globals: %d\n", mCodeView->mGlobals.mNumEntries);
OutputDebugStrF("DbgSymSectsFound: %d\n", mDbgSymSectsFound);
OutputDebugStrF("DbgSymSectsUsed: %d\n", mDbgSymSectsUsed);
OutputDebugStrF("Stat_ParseTagFuncs: %d\n", mCodeView->mStat_ParseTagFuncs);
OutputDebugStrF("Stat_TypeMapInserts: %d\n", mCodeView->mStat_TypeMapInserts);
}
}
void BlContext::Link()
{
//smap.insert()
//BeefyDbg64::TestPDB("C:\\temp\\out.pdbf");
//BeefyDbg64::TestPDB("C:\\proj\\TestCPP\\x64\\Debug\\TestCPP.pdb");
//BeefyDbg64::TestPDB("C:\\llvm-3.9.0\\bin64\\Debug\\bin\\Clang.pdb");
//
BL_AUTOPERF("BlContext::Link");
BF_ASSERT(mCodeView == NULL);
/*mTextSeg = CreateSegment(".text", IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_EXECUTE, 1);
mTextSeg->mOutSectionIdx = 0;
mRDataSeg = CreateSegment(".rdata", IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ, 1);
mRDataSeg->mOutSectionIdx = 1;
mDataSeg = CreateSegment(".data", IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE, 1);
mDataSeg->mOutSectionIdx = 2;
// We add the BSS data to the end of .data
//mBSSSeg = CreateSegment(".data$\xFF", IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE, 1);
// We used to name .BSS as ".data$\xFF" to make sure it appended to .data, but now we keep those segments separate so we can
// parallelize the COFF generation*/
mBSSSeg = CreateSegment(".bss", IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE, 1);
//mBSSSeg->mOutSectionIdx = 3;
//mNumFixedSegs = 4;
if ((mImageBase & 0xFFFF) != 0)
Fail(StrFormat("Image base, specified as 0x%p, must be a multiple of 64k (0x10000)", mImageBase));
// Make sure this is set to 'false' unless debugging
bool deferThreads = false;
if (mDebugKind != 0)
{
mCodeView = new BlCodeView();
mCodeView->mContext = this;
if (!deferThreads)
mCodeView->StartWorkThreads();
}
if (mOutName.empty())
{
char cwd[MAX_PATH];
_getcwd(cwd, MAX_PATH);
mOutName = String(cwd) + "\\" + GetFileName(cwd);
if (mIsDLL)
mOutName += ".dll";
else
mOutName += ".exe";
}
// Create PDB
if (mCodeView != NULL)
{
if (mPDBPath.empty())
{
String pdbFileName = mOutName;
pdbFileName.RemoveToEnd(pdbFileName.length() - 4);
pdbFileName += ".pdb";
mPDBPath = pdbFileName;
}
// Use .pdbf for PDB file
// The rationale is to allow alternating between the MS linker and the Beef linker. The MS linker
// currently chokes while trying to update PDBs built by the Beef linker
mPDBPath += "f";
if (!mCodeView->Create(mPDBPath))
{
Fail(StrFormat("Failed to create \"%s\"", mPDBPath.c_str()));
return;
}
}
auto imageBaseSym = mSymTable.Add("__ImageBase");
//TODO: Set up ImageBase properly
imageBaseSym->mObjectDataIdx = -1;
imageBaseSym->mKind = BlSymKind_ImageBaseRel;
imageBaseSym->mSegmentOffset = 0;
// We do not support /guard:cf (control flow protection) yet.
// Define CFG symbols anyway so that we can link MSVC 2015 CRT.
AddAbsoluteSym("__guard_fids_table", 0);
AddAbsoluteSym("__guard_fids_count", 0);
AddAbsoluteSym("__guard_flags", 0x100);
BlSymbol* entrySym = NULL;
BlSymbol* configSym = NULL;
int workLoopIdx = 0;
String entryPointName;
if (!mEntryPoint.empty())
entryPointName = mEntryPoint;
else if (mIsDLL)
entryPointName = "_DllMainCRTStartup";
else if (mPeSubsystem == IMAGE_SUBSYSTEM_WINDOWS_CUI)
entryPointName = "mainCRTStartup";
else if (mPeSubsystem == IMAGE_SUBSYSTEM_WINDOWS_GUI)
entryPointName = "WinMainCRTStartup";
while (!mObjectDataWorkQueue.empty())
{
LoadFiles();
ResolveRelocs();
for (auto& forcedSym : mForcedSyms)
ResolveSym(forcedSym.c_str());
mForcedSyms.clear();
if (workLoopIdx == 0)
{
if (!entryPointName.empty())
entrySym = ResolveSym(entryPointName.c_str());
configSym = ResolveSym("_load_config_used");
}
if (mObjectDataWorkQueue.empty())
{
for (auto& symNotFound : mSymNotFounds)
{
if ((symNotFound.mSym->mKind == BlSymKind_LibSymbolRef) || (symNotFound.mSym->mKind == BlSymKind_LibSymbolGroupRef))
ProcessSymbol(symNotFound.mSym);
}
}
workLoopIdx++;
}
// Check for any unresolved symbols
for (auto& symNotFound : mSymNotFounds)
{
auto sym = symNotFound.mSym;
if (sym->mKind != BlSymKind_Undefined)
continue;
int curOffset = 0;
int objectDataIdx = -1;
if (symNotFound.mSegmentIdx != -1)
{
auto seg = mSegments[symNotFound.mSegmentIdx];
// Find the chunk that this symbol is referenced from
for (auto& chunk : seg->mChunks)
{
curOffset += chunk.mAlignPad;
BF_ASSERT(curOffset == chunk.mOffset);
if ((symNotFound.mOutOffset >= curOffset) && (symNotFound.mOutOffset < curOffset + chunk.mSize))
{
objectDataIdx = chunk.mObjectDataIdx;
break;
}
curOffset += chunk.mSize;
}
}
if (objectDataIdx != -1)
{
Fail(StrFormat("Unable to find symbol %s referenced from %s", GetSymDisp(sym->mName).c_str(), ObjectDataIdxToString(objectDataIdx).c_str()));
}
else
{
Fail(StrFormat("Unable to find symbol %s", GetSymDisp(sym->mName).c_str()));
}
}
if (mFailed)
return;
mIDataSeg = CreateIData();
BlSegment* thunkSeg = CreateThunkData();
BlSegment* cvInfoSeg = CreateCvInfoData();
BlSegment* debugDirSeg = NULL;
if (mCodeView != NULL)
debugDirSeg = CreateDebugDirData();
BlSegment* resSeg = CreateResData();
BlSegment* exportSeg = CreateExportData();
PlaceSections();
PopulateIData(mIDataSeg);
if (thunkSeg != NULL)
PopulateThunkData(thunkSeg, mIDataSeg);
if (cvInfoSeg != NULL)
PopulateCvInfoData(cvInfoSeg);
PopulateDebugDirData(debugDirSeg, cvInfoSeg);
PopulateResData(resSeg);
if (exportSeg != NULL)
PopulateExportData(exportSeg);
if (mFailed)
return;
// The .reloc table is a special case because we don't know its size until after we process
// the relocations of all the other sections
auto lastOutSection = mOutSections.back();
auto relocOutSection = mOutSections.Alloc();
relocOutSection->mIdx = (int)mOutSections.size() - 1;
relocOutSection->mName = ".reloc";
relocOutSection->mCharacteristics = IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA;
relocOutSection->mRVA = lastOutSection->mRVA + lastOutSection->mVirtualSize;
relocOutSection->mRVA = (relocOutSection->mRVA + (0x1000 - 1)) & ~(0x1000 - 1);
relocOutSection->mRawDataPos = lastOutSection->mRawDataPos + lastOutSection->mRawSize;
relocOutSection->mRawSize = 0;
relocOutSection->mVirtualSize = 0;
// Finish relocs. Primary reloc loop.
{
BL_AUTOPERF("BlContext::Link Finish Relocs");
for (auto sect : mSegments)
{
for (auto& reloc : sect->mRelocs)
{
int sectionIdx = -1;
int sectionOffset = 0;
int64 outRVA = sect->mRVA + reloc.mOutOffset;
if ((reloc.mFlags & BeRelocFlags_Sym) != 0)
{
auto sym = reloc.mSym;
if (sym->mKind == BlSymKind_WeakSymbol)
{
sym = mSymTable.Add(mRemapStrs[sym->mParam].c_str());
if (sym->mKind == BlSymKind_Undefined)
{
Fail(StrFormat("Unable to resolve weak symbol %s", GetSymDisp(sym->mName).c_str()));
continue;
}
}
reloc.mFlags = (BeRelocFlags)(reloc.mFlags & ~BeRelocFlags_Sym | BeRelocFlags_Loc);
if (sym->mKind == BlSymKind_Import)
{
// It's a thunk
reloc.mSegmentIdx = thunkSeg->mSegmentIdx;
auto lookup = mImportLookups[sym->mParam];
reloc.mSegmentOffset = lookup->mThunkIdx * 6;
continue;
}
if (sym->mKind == BlSymKind_ImportImp)
{
BF_ASSERT((reloc.mFlags & BeRelocFlags_Func) == 0);
reloc.mSegmentIdx = mIDataSeg->mSegmentIdx;
auto lookup = mImportLookups[sym->mParam];
reloc.mSegmentOffset = lookup->mIDataIdx * 8;
continue;
}
else if ((sym->mKind == BlSymKind_ImageBaseRel) || (sym->mKind == BlSymKind_Absolute))
{
// Fine
}
else if (sym->mKind < 0)
{
AssertFailed();
Fail(StrFormat("Unable to find symbol %s", GetSymDisp(sym->mName).c_str()));
}
reloc.mSegmentIdx = sym->mSegmentIdx;
reloc.mSegmentOffset = sym->mSegmentOffset;
}
else
{
sectionIdx = reloc.mSegmentIdx;
sectionOffset = reloc.mSegmentOffset;
}
}
}
}
SysFileStream fs;
//if (!fs.Open(mOutName, GENERIC_WRITE | GENERIC_READ))
if (!fs.Open(mOutName, BfpFileCreateKind_CreateAlways, (BfpFileCreateFlags)(BfpFileCreateFlag_Read | BfpFileCreateFlag_Write)))
{
Fail(StrFormat("Unable to create file \"%s\"", mOutName.c_str()));
return;
}
PEHeader hdr = { 0 };
hdr.e_magic = PE_DOS_SIGNATURE;
hdr.e_cblp = 0x90;
hdr.e_cp = 0x03;
hdr.e_cparhdr = 4;
hdr.e_maxalloc = 0xFFFF;
hdr.e_sp = 0xB8;
hdr.e_lfarlc = 0x40;
hdr.e_lfanew = 0xF0;
PE_NTHeaders64 ntHdr = { 0 };
ntHdr.mSignature = PE_NT_SIGNATURE;
ntHdr.mFileHeader.mMachine = PE_MACHINE_X64;
ntHdr.mFileHeader.mNumberOfSections = (int)mOutSections.size();
ntHdr.mFileHeader.mTimeDateStamp = mTimestamp;
ntHdr.mFileHeader.mSizeOfOptionalHeader = 0xF0;
ntHdr.mFileHeader.mCharacteristics = IMAGE_FILE_LARGE_ADDRESS_AWARE | IMAGE_FILE_EXECUTABLE_IMAGE;
if (mIsDLL)
ntHdr.mFileHeader.mCharacteristics |= IMAGE_FILE_DLL;
if (mHasFixedBase)
ntHdr.mFileHeader.mCharacteristics |= IMAGE_FILE_RELOCS_STRIPPED;
ntHdr.mOptionalHeader.mMagic = IMAGE_NT_OPTIONAL_HDR64_MAGIC;
ntHdr.mOptionalHeader.mMajorLinkerVersion = 0xE;
// Export Directory
if (exportSeg != NULL)
{
ntHdr.mOptionalHeader.mDataDirectory[0].mVirtualAddress = exportSeg->mRVA;
ntHdr.mOptionalHeader.mDataDirectory[0].mSize = exportSeg->mCurSize;
}
auto tlsUsedSym = mSymTable.Add("_tls_used");
if (tlsUsedSym->mKind != BlSymKind_Undefined)
{
// TLS Directory
ntHdr.mOptionalHeader.mDataDirectory[9].mVirtualAddress = (uint32)GetSymAddr(tlsUsedSym);
ntHdr.mOptionalHeader.mDataDirectory[9].mSize = 0x28;
}
// Debug Directory
ntHdr.mOptionalHeader.mDataDirectory[6].mVirtualAddress = debugDirSeg->mRVA;
ntHdr.mOptionalHeader.mDataDirectory[6].mSize = debugDirSeg->mCurSize;
// Load Config Directory
ntHdr.mOptionalHeader.mDataDirectory[10].mVirtualAddress = (uint32)GetSymAddr(configSym);
ntHdr.mOptionalHeader.mDataDirectory[10].mSize = 0x94;
BlOutSection* pdataSection = NULL;
int imageSize = 0;
for (auto outSection : mOutSections)
{
if ((outSection->mCharacteristics & IMAGE_SCN_MEM_EXECUTE) != 0)
ntHdr.mOptionalHeader.mSizeOfCode += outSection->mVirtualSize;
if ((outSection->mCharacteristics & IMAGE_SCN_CNT_INITIALIZED_DATA) != 0)
ntHdr.mOptionalHeader.mSizeOfInitializedData += outSection->mVirtualSize;
if ((outSection->mCharacteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA) != 0)
ntHdr.mOptionalHeader.mSizeOfUninitializedData += outSection->mVirtualSize;
int dirIdx = -1;
if (outSection->mName == ".pdata")
{
pdataSection = outSection;
dirIdx = 3; // Exception Directory
}
else if (outSection->mName == ".rsrc")
{
dirIdx = 2; // Resource Directory
}
else if (outSection->mName == ".idata")
{
dirIdx = 1; // Import Directory
int importLookupTableSize = ((int)mImportLookups.size() + (int)mImportFiles.size()) * 8;
ntHdr.mOptionalHeader.mDataDirectory[dirIdx].mVirtualAddress = outSection->mRVA + importLookupTableSize;
ntHdr.mOptionalHeader.mDataDirectory[dirIdx].mSize = outSection->mVirtualSize;
dirIdx = 12; // Import Address Table
}
if (dirIdx != -1)
{
ntHdr.mOptionalHeader.mDataDirectory[dirIdx].mVirtualAddress = outSection->mRVA;
ntHdr.mOptionalHeader.mDataDirectory[dirIdx].mSize = outSection->mVirtualSize;
}
//TODO: Set up data directories
imageSize = (outSection->mRVA + outSection->mVirtualSize + (0x1000 - 1)) & ~(0x1000 - 1);
}
if (entrySym != NULL)
{
auto entrySection = mSegments[entrySym->mSegmentIdx];
ntHdr.mOptionalHeader.mAddressOfEntryPoint = entrySection->mRVA + entrySym->mSegmentOffset;
}
ntHdr.mOptionalHeader.mBaseOfCode = 0x1000;
ntHdr.mOptionalHeader.mImageBase = mImageBase;
ntHdr.mOptionalHeader.mSectionAlignment = 0x1000;
ntHdr.mOptionalHeader.mFileAlignment = 0x200;
ntHdr.mOptionalHeader.mMajorOperatingSystemVersion = 6;
ntHdr.mOptionalHeader.mMinorOperatingSystemVersion = 0;
ntHdr.mOptionalHeader.mMinorImageVersion = 0;
ntHdr.mOptionalHeader.mMajorImageVersion = 0;
ntHdr.mOptionalHeader.mMajorSubsystemVersion = 6;
ntHdr.mOptionalHeader.mMinorSubsystemVersion = 0;
ntHdr.mOptionalHeader.mSizeOfImage = imageSize;
ntHdr.mOptionalHeader.mSizeOfHeaders = 0x400;
if (mIsDLL)
ntHdr.mOptionalHeader.mSubsystem = IMAGE_SUBSYSTEM_WINDOWS_GUI;
else
ntHdr.mOptionalHeader.mSubsystem = mPeSubsystem;
ntHdr.mOptionalHeader.mDllCharacteristics = 0;
if (mIsTerminalServerAware)
ntHdr.mOptionalHeader.mDllCharacteristics |= IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE;
if (mIsNXCompat)
ntHdr.mOptionalHeader.mDllCharacteristics |= IMAGE_DLLCHARACTERISTICS_NX_COMPAT;
if (mHasDynamicBase)
ntHdr.mOptionalHeader.mDllCharacteristics |= IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE;
if (mHighEntropyVA)
ntHdr.mOptionalHeader.mDllCharacteristics |= IMAGE_DLLCHARACTERISTICS_HIGH_ENTROPY_VA;
ntHdr.mOptionalHeader.mSizeOfStackReserve = mStackReserve;
ntHdr.mOptionalHeader.mSizeOfStackCommit = mStackCommit;
ntHdr.mOptionalHeader.mSizeOfHeapReserve = mHeapReserve;
ntHdr.mOptionalHeader.mSizeOfHeapCommit = mHeapCommit;
ntHdr.mOptionalHeader.mNumberOfRvaAndSizes = 0x10;
fs.WriteT(hdr);
uint8 dosProgram[0xB0] = {
0x0E, 0x1F, 0xBA, 0x0E, 0x00, 0xB4, 0x09, 0xCD, 0x21, 0xB8, 0x01, 0x4C, 0xCD, 0x21, 0x54, 0x68,
0x69, 0x73, 0x20, 0x70, 0x72, 0x6F, 0x67, 0x72, 0x61, 0x6D, 0x20, 0x63, 0x61, 0x6E, 0x6E, 0x6F,
0x74, 0x20, 0x62, 0x65, 0x20, 0x72, 0x75, 0x6E, 0x20, 0x69, 0x6E, 0x20, 0x44, 0x4F, 0x53, 0x20,
0x6D, 0x6F, 0x64, 0x65, 0x2E, 0x0D, 0x0D, 0x0A, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x87, 0x9B, 0xD3, 0xE0, 0xC3, 0xFA, 0xBD, 0xB3, 0xC3, 0xFA, 0xBD, 0xB3, 0xC3, 0xFA, 0xBD, 0xB3,
0x77, 0x66, 0x52, 0xB3, 0xC1, 0xFA, 0xBD, 0xB3, 0xF8, 0xA4, 0xBC, 0xB2, 0xC0, 0xFA, 0xBD, 0xB3,
0xF8, 0xA4, 0xBE, 0xB2, 0xC1, 0xFA, 0xBD, 0xB3, 0xF8, 0xA4, 0xB8, 0xB2, 0xD2, 0xFA, 0xBD, 0xB3,
0xF8, 0xA4, 0xB9, 0xB2, 0xCF, 0xFA, 0xBD, 0xB3, 0x1E, 0x05, 0x76, 0xB3, 0xC1, 0xFA, 0xBD, 0xB3,
0xC3, 0xFA, 0xBC, 0xB3, 0xEF, 0xFA, 0xBD, 0xB3, 0x54, 0xA4, 0xB8, 0xB2, 0xC2, 0xFA, 0xBD, 0xB3,
0x51, 0xA4, 0x42, 0xB3, 0xC2, 0xFA, 0xBD, 0xB3, 0x54, 0xA4, 0xBF, 0xB2, 0xC2, 0xFA, 0xBD, 0xB3,
0x52, 0x69, 0x63, 0x68, 0xC3, 0xFA, 0xBD, 0xB3, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
fs.WriteT(dosProgram);
int ntHdrFilePos = fs.GetPos();
fs.WriteT(ntHdr);
int numSections = (int)mOutSections.size();
int rawDataPos = (fs.GetPos() + (numSections * sizeof(PESectionHeader)) + (512 - 1)) & ~(512 - 1);
int rawDataStart = rawDataPos;
int32 sectStartPos = fs.GetPos();
// This doesn't include reloc data, it's just an estimate for optimization
int wantSize = mOutSections.back()->mRawDataPos + mOutSections.back()->mRawSize;
fs.SetSizeFast(wantSize);
for (auto outSection : mOutSections)
{
PESectionHeader sectHdr = { 0 };
if (outSection->mName.length() <= 8)
{
memcpy(sectHdr.mName, outSection->mName.c_str(), (int)outSection->mName.length());
}
else
NotImpl();
BF_ASSERT(rawDataPos == outSection->mRawDataPos);
sectHdr.mVirtualAddress = outSection->mRVA;
sectHdr.mVirtualSize = outSection->mVirtualSize;
sectHdr.mSizeOfRawData = outSection->mRawSize;
sectHdr.mPointerToRawData = rawDataPos;
sectHdr.mCharacteristics = outSection->mCharacteristics;
rawDataPos += outSection->mRawSize;
fs.WriteT(sectHdr);
if (mCodeView != NULL)
mCodeView->mSectionHeaders.WriteT(sectHdr);
}
fs.Align(512);
BF_ASSERT(fs.GetPos() == rawDataStart);
if (mCodeView != NULL)
{
//BL_AUTOPERF("BlContext::Link CodeViewFinish");
//mCodeView->Finish();
}
int itrIdx = 0;
// Actually write section data
for (auto outSection : mOutSections)
{
BL_AUTOPERF("BlContext::Link Write OutSections");
int startPos = fs.GetPos();
if (outSection == relocOutSection)
{
outSection->mVirtualSize = mPeRelocs.mData.GetSize();
outSection->mRawSize = (outSection->mVirtualSize + (512 - 1)) & ~(512 - 1);
mPeRelocs.mData.Read(fs, mPeRelocs.mData.GetSize());
// Reloc Directory
ntHdr.mOptionalHeader.mDataDirectory[5].mVirtualAddress = outSection->mRVA;
ntHdr.mOptionalHeader.mDataDirectory[5].mSize = outSection->mVirtualSize;
//sectHdr.mVirtualAddress = ;
imageSize = (outSection->mRVA + outSection->mVirtualSize + (0x1000 - 1)) & ~(0x1000 - 1);
ntHdr.mOptionalHeader.mSizeOfImage = imageSize;
int endPos = fs.GetPos();
fs.SetPos(ntHdrFilePos);
fs.WriteT(ntHdr);
fs.SetPos(sectStartPos + ((int)mOutSections.size() - 1)*sizeof(PESectionHeader));
PESectionHeader sectHdr = { 0 };
strcpy(sectHdr.mName, ".reloc");
sectHdr.mVirtualAddress = outSection->mRVA;
sectHdr.mVirtualSize = outSection->mVirtualSize;
sectHdr.mSizeOfRawData = outSection->mRawSize;
sectHdr.mPointerToRawData = outSection->mRawDataPos;
sectHdr.mCharacteristics = outSection->mCharacteristics;
fs.WriteT(sectHdr);
fs.SetPos(endPos);
}
else if (outSection == pdataSection)
{
// We need to sort the pdata addresses, but we can sort until after we apply all the relocs which
// doesn't occur until WriteOutSection
struct _PDataEntry
{
uint32 mStartAddr;
uint32 mEndAddr;
uint32 mUnwindData;
};
std::vector<_PDataEntry> pdataVector;
pdataVector.resize(outSection->mVirtualSize / 12);
MemStream memStream((void*)&pdataVector[0], outSection->mVirtualSize, false);
WriteOutSection(outSection, &memStream);
std::sort(pdataVector.begin(), pdataVector.end(), [] (const _PDataEntry& lhs, const _PDataEntry& rhs)
{
return lhs.mStartAddr < rhs.mStartAddr;
});
fs.Write((void*)&pdataVector[0], outSection->mVirtualSize);
}
else
{
CachedDataStream cachedStream(&fs);
WriteOutSection(outSection, &cachedStream);
}
fs.Align(512);
int actualLen = fs.GetPos() - startPos;
BF_ASSERT(actualLen == outSection->mRawSize);
}
if (mCodeView != NULL)
{
if (deferThreads)
{
bool noThreads = false;
if (noThreads)
{
//
{
BL_AUTOPERF("Run TypeWorkThread");
mCodeView->mTypeWorkThread.mTypesDone = true;
mCodeView->mTypeWorkThread.Run();
}
//
{
BL_AUTOPERF("Run ModuleWorkThread");
mCodeView->mModuleWorkThread.mModulesDone = true;
mCodeView->mModuleWorkThread.Run();
}
}
else
{
mCodeView->StartWorkThreads();
}
}
BL_AUTOPERF("BfContext::Link StopWorkingThread");
mCodeView->Finish();
mCodeView->StopWorkThreads();
}
if (mIsDLL)
{
BL_AUTOPERF("BfContext::Link WriteDLLLib");
if (mImpLibName.empty())
{
String libFileName = mOutName;
libFileName.RemoveToEnd(libFileName.length() - 4);
libFileName += ".lib";
mImpLibName = libFileName;
}
WriteDLLLib(mImpLibName);
}
#ifdef BL_PERFTIME
PrintStats();
#endif
/*if (mCodeView != NULL)
BeefyDbg64::TestPDB(mCodeView->mFileName);*/
}
//////////////////////////////////////////////////////////////////////////
BF_EXPORT BlContext* BF_CALLTYPE BlContext_Create()
{
return new BlContext();
}
BF_EXPORT void BF_CALLTYPE BlContext_Delete(BlContext* blContext)
{
BL_AUTOPERF("BlContext_Delete");
delete blContext;
}
BF_EXPORT void BF_CALLTYPE BlContext_Init(BlContext* blContext, bool is64Bit, bool isDebug)
{
blContext->Init(is64Bit, isDebug);
}
BF_EXPORT void BF_CALLTYPE BlContext_AddSearchPath(BlContext* blContext, const char* directory)
{
blContext->AddSearchPath(directory);
}
BF_EXPORT bool BF_CALLTYPE BlContext_AddFile(BlContext* blContext, const char* fileName)
{
return blContext->AddFile(fileName, BlObjectDataKind_SpecifiedObj);
}
BF_EXPORT bool BF_CALLTYPE BlContext_Link(BlContext* blContext)
{
blContext->Link();
return !blContext->mFailed;
}
BF_EXPORT void BF_CALLTYPE BlContext_SetOutName(BlContext* blContext, const char* outName)
{
blContext->mOutName = outName;
}
BF_EXPORT void BF_CALLTYPE BlContext_SetEntryPoint(BlContext* blContext, const char* entryPoint)
{
blContext->mEntryPoint = entryPoint;
}
BF_EXPORT void BF_CALLTYPE BlContext_SetImpLib(BlContext* blContext, const char* impLibName)
{
blContext->mImpLibName = impLibName;
}
BF_EXPORT void BF_CALLTYPE BlContext_SetDebug(BlContext* blContext, int debugMode)
{
blContext->mDebugKind = debugMode;
}
BF_EXPORT void BF_CALLTYPE BlContext_SetPDBName(BlContext* blContext, const char* pdbPath)
{
blContext->mPDBPath = pdbPath;
}
BF_EXPORT void BF_CALLTYPE BlContext_SetIsDLL(BlContext* blContext)
{
blContext->mIsDLL = true;
}
BF_EXPORT void BF_CALLTYPE BlContext_SetVerbose(BlContext* blContext, bool enabled)
{
blContext->mVerbose = true;
}
BF_EXPORT void BF_CALLTYPE BlContext_SetNoDefaultLib(BlContext* blContext, bool enabled)
{
blContext->mNoDefaultLib = enabled;
}
BF_EXPORT void BF_CALLTYPE BlContext_AddNoDefaultLib(BlContext* blContext, const char* name)
{
String libName = name;
FixLibName(libName);
String libCanonName = FixPathAndCase(libName);
blContext->mNoDefaultLibs.insert(libCanonName);
}
BF_EXPORT void BF_CALLTYPE BlContext_AddDefaultLib(BlContext* blContext, const char* name)
{
blContext->mDefaultLibs.push_back(name);
}
BF_EXPORT void BF_CALLTYPE BlContext_SetImageBase(BlContext* blContext, int64 base)
{
blContext->mImageBase = base;
}
BF_EXPORT void BF_CALLTYPE BlContext_SetFixedBase(BlContext* blContext, bool enabled)
{
blContext->mHasFixedBase = enabled;
}
BF_EXPORT void BF_CALLTYPE BlContext_SetDynamicBase(BlContext* blContext, bool enabled)
{
blContext->mHasDynamicBase = enabled;
}
BF_EXPORT void BF_CALLTYPE BlContext_SetHighEntropyVA(BlContext* blContext, bool enabled)
{
blContext->mHighEntropyVA = enabled;
}
BF_EXPORT void BF_CALLTYPE BlContext_ManifestUAC(BlContext* blContext, const char* manifestUAC)
{
blContext->mManifestUAC = manifestUAC;
}
BF_EXPORT void BF_CALLTYPE BlContext_SetSubsystem(BlContext* blContext, int subsystem)
{
blContext->mPeSubsystem = subsystem;
}
BF_EXPORT void BF_CALLTYPE BlContext_SetStack(BlContext* blContext, int reserve, int commit)
{
if (reserve > 0)
blContext->mStackReserve = BF_ALIGN(reserve, 4);
if (commit > 0)
blContext->mStackCommit = BF_ALIGN(commit, 4);
}
BF_EXPORT void BF_CALLTYPE BlContext_SetHeap(BlContext* blContext, int reserve, int commit)
{
if (reserve > 0)
blContext->mHeapReserve = BF_ALIGN(reserve, 4);
if (commit > 0)
blContext->mHeapCommit = BF_ALIGN(commit, 4);
}
View git blame Copy permalink