bool Scan::loadCachedBinary(const string& file, const util::Params& params) {
if (!io::fileExists(file)) { return false; }
ifstream ifs(file, std::ios::binary);
{
ba::binary_iarchive ar(ifs);
ar >> id;
ar >> loadedMeshFileFullPath;
ar >> mesh;
ar >> bbox;
}
ifs.close();
finalizeLoad(params);
return true;
}
void Scan::loadFromCornellPLY(const util::Params& params, const string& plyfile) {
const string baseDir = params.get<string>("dataDir") + params.get<string>("cornellScanDir"),
filename = plyfile,
scanId = io::basename(filename),
cachedScanFile = params.get<string>("dataCacheDir") + params.get<string>("cornellScanDir")
+ scanId + ".cached";
if (loadCachedBinary(cachedScanFile, params)) { return; } // Bail out if can load cached
//mesh = ml::OpenMeshLoader::load(filename); ml::MeshDataf meshData; mesh.getMeshData(meshData);
loadedMeshFileFullPath = baseDir + filename;
mesh = loadCornellPLY(loadedMeshFileFullPath);
bbox = mesh.computeBoundingBox();
finalizeLoad(params);
// Save cached binary if it does not already exist
if (!io::fileExists(cachedScanFile)) {
saveCachedBinary(cachedScanFile);
}
}
ObjectImage *RuntimeDyldImpl::loadObject(ObjectImage *InputObject) {
MutexGuard locked(lock);
std::unique_ptr<ObjectImage> Obj(InputObject);
if (!Obj)
return NULL;
// Save information about our target
Arch = (Triple::ArchType)Obj->getArch();
IsTargetLittleEndian = Obj->getObjectFile()->isLittleEndian();
// Compute the memory size required to load all sections to be loaded
// and pass this information to the memory manager
if (MemMgr->needsToReserveAllocationSpace()) {
uint64_t CodeSize = 0, DataSizeRO = 0, DataSizeRW = 0;
computeTotalAllocSize(*Obj, CodeSize, DataSizeRO, DataSizeRW);
MemMgr->reserveAllocationSpace(CodeSize, DataSizeRO, DataSizeRW);
}
// Symbols found in this object
StringMap<SymbolLoc> LocalSymbols;
// Used sections from the object file
ObjSectionToIDMap LocalSections;
// Common symbols requiring allocation, with their sizes and alignments
CommonSymbolMap CommonSymbols;
// Maximum required total memory to allocate all common symbols
uint64_t CommonSize = 0;
// Parse symbols
DEBUG(dbgs() << "Parse symbols:\n");
for (symbol_iterator I = Obj->begin_symbols(), E = Obj->end_symbols(); I != E;
++I) {
object::SymbolRef::Type SymType;
StringRef Name;
Check(I->getType(SymType));
Check(I->getName(Name));
uint32_t Flags = I->getFlags();
bool IsCommon = Flags & SymbolRef::SF_Common;
if (IsCommon) {
// Add the common symbols to a list. We'll allocate them all below.
uint32_t Align;
Check(I->getAlignment(Align));
uint64_t Size = 0;
Check(I->getSize(Size));
CommonSize += Size + Align;
CommonSymbols[*I] = CommonSymbolInfo(Size, Align);
} else {
if (SymType == object::SymbolRef::ST_Function ||
SymType == object::SymbolRef::ST_Data ||
SymType == object::SymbolRef::ST_Unknown) {
uint64_t FileOffset;
StringRef SectionData;
bool IsCode;
section_iterator SI = Obj->end_sections();
Check(I->getFileOffset(FileOffset));
Check(I->getSection(SI));
if (SI == Obj->end_sections())
continue;
Check(SI->getContents(SectionData));
Check(SI->isText(IsCode));
const uint8_t *SymPtr =
(const uint8_t *)Obj->getData().data() + (uintptr_t)FileOffset;
uintptr_t SectOffset =
(uintptr_t)(SymPtr - (const uint8_t *)SectionData.begin());
unsigned SectionID =
findOrEmitSection(*Obj, *SI, IsCode, LocalSections);
LocalSymbols[Name.data()] = SymbolLoc(SectionID, SectOffset);
DEBUG(dbgs() << "\tFileOffset: " << format("%p", (uintptr_t)FileOffset)
<< " flags: " << Flags << " SID: " << SectionID
<< " Offset: " << format("%p", SectOffset));
GlobalSymbolTable[Name] = SymbolLoc(SectionID, SectOffset);
}
}
DEBUG(dbgs() << "\tType: " << SymType << " Name: " << Name << "\n");
}
// Allocate common symbols
if (CommonSize != 0)
emitCommonSymbols(*Obj, CommonSymbols, CommonSize, LocalSymbols);
// Parse and process relocations
DEBUG(dbgs() << "Parse relocations:\n");
for (section_iterator SI = Obj->begin_sections(), SE = Obj->end_sections();
SI != SE; ++SI) {
unsigned SectionID = 0;
StubMap Stubs;
section_iterator RelocatedSection = SI->getRelocatedSection();
if (SI->relocation_empty() && !ProcessAllSections)
continue;
bool IsCode = false;
Check(RelocatedSection->isText(IsCode));
SectionID =
findOrEmitSection(*Obj, *RelocatedSection, IsCode, LocalSections);
DEBUG(dbgs() << "\tSectionID: " << SectionID << "\n");
for (relocation_iterator I = SI->relocation_begin(),
E = SI->relocation_end(); I != E;)
I = processRelocationRef(SectionID, I, *Obj, LocalSections, LocalSymbols,
Stubs);
}
// Give the subclasses a chance to tie-up any loose ends.
finalizeLoad(LocalSections);
return Obj.release();
}
ObjectImage *RuntimeDyldImpl::loadObject(ObjectBuffer *InputBuffer) {
MutexGuard locked(lock);
OwningPtr<ObjectImage> obj(createObjectImage(InputBuffer));
if (!obj)
report_fatal_error("Unable to create object image from memory buffer!");
// Save information about our target
Arch = (Triple::ArchType)obj->getArch();
IsTargetLittleEndian = obj->getObjectFile()->isLittleEndian();
// Symbols found in this object
StringMap<SymbolLoc> LocalSymbols;
// Used sections from the object file
ObjSectionToIDMap LocalSections;
// Common symbols requiring allocation, with their sizes and alignments
CommonSymbolMap CommonSymbols;
// Maximum required total memory to allocate all common symbols
uint64_t CommonSize = 0;
error_code err;
// Parse symbols
DEBUG(dbgs() << "Parse symbols:\n");
for (symbol_iterator i = obj->begin_symbols(), e = obj->end_symbols();
i != e; i.increment(err)) {
Check(err);
object::SymbolRef::Type SymType;
StringRef Name;
Check(i->getType(SymType));
Check(i->getName(Name));
uint32_t flags;
Check(i->getFlags(flags));
bool isCommon = flags & SymbolRef::SF_Common;
if (isCommon) {
// Add the common symbols to a list. We'll allocate them all below.
uint32_t Align;
Check(i->getAlignment(Align));
uint64_t Size = 0;
Check(i->getSize(Size));
CommonSize += Size + Align;
CommonSymbols[*i] = CommonSymbolInfo(Size, Align);
} else {
if (SymType == object::SymbolRef::ST_Function ||
SymType == object::SymbolRef::ST_Data ||
SymType == object::SymbolRef::ST_Unknown) {
uint64_t FileOffset;
StringRef SectionData;
bool IsCode;
section_iterator si = obj->end_sections();
Check(i->getFileOffset(FileOffset));
Check(i->getSection(si));
if (si == obj->end_sections()) continue;
Check(si->getContents(SectionData));
Check(si->isText(IsCode));
const uint8_t* SymPtr = (const uint8_t*)InputBuffer->getBufferStart() +
(uintptr_t)FileOffset;
uintptr_t SectOffset = (uintptr_t)(SymPtr -
(const uint8_t*)SectionData.begin());
unsigned SectionID = findOrEmitSection(*obj, *si, IsCode, LocalSections);
LocalSymbols[Name.data()] = SymbolLoc(SectionID, SectOffset);
DEBUG(dbgs() << "\tFileOffset: " << format("%p", (uintptr_t)FileOffset)
<< " flags: " << flags
<< " SID: " << SectionID
<< " Offset: " << format("%p", SectOffset));
GlobalSymbolTable[Name] = SymbolLoc(SectionID, SectOffset);
}
}
DEBUG(dbgs() << "\tType: " << SymType << " Name: " << Name << "\n");
}
// Allocate common symbols
if (CommonSize != 0)
emitCommonSymbols(*obj, CommonSymbols, CommonSize, LocalSymbols);
// Parse and process relocations
DEBUG(dbgs() << "Parse relocations:\n");
for (section_iterator si = obj->begin_sections(),
se = obj->end_sections(); si != se; si.increment(err)) {
Check(err);
bool isFirstRelocation = true;
unsigned SectionID = 0;
StubMap Stubs;
section_iterator RelocatedSection = si->getRelocatedSection();
for (relocation_iterator i = si->begin_relocations(),
e = si->end_relocations(); i != e; i.increment(err)) {
Check(err);
// If it's the first relocation in this section, find its SectionID
if (isFirstRelocation) {
SectionID =
findOrEmitSection(*obj, *RelocatedSection, true, LocalSections);
DEBUG(dbgs() << "\tSectionID: " << SectionID << "\n");
isFirstRelocation = false;
}
processRelocationRef(SectionID, *i, *obj, LocalSections, LocalSymbols,
Stubs);
}
}
// Give the subclasses a chance to tie-up any loose ends.
finalizeLoad(LocalSections);
return obj.take();
}
