contrib/llvm/tools/clang/include/clang/Frontend/PCHContainerOperations.h

   1 //===--- Frontend/PCHContainerOperations.h - PCH Containers -----*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #ifndef LLVM_CLANG_PCH_CONTAINER_OPERATIONS_H
  11 #define LLVM_CLANG_PCH_CONTAINER_OPERATIONS_H
  12
  13 #include "llvm/ADT/SmallVector.h"
  14 #include "llvm/ADT/StringMap.h"
  15 #include "llvm/Support/MemoryBuffer.h"
  16 #include <memory>
  17
  18 namespace llvm {
  19 class raw_pwrite_stream;
  20 class BitstreamReader;
  21 }
  22
  23 using llvm::StringRef;
  24
  25 namespace clang {
  26
  27 class ASTConsumer;
  28 class CodeGenOptions;
  29 class DiagnosticsEngine;
  30 class HeaderSearchOptions;
  31 class LangOptions;
  32 class PreprocessorOptions;
  33 class TargetOptions;
  34
  35 struct PCHBuffer {
  36   bool IsComplete;
  37   llvm::SmallVector<char, 0> Data;
  38 };
  39
  40 /// This abstract interface provides operations for creating
  41 /// containers for serialized ASTs (precompiled headers and clang
  42 /// modules).
  43 class PCHContainerWriter {
  44 public:
  45   virtual ~PCHContainerWriter() = 0;
  46   virtual StringRef getFormat() const = 0;
  47
  48   /// Return an ASTConsumer that can be chained with a
  49   /// PCHGenerator that produces a wrapper file format containing a
  50   /// serialized AST bitstream.
  51   virtual std::unique_ptr<ASTConsumer> CreatePCHContainerGenerator(
  52       DiagnosticsEngine &Diags, const HeaderSearchOptions &HSO,
  53       const PreprocessorOptions &PPO, const TargetOptions &TO,
  54       const LangOptions &LO, const std::string &MainFileName,
  55       const std::string &OutputFileName, llvm::raw_pwrite_stream *OS,
  56       std::shared_ptr<PCHBuffer> Buffer) const = 0;
  57 };
  58
  59 /// This abstract interface provides operations for unwrapping
  60 /// containers for serialized ASTs (precompiled headers and clang
  61 /// modules).
  62 class PCHContainerReader {
  63 public:
  64   virtual ~PCHContainerReader() = 0;
  65   /// Equivalent to the format passed to -fmodule-format=
  66   virtual StringRef getFormat() const = 0;
  67
  68   /// Initialize an llvm::BitstreamReader with the serialized AST inside
  69   /// the PCH container Buffer.
  70   virtual void ExtractPCH(llvm::MemoryBufferRef Buffer,
  71                           llvm::BitstreamReader &StreamFile) const = 0;
  72 };
  73
  74 /// Implements write operations for a raw pass-through PCH container.
  75 class RawPCHContainerWriter : public PCHContainerWriter {
  76   StringRef getFormat() const override { return "raw"; }
  77
  78   /// Return an ASTConsumer that can be chained with a
  79   /// PCHGenerator that writes the module to a flat file.
  80   std::unique_ptr<ASTConsumer> CreatePCHContainerGenerator(
  81       DiagnosticsEngine &Diags, const HeaderSearchOptions &HSO,
  82       const PreprocessorOptions &PPO, const TargetOptions &TO,
  83       const LangOptions &LO, const std::string &MainFileName,
  84       const std::string &OutputFileName, llvm::raw_pwrite_stream *OS,
  85       std::shared_ptr<PCHBuffer> Buffer) const override;
  86 };
  87
  88 /// Implements read operations for a raw pass-through PCH container.
  89 class RawPCHContainerReader : public PCHContainerReader {
  90   StringRef getFormat() const override { return "raw"; }
  91
  92   /// Initialize an llvm::BitstreamReader with Buffer.
  93   void ExtractPCH(llvm::MemoryBufferRef Buffer,
  94                   llvm::BitstreamReader &StreamFile) const override;
  95 };
  96
  97 /// A registry of PCHContainerWriter and -Reader objects for different formats.
  98 class PCHContainerOperations {
  99   llvm::StringMap<std::unique_ptr<PCHContainerWriter>> Writers;
 100   llvm::StringMap<std::unique_ptr<PCHContainerReader>> Readers;
 101 public:
 102   /// Automatically registers a RawPCHContainerWriter and
 103   /// RawPCHContainerReader.
 104   PCHContainerOperations();
 105   void registerWriter(std::unique_ptr<PCHContainerWriter> Writer) {
 106     Writers[Writer->getFormat()] = std::move(Writer);
 107   }
 108   void registerReader(std::unique_ptr<PCHContainerReader> Reader) {
 109     Readers[Reader->getFormat()] = std::move(Reader);
 110   }
 111   const PCHContainerWriter *getWriterOrNull(StringRef Format) {
 112     return Writers[Format].get();
 113   }
 114   const PCHContainerReader *getReaderOrNull(StringRef Format) {
 115     return Readers[Format].get();
 116   }
 117   const PCHContainerReader &getRawReader() {
 118     return *getReaderOrNull("raw");
 119   }
 120 };
 121
 122 }
 123
 124 #endif