BitstreamCursor Stream;
uint64_t NextUnreadBit = 0;
bool SeenValueSymbolTable = false;
- unsigned VSTOffset = 0;
std::vector<Type*> TypeList;
BitcodeReaderValueList ValueList;
std::error_code parseTypeTable();
std::error_code parseTypeTableBody();
- ErrorOr<Value *> recordValue(SmallVectorImpl<uint64_t> &Record,
- unsigned NameIndex, Triple &TT);
- std::error_code parseValueSymbolTable(unsigned Offset = 0);
+ std::error_code parseValueSymbolTable();
std::error_code parseConstants();
std::error_code rememberAndSkipFunctionBody();
/// Save the positions of the Metadata blocks and skip parsing the blocks.
}
}
-/// Associate a value with its name from the given index in the provided record.
-ErrorOr<Value *> BitcodeReader::recordValue(SmallVectorImpl<uint64_t> &Record,
- unsigned NameIndex, Triple &TT) {
- SmallString<128> ValueName;
- if (convertToString(Record, NameIndex, ValueName))
- return error("Invalid record");
- unsigned ValueID = Record[0];
- if (ValueID >= ValueList.size() || !ValueList[ValueID])
- return error("Invalid record");
- Value *V = ValueList[ValueID];
-
- V->setName(StringRef(ValueName.data(), ValueName.size()));
- auto *GO = dyn_cast<GlobalObject>(V);
- if (GO) {
- if (GO->getComdat() == reinterpret_cast<Comdat *>(1)) {
- if (TT.isOSBinFormatMachO())
- GO->setComdat(nullptr);
- else
- GO->setComdat(TheModule->getOrInsertComdat(V->getName()));
- }
- }
- return V;
-}
-
-/// Parse the value symbol table at either the current parsing location or
-/// at the given bit offset if provided.
-std::error_code BitcodeReader::parseValueSymbolTable(unsigned Offset) {
- uint64_t CurrentBit;
- // Pass in the Offset to distinguish between calling for the module-level
- // VST (where we want to jump to the VST offset) and the function-level
- // VST (where we don't).
- if (Offset > 0) {
- // Save the current parsing location so we can jump back at the end
- // of the VST read.
- CurrentBit = Stream.GetCurrentBitNo();
- Stream.JumpToBit(Offset * 32);
- BitstreamEntry Entry = Stream.advance();
- assert(Entry.Kind == BitstreamEntry::SubBlock);
- assert(Entry.ID == bitc::VALUE_SYMTAB_BLOCK_ID);
- }
-
- // Compute the delta between the bitcode indices in the VST (the word offset
- // to the word-aligned ENTER_SUBBLOCK for the function block, and that
- // expected by the lazy reader. The reader's EnterSubBlock expects to have
- // already read the ENTER_SUBBLOCK code (size getAbbrevIDWidth) and BlockID
- // (size BlockIDWidth). Note that we access the stream's AbbrevID width here
- // just before entering the VST subblock because: 1) the EnterSubBlock
- // changes the AbbrevID width; 2) the VST block is nested within the same
- // outer MODULE_BLOCK as the FUNCTION_BLOCKs and therefore have the same
- // AbbrevID width before calling EnterSubBlock; and 3) when we want to
- // jump to the FUNCTION_BLOCK using this offset later, we don't want
- // to rely on the stream's AbbrevID width being that of the MODULE_BLOCK.
- unsigned FuncBitcodeOffsetDelta =
- Stream.getAbbrevIDWidth() + bitc::BlockIDWidth;
-
+std::error_code BitcodeReader::parseValueSymbolTable() {
if (Stream.EnterSubBlock(bitc::VALUE_SYMTAB_BLOCK_ID))
return error("Invalid record");
case BitstreamEntry::Error:
return error("Malformed block");
case BitstreamEntry::EndBlock:
- if (Offset > 0)
- Stream.JumpToBit(CurrentBit);
return std::error_code();
case BitstreamEntry::Record:
// The interesting case.
default: // Default behavior: unknown type.
break;
case bitc::VST_CODE_ENTRY: { // VST_ENTRY: [valueid, namechar x N]
- ErrorOr<Value *> ValOrErr = recordValue(Record, 1, TT);
- if (std::error_code EC = ValOrErr.getError())
- return EC;
- ValOrErr.get();
- break;
- }
- case bitc::VST_CODE_FNENTRY: {
- // VST_FNENTRY: [valueid, offset, namechar x N]
- ErrorOr<Value *> ValOrErr = recordValue(Record, 2, TT);
- if (std::error_code EC = ValOrErr.getError())
- return EC;
- Value *V = ValOrErr.get();
-
- auto *GO = dyn_cast<GlobalObject>(V);
- if (!GO) {
- // If this is an alias, need to get the actual Function object
- // it aliases, in order to set up the DeferredFunctionInfo entry below.
- auto *GA = dyn_cast<GlobalAlias>(V);
- if (GA)
- GO = GA->getBaseObject();
- assert(GO);
- }
+ if (convertToString(Record, 1, ValueName))
+ return error("Invalid record");
+ unsigned ValueID = Record[0];
+ if (ValueID >= ValueList.size() || !ValueList[ValueID])
+ return error("Invalid record");
+ Value *V = ValueList[ValueID];
- uint64_t FuncWordOffset = Record[1];
- Function *F = dyn_cast<Function>(GO);
- assert(F);
- uint64_t FuncBitOffset = FuncWordOffset * 32;
- DeferredFunctionInfo[F] = FuncBitOffset + FuncBitcodeOffsetDelta;
- // Set the NextUnreadBit to point to the last function block.
- // Later when parsing is resumed after function materialization,
- // we can simply skip that last function block.
- if (FuncBitOffset > NextUnreadBit)
- NextUnreadBit = FuncBitOffset;
+ V->setName(StringRef(ValueName.data(), ValueName.size()));
+ if (auto *GO = dyn_cast<GlobalObject>(V)) {
+ if (GO->getComdat() == reinterpret_cast<Comdat *>(1)) {
+ if (TT.isOSBinFormatMachO())
+ GO->setComdat(nullptr);
+ else
+ GO->setComdat(TheModule->getOrInsertComdat(V->getName()));
+ }
+ }
+ ValueName.clear();
break;
}
case bitc::VST_CODE_BBENTRY: {
return EC;
break;
case bitc::VALUE_SYMTAB_BLOCK_ID:
- if (!SeenValueSymbolTable) {
- // Either this is an old form VST without function index and an
- // associated VST forward declaration record (which would have caused
- // the VST to be jumped to and parsed before it was encountered
- // normally in the stream), or there were no function blocks to
- // trigger an earlier parsing of the VST.
- assert(VSTOffset == 0 || FunctionsWithBodies.empty());
- if (std::error_code EC = parseValueSymbolTable())
- return EC;
- SeenValueSymbolTable = true;
- } else {
- // We must have had a VST forward declaration record, which caused
- // the parser to jump to and parse the VST earlier.
- assert(VSTOffset > 0);
- if (Stream.SkipBlock())
- return error("Invalid record");
- }
+ if (std::error_code EC = parseValueSymbolTable())
+ return EC;
+ SeenValueSymbolTable = true;
break;
case bitc::CONSTANTS_BLOCK_ID:
if (std::error_code EC = parseConstants())
SeenFirstFunctionBody = true;
}
- if (VSTOffset > 0) {
- // If we have a VST forward declaration record, make sure we
- // parse the VST now if we haven't already. It is needed to
- // set up the DeferredFunctionInfo vector for lazy reading.
- if (!SeenValueSymbolTable) {
- if (std::error_code EC =
- BitcodeReader::parseValueSymbolTable(VSTOffset))
- return EC;
- SeenValueSymbolTable = true;
- return std::error_code();
- } else {
- // If we have a VST forward declaration record, but have already
- // parsed the VST (just above, when the first function body was
- // encountered here), then we are resuming the parse after
- // materializing functions. The NextUnreadBit points to the start
- // of the last function block recorded in the VST (set when
- // parsing the VST function entries). Skip it.
- if (Stream.SkipBlock())
- return error("Invalid record");
- continue;
- }
- }
-
- // Support older bitcode files that did not have the function
- // index in the VST, nor a VST forward declaration record.
- // Build the DeferredFunctionInfo vector on the fly.
if (std::error_code EC = rememberAndSkipFunctionBody())
return EC;
// Suspend parsing when we reach the function bodies. Subsequent
return error("Invalid record");
ValueList.shrinkTo(Record[0]);
break;
- /// MODULE_CODE_VSTOFFSET: [offset]
- case bitc::MODULE_CODE_VSTOFFSET:
- if (Record.size() < 1)
- return error("Invalid record");
- VSTOffset = Record[0];
- break;
}
Record.clear();
}
Function *F,
DenseMap<Function *, uint64_t>::iterator DeferredFunctionInfoIterator) {
while (DeferredFunctionInfoIterator->second == 0) {
- // This is the fallback handling for the old format bitcode that
- // didn't contain the function index in the VST. Assert if we end up
- // here for the new format (which is the only time the VSTOffset would
- // be non-zero).
- assert(VSTOffset == 0);
if (Stream.AtEndOfStream())
return error("Could not find function in stream");
// ParseModule will parse the next body in the stream and set its
projects / oota-llvm.git / blobdiff