| //===-- 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/Frontend/FrontendDiagnostic.h" |
| #include "clang/Serialization/ASTReader.h" |
| #include "llvm/ADT/Hashing.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 OS.str(); |
| } |