File Manager

003 File Manager

Current Path: /usr/src/contrib/llvm-project/clang/lib/Frontend

usr / src / contrib / llvm-project / clang / lib / Frontend /

📁 ..
📄 ASTConsumers.cpp(6.91 KB)
📄 ASTMerge.cpp(4.21 KB)
📄 ASTUnit.cpp(96.12 KB)
📄 ChainedDiagnosticConsumer.cpp(494 B)
📄 ChainedIncludesSource.cpp(8.64 KB)
📄 CompilerInstance.cpp(85 KB)
📄 CompilerInvocation.cpp(163.55 KB)
📄 CreateInvocationFromCommandLine.cpp(3.72 KB)
📄 DependencyFile.cpp(14.18 KB)
📄 DependencyGraph.cpp(4.29 KB)
📄 DiagnosticRenderer.cpp(23.59 KB)
📄 FrontendAction.cpp(41.79 KB)
📄 FrontendActions.cpp(35.13 KB)
📄 FrontendOptions.cpp(1.54 KB)
📄 FrontendTiming.cpp(610 B)
📄 HeaderIncludeGen.cpp(6.52 KB)
📄 InitHeaderSearch.cpp(24.31 KB)
📄 InitPreprocessor.cpp(51.21 KB)
📄 InterfaceStubFunctionsConsumer.cpp(12.33 KB)
📄 LayoutOverrideSource.cpp(6.13 KB)
📄 LogDiagnosticPrinter.cpp(5.15 KB)
📄 ModuleDependencyCollector.cpp(9.11 KB)
📄 MultiplexConsumer.cpp(14.03 KB)
📄 PrecompiledPreamble.cpp(31.65 KB)
📄 PrintPreprocessedOutput.cpp(32.34 KB)
📁 Rewrite
📄 SerializedDiagnosticPrinter.cpp(31.77 KB)
📄 SerializedDiagnosticReader.cpp(11.53 KB)
📄 TestModuleFileExtension.cpp(4.38 KB)
📄 TestModuleFileExtension.h(2.34 KB)
📄 TextDiagnostic.cpp(48.96 KB)
📄 TextDiagnosticBuffer.cpp(2.59 KB)
📄 TextDiagnosticPrinter.cpp(6.09 KB)
📄 VerifyDiagnosticConsumer.cpp(39.3 KB)

Editing: TestModuleFileExtension.cpp

//===-- 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;

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 };
}

llvm::hash_code TestModuleFileExtension::hashExtension(
                  llvm::hash_code Code) const {
  if (Hashed) {
    Code = llvm::hash_combine(Code, BlockName);
    Code = llvm::hash_combine(Code, MajorVersion);
    Code = llvm::hash_combine(Code, MinorVersion);
    Code = llvm::hash_combine(Code, UserInfo);
  }

return Code;
}

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));
}

003 File Manager

Editing: TestModuleFileExtension.cpp

Upload File

Create Folder