clang  3.7.0
PTHManager.h
Go to the documentation of this file.
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/Diagnostic.h"
20 #include "clang/Lex/PTHLexer.h"
21 #include "llvm/ADT/DenseMap.h"
22 #include "llvm/ADT/STLExtras.h"
23 #include "llvm/Support/Allocator.h"
24 #include "llvm/Support/OnDiskHashTable.h"
25 #include <string>
26 
27 namespace llvm {
28  class MemoryBuffer;
29 }
30 
31 namespace clang {
32 
33 class FileEntry;
34 class PTHLexer;
35 class DiagnosticsEngine;
36 class FileSystemStatCache;
37 
39  friend class PTHLexer;
40 
41  friend class PTHStatCache;
42 
44  class 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;
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  PTHManager(const PTHManager &) = delete;
96  void operator=(const PTHManager &) = delete;
97 
98  /// getSpellingAtPTHOffset - Used by PTHLexer classes to get the cached
99  /// spelling for a token.
100  unsigned getSpellingAtPTHOffset(unsigned PTHOffset, const char*& Buffer);
101 
102  /// GetIdentifierInfo - Used to reconstruct IdentifierInfo objects from the
103  /// PTH file.
104  inline IdentifierInfo* GetIdentifierInfo(unsigned PersistentID) {
105  // Check if the IdentifierInfo has already been resolved.
106  if (IdentifierInfo* II = PerIDCache[PersistentID])
107  return II;
108  return LazilyCreateIdentifierInfo(PersistentID);
109  }
110  IdentifierInfo* LazilyCreateIdentifierInfo(unsigned PersistentID);
111 
112 public:
113  // The current PTH version.
114  enum { Version = 10 };
115 
116  ~PTHManager() override;
117 
118  /// getOriginalSourceFile - Return the full path to the original header
119  /// file name that was used to generate the PTH cache.
120  const char* getOriginalSourceFile() const {
121  return OriginalSourceFile;
122  }
123 
124  /// get - Return the identifier token info for the specified named identifier.
125  /// Unlike the version in IdentifierTable, this returns a pointer instead
126  /// of a reference. If the pointer is NULL then the IdentifierInfo cannot
127  /// be found.
128  IdentifierInfo *get(StringRef Name) override;
129 
130  /// Create - This method creates PTHManager objects. The 'file' argument
131  /// is the name of the PTH file. This method returns NULL upon failure.
132  static PTHManager *Create(StringRef file, DiagnosticsEngine &Diags);
133 
134  void setPreprocessor(Preprocessor *pp) { PP = pp; }
135 
136  /// CreateLexer - Return a PTHLexer that "lexes" the cached tokens for the
137  /// specified file. This method returns NULL if no cached tokens exist.
138  /// It is the responsibility of the caller to 'delete' the returned object.
140 
141  /// createStatCache - Returns a FileSystemStatCache object for use with
142  /// FileManager objects. These objects use the PTH data to speed up
143  /// calls to stat by memoizing their results from when the PTH file
144  /// was generated.
145  std::unique_ptr<FileSystemStatCache> createStatCache();
146 };
147 
148 } // end namespace clang
149 
150 #endif
PTHLexer * CreateLexer(FileID FID)
Definition: PTHLexer.cpp:595
static PTHManager * Create(StringRef file, DiagnosticsEngine &Diags)
Definition: PTHLexer.cpp:434
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:135
std::unique_ptr< FileSystemStatCache > createStatCache()
Definition: PTHLexer.cpp:726
const char * getOriginalSourceFile() const
Definition: PTHManager.h:120
Provides lookups to, and iteration over, IdentiferInfo objects.
Defines the clang::LangOptions interface.
Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.
void setPreprocessor(Preprocessor *pp)
Definition: PTHManager.h:134
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
~PTHManager() override
Definition: PTHLexer.cpp:427
Defines the Diagnostic-related interfaces.
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:96