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