void LFS::import(std::string& lfsFileName, std::istream& data) {
unsigned iMapAddress = iMapAddresses[currentIMapIdx];
unsigned iMapSegmentIdx = getSegmentIndexFromAddress(iMapAddress);
unsigned iMapBlockIdx = getBlockIndexFromAddress(iMapAddress);
IMap iMap(segments[iMapSegmentIdx]->blocks[iMapBlockIdx]);
if (iMapAddress == 0) {
iMap = IMap();
}
if (!iMap.hasFree()) {
iMap = IMap();
currentIMapIdx++; // may go out of bounds.
}
INode iNode(lfsFileName);
while (data) {
Block dataBlock;
data >> dataBlock;
unsigned blockOffset =
segments[currentSegmentIdx]->addBlock(
dataBlock, iNode.fileSize, iMap.getNextINodeIndex());
if (blockOffset == 0) {
selectNewCleanSegment();
blockOffset = segments[currentSegmentIdx]->addBlock(
dataBlock, iNode.fileSize, iMap.getNextINodeIndex());
}
unsigned blockAddress = (currentSegmentIdx << 10) + blockOffset;
iNode.addBlockAddress(blockAddress);
if (iNode.fileSize == 128) {
data.setstate(std::ios::badbit);
break;
}
}
unsigned iNodeOffset =segments[currentSegmentIdx]->addBlock(
iNode, iMap.getNextINodeIndex());
if (iNodeOffset == 0) {
selectNewCleanSegment();
iNodeOffset = segments[currentSegmentIdx]->addBlock(
iNode, iMap.getNextINodeIndex());
}
unsigned iNodeAddress = (currentSegmentIdx << 10) + iNodeOffset;
iMap.addINodeWithAddress(iNodeAddress);
unsigned iMapOffset = segments[currentSegmentIdx]->addBlock(iMap, currentIMapIdx);
if (iMapOffset == 0) {
selectNewCleanSegment();
iMapOffset = segments[currentSegmentIdx]->addBlock(iMap, currentIMapIdx);
}
iMapAddress = (currentSegmentIdx << 10) + iMapOffset;
iMapAddresses[currentIMapIdx] = iMapAddress;
files[lfsFileName] = iNodeAddress;
}
//===----------------------------------------------------------------------===//
// Parse 'InstrMapping' records and use the information to form relationship
// between instructions. These relations are emitted as a tables along with the
// functions to query them.
//===----------------------------------------------------------------------===//
void EmitMapTable(RecordKeeper &Records, raw_ostream &OS) {
CodeGenTarget Target(Records);
std::string TargetName = Target.getName();
std::vector<Record*> InstrMapVec;
InstrMapVec = Records.getAllDerivedDefinitions("InstrMapping");
if (InstrMapVec.empty())
return;
OS << "#ifdef GET_INSTRMAP_INFO\n";
OS << "#undef GET_INSTRMAP_INFO\n";
OS << "namespace llvm {\n\n";
OS << "namespace " << TargetName << " {\n\n";
// Emit coulumn field names and their values as enums.
emitEnums(OS, Records);
// Iterate over all instruction mapping records and construct relationship
// maps based on the information specified there.
//
for (Record *CurMap : InstrMapVec) {
MapTableEmitter IMap(Target, Records, CurMap);
// Build RowInstrMap to group instructions based on their values for
// RowFields. In the process, also collect key instructions into
// KeyInstrVec.
IMap.buildRowInstrMap();
// Build MapTable to map key instructions with the corresponding column
// instructions.
IMap.buildMapTable();
// Emit map tables and the functions to query them.
IMap.emitTablesWithFunc(OS);
}
OS << "} // End " << TargetName << " namespace\n";
OS << "} // End llvm namespace\n";
OS << "#endif // GET_INSTRMAP_INFO\n\n";
}
