ModuleFileSharedCore.cpp

//===--- ModuleFileSharedCore.cpp - Core of a serialized module -----------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//

#include"ModuleFileSharedCore.h"
#include"ModuleFileCoreTableInfo.h"
#include"BCReadingExtras.h"
#include"DeserializationErrors.h"
#include"swift/Basic/LangOptions.h"
#include"swift/Strings.h"
#include"llvm/Support/MemoryBuffer.h"
#include"llvm/Support/OnDiskHashTable.h"
#include"llvm/Support/PrettyStackTrace.h"

usingnamespaceswift;
usingnamespaceswift::serialization;
usingnamespacellvm::support;
using llvm::Expected;

staticboolcheckModuleSignature(llvm::BitstreamCursor &cursor,
 ArrayRef<unsignedchar> signature) {
for (unsignedchar byte : signature) {
if (cursor.AtEndOfStream())
returnfalse;
if (Expected<llvm::SimpleBitstreamCursor::word_t> maybeRead =
 cursor.Read(8)) {
if (maybeRead.get() != byte)
returnfalse;
 } else {
consumeError(maybeRead.takeError());
returnfalse;
 }
 }
returntrue;
}

staticboolenterTopLevelModuleBlock(llvm::BitstreamCursor &cursor,
unsigned ID,
bool shouldReadBlockInfo = true) {
 Expected<llvm::BitstreamEntry> maybeNext = cursor.advance();
if (!maybeNext) {
// FIXME this drops the error on the floor.
consumeError(maybeNext.takeError());
returnfalse;
 }
 llvm::BitstreamEntry next = maybeNext.get();

if (next.Kind != llvm::BitstreamEntry::SubBlock)
returnfalse;

if (next.ID == llvm::bitc::BLOCKINFO_BLOCK_ID) {
if (shouldReadBlockInfo) {
if (!cursor.ReadBlockInfoBlock())
returnfalse;
 } else {
if (cursor.SkipBlock())
returnfalse;
 }
returnenterTopLevelModuleBlock(cursor, ID, false);
 }

if (next.ID != ID)
returnfalse;

if (llvm::Error Err = cursor.EnterSubBlock(ID)) {
// FIXME this drops the error on the floor.
consumeError(std::move(Err));
returnfalse;
 }

returntrue;
}

/// Populate \p extendedInfo with the data from the options block.
///
/// Returns true on success.
staticboolreadOptionsBlock(llvm::BitstreamCursor &cursor,
 SmallVectorImpl<uint64_t> &scratch,
 ExtendedValidationInfo &extendedInfo,
 PathObfuscator &pathRecoverer) {
while (!cursor.AtEndOfStream()) {
 Expected<llvm::BitstreamEntry> maybeEntry = cursor.advance();
if (!maybeEntry) {
// FIXME this drops the error on the floor.
consumeError(maybeEntry.takeError());
returnfalse;
 }
 llvm::BitstreamEntry entry = maybeEntry.get();
if (entry.Kind == llvm::BitstreamEntry::EndBlock)
break;

if (entry.Kind == llvm::BitstreamEntry::Error)
returnfalse;

if (entry.Kind == llvm::BitstreamEntry::SubBlock) {
// Unknown metadata sub-block, possibly for use by a future version of
// the module format.
if (cursor.SkipBlock())
returnfalse;
continue;
 }

 scratch.clear();
 StringRef blobData;
 Expected<unsigned> maybeKind =
 cursor.readRecord(entry.ID, scratch, &blobData);
if (!maybeKind) {
// FIXME this drops the error on the floor.
consumeError(maybeKind.takeError());
returnfalse;
 }
unsigned kind = maybeKind.get();
switch (kind) {
case options_block::SDK_PATH:
 extendedInfo.setSDKPath(pathRecoverer.recover(blobData));
break;
case options_block::XCC:
 extendedInfo.addExtraClangImporterOption(blobData);
break;
case options_block::IS_SIB:
bool IsSIB;
options_block::IsSIBLayout::readRecord(scratch, IsSIB);
 extendedInfo.setIsSIB(IsSIB);
break;
case options_block::IS_STATIC_LIBRARY:
 extendedInfo.setIsStaticLibrary(true);
break;
case options_block::HAS_HERMETIC_SEAL_AT_LINK:
 extendedInfo.setHasHermeticSealAtLink(true);
break;
case options_block::IS_TESTABLE:
 extendedInfo.setIsTestable(true);
break;
case options_block::ARE_PRIVATE_IMPORTS_ENABLED:
 extendedInfo.setPrivateImportsEnabled(true);
break;
case options_block::IS_IMPLICIT_DYNAMIC_ENABLED:
 extendedInfo.setImplicitDynamicEnabled(true);
break;
case options_block::RESILIENCE_STRATEGY:
unsigned Strategy;
options_block::ResilienceStrategyLayout::readRecord(scratch, Strategy);
 extendedInfo.setResilienceStrategy(ResilienceStrategy(Strategy));
break;
case options_block::IS_ALLOW_MODULE_WITH_COMPILER_ERRORS_ENABLED:
 extendedInfo.setAllowModuleWithCompilerErrorsEnabled(true);
break;
case options_block::MODULE_ABI_NAME:
 extendedInfo.setModuleABIName(blobData);
break;
case options_block::IS_CONCURRENCY_CHECKED:
 extendedInfo.setIsConcurrencyChecked(true);
break;
default:
// Unknown options record, possibly for use by a future version of the
// module format.
break;
 }
 }

returntrue;
}

static ValidationInfo validateControlBlock(
 llvm::BitstreamCursor &cursor, SmallVectorImpl<uint64_t> &scratch,
 std::pair<uint16_t, uint16_t> expectedVersion, bool requiresOSSAModules,
bool requiresRevisionMatch,
 StringRef requiredSDK,
 ExtendedValidationInfo *extendedInfo,
 PathObfuscator &pathRecoverer) {
// The control block is malformed until we've at least read a major version
// number.
 ValidationInfo result;
bool versionSeen = false;
bool revisionSeen = false;

while (!cursor.AtEndOfStream()) {
 Expected<llvm::BitstreamEntry> maybeEntry = cursor.advance();
if (!maybeEntry) {
// FIXME this drops the error on the floor.
consumeError(maybeEntry.takeError());
 result.status = Status::Malformed;
return result;
 }
 llvm::BitstreamEntry entry = maybeEntry.get();
if (entry.Kind == llvm::BitstreamEntry::EndBlock)
break;

if (entry.Kind == llvm::BitstreamEntry::Error) {
 result.status = Status::Malformed;
return result;
 }

if (entry.Kind == llvm::BitstreamEntry::SubBlock) {
if (entry.ID == OPTIONS_BLOCK_ID && extendedInfo) {
if (llvm::Error Err = cursor.EnterSubBlock(OPTIONS_BLOCK_ID)) {
// FIXME this drops the error on the floor.
consumeError(std::move(Err));
 result.status = Status::Malformed;
return result;
 }
if (!readOptionsBlock(cursor, scratch, *extendedInfo, pathRecoverer)) {
 result.status = Status::Malformed;
return result;
 }
 } else {
// Unknown metadata sub-block, possibly for use by a future version of
// the module format.
if (cursor.SkipBlock()) {
 result.status = Status::Malformed;
return result;
 }
 }
continue;
 }

 scratch.clear();
 StringRef blobData;
 Expected<unsigned> maybeKind =
 cursor.readRecord(entry.ID, scratch, &blobData);
if (!maybeKind) {
// FIXME this drops the error on the floor.
consumeError(maybeKind.takeError());
 result.status = Status::Malformed;
return result;
 }
unsigned kind = maybeKind.get();
switch (kind) {
case control_block::METADATA: {
if (versionSeen) {
 result.status = Status::Malformed;
break;
 }

uint16_t versionMajor = scratch[0];
if (versionMajor > expectedVersion.first)
 result.status = Status::FormatTooNew;
elseif (versionMajor < expectedVersion.first)
 result.status = Status::FormatTooOld;
else
 result.status = Status::Valid;

// Major version 0 does not have stable minor versions.
if (versionMajor == 0) {
uint16_t versionMinor = scratch[1];
if (versionMinor != expectedVersion.second) {
if (versionMinor < expectedVersion.second)
 result.status = Status::FormatTooOld;
else
 result.status = Status::FormatTooNew;
 }
 }

// These fields were added later; be resilient against their absence.
switch (scratch.size()) {
default:
// Add new cases here, in descending order.
case8:
case7:
case6:
case5: {
auto subMinor = 0;
auto build = 0;
// case 7 and 8 were added after case 5 and 6, so we need to have this
// special handling to make sure we can still load the module without
// case 7 and case 8 successfully.
if (scratch.size() >= 8) {
 subMinor = scratch[6];
 build = scratch[7];
 }
 result.userModuleVersion = llvm::VersionTuple(scratch[4], scratch[5],
 subMinor, build);
 LLVM_FALLTHROUGH;
 }
case4:
if (scratch[3] != 0) {
 result.compatibilityVersion =
version::Version(blobData.substr(scratch[2]+1, scratch[3]),
SourceLoc(), nullptr);
 }
 LLVM_FALLTHROUGH;
case3:
 result.shortVersion = blobData.slice(0, scratch[2]);
 LLVM_FALLTHROUGH;
case2:
case1:
case0:
break;
 }

 result.miscVersion = blobData;
 versionSeen = true;
break;
 }
case control_block::MODULE_NAME:
 result.name = blobData;
break;
case control_block::TARGET:
 result.targetTriple = blobData;
break;
case control_block::SDK_NAME: {
 result.sdkName = blobData;

// Enable this check for tagged compiler or when the
// env var is set (for testing).
staticconstchar* forceDebugPreSDKRestriction =
::getenv("SWIFT_DEBUG_FORCE_SWIFTMODULE_PER_SDK");
if (!version::isCurrentCompilerTagged() &&
 !forceDebugPreSDKRestriction) {
break;
 }

// The loaded module was built with a compatible SDK if either:
// * it was the same SDK
// * or one who's name is a prefix of the clients' SDK name. This expects
// that a module built with macOS11 can be used with the macOS11.secret SDK.
// This is generally the case as SDKs with suffixes are a superset of the
// short SDK name equivalent. While this is accepted, this is still not a
// recommended configuration and may lead to unreadable swiftmodules.
 StringRef moduleSDK = blobData;
if (!moduleSDK.empty() && !requiredSDK.empty() &&
 !requiredSDK.startswith(moduleSDK)) {
 result.status = Status::SDKMismatch;
return result;
 }

break;
 }
case control_block::REVISION: {
 revisionSeen = true;

// Tagged compilers should only load modules if they were
// produced by the exact same compiler tag.

// Disable this restriction for compiler testing by setting this
// env var to any value.
staticconstchar* ignoreRevision =
::getenv("SWIFT_DEBUG_IGNORE_SWIFTMODULE_REVISION");
if (ignoreRevision)
break;

// Override this env var for testing, forcing the behavior of a tagged
// compiler and using the env var value to override this compiler's
// revision.
staticconstchar* forcedDebugRevision =
::getenv("SWIFT_DEBUG_FORCE_SWIFTMODULE_REVISION");

bool isCompilerTagged = forcedDebugRevision ||
version::isCurrentCompilerTagged();

 StringRef moduleRevision = blobData;
if (isCompilerTagged) {
 StringRef compilerRevision = forcedDebugRevision ?
 forcedDebugRevision : version::getSwiftRevision();
if (moduleRevision != compilerRevision) {
 result.status = Status::RevisionIncompatible;

// We can't trust this module format at this point.
return result;
 }
 }
break;
 }
case control_block::IS_OSSA: {
auto isModuleInOSSA = scratch[0];
if (requiresOSSAModules && !isModuleInOSSA)
 result.status = Status::NotInOSSA;
break;
 }
default:
// Unknown metadata record, possibly for use by a future version of the
// module format.
break;
 }
 }

// Last resort check in cases where the format is broken enough that
// we didn't read the REVISION block, report such a case as incompatible.
if (requiresRevisionMatch &&
 !revisionSeen &&
 result.status == Status::Valid)
 result.status = Status::RevisionIncompatible;

return result;
}

staticboolvalidateInputBlock(
 llvm::BitstreamCursor &cursor, SmallVectorImpl<uint64_t> &scratch,
 SmallVectorImpl<SerializationOptions::FileDependency> &dependencies) {
 SmallVector<StringRef, 4> dependencyDirectories;
 SmallString<256> dependencyFullPathBuffer;

while (!cursor.AtEndOfStream()) {
 Expected<llvm::BitstreamEntry> maybeEntry = cursor.advance();
if (!maybeEntry) {
// FIXME this drops the error on the floor.
consumeError(maybeEntry.takeError());
returntrue;
 }
 llvm::BitstreamEntry entry = maybeEntry.get();
if (entry.Kind == llvm::BitstreamEntry::EndBlock)
break;

if (entry.Kind == llvm::BitstreamEntry::Error)
returntrue;

 scratch.clear();
 StringRef blobData;
 Expected<unsigned> maybeKind =
 cursor.readRecord(entry.ID, scratch, &blobData);
if (!maybeKind) {
// FIXME this drops the error on the floor.
consumeError(maybeKind.takeError());
returntrue;
 }
unsigned kind = maybeKind.get();
switch (kind) {
case input_block::FILE_DEPENDENCY: {
bool isHashBased = scratch[2] != 0;
bool isSDKRelative = scratch[3] != 0;

 StringRef path = blobData;
size_t directoryIndex = scratch[4];
if (directoryIndex != 0) {
if (directoryIndex > dependencyDirectories.size())
returntrue;
 dependencyFullPathBuffer = dependencyDirectories[directoryIndex-1];
llvm::sys::path::append(dependencyFullPathBuffer, blobData);
 path = dependencyFullPathBuffer;
 }

if (isHashBased) {
 dependencies.push_back(
SerializationOptions::FileDependency::hashBased(
 path, isSDKRelative, scratch[0], scratch[1]));
 } else {
 dependencies.push_back(
SerializationOptions::FileDependency::modTimeBased(
 path, isSDKRelative, scratch[0], scratch[1]));
 }
break;
 }
case input_block::DEPENDENCY_DIRECTORY:
 dependencyDirectories.push_back(blobData);
break;
default:
// Unknown metadata record, possibly for use by a future version of the
// module format.
break;
 }
 }
returnfalse;
}


boolserialization::isSerializedAST(StringRef data) {
 StringRef signatureStr(reinterpret_cast<constchar *>(SWIFTMODULE_SIGNATURE),
llvm::array_lengthof(SWIFTMODULE_SIGNATURE));
return data.startswith(signatureStr);
}

ValidationInfo serialization::validateSerializedAST(
 StringRef data, bool requiresOSSAModules, StringRef requiredSDK,
 ExtendedValidationInfo *extendedInfo,
 SmallVectorImpl<SerializationOptions::FileDependency> *dependencies) {
 ValidationInfo result;

// Check 32-bit alignment.
if (data.size() % SWIFTMODULE_ALIGNMENT != 0 ||
reinterpret_cast<uintptr_t>(data.data()) % SWIFTMODULE_ALIGNMENT != 0)
return result;

 llvm::BitstreamCursor cursor(data);
 SmallVector<uint64_t, 32> scratch;

if (!checkModuleSignature(cursor, SWIFTMODULE_SIGNATURE) ||
 !enterTopLevelModuleBlock(cursor, MODULE_BLOCK_ID, false))
return result;

 llvm::BitstreamEntry topLevelEntry;

while (!cursor.AtEndOfStream()) {
 Expected<llvm::BitstreamEntry> maybeEntry =
 cursor.advance(AF_DontPopBlockAtEnd);
if (!maybeEntry) {
// FIXME this drops the error on the floor.
consumeError(maybeEntry.takeError());
 result.status = Status::Malformed;
return result;
 }
 topLevelEntry = maybeEntry.get();
if (topLevelEntry.Kind != llvm::BitstreamEntry::SubBlock)
break;

if (topLevelEntry.ID == CONTROL_BLOCK_ID) {
if (llvm::Error Err = cursor.EnterSubBlock(CONTROL_BLOCK_ID)) {
// FIXME this drops the error on the floor.
consumeError(std::move(Err));
 result.status = Status::Malformed;
return result;
 }
 PathObfuscator localObfuscator;
 result = validateControlBlock(
 cursor, scratch,
 {SWIFTMODULE_VERSION_MAJOR, SWIFTMODULE_VERSION_MINOR},
 requiresOSSAModules, /*requiresRevisionMatch=*/true,
 requiredSDK,
 extendedInfo, localObfuscator);
if (result.status == Status::Malformed)
return result;
 } elseif (dependencies &&
 result.status == Status::Valid &&
 topLevelEntry.ID == INPUT_BLOCK_ID) {
if (llvm::Error Err = cursor.EnterSubBlock(INPUT_BLOCK_ID)) {
// FIXME this drops the error on the floor.
consumeError(std::move(Err));
 result.status = Status::Malformed;
return result;
 }
if (validateInputBlock(cursor, scratch, *dependencies)) {
 result.status = Status::Malformed;
return result;
 }
 } else {
if (cursor.SkipBlock()) {
 result.status = Status::Malformed;
return result;
 }
 }
 }

if (topLevelEntry.Kind == llvm::BitstreamEntry::EndBlock) {
 cursor.ReadBlockEnd();
assert(cursor.GetCurrentBitNo() % CHAR_BIT == 0);
 result.bytes = cursor.GetCurrentBitNo() / CHAR_BIT;
 } else {
 result.status = Status::Malformed;
 }

return result;
}

std::string ModuleFileSharedCore::Dependency::getPrettyPrintedPath() const {
 StringRef pathWithoutScope = RawPath;
if (isScoped()) {
size_t splitPoint = pathWithoutScope.find_last_of('\0');
 pathWithoutScope = pathWithoutScope.slice(0, splitPoint);
 }
 std::string output = pathWithoutScope.str();
std::replace(output.begin(), output.end(), '\0', '.');
return output;
}

voidModuleFileSharedCore::fatal(llvm::Error error) const {
 llvm::SmallString<0> errorStr;
 llvm::raw_svector_ostream out(errorStr);

 out << "*** DESERIALIZATION FAILURE ***\n";
outputDiagnosticInfo(out);
 out << "\n";
if (error) {
handleAllErrors(std::move(error), [&](const llvm::ErrorInfoBase &ei) {
 ei.log(out);
 out << "\n";
 });
 }

 llvm::PrettyStackTraceString trace(errorStr.c_str());
abort();
}

voidModuleFileSharedCore::outputDiagnosticInfo(llvm::raw_ostream &os) const {
 os << "module '" << Name << "' with full misc version '" << MiscVersion
 << "'";
if (Bits.IsAllowModuleWithCompilerErrorsEnabled)
 os << " (built with -experimental-allow-module-with-compiler-errors)";
}

ModuleFileSharedCore::~ModuleFileSharedCore() { }

std::unique_ptr<ModuleFileSharedCore::SerializedDeclTable>
ModuleFileSharedCore::readDeclTable(ArrayRef<uint64_t> fields,
 StringRef blobData) const {
uint32_t tableOffset;
index_block::DeclListLayout::readRecord(fields, tableOffset);
auto base = reinterpret_cast<constuint8_t *>(blobData.data());

using OwnedTable = std::unique_ptr<SerializedDeclTable>;
returnOwnedTable(SerializedDeclTable::Create(base + tableOffset,
 base + sizeof(uint32_t), base));
}

std::unique_ptr<ModuleFileSharedCore::SerializedExtensionTable>
ModuleFileSharedCore::readExtensionTable(ArrayRef<uint64_t> fields,
 StringRef blobData) const {
uint32_t tableOffset;
index_block::DeclListLayout::readRecord(fields, tableOffset);
auto base = reinterpret_cast<constuint8_t *>(blobData.data());

using OwnedTable = std::unique_ptr<SerializedExtensionTable>;
returnOwnedTable(SerializedExtensionTable::Create(base + tableOffset,
 base + sizeof(uint32_t), base, ExtensionTableInfo(*this)));
}

std::unique_ptr<ModuleFileSharedCore::SerializedLocalDeclTable>
ModuleFileSharedCore::readLocalDeclTable(ArrayRef<uint64_t> fields,
 StringRef blobData) const {
uint32_t tableOffset;
index_block::DeclListLayout::readRecord(fields, tableOffset);
auto base = reinterpret_cast<constuint8_t *>(blobData.data());

using OwnedTable = std::unique_ptr<SerializedLocalDeclTable>;
returnOwnedTable(SerializedLocalDeclTable::Create(base + tableOffset,
 base + sizeof(uint32_t), base));
}

std::unique_ptr<ModuleFileSharedCore::SerializedNestedTypeDeclsTable>
ModuleFileSharedCore::readNestedTypeDeclsTable(ArrayRef<uint64_t> fields,
 StringRef blobData) const {
uint32_t tableOffset;
index_block::NestedTypeDeclsLayout::readRecord(fields, tableOffset);
auto base = reinterpret_cast<constuint8_t *>(blobData.data());

using OwnedTable = std::unique_ptr<SerializedNestedTypeDeclsTable>;
returnOwnedTable(SerializedNestedTypeDeclsTable::Create(base + tableOffset,
 base + sizeof(uint32_t), base));
}

std::unique_ptr<ModuleFileSharedCore::SerializedDeclMemberNamesTable>
ModuleFileSharedCore::readDeclMemberNamesTable(ArrayRef<uint64_t> fields,
 StringRef blobData) const {
uint32_t tableOffset;
index_block::DeclMemberNamesLayout::readRecord(fields, tableOffset);
auto base = reinterpret_cast<constuint8_t *>(blobData.data());

using OwnedTable = std::unique_ptr<SerializedDeclMemberNamesTable>;
returnOwnedTable(SerializedDeclMemberNamesTable::Create(base + tableOffset,
 base + sizeof(uint32_t), base));
}

std::unique_ptr<ModuleFileSharedCore::SerializedDeclMembersTable>
ModuleFileSharedCore::readDeclMembersTable(ArrayRef<uint64_t> fields,
 StringRef blobData) const {
uint32_t tableOffset;
decl_member_tables_block::DeclMembersLayout::readRecord(fields,
 tableOffset);
auto base = reinterpret_cast<constuint8_t *>(blobData.data());

using OwnedTable = std::unique_ptr<SerializedDeclMembersTable>;
returnOwnedTable(SerializedDeclMembersTable::Create(base + tableOffset,
 base + sizeof(uint32_t), base));
}

std::unique_ptr<ModuleFileSharedCore::SerializedDeclFingerprintsTable>
ModuleFileSharedCore::readDeclFingerprintsTable(ArrayRef<uint64_t> fields,
 StringRef blobData) const {
uint32_t tableOffset;
index_block::DeclFingerprintsLayout::readRecord(fields, tableOffset);
auto base = reinterpret_cast<constuint8_t *>(blobData.data());

using OwnedTable = std::unique_ptr<SerializedDeclFingerprintsTable>;
returnOwnedTable(SerializedDeclFingerprintsTable::Create(
 base + tableOffset, base + sizeof(uint32_t), base));
}

std::unique_ptr<ModuleFileSharedCore::SerializedObjCMethodTable>
ModuleFileSharedCore::readObjCMethodTable(ArrayRef<uint64_t> fields,
 StringRef blobData) const {
uint32_t tableOffset;
index_block::ObjCMethodTableLayout::readRecord(fields, tableOffset);
auto base = reinterpret_cast<constuint8_t *>(blobData.data());

using OwnedTable = std::unique_ptr<SerializedObjCMethodTable>;
returnOwnedTable(
SerializedObjCMethodTable::Create(base + tableOffset,
 base + sizeof(uint32_t), base));
}

std::unique_ptr<ModuleFileSharedCore::SerializedDerivativeFunctionConfigTable>
ModuleFileSharedCore::readDerivativeFunctionConfigTable(
 ArrayRef<uint64_t> fields, StringRef blobData) const {
uint32_t tableOffset;
index_block::DerivativeFunctionConfigTableLayout::readRecord(fields,
 tableOffset);
auto base = reinterpret_cast<constuint8_t *>(blobData.data());

using OwnedTable = std::unique_ptr<SerializedDerivativeFunctionConfigTable>;
returnOwnedTable(SerializedDerivativeFunctionConfigTable::Create(
 base + tableOffset, base + sizeof(uint32_t), base));
}

boolModuleFileSharedCore::readIndexBlock(llvm::BitstreamCursor &cursor) {
if (llvm::Error Err = cursor.EnterSubBlock(INDEX_BLOCK_ID)) {
// FIXME this drops the error on the floor.
consumeError(std::move(Err));
returnfalse;
 }

 SmallVector<uint64_t, 4> scratch;
 StringRef blobData;

while (!cursor.AtEndOfStream()) {
 Expected<llvm::BitstreamEntry> maybeEntry = cursor.advance();
if (!maybeEntry) {
// FIXME this drops the error on the floor.
consumeError(maybeEntry.takeError());
returnfalse;
 }
 llvm::BitstreamEntry entry = maybeEntry.get();
switch (entry.Kind) {
case llvm::BitstreamEntry::EndBlock:
returntrue;

case llvm::BitstreamEntry::Error:
returnfalse;

case llvm::BitstreamEntry::SubBlock:
if (entry.ID == DECL_MEMBER_TABLES_BLOCK_ID) {
 DeclMemberTablesCursor = cursor;
if (llvm::Error Err = DeclMemberTablesCursor.EnterSubBlock(
 DECL_MEMBER_TABLES_BLOCK_ID)) {
// FIXME this drops the error on the floor.
consumeError(std::move(Err));
returnfalse;
 }
 llvm::BitstreamEntry subentry;
do {
// Scan forward, to load the cursor with any abbrevs we'll need while
// seeking inside this block later.
 Expected<llvm::BitstreamEntry> maybeEntry =
 DeclMemberTablesCursor.advance(
 llvm::BitstreamCursor::AF_DontPopBlockAtEnd);
if (!maybeEntry) {
// FIXME this drops the error on the floor.
consumeError(maybeEntry.takeError());
returnfalse;
 }
 subentry = maybeEntry.get();
 } while (!DeclMemberTablesCursor.AtEndOfStream() &&
 subentry.Kind != llvm::BitstreamEntry::Record &&
 subentry.Kind != llvm::BitstreamEntry::EndBlock);
 }
if (cursor.SkipBlock())
returnfalse;
break;

case llvm::BitstreamEntry::Record:
 scratch.clear();
 blobData = {};
 Expected<unsigned> maybeKind =
 cursor.readRecord(entry.ID, scratch, &blobData);
if (!maybeKind) {
// FIXME this drops the error on the floor.
consumeError(maybeKind.takeError());
returnfalse;
 }
unsigned kind = maybeKind.get();

switch (kind) {
case index_block::DECL_OFFSETS:
assert(blobData.empty());
allocateBuffer(Decls, scratch);
break;
case index_block::TYPE_OFFSETS:
assert(blobData.empty());
allocateBuffer(Types, scratch);
break;
case index_block::CLANG_TYPE_OFFSETS:
assert(blobData.empty());
allocateBuffer(ClangTypes, scratch);
break;
case index_block::IDENTIFIER_OFFSETS:
assert(blobData.empty());
allocateBuffer(Identifiers, scratch);
break;
case index_block::TOP_LEVEL_DECLS:
 TopLevelDecls = readDeclTable(scratch, blobData);
break;
case index_block::OPERATORS:
 OperatorDecls = readDeclTable(scratch, blobData);
break;
case index_block::PRECEDENCE_GROUPS:
 PrecedenceGroupDecls = readDeclTable(scratch, blobData);
break;
case index_block::EXTENSIONS:
 ExtensionDecls = readExtensionTable(scratch, blobData);
break;
case index_block::CLASS_MEMBERS_FOR_DYNAMIC_LOOKUP:
 ClassMembersForDynamicLookup = readDeclTable(scratch, blobData);
break;
case index_block::OPERATOR_METHODS:
 OperatorMethodDecls = readDeclTable(scratch, blobData);
break;
case index_block::OBJC_METHODS:
 ObjCMethods = readObjCMethodTable(scratch, blobData);
break;
case index_block::DERIVATIVE_FUNCTION_CONFIGURATIONS:
 DerivativeFunctionConfigurations =
readDerivativeFunctionConfigTable(scratch, blobData);
break;
case index_block::ENTRY_POINT:
assert(blobData.empty());
setEntryPointClassID(scratch.front());
break;
case index_block::ORDERED_TOP_LEVEL_DECLS:
allocateBuffer(OrderedTopLevelDecls, scratch);
break;
case index_block::EXPORTED_PRESPECIALIZATION_DECLS:
allocateBuffer(ExportedPrespecializationDecls, scratch);
break;
case index_block::LOCAL_TYPE_DECLS:
 LocalTypeDecls = readLocalDeclTable(scratch, blobData);
break;
case index_block::OPAQUE_RETURN_TYPE_DECLS:
 OpaqueReturnTypeDecls = readLocalDeclTable(scratch, blobData);
break;
case index_block::NESTED_TYPE_DECLS:
 NestedTypeDecls = readNestedTypeDeclsTable(scratch, blobData);
break;
case index_block::DECL_MEMBER_NAMES:
 DeclMemberNames = readDeclMemberNamesTable(scratch, blobData);
break;
case index_block::DECL_FINGERPRINTS:
 DeclFingerprints = readDeclFingerprintsTable(scratch, blobData);
break;
case index_block::LOCAL_DECL_CONTEXT_OFFSETS:
assert(blobData.empty());
allocateBuffer(LocalDeclContexts, scratch);
break;
case index_block::GENERIC_SIGNATURE_OFFSETS:
assert(blobData.empty());
allocateBuffer(GenericSignatures, scratch);
break;
case index_block::GENERIC_ENVIRONMENT_OFFSETS:
assert(blobData.empty());
allocateBuffer(GenericEnvironments, scratch);
break;
case index_block::SUBSTITUTION_MAP_OFFSETS:
assert(blobData.empty());
allocateBuffer(SubstitutionMaps, scratch);
break;
case index_block::PROTOCOL_CONFORMANCE_OFFSETS:
assert(blobData.empty());
allocateBuffer(Conformances, scratch);
break;
case index_block::SIL_LAYOUT_OFFSETS:
assert(blobData.empty());
allocateBuffer(SILLayouts, scratch);
break;

default:
// Unknown index kind, which this version of the compiler won't use.
break;
 }
break;
 }
 }

returnfalse;
}

std::unique_ptr<ModuleFileSharedCore::SerializedDeclCommentTable>
ModuleFileSharedCore::readDeclCommentTable(ArrayRef<uint64_t> fields,
 StringRef blobData) const {
if (fields.empty() || blobData.empty())
returnnullptr;
uint32_t tableOffset = static_cast<uint32_t>(fields.front());
auto base = reinterpret_cast<constuint8_t *>(blobData.data());

return std::unique_ptr<SerializedDeclCommentTable>(
SerializedDeclCommentTable::Create(base + tableOffset,
 base + sizeof(uint32_t), base));
}

std::unique_ptr<ModuleFileSharedCore::GroupNameTable>
ModuleFileSharedCore::readGroupTable(ArrayRef<uint64_t> Fields,
 StringRef BlobData) const {
auto pMap = std::make_unique<llvm::DenseMap<unsigned, StringRef>>();
auto Data = reinterpret_cast<constuint8_t *>(BlobData.data());
unsigned GroupCount = endian::readNext<uint32_t, little, unaligned>(Data);
for (unsigned I = 0; I < GroupCount; ++I) {
auto RawSize = endian::readNext<uint32_t, little, unaligned>(Data);
auto RawText = StringRef(reinterpret_cast<constchar *>(Data), RawSize);
 Data += RawSize;
 (*pMap)[I] = RawText;
 }
return std::unique_ptr<ModuleFileSharedCore::GroupNameTable>(pMap.release());
}

boolModuleFileSharedCore::readCommentBlock(llvm::BitstreamCursor &cursor) {
if (llvm::Error Err = cursor.EnterSubBlock(COMMENT_BLOCK_ID)) {
// FIXME this drops the error on the floor.
consumeError(std::move(Err));
returnfalse;
 }

 SmallVector<uint64_t, 4> scratch;
 StringRef blobData;

while (!cursor.AtEndOfStream()) {
 Expected<llvm::BitstreamEntry> maybeEntry = cursor.advance();
if (!maybeEntry) {
// FIXME this drops the error on the floor.
consumeError(maybeEntry.takeError());
returnfalse;
 }
 llvm::BitstreamEntry entry = maybeEntry.get();
switch (entry.Kind) {
case llvm::BitstreamEntry::EndBlock:
returntrue;

case llvm::BitstreamEntry::Error:
returnfalse;

case llvm::BitstreamEntry::SubBlock:
// Unknown sub-block, which this version of the compiler won't use.
if (cursor.SkipBlock())
returnfalse;
break;

case llvm::BitstreamEntry::Record:
 scratch.clear();
 Expected<unsigned> maybeKind =
 cursor.readRecord(entry.ID, scratch, &blobData);
if (!maybeKind) {
// FIXME this drops the error on the floor.
consumeError(maybeKind.takeError());
returnfalse;
 }
unsigned kind = maybeKind.get();

switch (kind) {
case comment_block::DECL_COMMENTS:
 DeclCommentTable = readDeclCommentTable(scratch, blobData);
break;
case comment_block::GROUP_NAMES:
 GroupNamesMap = readGroupTable(scratch, blobData);
break;
default:
// Unknown index kind, which this version of the compiler won't use.
break;
 }
break;
 }
 }

returnfalse;
}

static Optional<swift::LibraryKind> getActualLibraryKind(unsigned rawKind) {
auto stableKind = static_cast<serialization::LibraryKind>(rawKind);
if (stableKind != rawKind)
return None;

switch (stableKind) {
case serialization::LibraryKind::Library:
return swift::LibraryKind::Library;
case serialization::LibraryKind::Framework:
return swift::LibraryKind::Framework;
 }

// If there's a new case value in the module file, ignore it.
return None;
}

static Optional<ModuleDecl::ImportFilterKind>
getActualImportControl(unsigned rawValue) {
// We switch on the raw value rather than the enum in order to handle future
// values.
switch (rawValue) {
casestatic_cast<unsigned>(serialization::ImportControl::Normal):
return ModuleDecl::ImportFilterKind::Default;
casestatic_cast<unsigned>(serialization::ImportControl::Exported):
return ModuleDecl::ImportFilterKind::Exported;
casestatic_cast<unsigned>(serialization::ImportControl::ImplementationOnly):
return ModuleDecl::ImportFilterKind::ImplementationOnly;
default:
return None;
 }
}

boolModuleFileSharedCore::readModuleDocIfPresent(PathObfuscator &pathRecoverer) {
if (!this->ModuleDocInputBuffer)
returntrue;

 llvm::BitstreamCursor docCursor{ModuleDocInputBuffer->getMemBufferRef()};
if (!checkModuleSignature(docCursor, SWIFTDOC_SIGNATURE) ||
 !enterTopLevelModuleBlock(docCursor, MODULE_DOC_BLOCK_ID)) {
returnfalse;
 }

 SmallVector<uint64_t, 64> scratch;