contrib/llvm/tools/clang/include/clang/Lex/PTHManager.h

   1 //===- PTHManager.h - Manager object for PTH processing ---------*- 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 //  This file defines the PTHManager interface.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef LLVM_CLANG_LEX_PTHMANAGER_H
  15 #define LLVM_CLANG_LEX_PTHMANAGER_H
  16
  17 #include "clang/Basic/IdentifierTable.h"
  18 #include "clang/Basic/SourceLocation.h"
  19 #include "llvm/ADT/STLExtras.h"
  20 #include "llvm/ADT/StringRef.h"
  21 #include "llvm/Support/Allocator.h"
  22 #include "llvm/Support/OnDiskHashTable.h"
  23 #include <memory>
  24
  25 namespace llvm {
  26
  27 class MemoryBuffer;
  28
  29 } // namespace llvm
  30
  31 namespace clang {
  32
  33 class DiagnosticsEngine;
  34 class FileSystemStatCache;
  35 class Preprocessor;
  36 class PTHLexer;
  37
  38 class PTHManager : public IdentifierInfoLookup {
  39   friend class PTHLexer;
  40   friend class PTHStatCache;
  41
  42   class PTHFileLookupTrait;
  43   class PTHStringLookupTrait;
  44
  45   using PTHStringIdLookup = llvm::OnDiskChainedHashTable<PTHStringLookupTrait>;
  46   using PTHFileLookup = llvm::OnDiskChainedHashTable<PTHFileLookupTrait>;
  47
  48   /// The memory mapped PTH file.
  49   std::unique_ptr<const llvm::MemoryBuffer> Buf;
  50
  51   /// Alloc - Allocator used for IdentifierInfo objects.
  52   llvm::BumpPtrAllocator Alloc;
  53
  54   /// IdMap - A lazily generated cache mapping from persistent identifiers to
  55   ///  IdentifierInfo*.
  56   std::unique_ptr<IdentifierInfo *[], llvm::FreeDeleter> PerIDCache;
  57
  58   /// FileLookup - Abstract data structure used for mapping between files
  59   ///  and token data in the PTH file.
  60   std::unique_ptr<PTHFileLookup> FileLookup;
  61
  62   /// IdDataTable - Array representing the mapping from persistent IDs to the
  63   ///  data offset within the PTH file containing the information to
  64   ///  reconsitute an IdentifierInfo.
  65   const unsigned char* const IdDataTable;
  66
  67   /// SortedIdTable - Abstract data structure mapping from strings to
  68   ///  persistent IDs.  This is used by get().
  69   std::unique_ptr<PTHStringIdLookup> StringIdLookup;
  70
  71   /// NumIds - The number of identifiers in the PTH file.
  72   const unsigned NumIds;
  73
  74   /// PP - The Preprocessor object that will use this PTHManager to create
  75   ///  PTHLexer objects.
  76   Preprocessor* PP = nullptr;
  77
  78   /// SpellingBase - The base offset within the PTH memory buffer that
  79   ///  contains the cached spellings for literals.
  80   const unsigned char* const SpellingBase;
  81
  82   /// OriginalSourceFile - A null-terminated C-string that specifies the name
  83   ///  if the file (if any) that was to used to generate the PTH cache.
  84   const char* OriginalSourceFile;
  85
  86   /// This constructor is intended to only be called by the static 'Create'
  87   /// method.
  88   PTHManager(std::unique_ptr<const llvm::MemoryBuffer> buf,
  89              std::unique_ptr<PTHFileLookup> fileLookup,
  90              const unsigned char *idDataTable,
  91              std::unique_ptr<IdentifierInfo *[], llvm::FreeDeleter> perIDCache,
  92              std::unique_ptr<PTHStringIdLookup> stringIdLookup, unsigned numIds,
  93              const unsigned char *spellingBase, const char *originalSourceFile);
  94
  95   /// getSpellingAtPTHOffset - Used by PTHLexer classes to get the cached
  96   ///  spelling for a token.
  97   unsigned getSpellingAtPTHOffset(unsigned PTHOffset, const char*& Buffer);
  98
  99   /// GetIdentifierInfo - Used to reconstruct IdentifierInfo objects from the
 100   ///  PTH file.
 101   IdentifierInfo *GetIdentifierInfo(unsigned PersistentID) {
 102     // Check if the IdentifierInfo has already been resolved.
 103     if (IdentifierInfo* II = PerIDCache[PersistentID])
 104       return II;
 105     return LazilyCreateIdentifierInfo(PersistentID);
 106   }
 107   IdentifierInfo* LazilyCreateIdentifierInfo(unsigned PersistentID);
 108
 109 public:
 110   // The current PTH version.
 111   enum { Version = 10 };
 112
 113   PTHManager(const PTHManager &) = delete;
 114   PTHManager &operator=(const PTHManager &) = delete;
 115   ~PTHManager() override;
 116
 117   /// getOriginalSourceFile - Return the full path to the original header
 118   ///  file name that was used to generate the PTH cache.
 119   const char* getOriginalSourceFile() const {
 120     return OriginalSourceFile;
 121   }
 122
 123   /// get - Return the identifier token info for the specified named identifier.
 124   ///  Unlike the version in IdentifierTable, this returns a pointer instead
 125   ///  of a reference.  If the pointer is nullptr then the IdentifierInfo cannot
 126   ///  be found.
 127   IdentifierInfo *get(StringRef Name) override;
 128
 129   /// Create - This method creates PTHManager objects.  The 'file' argument
 130   ///  is the name of the PTH file.  This method returns nullptr upon failure.
 131   static PTHManager *Create(StringRef file, DiagnosticsEngine &Diags);
 132
 133   void setPreprocessor(Preprocessor *pp) { PP = pp; }
 134
 135   /// CreateLexer - Return a PTHLexer that "lexes" the cached tokens for the
 136   ///  specified file.  This method returns nullptr if no cached tokens exist.
 137   ///  It is the responsibility of the caller to 'delete' the returned object.
 138   PTHLexer *CreateLexer(FileID FID);
 139
 140   /// createStatCache - Returns a FileSystemStatCache object for use with
 141   ///  FileManager objects.  These objects use the PTH data to speed up
 142   ///  calls to stat by memoizing their results from when the PTH file
 143   ///  was generated.
 144   std::unique_ptr<FileSystemStatCache> createStatCache();
 145 };
 146
 147 } // namespace clang
 148
 149 #endif // LLVM_CLANG_LEX_PTHMANAGER_H