PTHManager.h revision 681c74afe6a81161aa13291c6c114e5240b23865 
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/Lex/PTHLexer.h"
18#include "clang/Basic/LangOptions.h"
19#include "clang/Basic/IdentifierTable.h"
20#include "clang/Basic/Diagnostic.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 Diagnostic;
34class StatSysCallCache;
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  // Do not implement.
85  PTHManager();
86  void operator=(const PTHManager&);
87
88  /// getSpellingAtPTHOffset - Used by PTHLexer classes to get the cached
89  ///  spelling for a token.
90  unsigned getSpellingAtPTHOffset(unsigned PTHOffset, const char*& Buffer);
91
92  /// GetIdentifierInfo - Used to reconstruct IdentifierInfo objects from the
93  ///  PTH file.
94  inline IdentifierInfo* GetIdentifierInfo(unsigned PersistentID) {
95    // Check if the IdentifierInfo has already been resolved.
96    if (IdentifierInfo* II = PerIDCache[PersistentID])
97      return II;
98    return LazilyCreateIdentifierInfo(PersistentID);
99  }
100  IdentifierInfo* LazilyCreateIdentifierInfo(unsigned PersistentID);
101
102public:
103  // The current PTH version.
104  enum { Version = 9 };
105
106  ~PTHManager();
107
108  /// getOriginalSourceFile - Return the full path to the original header
109  ///  file name that was used to generate the PTH cache.
110  const char* getOriginalSourceFile() const {
111    return OriginalSourceFile;
112  }
113
114  /// get - Return the identifier token info for the specified named identifier.
115  ///  Unlike the version in IdentifierTable, this returns a pointer instead
116  ///  of a reference.  If the pointer is NULL then the IdentifierInfo cannot
117  ///  be found.
118  IdentifierInfo *get(llvm::StringRef Name);
119
120  /// Create - This method creates PTHManager objects.  The 'file' argument
121  ///  is the name of the PTH file.  This method returns NULL upon failure.
122  static PTHManager *Create(const std::string& file, Diagnostic &Diags);
123
124  void setPreprocessor(Preprocessor *pp) { PP = pp; }
125
126  /// CreateLexer - Return a PTHLexer that "lexes" the cached tokens for the
127  ///  specified file.  This method returns NULL if no cached tokens exist.
128  ///  It is the responsibility of the caller to 'delete' the returned object.
129  PTHLexer *CreateLexer(FileID FID);
130
131  /// createStatCache - Returns a StatSysCallCache object for use with
132  ///  FileManager objects.  These objects use the PTH data to speed up
133  ///  calls to stat by memoizing their results from when the PTH file
134  ///  was generated.
135  StatSysCallCache *createStatCache();
136};
137
138}  // end namespace clang
139
140#endif
141