| //===-- TestModuleFileExtension.cpp - Module Extension Tester -------------===// | |
| // | |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. | |
| // See https://llvm.org/LICENSE.txt for license information. | |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception | |
| // | |
| //===----------------------------------------------------------------------===// | |
| #include "TestModuleFileExtension.h" | |
| #include "clang/Basic/DiagnosticFrontend.h" | |
| #include "clang/Serialization/ASTReader.h" | |
| #include "llvm/Bitstream/BitstreamWriter.h" | |
| #include "llvm/Support/raw_ostream.h" | |
| #include <cstdio> | |
| using namespace clang; | |
| using namespace clang::serialization; | |
| char TestModuleFileExtension::ID = 0; | |
| TestModuleFileExtension::Writer::~Writer() { } | |
| void TestModuleFileExtension::Writer::writeExtensionContents( | |
| Sema &SemaRef, | |
| llvm::BitstreamWriter &Stream) { | |
| using namespace llvm; | |
| // Write an abbreviation for this record. | |
| auto Abv = std::make_shared<llvm::BitCodeAbbrev>(); | |
| Abv->Add(BitCodeAbbrevOp(FIRST_EXTENSION_RECORD_ID)); | |
| Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // # of characters | |
| Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // message | |
| auto Abbrev = Stream.EmitAbbrev(std::move(Abv)); | |
| // Write a message into the extension block. | |
| SmallString<64> Message; | |
| { | |
| auto Ext = static_cast<TestModuleFileExtension *>(getExtension()); | |
| raw_svector_ostream OS(Message); | |
| OS << "Hello from " << Ext->BlockName << " v" << Ext->MajorVersion << "." | |
| << Ext->MinorVersion; | |
| } | |
| uint64_t Record[] = {FIRST_EXTENSION_RECORD_ID, Message.size()}; | |
| Stream.EmitRecordWithBlob(Abbrev, Record, Message); | |
| } | |
| TestModuleFileExtension::Reader::Reader(ModuleFileExtension *Ext, | |
| const llvm::BitstreamCursor &InStream) | |
| : ModuleFileExtensionReader(Ext), Stream(InStream) | |
| { | |
| // Read the extension block. | |
| SmallVector<uint64_t, 4> Record; | |
| while (true) { | |
| llvm::Expected<llvm::BitstreamEntry> MaybeEntry = | |
| Stream.advanceSkippingSubblocks(); | |
| if (!MaybeEntry) | |
| (void)MaybeEntry.takeError(); | |
| llvm::BitstreamEntry Entry = MaybeEntry.get(); | |
| switch (Entry.Kind) { | |
| case llvm::BitstreamEntry::SubBlock: | |
| case llvm::BitstreamEntry::EndBlock: | |
| case llvm::BitstreamEntry::Error: | |
| return; | |
| case llvm::BitstreamEntry::Record: | |
| break; | |
| } | |
| Record.clear(); | |
| StringRef Blob; | |
| Expected<unsigned> MaybeRecCode = | |
| Stream.readRecord(Entry.ID, Record, &Blob); | |
| if (!MaybeRecCode) | |
| fprintf(stderr, "Failed reading rec code: %s\n", | |
| toString(MaybeRecCode.takeError()).c_str()); | |
| switch (MaybeRecCode.get()) { | |
| case FIRST_EXTENSION_RECORD_ID: { | |
| StringRef Message = Blob.substr(0, Record[0]); | |
| fprintf(stderr, "Read extension block message: %s\n", | |
| Message.str().c_str()); | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| TestModuleFileExtension::Reader::~Reader() { } | |
| TestModuleFileExtension::~TestModuleFileExtension() { } | |
| ModuleFileExtensionMetadata | |
| TestModuleFileExtension::getExtensionMetadata() const { | |
| return { BlockName, MajorVersion, MinorVersion, UserInfo }; | |
| } | |
| void TestModuleFileExtension::hashExtension( | |
| ExtensionHashBuilder &HBuilder) const { | |
| if (Hashed) { | |
| HBuilder.add(BlockName); | |
| HBuilder.add(MajorVersion); | |
| HBuilder.add(MinorVersion); | |
| HBuilder.add(UserInfo); | |
| } | |
| } | |
| std::unique_ptr<ModuleFileExtensionWriter> | |
| TestModuleFileExtension::createExtensionWriter(ASTWriter &) { | |
| return std::unique_ptr<ModuleFileExtensionWriter>(new Writer(this)); | |
| } | |
| std::unique_ptr<ModuleFileExtensionReader> | |
| TestModuleFileExtension::createExtensionReader( | |
| const ModuleFileExtensionMetadata &Metadata, | |
| ASTReader &Reader, serialization::ModuleFile &Mod, | |
| const llvm::BitstreamCursor &Stream) | |
| { | |
| assert(Metadata.BlockName == BlockName && "Wrong block name"); | |
| if (std::make_pair(Metadata.MajorVersion, Metadata.MinorVersion) != | |
| std::make_pair(MajorVersion, MinorVersion)) { | |
| Reader.getDiags().Report(Mod.ImportLoc, | |
| diag::err_test_module_file_extension_version) | |
| << BlockName << Metadata.MajorVersion << Metadata.MinorVersion | |
| << MajorVersion << MinorVersion; | |
| return nullptr; | |
| } | |
| return std::unique_ptr<ModuleFileExtensionReader>( | |
| new TestModuleFileExtension::Reader(this, Stream)); | |
| } | |
| std::string TestModuleFileExtension::str() const { | |
| std::string Buffer; | |
| llvm::raw_string_ostream OS(Buffer); | |
| OS << BlockName << ":" << MajorVersion << ":" << MinorVersion << ":" << Hashed | |
| << ":" << UserInfo; | |
| return Buffer; | |
| } |