blob: 9a4874d9da428554a72258860178632d22dc3a85 [file] [log] [blame]
Sebastian Redl904c9c82010-08-18 23:57:11 +00001//===--- ASTReader.cpp - AST File Reader ------------------------*- C++ -*-===//
Douglas Gregor2cf26342009-04-09 22:27:44 +00002//
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//
Sebastian Redlc43b54c2010-08-18 23:56:43 +000010// This file defines the ASTReader class, which reads AST files.
Douglas Gregor2cf26342009-04-09 22:27:44 +000011//
12//===----------------------------------------------------------------------===//
Chris Lattner4c6f9522009-04-27 05:14:47 +000013
Sebastian Redl6ab7cd82010-08-18 23:57:17 +000014#include "clang/Serialization/ASTReader.h"
15#include "clang/Serialization/ASTDeserializationListener.h"
Douglas Gregor98339b92011-08-25 20:47:51 +000016#include "clang/Serialization/ModuleManager.h"
Chandler Carrutha2398d72011-12-09 00:02:23 +000017#include "clang/Serialization/SerializationDiagnostic.h"
Argyrios Kyrtzidis0eca89e2010-08-20 16:03:52 +000018#include "ASTCommon.h"
Douglas Gregor98339b92011-08-25 20:47:51 +000019#include "ASTReaderInternals.h"
Douglas Gregore737f502010-08-12 20:07:10 +000020#include "clang/Sema/Sema.h"
John McCall5f1e0942010-08-24 08:50:51 +000021#include "clang/Sema/Scope.h"
Douglas Gregorfdd01722009-04-14 00:24:19 +000022#include "clang/AST/ASTConsumer.h"
Douglas Gregor2cf26342009-04-09 22:27:44 +000023#include "clang/AST/ASTContext.h"
John McCall2a7fb272010-08-25 05:32:35 +000024#include "clang/AST/DeclTemplate.h"
Douglas Gregor0b748912009-04-14 21:18:50 +000025#include "clang/AST/Expr.h"
John McCall7a1fad32010-08-24 07:32:53 +000026#include "clang/AST/ExprCXX.h"
Douglas Gregor5f791bb2011-02-28 23:58:31 +000027#include "clang/AST/NestedNameSpecifier.h"
Douglas Gregor2cf26342009-04-09 22:27:44 +000028#include "clang/AST/Type.h"
John McCalla1ee0c52009-10-16 21:56:05 +000029#include "clang/AST/TypeLocVisitor.h"
Chris Lattner42d42b52009-04-10 21:41:48 +000030#include "clang/Lex/MacroInfo.h"
Douglas Gregor6a5a23f2010-03-19 21:51:54 +000031#include "clang/Lex/PreprocessingRecord.h"
Douglas Gregor14f79002009-04-10 03:52:48 +000032#include "clang/Lex/Preprocessor.h"
Steve Naroff83d63c72009-04-24 20:03:17 +000033#include "clang/Lex/HeaderSearch.h"
Douglas Gregor668c1a42009-04-21 22:25:48 +000034#include "clang/Basic/OnDiskHashTable.h"
Douglas Gregor14f79002009-04-10 03:52:48 +000035#include "clang/Basic/SourceManager.h"
Douglas Gregorbd945002009-04-13 16:31:14 +000036#include "clang/Basic/SourceManagerInternals.h"
Douglas Gregor14f79002009-04-10 03:52:48 +000037#include "clang/Basic/FileManager.h"
Chris Lattner10e286a2010-11-23 19:19:34 +000038#include "clang/Basic/FileSystemStatCache.h"
Douglas Gregor2bec0412009-04-10 21:16:55 +000039#include "clang/Basic/TargetInfo.h"
Douglas Gregor57016dd2012-10-16 23:40:58 +000040#include "clang/Basic/TargetOptions.h"
Douglas Gregor445e23e2009-10-05 21:07:28 +000041#include "clang/Basic/Version.h"
Douglas Gregor0a0d2b12011-03-23 00:50:03 +000042#include "clang/Basic/VersionTuple.h"
Daniel Dunbar2596e422009-10-17 23:52:28 +000043#include "llvm/ADT/StringExtras.h"
Douglas Gregor2cf26342009-04-09 22:27:44 +000044#include "llvm/Bitcode/BitstreamReader.h"
Douglas Gregor2cf26342009-04-09 22:27:44 +000045#include "llvm/Support/MemoryBuffer.h"
John McCall833ca992009-10-29 08:12:44 +000046#include "llvm/Support/ErrorHandling.h"
Douglas Gregorcfbf1c72011-02-10 17:09:37 +000047#include "llvm/Support/FileSystem.h"
Michael J. Spencer03013fa2010-11-29 18:12:39 +000048#include "llvm/Support/Path.h"
Nick Lewyckyb346d2f2012-04-16 02:51:46 +000049#include "llvm/Support/SaveAndRestore.h"
Michael J. Spencer3a321e22010-12-09 17:36:38 +000050#include "llvm/Support/system_error.h"
Douglas Gregor2cf26342009-04-09 22:27:44 +000051#include <algorithm>
Douglas Gregore721f952009-04-28 18:58:38 +000052#include <iterator>
Douglas Gregor2cf26342009-04-09 22:27:44 +000053#include <cstdio>
Douglas Gregor4fed3f42009-04-27 18:38:38 +000054#include <sys/stat.h>
Douglas Gregorcfbf1c72011-02-10 17:09:37 +000055
Douglas Gregor2cf26342009-04-09 22:27:44 +000056using namespace clang;
Sebastian Redl8538e8d2010-08-18 23:57:32 +000057using namespace clang::serialization;
Douglas Gregor98339b92011-08-25 20:47:51 +000058using namespace clang::serialization::reader;
Douglas Gregor2cf26342009-04-09 22:27:44 +000059
60//===----------------------------------------------------------------------===//
Sebastian Redl3c7f4132010-08-18 23:57:06 +000061// PCH validator implementation
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +000062//===----------------------------------------------------------------------===//
63
Sebastian Redl571db7f2010-08-18 23:56:56 +000064ASTReaderListener::~ASTReaderListener() {}
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +000065
Douglas Gregor27ffa6c2012-10-23 06:18:24 +000066/// \brief Compare the given set of language options against an existing set of
67/// language options.
68///
69/// \param Diags If non-NULL, diagnostics will be emitted via this engine.
70///
71/// \returns true if the languagae options mis-match, false otherwise.
72static bool checkLanguageOptions(const LangOptions &LangOpts,
73 const LangOptions &ExistingLangOpts,
74 DiagnosticsEngine *Diags) {
75#define LANGOPT(Name, Bits, Default, Description) \
76 if (ExistingLangOpts.Name != LangOpts.Name) { \
77 if (Diags) \
78 Diags->Report(diag::err_pch_langopt_mismatch) \
79 << Description << LangOpts.Name << ExistingLangOpts.Name; \
80 return true; \
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +000081 }
82
Douglas Gregor27ffa6c2012-10-23 06:18:24 +000083#define VALUE_LANGOPT(Name, Bits, Default, Description) \
84 if (ExistingLangOpts.Name != LangOpts.Name) { \
85 if (Diags) \
86 Diags->Report(diag::err_pch_langopt_value_mismatch) \
87 << Description; \
88 return true; \
Douglas Gregor38295be2012-10-22 23:51:00 +000089 }
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +000090
Douglas Gregor27ffa6c2012-10-23 06:18:24 +000091#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
92 if (ExistingLangOpts.get##Name() != LangOpts.get##Name()) { \
93 if (Diags) \
94 Diags->Report(diag::err_pch_langopt_value_mismatch) \
95 << Description; \
96 return true; \
Douglas Gregor7d5e81b2011-09-13 18:26:39 +000097 }
98
99#define BENIGN_LANGOPT(Name, Bits, Default, Description)
100#define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
101#include "clang/Basic/LangOptions.def"
John McCall260611a2012-06-20 06:18:46 +0000102
Douglas Gregor27ffa6c2012-10-23 06:18:24 +0000103 if (ExistingLangOpts.ObjCRuntime != LangOpts.ObjCRuntime) {
104 if (Diags)
105 Diags->Report(diag::err_pch_langopt_value_mismatch)
106 << "target Objective-C runtime";
John McCall260611a2012-06-20 06:18:46 +0000107 return true;
108 }
Douglas Gregor27ffa6c2012-10-23 06:18:24 +0000109
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000110 return false;
111}
112
Douglas Gregor27ffa6c2012-10-23 06:18:24 +0000113/// \brief Compare the given set of target options against an existing set of
114/// target options.
115///
116/// \param Diags If non-NULL, diagnostics will be emitted via this engine.
117///
118/// \returns true if the target options mis-match, false otherwise.
119static bool checkTargetOptions(const TargetOptions &TargetOpts,
120 const TargetOptions &ExistingTargetOpts,
121 DiagnosticsEngine *Diags) {
Douglas Gregor38295be2012-10-22 23:51:00 +0000122#define CHECK_TARGET_OPT(Field, Name) \
123 if (TargetOpts.Field != ExistingTargetOpts.Field) { \
Douglas Gregor27ffa6c2012-10-23 06:18:24 +0000124 if (Diags) \
125 Diags->Report(diag::err_pch_targetopt_mismatch) \
Douglas Gregor38295be2012-10-22 23:51:00 +0000126 << Name << TargetOpts.Field << ExistingTargetOpts.Field; \
127 return true; \
Douglas Gregor57016dd2012-10-16 23:40:58 +0000128 }
129
130 CHECK_TARGET_OPT(Triple, "target");
131 CHECK_TARGET_OPT(CPU, "target CPU");
132 CHECK_TARGET_OPT(ABI, "target ABI");
133 CHECK_TARGET_OPT(CXXABI, "target C++ ABI");
134 CHECK_TARGET_OPT(LinkerVersion, "target linker version");
135#undef CHECK_TARGET_OPT
136
137 // Compare feature sets.
138 SmallVector<StringRef, 4> ExistingFeatures(
Douglas Gregor27ffa6c2012-10-23 06:18:24 +0000139 ExistingTargetOpts.FeaturesAsWritten.begin(),
140 ExistingTargetOpts.FeaturesAsWritten.end());
Douglas Gregor57016dd2012-10-16 23:40:58 +0000141 SmallVector<StringRef, 4> ReadFeatures(TargetOpts.FeaturesAsWritten.begin(),
142 TargetOpts.FeaturesAsWritten.end());
143 std::sort(ExistingFeatures.begin(), ExistingFeatures.end());
144 std::sort(ReadFeatures.begin(), ReadFeatures.end());
145
146 unsigned ExistingIdx = 0, ExistingN = ExistingFeatures.size();
147 unsigned ReadIdx = 0, ReadN = ReadFeatures.size();
148 while (ExistingIdx < ExistingN && ReadIdx < ReadN) {
149 if (ExistingFeatures[ExistingIdx] == ReadFeatures[ReadIdx]) {
150 ++ExistingIdx;
151 ++ReadIdx;
152 continue;
153 }
154
155 if (ReadFeatures[ReadIdx] < ExistingFeatures[ExistingIdx]) {
Douglas Gregor27ffa6c2012-10-23 06:18:24 +0000156 if (Diags)
157 Diags->Report(diag::err_pch_targetopt_feature_mismatch)
Douglas Gregor38295be2012-10-22 23:51:00 +0000158 << false << ReadFeatures[ReadIdx];
Douglas Gregor57016dd2012-10-16 23:40:58 +0000159 return true;
160 }
161
Douglas Gregor27ffa6c2012-10-23 06:18:24 +0000162 if (Diags)
163 Diags->Report(diag::err_pch_targetopt_feature_mismatch)
Douglas Gregor38295be2012-10-22 23:51:00 +0000164 << true << ExistingFeatures[ExistingIdx];
Douglas Gregor57016dd2012-10-16 23:40:58 +0000165 return true;
166 }
167
168 if (ExistingIdx < ExistingN) {
Douglas Gregor27ffa6c2012-10-23 06:18:24 +0000169 if (Diags)
170 Diags->Report(diag::err_pch_targetopt_feature_mismatch)
Douglas Gregor38295be2012-10-22 23:51:00 +0000171 << true << ExistingFeatures[ExistingIdx];
Douglas Gregor57016dd2012-10-16 23:40:58 +0000172 return true;
173 }
174
175 if (ReadIdx < ReadN) {
Douglas Gregor27ffa6c2012-10-23 06:18:24 +0000176 if (Diags)
177 Diags->Report(diag::err_pch_targetopt_feature_mismatch)
Douglas Gregor38295be2012-10-22 23:51:00 +0000178 << false << ReadFeatures[ReadIdx];
Douglas Gregor57016dd2012-10-16 23:40:58 +0000179 return true;
180 }
181
182 return false;
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000183}
184
Douglas Gregor27ffa6c2012-10-23 06:18:24 +0000185bool
186PCHValidator::ReadLanguageOptions(const LangOptions &LangOpts,
187 bool Complain) {
188 const LangOptions &PPLangOpts = PP.getLangOpts();
189 return checkLanguageOptions(LangOpts, PPLangOpts,
190 Complain? &Reader.Diags : 0);
191}
192
193bool PCHValidator::ReadTargetOptions(const TargetOptions &TargetOpts,
194 bool Complain) {
195 const TargetOptions &ExistingTargetOpts = PP.getTargetInfo().getTargetOpts();
196 return checkTargetOptions(TargetOpts, ExistingTargetOpts,
197 Complain? &Reader.Diags : 0);
198}
199
Benjamin Kramer54353f42010-11-25 18:29:30 +0000200namespace {
201 struct EmptyStringRef {
Chris Lattner5f9e2722011-07-23 10:55:15 +0000202 bool operator ()(StringRef r) const { return r.empty(); }
Benjamin Kramer54353f42010-11-25 18:29:30 +0000203 };
204 struct EmptyBlock {
205 bool operator ()(const PCHPredefinesBlock &r) const {return r.Data.empty();}
206 };
207}
Sebastian Redl7e9ad8b2010-07-14 17:49:11 +0000208
Chris Lattner5f9e2722011-07-23 10:55:15 +0000209static bool EqualConcatenations(SmallVector<StringRef, 2> L,
Sebastian Redl7e9ad8b2010-07-14 17:49:11 +0000210 PCHPredefinesBlocks R) {
211 // First, sum up the lengths.
212 unsigned LL = 0, RL = 0;
213 for (unsigned I = 0, N = L.size(); I != N; ++I) {
214 LL += L[I].size();
215 }
216 for (unsigned I = 0, N = R.size(); I != N; ++I) {
217 RL += R[I].Data.size();
218 }
219 if (LL != RL)
220 return false;
221 if (LL == 0 && RL == 0)
222 return true;
223
224 // Kick out empty parts, they confuse the algorithm below.
225 L.erase(std::remove_if(L.begin(), L.end(), EmptyStringRef()), L.end());
226 R.erase(std::remove_if(R.begin(), R.end(), EmptyBlock()), R.end());
227
228 // Do it the hard way. At this point, both vectors must be non-empty.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000229 StringRef LR = L[0], RR = R[0].Data;
Sebastian Redl7e9ad8b2010-07-14 17:49:11 +0000230 unsigned LI = 0, RI = 0, LN = L.size(), RN = R.size();
Daniel Dunbarc76c9e02010-07-16 00:00:11 +0000231 (void) RN;
Sebastian Redl7e9ad8b2010-07-14 17:49:11 +0000232 for (;;) {
233 // Compare the current pieces.
234 if (LR.size() == RR.size()) {
235 // If they're the same length, it's pretty easy.
236 if (LR != RR)
237 return false;
238 // Both pieces are done, advance.
239 ++LI;
240 ++RI;
241 // If either string is done, they're both done, since they're the same
242 // length.
243 if (LI == LN) {
244 assert(RI == RN && "Strings not the same length after all?");
245 return true;
246 }
247 LR = L[LI];
248 RR = R[RI].Data;
249 } else if (LR.size() < RR.size()) {
250 // Right piece is longer.
251 if (!RR.startswith(LR))
252 return false;
253 ++LI;
254 assert(LI != LN && "Strings not the same length after all?");
255 RR = RR.substr(LR.size());
256 LR = L[LI];
257 } else {
258 // Left piece is longer.
259 if (!LR.startswith(RR))
260 return false;
261 ++RI;
262 assert(RI != RN && "Strings not the same length after all?");
263 LR = LR.substr(RR.size());
264 RR = R[RI].Data;
265 }
266 }
267}
268
Chris Lattner5f9e2722011-07-23 10:55:15 +0000269static std::pair<FileID, StringRef::size_type>
270FindMacro(const PCHPredefinesBlocks &Buffers, StringRef MacroDef) {
271 std::pair<FileID, StringRef::size_type> Res;
Sebastian Redl7e9ad8b2010-07-14 17:49:11 +0000272 for (unsigned I = 0, N = Buffers.size(); I != N; ++I) {
273 Res.second = Buffers[I].Data.find(MacroDef);
Chris Lattner5f9e2722011-07-23 10:55:15 +0000274 if (Res.second != StringRef::npos) {
Sebastian Redl7e9ad8b2010-07-14 17:49:11 +0000275 Res.first = Buffers[I].BufferID;
276 break;
277 }
278 }
279 return Res;
280}
281
282bool PCHValidator::ReadPredefinesBuffer(const PCHPredefinesBlocks &Buffers,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000283 StringRef OriginalFileName,
Nick Lewycky277a6e72011-02-23 21:16:44 +0000284 std::string &SuggestedPredefines,
Douglas Gregor38295be2012-10-22 23:51:00 +0000285 FileManager &FileMgr,
286 bool Complain) {
Daniel Dunbarc7162932009-11-11 23:58:53 +0000287 // We are in the context of an implicit include, so the predefines buffer will
288 // have a #include entry for the PCH file itself (as normalized by the
289 // preprocessor initialization). Find it and skip over it in the checking
290 // below.
Dylan Noblesmithf7ccbad2012-02-05 02:13:05 +0000291 SmallString<256> PCHInclude;
Daniel Dunbar7b5a1212009-11-11 05:29:04 +0000292 PCHInclude += "#include \"";
Chandler Carruthcb381ea2011-12-09 01:33:57 +0000293 PCHInclude += HeaderSearch::NormalizeDashIncludePath(OriginalFileName,
294 FileMgr);
Daniel Dunbar7b5a1212009-11-11 05:29:04 +0000295 PCHInclude += "\"\n";
Chris Lattner5f9e2722011-07-23 10:55:15 +0000296 std::pair<StringRef,StringRef> Split =
297 StringRef(PP.getPredefines()).split(PCHInclude.str());
298 StringRef Left = Split.first, Right = Split.second;
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +0000299 if (Left == PP.getPredefines()) {
Douglas Gregor38295be2012-10-22 23:51:00 +0000300 if (Complain)
301 Error("Missing PCH include entry!");
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +0000302 return true;
303 }
Daniel Dunbar7b5a1212009-11-11 05:29:04 +0000304
Sebastian Redl7e9ad8b2010-07-14 17:49:11 +0000305 // If the concatenation of all the PCH buffers is equal to the adjusted
306 // command line, we're done.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000307 SmallVector<StringRef, 2> CommandLine;
Sebastian Redl7e9ad8b2010-07-14 17:49:11 +0000308 CommandLine.push_back(Left);
309 CommandLine.push_back(Right);
310 if (EqualConcatenations(CommandLine, Buffers))
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000311 return false;
312
313 SourceManager &SourceMgr = PP.getSourceManager();
Mike Stump1eb44332009-09-09 15:08:12 +0000314
Daniel Dunbar10014aa2009-11-11 03:45:59 +0000315 // The predefines buffers are different. Determine what the differences are,
316 // and whether they require us to reject the PCH file.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000317 SmallVector<StringRef, 8> PCHLines;
Sebastian Redl7e9ad8b2010-07-14 17:49:11 +0000318 for (unsigned I = 0, N = Buffers.size(); I != N; ++I)
319 Buffers[I].Data.split(PCHLines, "\n", /*MaxSplit=*/-1, /*KeepEmpty=*/false);
Daniel Dunbare6750492009-11-13 16:46:11 +0000320
Chris Lattner5f9e2722011-07-23 10:55:15 +0000321 SmallVector<StringRef, 8> CmdLineLines;
Daniel Dunbare6750492009-11-13 16:46:11 +0000322 Left.split(CmdLineLines, "\n", /*MaxSplit=*/-1, /*KeepEmpty=*/false);
Argyrios Kyrtzidis297c7062010-09-30 16:53:50 +0000323
324 // Pick out implicit #includes after the PCH and don't consider them for
325 // validation; we will insert them into SuggestedPredefines so that the
326 // preprocessor includes them.
327 std::string IncludesAfterPCH;
Chris Lattner5f9e2722011-07-23 10:55:15 +0000328 SmallVector<StringRef, 8> AfterPCHLines;
Argyrios Kyrtzidis297c7062010-09-30 16:53:50 +0000329 Right.split(AfterPCHLines, "\n", /*MaxSplit=*/-1, /*KeepEmpty=*/false);
330 for (unsigned i = 0, e = AfterPCHLines.size(); i != e; ++i) {
331 if (AfterPCHLines[i].startswith("#include ")) {
332 IncludesAfterPCH += AfterPCHLines[i];
333 IncludesAfterPCH += '\n';
334 } else {
335 CmdLineLines.push_back(AfterPCHLines[i]);
336 }
337 }
338
339 // Make sure we add the includes last into SuggestedPredefines before we
340 // exit this function.
341 struct AddIncludesRAII {
342 std::string &SuggestedPredefines;
343 std::string &IncludesAfterPCH;
344
345 AddIncludesRAII(std::string &SuggestedPredefines,
346 std::string &IncludesAfterPCH)
347 : SuggestedPredefines(SuggestedPredefines),
348 IncludesAfterPCH(IncludesAfterPCH) { }
349 ~AddIncludesRAII() {
350 SuggestedPredefines += IncludesAfterPCH;
351 }
352 } AddIncludes(SuggestedPredefines, IncludesAfterPCH);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000353
Daniel Dunbar4d5936a2009-11-11 05:26:28 +0000354 // Sort both sets of predefined buffer lines, since we allow some extra
355 // definitions and they may appear at any point in the output.
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000356 std::sort(CmdLineLines.begin(), CmdLineLines.end());
357 std::sort(PCHLines.begin(), PCHLines.end());
358
Daniel Dunbar4d5936a2009-11-11 05:26:28 +0000359 // Determine which predefines that were used to build the PCH file are missing
360 // from the command line.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000361 std::vector<StringRef> MissingPredefines;
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000362 std::set_difference(PCHLines.begin(), PCHLines.end(),
363 CmdLineLines.begin(), CmdLineLines.end(),
364 std::back_inserter(MissingPredefines));
365
366 bool MissingDefines = false;
367 bool ConflictingDefines = false;
368 for (unsigned I = 0, N = MissingPredefines.size(); I != N; ++I) {
Chris Lattner5f9e2722011-07-23 10:55:15 +0000369 StringRef Missing = MissingPredefines[I];
Argyrios Kyrtzidis297c7062010-09-30 16:53:50 +0000370 if (Missing.startswith("#include ")) {
371 // An -include was specified when generating the PCH; it is included in
372 // the PCH, just ignore it.
373 continue;
374 }
Daniel Dunbar4d5936a2009-11-11 05:26:28 +0000375 if (!Missing.startswith("#define ")) {
Douglas Gregor38295be2012-10-22 23:51:00 +0000376 if (Complain)
377 Reader.Diag(diag::warn_pch_compiler_options_mismatch);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000378 return true;
379 }
Mike Stump1eb44332009-09-09 15:08:12 +0000380
Daniel Dunbar10014aa2009-11-11 03:45:59 +0000381 // This is a macro definition. Determine the name of the macro we're
382 // defining.
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000383 std::string::size_type StartOfMacroName = strlen("#define ");
Mike Stump1eb44332009-09-09 15:08:12 +0000384 std::string::size_type EndOfMacroName
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000385 = Missing.find_first_of("( \n\r", StartOfMacroName);
386 assert(EndOfMacroName != std::string::npos &&
387 "Couldn't find the end of the macro name");
Chris Lattner5f9e2722011-07-23 10:55:15 +0000388 StringRef MacroName = Missing.slice(StartOfMacroName, EndOfMacroName);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000389
Daniel Dunbar10014aa2009-11-11 03:45:59 +0000390 // Determine whether this macro was given a different definition on the
391 // command line.
Daniel Dunbar4d5936a2009-11-11 05:26:28 +0000392 std::string MacroDefStart = "#define " + MacroName.str();
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000393 std::string::size_type MacroDefLen = MacroDefStart.size();
Chris Lattner5f9e2722011-07-23 10:55:15 +0000394 SmallVector<StringRef, 8>::iterator ConflictPos
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000395 = std::lower_bound(CmdLineLines.begin(), CmdLineLines.end(),
396 MacroDefStart);
397 for (; ConflictPos != CmdLineLines.end(); ++ConflictPos) {
Daniel Dunbar10014aa2009-11-11 03:45:59 +0000398 if (!ConflictPos->startswith(MacroDefStart)) {
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000399 // Different macro; we're done.
400 ConflictPos = CmdLineLines.end();
Mike Stump1eb44332009-09-09 15:08:12 +0000401 break;
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000402 }
Mike Stump1eb44332009-09-09 15:08:12 +0000403
404 assert(ConflictPos->size() > MacroDefLen &&
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000405 "Invalid #define in predefines buffer?");
Mike Stump1eb44332009-09-09 15:08:12 +0000406 if ((*ConflictPos)[MacroDefLen] != ' ' &&
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000407 (*ConflictPos)[MacroDefLen] != '(')
408 continue; // Longer macro name; keep trying.
Mike Stump1eb44332009-09-09 15:08:12 +0000409
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000410 // We found a conflicting macro definition.
411 break;
412 }
Mike Stump1eb44332009-09-09 15:08:12 +0000413
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000414 if (ConflictPos != CmdLineLines.end()) {
Douglas Gregor38295be2012-10-22 23:51:00 +0000415 if (!Complain)
416 return true;
417
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000418 Reader.Diag(diag::warn_cmdline_conflicting_macro_def)
419 << MacroName;
420
421 // Show the definition of this macro within the PCH file.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000422 std::pair<FileID, StringRef::size_type> MacroLoc =
Sebastian Redl7e9ad8b2010-07-14 17:49:11 +0000423 FindMacro(Buffers, Missing);
Chris Lattner5f9e2722011-07-23 10:55:15 +0000424 assert(MacroLoc.second!=StringRef::npos && "Unable to find macro!");
Sebastian Redl7e9ad8b2010-07-14 17:49:11 +0000425 SourceLocation PCHMissingLoc =
426 SourceMgr.getLocForStartOfFile(MacroLoc.first)
Argyrios Kyrtzidisa64ccef2011-09-19 20:40:19 +0000427 .getLocWithOffset(MacroLoc.second);
Daniel Dunbar4d5936a2009-11-11 05:26:28 +0000428 Reader.Diag(PCHMissingLoc, diag::note_pch_macro_defined_as) << MacroName;
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000429
430 ConflictingDefines = true;
431 continue;
432 }
Mike Stump1eb44332009-09-09 15:08:12 +0000433
Daniel Dunbar10014aa2009-11-11 03:45:59 +0000434 // If the macro doesn't conflict, then we'll just pick up the macro
435 // definition from the PCH file. Warn the user that they made a mistake.
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000436 if (ConflictingDefines)
437 continue; // Don't complain if there are already conflicting defs
Mike Stump1eb44332009-09-09 15:08:12 +0000438
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000439 if (!MissingDefines) {
Douglas Gregor38295be2012-10-22 23:51:00 +0000440 if (!Complain)
441 return true;
442
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000443 Reader.Diag(diag::warn_cmdline_missing_macro_defs);
444 MissingDefines = true;
445 }
446
Douglas Gregor38295be2012-10-22 23:51:00 +0000447 if (!Complain)
448 return true;
449
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000450 // Show the definition of this macro within the PCH file.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000451 std::pair<FileID, StringRef::size_type> MacroLoc =
Sebastian Redl7e9ad8b2010-07-14 17:49:11 +0000452 FindMacro(Buffers, Missing);
Chris Lattner5f9e2722011-07-23 10:55:15 +0000453 assert(MacroLoc.second!=StringRef::npos && "Unable to find macro!");
Sebastian Redl7e9ad8b2010-07-14 17:49:11 +0000454 SourceLocation PCHMissingLoc =
455 SourceMgr.getLocForStartOfFile(MacroLoc.first)
Argyrios Kyrtzidisa64ccef2011-09-19 20:40:19 +0000456 .getLocWithOffset(MacroLoc.second);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000457 Reader.Diag(PCHMissingLoc, diag::note_using_macro_def_from_pch);
458 }
Mike Stump1eb44332009-09-09 15:08:12 +0000459
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000460 if (ConflictingDefines)
461 return true;
Mike Stump1eb44332009-09-09 15:08:12 +0000462
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000463 // Determine what predefines were introduced based on command-line
464 // parameters that were not present when building the PCH
465 // file. Extra #defines are okay, so long as the identifiers being
466 // defined were not used within the precompiled header.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000467 std::vector<StringRef> ExtraPredefines;
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000468 std::set_difference(CmdLineLines.begin(), CmdLineLines.end(),
469 PCHLines.begin(), PCHLines.end(),
Mike Stump1eb44332009-09-09 15:08:12 +0000470 std::back_inserter(ExtraPredefines));
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000471 for (unsigned I = 0, N = ExtraPredefines.size(); I != N; ++I) {
Chris Lattner5f9e2722011-07-23 10:55:15 +0000472 StringRef &Extra = ExtraPredefines[I];
Daniel Dunbar4d5936a2009-11-11 05:26:28 +0000473 if (!Extra.startswith("#define ")) {
Douglas Gregor38295be2012-10-22 23:51:00 +0000474 if (Complain)
475 Reader.Diag(diag::warn_pch_compiler_options_mismatch);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000476 return true;
477 }
478
479 // This is an extra macro definition. Determine the name of the
480 // macro we're defining.
481 std::string::size_type StartOfMacroName = strlen("#define ");
Mike Stump1eb44332009-09-09 15:08:12 +0000482 std::string::size_type EndOfMacroName
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000483 = Extra.find_first_of("( \n\r", StartOfMacroName);
484 assert(EndOfMacroName != std::string::npos &&
485 "Couldn't find the end of the macro name");
Chris Lattner5f9e2722011-07-23 10:55:15 +0000486 StringRef MacroName = Extra.slice(StartOfMacroName, EndOfMacroName);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000487
488 // Check whether this name was used somewhere in the PCH file. If
489 // so, defining it as a macro could change behavior, so we reject
490 // the PCH file.
Daniel Dunbar4d5936a2009-11-11 05:26:28 +0000491 if (IdentifierInfo *II = Reader.get(MacroName)) {
Douglas Gregor38295be2012-10-22 23:51:00 +0000492 if (Complain)
493 Reader.Diag(diag::warn_macro_name_used_in_pch) << II;
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000494 return true;
495 }
496
497 // Add this definition to the suggested predefines buffer.
498 SuggestedPredefines += Extra;
499 SuggestedPredefines += '\n';
500 }
501
502 // If we get here, it's because the predefines buffer had compatible
503 // contents. Accept the PCH file.
504 return false;
505}
506
Douglas Gregor12fab312010-03-16 16:35:32 +0000507void PCHValidator::ReadHeaderFileInfo(const HeaderFileInfo &HFI,
508 unsigned ID) {
509 PP.getHeaderSearchInfo().setHeaderFileInfoForUID(HFI, ID);
510 ++NumHeaderInfos;
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000511}
512
Argyrios Kyrtzidis62288ed2012-10-10 02:12:47 +0000513void PCHValidator::ReadCounter(const ModuleFile &M, unsigned Value) {
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000514 PP.setCounterValue(Value);
515}
516
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000517//===----------------------------------------------------------------------===//
Sebastian Redlc43b54c2010-08-18 23:56:43 +0000518// AST reader implementation
Douglas Gregor668c1a42009-04-21 22:25:48 +0000519//===----------------------------------------------------------------------===//
520
Sebastian Redlffaab3e2010-07-30 00:29:29 +0000521void
Sebastian Redl571db7f2010-08-18 23:56:56 +0000522ASTReader::setDeserializationListener(ASTDeserializationListener *Listener) {
Sebastian Redlffaab3e2010-07-30 00:29:29 +0000523 DeserializationListener = Listener;
Sebastian Redlffaab3e2010-07-30 00:29:29 +0000524}
525
Chris Lattner4c6f9522009-04-27 05:14:47 +0000526
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000527
Douglas Gregor98339b92011-08-25 20:47:51 +0000528unsigned ASTSelectorLookupTrait::ComputeHash(Selector Sel) {
529 return serialization::ComputeHash(Sel);
530}
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000531
Mike Stump1eb44332009-09-09 15:08:12 +0000532
Douglas Gregor98339b92011-08-25 20:47:51 +0000533std::pair<unsigned, unsigned>
534ASTSelectorLookupTrait::ReadKeyDataLength(const unsigned char*& d) {
535 using namespace clang::io;
536 unsigned KeyLen = ReadUnalignedLE16(d);
537 unsigned DataLen = ReadUnalignedLE16(d);
538 return std::make_pair(KeyLen, DataLen);
539}
540
541ASTSelectorLookupTrait::internal_key_type
542ASTSelectorLookupTrait::ReadKey(const unsigned char* d, unsigned) {
543 using namespace clang::io;
Douglas Gregor35942772011-09-09 21:34:22 +0000544 SelectorTable &SelTable = Reader.getContext().Selectors;
Douglas Gregor98339b92011-08-25 20:47:51 +0000545 unsigned N = ReadUnalignedLE16(d);
546 IdentifierInfo *FirstII
547 = Reader.getLocalIdentifier(F, ReadUnalignedLE32(d));
548 if (N == 0)
549 return SelTable.getNullarySelector(FirstII);
550 else if (N == 1)
551 return SelTable.getUnarySelector(FirstII);
552
553 SmallVector<IdentifierInfo *, 16> Args;
554 Args.push_back(FirstII);
555 for (unsigned I = 1; I != N; ++I)
556 Args.push_back(Reader.getLocalIdentifier(F, ReadUnalignedLE32(d)));
557
558 return SelTable.getSelector(N, Args.data());
559}
560
561ASTSelectorLookupTrait::data_type
562ASTSelectorLookupTrait::ReadData(Selector, const unsigned char* d,
563 unsigned DataLen) {
564 using namespace clang::io;
565
566 data_type Result;
567
568 Result.ID = Reader.getGlobalSelectorID(F, ReadUnalignedLE32(d));
569 unsigned NumInstanceMethods = ReadUnalignedLE16(d);
570 unsigned NumFactoryMethods = ReadUnalignedLE16(d);
571
572 // Load instance methods
Douglas Gregor98339b92011-08-25 20:47:51 +0000573 for (unsigned I = 0; I != NumInstanceMethods; ++I) {
574 if (ObjCMethodDecl *Method
575 = Reader.GetLocalDeclAs<ObjCMethodDecl>(F, ReadUnalignedLE32(d)))
576 Result.Instance.push_back(Method);
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000577 }
Mike Stump1eb44332009-09-09 15:08:12 +0000578
Douglas Gregor98339b92011-08-25 20:47:51 +0000579 // Load factory methods
Douglas Gregor98339b92011-08-25 20:47:51 +0000580 for (unsigned I = 0; I != NumFactoryMethods; ++I) {
581 if (ObjCMethodDecl *Method
582 = Reader.GetLocalDeclAs<ObjCMethodDecl>(F, ReadUnalignedLE32(d)))
583 Result.Factory.push_back(Method);
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000584 }
Mike Stump1eb44332009-09-09 15:08:12 +0000585
Douglas Gregor98339b92011-08-25 20:47:51 +0000586 return Result;
587}
Mike Stump1eb44332009-09-09 15:08:12 +0000588
Douglas Gregor98339b92011-08-25 20:47:51 +0000589unsigned ASTIdentifierLookupTrait::ComputeHash(const internal_key_type& a) {
590 return llvm::HashString(StringRef(a.first, a.second));
591}
Mike Stump1eb44332009-09-09 15:08:12 +0000592
Douglas Gregor98339b92011-08-25 20:47:51 +0000593std::pair<unsigned, unsigned>
594ASTIdentifierLookupTrait::ReadKeyDataLength(const unsigned char*& d) {
595 using namespace clang::io;
596 unsigned DataLen = ReadUnalignedLE16(d);
597 unsigned KeyLen = ReadUnalignedLE16(d);
598 return std::make_pair(KeyLen, DataLen);
599}
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000600
Douglas Gregor98339b92011-08-25 20:47:51 +0000601std::pair<const char*, unsigned>
602ASTIdentifierLookupTrait::ReadKey(const unsigned char* d, unsigned n) {
603 assert(n >= 2 && d[n-1] == '\0');
604 return std::make_pair((const char*) d, n-1);
605}
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000606
Douglas Gregor98339b92011-08-25 20:47:51 +0000607IdentifierInfo *ASTIdentifierLookupTrait::ReadData(const internal_key_type& k,
608 const unsigned char* d,
609 unsigned DataLen) {
610 using namespace clang::io;
611 unsigned RawID = ReadUnalignedLE32(d);
612 bool IsInteresting = RawID & 0x01;
Mike Stump1eb44332009-09-09 15:08:12 +0000613
Douglas Gregor98339b92011-08-25 20:47:51 +0000614 // Wipe out the "is interesting" bit.
615 RawID = RawID >> 1;
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000616
Douglas Gregor98339b92011-08-25 20:47:51 +0000617 IdentID ID = Reader.getGlobalIdentifierID(F, RawID);
618 if (!IsInteresting) {
619 // For uninteresting identifiers, just build the IdentifierInfo
620 // and associate it with the persistent ID.
Douglas Gregor668c1a42009-04-21 22:25:48 +0000621 IdentifierInfo *II = KnownII;
Douglas Gregor5d5051f2012-01-24 15:24:38 +0000622 if (!II) {
Douglas Gregor6ec60e02011-08-03 21:49:18 +0000623 II = &Reader.getIdentifierTable().getOwn(StringRef(k.first, k.second));
Douglas Gregor5d5051f2012-01-24 15:24:38 +0000624 KnownII = II;
625 }
Douglas Gregor668c1a42009-04-21 22:25:48 +0000626 Reader.SetIdentifierInfo(ID, II);
Sebastian Redl3c7f4132010-08-18 23:57:06 +0000627 II->setIsFromAST();
Douglas Gregor057df202012-01-18 20:56:22 +0000628 Reader.markIdentifierUpToDate(II);
Douglas Gregor668c1a42009-04-21 22:25:48 +0000629 return II;
630 }
Mike Stump1eb44332009-09-09 15:08:12 +0000631
Alexander Kornienko4d7e0ce2012-09-25 17:18:14 +0000632 unsigned ObjCOrBuiltinID = ReadUnalignedLE16(d);
Douglas Gregor98339b92011-08-25 20:47:51 +0000633 unsigned Bits = ReadUnalignedLE16(d);
634 bool CPlusPlusOperatorKeyword = Bits & 0x01;
635 Bits >>= 1;
636 bool HasRevertedTokenIDToIdentifier = Bits & 0x01;
637 Bits >>= 1;
638 bool Poisoned = Bits & 0x01;
639 Bits >>= 1;
640 bool ExtensionToken = Bits & 0x01;
641 Bits >>= 1;
Alexander Kornienko4d7e0ce2012-09-25 17:18:14 +0000642 bool hadMacroDefinition = Bits & 0x01;
643 Bits >>= 1;
Douglas Gregor668c1a42009-04-21 22:25:48 +0000644
Douglas Gregor98339b92011-08-25 20:47:51 +0000645 assert(Bits == 0 && "Extra bits in the identifier?");
Alexander Kornienko4d7e0ce2012-09-25 17:18:14 +0000646 DataLen -= 8;
Douglas Gregor668c1a42009-04-21 22:25:48 +0000647
Douglas Gregor98339b92011-08-25 20:47:51 +0000648 // Build the IdentifierInfo itself and link the identifier ID with
649 // the new IdentifierInfo.
650 IdentifierInfo *II = KnownII;
Douglas Gregor5d5051f2012-01-24 15:24:38 +0000651 if (!II) {
Douglas Gregor98339b92011-08-25 20:47:51 +0000652 II = &Reader.getIdentifierTable().getOwn(StringRef(k.first, k.second));
Douglas Gregor5d5051f2012-01-24 15:24:38 +0000653 KnownII = II;
654 }
Douglas Gregor057df202012-01-18 20:56:22 +0000655 Reader.markIdentifierUpToDate(II);
Douglas Gregoreee242f2011-10-27 09:33:13 +0000656 II->setIsFromAST();
Argyrios Kyrtzidis5d267682010-08-20 16:04:27 +0000657
Douglas Gregor98339b92011-08-25 20:47:51 +0000658 // Set or check the various bits in the IdentifierInfo structure.
659 // Token IDs are read-only.
660 if (HasRevertedTokenIDToIdentifier)
661 II->RevertTokenIDToIdentifier();
662 II->setObjCOrBuiltinID(ObjCOrBuiltinID);
663 assert(II->isExtensionToken() == ExtensionToken &&
664 "Incorrect extension token flag");
665 (void)ExtensionToken;
666 if (Poisoned)
667 II->setIsPoisoned(true);
668 assert(II->isCPlusPlusOperatorKeyword() == CPlusPlusOperatorKeyword &&
669 "Incorrect C++ operator keyword flag");
670 (void)CPlusPlusOperatorKeyword;
Argyrios Kyrtzidis5d267682010-08-20 16:04:27 +0000671
Douglas Gregor98339b92011-08-25 20:47:51 +0000672 // If this identifier is a macro, deserialize the macro
673 // definition.
Alexander Kornienko4d7e0ce2012-09-25 17:18:14 +0000674 if (hadMacroDefinition) {
Douglas Gregor6c6c54a2012-10-11 00:46:49 +0000675 SmallVector<MacroID, 4> MacroIDs;
676 while (uint32_t LocalID = ReadUnalignedLE32(d)) {
677 MacroIDs.push_back(Reader.getGlobalMacroID(F, LocalID));
678 DataLen -= 4;
Douglas Gregor13292642011-12-02 15:45:10 +0000679 }
Douglas Gregor6c6c54a2012-10-11 00:46:49 +0000680 DataLen -= 4;
681 Reader.setIdentifierIsMacro(II, MacroIDs);
Argyrios Kyrtzidis5d267682010-08-20 16:04:27 +0000682 }
683
Douglas Gregoreee242f2011-10-27 09:33:13 +0000684 Reader.SetIdentifierInfo(ID, II);
685
Douglas Gregor98339b92011-08-25 20:47:51 +0000686 // Read all of the declarations visible at global scope with this
687 // name.
Douglas Gregor98339b92011-08-25 20:47:51 +0000688 if (DataLen > 0) {
689 SmallVector<uint32_t, 4> DeclIDs;
690 for (; DataLen > 0; DataLen -= 4)
691 DeclIDs.push_back(Reader.getGlobalDeclID(F, ReadUnalignedLE32(d)));
692 Reader.SetGloballyVisibleDecls(II, DeclIDs);
Argyrios Kyrtzidis5d267682010-08-20 16:04:27 +0000693 }
694
Douglas Gregor98339b92011-08-25 20:47:51 +0000695 return II;
696}
Michael J. Spencer20249a12010-10-21 03:16:25 +0000697
Douglas Gregor98339b92011-08-25 20:47:51 +0000698unsigned
699ASTDeclContextNameLookupTrait::ComputeHash(const DeclNameKey &Key) const {
700 llvm::FoldingSetNodeID ID;
701 ID.AddInteger(Key.Kind);
702
703 switch (Key.Kind) {
704 case DeclarationName::Identifier:
705 case DeclarationName::CXXLiteralOperatorName:
706 ID.AddString(((IdentifierInfo*)Key.Data)->getName());
707 break;
708 case DeclarationName::ObjCZeroArgSelector:
709 case DeclarationName::ObjCOneArgSelector:
710 case DeclarationName::ObjCMultiArgSelector:
711 ID.AddInteger(serialization::ComputeHash(Selector(Key.Data)));
712 break;
713 case DeclarationName::CXXOperatorName:
714 ID.AddInteger((OverloadedOperatorKind)Key.Data);
715 break;
716 case DeclarationName::CXXConstructorName:
717 case DeclarationName::CXXDestructorName:
718 case DeclarationName::CXXConversionFunctionName:
719 case DeclarationName::CXXUsingDirective:
720 break;
Argyrios Kyrtzidis5d267682010-08-20 16:04:27 +0000721 }
722
Douglas Gregor98339b92011-08-25 20:47:51 +0000723 return ID.ComputeHash();
724}
Argyrios Kyrtzidisa60786b2010-08-20 23:35:55 +0000725
Douglas Gregor98339b92011-08-25 20:47:51 +0000726ASTDeclContextNameLookupTrait::internal_key_type
727ASTDeclContextNameLookupTrait::GetInternalKey(
728 const external_key_type& Name) const {
729 DeclNameKey Key;
730 Key.Kind = Name.getNameKind();
731 switch (Name.getNameKind()) {
732 case DeclarationName::Identifier:
733 Key.Data = (uint64_t)Name.getAsIdentifierInfo();
734 break;
735 case DeclarationName::ObjCZeroArgSelector:
736 case DeclarationName::ObjCOneArgSelector:
737 case DeclarationName::ObjCMultiArgSelector:
738 Key.Data = (uint64_t)Name.getObjCSelector().getAsOpaquePtr();
739 break;
740 case DeclarationName::CXXOperatorName:
741 Key.Data = Name.getCXXOverloadedOperator();
742 break;
743 case DeclarationName::CXXLiteralOperatorName:
744 Key.Data = (uint64_t)Name.getCXXLiteralIdentifier();
745 break;
746 case DeclarationName::CXXConstructorName:
747 case DeclarationName::CXXDestructorName:
748 case DeclarationName::CXXConversionFunctionName:
749 case DeclarationName::CXXUsingDirective:
750 Key.Data = 0;
751 break;
Argyrios Kyrtzidisa60786b2010-08-20 23:35:55 +0000752 }
753
Douglas Gregor98339b92011-08-25 20:47:51 +0000754 return Key;
755}
756
Douglas Gregor98339b92011-08-25 20:47:51 +0000757std::pair<unsigned, unsigned>
758ASTDeclContextNameLookupTrait::ReadKeyDataLength(const unsigned char*& d) {
759 using namespace clang::io;
760 unsigned KeyLen = ReadUnalignedLE16(d);
761 unsigned DataLen = ReadUnalignedLE16(d);
762 return std::make_pair(KeyLen, DataLen);
763}
Michael J. Spencer20249a12010-10-21 03:16:25 +0000764
Douglas Gregor98339b92011-08-25 20:47:51 +0000765ASTDeclContextNameLookupTrait::internal_key_type
766ASTDeclContextNameLookupTrait::ReadKey(const unsigned char* d, unsigned) {
767 using namespace clang::io;
768
769 DeclNameKey Key;
770 Key.Kind = (DeclarationName::NameKind)*d++;
771 switch (Key.Kind) {
772 case DeclarationName::Identifier:
773 Key.Data = (uint64_t)Reader.getLocalIdentifier(F, ReadUnalignedLE32(d));
774 break;
775 case DeclarationName::ObjCZeroArgSelector:
776 case DeclarationName::ObjCOneArgSelector:
777 case DeclarationName::ObjCMultiArgSelector:
778 Key.Data =
779 (uint64_t)Reader.getLocalSelector(F, ReadUnalignedLE32(d))
780 .getAsOpaquePtr();
781 break;
782 case DeclarationName::CXXOperatorName:
783 Key.Data = *d++; // OverloadedOperatorKind
784 break;
785 case DeclarationName::CXXLiteralOperatorName:
786 Key.Data = (uint64_t)Reader.getLocalIdentifier(F, ReadUnalignedLE32(d));
787 break;
788 case DeclarationName::CXXConstructorName:
789 case DeclarationName::CXXDestructorName:
790 case DeclarationName::CXXConversionFunctionName:
791 case DeclarationName::CXXUsingDirective:
792 Key.Data = 0;
793 break;
Argyrios Kyrtzidis5d267682010-08-20 16:04:27 +0000794 }
795
Douglas Gregor98339b92011-08-25 20:47:51 +0000796 return Key;
797}
Argyrios Kyrtzidis5d267682010-08-20 16:04:27 +0000798
Douglas Gregor98339b92011-08-25 20:47:51 +0000799ASTDeclContextNameLookupTrait::data_type
800ASTDeclContextNameLookupTrait::ReadData(internal_key_type,
801 const unsigned char* d,
Nick Lewyckyb346d2f2012-04-16 02:51:46 +0000802 unsigned DataLen) {
Douglas Gregor98339b92011-08-25 20:47:51 +0000803 using namespace clang::io;
804 unsigned NumDecls = ReadUnalignedLE16(d);
Douglas Gregor9b8b20f2012-01-06 16:09:53 +0000805 LE32DeclID *Start = (LE32DeclID *)d;
Douglas Gregor98339b92011-08-25 20:47:51 +0000806 return std::make_pair(Start, Start + NumDecls);
807}
Argyrios Kyrtzidis5d267682010-08-20 16:04:27 +0000808
Douglas Gregor1a4761e2011-11-30 23:21:26 +0000809bool ASTReader::ReadDeclContextStorage(ModuleFile &M,
Douglas Gregor0d95f772011-08-24 19:03:07 +0000810 llvm::BitstreamCursor &Cursor,
Argyrios Kyrtzidis074dcc82010-08-20 16:04:35 +0000811 const std::pair<uint64_t, uint64_t> &Offsets,
812 DeclContextInfo &Info) {
813 SavedStreamPosition SavedPosition(Cursor);
814 // First the lexical decls.
815 if (Offsets.first != 0) {
816 Cursor.JumpToBit(Offsets.first);
817
818 RecordData Record;
819 const char *Blob;
820 unsigned BlobLen;
821 unsigned Code = Cursor.ReadCode();
822 unsigned RecCode = Cursor.ReadRecord(Code, Record, &Blob, &BlobLen);
823 if (RecCode != DECL_CONTEXT_LEXICAL) {
824 Error("Expected lexical block");
825 return true;
826 }
827
Argyrios Kyrtzidiseb5e9982010-10-14 20:14:34 +0000828 Info.LexicalDecls = reinterpret_cast<const KindDeclIDPair*>(Blob);
829 Info.NumLexicalDecls = BlobLen / sizeof(KindDeclIDPair);
Argyrios Kyrtzidis074dcc82010-08-20 16:04:35 +0000830 }
831
832 // Now the lookup table.
833 if (Offsets.second != 0) {
834 Cursor.JumpToBit(Offsets.second);
835
836 RecordData Record;
837 const char *Blob;
838 unsigned BlobLen;
839 unsigned Code = Cursor.ReadCode();
840 unsigned RecCode = Cursor.ReadRecord(Code, Record, &Blob, &BlobLen);
841 if (RecCode != DECL_CONTEXT_VISIBLE) {
842 Error("Expected visible lookup table block");
843 return true;
844 }
845 Info.NameLookupTableData
846 = ASTDeclContextNameLookupTable::Create(
847 (const unsigned char *)Blob + Record[0],
848 (const unsigned char *)Blob,
Douglas Gregor0d95f772011-08-24 19:03:07 +0000849 ASTDeclContextNameLookupTrait(*this, M));
Argyrios Kyrtzidis074dcc82010-08-20 16:04:35 +0000850 }
851
852 return false;
853}
854
Chris Lattner5f9e2722011-07-23 10:55:15 +0000855void ASTReader::Error(StringRef Msg) {
Argyrios Kyrtzidis8d8f2c22011-04-25 22:23:56 +0000856 Error(diag::err_fe_pch_malformed, Msg);
857}
858
859void ASTReader::Error(unsigned DiagID,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000860 StringRef Arg1, StringRef Arg2) {
Argyrios Kyrtzidis8d8f2c22011-04-25 22:23:56 +0000861 if (Diags.isDiagnosticInFlight())
862 Diags.SetDelayedDiagnostic(DiagID, Arg1, Arg2);
863 else
864 Diag(DiagID) << Arg1 << Arg2;
Douglas Gregor2cf26342009-04-09 22:27:44 +0000865}
866
Sebastian Redl3c7f4132010-08-18 23:57:06 +0000867/// \brief Tell the AST listener about the predefines buffers in the chain.
Douglas Gregor38295be2012-10-22 23:51:00 +0000868bool ASTReader::CheckPredefinesBuffers(bool Complain) {
Douglas Gregor11407b82012-10-18 21:18:25 +0000869 if (Listener) {
870 // We only care about the primary module.
871 ModuleFile &M = ModuleMgr.getPrimaryModule();
Sebastian Redl7e9ad8b2010-07-14 17:49:11 +0000872 return Listener->ReadPredefinesBuffer(PCHPredefinesBuffers,
Douglas Gregor11407b82012-10-18 21:18:25 +0000873 M.ActualOriginalSourceFileName,
Nick Lewycky277a6e72011-02-23 21:16:44 +0000874 SuggestedPredefines,
Douglas Gregor38295be2012-10-22 23:51:00 +0000875 FileMgr,
876 Complain);
Douglas Gregor11407b82012-10-18 21:18:25 +0000877 }
Douglas Gregore721f952009-04-28 18:58:38 +0000878 return false;
Douglas Gregore1d918e2009-04-10 23:10:45 +0000879}
880
Douglas Gregor4fed3f42009-04-27 18:38:38 +0000881//===----------------------------------------------------------------------===//
882// Source Manager Deserialization
883//===----------------------------------------------------------------------===//
884
Douglas Gregorbd945002009-04-13 16:31:14 +0000885/// \brief Read the line table in the source manager block.
Sebastian Redlc3632732010-10-05 15:59:54 +0000886/// \returns true if there was an error.
Douglas Gregor1a4761e2011-11-30 23:21:26 +0000887bool ASTReader::ParseLineTable(ModuleFile &F,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000888 SmallVectorImpl<uint64_t> &Record) {
Douglas Gregorbd945002009-04-13 16:31:14 +0000889 unsigned Idx = 0;
890 LineTableInfo &LineTable = SourceMgr.getLineTable();
891
892 // Parse the file names
Douglas Gregorff0a9872009-04-13 17:12:42 +0000893 std::map<int, int> FileIDs;
894 for (int I = 0, N = Record[Idx++]; I != N; ++I) {
Douglas Gregorbd945002009-04-13 16:31:14 +0000895 // Extract the file name
896 unsigned FilenameLen = Record[Idx++];
897 std::string Filename(&Record[Idx], &Record[Idx] + FilenameLen);
898 Idx += FilenameLen;
Douglas Gregorcaed0602012-10-18 21:31:35 +0000899 MaybeAddSystemRootToFilename(F, Filename);
Jay Foad65aa6882011-06-21 15:13:30 +0000900 FileIDs[I] = LineTable.getLineTableFilenameID(Filename);
Douglas Gregorbd945002009-04-13 16:31:14 +0000901 }
902
903 // Parse the line entries
904 std::vector<LineEntry> Entries;
905 while (Idx < Record.size()) {
Argyrios Kyrtzidisf52a5d22010-07-02 11:55:05 +0000906 int FID = Record[Idx++];
Douglas Gregorf62d43d2011-07-19 16:10:42 +0000907 assert(FID >= 0 && "Serialized line entries for non-local file.");
908 // Remap FileID from 1-based old view.
909 FID += F.SLocEntryBaseID - 1;
Douglas Gregorbd945002009-04-13 16:31:14 +0000910
911 // Extract the line entries
912 unsigned NumEntries = Record[Idx++];
Argyrios Kyrtzidisf52a5d22010-07-02 11:55:05 +0000913 assert(NumEntries && "Numentries is 00000");
Douglas Gregorbd945002009-04-13 16:31:14 +0000914 Entries.clear();
915 Entries.reserve(NumEntries);
916 for (unsigned I = 0; I != NumEntries; ++I) {
917 unsigned FileOffset = Record[Idx++];
918 unsigned LineNo = Record[Idx++];
Argyrios Kyrtzidisf52a5d22010-07-02 11:55:05 +0000919 int FilenameID = FileIDs[Record[Idx++]];
Mike Stump1eb44332009-09-09 15:08:12 +0000920 SrcMgr::CharacteristicKind FileKind
Douglas Gregorbd945002009-04-13 16:31:14 +0000921 = (SrcMgr::CharacteristicKind)Record[Idx++];
922 unsigned IncludeOffset = Record[Idx++];
923 Entries.push_back(LineEntry::get(FileOffset, LineNo, FilenameID,
924 FileKind, IncludeOffset));
925 }
Douglas Gregor47d9de62012-06-08 16:40:28 +0000926 LineTable.AddEntry(FileID::get(FID), Entries);
Douglas Gregorbd945002009-04-13 16:31:14 +0000927 }
928
929 return false;
930}
931
Douglas Gregor4fed3f42009-04-27 18:38:38 +0000932namespace {
933
Sebastian Redl3c7f4132010-08-18 23:57:06 +0000934class ASTStatData {
Douglas Gregor4fed3f42009-04-27 18:38:38 +0000935public:
Douglas Gregor4fed3f42009-04-27 18:38:38 +0000936 const ino_t ino;
937 const dev_t dev;
938 const mode_t mode;
939 const time_t mtime;
940 const off_t size;
Mike Stump1eb44332009-09-09 15:08:12 +0000941
Sebastian Redl3c7f4132010-08-18 23:57:06 +0000942 ASTStatData(ino_t i, dev_t d, mode_t mo, time_t m, off_t s)
Chris Lattner74e976b2010-11-23 19:28:12 +0000943 : ino(i), dev(d), mode(mo), mtime(m), size(s) {}
Douglas Gregor4fed3f42009-04-27 18:38:38 +0000944};
945
Sebastian Redl3c7f4132010-08-18 23:57:06 +0000946class ASTStatLookupTrait {
Douglas Gregor4fed3f42009-04-27 18:38:38 +0000947 public:
948 typedef const char *external_key_type;
949 typedef const char *internal_key_type;
950
Sebastian Redl3c7f4132010-08-18 23:57:06 +0000951 typedef ASTStatData data_type;
Douglas Gregor4fed3f42009-04-27 18:38:38 +0000952
953 static unsigned ComputeHash(const char *path) {
Daniel Dunbar2596e422009-10-17 23:52:28 +0000954 return llvm::HashString(path);
Douglas Gregor4fed3f42009-04-27 18:38:38 +0000955 }
956
957 static internal_key_type GetInternalKey(const char *path) { return path; }
958
959 static bool EqualKey(internal_key_type a, internal_key_type b) {
960 return strcmp(a, b) == 0;
961 }
962
963 static std::pair<unsigned, unsigned>
964 ReadKeyDataLength(const unsigned char*& d) {
965 unsigned KeyLen = (unsigned) clang::io::ReadUnalignedLE16(d);
966 unsigned DataLen = (unsigned) *d++;
967 return std::make_pair(KeyLen + 1, DataLen);
968 }
969
970 static internal_key_type ReadKey(const unsigned char *d, unsigned) {
971 return (const char *)d;
972 }
973
974 static data_type ReadData(const internal_key_type, const unsigned char *d,
975 unsigned /*DataLen*/) {
976 using namespace clang::io;
977
Douglas Gregor4fed3f42009-04-27 18:38:38 +0000978 ino_t ino = (ino_t) ReadUnalignedLE32(d);
979 dev_t dev = (dev_t) ReadUnalignedLE32(d);
980 mode_t mode = (mode_t) ReadUnalignedLE16(d);
Mike Stump1eb44332009-09-09 15:08:12 +0000981 time_t mtime = (time_t) ReadUnalignedLE64(d);
Douglas Gregor4fed3f42009-04-27 18:38:38 +0000982 off_t size = (off_t) ReadUnalignedLE64(d);
983 return data_type(ino, dev, mode, mtime, size);
984 }
985};
986
987/// \brief stat() cache for precompiled headers.
988///
989/// This cache is very similar to the stat cache used by pretokenized
990/// headers.
Chris Lattner10e286a2010-11-23 19:19:34 +0000991class ASTStatCache : public FileSystemStatCache {
Sebastian Redl3c7f4132010-08-18 23:57:06 +0000992 typedef OnDiskChainedHashTable<ASTStatLookupTrait> CacheTy;
Douglas Gregor4fed3f42009-04-27 18:38:38 +0000993 CacheTy *Cache;
994
995 unsigned &NumStatHits, &NumStatMisses;
Mike Stump1eb44332009-09-09 15:08:12 +0000996public:
Chris Lattner74e976b2010-11-23 19:28:12 +0000997 ASTStatCache(const unsigned char *Buckets, const unsigned char *Base,
998 unsigned &NumStatHits, unsigned &NumStatMisses)
Douglas Gregor4fed3f42009-04-27 18:38:38 +0000999 : Cache(0), NumStatHits(NumStatHits), NumStatMisses(NumStatMisses) {
1000 Cache = CacheTy::Create(Buckets, Base);
1001 }
1002
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001003 ~ASTStatCache() { delete Cache; }
Mike Stump1eb44332009-09-09 15:08:12 +00001004
Chris Lattner898a0612010-11-23 21:17:56 +00001005 LookupResult getStat(const char *Path, struct stat &StatBuf,
1006 int *FileDescriptor) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001007 // Do the lookup for the file's data in the AST file.
Chris Lattner10e286a2010-11-23 19:19:34 +00001008 CacheTy::iterator I = Cache->find(Path);
Douglas Gregor4fed3f42009-04-27 18:38:38 +00001009
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001010 // If we don't get a hit in the AST file just forward to 'stat'.
Douglas Gregor4fed3f42009-04-27 18:38:38 +00001011 if (I == Cache->end()) {
1012 ++NumStatMisses;
Chris Lattner898a0612010-11-23 21:17:56 +00001013 return statChained(Path, StatBuf, FileDescriptor);
Douglas Gregor4fed3f42009-04-27 18:38:38 +00001014 }
Mike Stump1eb44332009-09-09 15:08:12 +00001015
Douglas Gregor4fed3f42009-04-27 18:38:38 +00001016 ++NumStatHits;
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001017 ASTStatData Data = *I;
Mike Stump1eb44332009-09-09 15:08:12 +00001018
Chris Lattner10e286a2010-11-23 19:19:34 +00001019 StatBuf.st_ino = Data.ino;
1020 StatBuf.st_dev = Data.dev;
1021 StatBuf.st_mtime = Data.mtime;
1022 StatBuf.st_mode = Data.mode;
1023 StatBuf.st_size = Data.size;
Chris Lattnerd6f61112010-11-23 20:05:15 +00001024 return CacheExists;
Douglas Gregor4fed3f42009-04-27 18:38:38 +00001025 }
1026};
1027} // end anonymous namespace
1028
1029
Sebastian Redl93fb9ed2010-07-19 20:52:06 +00001030/// \brief Read a source manager block
Douglas Gregor4825fd72012-10-22 22:50:17 +00001031bool ASTReader::ReadSourceManagerBlock(ModuleFile &F) {
Douglas Gregor14f79002009-04-10 03:52:48 +00001032 using namespace SrcMgr;
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001033
Sebastian Redl93fb9ed2010-07-19 20:52:06 +00001034 llvm::BitstreamCursor &SLocEntryCursor = F.SLocEntryCursor;
Sebastian Redl9137a522010-07-16 17:50:48 +00001035
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001036 // Set the source-location entry cursor to the current position in
1037 // the stream. This cursor will be used to read the contents of the
1038 // source manager block initially, and then lazily read
1039 // source-location entries as needed.
Sebastian Redl93fb9ed2010-07-19 20:52:06 +00001040 SLocEntryCursor = F.Stream;
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001041
1042 // The stream itself is going to skip over the source manager block.
Sebastian Redl93fb9ed2010-07-19 20:52:06 +00001043 if (F.Stream.SkipBlock()) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001044 Error("malformed block record in AST file");
Douglas Gregor4825fd72012-10-22 22:50:17 +00001045 return true;
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001046 }
1047
1048 // Enter the source manager block.
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001049 if (SLocEntryCursor.EnterSubBlock(SOURCE_MANAGER_BLOCK_ID)) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001050 Error("malformed source manager block record in AST file");
Douglas Gregor4825fd72012-10-22 22:50:17 +00001051 return true;
Douglas Gregore1d918e2009-04-10 23:10:45 +00001052 }
Douglas Gregor14f79002009-04-10 03:52:48 +00001053
Douglas Gregor14f79002009-04-10 03:52:48 +00001054 RecordData Record;
1055 while (true) {
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001056 unsigned Code = SLocEntryCursor.ReadCode();
Douglas Gregor14f79002009-04-10 03:52:48 +00001057 if (Code == llvm::bitc::END_BLOCK) {
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001058 if (SLocEntryCursor.ReadBlockEnd()) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001059 Error("error at end of Source Manager block in AST file");
Douglas Gregor4825fd72012-10-22 22:50:17 +00001060 return true;
Douglas Gregore1d918e2009-04-10 23:10:45 +00001061 }
Douglas Gregor4825fd72012-10-22 22:50:17 +00001062 return false;
Douglas Gregor14f79002009-04-10 03:52:48 +00001063 }
Mike Stump1eb44332009-09-09 15:08:12 +00001064
Douglas Gregor14f79002009-04-10 03:52:48 +00001065 if (Code == llvm::bitc::ENTER_SUBBLOCK) {
1066 // No known subblocks, always skip them.
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001067 SLocEntryCursor.ReadSubBlockID();
1068 if (SLocEntryCursor.SkipBlock()) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001069 Error("malformed block record in AST file");
Douglas Gregor4825fd72012-10-22 22:50:17 +00001070 return true;
Douglas Gregore1d918e2009-04-10 23:10:45 +00001071 }
Douglas Gregor14f79002009-04-10 03:52:48 +00001072 continue;
1073 }
Mike Stump1eb44332009-09-09 15:08:12 +00001074
Douglas Gregor14f79002009-04-10 03:52:48 +00001075 if (Code == llvm::bitc::DEFINE_ABBREV) {
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001076 SLocEntryCursor.ReadAbbrevRecord();
Douglas Gregor14f79002009-04-10 03:52:48 +00001077 continue;
1078 }
Mike Stump1eb44332009-09-09 15:08:12 +00001079
Douglas Gregor14f79002009-04-10 03:52:48 +00001080 // Read a record.
1081 const char *BlobStart;
1082 unsigned BlobLen;
1083 Record.clear();
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001084 switch (SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) {
Douglas Gregor14f79002009-04-10 03:52:48 +00001085 default: // Default behavior: ignore.
1086 break;
1087
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001088 case SM_SLOC_FILE_ENTRY:
1089 case SM_SLOC_BUFFER_ENTRY:
Chandler Carruthf70d12d2011-07-15 07:25:21 +00001090 case SM_SLOC_EXPANSION_ENTRY:
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001091 // Once we hit one of the source location entries, we're done.
Douglas Gregor4825fd72012-10-22 22:50:17 +00001092 return false;
Douglas Gregor14f79002009-04-10 03:52:48 +00001093 }
1094 }
1095}
1096
Argyrios Kyrtzidis8e3df4d2011-02-15 17:54:22 +00001097/// \brief If a header file is not found at the path that we expect it to be
1098/// and the PCH file was moved from its original location, try to resolve the
1099/// file by assuming that header+PCH were moved together and the header is in
1100/// the same place relative to the PCH.
1101static std::string
1102resolveFileRelativeToOriginalDir(const std::string &Filename,
1103 const std::string &OriginalDir,
1104 const std::string &CurrDir) {
1105 assert(OriginalDir != CurrDir &&
1106 "No point trying to resolve the file if the PCH dir didn't change");
1107 using namespace llvm::sys;
Dylan Noblesmithf7ccbad2012-02-05 02:13:05 +00001108 SmallString<128> filePath(Filename);
Argyrios Kyrtzidis8e3df4d2011-02-15 17:54:22 +00001109 fs::make_absolute(filePath);
1110 assert(path::is_absolute(OriginalDir));
Dylan Noblesmithf7ccbad2012-02-05 02:13:05 +00001111 SmallString<128> currPCHPath(CurrDir);
Argyrios Kyrtzidis8e3df4d2011-02-15 17:54:22 +00001112
1113 path::const_iterator fileDirI = path::begin(path::parent_path(filePath)),
1114 fileDirE = path::end(path::parent_path(filePath));
1115 path::const_iterator origDirI = path::begin(OriginalDir),
1116 origDirE = path::end(OriginalDir);
1117 // Skip the common path components from filePath and OriginalDir.
1118 while (fileDirI != fileDirE && origDirI != origDirE &&
1119 *fileDirI == *origDirI) {
1120 ++fileDirI;
1121 ++origDirI;
1122 }
1123 for (; origDirI != origDirE; ++origDirI)
1124 path::append(currPCHPath, "..");
1125 path::append(currPCHPath, fileDirI, fileDirE);
1126 path::append(currPCHPath, path::filename(Filename));
1127 return currPCHPath.str();
1128}
1129
Douglas Gregor8b53d142012-10-22 22:53:10 +00001130bool ASTReader::ReadSLocEntry(int ID) {
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001131 if (ID == 0)
Douglas Gregor4825fd72012-10-22 22:50:17 +00001132 return false;
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001133
Douglas Gregor0cdd7982011-07-21 18:46:38 +00001134 if (unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001135 Error("source location entry ID out-of-range for AST file");
Douglas Gregor4825fd72012-10-22 22:50:17 +00001136 return true;
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001137 }
1138
Douglas Gregor1a4761e2011-11-30 23:21:26 +00001139 ModuleFile *F = GlobalSLocEntryMap.find(-ID)->second;
Douglas Gregorf62d43d2011-07-19 16:10:42 +00001140 F->SLocEntryCursor.JumpToBit(F->SLocEntryOffsets[ID - F->SLocEntryBaseID]);
Sebastian Redlc3632732010-10-05 15:59:54 +00001141 llvm::BitstreamCursor &SLocEntryCursor = F->SLocEntryCursor;
Douglas Gregorf62d43d2011-07-19 16:10:42 +00001142 unsigned BaseOffset = F->SLocEntryBaseOffset;
Sebastian Redl9137a522010-07-16 17:50:48 +00001143
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001144 ++NumSLocEntriesRead;
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001145 unsigned Code = SLocEntryCursor.ReadCode();
1146 if (Code == llvm::bitc::END_BLOCK ||
1147 Code == llvm::bitc::ENTER_SUBBLOCK ||
1148 Code == llvm::bitc::DEFINE_ABBREV) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001149 Error("incorrectly-formatted source location entry in AST file");
Douglas Gregor4825fd72012-10-22 22:50:17 +00001150 return true;
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001151 }
1152
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001153 RecordData Record;
1154 const char *BlobStart;
1155 unsigned BlobLen;
1156 switch (SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) {
1157 default:
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001158 Error("incorrectly-formatted source location entry in AST file");
Douglas Gregor4825fd72012-10-22 22:50:17 +00001159 return true;
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001160
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001161 case SM_SLOC_FILE_ENTRY: {
Argyrios Kyrtzidisa4c29b62012-02-20 23:58:07 +00001162 // We will detect whether a file changed and return 'Failure' for it, but
1163 // we will also try to fail gracefully by setting up the SLocEntry.
Douglas Gregora930dc92012-10-22 18:42:04 +00001164 unsigned InputID = Record[4];
1165 InputFile IF = getInputFile(*F, InputID);
1166 const FileEntry *File = IF.getPointer();
1167 bool OverriddenBuffer = IF.getInt();
Argyrios Kyrtzidisa4c29b62012-02-20 23:58:07 +00001168
Douglas Gregora930dc92012-10-22 18:42:04 +00001169 if (!IF.getPointer())
Douglas Gregor4825fd72012-10-22 22:50:17 +00001170 return true;
Douglas Gregor2d52be52010-03-21 22:49:54 +00001171
Douglas Gregorf62d43d2011-07-19 16:10:42 +00001172 SourceLocation IncludeLoc = ReadSourceLocation(*F, Record[1]);
Douglas Gregor72a9ae12011-07-22 16:00:58 +00001173 if (IncludeLoc.isInvalid() && F->Kind != MK_MainFile) {
Douglas Gregorf62d43d2011-07-19 16:10:42 +00001174 // This is the module's main file.
1175 IncludeLoc = getImportLocation(F);
1176 }
Argyrios Kyrtzidisff398962012-07-11 20:59:04 +00001177 SrcMgr::CharacteristicKind
1178 FileCharacter = (SrcMgr::CharacteristicKind)Record[2];
1179 FileID FID = SourceMgr.createFileID(File, IncludeLoc, FileCharacter,
Douglas Gregorf62d43d2011-07-19 16:10:42 +00001180 ID, BaseOffset + Record[0]);
Argyrios Kyrtzidisd9d2b672011-08-21 23:33:04 +00001181 SrcMgr::FileInfo &FileInfo =
1182 const_cast<SrcMgr::FileInfo&>(SourceMgr.getSLocEntry(FID).getFile());
Douglas Gregora930dc92012-10-22 18:42:04 +00001183 FileInfo.NumCreatedFIDs = Record[5];
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001184 if (Record[3])
Argyrios Kyrtzidisd9d2b672011-08-21 23:33:04 +00001185 FileInfo.setHasLineDirectives();
Argyrios Kyrtzidis10f3df52011-10-28 22:54:21 +00001186
Douglas Gregora930dc92012-10-22 18:42:04 +00001187 const DeclID *FirstDecl = F->FileSortedDecls + Record[6];
1188 unsigned NumFileDecls = Record[7];
Argyrios Kyrtzidis10f3df52011-10-28 22:54:21 +00001189 if (NumFileDecls) {
1190 assert(F->FileSortedDecls && "FILE_SORTED_DECLS not encountered yet ?");
Argyrios Kyrtzidis9d128d02011-10-31 07:20:08 +00001191 FileDeclIDs[FID] = FileDeclsInfo(F, llvm::makeArrayRef(FirstDecl,
1192 NumFileDecls));
Argyrios Kyrtzidis10f3df52011-10-28 22:54:21 +00001193 }
Douglas Gregorcfbf1c72011-02-10 17:09:37 +00001194
Douglas Gregor35f9ae62011-11-17 01:44:33 +00001195 const SrcMgr::ContentCache *ContentCache
Argyrios Kyrtzidisff398962012-07-11 20:59:04 +00001196 = SourceMgr.getOrCreateContentCache(File,
1197 /*isSystemFile=*/FileCharacter != SrcMgr::C_User);
Douglas Gregor35f9ae62011-11-17 01:44:33 +00001198 if (OverriddenBuffer && !ContentCache->BufferOverridden &&
1199 ContentCache->ContentsEntry == ContentCache->OrigEntry) {
Douglas Gregora081da52011-11-16 20:05:18 +00001200 unsigned Code = SLocEntryCursor.ReadCode();
1201 Record.clear();
1202 unsigned RecCode
1203 = SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen);
1204
1205 if (RecCode != SM_SLOC_BUFFER_BLOB) {
1206 Error("AST record has invalid code");
Douglas Gregor4825fd72012-10-22 22:50:17 +00001207 return true;
Douglas Gregora081da52011-11-16 20:05:18 +00001208 }
1209
1210 llvm::MemoryBuffer *Buffer
1211 = llvm::MemoryBuffer::getMemBuffer(StringRef(BlobStart, BlobLen - 1),
Douglas Gregora930dc92012-10-22 18:42:04 +00001212 File->getName());
Douglas Gregora081da52011-11-16 20:05:18 +00001213 SourceMgr.overrideFileContents(File, Buffer);
1214 }
Argyrios Kyrtzidisa4c29b62012-02-20 23:58:07 +00001215
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001216 break;
1217 }
1218
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001219 case SM_SLOC_BUFFER_ENTRY: {
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001220 const char *Name = BlobStart;
1221 unsigned Offset = Record[0];
1222 unsigned Code = SLocEntryCursor.ReadCode();
1223 Record.clear();
Mike Stump1eb44332009-09-09 15:08:12 +00001224 unsigned RecCode
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001225 = SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen);
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00001226
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001227 if (RecCode != SM_SLOC_BUFFER_BLOB) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001228 Error("AST record has invalid code");
Douglas Gregor4825fd72012-10-22 22:50:17 +00001229 return true;
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00001230 }
1231
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001232 llvm::MemoryBuffer *Buffer
Douglas Gregora081da52011-11-16 20:05:18 +00001233 = llvm::MemoryBuffer::getMemBuffer(StringRef(BlobStart, BlobLen - 1),
1234 Name);
Douglas Gregorf62d43d2011-07-19 16:10:42 +00001235 FileID BufferID = SourceMgr.createFileIDForMemBuffer(Buffer, ID,
1236 BaseOffset + Offset);
Mike Stump1eb44332009-09-09 15:08:12 +00001237
Douglas Gregor6236a292011-12-02 21:56:05 +00001238 if (strcmp(Name, "<built-in>") == 0 && F->Kind == MK_PCH) {
Sebastian Redl7e9ad8b2010-07-14 17:49:11 +00001239 PCHPredefinesBlock Block = {
1240 BufferID,
Chris Lattner5f9e2722011-07-23 10:55:15 +00001241 StringRef(BlobStart, BlobLen - 1)
Sebastian Redl7e9ad8b2010-07-14 17:49:11 +00001242 };
1243 PCHPredefinesBuffers.push_back(Block);
Douglas Gregor92b059e2009-04-28 20:33:11 +00001244 }
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001245
1246 break;
1247 }
1248
Chandler Carruthf70d12d2011-07-15 07:25:21 +00001249 case SM_SLOC_EXPANSION_ENTRY: {
Sebastian Redlc3632732010-10-05 15:59:54 +00001250 SourceLocation SpellingLoc = ReadSourceLocation(*F, Record[1]);
Chandler Carruthbf340e42011-07-26 03:03:05 +00001251 SourceMgr.createExpansionLoc(SpellingLoc,
Sebastian Redlc3632732010-10-05 15:59:54 +00001252 ReadSourceLocation(*F, Record[2]),
1253 ReadSourceLocation(*F, Record[3]),
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001254 Record[4],
1255 ID,
Douglas Gregorf62d43d2011-07-19 16:10:42 +00001256 BaseOffset + Record[0]);
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001257 break;
Mike Stump1eb44332009-09-09 15:08:12 +00001258 }
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001259 }
1260
Douglas Gregor4825fd72012-10-22 22:50:17 +00001261 return false;
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001262}
1263
Douglas Gregorf62d43d2011-07-19 16:10:42 +00001264/// \brief Find the location where the module F is imported.
Douglas Gregor1a4761e2011-11-30 23:21:26 +00001265SourceLocation ASTReader::getImportLocation(ModuleFile *F) {
Douglas Gregorf62d43d2011-07-19 16:10:42 +00001266 if (F->ImportLoc.isValid())
1267 return F->ImportLoc;
Jonathan D. Turner2e091632011-07-29 18:09:09 +00001268
Douglas Gregorf62d43d2011-07-19 16:10:42 +00001269 // Otherwise we have a PCH. It's considered to be "imported" at the first
1270 // location of its includer.
Jonathan D. Turner2e091632011-07-29 18:09:09 +00001271 if (F->ImportedBy.empty() || !F->ImportedBy[0]) {
Douglas Gregorf62d43d2011-07-19 16:10:42 +00001272 // Main file is the importer. We assume that it is the first entry in the
1273 // entry table. We can't ask the manager, because at the time of PCH loading
1274 // the main file entry doesn't exist yet.
1275 // The very first entry is the invalid instantiation loc, which takes up
1276 // offsets 0 and 1.
1277 return SourceLocation::getFromRawEncoding(2U);
1278 }
Jonathan D. Turner2e091632011-07-29 18:09:09 +00001279 //return F->Loaders[0]->FirstLoc;
1280 return F->ImportedBy[0]->FirstLoc;
Douglas Gregorf62d43d2011-07-19 16:10:42 +00001281}
1282
Chris Lattner6367f6d2009-04-27 01:05:14 +00001283/// ReadBlockAbbrevs - Enter a subblock of the specified BlockID with the
1284/// specified cursor. Read the abbreviations that are at the top of the block
1285/// and then leave the cursor pointing into the block.
Sebastian Redlc43b54c2010-08-18 23:56:43 +00001286bool ASTReader::ReadBlockAbbrevs(llvm::BitstreamCursor &Cursor,
Chris Lattner6367f6d2009-04-27 01:05:14 +00001287 unsigned BlockID) {
1288 if (Cursor.EnterSubBlock(BlockID)) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001289 Error("malformed block record in AST file");
Chris Lattner6367f6d2009-04-27 01:05:14 +00001290 return Failure;
1291 }
Mike Stump1eb44332009-09-09 15:08:12 +00001292
Chris Lattner6367f6d2009-04-27 01:05:14 +00001293 while (true) {
Douglas Gregorecdcb882010-10-20 22:00:55 +00001294 uint64_t Offset = Cursor.GetCurrentBitNo();
Chris Lattner6367f6d2009-04-27 01:05:14 +00001295 unsigned Code = Cursor.ReadCode();
Michael J. Spencer20249a12010-10-21 03:16:25 +00001296
Chris Lattner6367f6d2009-04-27 01:05:14 +00001297 // We expect all abbrevs to be at the start of the block.
Douglas Gregorecdcb882010-10-20 22:00:55 +00001298 if (Code != llvm::bitc::DEFINE_ABBREV) {
1299 Cursor.JumpToBit(Offset);
Chris Lattner6367f6d2009-04-27 01:05:14 +00001300 return false;
Douglas Gregorecdcb882010-10-20 22:00:55 +00001301 }
Chris Lattner6367f6d2009-04-27 01:05:14 +00001302 Cursor.ReadAbbrevRecord();
1303 }
1304}
1305
Douglas Gregor3ab50fe2012-10-11 17:41:54 +00001306void ASTReader::ReadMacroRecord(ModuleFile &F, uint64_t Offset,
1307 MacroInfo *Hint) {
Douglas Gregorecdcb882010-10-20 22:00:55 +00001308 llvm::BitstreamCursor &Stream = F.MacroCursor;
Mike Stump1eb44332009-09-09 15:08:12 +00001309
Douglas Gregor37e26842009-04-21 23:56:24 +00001310 // Keep track of where we are in the stream, then jump back there
1311 // after reading this macro.
1312 SavedStreamPosition SavedPosition(Stream);
1313
1314 Stream.JumpToBit(Offset);
1315 RecordData Record;
Chris Lattner5f9e2722011-07-23 10:55:15 +00001316 SmallVector<IdentifierInfo*, 16> MacroArgs;
Douglas Gregor37e26842009-04-21 23:56:24 +00001317 MacroInfo *Macro = 0;
Mike Stump1eb44332009-09-09 15:08:12 +00001318
Douglas Gregore8219a62012-10-11 21:07:39 +00001319 // RAII object to add the loaded macro information once we're done
1320 // adding tokens.
1321 struct AddLoadedMacroInfoRAII {
1322 Preprocessor &PP;
1323 MacroInfo *Hint;
1324 MacroInfo *MI;
1325 IdentifierInfo *II;
1326
1327 AddLoadedMacroInfoRAII(Preprocessor &PP, MacroInfo *Hint)
1328 : PP(PP), Hint(Hint), MI(), II() { }
1329 ~AddLoadedMacroInfoRAII( ) {
1330 if (MI) {
1331 // Finally, install the macro.
1332 PP.addLoadedMacroInfo(II, MI, Hint);
1333 }
1334 }
1335 } AddLoadedMacroInfo(PP, Hint);
1336
Douglas Gregor37e26842009-04-21 23:56:24 +00001337 while (true) {
1338 unsigned Code = Stream.ReadCode();
1339 switch (Code) {
1340 case llvm::bitc::END_BLOCK:
Douglas Gregor3b2257c2011-08-04 18:09:14 +00001341 return;
Douglas Gregor37e26842009-04-21 23:56:24 +00001342
1343 case llvm::bitc::ENTER_SUBBLOCK:
1344 // No known subblocks, always skip them.
1345 Stream.ReadSubBlockID();
1346 if (Stream.SkipBlock()) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001347 Error("malformed block record in AST file");
Douglas Gregor3b2257c2011-08-04 18:09:14 +00001348 return;
Douglas Gregor37e26842009-04-21 23:56:24 +00001349 }
1350 continue;
Mike Stump1eb44332009-09-09 15:08:12 +00001351
Douglas Gregor37e26842009-04-21 23:56:24 +00001352 case llvm::bitc::DEFINE_ABBREV:
1353 Stream.ReadAbbrevRecord();
1354 continue;
1355 default: break;
1356 }
1357
1358 // Read a record.
Douglas Gregorecdcb882010-10-20 22:00:55 +00001359 const char *BlobStart = 0;
1360 unsigned BlobLen = 0;
Douglas Gregor37e26842009-04-21 23:56:24 +00001361 Record.clear();
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001362 PreprocessorRecordTypes RecType =
Michael J. Spencer20249a12010-10-21 03:16:25 +00001363 (PreprocessorRecordTypes)Stream.ReadRecord(Code, Record, BlobStart,
Douglas Gregorecdcb882010-10-20 22:00:55 +00001364 BlobLen);
Douglas Gregor37e26842009-04-21 23:56:24 +00001365 switch (RecType) {
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001366 case PP_MACRO_OBJECT_LIKE:
1367 case PP_MACRO_FUNCTION_LIKE: {
Douglas Gregor37e26842009-04-21 23:56:24 +00001368 // If we already have a macro, that means that we've hit the end
1369 // of the definition of the macro we were looking for. We're
1370 // done.
1371 if (Macro)
Douglas Gregor3b2257c2011-08-04 18:09:14 +00001372 return;
Douglas Gregor37e26842009-04-21 23:56:24 +00001373
Douglas Gregor95eab172011-07-28 20:55:49 +00001374 IdentifierInfo *II = getLocalIdentifier(F, Record[0]);
Douglas Gregor37e26842009-04-21 23:56:24 +00001375 if (II == 0) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001376 Error("macro must have a name in AST file");
Douglas Gregor3b2257c2011-08-04 18:09:14 +00001377 return;
Douglas Gregor37e26842009-04-21 23:56:24 +00001378 }
Mike Stump1eb44332009-09-09 15:08:12 +00001379
Douglas Gregora8235d62012-10-09 23:05:51 +00001380 unsigned GlobalID = getGlobalMacroID(F, Record[1]);
1381
1382 // If this macro has already been loaded, don't do so again.
1383 if (MacrosLoaded[GlobalID - NUM_PREDEF_MACRO_IDS])
1384 return;
1385
Douglas Gregor6c6c54a2012-10-11 00:46:49 +00001386 SubmoduleID GlobalSubmoduleID = getGlobalSubmoduleID(F, Record[2]);
1387 unsigned NextIndex = 3;
Alexander Kornienko4d7e0ce2012-09-25 17:18:14 +00001388 SourceLocation Loc = ReadSourceLocation(F, Record, NextIndex);
Douglas Gregor712f2fc2011-09-09 22:02:16 +00001389 MacroInfo *MI = PP.AllocateMacroInfo(Loc);
Alexander Kornienko4d7e0ce2012-09-25 17:18:14 +00001390
Douglas Gregora8235d62012-10-09 23:05:51 +00001391 // Record this macro.
1392 MacrosLoaded[GlobalID - NUM_PREDEF_MACRO_IDS] = MI;
1393
Alexander Kornienko4d7e0ce2012-09-25 17:18:14 +00001394 SourceLocation UndefLoc = ReadSourceLocation(F, Record, NextIndex);
1395 if (UndefLoc.isValid())
1396 MI->setUndefLoc(UndefLoc);
1397
1398 MI->setIsUsed(Record[NextIndex++]);
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001399 MI->setIsFromAST();
Mike Stump1eb44332009-09-09 15:08:12 +00001400
Alexander Kornienko4d7e0ce2012-09-25 17:18:14 +00001401 bool IsPublic = Record[NextIndex++];
Douglas Gregoraa93a872011-10-17 15:32:29 +00001402 MI->setVisibility(IsPublic, ReadSourceLocation(F, Record, NextIndex));
Alexander Kornienko4d7e0ce2012-09-25 17:18:14 +00001403
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001404 if (RecType == PP_MACRO_FUNCTION_LIKE) {
Douglas Gregor37e26842009-04-21 23:56:24 +00001405 // Decode function-like macro info.
Douglas Gregor7143aab2011-09-01 17:04:32 +00001406 bool isC99VarArgs = Record[NextIndex++];
1407 bool isGNUVarArgs = Record[NextIndex++];
Douglas Gregor37e26842009-04-21 23:56:24 +00001408 MacroArgs.clear();
Douglas Gregor7143aab2011-09-01 17:04:32 +00001409 unsigned NumArgs = Record[NextIndex++];
Douglas Gregor37e26842009-04-21 23:56:24 +00001410 for (unsigned i = 0; i != NumArgs; ++i)
Douglas Gregor7143aab2011-09-01 17:04:32 +00001411 MacroArgs.push_back(getLocalIdentifier(F, Record[NextIndex++]));
Douglas Gregor37e26842009-04-21 23:56:24 +00001412
1413 // Install function-like macro info.
1414 MI->setIsFunctionLike();
1415 if (isC99VarArgs) MI->setIsC99Varargs();
1416 if (isGNUVarArgs) MI->setIsGNUVarargs();
Douglas Gregor75fdb232009-05-22 22:45:36 +00001417 MI->setArgumentList(MacroArgs.data(), MacroArgs.size(),
Douglas Gregor712f2fc2011-09-09 22:02:16 +00001418 PP.getPreprocessorAllocator());
Douglas Gregor37e26842009-04-21 23:56:24 +00001419 }
1420
Douglas Gregora8235d62012-10-09 23:05:51 +00001421 if (DeserializationListener)
1422 DeserializationListener->MacroRead(GlobalID, MI);
1423
1424 // If an update record marked this as undefined, do so now.
Douglas Gregor6c6c54a2012-10-11 00:46:49 +00001425 // FIXME: Only if the submodule this update came from is visible?
Douglas Gregora8235d62012-10-09 23:05:51 +00001426 MacroUpdatesMap::iterator Update = MacroUpdates.find(GlobalID);
1427 if (Update != MacroUpdates.end()) {
1428 if (MI->getUndefLoc().isInvalid()) {
Douglas Gregor54c8a402012-10-12 00:16:50 +00001429 for (unsigned I = 0, N = Update->second.size(); I != N; ++I) {
1430 bool Hidden = false;
1431 if (unsigned SubmoduleID = Update->second[I].first) {
1432 if (Module *Owner = getSubmodule(SubmoduleID)) {
1433 if (Owner->NameVisibility == Module::Hidden) {
1434 // Note that this #undef is hidden.
1435 Hidden = true;
1436
1437 // Record this hiding for later.
1438 HiddenNamesMap[Owner].push_back(
1439 HiddenName(II, MI, Update->second[I].second.UndefLoc));
1440 }
1441 }
1442 }
1443
1444 if (!Hidden) {
1445 MI->setUndefLoc(Update->second[I].second.UndefLoc);
1446 if (PPMutationListener *Listener = PP.getPPMutationListener())
1447 Listener->UndefinedMacro(MI);
1448 break;
1449 }
1450 }
Douglas Gregora8235d62012-10-09 23:05:51 +00001451 }
1452 MacroUpdates.erase(Update);
1453 }
1454
Douglas Gregor6c6c54a2012-10-11 00:46:49 +00001455 // Determine whether this macro definition is visible.
1456 bool Hidden = !MI->isPublic();
1457 if (!Hidden && GlobalSubmoduleID) {
1458 if (Module *Owner = getSubmodule(GlobalSubmoduleID)) {
1459 if (Owner->NameVisibility == Module::Hidden) {
1460 // The owning module is not visible, and this macro definition
1461 // should not be, either.
1462 Hidden = true;
1463
1464 // Note that this macro definition was hidden because its owning
1465 // module is not yet visible.
1466 HiddenNamesMap[Owner].push_back(HiddenName(II, MI));
1467 }
1468 }
1469 }
1470 MI->setHidden(Hidden);
1471
Douglas Gregore8219a62012-10-11 21:07:39 +00001472 // Make sure we install the macro once we're done.
1473 AddLoadedMacroInfo.MI = MI;
1474 AddLoadedMacroInfo.II = II;
Douglas Gregor37e26842009-04-21 23:56:24 +00001475
1476 // Remember that we saw this macro last so that we add the tokens that
1477 // form its body to it.
1478 Macro = MI;
Michael J. Spencer20249a12010-10-21 03:16:25 +00001479
Argyrios Kyrtzidise24692b2011-09-15 18:02:56 +00001480 if (NextIndex + 1 == Record.size() && PP.getPreprocessingRecord() &&
1481 Record[NextIndex]) {
1482 // We have a macro definition. Register the association
1483 PreprocessedEntityID
1484 GlobalID = getGlobalPreprocessedEntityID(F, Record[NextIndex]);
1485 PreprocessingRecord &PPRec = *PP.getPreprocessingRecord();
1486 PPRec.RegisterMacroDefinition(Macro,
1487 PPRec.getPPEntityID(GlobalID-1, /*isLoaded=*/true));
Douglas Gregor6a5a23f2010-03-19 21:51:54 +00001488 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00001489
Douglas Gregor37e26842009-04-21 23:56:24 +00001490 ++NumMacrosRead;
1491 break;
1492 }
Mike Stump1eb44332009-09-09 15:08:12 +00001493
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001494 case PP_TOKEN: {
Douglas Gregor37e26842009-04-21 23:56:24 +00001495 // If we see a TOKEN before a PP_MACRO_*, then the file is
1496 // erroneous, just pretend we didn't see this.
1497 if (Macro == 0) break;
Mike Stump1eb44332009-09-09 15:08:12 +00001498
Douglas Gregor37e26842009-04-21 23:56:24 +00001499 Token Tok;
1500 Tok.startToken();
Sebastian Redlc3632732010-10-05 15:59:54 +00001501 Tok.setLocation(ReadSourceLocation(F, Record[0]));
Douglas Gregor37e26842009-04-21 23:56:24 +00001502 Tok.setLength(Record[1]);
Douglas Gregor95eab172011-07-28 20:55:49 +00001503 if (IdentifierInfo *II = getLocalIdentifier(F, Record[2]))
Douglas Gregor37e26842009-04-21 23:56:24 +00001504 Tok.setIdentifierInfo(II);
1505 Tok.setKind((tok::TokenKind)Record[3]);
1506 Tok.setFlag((Token::TokenFlags)Record[4]);
1507 Macro->AddTokenToBody(Tok);
1508 break;
1509 }
David Blaikie7530c032012-01-17 06:56:22 +00001510 }
Douglas Gregor4800a5c2011-02-08 21:58:10 +00001511 }
Douglas Gregor37e26842009-04-21 23:56:24 +00001512}
1513
Douglas Gregor86c67d82011-07-28 22:39:26 +00001514PreprocessedEntityID
Douglas Gregor1a4761e2011-11-30 23:21:26 +00001515ASTReader::getGlobalPreprocessedEntityID(ModuleFile &M, unsigned LocalID) const {
Argyrios Kyrtzidis1f6d2252011-09-19 20:40:02 +00001516 ContinuousRangeMap<uint32_t, int, 2>::const_iterator
Douglas Gregor272b6bc2011-08-04 18:56:47 +00001517 I = M.PreprocessedEntityRemap.find(LocalID - NUM_PREDEF_PP_ENTITY_IDS);
1518 assert(I != M.PreprocessedEntityRemap.end()
1519 && "Invalid index into preprocessed entity index remap");
1520
1521 return LocalID + I->second;
Douglas Gregor86c67d82011-07-28 22:39:26 +00001522}
1523
Douglas Gregor98339b92011-08-25 20:47:51 +00001524unsigned HeaderFileInfoTrait::ComputeHash(const char *path) {
1525 return llvm::HashString(llvm::sys::path::filename(path));
Douglas Gregorcfbf1c72011-02-10 17:09:37 +00001526}
Douglas Gregor98339b92011-08-25 20:47:51 +00001527
1528HeaderFileInfoTrait::internal_key_type
1529HeaderFileInfoTrait::GetInternalKey(const char *path) { return path; }
1530
1531bool HeaderFileInfoTrait::EqualKey(internal_key_type a, internal_key_type b) {
1532 if (strcmp(a, b) == 0)
1533 return true;
1534
1535 if (llvm::sys::path::filename(a) != llvm::sys::path::filename(b))
1536 return false;
Douglas Gregor99a922b2011-12-09 16:22:07 +00001537
1538 // Determine whether the actual files are equivalent.
1539 bool Result = false;
1540 if (llvm::sys::fs::equivalent(a, b, Result))
Douglas Gregor98339b92011-08-25 20:47:51 +00001541 return false;
1542
Douglas Gregor99a922b2011-12-09 16:22:07 +00001543 return Result;
Douglas Gregor98339b92011-08-25 20:47:51 +00001544}
1545
1546std::pair<unsigned, unsigned>
1547HeaderFileInfoTrait::ReadKeyDataLength(const unsigned char*& d) {
1548 unsigned KeyLen = (unsigned) clang::io::ReadUnalignedLE16(d);
1549 unsigned DataLen = (unsigned) *d++;
1550 return std::make_pair(KeyLen + 1, DataLen);
1551}
1552
1553HeaderFileInfoTrait::data_type
1554HeaderFileInfoTrait::ReadData(const internal_key_type, const unsigned char *d,
1555 unsigned DataLen) {
1556 const unsigned char *End = d + DataLen;
1557 using namespace clang::io;
1558 HeaderFileInfo HFI;
1559 unsigned Flags = *d++;
1560 HFI.isImport = (Flags >> 5) & 0x01;
1561 HFI.isPragmaOnce = (Flags >> 4) & 0x01;
1562 HFI.DirInfo = (Flags >> 2) & 0x03;
1563 HFI.Resolved = (Flags >> 1) & 0x01;
1564 HFI.IndexHeaderMapHeader = Flags & 0x01;
1565 HFI.NumIncludes = ReadUnalignedLE16(d);
Douglas Gregor541ba162011-10-17 18:53:12 +00001566 HFI.ControllingMacroID = Reader.getGlobalIdentifierID(M,
1567 ReadUnalignedLE32(d));
Douglas Gregor98339b92011-08-25 20:47:51 +00001568 if (unsigned FrameworkOffset = ReadUnalignedLE32(d)) {
1569 // The framework offset is 1 greater than the actual offset,
1570 // since 0 is used as an indicator for "no framework name".
1571 StringRef FrameworkName(FrameworkStrings + FrameworkOffset - 1);
1572 HFI.Framework = HS->getUniqueFrameworkName(FrameworkName);
1573 }
1574
1575 assert(End == d && "Wrong data length in HeaderFileInfo deserialization");
1576 (void)End;
1577
1578 // This HeaderFileInfo was externally loaded.
1579 HFI.External = true;
1580 return HFI;
1581}
Douglas Gregorcfbf1c72011-02-10 17:09:37 +00001582
Douglas Gregor6c6c54a2012-10-11 00:46:49 +00001583void ASTReader::setIdentifierIsMacro(IdentifierInfo *II, ArrayRef<MacroID> IDs){
1584 II->setHadMacroDefinition(true);
1585 assert(NumCurrentElementsDeserializing > 0 &&"Missing deserialization guard");
1586 PendingMacroIDs[II].append(IDs.begin(), IDs.end());
Douglas Gregor295a2a62010-10-30 00:23:06 +00001587}
1588
Sebastian Redlc43b54c2010-08-18 23:56:43 +00001589void ASTReader::ReadDefinedMacros() {
Douglas Gregor6c6c54a2012-10-11 00:46:49 +00001590 // Note that we are loading defined macros.
1591 Deserializing Macros(this);
1592
Jonathan D. Turner5d6d89f2011-07-25 20:32:21 +00001593 for (ModuleReverseIterator I = ModuleMgr.rbegin(),
1594 E = ModuleMgr.rend(); I != E; ++I) {
1595 llvm::BitstreamCursor &MacroCursor = (*I)->MacroCursor;
Sebastian Redl9137a522010-07-16 17:50:48 +00001596
Sebastian Redld27d3fc2010-07-21 22:31:37 +00001597 // If there was no preprocessor block, skip this file.
1598 if (!MacroCursor.getBitStreamReader())
1599 continue;
Kovarththanan Rajaratnam6b82f642010-03-07 19:10:13 +00001600
Sebastian Redld27d3fc2010-07-21 22:31:37 +00001601 llvm::BitstreamCursor Cursor = MacroCursor;
Jonathan D. Turner5d6d89f2011-07-25 20:32:21 +00001602 Cursor.JumpToBit((*I)->MacroStartOffset);
Michael J. Spencer20249a12010-10-21 03:16:25 +00001603
Sebastian Redld27d3fc2010-07-21 22:31:37 +00001604 RecordData Record;
1605 while (true) {
1606 unsigned Code = Cursor.ReadCode();
Douglas Gregorecdcb882010-10-20 22:00:55 +00001607 if (Code == llvm::bitc::END_BLOCK)
Sebastian Redld27d3fc2010-07-21 22:31:37 +00001608 break;
Kovarththanan Rajaratnam6b82f642010-03-07 19:10:13 +00001609
Sebastian Redld27d3fc2010-07-21 22:31:37 +00001610 if (Code == llvm::bitc::ENTER_SUBBLOCK) {
1611 // No known subblocks, always skip them.
1612 Cursor.ReadSubBlockID();
1613 if (Cursor.SkipBlock()) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001614 Error("malformed block record in AST file");
Sebastian Redld27d3fc2010-07-21 22:31:37 +00001615 return;
1616 }
1617 continue;
1618 }
Kovarththanan Rajaratnam6b82f642010-03-07 19:10:13 +00001619
Sebastian Redld27d3fc2010-07-21 22:31:37 +00001620 if (Code == llvm::bitc::DEFINE_ABBREV) {
1621 Cursor.ReadAbbrevRecord();
1622 continue;
1623 }
Kovarththanan Rajaratnam6b82f642010-03-07 19:10:13 +00001624
Sebastian Redld27d3fc2010-07-21 22:31:37 +00001625 // Read a record.
1626 const char *BlobStart;
1627 unsigned BlobLen;
1628 Record.clear();
1629 switch (Cursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) {
1630 default: // Default behavior: ignore.
1631 break;
Douglas Gregor88a35862010-01-04 19:18:44 +00001632
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001633 case PP_MACRO_OBJECT_LIKE:
1634 case PP_MACRO_FUNCTION_LIKE:
Douglas Gregor95eab172011-07-28 20:55:49 +00001635 getLocalIdentifier(**I, Record[0]);
Sebastian Redld27d3fc2010-07-21 22:31:37 +00001636 break;
1637
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001638 case PP_TOKEN:
Sebastian Redld27d3fc2010-07-21 22:31:37 +00001639 // Ignore tokens.
1640 break;
Sebastian Redld27d3fc2010-07-21 22:31:37 +00001641 }
Douglas Gregor88a35862010-01-04 19:18:44 +00001642 }
1643 }
Douglas Gregor295a2a62010-10-30 00:23:06 +00001644}
1645
Douglas Gregoreee242f2011-10-27 09:33:13 +00001646namespace {
1647 /// \brief Visitor class used to look up identifirs in an AST file.
1648 class IdentifierLookupVisitor {
1649 StringRef Name;
Douglas Gregor057df202012-01-18 20:56:22 +00001650 unsigned PriorGeneration;
Douglas Gregoreee242f2011-10-27 09:33:13 +00001651 IdentifierInfo *Found;
1652 public:
Douglas Gregor057df202012-01-18 20:56:22 +00001653 IdentifierLookupVisitor(StringRef Name, unsigned PriorGeneration)
1654 : Name(Name), PriorGeneration(PriorGeneration), Found() { }
Douglas Gregoreee242f2011-10-27 09:33:13 +00001655
Douglas Gregor1a4761e2011-11-30 23:21:26 +00001656 static bool visit(ModuleFile &M, void *UserData) {
Douglas Gregoreee242f2011-10-27 09:33:13 +00001657 IdentifierLookupVisitor *This
1658 = static_cast<IdentifierLookupVisitor *>(UserData);
1659
Douglas Gregor057df202012-01-18 20:56:22 +00001660 // If we've already searched this module file, skip it now.
1661 if (M.Generation <= This->PriorGeneration)
1662 return true;
1663
Douglas Gregoreee242f2011-10-27 09:33:13 +00001664 ASTIdentifierLookupTable *IdTable
1665 = (ASTIdentifierLookupTable *)M.IdentifierLookupTable;
1666 if (!IdTable)
1667 return false;
1668
Douglas Gregor5d5051f2012-01-24 15:24:38 +00001669 ASTIdentifierLookupTrait Trait(IdTable->getInfoObj().getReader(),
1670 M, This->Found);
1671
Douglas Gregoreee242f2011-10-27 09:33:13 +00001672 std::pair<const char*, unsigned> Key(This->Name.begin(),
1673 This->Name.size());
Douglas Gregor5d5051f2012-01-24 15:24:38 +00001674 ASTIdentifierLookupTable::iterator Pos = IdTable->find(Key, &Trait);
Douglas Gregoreee242f2011-10-27 09:33:13 +00001675 if (Pos == IdTable->end())
1676 return false;
1677
1678 // Dereferencing the iterator has the effect of building the
1679 // IdentifierInfo node and populating it with the various
1680 // declarations it needs.
1681 This->Found = *Pos;
1682 return true;
1683 }
1684
1685 // \brief Retrieve the identifier info found within the module
1686 // files.
1687 IdentifierInfo *getIdentifierInfo() const { return Found; }
1688 };
1689}
1690
1691void ASTReader::updateOutOfDateIdentifier(IdentifierInfo &II) {
Douglas Gregor6c6c54a2012-10-11 00:46:49 +00001692 // Note that we are loading an identifier.
1693 Deserializing AnIdentifier(this);
1694
Douglas Gregor057df202012-01-18 20:56:22 +00001695 unsigned PriorGeneration = 0;
David Blaikie4e4d0842012-03-11 07:00:24 +00001696 if (getContext().getLangOpts().Modules)
Douglas Gregor057df202012-01-18 20:56:22 +00001697 PriorGeneration = IdentifierGeneration[&II];
1698
1699 IdentifierLookupVisitor Visitor(II.getName(), PriorGeneration);
1700 ModuleMgr.visit(IdentifierLookupVisitor::visit, &Visitor);
1701 markIdentifierUpToDate(&II);
1702}
1703
1704void ASTReader::markIdentifierUpToDate(IdentifierInfo *II) {
1705 if (!II)
1706 return;
1707
1708 II->setOutOfDate(false);
1709
1710 // Update the generation for this identifier.
David Blaikie4e4d0842012-03-11 07:00:24 +00001711 if (getContext().getLangOpts().Modules)
Douglas Gregor057df202012-01-18 20:56:22 +00001712 IdentifierGeneration[II] = CurrentGeneration;
Douglas Gregoreee242f2011-10-27 09:33:13 +00001713}
1714
Douglas Gregora930dc92012-10-22 18:42:04 +00001715llvm::PointerIntPair<const FileEntry *, 1, bool>
Douglas Gregor38295be2012-10-22 23:51:00 +00001716ASTReader::getInputFile(ModuleFile &F, unsigned ID, bool Complain) {
Douglas Gregora930dc92012-10-22 18:42:04 +00001717 // If this ID is bogus, just return an empty input file.
1718 if (ID == 0 || ID > F.InputFilesLoaded.size())
1719 return InputFile();
1720
1721 // If we've already loaded this input file, return it.
1722 if (F.InputFilesLoaded[ID-1].getPointer())
1723 return F.InputFilesLoaded[ID-1];
1724
1725 // Go find this input file.
1726 llvm::BitstreamCursor &Cursor = F.InputFilesCursor;
1727 SavedStreamPosition SavedPosition(Cursor);
1728 Cursor.JumpToBit(F.InputFileOffsets[ID-1]);
1729
1730 unsigned Code = Cursor.ReadCode();
1731 RecordData Record;
1732 const char *BlobStart = 0;
1733 unsigned BlobLen = 0;
1734 switch ((InputFileRecordTypes)Cursor.ReadRecord(Code, Record,
1735 &BlobStart, &BlobLen)) {
1736 case INPUT_FILE: {
1737 unsigned StoredID = Record[0];
1738 assert(ID == StoredID && "Bogus stored ID or offset");
NAKAMURA Takumi6b8194e2012-10-22 21:50:39 +00001739 (void)StoredID;
Douglas Gregora930dc92012-10-22 18:42:04 +00001740 off_t StoredSize = (off_t)Record[1];
1741 time_t StoredTime = (time_t)Record[2];
1742 bool Overridden = (bool)Record[3];
1743
1744 // Get the file entry for this input file.
1745 StringRef OrigFilename(BlobStart, BlobLen);
1746 std::string Filename = OrigFilename;
1747 MaybeAddSystemRootToFilename(F, Filename);
1748 const FileEntry *File
1749 = Overridden? FileMgr.getVirtualFile(Filename, StoredSize, StoredTime)
1750 : FileMgr.getFile(Filename, /*OpenFile=*/false);
1751
1752 // If we didn't find the file, resolve it relative to the
1753 // original directory from which this AST file was created.
1754 if (File == 0 && !F.OriginalDir.empty() && !CurrentDir.empty() &&
1755 F.OriginalDir != CurrentDir) {
1756 std::string Resolved = resolveFileRelativeToOriginalDir(Filename,
1757 F.OriginalDir,
1758 CurrentDir);
1759 if (!Resolved.empty())
1760 File = FileMgr.getFile(Resolved);
1761 }
1762
1763 // For an overridden file, create a virtual file with the stored
1764 // size/timestamp.
1765 if (Overridden && File == 0) {
1766 File = FileMgr.getVirtualFile(Filename, StoredSize, StoredTime);
1767 }
1768
1769 if (File == 0) {
Douglas Gregor38295be2012-10-22 23:51:00 +00001770 if (Complain) {
1771 std::string ErrorStr = "could not find file '";
1772 ErrorStr += Filename;
1773 ErrorStr += "' referenced by AST file";
1774 Error(ErrorStr.c_str());
1775 }
Douglas Gregora930dc92012-10-22 18:42:04 +00001776 return InputFile();
1777 }
1778
1779 // Note that we've loaded this input file.
1780 F.InputFilesLoaded[ID-1] = InputFile(File, Overridden);
1781
1782 // Check if there was a request to override the contents of the file
1783 // that was part of the precompiled header. Overridding such a file
1784 // can lead to problems when lexing using the source locations from the
1785 // PCH.
1786 SourceManager &SM = getSourceManager();
1787 if (!Overridden && SM.isFileOverridden(File)) {
1788 Error(diag::err_fe_pch_file_overridden, Filename);
1789 // After emitting the diagnostic, recover by disabling the override so
1790 // that the original file will be used.
1791 SM.disableFileContentsOverride(File);
1792 // The FileEntry is a virtual file entry with the size of the contents
1793 // that would override the original contents. Set it to the original's
1794 // size/time.
1795 FileMgr.modifyFileEntry(const_cast<FileEntry*>(File),
1796 StoredSize, StoredTime);
1797 }
1798
1799 // For an overridden file, there is nothing to validate.
1800 if (Overridden)
1801 return InputFile(File, Overridden);
1802
1803 // The stat info from the FileEntry came from the cached stat
1804 // info of the PCH, so we cannot trust it.
1805 struct stat StatBuf;
1806 if (::stat(File->getName(), &StatBuf) != 0) {
1807 StatBuf.st_size = File->getSize();
1808 StatBuf.st_mtime = File->getModificationTime();
1809 }
1810
1811 if ((StoredSize != StatBuf.st_size
1812#if !defined(LLVM_ON_WIN32)
1813 // In our regression testing, the Windows file system seems to
1814 // have inconsistent modification times that sometimes
1815 // erroneously trigger this error-handling path.
1816 || StoredTime != StatBuf.st_mtime
1817#endif
1818 )) {
Douglas Gregor38295be2012-10-22 23:51:00 +00001819 if (Complain)
1820 Error(diag::err_fe_pch_file_modified, Filename);
1821
Douglas Gregora930dc92012-10-22 18:42:04 +00001822 return InputFile();
1823 }
1824
1825 return InputFile(File, Overridden);
1826 }
1827 }
1828
1829 return InputFile();
1830}
1831
Chris Lattner5f9e2722011-07-23 10:55:15 +00001832const FileEntry *ASTReader::getFileEntry(StringRef filenameStrRef) {
Douglas Gregor69e16082012-10-18 21:47:16 +00001833 ModuleFile &M = ModuleMgr.getPrimaryModule();
Argyrios Kyrtzidisb68ffb12011-06-01 05:43:53 +00001834 std::string Filename = filenameStrRef;
Douglas Gregor69e16082012-10-18 21:47:16 +00001835 MaybeAddSystemRootToFilename(M, Filename);
Argyrios Kyrtzidisb68ffb12011-06-01 05:43:53 +00001836 const FileEntry *File = FileMgr.getFile(Filename);
Douglas Gregor69e16082012-10-18 21:47:16 +00001837 if (File == 0 && !M.OriginalDir.empty() && !CurrentDir.empty() &&
1838 M.OriginalDir != CurrentDir) {
Argyrios Kyrtzidisb68ffb12011-06-01 05:43:53 +00001839 std::string resolved = resolveFileRelativeToOriginalDir(Filename,
Douglas Gregor69e16082012-10-18 21:47:16 +00001840 M.OriginalDir,
Argyrios Kyrtzidisb68ffb12011-06-01 05:43:53 +00001841 CurrentDir);
1842 if (!resolved.empty())
1843 File = FileMgr.getFile(resolved);
1844 }
1845
1846 return File;
1847}
1848
Douglas Gregore650c8c2009-07-07 00:12:59 +00001849/// \brief If we are loading a relocatable PCH file, and the filename is
1850/// not an absolute path, add the system root to the beginning of the file
1851/// name.
Douglas Gregora930dc92012-10-22 18:42:04 +00001852StringRef ASTReader::MaybeAddSystemRootToFilename(ModuleFile &M,
1853 std::string &Filename) {
Douglas Gregore650c8c2009-07-07 00:12:59 +00001854 // If this is not a relocatable PCH file, there's nothing to do.
Douglas Gregorcaed0602012-10-18 21:31:35 +00001855 if (!M.RelocatablePCH)
Douglas Gregora930dc92012-10-22 18:42:04 +00001856 return Filename;
Mike Stump1eb44332009-09-09 15:08:12 +00001857
Michael J. Spencer256053b2010-12-17 21:22:22 +00001858 if (Filename.empty() || llvm::sys::path::is_absolute(Filename))
Douglas Gregora930dc92012-10-22 18:42:04 +00001859 return Filename;
Douglas Gregore650c8c2009-07-07 00:12:59 +00001860
Douglas Gregor832d6202011-07-22 16:35:34 +00001861 if (isysroot.empty()) {
Douglas Gregore650c8c2009-07-07 00:12:59 +00001862 // If no system root was given, default to '/'
1863 Filename.insert(Filename.begin(), '/');
Douglas Gregora930dc92012-10-22 18:42:04 +00001864 return Filename;
Douglas Gregore650c8c2009-07-07 00:12:59 +00001865 }
Mike Stump1eb44332009-09-09 15:08:12 +00001866
Douglas Gregor832d6202011-07-22 16:35:34 +00001867 unsigned Length = isysroot.size();
Douglas Gregore650c8c2009-07-07 00:12:59 +00001868 if (isysroot[Length - 1] != '/')
1869 Filename.insert(Filename.begin(), '/');
Mike Stump1eb44332009-09-09 15:08:12 +00001870
Douglas Gregor832d6202011-07-22 16:35:34 +00001871 Filename.insert(Filename.begin(), isysroot.begin(), isysroot.end());
Douglas Gregora930dc92012-10-22 18:42:04 +00001872 return Filename;
Douglas Gregore650c8c2009-07-07 00:12:59 +00001873}
1874
Douglas Gregor38295be2012-10-22 23:51:00 +00001875ASTReader::ASTReadResult
1876ASTReader::ReadControlBlock(ModuleFile &F,
1877 llvm::SmallVectorImpl<ModuleFile *> &Loaded,
1878 unsigned ClientLoadCapabilities) {
Douglas Gregor1d9d9892012-10-18 05:31:06 +00001879 llvm::BitstreamCursor &Stream = F.Stream;
1880
1881 if (Stream.EnterSubBlock(CONTROL_BLOCK_ID)) {
1882 Error("malformed block record in AST file");
1883 return Failure;
1884 }
1885
1886 // Read all of the records and blocks in the control block.
1887 RecordData Record;
1888 while (!Stream.AtEndOfStream()) {
1889 unsigned Code = Stream.ReadCode();
1890 if (Code == llvm::bitc::END_BLOCK) {
1891 if (Stream.ReadBlockEnd()) {
1892 Error("error at end of control block in AST file");
1893 return Failure;
1894 }
1895
Douglas Gregora930dc92012-10-22 18:42:04 +00001896 // Validate all of the input files.
1897 if (!DisableValidation) {
Douglas Gregor38295be2012-10-22 23:51:00 +00001898 bool Complain = (ClientLoadCapabilities & ARR_OutOfDate) == 0;
Douglas Gregora930dc92012-10-22 18:42:04 +00001899 for (unsigned I = 0, N = Record[0]; I < N; ++I)
Douglas Gregor38295be2012-10-22 23:51:00 +00001900 if (!getInputFile(F, I+1, Complain).getPointer())
Douglas Gregor4825fd72012-10-22 22:50:17 +00001901 return OutOfDate;
Douglas Gregora930dc92012-10-22 18:42:04 +00001902 }
1903
Douglas Gregor1d9d9892012-10-18 05:31:06 +00001904 return Success;
1905 }
1906
1907 if (Code == llvm::bitc::ENTER_SUBBLOCK) {
Douglas Gregor745e6f12012-10-19 00:38:02 +00001908 switch (Stream.ReadSubBlockID()) {
1909 case INPUT_FILES_BLOCK_ID:
Douglas Gregora930dc92012-10-22 18:42:04 +00001910 F.InputFilesCursor = Stream;
1911 if (Stream.SkipBlock() || // Skip with the main cursor
1912 // Read the abbreviations
1913 ReadBlockAbbrevs(F.InputFilesCursor, INPUT_FILES_BLOCK_ID)) {
1914 Error("malformed block record in AST file");
Douglas Gregor745e6f12012-10-19 00:38:02 +00001915 return Failure;
Douglas Gregor745e6f12012-10-19 00:38:02 +00001916 }
Douglas Gregor1d9d9892012-10-18 05:31:06 +00001917 continue;
Douglas Gregor745e6f12012-10-19 00:38:02 +00001918
1919 default:
1920 if (!Stream.SkipBlock())
1921 continue;
1922 break;
1923 }
Douglas Gregor1d9d9892012-10-18 05:31:06 +00001924
1925 Error("malformed block record in AST file");
1926 return Failure;
1927 }
1928
1929 if (Code == llvm::bitc::DEFINE_ABBREV) {
1930 Stream.ReadAbbrevRecord();
1931 continue;
1932 }
1933
1934 // Read and process a record.
1935 Record.clear();
1936 const char *BlobStart = 0;
1937 unsigned BlobLen = 0;
1938 switch ((ControlRecordTypes)Stream.ReadRecord(Code, Record,
1939 &BlobStart, &BlobLen)) {
1940 case METADATA: {
1941 if (Record[0] != VERSION_MAJOR && !DisableValidation) {
Douglas Gregor38295be2012-10-22 23:51:00 +00001942 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
1943 Diag(Record[0] < VERSION_MAJOR? diag::warn_pch_version_too_old
1944 : diag::warn_pch_version_too_new);
Douglas Gregor4825fd72012-10-22 22:50:17 +00001945 return VersionMismatch;
Douglas Gregor1d9d9892012-10-18 05:31:06 +00001946 }
1947
1948 bool hasErrors = Record[5];
1949 if (hasErrors && !DisableValidation && !AllowASTWithCompilerErrors) {
1950 Diag(diag::err_pch_with_compiler_errors);
Douglas Gregor4825fd72012-10-22 22:50:17 +00001951 return HadErrors;
Douglas Gregor1d9d9892012-10-18 05:31:06 +00001952 }
1953
Douglas Gregorcaed0602012-10-18 21:31:35 +00001954 F.RelocatablePCH = Record[4];
Douglas Gregor7ae467f2012-10-18 18:27:37 +00001955
1956 const std::string &CurBranch = getClangFullRepositoryVersion();
1957 StringRef ASTBranch(BlobStart, BlobLen);
1958 if (StringRef(CurBranch) != ASTBranch && !DisableValidation) {
Douglas Gregor38295be2012-10-22 23:51:00 +00001959 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
1960 Diag(diag::warn_pch_different_branch) << ASTBranch << CurBranch;
Douglas Gregor4825fd72012-10-22 22:50:17 +00001961 return VersionMismatch;
Douglas Gregor7ae467f2012-10-18 18:27:37 +00001962 }
Douglas Gregor1d9d9892012-10-18 05:31:06 +00001963 break;
1964 }
1965
1966 case IMPORTS: {
1967 // Load each of the imported PCH files.
1968 unsigned Idx = 0, N = Record.size();
1969 while (Idx < N) {
1970 // Read information about the AST file.
1971 ModuleKind ImportedKind = (ModuleKind)Record[Idx++];
1972 unsigned Length = Record[Idx++];
1973 SmallString<128> ImportedFile(Record.begin() + Idx,
1974 Record.begin() + Idx + Length);
1975 Idx += Length;
1976
1977 // Load the AST file.
Douglas Gregor38295be2012-10-22 23:51:00 +00001978 switch(ReadASTCore(ImportedFile, ImportedKind, &F, Loaded,
1979 ClientLoadCapabilities)) {
Douglas Gregor1d9d9892012-10-18 05:31:06 +00001980 case Failure: return Failure;
1981 // If we have to ignore the dependency, we'll have to ignore this too.
Douglas Gregor4825fd72012-10-22 22:50:17 +00001982 case OutOfDate: return OutOfDate;
1983 case VersionMismatch: return VersionMismatch;
1984 case ConfigurationMismatch: return ConfigurationMismatch;
1985 case HadErrors: return HadErrors;
Douglas Gregor1d9d9892012-10-18 05:31:06 +00001986 case Success: break;
1987 }
1988 }
1989 break;
1990 }
1991
Douglas Gregor38295be2012-10-22 23:51:00 +00001992 case LANGUAGE_OPTIONS: {
1993 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
1994 if (Listener && &F == *ModuleMgr.begin() &&
Douglas Gregor27ffa6c2012-10-23 06:18:24 +00001995 ParseLanguageOptions(Record, Complain, *Listener) &&
1996 !DisableValidation)
Douglas Gregor4825fd72012-10-22 22:50:17 +00001997 return ConfigurationMismatch;
Douglas Gregor1d9d9892012-10-18 05:31:06 +00001998 break;
Douglas Gregor38295be2012-10-22 23:51:00 +00001999 }
Douglas Gregor1d9d9892012-10-18 05:31:06 +00002000
Douglas Gregoree097c12012-10-18 17:58:09 +00002001 case TARGET_OPTIONS: {
Douglas Gregor27ffa6c2012-10-23 06:18:24 +00002002 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch)==0;
2003 if (Listener && &F == *ModuleMgr.begin() &&
2004 ParseTargetOptions(Record, Complain, *Listener) &&
2005 !DisableValidation)
2006 return ConfigurationMismatch;
Douglas Gregoree097c12012-10-18 17:58:09 +00002007 break;
2008 }
2009
Douglas Gregor5f3d8222012-10-24 15:17:15 +00002010 case DIAGNOSTIC_OPTIONS: {
2011 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch)==0;
2012 if (Listener && &F == *ModuleMgr.begin() &&
2013 ParseDiagnosticOptions(Record, Complain, *Listener) &&
2014 !DisableValidation)
2015 return ConfigurationMismatch;
2016 break;
2017 }
Douglas Gregor1b2c3c02012-10-24 15:49:58 +00002018
2019 case FILE_SYSTEM_OPTIONS: {
2020 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch)==0;
2021 if (Listener && &F == *ModuleMgr.begin() &&
2022 ParseFileSystemOptions(Record, Complain, *Listener) &&
2023 !DisableValidation)
2024 return ConfigurationMismatch;
2025 break;
2026 }
2027
Douglas Gregor39c497b2012-10-18 18:36:53 +00002028 case ORIGINAL_FILE:
Douglas Gregor69e16082012-10-18 21:47:16 +00002029 F.OriginalSourceFileID = FileID::get(Record[0]);
2030 F.ActualOriginalSourceFileName.assign(BlobStart, BlobLen);
2031 F.OriginalSourceFileName = F.ActualOriginalSourceFileName;
2032 MaybeAddSystemRootToFilename(F, F.OriginalSourceFileName);
Douglas Gregor1d9d9892012-10-18 05:31:06 +00002033 break;
2034
Douglas Gregor1d9d9892012-10-18 05:31:06 +00002035 case ORIGINAL_PCH_DIR:
Douglas Gregor69e16082012-10-18 21:47:16 +00002036 F.OriginalDir.assign(BlobStart, BlobLen);
Douglas Gregor1d9d9892012-10-18 05:31:06 +00002037 break;
Douglas Gregor1d9d9892012-10-18 05:31:06 +00002038
Douglas Gregora930dc92012-10-22 18:42:04 +00002039 case INPUT_FILE_OFFSETS:
2040 F.InputFileOffsets = (const uint32_t *)BlobStart;
2041 F.InputFilesLoaded.resize(Record[0]);
Douglas Gregor745e6f12012-10-19 00:38:02 +00002042 break;
2043 }
Douglas Gregor745e6f12012-10-19 00:38:02 +00002044 }
2045
2046 Error("premature end of bitstream in AST file");
2047 return Failure;
2048}
2049
Douglas Gregor4825fd72012-10-22 22:50:17 +00002050bool ASTReader::ReadASTBlock(ModuleFile &F) {
Sebastian Redl9137a522010-07-16 17:50:48 +00002051 llvm::BitstreamCursor &Stream = F.Stream;
2052
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002053 if (Stream.EnterSubBlock(AST_BLOCK_ID)) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002054 Error("malformed block record in AST file");
Douglas Gregor4825fd72012-10-22 22:50:17 +00002055 return true;
Douglas Gregor0a0428e2009-04-10 20:39:37 +00002056 }
Douglas Gregor2cf26342009-04-09 22:27:44 +00002057
Douglas Gregor1d9d9892012-10-18 05:31:06 +00002058 // Read all of the records and blocks for the AST file.
Douglas Gregor8038d512009-04-10 17:25:41 +00002059 RecordData Record;
Douglas Gregor2cf26342009-04-09 22:27:44 +00002060 while (!Stream.AtEndOfStream()) {
2061 unsigned Code = Stream.ReadCode();
2062 if (Code == llvm::bitc::END_BLOCK) {
Douglas Gregor0a0428e2009-04-10 20:39:37 +00002063 if (Stream.ReadBlockEnd()) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002064 Error("error at end of module block in AST file");
Douglas Gregor4825fd72012-10-22 22:50:17 +00002065 return true;
Douglas Gregor0a0428e2009-04-10 20:39:37 +00002066 }
Chris Lattner7356a312009-04-11 21:15:38 +00002067
Argyrios Kyrtzidis1f941242012-09-21 01:30:00 +00002068 DeclContext *DC = Context.getTranslationUnitDecl();
2069 if (!DC->hasExternalVisibleStorage() && DC->hasExternalLexicalStorage())
2070 DC->setMustBuildLookupTable();
2071
Douglas Gregor4825fd72012-10-22 22:50:17 +00002072 return false;
Douglas Gregor2cf26342009-04-09 22:27:44 +00002073 }
2074
2075 if (Code == llvm::bitc::ENTER_SUBBLOCK) {
2076 switch (Stream.ReadSubBlockID()) {
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002077 case DECLTYPES_BLOCK_ID:
Chris Lattner6367f6d2009-04-27 01:05:14 +00002078 // We lazily load the decls block, but we want to set up the
2079 // DeclsCursor cursor to point into it. Clone our current bitcode
2080 // cursor to it, enter the block and read the abbrevs in that block.
2081 // With the main cursor, we just skip over it.
Sebastian Redl9137a522010-07-16 17:50:48 +00002082 F.DeclsCursor = Stream;
Chris Lattner6367f6d2009-04-27 01:05:14 +00002083 if (Stream.SkipBlock() || // Skip with the main cursor.
2084 // Read the abbrevs.
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002085 ReadBlockAbbrevs(F.DeclsCursor, DECLTYPES_BLOCK_ID)) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002086 Error("malformed block record in AST file");
Douglas Gregor4825fd72012-10-22 22:50:17 +00002087 return true;
Chris Lattner6367f6d2009-04-27 01:05:14 +00002088 }
2089 break;
Mike Stump1eb44332009-09-09 15:08:12 +00002090
Argyrios Kyrtzidis7b903402010-10-24 17:26:36 +00002091 case DECL_UPDATES_BLOCK_ID:
2092 if (Stream.SkipBlock()) {
2093 Error("malformed block record in AST file");
Douglas Gregor4825fd72012-10-22 22:50:17 +00002094 return true;
Argyrios Kyrtzidis7b903402010-10-24 17:26:36 +00002095 }
2096 break;
2097
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002098 case PREPROCESSOR_BLOCK_ID:
Sebastian Redl9137a522010-07-16 17:50:48 +00002099 F.MacroCursor = Stream;
Douglas Gregor712f2fc2011-09-09 22:02:16 +00002100 if (!PP.getExternalSource())
2101 PP.setExternalSource(this);
Douglas Gregor88a35862010-01-04 19:18:44 +00002102
Douglas Gregorecdcb882010-10-20 22:00:55 +00002103 if (Stream.SkipBlock() ||
2104 ReadBlockAbbrevs(F.MacroCursor, PREPROCESSOR_BLOCK_ID)) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002105 Error("malformed block record in AST file");
Douglas Gregor4825fd72012-10-22 22:50:17 +00002106 return true;
Chris Lattner7356a312009-04-11 21:15:38 +00002107 }
Douglas Gregorecdcb882010-10-20 22:00:55 +00002108 F.MacroStartOffset = F.MacroCursor.GetCurrentBitNo();
Chris Lattner7356a312009-04-11 21:15:38 +00002109 break;
Steve Naroff90cd1bb2009-04-23 10:39:46 +00002110
Douglas Gregor4800a5c2011-02-08 21:58:10 +00002111 case PREPROCESSOR_DETAIL_BLOCK_ID:
2112 F.PreprocessorDetailCursor = Stream;
2113 if (Stream.SkipBlock() ||
2114 ReadBlockAbbrevs(F.PreprocessorDetailCursor,
2115 PREPROCESSOR_DETAIL_BLOCK_ID)) {
2116 Error("malformed preprocessor detail record in AST file");
Douglas Gregor4825fd72012-10-22 22:50:17 +00002117 return true;
Douglas Gregor4800a5c2011-02-08 21:58:10 +00002118 }
2119 F.PreprocessorDetailStartOffset
2120 = F.PreprocessorDetailCursor.GetCurrentBitNo();
Douglas Gregor712f2fc2011-09-09 22:02:16 +00002121
2122 if (!PP.getPreprocessingRecord())
Argyrios Kyrtzidisc6c54522012-03-05 05:48:17 +00002123 PP.createPreprocessingRecord(/*RecordConditionalDirectives=*/false);
Douglas Gregor712f2fc2011-09-09 22:02:16 +00002124 if (!PP.getPreprocessingRecord()->getExternalSource())
2125 PP.getPreprocessingRecord()->SetExternalSource(*this);
Douglas Gregor4800a5c2011-02-08 21:58:10 +00002126 break;
2127
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002128 case SOURCE_MANAGER_BLOCK_ID:
Douglas Gregor4825fd72012-10-22 22:50:17 +00002129 if (ReadSourceManagerBlock(F))
2130 return true;
Douglas Gregor14f79002009-04-10 03:52:48 +00002131 break;
Douglas Gregor392ed2b2011-11-30 17:33:56 +00002132
2133 case SUBMODULE_BLOCK_ID:
Douglas Gregor4825fd72012-10-22 22:50:17 +00002134 if (ReadSubmoduleBlock(F))
2135 return true;
Douglas Gregor392ed2b2011-11-30 17:33:56 +00002136 break;
2137
Dmitri Gribenkoaa0cd852012-06-20 00:34:58 +00002138 case COMMENTS_BLOCK_ID: {
2139 llvm::BitstreamCursor C = Stream;
2140 if (Stream.SkipBlock() ||
2141 ReadBlockAbbrevs(C, COMMENTS_BLOCK_ID)) {
2142 Error("malformed comments block in AST file");
Douglas Gregor4825fd72012-10-22 22:50:17 +00002143 return true;
Dmitri Gribenkoaa0cd852012-06-20 00:34:58 +00002144 }
2145 CommentsCursors.push_back(std::make_pair(C, &F));
2146 break;
2147 }
2148
Douglas Gregor392ed2b2011-11-30 17:33:56 +00002149 default:
2150 if (!Stream.SkipBlock())
2151 break;
2152 Error("malformed block record in AST file");
Douglas Gregor4825fd72012-10-22 22:50:17 +00002153 return true;
Douglas Gregor2cf26342009-04-09 22:27:44 +00002154 }
Douglas Gregor8038d512009-04-10 17:25:41 +00002155 continue;
2156 }
2157
2158 if (Code == llvm::bitc::DEFINE_ABBREV) {
2159 Stream.ReadAbbrevRecord();
2160 continue;
2161 }
2162
2163 // Read and process a record.
2164 Record.clear();
Douglas Gregor2bec0412009-04-10 21:16:55 +00002165 const char *BlobStart = 0;
2166 unsigned BlobLen = 0;
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002167 switch ((ASTRecordTypes)Stream.ReadRecord(Code, Record,
Sebastian Redlc3632732010-10-05 15:59:54 +00002168 &BlobStart, &BlobLen)) {
Douglas Gregor8038d512009-04-10 17:25:41 +00002169 default: // Default behavior: ignore.
2170 break;
2171
Douglas Gregora119da02011-08-02 16:26:37 +00002172 case TYPE_OFFSET: {
Sebastian Redl12d6da02010-07-19 22:06:55 +00002173 if (F.LocalNumTypes != 0) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002174 Error("duplicate TYPE_OFFSET record in AST file");
Douglas Gregor4825fd72012-10-22 22:50:17 +00002175 return true;
Douglas Gregor0a0428e2009-04-10 20:39:37 +00002176 }
Sebastian Redl12d6da02010-07-19 22:06:55 +00002177 F.TypeOffsets = (const uint32_t *)BlobStart;
2178 F.LocalNumTypes = Record[0];
Douglas Gregore3605012011-08-02 18:32:54 +00002179 unsigned LocalBaseTypeIndex = Record[1];
2180 F.BaseTypeIndex = getTotalNumTypes();
Douglas Gregor1e849b62011-07-29 00:21:44 +00002181
Douglas Gregora119da02011-08-02 16:26:37 +00002182 if (F.LocalNumTypes > 0) {
2183 // Introduce the global -> local mapping for types within this module.
2184 GlobalTypeMap.insert(std::make_pair(getTotalNumTypes(), &F));
2185
2186 // Introduce the local -> global mapping for types within this module.
Douglas Gregoradafc2e2011-12-19 16:14:14 +00002187 F.TypeRemap.insertOrReplace(
2188 std::make_pair(LocalBaseTypeIndex,
2189 F.BaseTypeIndex - LocalBaseTypeIndex));
Douglas Gregora119da02011-08-02 16:26:37 +00002190
2191 TypesLoaded.resize(TypesLoaded.size() + F.LocalNumTypes);
2192 }
Douglas Gregor8038d512009-04-10 17:25:41 +00002193 break;
Douglas Gregora119da02011-08-02 16:26:37 +00002194 }
2195
Douglas Gregor496c7092011-08-03 15:48:04 +00002196 case DECL_OFFSET: {
Sebastian Redl12d6da02010-07-19 22:06:55 +00002197 if (F.LocalNumDecls != 0) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002198 Error("duplicate DECL_OFFSET record in AST file");
Douglas Gregor4825fd72012-10-22 22:50:17 +00002199 return true;
Douglas Gregor0a0428e2009-04-10 20:39:37 +00002200 }
Argyrios Kyrtzidis9d31fa72011-10-27 18:47:35 +00002201 F.DeclOffsets = (const DeclOffset *)BlobStart;
Sebastian Redl12d6da02010-07-19 22:06:55 +00002202 F.LocalNumDecls = Record[0];
Douglas Gregor496c7092011-08-03 15:48:04 +00002203 unsigned LocalBaseDeclID = Record[1];
Douglas Gregor9827a802011-07-29 00:56:45 +00002204 F.BaseDeclID = getTotalNumDecls();
Douglas Gregor96e973f2011-07-20 00:27:43 +00002205
Douglas Gregor496c7092011-08-03 15:48:04 +00002206 if (F.LocalNumDecls > 0) {
2207 // Introduce the global -> local mapping for declarations within this
2208 // module.
Douglas Gregor6bf2b9f2011-08-12 00:15:20 +00002209 GlobalDeclMap.insert(
2210 std::make_pair(getTotalNumDecls() + NUM_PREDEF_DECL_IDS, &F));
Douglas Gregor496c7092011-08-03 15:48:04 +00002211
2212 // Introduce the local -> global mapping for declarations within this
2213 // module.
Douglas Gregoradafc2e2011-12-19 16:14:14 +00002214 F.DeclRemap.insertOrReplace(
2215 std::make_pair(LocalBaseDeclID, F.BaseDeclID - LocalBaseDeclID));
Douglas Gregor496c7092011-08-03 15:48:04 +00002216
Douglas Gregora1be2782011-12-17 23:38:30 +00002217 // Introduce the global -> local mapping for declarations within this
2218 // module.
2219 F.GlobalToLocalDeclIDs[&F] = LocalBaseDeclID;
2220
Douglas Gregor496c7092011-08-03 15:48:04 +00002221 DeclsLoaded.resize(DeclsLoaded.size() + F.LocalNumDecls);
2222 }
Douglas Gregor8038d512009-04-10 17:25:41 +00002223 break;
Douglas Gregor496c7092011-08-03 15:48:04 +00002224 }
2225
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002226 case TU_UPDATE_LEXICAL: {
Douglas Gregor35942772011-09-09 21:34:22 +00002227 DeclContext *TU = Context.getTranslationUnitDecl();
Douglas Gregor0d95f772011-08-24 19:03:07 +00002228 DeclContextInfo &Info = F.DeclContextInfos[TU];
2229 Info.LexicalDecls = reinterpret_cast<const KindDeclIDPair *>(BlobStart);
2230 Info.NumLexicalDecls
2231 = static_cast<unsigned int>(BlobLen / sizeof(KindDeclIDPair));
Douglas Gregor35942772011-09-09 21:34:22 +00002232 TU->setHasExternalLexicalStorage(true);
Sebastian Redld692af72010-07-27 18:24:41 +00002233 break;
2234 }
2235
Sebastian Redle1dde812010-08-24 00:50:04 +00002236 case UPDATE_VISIBLE: {
Douglas Gregor496c7092011-08-03 15:48:04 +00002237 unsigned Idx = 0;
2238 serialization::DeclID ID = ReadDeclID(F, Record, Idx);
Benjamin Kramerb1758c62012-04-15 12:36:49 +00002239 ASTDeclContextNameLookupTable *Table =
2240 ASTDeclContextNameLookupTable::Create(
Douglas Gregor496c7092011-08-03 15:48:04 +00002241 (const unsigned char *)BlobStart + Record[Idx++],
Sebastian Redle1dde812010-08-24 00:50:04 +00002242 (const unsigned char *)BlobStart,
Douglas Gregor393f2492011-07-22 00:38:23 +00002243 ASTDeclContextNameLookupTrait(*this, F));
Douglas Gregor35942772011-09-09 21:34:22 +00002244 if (ID == PREDEF_DECL_TRANSLATION_UNIT_ID) { // Is it the TU?
2245 DeclContext *TU = Context.getTranslationUnitDecl();
Douglas Gregor0d95f772011-08-24 19:03:07 +00002246 F.DeclContextInfos[TU].NameLookupTableData = Table;
Douglas Gregor6bf2b9f2011-08-12 00:15:20 +00002247 TU->setHasExternalVisibleStorage(true);
Sebastian Redle1dde812010-08-24 00:50:04 +00002248 } else
Douglas Gregor496c7092011-08-03 15:48:04 +00002249 PendingVisibleUpdates[ID].push_back(std::make_pair(Table, &F));
Sebastian Redle1dde812010-08-24 00:50:04 +00002250 break;
2251 }
2252
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002253 case IDENTIFIER_TABLE:
Sebastian Redl93fb9ed2010-07-19 20:52:06 +00002254 F.IdentifierTableData = BlobStart;
Douglas Gregor2b3a5a82009-04-25 19:10:14 +00002255 if (Record[0]) {
Sebastian Redl93fb9ed2010-07-19 20:52:06 +00002256 F.IdentifierLookupTable
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002257 = ASTIdentifierLookupTable::Create(
Sebastian Redl93fb9ed2010-07-19 20:52:06 +00002258 (const unsigned char *)F.IdentifierTableData + Record[0],
2259 (const unsigned char *)F.IdentifierTableData,
Sebastian Redlc3632732010-10-05 15:59:54 +00002260 ASTIdentifierLookupTrait(*this, F));
Douglas Gregor712f2fc2011-09-09 22:02:16 +00002261
2262 PP.getIdentifierTable().setExternalIdentifierLookup(this);
Douglas Gregor2b3a5a82009-04-25 19:10:14 +00002263 }
Douglas Gregorafaf3082009-04-11 00:14:32 +00002264 break;
2265
Douglas Gregor6ec60e02011-08-03 21:49:18 +00002266 case IDENTIFIER_OFFSET: {
Sebastian Redl2da08f92010-07-19 22:28:42 +00002267 if (F.LocalNumIdentifiers != 0) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002268 Error("duplicate IDENTIFIER_OFFSET record in AST file");
Douglas Gregor4825fd72012-10-22 22:50:17 +00002269 return true;
Douglas Gregorafaf3082009-04-11 00:14:32 +00002270 }
Sebastian Redl2da08f92010-07-19 22:28:42 +00002271 F.IdentifierOffsets = (const uint32_t *)BlobStart;
2272 F.LocalNumIdentifiers = Record[0];
Douglas Gregor6ec60e02011-08-03 21:49:18 +00002273 unsigned LocalBaseIdentifierID = Record[1];
Douglas Gregor9827a802011-07-29 00:56:45 +00002274 F.BaseIdentifierID = getTotalNumIdentifiers();
Douglas Gregor67268d02011-07-20 00:59:32 +00002275
Douglas Gregor6ec60e02011-08-03 21:49:18 +00002276 if (F.LocalNumIdentifiers > 0) {
2277 // Introduce the global -> local mapping for identifiers within this
2278 // module.
2279 GlobalIdentifierMap.insert(std::make_pair(getTotalNumIdentifiers() + 1,
2280 &F));
2281
2282 // Introduce the local -> global mapping for identifiers within this
2283 // module.
Douglas Gregoradafc2e2011-12-19 16:14:14 +00002284 F.IdentifierRemap.insertOrReplace(
2285 std::make_pair(LocalBaseIdentifierID,
2286 F.BaseIdentifierID - LocalBaseIdentifierID));
Douglas Gregor6ec60e02011-08-03 21:49:18 +00002287
2288 IdentifiersLoaded.resize(IdentifiersLoaded.size()
2289 + F.LocalNumIdentifiers);
2290 }
Douglas Gregorafaf3082009-04-11 00:14:32 +00002291 break;
Douglas Gregor6ec60e02011-08-03 21:49:18 +00002292 }
Douglas Gregora8235d62012-10-09 23:05:51 +00002293
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002294 case EXTERNAL_DEFINITIONS:
Douglas Gregor409448c2011-07-21 22:35:25 +00002295 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2296 ExternalDefinitions.push_back(getGlobalDeclID(F, Record[I]));
Douglas Gregorfdd01722009-04-14 00:24:19 +00002297 break;
Douglas Gregor3e1af842009-04-17 22:13:46 +00002298
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002299 case SPECIAL_TYPES:
Douglas Gregor393f2492011-07-22 00:38:23 +00002300 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2301 SpecialTypes.push_back(getGlobalTypeID(F, Record[I]));
Douglas Gregorad1de002009-04-18 05:55:16 +00002302 break;
2303
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002304 case STATISTICS:
Sebastian Redl518d8cb2010-07-20 21:20:32 +00002305 TotalNumStatements += Record[0];
2306 TotalNumMacros += Record[1];
2307 TotalLexicalDeclContexts += Record[2];
2308 TotalVisibleDeclContexts += Record[3];
Douglas Gregor3e1af842009-04-17 22:13:46 +00002309 break;
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00002310
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002311 case UNUSED_FILESCOPED_DECLS:
Douglas Gregor409448c2011-07-21 22:35:25 +00002312 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2313 UnusedFileScopedDecls.push_back(getGlobalDeclID(F, Record[I]));
Tanya Lattnere6bbc012010-02-12 00:07:30 +00002314 break;
Kovarththanan Rajaratnam6b82f642010-03-07 19:10:13 +00002315
Sean Huntebcbe1d2011-05-04 23:29:54 +00002316 case DELEGATING_CTORS:
Douglas Gregor409448c2011-07-21 22:35:25 +00002317 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2318 DelegatingCtorDecls.push_back(getGlobalDeclID(F, Record[I]));
Sean Huntebcbe1d2011-05-04 23:29:54 +00002319 break;
2320
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002321 case WEAK_UNDECLARED_IDENTIFIERS:
Douglas Gregor31e37b22011-07-28 18:09:57 +00002322 if (Record.size() % 4 != 0) {
2323 Error("invalid weak identifiers record");
Douglas Gregor4825fd72012-10-22 22:50:17 +00002324 return true;
Douglas Gregor31e37b22011-07-28 18:09:57 +00002325 }
2326
2327 // FIXME: Ignore weak undeclared identifiers from non-original PCH
2328 // files. This isn't the way to do it :)
2329 WeakUndeclaredIdentifiers.clear();
2330
2331 // Translate the weak, undeclared identifiers into global IDs.
2332 for (unsigned I = 0, N = Record.size(); I < N; /* in loop */) {
2333 WeakUndeclaredIdentifiers.push_back(
2334 getGlobalIdentifierID(F, Record[I++]));
2335 WeakUndeclaredIdentifiers.push_back(
2336 getGlobalIdentifierID(F, Record[I++]));
2337 WeakUndeclaredIdentifiers.push_back(
2338 ReadSourceLocation(F, Record, I).getRawEncoding());
2339 WeakUndeclaredIdentifiers.push_back(Record[I++]);
2340 }
Argyrios Kyrtzidis72b90572010-08-05 09:48:08 +00002341 break;
2342
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002343 case LOCALLY_SCOPED_EXTERNAL_DECLS:
Douglas Gregor409448c2011-07-21 22:35:25 +00002344 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2345 LocallyScopedExternalDecls.push_back(getGlobalDeclID(F, Record[I]));
Douglas Gregor14c22f22009-04-22 22:18:58 +00002346 break;
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +00002347
Douglas Gregorb18b1fd2011-08-03 23:28:44 +00002348 case SELECTOR_OFFSETS: {
Sebastian Redl059612d2010-08-03 21:58:15 +00002349 F.SelectorOffsets = (const uint32_t *)BlobStart;
Sebastian Redl725cd962010-08-04 20:40:17 +00002350 F.LocalNumSelectors = Record[0];
Douglas Gregorb18b1fd2011-08-03 23:28:44 +00002351 unsigned LocalBaseSelectorID = Record[1];
Douglas Gregor9827a802011-07-29 00:56:45 +00002352 F.BaseSelectorID = getTotalNumSelectors();
Douglas Gregor96958cb2011-07-20 01:10:58 +00002353
Douglas Gregorb18b1fd2011-08-03 23:28:44 +00002354 if (F.LocalNumSelectors > 0) {
2355 // Introduce the global -> local mapping for selectors within this
2356 // module.
2357 GlobalSelectorMap.insert(std::make_pair(getTotalNumSelectors()+1, &F));
2358
2359 // Introduce the local -> global mapping for selectors within this
2360 // module.
Douglas Gregoradafc2e2011-12-19 16:14:14 +00002361 F.SelectorRemap.insertOrReplace(
2362 std::make_pair(LocalBaseSelectorID,
2363 F.BaseSelectorID - LocalBaseSelectorID));
Douglas Gregor83941df2009-04-25 17:48:32 +00002364
Douglas Gregorb18b1fd2011-08-03 23:28:44 +00002365 SelectorsLoaded.resize(SelectorsLoaded.size() + F.LocalNumSelectors);
2366 }
2367 break;
2368 }
2369
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002370 case METHOD_POOL:
Sebastian Redl725cd962010-08-04 20:40:17 +00002371 F.SelectorLookupTableData = (const unsigned char *)BlobStart;
Douglas Gregor83941df2009-04-25 17:48:32 +00002372 if (Record[0])
Sebastian Redl725cd962010-08-04 20:40:17 +00002373 F.SelectorLookupTable
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002374 = ASTSelectorLookupTable::Create(
Sebastian Redl725cd962010-08-04 20:40:17 +00002375 F.SelectorLookupTableData + Record[0],
2376 F.SelectorLookupTableData,
Douglas Gregor409448c2011-07-21 22:35:25 +00002377 ASTSelectorLookupTrait(*this, F));
Sebastian Redlfa78dec2010-08-04 21:22:45 +00002378 TotalNumMethodPoolEntries += Record[1];
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +00002379 break;
Douglas Gregor2eafc1b2009-04-26 00:07:37 +00002380
Sebastian Redl4ee5a6f2010-09-22 00:42:30 +00002381 case REFERENCED_SELECTOR_POOL:
Douglas Gregor8451ec72011-07-28 14:41:43 +00002382 if (!Record.empty()) {
2383 for (unsigned Idx = 0, N = Record.size() - 1; Idx < N; /* in loop */) {
2384 ReferencedSelectorsData.push_back(getGlobalSelectorID(F,
2385 Record[Idx++]));
2386 ReferencedSelectorsData.push_back(ReadSourceLocation(F, Record, Idx).
2387 getRawEncoding());
2388 }
2389 }
Fariborz Jahanian32019832010-07-23 19:11:11 +00002390 break;
2391
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002392 case PP_COUNTER_VALUE:
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00002393 if (!Record.empty() && Listener)
Argyrios Kyrtzidis62288ed2012-10-10 02:12:47 +00002394 Listener->ReadCounter(F, Record[0]);
Douglas Gregor2eafc1b2009-04-26 00:07:37 +00002395 break;
Argyrios Kyrtzidis10f3df52011-10-28 22:54:21 +00002396
2397 case FILE_SORTED_DECLS:
2398 F.FileSortedDecls = (const DeclID *)BlobStart;
Argyrios Kyrtzidis2093e0b2012-10-02 21:09:13 +00002399 F.NumFileSortedDecls = Record[0];
Argyrios Kyrtzidis10f3df52011-10-28 22:54:21 +00002400 break;
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00002401
Douglas Gregorf62d43d2011-07-19 16:10:42 +00002402 case SOURCE_LOCATION_OFFSETS: {
2403 F.SLocEntryOffsets = (const uint32_t *)BlobStart;
Sebastian Redl518d8cb2010-07-20 21:20:32 +00002404 F.LocalNumSLocEntries = Record[0];
Argyrios Kyrtzidis2dbaca72011-09-19 20:40:25 +00002405 unsigned SLocSpaceSize = Record[1];
Douglas Gregorf62d43d2011-07-19 16:10:42 +00002406 llvm::tie(F.SLocEntryBaseID, F.SLocEntryBaseOffset) =
Argyrios Kyrtzidis2dbaca72011-09-19 20:40:25 +00002407 SourceMgr.AllocateLoadedSLocEntries(F.LocalNumSLocEntries,
2408 SLocSpaceSize);
Douglas Gregorf62d43d2011-07-19 16:10:42 +00002409 // Make our entry in the range map. BaseID is negative and growing, so
2410 // we invert it. Because we invert it, though, we need the other end of
2411 // the range.
2412 unsigned RangeStart =
2413 unsigned(-F.SLocEntryBaseID) - F.LocalNumSLocEntries + 1;
2414 GlobalSLocEntryMap.insert(std::make_pair(RangeStart, &F));
2415 F.FirstLoc = SourceLocation::getFromRawEncoding(F.SLocEntryBaseOffset);
2416
Argyrios Kyrtzidis2dbaca72011-09-19 20:40:25 +00002417 // SLocEntryBaseOffset is lower than MaxLoadedOffset and decreasing.
2418 assert((F.SLocEntryBaseOffset & (1U << 31U)) == 0);
2419 GlobalSLocOffsetMap.insert(
2420 std::make_pair(SourceManager::MaxLoadedOffset - F.SLocEntryBaseOffset
2421 - SLocSpaceSize,&F));
2422
Douglas Gregorf62d43d2011-07-19 16:10:42 +00002423 // Initialize the remapping table.
2424 // Invalid stays invalid.
2425 F.SLocRemap.insert(std::make_pair(0U, 0));
2426 // This module. Base was 2 when being compiled.
2427 F.SLocRemap.insert(std::make_pair(2U,
2428 static_cast<int>(F.SLocEntryBaseOffset - 2)));
Douglas Gregor0cdd7982011-07-21 18:46:38 +00002429
2430 TotalNumSLocEntries += F.LocalNumSLocEntries;
Douglas Gregorf62d43d2011-07-19 16:10:42 +00002431 break;
2432 }
2433
Douglas Gregor5d51a1d2011-08-01 16:01:55 +00002434 case MODULE_OFFSET_MAP: {
Douglas Gregorf62d43d2011-07-19 16:10:42 +00002435 // Additional remapping information.
2436 const unsigned char *Data = (const unsigned char*)BlobStart;
2437 const unsigned char *DataEnd = Data + BlobLen;
Douglas Gregorf33740e2011-08-02 10:56:51 +00002438
2439 // Continuous range maps we may be updating in our module.
2440 ContinuousRangeMap<uint32_t, int, 2>::Builder SLocRemap(F.SLocRemap);
Douglas Gregor6ec60e02011-08-03 21:49:18 +00002441 ContinuousRangeMap<uint32_t, int, 2>::Builder
2442 IdentifierRemap(F.IdentifierRemap);
Douglas Gregora8235d62012-10-09 23:05:51 +00002443 ContinuousRangeMap<uint32_t, int, 2>::Builder
2444 MacroRemap(F.MacroRemap);
2445 ContinuousRangeMap<uint32_t, int, 2>::Builder
Douglas Gregor272b6bc2011-08-04 18:56:47 +00002446 PreprocessedEntityRemap(F.PreprocessedEntityRemap);
2447 ContinuousRangeMap<uint32_t, int, 2>::Builder
Douglas Gregor26ced122011-12-01 00:59:36 +00002448 SubmoduleRemap(F.SubmoduleRemap);
2449 ContinuousRangeMap<uint32_t, int, 2>::Builder
Douglas Gregorb18b1fd2011-08-03 23:28:44 +00002450 SelectorRemap(F.SelectorRemap);
Douglas Gregor496c7092011-08-03 15:48:04 +00002451 ContinuousRangeMap<uint32_t, int, 2>::Builder DeclRemap(F.DeclRemap);
Douglas Gregora119da02011-08-02 16:26:37 +00002452 ContinuousRangeMap<uint32_t, int, 2>::Builder TypeRemap(F.TypeRemap);
2453
Douglas Gregorf62d43d2011-07-19 16:10:42 +00002454 while(Data < DataEnd) {
Douglas Gregorf62d43d2011-07-19 16:10:42 +00002455 uint16_t Len = io::ReadUnalignedLE16(Data);
Chris Lattner5f9e2722011-07-23 10:55:15 +00002456 StringRef Name = StringRef((const char*)Data, Len);
Douglas Gregorf33740e2011-08-02 10:56:51 +00002457 Data += Len;
Douglas Gregor1a4761e2011-11-30 23:21:26 +00002458 ModuleFile *OM = ModuleMgr.lookup(Name);
Douglas Gregorf62d43d2011-07-19 16:10:42 +00002459 if (!OM) {
2460 Error("SourceLocation remap refers to unknown module");
Douglas Gregor4825fd72012-10-22 22:50:17 +00002461 return true;
Douglas Gregorf62d43d2011-07-19 16:10:42 +00002462 }
Douglas Gregorf33740e2011-08-02 10:56:51 +00002463
2464 uint32_t SLocOffset = io::ReadUnalignedLE32(Data);
2465 uint32_t IdentifierIDOffset = io::ReadUnalignedLE32(Data);
Douglas Gregora8235d62012-10-09 23:05:51 +00002466 uint32_t MacroIDOffset = io::ReadUnalignedLE32(Data);
Douglas Gregorf33740e2011-08-02 10:56:51 +00002467 uint32_t PreprocessedEntityIDOffset = io::ReadUnalignedLE32(Data);
Douglas Gregor26ced122011-12-01 00:59:36 +00002468 uint32_t SubmoduleIDOffset = io::ReadUnalignedLE32(Data);
Douglas Gregorf33740e2011-08-02 10:56:51 +00002469 uint32_t SelectorIDOffset = io::ReadUnalignedLE32(Data);
2470 uint32_t DeclIDOffset = io::ReadUnalignedLE32(Data);
Douglas Gregora119da02011-08-02 16:26:37 +00002471 uint32_t TypeIndexOffset = io::ReadUnalignedLE32(Data);
Douglas Gregorf33740e2011-08-02 10:56:51 +00002472
2473 // Source location offset is mapped to OM->SLocEntryBaseOffset.
2474 SLocRemap.insert(std::make_pair(SLocOffset,
2475 static_cast<int>(OM->SLocEntryBaseOffset - SLocOffset)));
Douglas Gregor6ec60e02011-08-03 21:49:18 +00002476 IdentifierRemap.insert(
2477 std::make_pair(IdentifierIDOffset,
2478 OM->BaseIdentifierID - IdentifierIDOffset));
Douglas Gregora8235d62012-10-09 23:05:51 +00002479 MacroRemap.insert(std::make_pair(MacroIDOffset,
2480 OM->BaseMacroID - MacroIDOffset));
Douglas Gregor272b6bc2011-08-04 18:56:47 +00002481 PreprocessedEntityRemap.insert(
2482 std::make_pair(PreprocessedEntityIDOffset,
2483 OM->BasePreprocessedEntityID - PreprocessedEntityIDOffset));
Douglas Gregor26ced122011-12-01 00:59:36 +00002484 SubmoduleRemap.insert(std::make_pair(SubmoduleIDOffset,
2485 OM->BaseSubmoduleID - SubmoduleIDOffset));
Douglas Gregorb18b1fd2011-08-03 23:28:44 +00002486 SelectorRemap.insert(std::make_pair(SelectorIDOffset,
2487 OM->BaseSelectorID - SelectorIDOffset));
Douglas Gregor496c7092011-08-03 15:48:04 +00002488 DeclRemap.insert(std::make_pair(DeclIDOffset,
2489 OM->BaseDeclID - DeclIDOffset));
2490
Douglas Gregora119da02011-08-02 16:26:37 +00002491 TypeRemap.insert(std::make_pair(TypeIndexOffset,
Douglas Gregore3605012011-08-02 18:32:54 +00002492 OM->BaseTypeIndex - TypeIndexOffset));
Douglas Gregora1be2782011-12-17 23:38:30 +00002493
2494 // Global -> local mappings.
2495 F.GlobalToLocalDeclIDs[OM] = DeclIDOffset;
Douglas Gregorf62d43d2011-07-19 16:10:42 +00002496 }
2497 break;
2498 }
2499
Douglas Gregorf62d43d2011-07-19 16:10:42 +00002500 case SOURCE_MANAGER_LINE_TABLE:
2501 if (ParseLineTable(F, Record))
Douglas Gregor4825fd72012-10-22 22:50:17 +00002502 return true;
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00002503 break;
2504
Douglas Gregorf62d43d2011-07-19 16:10:42 +00002505 case SOURCE_LOCATION_PRELOADS: {
2506 // Need to transform from the local view (1-based IDs) to the global view,
2507 // which is based off F.SLocEntryBaseID.
Douglas Gregorf249bf32011-08-25 21:09:44 +00002508 if (!F.PreloadSLocEntries.empty()) {
2509 Error("Multiple SOURCE_LOCATION_PRELOADS records in AST file");
Douglas Gregor4825fd72012-10-22 22:50:17 +00002510 return true;
Douglas Gregorf249bf32011-08-25 21:09:44 +00002511 }
2512
2513 F.PreloadSLocEntries.swap(Record);
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00002514 break;
Douglas Gregorf62d43d2011-07-19 16:10:42 +00002515 }
Douglas Gregor4fed3f42009-04-27 18:38:38 +00002516
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002517 case STAT_CACHE: {
Douglas Gregor8ef6c8c2011-02-05 19:42:43 +00002518 if (!DisableStatCache) {
2519 ASTStatCache *MyStatCache =
2520 new ASTStatCache((const unsigned char *)BlobStart + Record[0],
2521 (const unsigned char *)BlobStart,
2522 NumStatHits, NumStatMisses);
2523 FileMgr.addStatCache(MyStatCache);
2524 F.StatCache = MyStatCache;
2525 }
Douglas Gregor4fed3f42009-04-27 18:38:38 +00002526 break;
Douglas Gregor52e71082009-10-16 18:18:30 +00002527 }
Kovarththanan Rajaratnam6b82f642010-03-07 19:10:13 +00002528
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002529 case EXT_VECTOR_DECLS:
Douglas Gregor409448c2011-07-21 22:35:25 +00002530 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2531 ExtVectorDecls.push_back(getGlobalDeclID(F, Record[I]));
Douglas Gregorb81c1702009-04-27 20:06:05 +00002532 break;
2533
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002534 case VTABLE_USES:
Douglas Gregordfe65432011-07-28 19:11:31 +00002535 if (Record.size() % 3 != 0) {
2536 Error("Invalid VTABLE_USES record");
Douglas Gregor4825fd72012-10-22 22:50:17 +00002537 return true;
Douglas Gregordfe65432011-07-28 19:11:31 +00002538 }
2539
Sebastian Redl40566802010-08-05 18:21:25 +00002540 // Later tables overwrite earlier ones.
Douglas Gregordfe65432011-07-28 19:11:31 +00002541 // FIXME: Modules will have some trouble with this. This is clearly not
2542 // the right way to do this.
Douglas Gregor409448c2011-07-21 22:35:25 +00002543 VTableUses.clear();
Douglas Gregordfe65432011-07-28 19:11:31 +00002544
2545 for (unsigned Idx = 0, N = Record.size(); Idx != N; /* In loop */) {
2546 VTableUses.push_back(getGlobalDeclID(F, Record[Idx++]));
2547 VTableUses.push_back(
2548 ReadSourceLocation(F, Record, Idx).getRawEncoding());
2549 VTableUses.push_back(Record[Idx++]);
2550 }
Argyrios Kyrtzidisd455add2010-07-06 15:37:04 +00002551 break;
2552
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002553 case DYNAMIC_CLASSES:
Douglas Gregor409448c2011-07-21 22:35:25 +00002554 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2555 DynamicClasses.push_back(getGlobalDeclID(F, Record[I]));
Argyrios Kyrtzidisd455add2010-07-06 15:37:04 +00002556 break;
2557
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002558 case PENDING_IMPLICIT_INSTANTIATIONS:
Douglas Gregorf2abb522011-07-28 19:26:52 +00002559 if (PendingInstantiations.size() % 2 != 0) {
Axel Naumann39d26c32012-10-02 09:09:43 +00002560 Error("Invalid existing PendingInstantiations");
Douglas Gregor4825fd72012-10-22 22:50:17 +00002561 return true;
Axel Naumann39d26c32012-10-02 09:09:43 +00002562 }
2563
2564 if (Record.size() % 2 != 0) {
Douglas Gregorf2abb522011-07-28 19:26:52 +00002565 Error("Invalid PENDING_IMPLICIT_INSTANTIATIONS block");
Douglas Gregor4825fd72012-10-22 22:50:17 +00002566 return true;
Douglas Gregorf2abb522011-07-28 19:26:52 +00002567 }
Axel Naumann39d26c32012-10-02 09:09:43 +00002568
Douglas Gregorf2abb522011-07-28 19:26:52 +00002569 for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) {
2570 PendingInstantiations.push_back(getGlobalDeclID(F, Record[I++]));
2571 PendingInstantiations.push_back(
2572 ReadSourceLocation(F, Record, I).getRawEncoding());
2573 }
Argyrios Kyrtzidis0e036382010-08-05 09:48:16 +00002574 break;
2575
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002576 case SEMA_DECL_REFS:
Sebastian Redl40566802010-08-05 18:21:25 +00002577 // Later tables overwrite earlier ones.
Douglas Gregor409448c2011-07-21 22:35:25 +00002578 // FIXME: Modules will have some trouble with this.
2579 SemaDeclRefs.clear();
2580 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2581 SemaDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
Argyrios Kyrtzidis76c38d32010-08-02 07:14:54 +00002582 break;
2583
Argyrios Kyrtzidise24692b2011-09-15 18:02:56 +00002584 case PPD_ENTITIES_OFFSETS: {
Argyrios Kyrtzidis2dbaca72011-09-19 20:40:25 +00002585 F.PreprocessedEntityOffsets = (const PPEntityOffset *)BlobStart;
2586 assert(BlobLen % sizeof(PPEntityOffset) == 0);
2587 F.NumPreprocessedEntities = BlobLen / sizeof(PPEntityOffset);
Argyrios Kyrtzidise24692b2011-09-15 18:02:56 +00002588
2589 unsigned LocalBasePreprocessedEntityID = Record[0];
Douglas Gregorfb2d9e02011-08-04 16:36:56 +00002590
Douglas Gregor4c30bb12011-07-21 00:47:40 +00002591 unsigned StartingID;
Douglas Gregor712f2fc2011-09-09 22:02:16 +00002592 if (!PP.getPreprocessingRecord())
Argyrios Kyrtzidisc6c54522012-03-05 05:48:17 +00002593 PP.createPreprocessingRecord(/*RecordConditionalDirectives=*/false);
Douglas Gregor712f2fc2011-09-09 22:02:16 +00002594 if (!PP.getPreprocessingRecord()->getExternalSource())
2595 PP.getPreprocessingRecord()->SetExternalSource(*this);
2596 StartingID
2597 = PP.getPreprocessingRecord()
Argyrios Kyrtzidise24692b2011-09-15 18:02:56 +00002598 ->allocateLoadedEntities(F.NumPreprocessedEntities);
Douglas Gregor9827a802011-07-29 00:56:45 +00002599 F.BasePreprocessedEntityID = StartingID;
Douglas Gregor4c30bb12011-07-21 00:47:40 +00002600
Argyrios Kyrtzidise24692b2011-09-15 18:02:56 +00002601 if (F.NumPreprocessedEntities > 0) {
Douglas Gregor272b6bc2011-08-04 18:56:47 +00002602 // Introduce the global -> local mapping for preprocessed entities in
2603 // this module.
2604 GlobalPreprocessedEntityMap.insert(std::make_pair(StartingID, &F));
2605
2606 // Introduce the local -> global mapping for preprocessed entities in
2607 // this module.
Douglas Gregoradafc2e2011-12-19 16:14:14 +00002608 F.PreprocessedEntityRemap.insertOrReplace(
Douglas Gregor272b6bc2011-08-04 18:56:47 +00002609 std::make_pair(LocalBasePreprocessedEntityID,
2610 F.BasePreprocessedEntityID - LocalBasePreprocessedEntityID));
2611 }
Douglas Gregor272b6bc2011-08-04 18:56:47 +00002612
Douglas Gregor6a5a23f2010-03-19 21:51:54 +00002613 break;
Douglas Gregor4c30bb12011-07-21 00:47:40 +00002614 }
2615
Argyrios Kyrtzidis7b903402010-10-24 17:26:36 +00002616 case DECL_UPDATE_OFFSETS: {
2617 if (Record.size() % 2 != 0) {
2618 Error("invalid DECL_UPDATE_OFFSETS block in AST file");
Douglas Gregor4825fd72012-10-22 22:50:17 +00002619 return true;
Argyrios Kyrtzidis7b903402010-10-24 17:26:36 +00002620 }
2621 for (unsigned I = 0, N = Record.size(); I != N; I += 2)
Douglas Gregor496c7092011-08-03 15:48:04 +00002622 DeclUpdateOffsets[getGlobalDeclID(F, Record[I])]
2623 .push_back(std::make_pair(&F, Record[I+1]));
Argyrios Kyrtzidis7b903402010-10-24 17:26:36 +00002624 break;
2625 }
2626
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002627 case DECL_REPLACEMENTS: {
Argyrios Kyrtzidisef23b602011-10-31 07:20:15 +00002628 if (Record.size() % 3 != 0) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002629 Error("invalid DECL_REPLACEMENTS block in AST file");
Douglas Gregor4825fd72012-10-22 22:50:17 +00002630 return true;
Sebastian Redl0b17c612010-08-13 00:28:03 +00002631 }
Argyrios Kyrtzidisef23b602011-10-31 07:20:15 +00002632 for (unsigned I = 0, N = Record.size(); I != N; I += 3)
Douglas Gregor496c7092011-08-03 15:48:04 +00002633 ReplacedDecls[getGlobalDeclID(F, Record[I])]
Argyrios Kyrtzidisef23b602011-10-31 07:20:15 +00002634 = ReplacedDeclInfo(&F, Record[I+1], Record[I+2]);
Sebastian Redl0b17c612010-08-13 00:28:03 +00002635 break;
2636 }
Argyrios Kyrtzidise6b8d682011-09-01 00:58:55 +00002637
Douglas Gregorcff9f262012-01-27 01:47:08 +00002638 case OBJC_CATEGORIES_MAP: {
2639 if (F.LocalNumObjCCategoriesInMap != 0) {
2640 Error("duplicate OBJC_CATEGORIES_MAP record in AST file");
Douglas Gregor4825fd72012-10-22 22:50:17 +00002641 return true;
Argyrios Kyrtzidise6b8d682011-09-01 00:58:55 +00002642 }
Douglas Gregorcff9f262012-01-27 01:47:08 +00002643
2644 F.LocalNumObjCCategoriesInMap = Record[0];
2645 F.ObjCCategoriesMap = (const ObjCCategoriesInfo *)BlobStart;
Argyrios Kyrtzidise6b8d682011-09-01 00:58:55 +00002646 break;
2647 }
Douglas Gregor7c789c12010-10-29 22:39:52 +00002648
Douglas Gregorcff9f262012-01-27 01:47:08 +00002649 case OBJC_CATEGORIES:
2650 F.ObjCCategories.swap(Record);
2651 break;
2652
Douglas Gregor7c789c12010-10-29 22:39:52 +00002653 case CXX_BASE_SPECIFIER_OFFSETS: {
2654 if (F.LocalNumCXXBaseSpecifiers != 0) {
2655 Error("duplicate CXX_BASE_SPECIFIER_OFFSETS record in AST file");
Douglas Gregor4825fd72012-10-22 22:50:17 +00002656 return true;
Douglas Gregor7c789c12010-10-29 22:39:52 +00002657 }
2658
2659 F.LocalNumCXXBaseSpecifiers = Record[0];
2660 F.CXXBaseSpecifiersOffsets = (const uint32_t *)BlobStart;
Jonathan D. Turner1da90142011-07-21 21:15:19 +00002661 NumCXXBaseSpecifiersLoaded += F.LocalNumCXXBaseSpecifiers;
Douglas Gregor7c789c12010-10-29 22:39:52 +00002662 break;
2663 }
Argyrios Kyrtzidisf41d3be2010-11-05 22:10:18 +00002664
Argyrios Kyrtzidis3efd52c2011-01-14 20:54:07 +00002665 case DIAG_PRAGMA_MAPPINGS:
Argyrios Kyrtzidisf41d3be2010-11-05 22:10:18 +00002666 if (Record.size() % 2 != 0) {
2667 Error("invalid DIAG_USER_MAPPINGS block in AST file");
Douglas Gregor4825fd72012-10-22 22:50:17 +00002668 return true;
Argyrios Kyrtzidisf41d3be2010-11-05 22:10:18 +00002669 }
Douglas Gregorf62d43d2011-07-19 16:10:42 +00002670
2671 if (F.PragmaDiagMappings.empty())
2672 F.PragmaDiagMappings.swap(Record);
Argyrios Kyrtzidisf41d3be2010-11-05 22:10:18 +00002673 else
Douglas Gregorf62d43d2011-07-19 16:10:42 +00002674 F.PragmaDiagMappings.insert(F.PragmaDiagMappings.end(),
2675 Record.begin(), Record.end());
Argyrios Kyrtzidisf41d3be2010-11-05 22:10:18 +00002676 break;
Douglas Gregorcfbf1c72011-02-10 17:09:37 +00002677
Peter Collingbourne14b6ba72011-02-09 21:04:32 +00002678 case CUDA_SPECIAL_DECL_REFS:
2679 // Later tables overwrite earlier ones.
Douglas Gregor409448c2011-07-21 22:35:25 +00002680 // FIXME: Modules will have trouble with this.
2681 CUDASpecialDeclRefs.clear();
2682 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2683 CUDASpecialDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
Peter Collingbourne14b6ba72011-02-09 21:04:32 +00002684 break;
Douglas Gregorcfbf1c72011-02-10 17:09:37 +00002685
Douglas Gregorb4dc4852011-07-28 04:50:02 +00002686 case HEADER_SEARCH_TABLE: {
Douglas Gregorcfbf1c72011-02-10 17:09:37 +00002687 F.HeaderFileInfoTableData = BlobStart;
2688 F.LocalNumHeaderFileInfos = Record[1];
Douglas Gregorb4dc4852011-07-28 04:50:02 +00002689 F.HeaderFileFrameworkStrings = BlobStart + Record[2];
Douglas Gregorcfbf1c72011-02-10 17:09:37 +00002690 if (Record[0]) {
2691 F.HeaderFileInfoTable
2692 = HeaderFileInfoLookupTable::Create(
2693 (const unsigned char *)F.HeaderFileInfoTableData + Record[0],
Douglas Gregorb4dc4852011-07-28 04:50:02 +00002694 (const unsigned char *)F.HeaderFileInfoTableData,
Douglas Gregor95eab172011-07-28 20:55:49 +00002695 HeaderFileInfoTrait(*this, F,
Douglas Gregor712f2fc2011-09-09 22:02:16 +00002696 &PP.getHeaderSearchInfo(),
Douglas Gregorb4dc4852011-07-28 04:50:02 +00002697 BlobStart + Record[2]));
Douglas Gregor712f2fc2011-09-09 22:02:16 +00002698
2699 PP.getHeaderSearchInfo().SetExternalSource(this);
2700 if (!PP.getHeaderSearchInfo().getExternalLookup())
2701 PP.getHeaderSearchInfo().SetExternalLookup(this);
Douglas Gregorcfbf1c72011-02-10 17:09:37 +00002702 }
2703 break;
Douglas Gregorb4dc4852011-07-28 04:50:02 +00002704 }
2705
Peter Collingbourne84bccea2011-02-15 19:46:30 +00002706 case FP_PRAGMA_OPTIONS:
2707 // Later tables overwrite earlier ones.
2708 FPPragmaOptions.swap(Record);
2709 break;
2710
2711 case OPENCL_EXTENSIONS:
2712 // Later tables overwrite earlier ones.
2713 OpenCLExtensions.swap(Record);
2714 break;
Sean Huntebcbe1d2011-05-04 23:29:54 +00002715
2716 case TENTATIVE_DEFINITIONS:
Douglas Gregor409448c2011-07-21 22:35:25 +00002717 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2718 TentativeDefinitions.push_back(getGlobalDeclID(F, Record[I]));
Sean Huntebcbe1d2011-05-04 23:29:54 +00002719 break;
Douglas Gregord8bba9c2011-06-28 16:20:02 +00002720
2721 case KNOWN_NAMESPACES:
Douglas Gregor409448c2011-07-21 22:35:25 +00002722 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2723 KnownNamespaces.push_back(getGlobalDeclID(F, Record[I]));
Douglas Gregord8bba9c2011-06-28 16:20:02 +00002724 break;
Douglas Gregorf6137e42011-12-03 00:59:55 +00002725
2726 case IMPORTED_MODULES: {
2727 if (F.Kind != MK_Module) {
2728 // If we aren't loading a module (which has its own exports), make
2729 // all of the imported modules visible.
2730 // FIXME: Deal with macros-only imports.
2731 for (unsigned I = 0, N = Record.size(); I != N; ++I) {
2732 if (unsigned GlobalID = getGlobalSubmoduleID(F, Record[I]))
2733 ImportedModules.push_back(GlobalID);
2734 }
2735 }
2736 break;
Douglas Gregora1be2782011-12-17 23:38:30 +00002737 }
Douglas Gregor2171bf12012-01-15 16:58:34 +00002738
Douglas Gregora1be2782011-12-17 23:38:30 +00002739 case LOCAL_REDECLARATIONS: {
Douglas Gregor2171bf12012-01-15 16:58:34 +00002740 F.RedeclarationChains.swap(Record);
2741 break;
2742 }
2743
2744 case LOCAL_REDECLARATIONS_MAP: {
2745 if (F.LocalNumRedeclarationsInMap != 0) {
2746 Error("duplicate LOCAL_REDECLARATIONS_MAP record in AST file");
Douglas Gregor4825fd72012-10-22 22:50:17 +00002747 return true;
Douglas Gregora1be2782011-12-17 23:38:30 +00002748 }
Douglas Gregorf6137e42011-12-03 00:59:55 +00002749
Douglas Gregor2171bf12012-01-15 16:58:34 +00002750 F.LocalNumRedeclarationsInMap = Record[0];
2751 F.RedeclarationsMap = (const LocalRedeclarationsInfo *)BlobStart;
Douglas Gregora1be2782011-12-17 23:38:30 +00002752 break;
Douglas Gregorf6137e42011-12-03 00:59:55 +00002753 }
Douglas Gregorc3cfd2a2011-12-22 21:40:42 +00002754
2755 case MERGED_DECLARATIONS: {
2756 for (unsigned Idx = 0; Idx < Record.size(); /* increment in loop */) {
2757 GlobalDeclID CanonID = getGlobalDeclID(F, Record[Idx++]);
2758 SmallVectorImpl<GlobalDeclID> &Decls = StoredMergedDecls[CanonID];
2759 for (unsigned N = Record[Idx++]; N > 0; --N)
2760 Decls.push_back(getGlobalDeclID(F, Record[Idx++]));
2761 }
2762 break;
2763 }
Douglas Gregora8235d62012-10-09 23:05:51 +00002764
2765 case MACRO_OFFSET: {
2766 if (F.LocalNumMacros != 0) {
2767 Error("duplicate MACRO_OFFSET record in AST file");
Douglas Gregor4825fd72012-10-22 22:50:17 +00002768 return true;
Douglas Gregora8235d62012-10-09 23:05:51 +00002769 }
2770 F.MacroOffsets = (const uint32_t *)BlobStart;
2771 F.LocalNumMacros = Record[0];
2772 unsigned LocalBaseMacroID = Record[1];
2773 F.BaseMacroID = getTotalNumMacros();
2774
2775 if (F.LocalNumMacros > 0) {
2776 // Introduce the global -> local mapping for macros within this module.
2777 GlobalMacroMap.insert(std::make_pair(getTotalNumMacros() + 1, &F));
2778
2779 // Introduce the local -> global mapping for macros within this module.
2780 F.MacroRemap.insertOrReplace(
2781 std::make_pair(LocalBaseMacroID,
2782 F.BaseMacroID - LocalBaseMacroID));
2783
2784 MacrosLoaded.resize(MacrosLoaded.size() + F.LocalNumMacros);
2785 }
2786 break;
2787 }
2788
2789 case MACRO_UPDATES: {
2790 for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) {
2791 MacroID ID = getGlobalMacroID(F, Record[I++]);
2792 if (I == N)
2793 break;
2794
Douglas Gregor54c8a402012-10-12 00:16:50 +00002795 SourceLocation UndefLoc = ReadSourceLocation(F, Record, I);
2796 SubmoduleID SubmoduleID = getGlobalSubmoduleID(F, Record[I++]);;
2797 MacroUpdate Update;
2798 Update.UndefLoc = UndefLoc;
2799 MacroUpdates[ID].push_back(std::make_pair(SubmoduleID, Update));
Douglas Gregora8235d62012-10-09 23:05:51 +00002800 }
2801 break;
2802 }
Douglas Gregorafaf3082009-04-11 00:14:32 +00002803 }
Douglas Gregor2cf26342009-04-09 22:27:44 +00002804 }
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002805 Error("premature end of bitstream in AST file");
Douglas Gregor4825fd72012-10-22 22:50:17 +00002806 return true;
Douglas Gregor2cf26342009-04-09 22:27:44 +00002807}
2808
Douglas Gregorecc2c092011-12-01 22:20:10 +00002809void ASTReader::makeNamesVisible(const HiddenNames &Names) {
Douglas Gregor13292642011-12-02 15:45:10 +00002810 for (unsigned I = 0, N = Names.size(); I != N; ++I) {
Douglas Gregor54c8a402012-10-12 00:16:50 +00002811 switch (Names[I].getKind()) {
2812 case HiddenName::Declaration:
Douglas Gregor6c6c54a2012-10-11 00:46:49 +00002813 Names[I].getDecl()->Hidden = false;
Douglas Gregor54c8a402012-10-12 00:16:50 +00002814 break;
2815
2816 case HiddenName::MacroVisibility: {
2817 std::pair<IdentifierInfo *, MacroInfo *> Macro = Names[I].getMacro();
2818 Macro.second->setHidden(!Macro.second->isPublic());
2819 if (Macro.second->isDefined()) {
2820 PP.makeLoadedMacroInfoVisible(Macro.first, Macro.second);
2821 }
2822 break;
Douglas Gregor6c6c54a2012-10-11 00:46:49 +00002823 }
2824
Douglas Gregor54c8a402012-10-12 00:16:50 +00002825 case HiddenName::MacroUndef: {
2826 std::pair<IdentifierInfo *, MacroInfo *> Macro = Names[I].getMacro();
2827 if (Macro.second->isDefined()) {
2828 Macro.second->setUndefLoc(Names[I].getMacroUndefLoc());
2829 if (PPMutationListener *Listener = PP.getPPMutationListener())
2830 Listener->UndefinedMacro(Macro.second);
2831 PP.makeLoadedMacroInfoVisible(Macro.first, Macro.second);
2832 }
2833 break;
2834 }
Douglas Gregor1d4c1132011-12-20 22:06:13 +00002835 }
Douglas Gregor13292642011-12-02 15:45:10 +00002836 }
Douglas Gregorecc2c092011-12-01 22:20:10 +00002837}
2838
Douglas Gregor5e356932011-12-01 17:11:21 +00002839void ASTReader::makeModuleVisible(Module *Mod,
2840 Module::NameVisibilityKind NameVisibility) {
2841 llvm::SmallPtrSet<Module *, 4> Visited;
2842 llvm::SmallVector<Module *, 4> Stack;
2843 Stack.push_back(Mod);
2844 while (!Stack.empty()) {
2845 Mod = Stack.back();
2846 Stack.pop_back();
2847
2848 if (NameVisibility <= Mod->NameVisibility) {
2849 // This module already has this level of visibility (or greater), so
2850 // there is nothing more to do.
2851 continue;
2852 }
2853
Douglas Gregor51f564f2011-12-31 04:05:44 +00002854 if (!Mod->isAvailable()) {
2855 // Modules that aren't available cannot be made visible.
2856 continue;
2857 }
2858
Douglas Gregor5e356932011-12-01 17:11:21 +00002859 // Update the module's name visibility.
2860 Mod->NameVisibility = NameVisibility;
2861
Douglas Gregorecc2c092011-12-01 22:20:10 +00002862 // If we've already deserialized any names from this module,
Douglas Gregor5e356932011-12-01 17:11:21 +00002863 // mark them as visible.
Douglas Gregorecc2c092011-12-01 22:20:10 +00002864 HiddenNamesMapType::iterator Hidden = HiddenNamesMap.find(Mod);
2865 if (Hidden != HiddenNamesMap.end()) {
2866 makeNamesVisible(Hidden->second);
2867 HiddenNamesMap.erase(Hidden);
2868 }
Douglas Gregor5e356932011-12-01 17:11:21 +00002869
2870 // Push any non-explicit submodules onto the stack to be marked as
2871 // visible.
Douglas Gregorb7a78192012-01-04 23:32:19 +00002872 for (Module::submodule_iterator Sub = Mod->submodule_begin(),
2873 SubEnd = Mod->submodule_end();
Douglas Gregor5e356932011-12-01 17:11:21 +00002874 Sub != SubEnd; ++Sub) {
Douglas Gregorb7a78192012-01-04 23:32:19 +00002875 if (!(*Sub)->IsExplicit && Visited.insert(*Sub))
2876 Stack.push_back(*Sub);
Douglas Gregor5e356932011-12-01 17:11:21 +00002877 }
Douglas Gregor07165b92011-12-02 19:11:09 +00002878
2879 // Push any exported modules onto the stack to be marked as visible.
Douglas Gregor0adaa882011-12-05 17:28:06 +00002880 bool AnyWildcard = false;
2881 bool UnrestrictedWildcard = false;
2882 llvm::SmallVector<Module *, 4> WildcardRestrictions;
Douglas Gregor07165b92011-12-02 19:11:09 +00002883 for (unsigned I = 0, N = Mod->Exports.size(); I != N; ++I) {
2884 Module *Exported = Mod->Exports[I].getPointer();
Douglas Gregor0adaa882011-12-05 17:28:06 +00002885 if (!Mod->Exports[I].getInt()) {
2886 // Export a named module directly; no wildcards involved.
2887 if (Visited.insert(Exported))
Douglas Gregor07165b92011-12-02 19:11:09 +00002888 Stack.push_back(Exported);
Douglas Gregor0adaa882011-12-05 17:28:06 +00002889
2890 continue;
Douglas Gregor07165b92011-12-02 19:11:09 +00002891 }
Douglas Gregor0adaa882011-12-05 17:28:06 +00002892
2893 // Wildcard export: export all of the imported modules that match
2894 // the given pattern.
2895 AnyWildcard = true;
2896 if (UnrestrictedWildcard)
2897 continue;
2898
2899 if (Module *Restriction = Mod->Exports[I].getPointer())
2900 WildcardRestrictions.push_back(Restriction);
2901 else {
2902 WildcardRestrictions.clear();
2903 UnrestrictedWildcard = true;
2904 }
2905 }
2906
2907 // If there were any wildcards, push any imported modules that were
2908 // re-exported by the wildcard restriction.
2909 if (!AnyWildcard)
2910 continue;
2911
2912 for (unsigned I = 0, N = Mod->Imports.size(); I != N; ++I) {
2913 Module *Imported = Mod->Imports[I];
Benjamin Kramerd48bcb22012-08-22 15:37:55 +00002914 if (!Visited.insert(Imported))
Douglas Gregor0adaa882011-12-05 17:28:06 +00002915 continue;
2916
2917 bool Acceptable = UnrestrictedWildcard;
2918 if (!Acceptable) {
2919 // Check whether this module meets one of the restrictions.
2920 for (unsigned R = 0, NR = WildcardRestrictions.size(); R != NR; ++R) {
2921 Module *Restriction = WildcardRestrictions[R];
2922 if (Imported == Restriction || Imported->isSubModuleOf(Restriction)) {
2923 Acceptable = true;
2924 break;
2925 }
2926 }
2927 }
2928
2929 if (!Acceptable)
2930 continue;
2931
Douglas Gregor0adaa882011-12-05 17:28:06 +00002932 Stack.push_back(Imported);
Douglas Gregor07165b92011-12-02 19:11:09 +00002933 }
Douglas Gregor5e356932011-12-01 17:11:21 +00002934 }
2935}
2936
Sebastian Redl1d9f1fe2010-10-05 16:15:19 +00002937ASTReader::ASTReadResult ASTReader::ReadAST(const std::string &FileName,
Douglas Gregor38295be2012-10-22 23:51:00 +00002938 ModuleKind Type,
2939 unsigned ClientLoadCapabilities) {
Douglas Gregor057df202012-01-18 20:56:22 +00002940 // Bump the generation number.
Douglas Gregorcff9f262012-01-27 01:47:08 +00002941 unsigned PreviousGeneration = CurrentGeneration++;
Douglas Gregor1d9d9892012-10-18 05:31:06 +00002942
2943 // Load the core of the AST files.
2944 llvm::SmallVector<ModuleFile *, 4> Loaded;
Douglas Gregor38295be2012-10-22 23:51:00 +00002945 switch(ReadASTCore(FileName, Type, /*ImportedBy=*/0, Loaded,
2946 ClientLoadCapabilities)) {
Sebastian Redlcdf3b832010-07-16 20:41:52 +00002947 case Failure: return Failure;
Douglas Gregor4825fd72012-10-22 22:50:17 +00002948 case OutOfDate: return OutOfDate;
2949 case VersionMismatch: return VersionMismatch;
2950 case ConfigurationMismatch: return ConfigurationMismatch;
2951 case HadErrors: return HadErrors;
Sebastian Redlcdf3b832010-07-16 20:41:52 +00002952 case Success: break;
2953 }
Sebastian Redlfbd4bf12010-07-17 00:12:06 +00002954
2955 // Here comes stuff that we only do once the entire chain is loaded.
Douglas Gregor057df202012-01-18 20:56:22 +00002956
Douglas Gregor1d9d9892012-10-18 05:31:06 +00002957 // Load the AST blocks of all of the modules that we loaded.
2958 for (llvm::SmallVectorImpl<ModuleFile *>::iterator M = Loaded.begin(),
2959 MEnd = Loaded.end();
2960 M != MEnd; ++M) {
2961 ModuleFile &F = **M;
2962
2963 // Read the AST block.
Douglas Gregor4825fd72012-10-22 22:50:17 +00002964 if (ReadASTBlock(F))
2965 return Failure;
Douglas Gregor1d9d9892012-10-18 05:31:06 +00002966
2967 // Once read, set the ModuleFile bit base offset and update the size in
2968 // bits of all files we've seen.
2969 F.GlobalBitOffset = TotalModulesSizeInBits;
2970 TotalModulesSizeInBits += F.SizeInBits;
2971 GlobalBitOffsetsMap.insert(std::make_pair(F.GlobalBitOffset, &F));
2972
Douglas Gregor1d9d9892012-10-18 05:31:06 +00002973 // Preload SLocEntries.
2974 for (unsigned I = 0, N = F.PreloadSLocEntries.size(); I != N; ++I) {
2975 int Index = int(F.PreloadSLocEntries[I] - 1) + F.SLocEntryBaseID;
Douglas Gregor8b53d142012-10-22 22:53:10 +00002976 // Load it through the SourceManager and don't call ReadSLocEntry()
Douglas Gregor1d9d9892012-10-18 05:31:06 +00002977 // directly because the entry may have already been loaded in which case
Douglas Gregor8b53d142012-10-22 22:53:10 +00002978 // calling ReadSLocEntry() directly would trigger an assertion in
Douglas Gregor1d9d9892012-10-18 05:31:06 +00002979 // SourceManager.
2980 SourceMgr.getLoadedSLocEntryByID(Index);
2981 }
2982 }
2983
Sebastian Redlfbd4bf12010-07-17 00:12:06 +00002984 // Check the predefines buffers.
Douglas Gregor38295be2012-10-22 23:51:00 +00002985 bool ConfigComplain = (ClientLoadCapabilities & ARR_ConfigurationMismatch)==0;
Douglas Gregor6236a292011-12-02 21:56:05 +00002986 if (!DisableValidation && Type == MK_PCH &&
Argyrios Kyrtzidis26d43cd2011-09-12 18:09:38 +00002987 // FIXME: CheckPredefinesBuffers also sets the SuggestedPredefines;
2988 // if DisableValidation is true, defines that were set on command-line
2989 // but not in the PCH file will not be added to SuggestedPredefines.
Douglas Gregor38295be2012-10-22 23:51:00 +00002990 CheckPredefinesBuffers(ConfigComplain))
Douglas Gregor4825fd72012-10-22 22:50:17 +00002991 return ConfigurationMismatch;
Sebastian Redlfbd4bf12010-07-17 00:12:06 +00002992
Douglas Gregoreee242f2011-10-27 09:33:13 +00002993 // Mark all of the identifiers in the identifier table as being out of date,
2994 // so that various accessors know to check the loaded modules when the
2995 // identifier is used.
Douglas Gregor712f2fc2011-09-09 22:02:16 +00002996 for (IdentifierTable::iterator Id = PP.getIdentifierTable().begin(),
2997 IdEnd = PP.getIdentifierTable().end();
2998 Id != IdEnd; ++Id)
Douglas Gregoreee242f2011-10-27 09:33:13 +00002999 Id->second->setOutOfDate(true);
Douglas Gregor057df202012-01-18 20:56:22 +00003000
Douglas Gregoraf13bfc2011-12-02 18:58:38 +00003001 // Resolve any unresolved module exports.
Douglas Gregor55988682011-12-05 16:33:54 +00003002 for (unsigned I = 0, N = UnresolvedModuleImportExports.size(); I != N; ++I) {
3003 UnresolvedModuleImportExport &Unresolved = UnresolvedModuleImportExports[I];
3004 SubmoduleID GlobalID = getGlobalSubmoduleID(*Unresolved.File,Unresolved.ID);
Douglas Gregor0adaa882011-12-05 17:28:06 +00003005 Module *ResolvedMod = getSubmodule(GlobalID);
3006
3007 if (Unresolved.IsImport) {
3008 if (ResolvedMod)
Douglas Gregor55988682011-12-05 16:33:54 +00003009 Unresolved.Mod->Imports.push_back(ResolvedMod);
Douglas Gregor0adaa882011-12-05 17:28:06 +00003010 continue;
Douglas Gregoraf13bfc2011-12-02 18:58:38 +00003011 }
Douglas Gregor0adaa882011-12-05 17:28:06 +00003012
3013 if (ResolvedMod || Unresolved.IsWildcard)
3014 Unresolved.Mod->Exports.push_back(
3015 Module::ExportDecl(ResolvedMod, Unresolved.IsWildcard));
Douglas Gregoraf13bfc2011-12-02 18:58:38 +00003016 }
Douglas Gregor55988682011-12-05 16:33:54 +00003017 UnresolvedModuleImportExports.clear();
Douglas Gregoraf13bfc2011-12-02 18:58:38 +00003018
Douglas Gregor35942772011-09-09 21:34:22 +00003019 InitializeContext();
Sebastian Redlfbd4bf12010-07-17 00:12:06 +00003020
Argyrios Kyrtzidis7b903402010-10-24 17:26:36 +00003021 if (DeserializationListener)
3022 DeserializationListener->ReaderInitialized(this);
3023
Douglas Gregor11407b82012-10-18 21:18:25 +00003024 ModuleFile &PrimaryModule = ModuleMgr.getPrimaryModule();
3025 if (!PrimaryModule.OriginalSourceFileID.isInvalid()) {
3026 PrimaryModule.OriginalSourceFileID
3027 = FileID::get(PrimaryModule.SLocEntryBaseID
3028 + PrimaryModule.OriginalSourceFileID.getOpaqueValue() - 1);
Argyrios Kyrtzidisb8c879a2012-01-05 21:36:25 +00003029
Douglas Gregor11407b82012-10-18 21:18:25 +00003030 // If this AST file is a precompiled preamble, then set the
3031 // preamble file ID of the source manager to the file source file
3032 // from which the preamble was built.
Argyrios Kyrtzidisb8c879a2012-01-05 21:36:25 +00003033 if (Type == MK_Preamble) {
Douglas Gregor11407b82012-10-18 21:18:25 +00003034 SourceMgr.setPreambleFileID(PrimaryModule.OriginalSourceFileID);
Argyrios Kyrtzidisb8c879a2012-01-05 21:36:25 +00003035 } else if (Type == MK_MainFile) {
Douglas Gregor11407b82012-10-18 21:18:25 +00003036 SourceMgr.setMainFileID(PrimaryModule.OriginalSourceFileID);
Douglas Gregorf62d43d2011-07-19 16:10:42 +00003037 }
Douglas Gregor414cb642010-11-30 05:23:00 +00003038 }
3039
Douglas Gregorcff9f262012-01-27 01:47:08 +00003040 // For any Objective-C class definitions we have already loaded, make sure
3041 // that we load any additional categories.
3042 for (unsigned I = 0, N = ObjCClassesLoaded.size(); I != N; ++I) {
3043 loadObjCCategories(ObjCClassesLoaded[I]->getGlobalID(),
3044 ObjCClassesLoaded[I],
3045 PreviousGeneration);
3046 }
3047
Sebastian Redlfbd4bf12010-07-17 00:12:06 +00003048 return Success;
3049}
3050
Douglas Gregor38295be2012-10-22 23:51:00 +00003051ASTReader::ASTReadResult
3052ASTReader::ReadASTCore(StringRef FileName,
3053 ModuleKind Type,
3054 ModuleFile *ImportedBy,
3055 llvm::SmallVectorImpl<ModuleFile *> &Loaded,
3056 unsigned ClientLoadCapabilities) {
Douglas Gregor1a4761e2011-11-30 23:21:26 +00003057 ModuleFile *M;
Douglas Gregorfac4ece2011-08-19 02:29:29 +00003058 bool NewModule;
3059 std::string ErrorStr;
3060 llvm::tie(M, NewModule) = ModuleMgr.addModule(FileName, Type, ImportedBy,
Douglas Gregor057df202012-01-18 20:56:22 +00003061 CurrentGeneration, ErrorStr);
Sebastian Redlfbd4bf12010-07-17 00:12:06 +00003062
Douglas Gregorfac4ece2011-08-19 02:29:29 +00003063 if (!M) {
3064 // We couldn't load the module.
3065 std::string Msg = "Unable to load module \"" + FileName.str() + "\": "
3066 + ErrorStr;
3067 Error(Msg);
3068 return Failure;
3069 }
3070
3071 if (!NewModule) {
3072 // We've already loaded this module.
3073 return Success;
3074 }
3075
3076 // FIXME: This seems rather a hack. Should CurrentDir be part of the
3077 // module?
Argyrios Kyrtzidis8e3df4d2011-02-15 17:54:22 +00003078 if (FileName != "-") {
3079 CurrentDir = llvm::sys::path::parent_path(FileName);
3080 if (CurrentDir.empty()) CurrentDir = ".";
3081 }
3082
Douglas Gregor1a4761e2011-11-30 23:21:26 +00003083 ModuleFile &F = *M;
Sebastian Redl9137a522010-07-16 17:50:48 +00003084 llvm::BitstreamCursor &Stream = F.Stream;
Sebastian Redlfbd4bf12010-07-17 00:12:06 +00003085 Stream.init(F.StreamFile);
Sebastian Redl04e6fd42010-07-21 20:07:32 +00003086 F.SizeInBits = F.Buffer->getBufferSize() * 8;
Douglas Gregor8f1231b2011-07-22 06:10:01 +00003087
Sebastian Redlfbd4bf12010-07-17 00:12:06 +00003088 // Sniff for the signature.
3089 if (Stream.Read(8) != 'C' ||
3090 Stream.Read(8) != 'P' ||
3091 Stream.Read(8) != 'C' ||
3092 Stream.Read(8) != 'H') {
3093 Diag(diag::err_not_a_pch_file) << FileName;
3094 return Failure;
3095 }
Douglas Gregor2cf26342009-04-09 22:27:44 +00003096
Douglas Gregor2cf26342009-04-09 22:27:44 +00003097 while (!Stream.AtEndOfStream()) {
3098 unsigned Code = Stream.ReadCode();
Mike Stump1eb44332009-09-09 15:08:12 +00003099
Douglas Gregore1d918e2009-04-10 23:10:45 +00003100 if (Code != llvm::bitc::ENTER_SUBBLOCK) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00003101 Error("invalid record at top-level of AST file");
Douglas Gregore1d918e2009-04-10 23:10:45 +00003102 return Failure;
3103 }
Douglas Gregor2cf26342009-04-09 22:27:44 +00003104
3105 unsigned BlockID = Stream.ReadSubBlockID();
Douglas Gregor668c1a42009-04-21 22:25:48 +00003106
Douglas Gregor7ae467f2012-10-18 18:27:37 +00003107 // We only know the control subblock ID.
Douglas Gregor2cf26342009-04-09 22:27:44 +00003108 switch (BlockID) {
3109 case llvm::bitc::BLOCKINFO_BLOCK_ID:
Douglas Gregore1d918e2009-04-10 23:10:45 +00003110 if (Stream.ReadBlockInfoBlock()) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00003111 Error("malformed BlockInfoBlock in AST file");
Douglas Gregore1d918e2009-04-10 23:10:45 +00003112 return Failure;
3113 }
Douglas Gregor2cf26342009-04-09 22:27:44 +00003114 break;
Douglas Gregor1d9d9892012-10-18 05:31:06 +00003115 case CONTROL_BLOCK_ID:
Douglas Gregor38295be2012-10-22 23:51:00 +00003116 switch (ReadControlBlock(F, Loaded, ClientLoadCapabilities)) {
Douglas Gregor0a0428e2009-04-10 20:39:37 +00003117 case Success:
3118 break;
3119
Douglas Gregor4825fd72012-10-22 22:50:17 +00003120 case Failure: return Failure;
3121 case OutOfDate: return OutOfDate;
3122 case VersionMismatch: return VersionMismatch;
3123 case ConfigurationMismatch: return ConfigurationMismatch;
3124 case HadErrors: return HadErrors;
Douglas Gregor0a0428e2009-04-10 20:39:37 +00003125 }
Douglas Gregor2cf26342009-04-09 22:27:44 +00003126 break;
Douglas Gregor1d9d9892012-10-18 05:31:06 +00003127 case AST_BLOCK_ID:
3128 // Record that we've loaded this module.
3129 Loaded.push_back(M);
3130 return Success;
3131
Douglas Gregor2cf26342009-04-09 22:27:44 +00003132 default:
Douglas Gregore1d918e2009-04-10 23:10:45 +00003133 if (Stream.SkipBlock()) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00003134 Error("malformed block record in AST file");
Douglas Gregore1d918e2009-04-10 23:10:45 +00003135 return Failure;
3136 }
Douglas Gregor2cf26342009-04-09 22:27:44 +00003137 break;
3138 }
Mike Stump1eb44332009-09-09 15:08:12 +00003139 }
Douglas Gregor8f1231b2011-07-22 06:10:01 +00003140
Sebastian Redlcdf3b832010-07-16 20:41:52 +00003141 return Success;
3142}
3143
Douglas Gregor712f2fc2011-09-09 22:02:16 +00003144void ASTReader::InitializeContext() {
Douglas Gregor6bf2b9f2011-08-12 00:15:20 +00003145 // If there's a listener, notify them that we "read" the translation unit.
3146 if (DeserializationListener)
Douglas Gregor35942772011-09-09 21:34:22 +00003147 DeserializationListener->DeclRead(PREDEF_DECL_TRANSLATION_UNIT_ID,
3148 Context.getTranslationUnitDecl());
Douglas Gregor3747ee72010-10-01 01:18:02 +00003149
Douglas Gregor6bf2b9f2011-08-12 00:15:20 +00003150 // Make sure we load the declaration update records for the translation unit,
3151 // if there are any.
Douglas Gregor35942772011-09-09 21:34:22 +00003152 loadDeclUpdateRecords(PREDEF_DECL_TRANSLATION_UNIT_ID,
3153 Context.getTranslationUnitDecl());
Douglas Gregor6bf2b9f2011-08-12 00:15:20 +00003154
Douglas Gregor5f957282011-08-11 22:18:49 +00003155 // FIXME: Find a better way to deal with collisions between these
3156 // built-in types. Right now, we just ignore the problem.
3157
3158 // Load the special types.
Douglas Gregora6ea10e2012-01-17 18:09:05 +00003159 if (SpecialTypes.size() >= NumSpecialTypeIDs) {
Douglas Gregor02a5e872011-09-10 00:30:18 +00003160 if (unsigned String = SpecialTypes[SPECIAL_TYPE_CF_CONSTANT_STRING]) {
3161 if (!Context.CFConstantStringTypeDecl)
3162 Context.setCFConstantStringType(GetType(String));
3163 }
3164
3165 if (unsigned File = SpecialTypes[SPECIAL_TYPE_FILE]) {
3166 QualType FileType = GetType(File);
3167 if (FileType.isNull()) {
3168 Error("FILE type is NULL");
3169 return;
3170 }
3171
3172 if (!Context.FILEDecl) {
3173 if (const TypedefType *Typedef = FileType->getAs<TypedefType>())
3174 Context.setFILEDecl(Typedef->getDecl());
3175 else {
3176 const TagType *Tag = FileType->getAs<TagType>();
3177 if (!Tag) {
3178 Error("Invalid FILE type in AST file");
3179 return;
3180 }
3181 Context.setFILEDecl(Tag->getDecl());
Jonathan D. Turnerde91db52011-08-05 23:07:10 +00003182 }
Jonathan D. Turnerde91db52011-08-05 23:07:10 +00003183 }
Douglas Gregorc29f77b2009-07-07 16:35:42 +00003184 }
Douglas Gregor5f957282011-08-11 22:18:49 +00003185
Douglas Gregor72cd7a02011-11-11 19:13:12 +00003186 if (unsigned Jmp_buf = SpecialTypes[SPECIAL_TYPE_JMP_BUF]) {
Douglas Gregor02a5e872011-09-10 00:30:18 +00003187 QualType Jmp_bufType = GetType(Jmp_buf);
3188 if (Jmp_bufType.isNull()) {
3189 Error("jmp_buf type is NULL");
3190 return;
3191 }
3192
3193 if (!Context.jmp_bufDecl) {
3194 if (const TypedefType *Typedef = Jmp_bufType->getAs<TypedefType>())
3195 Context.setjmp_bufDecl(Typedef->getDecl());
3196 else {
3197 const TagType *Tag = Jmp_bufType->getAs<TagType>();
3198 if (!Tag) {
3199 Error("Invalid jmp_buf type in AST file");
3200 return;
3201 }
3202 Context.setjmp_bufDecl(Tag->getDecl());
Jonathan D. Turnerde91db52011-08-05 23:07:10 +00003203 }
Jonathan D. Turnerde91db52011-08-05 23:07:10 +00003204 }
Mike Stump782fa302009-07-28 02:25:19 +00003205 }
Douglas Gregor02a5e872011-09-10 00:30:18 +00003206
Douglas Gregor72cd7a02011-11-11 19:13:12 +00003207 if (unsigned Sigjmp_buf = SpecialTypes[SPECIAL_TYPE_SIGJMP_BUF]) {
Douglas Gregor02a5e872011-09-10 00:30:18 +00003208 QualType Sigjmp_bufType = GetType(Sigjmp_buf);
3209 if (Sigjmp_bufType.isNull()) {
3210 Error("sigjmp_buf type is NULL");
3211 return;
3212 }
3213
3214 if (!Context.sigjmp_bufDecl) {
3215 if (const TypedefType *Typedef = Sigjmp_bufType->getAs<TypedefType>())
3216 Context.setsigjmp_bufDecl(Typedef->getDecl());
3217 else {
3218 const TagType *Tag = Sigjmp_bufType->getAs<TagType>();
3219 assert(Tag && "Invalid sigjmp_buf type in AST file");
3220 Context.setsigjmp_bufDecl(Tag->getDecl());
3221 }
3222 }
3223 }
3224
3225 if (unsigned ObjCIdRedef
3226 = SpecialTypes[SPECIAL_TYPE_OBJC_ID_REDEFINITION]) {
3227 if (Context.ObjCIdRedefinitionType.isNull())
3228 Context.ObjCIdRedefinitionType = GetType(ObjCIdRedef);
3229 }
3230
3231 if (unsigned ObjCClassRedef
3232 = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS_REDEFINITION]) {
3233 if (Context.ObjCClassRedefinitionType.isNull())
3234 Context.ObjCClassRedefinitionType = GetType(ObjCClassRedef);
3235 }
3236
3237 if (unsigned ObjCSelRedef
3238 = SpecialTypes[SPECIAL_TYPE_OBJC_SEL_REDEFINITION]) {
3239 if (Context.ObjCSelRedefinitionType.isNull())
3240 Context.ObjCSelRedefinitionType = GetType(ObjCSelRedef);
3241 }
Rafael Espindolae2d4f4e2011-11-13 21:51:09 +00003242
3243 if (unsigned Ucontext_t = SpecialTypes[SPECIAL_TYPE_UCONTEXT_T]) {
3244 QualType Ucontext_tType = GetType(Ucontext_t);
3245 if (Ucontext_tType.isNull()) {
3246 Error("ucontext_t type is NULL");
3247 return;
3248 }
3249
3250 if (!Context.ucontext_tDecl) {
3251 if (const TypedefType *Typedef = Ucontext_tType->getAs<TypedefType>())
3252 Context.setucontext_tDecl(Typedef->getDecl());
3253 else {
3254 const TagType *Tag = Ucontext_tType->getAs<TagType>();
3255 assert(Tag && "Invalid ucontext_t type in AST file");
3256 Context.setucontext_tDecl(Tag->getDecl());
3257 }
3258 }
3259 }
Douglas Gregor5f957282011-08-11 22:18:49 +00003260 }
3261
Douglas Gregor35942772011-09-09 21:34:22 +00003262 ReadPragmaDiagnosticMappings(Context.getDiagnostics());
Peter Collingbourne14b6ba72011-02-09 21:04:32 +00003263
3264 // If there were any CUDA special declarations, deserialize them.
3265 if (!CUDASpecialDeclRefs.empty()) {
3266 assert(CUDASpecialDeclRefs.size() == 1 && "More decl refs than expected!");
Douglas Gregor35942772011-09-09 21:34:22 +00003267 Context.setcudaConfigureCallDecl(
Peter Collingbourne14b6ba72011-02-09 21:04:32 +00003268 cast<FunctionDecl>(GetDecl(CUDASpecialDeclRefs[0])));
3269 }
Douglas Gregorf6137e42011-12-03 00:59:55 +00003270
3271 // Re-export any modules that were imported by a non-module AST file.
3272 for (unsigned I = 0, N = ImportedModules.size(); I != N; ++I) {
3273 if (Module *Imported = getSubmodule(ImportedModules[I]))
3274 makeModuleVisible(Imported, Module::AllVisible);
3275 }
3276 ImportedModules.clear();
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00003277}
3278
Douglas Gregorecc2c092011-12-01 22:20:10 +00003279void ASTReader::finalizeForWriting() {
3280 for (HiddenNamesMapType::iterator Hidden = HiddenNamesMap.begin(),
3281 HiddenEnd = HiddenNamesMap.end();
3282 Hidden != HiddenEnd; ++Hidden) {
3283 makeNamesVisible(Hidden->second);
3284 }
3285 HiddenNamesMap.clear();
3286}
3287
Douglas Gregorb64c1932009-05-12 01:31:05 +00003288/// \brief Retrieve the name of the original source file name
Sebastian Redl3c7f4132010-08-18 23:57:06 +00003289/// directly from the AST file, without actually loading the AST
Douglas Gregorb64c1932009-05-12 01:31:05 +00003290/// file.
Sebastian Redl3c7f4132010-08-18 23:57:06 +00003291std::string ASTReader::getOriginalSourceFile(const std::string &ASTFileName,
Argyrios Kyrtzidis389db162010-11-03 22:45:23 +00003292 FileManager &FileMgr,
David Blaikied6471f72011-09-25 23:23:43 +00003293 DiagnosticsEngine &Diags) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00003294 // Open the AST file.
Douglas Gregorb64c1932009-05-12 01:31:05 +00003295 std::string ErrStr;
Dylan Noblesmith6f42b622012-02-05 02:12:40 +00003296 OwningPtr<llvm::MemoryBuffer> Buffer;
Chris Lattner39b49bc2010-11-23 08:35:12 +00003297 Buffer.reset(FileMgr.getBufferForFile(ASTFileName, &ErrStr));
Douglas Gregorb64c1932009-05-12 01:31:05 +00003298 if (!Buffer) {
Kaelyn Uhrainda01f622012-06-20 00:36:03 +00003299 Diags.Report(diag::err_fe_unable_to_read_pch_file) << ASTFileName << ErrStr;
Douglas Gregorb64c1932009-05-12 01:31:05 +00003300 return std::string();
3301 }
3302
3303 // Initialize the stream
3304 llvm::BitstreamReader StreamFile;
3305 llvm::BitstreamCursor Stream;
Mike Stump1eb44332009-09-09 15:08:12 +00003306 StreamFile.init((const unsigned char *)Buffer->getBufferStart(),
Douglas Gregorb64c1932009-05-12 01:31:05 +00003307 (const unsigned char *)Buffer->getBufferEnd());
3308 Stream.init(StreamFile);
3309
3310 // Sniff for the signature.
3311 if (Stream.Read(8) != 'C' ||
3312 Stream.Read(8) != 'P' ||
3313 Stream.Read(8) != 'C' ||
3314 Stream.Read(8) != 'H') {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00003315 Diags.Report(diag::err_fe_not_a_pch_file) << ASTFileName;
Douglas Gregorb64c1932009-05-12 01:31:05 +00003316 return std::string();
3317 }
3318
3319 RecordData Record;
3320 while (!Stream.AtEndOfStream()) {
3321 unsigned Code = Stream.ReadCode();
Mike Stump1eb44332009-09-09 15:08:12 +00003322
Douglas Gregorb64c1932009-05-12 01:31:05 +00003323 if (Code == llvm::bitc::ENTER_SUBBLOCK) {
3324 unsigned BlockID = Stream.ReadSubBlockID();
Mike Stump1eb44332009-09-09 15:08:12 +00003325
Sebastian Redl3c7f4132010-08-18 23:57:06 +00003326 // We only know the AST subblock ID.
Douglas Gregorb64c1932009-05-12 01:31:05 +00003327 switch (BlockID) {
Douglas Gregor1d9d9892012-10-18 05:31:06 +00003328 case CONTROL_BLOCK_ID:
3329 if (Stream.EnterSubBlock(CONTROL_BLOCK_ID)) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00003330 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
Douglas Gregorb64c1932009-05-12 01:31:05 +00003331 return std::string();
3332 }
3333 break;
Mike Stump1eb44332009-09-09 15:08:12 +00003334
Douglas Gregorb64c1932009-05-12 01:31:05 +00003335 default:
3336 if (Stream.SkipBlock()) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00003337 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
Douglas Gregorb64c1932009-05-12 01:31:05 +00003338 return std::string();
3339 }
3340 break;
3341 }
3342 continue;
3343 }
3344
3345 if (Code == llvm::bitc::END_BLOCK) {
3346 if (Stream.ReadBlockEnd()) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00003347 Diags.Report(diag::err_fe_pch_error_at_end_block) << ASTFileName;
Douglas Gregorb64c1932009-05-12 01:31:05 +00003348 return std::string();
3349 }
3350 continue;
3351 }
3352
3353 if (Code == llvm::bitc::DEFINE_ABBREV) {
3354 Stream.ReadAbbrevRecord();
3355 continue;
3356 }
3357
3358 Record.clear();
3359 const char *BlobStart = 0;
3360 unsigned BlobLen = 0;
Douglas Gregor39c497b2012-10-18 18:36:53 +00003361 if (Stream.ReadRecord(Code, Record, &BlobStart, &BlobLen) == ORIGINAL_FILE)
Douglas Gregorb64c1932009-05-12 01:31:05 +00003362 return std::string(BlobStart, BlobLen);
Mike Stump1eb44332009-09-09 15:08:12 +00003363 }
Douglas Gregorb64c1932009-05-12 01:31:05 +00003364
3365 return std::string();
3366}
3367
Douglas Gregor27ffa6c2012-10-23 06:18:24 +00003368namespace {
3369 class SimplePCHValidator : public ASTReaderListener {
3370 const LangOptions &ExistingLangOpts;
3371 const TargetOptions &ExistingTargetOpts;
3372
3373 public:
3374 SimplePCHValidator(const LangOptions &ExistingLangOpts,
3375 const TargetOptions &ExistingTargetOpts)
3376 : ExistingLangOpts(ExistingLangOpts),
3377 ExistingTargetOpts(ExistingTargetOpts)
3378 {
3379 }
3380
3381 virtual bool ReadLanguageOptions(const LangOptions &LangOpts,
3382 bool Complain) {
3383 return checkLanguageOptions(ExistingLangOpts, LangOpts, 0);
3384 }
3385 virtual bool ReadTargetOptions(const TargetOptions &TargetOpts,
3386 bool Complain) {
3387 return checkTargetOptions(ExistingTargetOpts, TargetOpts, 0);
3388 }
3389 };
3390}
3391
3392bool ASTReader::isAcceptableASTFile(StringRef Filename,
3393 FileManager &FileMgr,
3394 const LangOptions &LangOpts,
3395 const TargetOptions &TargetOpts) {
3396 // Open the AST file.
3397 std::string ErrStr;
3398 OwningPtr<llvm::MemoryBuffer> Buffer;
3399 Buffer.reset(FileMgr.getBufferForFile(Filename, &ErrStr));
3400 if (!Buffer) {
3401 return false;
3402 }
3403
3404 // Initialize the stream
3405 llvm::BitstreamReader StreamFile;
3406 llvm::BitstreamCursor Stream;
3407 StreamFile.init((const unsigned char *)Buffer->getBufferStart(),
3408 (const unsigned char *)Buffer->getBufferEnd());
3409 Stream.init(StreamFile);
3410
3411 // Sniff for the signature.
3412 if (Stream.Read(8) != 'C' ||
3413 Stream.Read(8) != 'P' ||
3414 Stream.Read(8) != 'C' ||
3415 Stream.Read(8) != 'H') {
3416 return false;
3417 }
3418
3419 SimplePCHValidator Validator(LangOpts, TargetOpts);
3420 RecordData Record;
3421 bool InControlBlock = false;
3422 while (!Stream.AtEndOfStream()) {
3423 unsigned Code = Stream.ReadCode();
3424
3425 if (Code == llvm::bitc::ENTER_SUBBLOCK) {
3426 unsigned BlockID = Stream.ReadSubBlockID();
3427
3428 // We only know the control subblock ID.
3429 switch (BlockID) {
3430 case CONTROL_BLOCK_ID:
3431 if (Stream.EnterSubBlock(CONTROL_BLOCK_ID)) {
3432 return false;
3433 } else {
3434 InControlBlock = true;
3435 }
3436 break;
3437
3438 default:
3439 if (Stream.SkipBlock())
3440 return false;
3441 break;
3442 }
3443 continue;
3444 }
3445
3446 if (Code == llvm::bitc::END_BLOCK) {
3447 if (Stream.ReadBlockEnd()) {
3448 return false;
3449 }
3450 InControlBlock = false;
3451 continue;
3452 }
3453
3454 if (Code == llvm::bitc::DEFINE_ABBREV) {
3455 Stream.ReadAbbrevRecord();
3456 continue;
3457 }
3458
3459 Record.clear();
3460 const char *BlobStart = 0;
3461 unsigned BlobLen = 0;
3462 unsigned RecCode = Stream.ReadRecord(Code, Record, &BlobStart, &BlobLen);
3463 if (InControlBlock) {
3464 switch ((ControlRecordTypes)RecCode) {
3465 case METADATA: {
3466 if (Record[0] != VERSION_MAJOR) {
3467 return false;
3468 }
3469
3470 const std::string &CurBranch = getClangFullRepositoryVersion();
3471 StringRef ASTBranch(BlobStart, BlobLen);
3472 if (StringRef(CurBranch) != ASTBranch)
3473 return false;
3474
3475 break;
3476 }
3477 case LANGUAGE_OPTIONS:
3478 if (ParseLanguageOptions(Record, false, Validator))
3479 return false;
3480 break;
3481
3482 case TARGET_OPTIONS:
3483 if (ParseTargetOptions(Record, false, Validator))
3484 return false;
3485 break;
3486
Douglas Gregor5f3d8222012-10-24 15:17:15 +00003487 case DIAGNOSTIC_OPTIONS:
3488 if (ParseDiagnosticOptions(Record, false, Validator))
3489 return false;
3490 break;
3491
Douglas Gregor27ffa6c2012-10-23 06:18:24 +00003492 default:
3493 // No other validation to perform.
3494 break;
3495 }
3496 }
3497 }
3498
3499 return true;
3500}
3501
Douglas Gregor4825fd72012-10-22 22:50:17 +00003502bool ASTReader::ReadSubmoduleBlock(ModuleFile &F) {
Douglas Gregor392ed2b2011-11-30 17:33:56 +00003503 // Enter the submodule block.
3504 if (F.Stream.EnterSubBlock(SUBMODULE_BLOCK_ID)) {
3505 Error("malformed submodule block record in AST file");
Douglas Gregor4825fd72012-10-22 22:50:17 +00003506 return true;
Douglas Gregor392ed2b2011-11-30 17:33:56 +00003507 }
3508
3509 ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap();
Douglas Gregor26ced122011-12-01 00:59:36 +00003510 bool First = true;
Douglas Gregor1a4761e2011-11-30 23:21:26 +00003511 Module *CurrentModule = 0;
Douglas Gregor392ed2b2011-11-30 17:33:56 +00003512 RecordData Record;
3513 while (true) {
3514 unsigned Code = F.Stream.ReadCode();
3515 if (Code == llvm::bitc::END_BLOCK) {
3516 if (F.Stream.ReadBlockEnd()) {
3517 Error("error at end of submodule block in AST file");
Douglas Gregor4825fd72012-10-22 22:50:17 +00003518 return true;
Douglas Gregor392ed2b2011-11-30 17:33:56 +00003519 }
Douglas Gregor4825fd72012-10-22 22:50:17 +00003520 return false;
Douglas Gregor392ed2b2011-11-30 17:33:56 +00003521 }
3522
3523 if (Code == llvm::bitc::ENTER_SUBBLOCK) {
3524 // No known subblocks, always skip them.
3525 F.Stream.ReadSubBlockID();
3526 if (F.Stream.SkipBlock()) {
3527 Error("malformed block record in AST file");
Douglas Gregor4825fd72012-10-22 22:50:17 +00003528 return true;
Douglas Gregor392ed2b2011-11-30 17:33:56 +00003529 }
3530 continue;
3531 }
3532
3533 if (Code == llvm::bitc::DEFINE_ABBREV) {
3534 F.Stream.ReadAbbrevRecord();
3535 continue;
3536 }
3537
3538 // Read a record.
3539 const char *BlobStart;
3540 unsigned BlobLen;
3541 Record.clear();
3542 switch (F.Stream.ReadRecord(Code, Record, &BlobStart, &BlobLen)) {
3543 default: // Default behavior: ignore.
3544 break;
3545
3546 case SUBMODULE_DEFINITION: {
Douglas Gregor26ced122011-12-01 00:59:36 +00003547 if (First) {
3548 Error("missing submodule metadata record at beginning of block");
Douglas Gregor4825fd72012-10-22 22:50:17 +00003549 return true;
Douglas Gregor26ced122011-12-01 00:59:36 +00003550 }
3551
Douglas Gregore209e502011-12-06 01:10:29 +00003552 if (Record.size() < 7) {
Douglas Gregor1e123682011-12-05 22:27:44 +00003553 Error("malformed module definition");
Douglas Gregor4825fd72012-10-22 22:50:17 +00003554 return true;
Douglas Gregor1e123682011-12-05 22:27:44 +00003555 }
3556
Douglas Gregor392ed2b2011-11-30 17:33:56 +00003557 StringRef Name(BlobStart, BlobLen);
Douglas Gregore209e502011-12-06 01:10:29 +00003558 SubmoduleID GlobalID = getGlobalSubmoduleID(F, Record[0]);
3559 SubmoduleID Parent = getGlobalSubmoduleID(F, Record[1]);
3560 bool IsFramework = Record[2];
3561 bool IsExplicit = Record[3];
Douglas Gregora1f1fad2012-01-27 19:52:33 +00003562 bool IsSystem = Record[4];
3563 bool InferSubmodules = Record[5];
3564 bool InferExplicitSubmodules = Record[6];
3565 bool InferExportWildcard = Record[7];
Douglas Gregor1e123682011-12-05 22:27:44 +00003566
Douglas Gregor1a4761e2011-11-30 23:21:26 +00003567 Module *ParentModule = 0;
Douglas Gregor26ced122011-12-01 00:59:36 +00003568 if (Parent)
3569 ParentModule = getSubmodule(Parent);
Douglas Gregor392ed2b2011-11-30 17:33:56 +00003570
3571 // Retrieve this (sub)module from the module map, creating it if
3572 // necessary.
3573 CurrentModule = ModMap.findOrCreateModule(Name, ParentModule,
3574 IsFramework,
3575 IsExplicit).first;
Douglas Gregore209e502011-12-06 01:10:29 +00003576 SubmoduleID GlobalIndex = GlobalID - NUM_PREDEF_SUBMODULE_IDS;
3577 if (GlobalIndex >= SubmodulesLoaded.size() ||
3578 SubmodulesLoaded[GlobalIndex]) {
Douglas Gregor26ced122011-12-01 00:59:36 +00003579 Error("too many submodules");
Douglas Gregor4825fd72012-10-22 22:50:17 +00003580 return true;
Douglas Gregor26ced122011-12-01 00:59:36 +00003581 }
Douglas Gregora015cab2011-12-02 17:30:13 +00003582
Argyrios Kyrtzidisd64c26f2012-10-03 01:58:42 +00003583 CurrentModule->setASTFile(F.File);
Douglas Gregor305dc3e2011-12-20 00:28:52 +00003584 CurrentModule->IsFromModuleFile = true;
Douglas Gregora1f1fad2012-01-27 19:52:33 +00003585 CurrentModule->IsSystem = IsSystem || CurrentModule->IsSystem;
Douglas Gregor1e123682011-12-05 22:27:44 +00003586 CurrentModule->InferSubmodules = InferSubmodules;
3587 CurrentModule->InferExplicitSubmodules = InferExplicitSubmodules;
3588 CurrentModule->InferExportWildcard = InferExportWildcard;
Douglas Gregora015cab2011-12-02 17:30:13 +00003589 if (DeserializationListener)
Douglas Gregore209e502011-12-06 01:10:29 +00003590 DeserializationListener->ModuleRead(GlobalID, CurrentModule);
Douglas Gregora015cab2011-12-02 17:30:13 +00003591
Douglas Gregore209e502011-12-06 01:10:29 +00003592 SubmodulesLoaded[GlobalIndex] = CurrentModule;
Douglas Gregor392ed2b2011-11-30 17:33:56 +00003593 break;
3594 }
3595
Douglas Gregor77d029f2011-12-08 19:11:24 +00003596 case SUBMODULE_UMBRELLA_HEADER: {
Douglas Gregor26ced122011-12-01 00:59:36 +00003597 if (First) {
3598 Error("missing submodule metadata record at beginning of block");
Douglas Gregor4825fd72012-10-22 22:50:17 +00003599 return true;
Douglas Gregor26ced122011-12-01 00:59:36 +00003600 }
3601
Douglas Gregor392ed2b2011-11-30 17:33:56 +00003602 if (!CurrentModule)
3603 break;
3604
3605 StringRef FileName(BlobStart, BlobLen);
3606 if (const FileEntry *Umbrella = PP.getFileManager().getFile(FileName)) {
Douglas Gregor10694ce2011-12-08 17:39:04 +00003607 if (!CurrentModule->getUmbrellaHeader())
Douglas Gregore209e502011-12-06 01:10:29 +00003608 ModMap.setUmbrellaHeader(CurrentModule, Umbrella);
Douglas Gregor10694ce2011-12-08 17:39:04 +00003609 else if (CurrentModule->getUmbrellaHeader() != Umbrella) {
Douglas Gregor392ed2b2011-11-30 17:33:56 +00003610 Error("mismatched umbrella headers in submodule");
Douglas Gregor4825fd72012-10-22 22:50:17 +00003611 return true;
Douglas Gregor392ed2b2011-11-30 17:33:56 +00003612 }
3613 }
3614 break;
3615 }
3616
3617 case SUBMODULE_HEADER: {
Douglas Gregor26ced122011-12-01 00:59:36 +00003618 if (First) {
3619 Error("missing submodule metadata record at beginning of block");
Douglas Gregor4825fd72012-10-22 22:50:17 +00003620 return true;
Douglas Gregor26ced122011-12-01 00:59:36 +00003621 }
3622
Douglas Gregor392ed2b2011-11-30 17:33:56 +00003623 if (!CurrentModule)
3624 break;
3625
3626 // FIXME: Be more lazy about this!
3627 StringRef FileName(BlobStart, BlobLen);
3628 if (const FileEntry *File = PP.getFileManager().getFile(FileName)) {
3629 if (std::find(CurrentModule->Headers.begin(),
3630 CurrentModule->Headers.end(),
3631 File) == CurrentModule->Headers.end())
Douglas Gregor2b49d1f2012-10-15 06:28:11 +00003632 ModMap.addHeader(CurrentModule, File, false);
3633 }
3634 break;
3635 }
3636
3637 case SUBMODULE_EXCLUDED_HEADER: {
3638 if (First) {
3639 Error("missing submodule metadata record at beginning of block");
Douglas Gregor4825fd72012-10-22 22:50:17 +00003640 return true;
Douglas Gregor2b49d1f2012-10-15 06:28:11 +00003641 }
3642
3643 if (!CurrentModule)
3644 break;
3645
3646 // FIXME: Be more lazy about this!
3647 StringRef FileName(BlobStart, BlobLen);
3648 if (const FileEntry *File = PP.getFileManager().getFile(FileName)) {
3649 if (std::find(CurrentModule->Headers.begin(),
3650 CurrentModule->Headers.end(),
3651 File) == CurrentModule->Headers.end())
3652 ModMap.addHeader(CurrentModule, File, true);
Douglas Gregor392ed2b2011-11-30 17:33:56 +00003653 }
3654 break;
3655 }
Argyrios Kyrtzidisc7782d92012-10-05 00:22:33 +00003656
3657 case SUBMODULE_TOPHEADER: {
3658 if (First) {
3659 Error("missing submodule metadata record at beginning of block");
Douglas Gregor4825fd72012-10-22 22:50:17 +00003660 return true;
Argyrios Kyrtzidisc7782d92012-10-05 00:22:33 +00003661 }
3662
3663 if (!CurrentModule)
3664 break;
3665
3666 // FIXME: Be more lazy about this!
3667 StringRef FileName(BlobStart, BlobLen);
3668 if (const FileEntry *File = PP.getFileManager().getFile(FileName))
3669 CurrentModule->TopHeaders.insert(File);
3670 break;
3671 }
3672
Douglas Gregor77d029f2011-12-08 19:11:24 +00003673 case SUBMODULE_UMBRELLA_DIR: {
3674 if (First) {
3675 Error("missing submodule metadata record at beginning of block");
Douglas Gregor4825fd72012-10-22 22:50:17 +00003676 return true;
Douglas Gregor77d029f2011-12-08 19:11:24 +00003677 }
3678
3679 if (!CurrentModule)
3680 break;
3681
3682 StringRef DirName(BlobStart, BlobLen);
3683 if (const DirectoryEntry *Umbrella
3684 = PP.getFileManager().getDirectory(DirName)) {
3685 if (!CurrentModule->getUmbrellaDir())
3686 ModMap.setUmbrellaDir(CurrentModule, Umbrella);
3687 else if (CurrentModule->getUmbrellaDir() != Umbrella) {
3688 Error("mismatched umbrella directories in submodule");
Douglas Gregor4825fd72012-10-22 22:50:17 +00003689 return true;
Douglas Gregor77d029f2011-12-08 19:11:24 +00003690 }
3691 }
3692 break;
3693 }
3694
Douglas Gregor26ced122011-12-01 00:59:36 +00003695 case SUBMODULE_METADATA: {
3696 if (!First) {
3697 Error("submodule metadata record not at beginning of block");
Douglas Gregor4825fd72012-10-22 22:50:17 +00003698 return true;
Douglas Gregor26ced122011-12-01 00:59:36 +00003699 }
3700 First = false;
3701
3702 F.BaseSubmoduleID = getTotalNumSubmodules();
Douglas Gregor26ced122011-12-01 00:59:36 +00003703 F.LocalNumSubmodules = Record[0];
3704 unsigned LocalBaseSubmoduleID = Record[1];
3705 if (F.LocalNumSubmodules > 0) {
3706 // Introduce the global -> local mapping for submodules within this
3707 // module.
3708 GlobalSubmoduleMap.insert(std::make_pair(getTotalNumSubmodules()+1,&F));
3709
3710 // Introduce the local -> global mapping for submodules within this
3711 // module.
Douglas Gregoradafc2e2011-12-19 16:14:14 +00003712 F.SubmoduleRemap.insertOrReplace(
Douglas Gregor26ced122011-12-01 00:59:36 +00003713 std::make_pair(LocalBaseSubmoduleID,
3714 F.BaseSubmoduleID - LocalBaseSubmoduleID));
3715
3716 SubmodulesLoaded.resize(SubmodulesLoaded.size() + F.LocalNumSubmodules);
3717 }
3718 break;
3719 }
Douglas Gregoraf13bfc2011-12-02 18:58:38 +00003720
Douglas Gregor55988682011-12-05 16:33:54 +00003721 case SUBMODULE_IMPORTS: {
3722 if (First) {
3723 Error("missing submodule metadata record at beginning of block");
Douglas Gregor4825fd72012-10-22 22:50:17 +00003724 return true;
Douglas Gregor55988682011-12-05 16:33:54 +00003725 }
3726
3727 if (!CurrentModule)
3728 break;
3729
3730 for (unsigned Idx = 0; Idx != Record.size(); ++Idx) {
3731 UnresolvedModuleImportExport Unresolved;
3732 Unresolved.File = &F;
3733 Unresolved.Mod = CurrentModule;
3734 Unresolved.ID = Record[Idx];
3735 Unresolved.IsImport = true;
3736 Unresolved.IsWildcard = false;
3737 UnresolvedModuleImportExports.push_back(Unresolved);
3738 }
3739 break;
3740 }
3741
Douglas Gregoraf13bfc2011-12-02 18:58:38 +00003742 case SUBMODULE_EXPORTS: {
3743 if (First) {
3744 Error("missing submodule metadata record at beginning of block");
Douglas Gregor4825fd72012-10-22 22:50:17 +00003745 return true;
Douglas Gregoraf13bfc2011-12-02 18:58:38 +00003746 }
3747
3748 if (!CurrentModule)
3749 break;
3750
3751 for (unsigned Idx = 0; Idx + 1 < Record.size(); Idx += 2) {
Douglas Gregor55988682011-12-05 16:33:54 +00003752 UnresolvedModuleImportExport Unresolved;
Douglas Gregoraf13bfc2011-12-02 18:58:38 +00003753 Unresolved.File = &F;
Douglas Gregor55988682011-12-05 16:33:54 +00003754 Unresolved.Mod = CurrentModule;
3755 Unresolved.ID = Record[Idx];
3756 Unresolved.IsImport = false;
3757 Unresolved.IsWildcard = Record[Idx + 1];
3758 UnresolvedModuleImportExports.push_back(Unresolved);
Douglas Gregoraf13bfc2011-12-02 18:58:38 +00003759 }
3760
3761 // Once we've loaded the set of exports, there's no reason to keep
3762 // the parsed, unresolved exports around.
3763 CurrentModule->UnresolvedExports.clear();
3764 break;
3765 }
Douglas Gregor51f564f2011-12-31 04:05:44 +00003766 case SUBMODULE_REQUIRES: {
3767 if (First) {
3768 Error("missing submodule metadata record at beginning of block");
Douglas Gregor4825fd72012-10-22 22:50:17 +00003769 return true;
Douglas Gregor51f564f2011-12-31 04:05:44 +00003770 }
3771
3772 if (!CurrentModule)
3773 break;
3774
3775 CurrentModule->addRequirement(StringRef(BlobStart, BlobLen),
David Blaikie4e4d0842012-03-11 07:00:24 +00003776 Context.getLangOpts(),
Douglas Gregordc58aa72012-01-30 06:01:29 +00003777 Context.getTargetInfo());
Douglas Gregor51f564f2011-12-31 04:05:44 +00003778 break;
3779 }
Douglas Gregor392ed2b2011-11-30 17:33:56 +00003780 }
3781 }
Douglas Gregor392ed2b2011-11-30 17:33:56 +00003782}
3783
Douglas Gregor0a0428e2009-04-10 20:39:37 +00003784/// \brief Parse the record that corresponds to a LangOptions data
3785/// structure.
3786///
Sebastian Redl3c7f4132010-08-18 23:57:06 +00003787/// This routine parses the language options from the AST file and then gives
3788/// them to the AST listener if one is set.
Douglas Gregor0a0428e2009-04-10 20:39:37 +00003789///
Sebastian Redl3c7f4132010-08-18 23:57:06 +00003790/// \returns true if the listener deems the file unacceptable, false otherwise.
Douglas Gregor27ffa6c2012-10-23 06:18:24 +00003791bool ASTReader::ParseLanguageOptions(const RecordData &Record,
3792 bool Complain,
3793 ASTReaderListener &Listener) {
3794 LangOptions LangOpts;
3795 unsigned Idx = 0;
Douglas Gregor7d5e81b2011-09-13 18:26:39 +00003796#define LANGOPT(Name, Bits, Default, Description) \
3797 LangOpts.Name = Record[Idx++];
3798#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
3799 LangOpts.set##Name(static_cast<LangOptions::Type>(Record[Idx++]));
3800#include "clang/Basic/LangOptions.def"
John McCall260611a2012-06-20 06:18:46 +00003801
Douglas Gregor27ffa6c2012-10-23 06:18:24 +00003802 ObjCRuntime::Kind runtimeKind = (ObjCRuntime::Kind) Record[Idx++];
3803 VersionTuple runtimeVersion = ReadVersionTuple(Record, Idx);
3804 LangOpts.ObjCRuntime = ObjCRuntime(runtimeKind, runtimeVersion);
3805
3806 unsigned Length = Record[Idx++];
3807 LangOpts.CurrentModule.assign(Record.begin() + Idx,
3808 Record.begin() + Idx + Length);
3809 return Listener.ReadLanguageOptions(LangOpts, Complain);
3810}
3811
3812bool ASTReader::ParseTargetOptions(const RecordData &Record,
3813 bool Complain,
3814 ASTReaderListener &Listener) {
3815 unsigned Idx = 0;
3816 TargetOptions TargetOpts;
3817 TargetOpts.Triple = ReadString(Record, Idx);
3818 TargetOpts.CPU = ReadString(Record, Idx);
3819 TargetOpts.ABI = ReadString(Record, Idx);
3820 TargetOpts.CXXABI = ReadString(Record, Idx);
3821 TargetOpts.LinkerVersion = ReadString(Record, Idx);
3822 for (unsigned N = Record[Idx++]; N; --N) {
3823 TargetOpts.FeaturesAsWritten.push_back(ReadString(Record, Idx));
3824 }
3825 for (unsigned N = Record[Idx++]; N; --N) {
3826 TargetOpts.Features.push_back(ReadString(Record, Idx));
Douglas Gregor0a0428e2009-04-10 20:39:37 +00003827 }
Douglas Gregor0a0428e2009-04-10 20:39:37 +00003828
Douglas Gregor27ffa6c2012-10-23 06:18:24 +00003829 return Listener.ReadTargetOptions(TargetOpts, Complain);
Douglas Gregor0a0428e2009-04-10 20:39:37 +00003830}
3831
Douglas Gregor5f3d8222012-10-24 15:17:15 +00003832bool ASTReader::ParseDiagnosticOptions(const RecordData &Record, bool Complain,
3833 ASTReaderListener &Listener) {
3834 DiagnosticOptions DiagOpts;
3835 unsigned Idx = 0;
3836#define DIAGOPT(Name, Bits, Default) DiagOpts.Name = Record[Idx++];
3837#define ENUM_DIAGOPT(Name, Type, Bits, Default) \
3838 DiagOpts.set##Name(static_cast<Type>(Record[Idx++]));
3839#include "clang/Basic/DiagnosticOptions.def"
3840
3841 for (unsigned N = Record[Idx++]; N; --N) {
3842 DiagOpts.Warnings.push_back(ReadString(Record, Idx));
3843 }
3844
3845 return Listener.ReadDiagnosticOptions(DiagOpts, Complain);
3846}
3847
Douglas Gregor1b2c3c02012-10-24 15:49:58 +00003848bool ASTReader::ParseFileSystemOptions(const RecordData &Record, bool Complain,
3849 ASTReaderListener &Listener) {
3850 FileSystemOptions FSOpts;
3851 unsigned Idx = 0;
3852 FSOpts.WorkingDir = ReadString(Record, Idx);
3853 return Listener.ReadFileSystemOptions(FSOpts, Complain);
3854}
3855
Douglas Gregor1a4761e2011-11-30 23:21:26 +00003856std::pair<ModuleFile *, unsigned>
Argyrios Kyrtzidisf226ff92011-10-25 00:29:50 +00003857ASTReader::getModulePreprocessedEntity(unsigned GlobalIndex) {
Argyrios Kyrtzidise24692b2011-09-15 18:02:56 +00003858 GlobalPreprocessedEntityMapType::iterator
Argyrios Kyrtzidisf226ff92011-10-25 00:29:50 +00003859 I = GlobalPreprocessedEntityMap.find(GlobalIndex);
Argyrios Kyrtzidise24692b2011-09-15 18:02:56 +00003860 assert(I != GlobalPreprocessedEntityMap.end() &&
3861 "Corrupted global preprocessed entity map");
Douglas Gregor1a4761e2011-11-30 23:21:26 +00003862 ModuleFile *M = I->second;
Argyrios Kyrtzidisf226ff92011-10-25 00:29:50 +00003863 unsigned LocalIndex = GlobalIndex - M->BasePreprocessedEntityID;
3864 return std::make_pair(M, LocalIndex);
3865}
3866
Argyrios Kyrtzidis632dcc92012-10-02 16:10:51 +00003867std::pair<PreprocessingRecord::iterator, PreprocessingRecord::iterator>
3868ASTReader::getModulePreprocessedEntities(ModuleFile &Mod) const {
3869 if (PreprocessingRecord *PPRec = PP.getPreprocessingRecord())
3870 return PPRec->getIteratorsForLoadedRange(Mod.BasePreprocessedEntityID,
3871 Mod.NumPreprocessedEntities);
3872
3873 return std::make_pair(PreprocessingRecord::iterator(),
3874 PreprocessingRecord::iterator());
3875}
3876
Argyrios Kyrtzidis2093e0b2012-10-02 21:09:13 +00003877std::pair<ASTReader::ModuleDeclIterator, ASTReader::ModuleDeclIterator>
3878ASTReader::getModuleFileLevelDecls(ModuleFile &Mod) {
3879 return std::make_pair(ModuleDeclIterator(this, &Mod, Mod.FileSortedDecls),
3880 ModuleDeclIterator(this, &Mod,
3881 Mod.FileSortedDecls + Mod.NumFileSortedDecls));
3882}
3883
Argyrios Kyrtzidisf226ff92011-10-25 00:29:50 +00003884PreprocessedEntity *ASTReader::ReadPreprocessedEntity(unsigned Index) {
3885 PreprocessedEntityID PPID = Index+1;
Douglas Gregor1a4761e2011-11-30 23:21:26 +00003886 std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index);
3887 ModuleFile &M = *PPInfo.first;
Argyrios Kyrtzidisf226ff92011-10-25 00:29:50 +00003888 unsigned LocalIndex = PPInfo.second;
Argyrios Kyrtzidis8f958f12011-09-20 23:27:41 +00003889 const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex];
Douglas Gregor4800a5c2011-02-08 21:58:10 +00003890
Argyrios Kyrtzidise24692b2011-09-15 18:02:56 +00003891 SavedStreamPosition SavedPosition(M.PreprocessorDetailCursor);
Argyrios Kyrtzidis8f958f12011-09-20 23:27:41 +00003892 M.PreprocessorDetailCursor.JumpToBit(PPOffs.BitOffset);
Argyrios Kyrtzidis290ad8c2011-09-20 23:27:38 +00003893
3894 unsigned Code = M.PreprocessorDetailCursor.ReadCode();
3895 switch (Code) {
3896 case llvm::bitc::END_BLOCK:
3897 return 0;
3898
3899 case llvm::bitc::ENTER_SUBBLOCK:
3900 Error("unexpected subblock record in preprocessor detail block");
3901 return 0;
3902
3903 case llvm::bitc::DEFINE_ABBREV:
3904 Error("unexpected abbrevation record in preprocessor detail block");
3905 return 0;
3906
3907 default:
3908 break;
3909 }
3910
3911 if (!PP.getPreprocessingRecord()) {
3912 Error("no preprocessing record");
3913 return 0;
3914 }
3915
3916 // Read the record.
Argyrios Kyrtzidis8f958f12011-09-20 23:27:41 +00003917 SourceRange Range(ReadSourceLocation(M, PPOffs.Begin),
3918 ReadSourceLocation(M, PPOffs.End));
Argyrios Kyrtzidis290ad8c2011-09-20 23:27:38 +00003919 PreprocessingRecord &PPRec = *PP.getPreprocessingRecord();
3920 const char *BlobStart = 0;
3921 unsigned BlobLen = 0;
3922 RecordData Record;
3923 PreprocessorDetailRecordTypes RecType =
3924 (PreprocessorDetailRecordTypes)M.PreprocessorDetailCursor.ReadRecord(
3925 Code, Record, BlobStart, BlobLen);
3926 switch (RecType) {
3927 case PPD_MACRO_EXPANSION: {
Argyrios Kyrtzidis8f958f12011-09-20 23:27:41 +00003928 bool isBuiltin = Record[0];
Argyrios Kyrtzidis290ad8c2011-09-20 23:27:38 +00003929 IdentifierInfo *Name = 0;
3930 MacroDefinition *Def = 0;
3931 if (isBuiltin)
Argyrios Kyrtzidis8f958f12011-09-20 23:27:41 +00003932 Name = getLocalIdentifier(M, Record[1]);
Argyrios Kyrtzidis290ad8c2011-09-20 23:27:38 +00003933 else {
3934 PreprocessedEntityID
Argyrios Kyrtzidis8f958f12011-09-20 23:27:41 +00003935 GlobalID = getGlobalPreprocessedEntityID(M, Record[1]);
Argyrios Kyrtzidis290ad8c2011-09-20 23:27:38 +00003936 Def =cast<MacroDefinition>(PPRec.getLoadedPreprocessedEntity(GlobalID-1));
3937 }
3938
3939 MacroExpansion *ME;
3940 if (isBuiltin)
3941 ME = new (PPRec) MacroExpansion(Name, Range);
3942 else
3943 ME = new (PPRec) MacroExpansion(Def, Range);
3944
3945 return ME;
3946 }
3947
3948 case PPD_MACRO_DEFINITION: {
3949 // Decode the identifier info and then check again; if the macro is
3950 // still defined and associated with the identifier,
Argyrios Kyrtzidis8f958f12011-09-20 23:27:41 +00003951 IdentifierInfo *II = getLocalIdentifier(M, Record[0]);
Argyrios Kyrtzidis290ad8c2011-09-20 23:27:38 +00003952 MacroDefinition *MD
Argyrios Kyrtzidis8f958f12011-09-20 23:27:41 +00003953 = new (PPRec) MacroDefinition(II, Range);
Argyrios Kyrtzidis290ad8c2011-09-20 23:27:38 +00003954
3955 if (DeserializationListener)
3956 DeserializationListener->MacroDefinitionRead(PPID, MD);
3957
3958 return MD;
3959 }
3960
3961 case PPD_INCLUSION_DIRECTIVE: {
Argyrios Kyrtzidis8f958f12011-09-20 23:27:41 +00003962 const char *FullFileNameStart = BlobStart + Record[0];
Argyrios Kyrtzidis29f98b42012-03-08 01:08:28 +00003963 StringRef FullFileName(FullFileNameStart, BlobLen - Record[0]);
3964 const FileEntry *File = 0;
3965 if (!FullFileName.empty())
3966 File = PP.getFileManager().getFile(FullFileName);
Argyrios Kyrtzidis290ad8c2011-09-20 23:27:38 +00003967
3968 // FIXME: Stable encoding
3969 InclusionDirective::InclusionKind Kind
Argyrios Kyrtzidis8f958f12011-09-20 23:27:41 +00003970 = static_cast<InclusionDirective::InclusionKind>(Record[2]);
Argyrios Kyrtzidis290ad8c2011-09-20 23:27:38 +00003971 InclusionDirective *ID
3972 = new (PPRec) InclusionDirective(PPRec, Kind,
Argyrios Kyrtzidis8f958f12011-09-20 23:27:41 +00003973 StringRef(BlobStart, Record[0]),
Argyrios Kyrtzidis8dd927c2012-10-02 16:10:46 +00003974 Record[1], Record[3],
Argyrios Kyrtzidis290ad8c2011-09-20 23:27:38 +00003975 File,
Argyrios Kyrtzidis8f958f12011-09-20 23:27:41 +00003976 Range);
Argyrios Kyrtzidis290ad8c2011-09-20 23:27:38 +00003977 return ID;
3978 }
3979 }
David Blaikie7530c032012-01-17 06:56:22 +00003980
3981 llvm_unreachable("Invalid PreprocessorDetailRecordTypes");
Douglas Gregor6a5a23f2010-03-19 21:51:54 +00003982}
3983
Argyrios Kyrtzidis2dbaca72011-09-19 20:40:25 +00003984/// \brief \arg SLocMapI points at a chunk of a module that contains no
3985/// preprocessed entities or the entities it contains are not the ones we are
3986/// looking for. Find the next module that contains entities and return the ID
3987/// of the first entry.
3988PreprocessedEntityID ASTReader::findNextPreprocessedEntity(
3989 GlobalSLocOffsetMapType::const_iterator SLocMapI) const {
3990 ++SLocMapI;
3991 for (GlobalSLocOffsetMapType::const_iterator
3992 EndI = GlobalSLocOffsetMap.end(); SLocMapI != EndI; ++SLocMapI) {
Douglas Gregor1a4761e2011-11-30 23:21:26 +00003993 ModuleFile &M = *SLocMapI->second;
Argyrios Kyrtzidis2dbaca72011-09-19 20:40:25 +00003994 if (M.NumPreprocessedEntities)
3995 return getGlobalPreprocessedEntityID(M, M.BasePreprocessedEntityID);
3996 }
3997
3998 return getTotalNumPreprocessedEntities();
3999}
4000
4001namespace {
4002
4003template <unsigned PPEntityOffset::*PPLoc>
4004struct PPEntityComp {
4005 const ASTReader &Reader;
Douglas Gregor1a4761e2011-11-30 23:21:26 +00004006 ModuleFile &M;
Argyrios Kyrtzidis2dbaca72011-09-19 20:40:25 +00004007
Douglas Gregor1a4761e2011-11-30 23:21:26 +00004008 PPEntityComp(const ASTReader &Reader, ModuleFile &M) : Reader(Reader), M(M) { }
Argyrios Kyrtzidis2dbaca72011-09-19 20:40:25 +00004009
Benjamin Kramer88df1252011-09-21 06:42:26 +00004010 bool operator()(const PPEntityOffset &L, const PPEntityOffset &R) const {
4011 SourceLocation LHS = getLoc(L);
4012 SourceLocation RHS = getLoc(R);
4013 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
4014 }
4015
4016 bool operator()(const PPEntityOffset &L, SourceLocation RHS) const {
Argyrios Kyrtzidis2dbaca72011-09-19 20:40:25 +00004017 SourceLocation LHS = getLoc(L);
4018 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
4019 }
4020
Benjamin Kramer88df1252011-09-21 06:42:26 +00004021 bool operator()(SourceLocation LHS, const PPEntityOffset &R) const {
Argyrios Kyrtzidis2dbaca72011-09-19 20:40:25 +00004022 SourceLocation RHS = getLoc(R);
4023 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
4024 }
4025
4026 SourceLocation getLoc(const PPEntityOffset &PPE) const {
4027 return Reader.ReadSourceLocation(M, PPE.*PPLoc);
4028 }
4029};
4030
4031}
4032
4033/// \brief Returns the first preprocessed entity ID that ends after \arg BLoc.
4034PreprocessedEntityID
4035ASTReader::findBeginPreprocessedEntity(SourceLocation BLoc) const {
4036 if (SourceMgr.isLocalSourceLocation(BLoc))
4037 return getTotalNumPreprocessedEntities();
4038
4039 GlobalSLocOffsetMapType::const_iterator
4040 SLocMapI = GlobalSLocOffsetMap.find(SourceManager::MaxLoadedOffset -
4041 BLoc.getOffset());
4042 assert(SLocMapI != GlobalSLocOffsetMap.end() &&
4043 "Corrupted global sloc offset map");
4044
4045 if (SLocMapI->second->NumPreprocessedEntities == 0)
4046 return findNextPreprocessedEntity(SLocMapI);
4047
Douglas Gregor1a4761e2011-11-30 23:21:26 +00004048 ModuleFile &M = *SLocMapI->second;
Argyrios Kyrtzidis2dbaca72011-09-19 20:40:25 +00004049 typedef const PPEntityOffset *pp_iterator;
4050 pp_iterator pp_begin = M.PreprocessedEntityOffsets;
4051 pp_iterator pp_end = pp_begin + M.NumPreprocessedEntities;
Argyrios Kyrtzidis4cd06342011-09-22 21:17:02 +00004052
4053 size_t Count = M.NumPreprocessedEntities;
4054 size_t Half;
4055 pp_iterator First = pp_begin;
4056 pp_iterator PPI;
4057
4058 // Do a binary search manually instead of using std::lower_bound because
4059 // The end locations of entities may be unordered (when a macro expansion
4060 // is inside another macro argument), but for this case it is not important
4061 // whether we get the first macro expansion or its containing macro.
4062 while (Count > 0) {
4063 Half = Count/2;
4064 PPI = First;
4065 std::advance(PPI, Half);
4066 if (SourceMgr.isBeforeInTranslationUnit(ReadSourceLocation(M, PPI->End),
4067 BLoc)){
4068 First = PPI;
4069 ++First;
4070 Count = Count - Half - 1;
4071 } else
4072 Count = Half;
4073 }
Argyrios Kyrtzidis2dbaca72011-09-19 20:40:25 +00004074
4075 if (PPI == pp_end)
4076 return findNextPreprocessedEntity(SLocMapI);
4077
4078 return getGlobalPreprocessedEntityID(M,
4079 M.BasePreprocessedEntityID + (PPI - pp_begin));
4080}
4081
4082/// \brief Returns the first preprocessed entity ID that begins after \arg ELoc.
4083PreprocessedEntityID
4084ASTReader::findEndPreprocessedEntity(SourceLocation ELoc) const {
4085 if (SourceMgr.isLocalSourceLocation(ELoc))
4086 return getTotalNumPreprocessedEntities();
4087
4088 GlobalSLocOffsetMapType::const_iterator
4089 SLocMapI = GlobalSLocOffsetMap.find(SourceManager::MaxLoadedOffset -
4090 ELoc.getOffset());
4091 assert(SLocMapI != GlobalSLocOffsetMap.end() &&
4092 "Corrupted global sloc offset map");
4093
4094 if (SLocMapI->second->NumPreprocessedEntities == 0)
4095 return findNextPreprocessedEntity(SLocMapI);
4096
Douglas Gregor1a4761e2011-11-30 23:21:26 +00004097 ModuleFile &M = *SLocMapI->second;
Argyrios Kyrtzidis2dbaca72011-09-19 20:40:25 +00004098 typedef const PPEntityOffset *pp_iterator;
4099 pp_iterator pp_begin = M.PreprocessedEntityOffsets;
4100 pp_iterator pp_end = pp_begin + M.NumPreprocessedEntities;
4101 pp_iterator PPI =
4102 std::upper_bound(pp_begin, pp_end, ELoc,
4103 PPEntityComp<&PPEntityOffset::Begin>(*this, M));
4104
4105 if (PPI == pp_end)
4106 return findNextPreprocessedEntity(SLocMapI);
4107
4108 return getGlobalPreprocessedEntityID(M,
4109 M.BasePreprocessedEntityID + (PPI - pp_begin));
4110}
4111
4112/// \brief Returns a pair of [Begin, End) indices of preallocated
4113/// preprocessed entities that \arg Range encompasses.
4114std::pair<unsigned, unsigned>
4115 ASTReader::findPreprocessedEntitiesInRange(SourceRange Range) {
4116 if (Range.isInvalid())
4117 return std::make_pair(0,0);
4118 assert(!SourceMgr.isBeforeInTranslationUnit(Range.getEnd(),Range.getBegin()));
4119
4120 PreprocessedEntityID BeginID = findBeginPreprocessedEntity(Range.getBegin());
4121 PreprocessedEntityID EndID = findEndPreprocessedEntity(Range.getEnd());
4122 return std::make_pair(BeginID, EndID);
4123}
4124
Argyrios Kyrtzidisf226ff92011-10-25 00:29:50 +00004125/// \brief Optionally returns true or false if the preallocated preprocessed
4126/// entity with index \arg Index came from file \arg FID.
4127llvm::Optional<bool> ASTReader::isPreprocessedEntityInFileID(unsigned Index,
4128 FileID FID) {
4129 if (FID.isInvalid())
4130 return false;
4131
Douglas Gregor1a4761e2011-11-30 23:21:26 +00004132 std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index);
4133 ModuleFile &M = *PPInfo.first;
Argyrios Kyrtzidisf226ff92011-10-25 00:29:50 +00004134 unsigned LocalIndex = PPInfo.second;
4135 const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex];
4136
4137 SourceLocation Loc = ReadSourceLocation(M, PPOffs.Begin);
4138 if (Loc.isInvalid())
4139 return false;
4140
4141 if (SourceMgr.isInFileID(SourceMgr.getFileLoc(Loc), FID))
4142 return true;
4143 else
4144 return false;
4145}
4146
Douglas Gregord10a3812011-08-25 18:14:34 +00004147namespace {
4148 /// \brief Visitor used to search for information about a header file.
4149 class HeaderFileInfoVisitor {
4150 ASTReader &Reader;
4151 const FileEntry *FE;
4152
4153 llvm::Optional<HeaderFileInfo> HFI;
4154
4155 public:
4156 HeaderFileInfoVisitor(ASTReader &Reader, const FileEntry *FE)
4157 : Reader(Reader), FE(FE) { }
4158
Douglas Gregor1a4761e2011-11-30 23:21:26 +00004159 static bool visit(ModuleFile &M, void *UserData) {
Douglas Gregord10a3812011-08-25 18:14:34 +00004160 HeaderFileInfoVisitor *This
4161 = static_cast<HeaderFileInfoVisitor *>(UserData);
4162
4163 HeaderFileInfoTrait Trait(This->Reader, M,
4164 &This->Reader.getPreprocessor().getHeaderSearchInfo(),
4165 M.HeaderFileFrameworkStrings,
4166 This->FE->getName());
4167
4168 HeaderFileInfoLookupTable *Table
4169 = static_cast<HeaderFileInfoLookupTable *>(M.HeaderFileInfoTable);
4170 if (!Table)
4171 return false;
4172
4173 // Look in the on-disk hash table for an entry for this file name.
4174 HeaderFileInfoLookupTable::iterator Pos = Table->find(This->FE->getName(),
4175 &Trait);
4176 if (Pos == Table->end())
4177 return false;
4178
4179 This->HFI = *Pos;
4180 return true;
4181 }
4182
4183 llvm::Optional<HeaderFileInfo> getHeaderFileInfo() const { return HFI; }
4184 };
4185}
4186
Douglas Gregorcfbf1c72011-02-10 17:09:37 +00004187HeaderFileInfo ASTReader::GetHeaderFileInfo(const FileEntry *FE) {
Douglas Gregord10a3812011-08-25 18:14:34 +00004188 HeaderFileInfoVisitor Visitor(*this, FE);
4189 ModuleMgr.visit(&HeaderFileInfoVisitor::visit, &Visitor);
4190 if (llvm::Optional<HeaderFileInfo> HFI = Visitor.getHeaderFileInfo()) {
Douglas Gregorcfbf1c72011-02-10 17:09:37 +00004191 if (Listener)
Douglas Gregord10a3812011-08-25 18:14:34 +00004192 Listener->ReadHeaderFileInfo(*HFI, FE->getUID());
4193 return *HFI;
Douglas Gregorcfbf1c72011-02-10 17:09:37 +00004194 }
4195
4196 return HeaderFileInfo();
4197}
4198
David Blaikied6471f72011-09-25 23:23:43 +00004199void ASTReader::ReadPragmaDiagnosticMappings(DiagnosticsEngine &Diag) {
Jonathan D. Turner5d6d89f2011-07-25 20:32:21 +00004200 for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) {
Douglas Gregor1a4761e2011-11-30 23:21:26 +00004201 ModuleFile &F = *(*I);
Douglas Gregorf62d43d2011-07-19 16:10:42 +00004202 unsigned Idx = 0;
4203 while (Idx < F.PragmaDiagMappings.size()) {
4204 SourceLocation Loc = ReadSourceLocation(F, F.PragmaDiagMappings[Idx++]);
Argyrios Kyrtzidis87429a02011-11-09 01:24:17 +00004205 Diag.DiagStates.push_back(*Diag.GetCurDiagState());
4206 Diag.DiagStatePoints.push_back(
4207 DiagnosticsEngine::DiagStatePoint(&Diag.DiagStates.back(),
4208 FullSourceLoc(Loc, SourceMgr)));
Douglas Gregorf62d43d2011-07-19 16:10:42 +00004209 while (1) {
4210 assert(Idx < F.PragmaDiagMappings.size() &&
4211 "Invalid data, didn't find '-1' marking end of diag/map pairs");
4212 if (Idx >= F.PragmaDiagMappings.size()) {
4213 break; // Something is messed up but at least avoid infinite loop in
4214 // release build.
4215 }
4216 unsigned DiagID = F.PragmaDiagMappings[Idx++];
4217 if (DiagID == (unsigned)-1) {
4218 break; // no more diag/map pairs for this location.
4219 }
4220 diag::Mapping Map = (diag::Mapping)F.PragmaDiagMappings[Idx++];
Argyrios Kyrtzidis87429a02011-11-09 01:24:17 +00004221 DiagnosticMappingInfo MappingInfo = Diag.makeMappingInfo(Map, Loc);
4222 Diag.GetCurDiagState()->setMappingInfo(DiagID, MappingInfo);
Douglas Gregorf62d43d2011-07-19 16:10:42 +00004223 }
Argyrios Kyrtzidis3efd52c2011-01-14 20:54:07 +00004224 }
Argyrios Kyrtzidisf41d3be2010-11-05 22:10:18 +00004225 }
4226}
4227
Sebastian Redlaaec0aa2010-07-20 22:37:49 +00004228/// \brief Get the correct cursor and offset for loading a type.
Sebastian Redlc43b54c2010-08-18 23:56:43 +00004229ASTReader::RecordLocation ASTReader::TypeCursorForIndex(unsigned Index) {
Douglas Gregora119da02011-08-02 16:26:37 +00004230 GlobalTypeMapType::iterator I = GlobalTypeMap.find(Index);
Jonathan D. Turnere9b76c12011-07-20 21:31:32 +00004231 assert(I != GlobalTypeMap.end() && "Corrupted global type map");
Douglas Gregor1a4761e2011-11-30 23:21:26 +00004232 ModuleFile *M = I->second;
Douglas Gregore3605012011-08-02 18:32:54 +00004233 return RecordLocation(M, M->TypeOffsets[Index - M->BaseTypeIndex]);
Sebastian Redlaaec0aa2010-07-20 22:37:49 +00004234}
4235
4236/// \brief Read and return the type with the given index..
Douglas Gregor2cf26342009-04-09 22:27:44 +00004237///
Sebastian Redlaaec0aa2010-07-20 22:37:49 +00004238/// The index is the type ID, shifted and minus the number of predefs. This
4239/// routine actually reads the record corresponding to the type at the given
4240/// location. It is a helper routine for GetType, which deals with reading type
4241/// IDs.
Douglas Gregor393f2492011-07-22 00:38:23 +00004242QualType ASTReader::readTypeRecord(unsigned Index) {
Sebastian Redlaaec0aa2010-07-20 22:37:49 +00004243 RecordLocation Loc = TypeCursorForIndex(Index);
Sebastian Redlc3632732010-10-05 15:59:54 +00004244 llvm::BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;
Sebastian Redl9137a522010-07-16 17:50:48 +00004245
Douglas Gregor0b748912009-04-14 21:18:50 +00004246 // Keep track of where we are in the stream, then jump back there
4247 // after reading this type.
Douglas Gregor61d60ee2009-10-17 00:13:19 +00004248 SavedStreamPosition SavedPosition(DeclsCursor);
Douglas Gregor0b748912009-04-14 21:18:50 +00004249
Argyrios Kyrtzidis919e6932010-06-28 22:28:35 +00004250 ReadingKindTracker ReadingKind(Read_Type, *this);
Sebastian Redl27372b42010-08-11 18:52:41 +00004251
Douglas Gregord89275b2009-07-06 18:54:52 +00004252 // Note that we are loading a type record.
Argyrios Kyrtzidis29ee3a22010-07-30 10:03:16 +00004253 Deserializing AType(this);
Mike Stump1eb44332009-09-09 15:08:12 +00004254
Douglas Gregor393f2492011-07-22 00:38:23 +00004255 unsigned Idx = 0;
Sebastian Redlc3632732010-10-05 15:59:54 +00004256 DeclsCursor.JumpToBit(Loc.Offset);
Douglas Gregor2cf26342009-04-09 22:27:44 +00004257 RecordData Record;
Douglas Gregor61d60ee2009-10-17 00:13:19 +00004258 unsigned Code = DeclsCursor.ReadCode();
Sebastian Redl8538e8d2010-08-18 23:57:32 +00004259 switch ((TypeCode)DeclsCursor.ReadRecord(Code, Record)) {
4260 case TYPE_EXT_QUAL: {
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00004261 if (Record.size() != 2) {
4262 Error("Incorrect encoding of extended qualifier type");
4263 return QualType();
4264 }
Douglas Gregor393f2492011-07-22 00:38:23 +00004265 QualType Base = readType(*Loc.F, Record, Idx);
4266 Qualifiers Quals = Qualifiers::fromOpaqueValue(Record[Idx++]);
Douglas Gregor35942772011-09-09 21:34:22 +00004267 return Context.getQualifiedType(Base, Quals);
Douglas Gregor6d473962009-04-15 22:00:08 +00004268 }
Douglas Gregorb4e715b2009-04-13 20:46:52 +00004269
Sebastian Redl8538e8d2010-08-18 23:57:32 +00004270 case TYPE_COMPLEX: {
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00004271 if (Record.size() != 1) {
4272 Error("Incorrect encoding of complex type");
4273 return QualType();
4274 }
Douglas Gregor393f2492011-07-22 00:38:23 +00004275 QualType ElemType = readType(*Loc.F, Record, Idx);
Douglas Gregor35942772011-09-09 21:34:22 +00004276 return Context.getComplexType(ElemType);
Douglas Gregor2cf26342009-04-09 22:27:44 +00004277 }
4278
Sebastian Redl8538e8d2010-08-18 23:57:32 +00004279 case TYPE_POINTER: {
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00004280 if (Record.size() != 1) {
4281 Error("Incorrect encoding of pointer type");
4282 return QualType();
4283 }
Douglas Gregor393f2492011-07-22 00:38:23 +00004284 QualType PointeeType = readType(*Loc.F, Record, Idx);
Douglas Gregor35942772011-09-09 21:34:22 +00004285 return Context.getPointerType(PointeeType);
Douglas Gregor2cf26342009-04-09 22:27:44 +00004286 }
4287
Sebastian Redl8538e8d2010-08-18 23:57:32 +00004288 case TYPE_BLOCK_POINTER: {
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00004289 if (Record.size() != 1) {
4290 Error("Incorrect encoding of block pointer type");
4291 return QualType();
4292 }
Douglas Gregor393f2492011-07-22 00:38:23 +00004293 QualType PointeeType = readType(*Loc.F, Record, Idx);
Douglas Gregor35942772011-09-09 21:34:22 +00004294 return Context.getBlockPointerType(PointeeType);
Douglas Gregor2cf26342009-04-09 22:27:44 +00004295 }
4296
Sebastian Redl8538e8d2010-08-18 23:57:32 +00004297 case TYPE_LVALUE_REFERENCE: {
Richard Smithdf1550f2011-04-12 10:38:03 +00004298 if (Record.size() != 2) {
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00004299 Error("Incorrect encoding of lvalue reference type");
4300 return QualType();
4301 }
Douglas Gregor393f2492011-07-22 00:38:23 +00004302 QualType PointeeType = readType(*Loc.F, Record, Idx);
Douglas Gregor35942772011-09-09 21:34:22 +00004303 return Context.getLValueReferenceType(PointeeType, Record[1]);
Douglas Gregor2cf26342009-04-09 22:27:44 +00004304 }
4305
Sebastian Redl8538e8d2010-08-18 23:57:32 +00004306 case TYPE_RVALUE_REFERENCE: {
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00004307 if (Record.size() != 1) {
4308 Error("Incorrect encoding of rvalue reference type");
4309 return QualType();
4310 }
Douglas Gregor393f2492011-07-22 00:38:23 +00004311 QualType PointeeType = readType(*Loc.F, Record, Idx);
Douglas Gregor35942772011-09-09 21:34:22 +00004312 return Context.getRValueReferenceType(PointeeType);
Douglas Gregor2cf26342009-04-09 22:27:44 +00004313 }
4314
Sebastian Redl8538e8d2010-08-18 23:57:32 +00004315 case TYPE_MEMBER_POINTER: {
Argyrios Kyrtzidis240437b2010-07-02 11:55:15 +00004316 if (Record.size() != 2) {
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00004317 Error("Incorrect encoding of member pointer type");
4318 return QualType();
4319 }
Douglas Gregor393f2492011-07-22 00:38:23 +00004320 QualType PointeeType = readType(*Loc.F, Record, Idx);
4321 QualType ClassType = readType(*Loc.F, Record, Idx);
Douglas Gregor1ab55e92010-12-10 17:03:06 +00004322 if (PointeeType.isNull() || ClassType.isNull())
4323 return QualType();
4324
Douglas Gregor35942772011-09-09 21:34:22 +00004325 return Context.getMemberPointerType(PointeeType, ClassType.getTypePtr());
Douglas Gregor2cf26342009-04-09 22:27:44 +00004326 }
4327
Sebastian Redl8538e8d2010-08-18 23:57:32 +00004328 case TYPE_CONSTANT_ARRAY: {
Douglas Gregor393f2492011-07-22 00:38:23 +00004329 QualType ElementType = readType(*Loc.F, Record, Idx);
Douglas Gregorb4e715b2009-04-13 20:46:52 +00004330 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
4331 unsigned IndexTypeQuals = Record[2];
4332 unsigned Idx = 3;
4333 llvm::APInt Size = ReadAPInt(Record, Idx);
Douglas Gregor35942772011-09-09 21:34:22 +00004334 return Context.getConstantArrayType(ElementType, Size,
Douglas Gregor7e7eb3d2009-07-06 15:59:29 +00004335 ASM, IndexTypeQuals);
4336 }
4337
Sebastian Redl8538e8d2010-08-18 23:57:32 +00004338 case TYPE_INCOMPLETE_ARRAY: {
Douglas Gregor393f2492011-07-22 00:38:23 +00004339 QualType ElementType = readType(*Loc.F, Record, Idx);
Douglas Gregorb4e715b2009-04-13 20:46:52 +00004340 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
4341 unsigned IndexTypeQuals = Record[2];
Douglas Gregor35942772011-09-09 21:34:22 +00004342 return Context.getIncompleteArrayType(ElementType, ASM, IndexTypeQuals);
Douglas Gregorb4e715b2009-04-13 20:46:52 +00004343 }
4344
Sebastian Redl8538e8d2010-08-18 23:57:32 +00004345 case TYPE_VARIABLE_ARRAY: {
Douglas Gregor393f2492011-07-22 00:38:23 +00004346 QualType ElementType = readType(*Loc.F, Record, Idx);
Douglas Gregor0b748912009-04-14 21:18:50 +00004347 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
4348 unsigned IndexTypeQuals = Record[2];
Sebastian Redlc3632732010-10-05 15:59:54 +00004349 SourceLocation LBLoc = ReadSourceLocation(*Loc.F, Record[3]);
4350 SourceLocation RBLoc = ReadSourceLocation(*Loc.F, Record[4]);
Douglas Gregor35942772011-09-09 21:34:22 +00004351 return Context.getVariableArrayType(ElementType, ReadExpr(*Loc.F),
Douglas Gregor7e7eb3d2009-07-06 15:59:29 +00004352 ASM, IndexTypeQuals,
4353 SourceRange(LBLoc, RBLoc));
Douglas Gregorb4e715b2009-04-13 20:46:52 +00004354 }
4355
Sebastian Redl8538e8d2010-08-18 23:57:32 +00004356 case TYPE_VECTOR: {
Chris Lattner788b0fd2010-06-23 06:00:24 +00004357 if (Record.size() != 3) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00004358 Error("incorrect encoding of vector type in AST file");
Douglas Gregorb4e715b2009-04-13 20:46:52 +00004359 return QualType();
4360 }
4361
Douglas Gregor393f2492011-07-22 00:38:23 +00004362 QualType ElementType = readType(*Loc.F, Record, Idx);
Douglas Gregorb4e715b2009-04-13 20:46:52 +00004363 unsigned NumElements = Record[1];
Bob Wilsone86d78c2010-11-10 21:56:12 +00004364 unsigned VecKind = Record[2];
Douglas Gregor35942772011-09-09 21:34:22 +00004365 return Context.getVectorType(ElementType, NumElements,
Bob Wilsone86d78c2010-11-10 21:56:12 +00004366 (VectorType::VectorKind)VecKind);
Douglas Gregorb4e715b2009-04-13 20:46:52 +00004367 }
4368
Sebastian Redl8538e8d2010-08-18 23:57:32 +00004369 case TYPE_EXT_VECTOR: {
Chris Lattner788b0fd2010-06-23 06:00:24 +00004370 if (Record.size() != 3) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00004371 Error("incorrect encoding of extended vector type in AST file");
Douglas Gregorb4e715b2009-04-13 20:46:52 +00004372 return QualType();
4373 }
4374
Douglas Gregor393f2492011-07-22 00:38:23 +00004375 QualType ElementType = readType(*Loc.F, Record, Idx);
Douglas Gregorb4e715b2009-04-13 20:46:52 +00004376 unsigned NumElements = Record[1];
Douglas Gregor35942772011-09-09 21:34:22 +00004377 return Context.getExtVectorType(ElementType, NumElements);
Douglas Gregorb4e715b2009-04-13 20:46:52 +00004378 }
4379
Sebastian Redl8538e8d2010-08-18 23:57:32 +00004380 case TYPE_FUNCTION_NO_PROTO: {
John McCallf85e1932011-06-15 23:02:42 +00004381 if (Record.size() != 6) {
Douglas Gregora02b1472009-04-28 21:53:25 +00004382 Error("incorrect encoding of no-proto function type");
Douglas Gregorb4e715b2009-04-13 20:46:52 +00004383 return QualType();
4384 }
Douglas Gregor393f2492011-07-22 00:38:23 +00004385 QualType ResultType = readType(*Loc.F, Record, Idx);
John McCallf85e1932011-06-15 23:02:42 +00004386 FunctionType::ExtInfo Info(Record[1], Record[2], Record[3],
4387 (CallingConv)Record[4], Record[5]);
Douglas Gregor35942772011-09-09 21:34:22 +00004388 return Context.getFunctionNoProtoType(ResultType, Info);
Douglas Gregorb4e715b2009-04-13 20:46:52 +00004389 }
4390
Sebastian Redl8538e8d2010-08-18 23:57:32 +00004391 case TYPE_FUNCTION_PROTO: {
Douglas Gregor393f2492011-07-22 00:38:23 +00004392 QualType ResultType = readType(*Loc.F, Record, Idx);
John McCalle23cf432010-12-14 08:05:40 +00004393
4394 FunctionProtoType::ExtProtoInfo EPI;
4395 EPI.ExtInfo = FunctionType::ExtInfo(/*noreturn*/ Record[1],
Eli Friedmana49218e2011-04-09 08:18:08 +00004396 /*hasregparm*/ Record[2],
4397 /*regparm*/ Record[3],
John McCallf85e1932011-06-15 23:02:42 +00004398 static_cast<CallingConv>(Record[4]),
4399 /*produces*/ Record[5]);
John McCalle23cf432010-12-14 08:05:40 +00004400
John McCallf85e1932011-06-15 23:02:42 +00004401 unsigned Idx = 6;
Douglas Gregorb4e715b2009-04-13 20:46:52 +00004402 unsigned NumParams = Record[Idx++];
Chris Lattner5f9e2722011-07-23 10:55:15 +00004403 SmallVector<QualType, 16> ParamTypes;
Douglas Gregorb4e715b2009-04-13 20:46:52 +00004404 for (unsigned I = 0; I != NumParams; ++I)
Douglas Gregor393f2492011-07-22 00:38:23 +00004405 ParamTypes.push_back(readType(*Loc.F, Record, Idx));
John McCalle23cf432010-12-14 08:05:40 +00004406
4407 EPI.Variadic = Record[Idx++];
Richard Smitheefb3d52012-02-10 09:58:53 +00004408 EPI.HasTrailingReturn = Record[Idx++];
John McCalle23cf432010-12-14 08:05:40 +00004409 EPI.TypeQuals = Record[Idx++];
Douglas Gregorc938c162011-01-26 05:01:58 +00004410 EPI.RefQualifier = static_cast<RefQualifierKind>(Record[Idx++]);
Sebastian Redl60618fa2011-03-12 11:50:43 +00004411 ExceptionSpecificationType EST =
4412 static_cast<ExceptionSpecificationType>(Record[Idx++]);
4413 EPI.ExceptionSpecType = EST;
Douglas Gregorb0d06e22012-04-04 00:34:49 +00004414 SmallVector<QualType, 2> Exceptions;
Sebastian Redl60618fa2011-03-12 11:50:43 +00004415 if (EST == EST_Dynamic) {
4416 EPI.NumExceptions = Record[Idx++];
Sebastian Redl60618fa2011-03-12 11:50:43 +00004417 for (unsigned I = 0; I != EPI.NumExceptions; ++I)
Douglas Gregor393f2492011-07-22 00:38:23 +00004418 Exceptions.push_back(readType(*Loc.F, Record, Idx));
Sebastian Redl60618fa2011-03-12 11:50:43 +00004419 EPI.Exceptions = Exceptions.data();
4420 } else if (EST == EST_ComputedNoexcept) {
4421 EPI.NoexceptExpr = ReadExpr(*Loc.F);
Richard Smith7bb698a2012-04-21 17:47:47 +00004422 } else if (EST == EST_Uninstantiated) {
4423 EPI.ExceptionSpecDecl = ReadDeclAs<FunctionDecl>(*Loc.F, Record, Idx);
4424 EPI.ExceptionSpecTemplate = ReadDeclAs<FunctionDecl>(*Loc.F, Record, Idx);
Richard Smithb9d0b762012-07-27 04:22:15 +00004425 } else if (EST == EST_Unevaluated) {
4426 EPI.ExceptionSpecDecl = ReadDeclAs<FunctionDecl>(*Loc.F, Record, Idx);
Sebastian Redl60618fa2011-03-12 11:50:43 +00004427 }
Douglas Gregor35942772011-09-09 21:34:22 +00004428 return Context.getFunctionType(ResultType, ParamTypes.data(), NumParams,
John McCalle23cf432010-12-14 08:05:40 +00004429 EPI);
Douglas Gregorb4e715b2009-04-13 20:46:52 +00004430 }
4431
Douglas Gregor409448c2011-07-21 22:35:25 +00004432 case TYPE_UNRESOLVED_USING: {
4433 unsigned Idx = 0;
Douglas Gregor35942772011-09-09 21:34:22 +00004434 return Context.getTypeDeclType(
Douglas Gregor409448c2011-07-21 22:35:25 +00004435 ReadDeclAs<UnresolvedUsingTypenameDecl>(*Loc.F, Record, Idx));
4436 }
4437
Sebastian Redl8538e8d2010-08-18 23:57:32 +00004438 case TYPE_TYPEDEF: {
Argyrios Kyrtzidis9763e222010-07-02 11:55:11 +00004439 if (Record.size() != 2) {
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00004440 Error("incorrect encoding of typedef type");
4441 return QualType();
4442 }
Douglas Gregor409448c2011-07-21 22:35:25 +00004443 unsigned Idx = 0;
4444 TypedefNameDecl *Decl = ReadDeclAs<TypedefNameDecl>(*Loc.F, Record, Idx);
Douglas Gregor393f2492011-07-22 00:38:23 +00004445 QualType Canonical = readType(*Loc.F, Record, Idx);
Douglas Gregor32adc8b2010-10-26 00:51:02 +00004446 if (!Canonical.isNull())
Douglas Gregor35942772011-09-09 21:34:22 +00004447 Canonical = Context.getCanonicalType(Canonical);
4448 return Context.getTypedefType(Decl, Canonical);
Argyrios Kyrtzidis9763e222010-07-02 11:55:11 +00004449 }
Douglas Gregorb4e715b2009-04-13 20:46:52 +00004450
Sebastian Redl8538e8d2010-08-18 23:57:32 +00004451 case TYPE_TYPEOF_EXPR:
Douglas Gregor35942772011-09-09 21:34:22 +00004452 return Context.getTypeOfExprType(ReadExpr(*Loc.F));
Douglas Gregorb4e715b2009-04-13 20:46:52 +00004453
Sebastian Redl8538e8d2010-08-18 23:57:32 +00004454 case TYPE_TYPEOF: {
Douglas Gregorb4e715b2009-04-13 20:46:52 +00004455 if (Record.size() != 1) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00004456 Error("incorrect encoding of typeof(type) in AST file");
Douglas Gregorb4e715b2009-04-13 20:46:52 +00004457 return QualType();
4458 }
Douglas Gregor393f2492011-07-22 00:38:23 +00004459 QualType UnderlyingType = readType(*Loc.F, Record, Idx);
Douglas Gregor35942772011-09-09 21:34:22 +00004460 return Context.getTypeOfType(UnderlyingType);
Douglas Gregorb4e715b2009-04-13 20:46:52 +00004461 }
Mike Stump1eb44332009-09-09 15:08:12 +00004462
Douglas Gregorf8af9822012-02-12 18:42:33 +00004463 case TYPE_DECLTYPE: {
4464 QualType UnderlyingType = readType(*Loc.F, Record, Idx);
4465 return Context.getDecltypeType(ReadExpr(*Loc.F), UnderlyingType);
4466 }
Anders Carlsson395b4752009-06-24 19:06:50 +00004467
Sean Huntca63c202011-05-24 22:41:36 +00004468 case TYPE_UNARY_TRANSFORM: {
Douglas Gregor393f2492011-07-22 00:38:23 +00004469 QualType BaseType = readType(*Loc.F, Record, Idx);
4470 QualType UnderlyingType = readType(*Loc.F, Record, Idx);
Sean Huntca63c202011-05-24 22:41:36 +00004471 UnaryTransformType::UTTKind UKind = (UnaryTransformType::UTTKind)Record[2];
Douglas Gregor35942772011-09-09 21:34:22 +00004472 return Context.getUnaryTransformType(BaseType, UnderlyingType, UKind);
Sean Huntca63c202011-05-24 22:41:36 +00004473 }
4474
Richard Smith34b41d92011-02-20 03:19:35 +00004475 case TYPE_AUTO:
Douglas Gregor35942772011-09-09 21:34:22 +00004476 return Context.getAutoType(readType(*Loc.F, Record, Idx));
Richard Smith34b41d92011-02-20 03:19:35 +00004477
Sebastian Redl8538e8d2010-08-18 23:57:32 +00004478 case TYPE_RECORD: {
Argyrios Kyrtzidisbe191102010-07-08 13:09:53 +00004479 if (Record.size() != 2) {
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00004480 Error("incorrect encoding of record type");
4481 return QualType();
4482 }
Douglas Gregor409448c2011-07-21 22:35:25 +00004483 unsigned Idx = 0;
4484 bool IsDependent = Record[Idx++];
Douglas Gregor56ca8a92012-01-17 19:21:53 +00004485 RecordDecl *RD = ReadDeclAs<RecordDecl>(*Loc.F, Record, Idx);
4486 RD = cast_or_null<RecordDecl>(RD->getCanonicalDecl());
4487 QualType T = Context.getRecordType(RD);
John McCallf4c73712011-01-19 06:33:43 +00004488 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
Argyrios Kyrtzidisbe191102010-07-08 13:09:53 +00004489 return T;
4490 }
Douglas Gregorb4e715b2009-04-13 20:46:52 +00004491
Sebastian Redl8538e8d2010-08-18 23:57:32 +00004492 case TYPE_ENUM: {
Argyrios Kyrtzidisbe191102010-07-08 13:09:53 +00004493 if (Record.size() != 2) {
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00004494 Error("incorrect encoding of enum type");
4495 return QualType();
4496 }
Douglas Gregor409448c2011-07-21 22:35:25 +00004497 unsigned Idx = 0;
4498 bool IsDependent = Record[Idx++];
4499 QualType T
Douglas Gregor35942772011-09-09 21:34:22 +00004500 = Context.getEnumType(ReadDeclAs<EnumDecl>(*Loc.F, Record, Idx));
John McCallf4c73712011-01-19 06:33:43 +00004501 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
Argyrios Kyrtzidisbe191102010-07-08 13:09:53 +00004502 return T;
4503 }
Douglas Gregor0a2b45e2009-04-13 18:14:40 +00004504
John McCall9d156a72011-01-06 01:58:22 +00004505 case TYPE_ATTRIBUTED: {
4506 if (Record.size() != 3) {
4507 Error("incorrect encoding of attributed type");
4508 return QualType();
4509 }
Douglas Gregor393f2492011-07-22 00:38:23 +00004510 QualType modifiedType = readType(*Loc.F, Record, Idx);
4511 QualType equivalentType = readType(*Loc.F, Record, Idx);
John McCall9d156a72011-01-06 01:58:22 +00004512 AttributedType::Kind kind = static_cast<AttributedType::Kind>(Record[2]);
Douglas Gregor35942772011-09-09 21:34:22 +00004513 return Context.getAttributedType(kind, modifiedType, equivalentType);
John McCall9d156a72011-01-06 01:58:22 +00004514 }
4515
Abramo Bagnara075f8f12010-12-10 16:29:40 +00004516 case TYPE_PAREN: {
4517 if (Record.size() != 1) {
4518 Error("incorrect encoding of paren type");
4519 return QualType();
4520 }
Douglas Gregor393f2492011-07-22 00:38:23 +00004521 QualType InnerType = readType(*Loc.F, Record, Idx);
Douglas Gregor35942772011-09-09 21:34:22 +00004522 return Context.getParenType(InnerType);
Abramo Bagnara075f8f12010-12-10 16:29:40 +00004523 }
4524
Douglas Gregor7536dd52010-12-20 02:24:11 +00004525 case TYPE_PACK_EXPANSION: {
Douglas Gregorf9997a02011-02-01 15:24:58 +00004526 if (Record.size() != 2) {
Douglas Gregor7536dd52010-12-20 02:24:11 +00004527 Error("incorrect encoding of pack expansion type");
4528 return QualType();
4529 }
Douglas Gregor393f2492011-07-22 00:38:23 +00004530 QualType Pattern = readType(*Loc.F, Record, Idx);
Douglas Gregor7536dd52010-12-20 02:24:11 +00004531 if (Pattern.isNull())
4532 return QualType();
Douglas Gregorcded4f62011-01-14 17:04:44 +00004533 llvm::Optional<unsigned> NumExpansions;
4534 if (Record[1])
4535 NumExpansions = Record[1] - 1;
Douglas Gregor35942772011-09-09 21:34:22 +00004536 return Context.getPackExpansionType(Pattern, NumExpansions);
Douglas Gregor7536dd52010-12-20 02:24:11 +00004537 }
4538
Sebastian Redl8538e8d2010-08-18 23:57:32 +00004539 case TYPE_ELABORATED: {
Argyrios Kyrtzidis3acad622010-06-25 16:24:58 +00004540 unsigned Idx = 0;
4541 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
Douglas Gregor409448c2011-07-21 22:35:25 +00004542 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
Douglas Gregor393f2492011-07-22 00:38:23 +00004543 QualType NamedType = readType(*Loc.F, Record, Idx);
Douglas Gregor35942772011-09-09 21:34:22 +00004544 return Context.getElaboratedType(Keyword, NNS, NamedType);
John McCall7da24312009-09-05 00:15:47 +00004545 }
4546
Sebastian Redl8538e8d2010-08-18 23:57:32 +00004547 case TYPE_OBJC_INTERFACE: {
Chris Lattnerc6fa4452009-04-22 06:45:28 +00004548 unsigned Idx = 0;
Douglas Gregor409448c2011-07-21 22:35:25 +00004549 ObjCInterfaceDecl *ItfD
4550 = ReadDeclAs<ObjCInterfaceDecl>(*Loc.F, Record, Idx);
Douglas Gregor56ca8a92012-01-17 19:21:53 +00004551 return Context.getObjCInterfaceType(ItfD->getCanonicalDecl());
John McCallc12c5bb2010-05-15 11:32:37 +00004552 }
4553
Sebastian Redl8538e8d2010-08-18 23:57:32 +00004554 case TYPE_OBJC_OBJECT: {
John McCallc12c5bb2010-05-15 11:32:37 +00004555 unsigned Idx = 0;
Douglas Gregor393f2492011-07-22 00:38:23 +00004556 QualType Base = readType(*Loc.F, Record, Idx);
Chris Lattnerc6fa4452009-04-22 06:45:28 +00004557 unsigned NumProtos = Record[Idx++];
Chris Lattner5f9e2722011-07-23 10:55:15 +00004558 SmallVector<ObjCProtocolDecl*, 4> Protos;
Chris Lattnerc6fa4452009-04-22 06:45:28 +00004559 for (unsigned I = 0; I != NumProtos; ++I)
Douglas Gregor409448c2011-07-21 22:35:25 +00004560 Protos.push_back(ReadDeclAs<ObjCProtocolDecl>(*Loc.F, Record, Idx));
Douglas Gregor35942772011-09-09 21:34:22 +00004561 return Context.getObjCObjectType(Base, Protos.data(), NumProtos);
Chris Lattnerc6fa4452009-04-22 06:45:28 +00004562 }
Douglas Gregorb4e715b2009-04-13 20:46:52 +00004563
Sebastian Redl8538e8d2010-08-18 23:57:32 +00004564 case TYPE_OBJC_OBJECT_POINTER: {
Chris Lattnerd7a3fcd2009-04-22 06:40:03 +00004565 unsigned Idx = 0;
Douglas Gregor393f2492011-07-22 00:38:23 +00004566 QualType Pointee = readType(*Loc.F, Record, Idx);
Douglas Gregor35942772011-09-09 21:34:22 +00004567 return Context.getObjCObjectPointerType(Pointee);
Chris Lattnerd7a3fcd2009-04-22 06:40:03 +00004568 }
Argyrios Kyrtzidis24fab412009-09-29 19:42:55 +00004569
Sebastian Redl8538e8d2010-08-18 23:57:32 +00004570 case TYPE_SUBST_TEMPLATE_TYPE_PARM: {
John McCall49a832b2009-10-18 09:09:24 +00004571 unsigned Idx = 0;
Douglas Gregor393f2492011-07-22 00:38:23 +00004572 QualType Parm = readType(*Loc.F, Record, Idx);
4573 QualType Replacement = readType(*Loc.F, Record, Idx);
John McCall49a832b2009-10-18 09:09:24 +00004574 return
Douglas Gregor35942772011-09-09 21:34:22 +00004575 Context.getSubstTemplateTypeParmType(cast<TemplateTypeParmType>(Parm),
John McCall49a832b2009-10-18 09:09:24 +00004576 Replacement);
4577 }
John McCall3cb0ebd2010-03-10 03:28:59 +00004578
Douglas Gregorc3069d62011-01-14 02:55:32 +00004579 case TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK: {
4580 unsigned Idx = 0;
Douglas Gregor393f2492011-07-22 00:38:23 +00004581 QualType Parm = readType(*Loc.F, Record, Idx);
Douglas Gregorc3069d62011-01-14 02:55:32 +00004582 TemplateArgument ArgPack = ReadTemplateArgument(*Loc.F, Record, Idx);
Douglas Gregor35942772011-09-09 21:34:22 +00004583 return Context.getSubstTemplateTypeParmPackType(
Douglas Gregorc3069d62011-01-14 02:55:32 +00004584 cast<TemplateTypeParmType>(Parm),
4585 ArgPack);
4586 }
4587
Sebastian Redl8538e8d2010-08-18 23:57:32 +00004588 case TYPE_INJECTED_CLASS_NAME: {
Douglas Gregor409448c2011-07-21 22:35:25 +00004589 CXXRecordDecl *D = ReadDeclAs<CXXRecordDecl>(*Loc.F, Record, Idx);
Douglas Gregor393f2492011-07-22 00:38:23 +00004590 QualType TST = readType(*Loc.F, Record, Idx); // probably derivable
Argyrios Kyrtzidis43921b52010-07-02 11:55:20 +00004591 // FIXME: ASTContext::getInjectedClassNameType is not currently suitable
Sebastian Redl3c7f4132010-08-18 23:57:06 +00004592 // for AST reading, too much interdependencies.
Argyrios Kyrtzidis43921b52010-07-02 11:55:20 +00004593 return
Douglas Gregor35942772011-09-09 21:34:22 +00004594 QualType(new (Context, TypeAlignment) InjectedClassNameType(D, TST), 0);
John McCall3cb0ebd2010-03-10 03:28:59 +00004595 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00004596
Sebastian Redl8538e8d2010-08-18 23:57:32 +00004597 case TYPE_TEMPLATE_TYPE_PARM: {
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00004598 unsigned Idx = 0;
4599 unsigned Depth = Record[Idx++];
4600 unsigned Index = Record[Idx++];
4601 bool Pack = Record[Idx++];
Douglas Gregor409448c2011-07-21 22:35:25 +00004602 TemplateTypeParmDecl *D
4603 = ReadDeclAs<TemplateTypeParmDecl>(*Loc.F, Record, Idx);
Douglas Gregor35942772011-09-09 21:34:22 +00004604 return Context.getTemplateTypeParmType(Depth, Index, Pack, D);
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00004605 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00004606
Sebastian Redl8538e8d2010-08-18 23:57:32 +00004607 case TYPE_DEPENDENT_NAME: {
Argyrios Kyrtzidis8dfbd8b2010-06-24 08:57:31 +00004608 unsigned Idx = 0;
4609 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
Douglas Gregor409448c2011-07-21 22:35:25 +00004610 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
Douglas Gregor95eab172011-07-28 20:55:49 +00004611 const IdentifierInfo *Name = this->GetIdentifierInfo(*Loc.F, Record, Idx);
Douglas Gregor393f2492011-07-22 00:38:23 +00004612 QualType Canon = readType(*Loc.F, Record, Idx);
Douglas Gregor32adc8b2010-10-26 00:51:02 +00004613 if (!Canon.isNull())
Douglas Gregor35942772011-09-09 21:34:22 +00004614 Canon = Context.getCanonicalType(Canon);
4615 return Context.getDependentNameType(Keyword, NNS, Name, Canon);
Argyrios Kyrtzidis8dfbd8b2010-06-24 08:57:31 +00004616 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00004617
Sebastian Redl8538e8d2010-08-18 23:57:32 +00004618 case TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION: {
Argyrios Kyrtzidis3acad622010-06-25 16:24:58 +00004619 unsigned Idx = 0;
4620 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
Douglas Gregor409448c2011-07-21 22:35:25 +00004621 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
Douglas Gregor95eab172011-07-28 20:55:49 +00004622 const IdentifierInfo *Name = this->GetIdentifierInfo(*Loc.F, Record, Idx);
Argyrios Kyrtzidis3acad622010-06-25 16:24:58 +00004623 unsigned NumArgs = Record[Idx++];
Chris Lattner5f9e2722011-07-23 10:55:15 +00004624 SmallVector<TemplateArgument, 8> Args;
Argyrios Kyrtzidis3acad622010-06-25 16:24:58 +00004625 Args.reserve(NumArgs);
4626 while (NumArgs--)
Sebastian Redlc3632732010-10-05 15:59:54 +00004627 Args.push_back(ReadTemplateArgument(*Loc.F, Record, Idx));
Douglas Gregor35942772011-09-09 21:34:22 +00004628 return Context.getDependentTemplateSpecializationType(Keyword, NNS, Name,
Argyrios Kyrtzidis3acad622010-06-25 16:24:58 +00004629 Args.size(), Args.data());
4630 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00004631
Sebastian Redl8538e8d2010-08-18 23:57:32 +00004632 case TYPE_DEPENDENT_SIZED_ARRAY: {
Argyrios Kyrtzidisae8b17f2010-06-30 08:49:25 +00004633 unsigned Idx = 0;
4634
4635 // ArrayType
Douglas Gregor393f2492011-07-22 00:38:23 +00004636 QualType ElementType = readType(*Loc.F, Record, Idx);
Argyrios Kyrtzidisae8b17f2010-06-30 08:49:25 +00004637 ArrayType::ArraySizeModifier ASM
4638 = (ArrayType::ArraySizeModifier)Record[Idx++];
4639 unsigned IndexTypeQuals = Record[Idx++];
4640
4641 // DependentSizedArrayType
Sebastian Redlc3632732010-10-05 15:59:54 +00004642 Expr *NumElts = ReadExpr(*Loc.F);
4643 SourceRange Brackets = ReadSourceRange(*Loc.F, Record, Idx);
Argyrios Kyrtzidisae8b17f2010-06-30 08:49:25 +00004644
Douglas Gregor35942772011-09-09 21:34:22 +00004645 return Context.getDependentSizedArrayType(ElementType, NumElts, ASM,
Argyrios Kyrtzidisae8b17f2010-06-30 08:49:25 +00004646 IndexTypeQuals, Brackets);
4647 }
Argyrios Kyrtzidis90b715e2010-06-19 19:28:53 +00004648
Sebastian Redl8538e8d2010-08-18 23:57:32 +00004649 case TYPE_TEMPLATE_SPECIALIZATION: {
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00004650 unsigned Idx = 0;
Argyrios Kyrtzidisbe191102010-07-08 13:09:53 +00004651 bool IsDependent = Record[Idx++];
Douglas Gregor1aee05d2011-01-15 06:45:20 +00004652 TemplateName Name = ReadTemplateName(*Loc.F, Record, Idx);
Chris Lattner5f9e2722011-07-23 10:55:15 +00004653 SmallVector<TemplateArgument, 8> Args;
Sebastian Redlc3632732010-10-05 15:59:54 +00004654 ReadTemplateArgumentList(Args, *Loc.F, Record, Idx);
Douglas Gregor393f2492011-07-22 00:38:23 +00004655 QualType Underlying = readType(*Loc.F, Record, Idx);
Argyrios Kyrtzidisbe191102010-07-08 13:09:53 +00004656 QualType T;
Richard Smith3e4c6c42011-05-05 21:57:07 +00004657 if (Underlying.isNull())
Douglas Gregor35942772011-09-09 21:34:22 +00004658 T = Context.getCanonicalTemplateSpecializationType(Name, Args.data(),
Argyrios Kyrtzidisbe191102010-07-08 13:09:53 +00004659 Args.size());
Argyrios Kyrtzidis9763e222010-07-02 11:55:11 +00004660 else
Douglas Gregor35942772011-09-09 21:34:22 +00004661 T = Context.getTemplateSpecializationType(Name, Args.data(),
Richard Smith3e4c6c42011-05-05 21:57:07 +00004662 Args.size(), Underlying);
John McCallf4c73712011-01-19 06:33:43 +00004663 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
Argyrios Kyrtzidisbe191102010-07-08 13:09:53 +00004664 return T;
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00004665 }
Eli Friedmanb001de72011-10-06 23:00:33 +00004666
4667 case TYPE_ATOMIC: {
4668 if (Record.size() != 1) {
4669 Error("Incorrect encoding of atomic type");
4670 return QualType();
4671 }
4672 QualType ValueType = readType(*Loc.F, Record, Idx);
4673 return Context.getAtomicType(ValueType);
4674 }
Douglas Gregor2cf26342009-04-09 22:27:44 +00004675 }
David Blaikie7530c032012-01-17 06:56:22 +00004676 llvm_unreachable("Invalid TypeCode!");
Douglas Gregor2cf26342009-04-09 22:27:44 +00004677}
4678
Sebastian Redlc3632732010-10-05 15:59:54 +00004679class clang::TypeLocReader : public TypeLocVisitor<TypeLocReader> {
Sebastian Redlc43b54c2010-08-18 23:56:43 +00004680 ASTReader &Reader;
Douglas Gregor1a4761e2011-11-30 23:21:26 +00004681 ModuleFile &F;
Sebastian Redlc43b54c2010-08-18 23:56:43 +00004682 const ASTReader::RecordData &Record;
John McCalla1ee0c52009-10-16 21:56:05 +00004683 unsigned &Idx;
4684
Sebastian Redlc3632732010-10-05 15:59:54 +00004685 SourceLocation ReadSourceLocation(const ASTReader::RecordData &R,
4686 unsigned &I) {
4687 return Reader.ReadSourceLocation(F, R, I);
4688 }
4689
Douglas Gregor409448c2011-07-21 22:35:25 +00004690 template<typename T>
4691 T *ReadDeclAs(const ASTReader::RecordData &Record, unsigned &Idx) {
4692 return Reader.ReadDeclAs<T>(F, Record, Idx);
4693 }
4694
John McCalla1ee0c52009-10-16 21:56:05 +00004695public:
Douglas Gregor1a4761e2011-11-30 23:21:26 +00004696 TypeLocReader(ASTReader &Reader, ModuleFile &F,
Sebastian Redlc43b54c2010-08-18 23:56:43 +00004697 const ASTReader::RecordData &Record, unsigned &Idx)
Benjamin Kramerfacde172012-06-06 17:32:50 +00004698 : Reader(Reader), F(F), Record(Record), Idx(Idx)
Sebastian Redlc3632732010-10-05 15:59:54 +00004699 { }
John McCalla1ee0c52009-10-16 21:56:05 +00004700
John McCall51bd8032009-10-18 01:05:36 +00004701 // We want compile-time assurance that we've enumerated all of
4702 // these, so unfortunately we have to declare them first, then
4703 // define them out-of-line.
4704#define ABSTRACT_TYPELOC(CLASS, PARENT)
John McCalla1ee0c52009-10-16 21:56:05 +00004705#define TYPELOC(CLASS, PARENT) \
John McCall51bd8032009-10-18 01:05:36 +00004706 void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc);
John McCalla1ee0c52009-10-16 21:56:05 +00004707#include "clang/AST/TypeLocNodes.def"
4708
John McCall51bd8032009-10-18 01:05:36 +00004709 void VisitFunctionTypeLoc(FunctionTypeLoc);
4710 void VisitArrayTypeLoc(ArrayTypeLoc);
John McCalla1ee0c52009-10-16 21:56:05 +00004711};
4712
John McCall51bd8032009-10-18 01:05:36 +00004713void TypeLocReader::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
John McCalla1ee0c52009-10-16 21:56:05 +00004714 // nothing to do
4715}
John McCall51bd8032009-10-18 01:05:36 +00004716void TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00004717 TL.setBuiltinLoc(ReadSourceLocation(Record, Idx));
Douglas Gregorddf889a2010-01-18 18:04:31 +00004718 if (TL.needsExtraLocalData()) {
4719 TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Record[Idx++]));
4720 TL.setWrittenSignSpec(static_cast<DeclSpec::TSS>(Record[Idx++]));
4721 TL.setWrittenWidthSpec(static_cast<DeclSpec::TSW>(Record[Idx++]));
4722 TL.setModeAttr(Record[Idx++]);
4723 }
John McCalla1ee0c52009-10-16 21:56:05 +00004724}
John McCall51bd8032009-10-18 01:05:36 +00004725void TypeLocReader::VisitComplexTypeLoc(ComplexTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00004726 TL.setNameLoc(ReadSourceLocation(Record, Idx));
John McCalla1ee0c52009-10-16 21:56:05 +00004727}
John McCall51bd8032009-10-18 01:05:36 +00004728void TypeLocReader::VisitPointerTypeLoc(PointerTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00004729 TL.setStarLoc(ReadSourceLocation(Record, Idx));
John McCalla1ee0c52009-10-16 21:56:05 +00004730}
John McCall51bd8032009-10-18 01:05:36 +00004731void TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00004732 TL.setCaretLoc(ReadSourceLocation(Record, Idx));
John McCalla1ee0c52009-10-16 21:56:05 +00004733}
John McCall51bd8032009-10-18 01:05:36 +00004734void TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00004735 TL.setAmpLoc(ReadSourceLocation(Record, Idx));
John McCalla1ee0c52009-10-16 21:56:05 +00004736}
John McCall51bd8032009-10-18 01:05:36 +00004737void TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00004738 TL.setAmpAmpLoc(ReadSourceLocation(Record, Idx));
John McCalla1ee0c52009-10-16 21:56:05 +00004739}
John McCall51bd8032009-10-18 01:05:36 +00004740void TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00004741 TL.setStarLoc(ReadSourceLocation(Record, Idx));
Abramo Bagnarab6ab6c12011-03-05 14:42:21 +00004742 TL.setClassTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
John McCalla1ee0c52009-10-16 21:56:05 +00004743}
John McCall51bd8032009-10-18 01:05:36 +00004744void TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00004745 TL.setLBracketLoc(ReadSourceLocation(Record, Idx));
4746 TL.setRBracketLoc(ReadSourceLocation(Record, Idx));
John McCalla1ee0c52009-10-16 21:56:05 +00004747 if (Record[Idx++])
Sebastian Redlc3632732010-10-05 15:59:54 +00004748 TL.setSizeExpr(Reader.ReadExpr(F));
Douglas Gregor61d60ee2009-10-17 00:13:19 +00004749 else
John McCall51bd8032009-10-18 01:05:36 +00004750 TL.setSizeExpr(0);
4751}
4752void TypeLocReader::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) {
4753 VisitArrayTypeLoc(TL);
4754}
4755void TypeLocReader::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) {
4756 VisitArrayTypeLoc(TL);
4757}
4758void TypeLocReader::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) {
4759 VisitArrayTypeLoc(TL);
4760}
4761void TypeLocReader::VisitDependentSizedArrayTypeLoc(
4762 DependentSizedArrayTypeLoc TL) {
4763 VisitArrayTypeLoc(TL);
4764}
4765void TypeLocReader::VisitDependentSizedExtVectorTypeLoc(
4766 DependentSizedExtVectorTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00004767 TL.setNameLoc(ReadSourceLocation(Record, Idx));
John McCall51bd8032009-10-18 01:05:36 +00004768}
4769void TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00004770 TL.setNameLoc(ReadSourceLocation(Record, Idx));
John McCall51bd8032009-10-18 01:05:36 +00004771}
4772void TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00004773 TL.setNameLoc(ReadSourceLocation(Record, Idx));
John McCall51bd8032009-10-18 01:05:36 +00004774}
4775void TypeLocReader::VisitFunctionTypeLoc(FunctionTypeLoc TL) {
Abramo Bagnara796aa442011-03-12 11:17:06 +00004776 TL.setLocalRangeBegin(ReadSourceLocation(Record, Idx));
Abramo Bagnara59c0a812012-10-04 21:42:10 +00004777 TL.setLParenLoc(ReadSourceLocation(Record, Idx));
4778 TL.setRParenLoc(ReadSourceLocation(Record, Idx));
Abramo Bagnara796aa442011-03-12 11:17:06 +00004779 TL.setLocalRangeEnd(ReadSourceLocation(Record, Idx));
John McCall51bd8032009-10-18 01:05:36 +00004780 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) {
Douglas Gregor409448c2011-07-21 22:35:25 +00004781 TL.setArg(i, ReadDeclAs<ParmVarDecl>(Record, Idx));
John McCall51bd8032009-10-18 01:05:36 +00004782 }
4783}
4784void TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) {
4785 VisitFunctionTypeLoc(TL);
4786}
4787void TypeLocReader::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) {
4788 VisitFunctionTypeLoc(TL);
4789}
John McCalled976492009-12-04 22:46:56 +00004790void TypeLocReader::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00004791 TL.setNameLoc(ReadSourceLocation(Record, Idx));
John McCalled976492009-12-04 22:46:56 +00004792}
John McCall51bd8032009-10-18 01:05:36 +00004793void TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00004794 TL.setNameLoc(ReadSourceLocation(Record, Idx));
John McCall51bd8032009-10-18 01:05:36 +00004795}
4796void TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00004797 TL.setTypeofLoc(ReadSourceLocation(Record, Idx));
4798 TL.setLParenLoc(ReadSourceLocation(Record, Idx));
4799 TL.setRParenLoc(ReadSourceLocation(Record, Idx));
John McCall51bd8032009-10-18 01:05:36 +00004800}
4801void TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00004802 TL.setTypeofLoc(ReadSourceLocation(Record, Idx));
4803 TL.setLParenLoc(ReadSourceLocation(Record, Idx));
4804 TL.setRParenLoc(ReadSourceLocation(Record, Idx));
4805 TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
John McCall51bd8032009-10-18 01:05:36 +00004806}
4807void TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00004808 TL.setNameLoc(ReadSourceLocation(Record, Idx));
John McCall51bd8032009-10-18 01:05:36 +00004809}
Sean Huntca63c202011-05-24 22:41:36 +00004810void TypeLocReader::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
4811 TL.setKWLoc(ReadSourceLocation(Record, Idx));
4812 TL.setLParenLoc(ReadSourceLocation(Record, Idx));
4813 TL.setRParenLoc(ReadSourceLocation(Record, Idx));
4814 TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
4815}
Richard Smith34b41d92011-02-20 03:19:35 +00004816void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) {
4817 TL.setNameLoc(ReadSourceLocation(Record, Idx));
4818}
John McCall51bd8032009-10-18 01:05:36 +00004819void TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00004820 TL.setNameLoc(ReadSourceLocation(Record, Idx));
John McCall51bd8032009-10-18 01:05:36 +00004821}
4822void TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00004823 TL.setNameLoc(ReadSourceLocation(Record, Idx));
John McCall51bd8032009-10-18 01:05:36 +00004824}
John McCall9d156a72011-01-06 01:58:22 +00004825void TypeLocReader::VisitAttributedTypeLoc(AttributedTypeLoc TL) {
4826 TL.setAttrNameLoc(ReadSourceLocation(Record, Idx));
4827 if (TL.hasAttrOperand()) {
4828 SourceRange range;
4829 range.setBegin(ReadSourceLocation(Record, Idx));
4830 range.setEnd(ReadSourceLocation(Record, Idx));
4831 TL.setAttrOperandParensRange(range);
4832 }
4833 if (TL.hasAttrExprOperand()) {
4834 if (Record[Idx++])
4835 TL.setAttrExprOperand(Reader.ReadExpr(F));
4836 else
4837 TL.setAttrExprOperand(0);
4838 } else if (TL.hasAttrEnumOperand())
4839 TL.setAttrEnumOperandLoc(ReadSourceLocation(Record, Idx));
4840}
John McCall51bd8032009-10-18 01:05:36 +00004841void TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00004842 TL.setNameLoc(ReadSourceLocation(Record, Idx));
John McCall51bd8032009-10-18 01:05:36 +00004843}
John McCall49a832b2009-10-18 09:09:24 +00004844void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc(
4845 SubstTemplateTypeParmTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00004846 TL.setNameLoc(ReadSourceLocation(Record, Idx));
John McCall49a832b2009-10-18 09:09:24 +00004847}
Douglas Gregorc3069d62011-01-14 02:55:32 +00004848void TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc(
4849 SubstTemplateTypeParmPackTypeLoc TL) {
4850 TL.setNameLoc(ReadSourceLocation(Record, Idx));
4851}
John McCall51bd8032009-10-18 01:05:36 +00004852void TypeLocReader::VisitTemplateSpecializationTypeLoc(
4853 TemplateSpecializationTypeLoc TL) {
Abramo Bagnara55d23c92012-02-06 14:41:24 +00004854 TL.setTemplateKeywordLoc(ReadSourceLocation(Record, Idx));
Sebastian Redlc3632732010-10-05 15:59:54 +00004855 TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx));
4856 TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
4857 TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
John McCall833ca992009-10-29 08:12:44 +00004858 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
4859 TL.setArgLocInfo(i,
Sebastian Redlc3632732010-10-05 15:59:54 +00004860 Reader.GetTemplateArgumentLocInfo(F,
4861 TL.getTypePtr()->getArg(i).getKind(),
4862 Record, Idx));
John McCall51bd8032009-10-18 01:05:36 +00004863}
Abramo Bagnara075f8f12010-12-10 16:29:40 +00004864void TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) {
4865 TL.setLParenLoc(ReadSourceLocation(Record, Idx));
4866 TL.setRParenLoc(ReadSourceLocation(Record, Idx));
4867}
Abramo Bagnara465d41b2010-05-11 21:36:43 +00004868void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
Abramo Bagnara38a42912012-02-06 19:09:27 +00004869 TL.setElaboratedKeywordLoc(ReadSourceLocation(Record, Idx));
Douglas Gregor9e876872011-03-01 18:12:44 +00004870 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
John McCall51bd8032009-10-18 01:05:36 +00004871}
John McCall3cb0ebd2010-03-10 03:28:59 +00004872void TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00004873 TL.setNameLoc(ReadSourceLocation(Record, Idx));
John McCall3cb0ebd2010-03-10 03:28:59 +00004874}
Douglas Gregor4714c122010-03-31 17:34:00 +00004875void TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
Abramo Bagnara38a42912012-02-06 19:09:27 +00004876 TL.setElaboratedKeywordLoc(ReadSourceLocation(Record, Idx));
Douglas Gregor2494dd02011-03-01 01:34:45 +00004877 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
Sebastian Redlc3632732010-10-05 15:59:54 +00004878 TL.setNameLoc(ReadSourceLocation(Record, Idx));
John McCall51bd8032009-10-18 01:05:36 +00004879}
John McCall33500952010-06-11 00:33:02 +00004880void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc(
4881 DependentTemplateSpecializationTypeLoc TL) {
Abramo Bagnara55d23c92012-02-06 14:41:24 +00004882 TL.setElaboratedKeywordLoc(ReadSourceLocation(Record, Idx));
Douglas Gregor94fdffa2011-03-01 20:11:18 +00004883 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
Abramo Bagnara66581d42012-02-06 22:45:07 +00004884 TL.setTemplateKeywordLoc(ReadSourceLocation(Record, Idx));
Abramo Bagnara55d23c92012-02-06 14:41:24 +00004885 TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx));
Sebastian Redlc3632732010-10-05 15:59:54 +00004886 TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
4887 TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
John McCall33500952010-06-11 00:33:02 +00004888 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I)
4889 TL.setArgLocInfo(I,
Sebastian Redlc3632732010-10-05 15:59:54 +00004890 Reader.GetTemplateArgumentLocInfo(F,
4891 TL.getTypePtr()->getArg(I).getKind(),
4892 Record, Idx));
John McCall33500952010-06-11 00:33:02 +00004893}
Douglas Gregor7536dd52010-12-20 02:24:11 +00004894void TypeLocReader::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
4895 TL.setEllipsisLoc(ReadSourceLocation(Record, Idx));
4896}
John McCall51bd8032009-10-18 01:05:36 +00004897void TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00004898 TL.setNameLoc(ReadSourceLocation(Record, Idx));
John McCallc12c5bb2010-05-15 11:32:37 +00004899}
4900void TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
4901 TL.setHasBaseTypeAsWritten(Record[Idx++]);
Sebastian Redlc3632732010-10-05 15:59:54 +00004902 TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
4903 TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
John McCall51bd8032009-10-18 01:05:36 +00004904 for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
Sebastian Redlc3632732010-10-05 15:59:54 +00004905 TL.setProtocolLoc(i, ReadSourceLocation(Record, Idx));
John McCalla1ee0c52009-10-16 21:56:05 +00004906}
John McCall54e14c42009-10-22 22:37:11 +00004907void TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00004908 TL.setStarLoc(ReadSourceLocation(Record, Idx));
John McCall54e14c42009-10-22 22:37:11 +00004909}
Eli Friedmanb001de72011-10-06 23:00:33 +00004910void TypeLocReader::VisitAtomicTypeLoc(AtomicTypeLoc TL) {
4911 TL.setKWLoc(ReadSourceLocation(Record, Idx));
4912 TL.setLParenLoc(ReadSourceLocation(Record, Idx));
4913 TL.setRParenLoc(ReadSourceLocation(Record, Idx));
4914}
John McCalla1ee0c52009-10-16 21:56:05 +00004915
Douglas Gregor1a4761e2011-11-30 23:21:26 +00004916TypeSourceInfo *ASTReader::GetTypeSourceInfo(ModuleFile &F,
Sebastian Redl577d4792010-07-22 22:43:28 +00004917 const RecordData &Record,
John McCalla1ee0c52009-10-16 21:56:05 +00004918 unsigned &Idx) {
Douglas Gregor393f2492011-07-22 00:38:23 +00004919 QualType InfoTy = readType(F, Record, Idx);
John McCalla1ee0c52009-10-16 21:56:05 +00004920 if (InfoTy.isNull())
4921 return 0;
4922
Douglas Gregor35942772011-09-09 21:34:22 +00004923 TypeSourceInfo *TInfo = getContext().CreateTypeSourceInfo(InfoTy);
Sebastian Redlc3632732010-10-05 15:59:54 +00004924 TypeLocReader TLR(*this, F, Record, Idx);
John McCalla93c9342009-12-07 02:54:59 +00004925 for (TypeLoc TL = TInfo->getTypeLoc(); !TL.isNull(); TL = TL.getNextTypeLoc())
John McCalla1ee0c52009-10-16 21:56:05 +00004926 TLR.Visit(TL);
John McCalla93c9342009-12-07 02:54:59 +00004927 return TInfo;
John McCalla1ee0c52009-10-16 21:56:05 +00004928}
Douglas Gregor2cf26342009-04-09 22:27:44 +00004929
Sebastian Redl8538e8d2010-08-18 23:57:32 +00004930QualType ASTReader::GetType(TypeID ID) {
John McCall0953e762009-09-24 19:53:00 +00004931 unsigned FastQuals = ID & Qualifiers::FastMask;
4932 unsigned Index = ID >> Qualifiers::FastWidth;
Douglas Gregor2cf26342009-04-09 22:27:44 +00004933
Sebastian Redl8538e8d2010-08-18 23:57:32 +00004934 if (Index < NUM_PREDEF_TYPE_IDS) {
Douglas Gregor2cf26342009-04-09 22:27:44 +00004935 QualType T;
Sebastian Redl8538e8d2010-08-18 23:57:32 +00004936 switch ((PredefinedTypeIDs)Index) {
4937 case PREDEF_TYPE_NULL_ID: return QualType();
Douglas Gregor35942772011-09-09 21:34:22 +00004938 case PREDEF_TYPE_VOID_ID: T = Context.VoidTy; break;
4939 case PREDEF_TYPE_BOOL_ID: T = Context.BoolTy; break;
Douglas Gregor2cf26342009-04-09 22:27:44 +00004940
Sebastian Redl8538e8d2010-08-18 23:57:32 +00004941 case PREDEF_TYPE_CHAR_U_ID:
4942 case PREDEF_TYPE_CHAR_S_ID:
Douglas Gregor2cf26342009-04-09 22:27:44 +00004943 // FIXME: Check that the signedness of CharTy is correct!
Douglas Gregor35942772011-09-09 21:34:22 +00004944 T = Context.CharTy;
Douglas Gregor2cf26342009-04-09 22:27:44 +00004945 break;
4946
Douglas Gregor35942772011-09-09 21:34:22 +00004947 case PREDEF_TYPE_UCHAR_ID: T = Context.UnsignedCharTy; break;
4948 case PREDEF_TYPE_USHORT_ID: T = Context.UnsignedShortTy; break;
4949 case PREDEF_TYPE_UINT_ID: T = Context.UnsignedIntTy; break;
4950 case PREDEF_TYPE_ULONG_ID: T = Context.UnsignedLongTy; break;
4951 case PREDEF_TYPE_ULONGLONG_ID: T = Context.UnsignedLongLongTy; break;
4952 case PREDEF_TYPE_UINT128_ID: T = Context.UnsignedInt128Ty; break;
4953 case PREDEF_TYPE_SCHAR_ID: T = Context.SignedCharTy; break;
4954 case PREDEF_TYPE_WCHAR_ID: T = Context.WCharTy; break;
4955 case PREDEF_TYPE_SHORT_ID: T = Context.ShortTy; break;
4956 case PREDEF_TYPE_INT_ID: T = Context.IntTy; break;
4957 case PREDEF_TYPE_LONG_ID: T = Context.LongTy; break;
4958 case PREDEF_TYPE_LONGLONG_ID: T = Context.LongLongTy; break;
4959 case PREDEF_TYPE_INT128_ID: T = Context.Int128Ty; break;
Anton Korobeynikovaa4a99b2011-10-14 23:23:15 +00004960 case PREDEF_TYPE_HALF_ID: T = Context.HalfTy; break;
Douglas Gregor35942772011-09-09 21:34:22 +00004961 case PREDEF_TYPE_FLOAT_ID: T = Context.FloatTy; break;
4962 case PREDEF_TYPE_DOUBLE_ID: T = Context.DoubleTy; break;
4963 case PREDEF_TYPE_LONGDOUBLE_ID: T = Context.LongDoubleTy; break;
4964 case PREDEF_TYPE_OVERLOAD_ID: T = Context.OverloadTy; break;
4965 case PREDEF_TYPE_BOUND_MEMBER: T = Context.BoundMemberTy; break;
John McCall3c3b7f92011-10-25 17:37:35 +00004966 case PREDEF_TYPE_PSEUDO_OBJECT: T = Context.PseudoObjectTy; break;
Douglas Gregor35942772011-09-09 21:34:22 +00004967 case PREDEF_TYPE_DEPENDENT_ID: T = Context.DependentTy; break;
4968 case PREDEF_TYPE_UNKNOWN_ANY: T = Context.UnknownAnyTy; break;
4969 case PREDEF_TYPE_NULLPTR_ID: T = Context.NullPtrTy; break;
4970 case PREDEF_TYPE_CHAR16_ID: T = Context.Char16Ty; break;
4971 case PREDEF_TYPE_CHAR32_ID: T = Context.Char32Ty; break;
4972 case PREDEF_TYPE_OBJC_ID: T = Context.ObjCBuiltinIdTy; break;
4973 case PREDEF_TYPE_OBJC_CLASS: T = Context.ObjCBuiltinClassTy; break;
4974 case PREDEF_TYPE_OBJC_SEL: T = Context.ObjCBuiltinSelTy; break;
4975 case PREDEF_TYPE_AUTO_DEDUCT: T = Context.getAutoDeductType(); break;
Douglas Gregor3b8043b2011-08-09 15:13:55 +00004976
4977 case PREDEF_TYPE_AUTO_RREF_DEDUCT:
Douglas Gregor35942772011-09-09 21:34:22 +00004978 T = Context.getAutoRRefDeductType();
Douglas Gregor3b8043b2011-08-09 15:13:55 +00004979 break;
John McCall0ddaeb92011-10-17 18:09:15 +00004980
4981 case PREDEF_TYPE_ARC_UNBRIDGED_CAST:
4982 T = Context.ARCUnbridgedCastTy;
4983 break;
4984
Meador Ingefb40e3f2012-07-01 15:57:25 +00004985 case PREDEF_TYPE_VA_LIST_TAG:
4986 T = Context.getVaListTagType();
4987 break;
Eli Friedmana6c66ce2012-08-31 00:14:07 +00004988
4989 case PREDEF_TYPE_BUILTIN_FN:
4990 T = Context.BuiltinFnTy;
4991 break;
Douglas Gregor2cf26342009-04-09 22:27:44 +00004992 }
4993
4994 assert(!T.isNull() && "Unknown predefined type");
John McCall0953e762009-09-24 19:53:00 +00004995 return T.withFastQualifiers(FastQuals);
Douglas Gregor2cf26342009-04-09 22:27:44 +00004996 }
4997
Sebastian Redl8538e8d2010-08-18 23:57:32 +00004998 Index -= NUM_PREDEF_TYPE_IDS;
Sebastian Redlaaec0aa2010-07-20 22:37:49 +00004999 assert(Index < TypesLoaded.size() && "Type index out-of-range");
Sebastian Redl07a353c2010-07-14 20:26:45 +00005000 if (TypesLoaded[Index].isNull()) {
Douglas Gregor393f2492011-07-22 00:38:23 +00005001 TypesLoaded[Index] = readTypeRecord(Index);
Douglas Gregor97475832010-10-05 18:37:06 +00005002 if (TypesLoaded[Index].isNull())
5003 return QualType();
5004
Sebastian Redl3c7f4132010-08-18 23:57:06 +00005005 TypesLoaded[Index]->setFromAST();
Sebastian Redl30c514c2010-07-14 23:45:08 +00005006 if (DeserializationListener)
Argyrios Kyrtzidisc8e5d512010-08-20 16:03:59 +00005007 DeserializationListener->TypeRead(TypeIdx::fromTypeID(ID),
Sebastian Redl1476ed42010-07-16 16:36:56 +00005008 TypesLoaded[Index]);
Sebastian Redl07a353c2010-07-14 20:26:45 +00005009 }
Mike Stump1eb44332009-09-09 15:08:12 +00005010
John McCall0953e762009-09-24 19:53:00 +00005011 return TypesLoaded[Index].withFastQualifiers(FastQuals);
Douglas Gregor2cf26342009-04-09 22:27:44 +00005012}
5013
Douglas Gregor1a4761e2011-11-30 23:21:26 +00005014QualType ASTReader::getLocalType(ModuleFile &F, unsigned LocalID) {
Douglas Gregor393f2492011-07-22 00:38:23 +00005015 return GetType(getGlobalTypeID(F, LocalID));
5016}
5017
5018serialization::TypeID
Douglas Gregor1a4761e2011-11-30 23:21:26 +00005019ASTReader::getGlobalTypeID(ModuleFile &F, unsigned LocalID) const {
Douglas Gregora119da02011-08-02 16:26:37 +00005020 unsigned FastQuals = LocalID & Qualifiers::FastMask;
5021 unsigned LocalIndex = LocalID >> Qualifiers::FastWidth;
5022
5023 if (LocalIndex < NUM_PREDEF_TYPE_IDS)
5024 return LocalID;
5025
5026 ContinuousRangeMap<uint32_t, int, 2>::iterator I
5027 = F.TypeRemap.find(LocalIndex - NUM_PREDEF_TYPE_IDS);
5028 assert(I != F.TypeRemap.end() && "Invalid index into type index remap");
5029
5030 unsigned GlobalIndex = LocalIndex + I->second;
5031 return (GlobalIndex << Qualifiers::FastWidth) | FastQuals;
5032}
5033
John McCall833ca992009-10-29 08:12:44 +00005034TemplateArgumentLocInfo
Douglas Gregor1a4761e2011-11-30 23:21:26 +00005035ASTReader::GetTemplateArgumentLocInfo(ModuleFile &F,
Sebastian Redlc3632732010-10-05 15:59:54 +00005036 TemplateArgument::ArgKind Kind,
John McCall833ca992009-10-29 08:12:44 +00005037 const RecordData &Record,
Argyrios Kyrtzidis919e6932010-06-28 22:28:35 +00005038 unsigned &Index) {
John McCall833ca992009-10-29 08:12:44 +00005039 switch (Kind) {
5040 case TemplateArgument::Expression:
Sebastian Redlc3632732010-10-05 15:59:54 +00005041 return ReadExpr(F);
John McCall833ca992009-10-29 08:12:44 +00005042 case TemplateArgument::Type:
Sebastian Redlc3632732010-10-05 15:59:54 +00005043 return GetTypeSourceInfo(F, Record, Index);
Douglas Gregor788cd062009-11-11 01:00:40 +00005044 case TemplateArgument::Template: {
Douglas Gregorb6744ef2011-03-02 17:09:35 +00005045 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
5046 Index);
Sebastian Redlc3632732010-10-05 15:59:54 +00005047 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
Douglas Gregorb6744ef2011-03-02 17:09:35 +00005048 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
Douglas Gregora7fc9012011-01-05 18:58:31 +00005049 SourceLocation());
5050 }
5051 case TemplateArgument::TemplateExpansion: {
Douglas Gregorb6744ef2011-03-02 17:09:35 +00005052 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
5053 Index);
Douglas Gregora7fc9012011-01-05 18:58:31 +00005054 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
Douglas Gregorba68eca2011-01-05 17:40:24 +00005055 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Index);
Douglas Gregorb6744ef2011-03-02 17:09:35 +00005056 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
Douglas Gregorba68eca2011-01-05 17:40:24 +00005057 EllipsisLoc);
Douglas Gregor788cd062009-11-11 01:00:40 +00005058 }
John McCall833ca992009-10-29 08:12:44 +00005059 case TemplateArgument::Null:
5060 case TemplateArgument::Integral:
5061 case TemplateArgument::Declaration:
Eli Friedmand7a6b162012-09-26 02:36:12 +00005062 case TemplateArgument::NullPtr:
John McCall833ca992009-10-29 08:12:44 +00005063 case TemplateArgument::Pack:
Eli Friedmand7a6b162012-09-26 02:36:12 +00005064 // FIXME: Is this right?
John McCall833ca992009-10-29 08:12:44 +00005065 return TemplateArgumentLocInfo();
5066 }
Jeffrey Yasskin9f61aa92009-12-12 05:05:38 +00005067 llvm_unreachable("unexpected template argument loc");
John McCall833ca992009-10-29 08:12:44 +00005068}
5069
Argyrios Kyrtzidis17cfded2010-06-28 09:31:42 +00005070TemplateArgumentLoc
Douglas Gregor1a4761e2011-11-30 23:21:26 +00005071ASTReader::ReadTemplateArgumentLoc(ModuleFile &F,
Sebastian Redl577d4792010-07-22 22:43:28 +00005072 const RecordData &Record, unsigned &Index) {
Sebastian Redlc3632732010-10-05 15:59:54 +00005073 TemplateArgument Arg = ReadTemplateArgument(F, Record, Index);
Argyrios Kyrtzidis17cfded2010-06-28 09:31:42 +00005074
5075 if (Arg.getKind() == TemplateArgument::Expression) {
5076 if (Record[Index++]) // bool InfoHasSameExpr.
5077 return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo(Arg.getAsExpr()));
5078 }
Sebastian Redlc3632732010-10-05 15:59:54 +00005079 return TemplateArgumentLoc(Arg, GetTemplateArgumentLocInfo(F, Arg.getKind(),
Argyrios Kyrtzidis919e6932010-06-28 22:28:35 +00005080 Record, Index));
Argyrios Kyrtzidis44f8c372010-06-22 09:54:59 +00005081}
5082
Sebastian Redlc43b54c2010-08-18 23:56:43 +00005083Decl *ASTReader::GetExternalDecl(uint32_t ID) {
John McCall76bd1f32010-06-01 09:23:16 +00005084 return GetDecl(ID);
5085}
5086
Douglas Gregor1a4761e2011-11-30 23:21:26 +00005087uint64_t ASTReader::readCXXBaseSpecifiers(ModuleFile &M, const RecordData &Record,
Douglas Gregore92b8a12011-08-04 00:01:48 +00005088 unsigned &Idx){
5089 if (Idx >= Record.size())
Douglas Gregor7c789c12010-10-29 22:39:52 +00005090 return 0;
Douglas Gregor7c789c12010-10-29 22:39:52 +00005091
Douglas Gregore92b8a12011-08-04 00:01:48 +00005092 unsigned LocalID = Record[Idx++];
5093 return getGlobalBitOffset(M, M.CXXBaseSpecifiersOffsets[LocalID - 1]);
Douglas Gregor7c789c12010-10-29 22:39:52 +00005094}
5095
5096CXXBaseSpecifier *ASTReader::GetExternalCXXBaseSpecifiers(uint64_t Offset) {
Douglas Gregor8f1231b2011-07-22 06:10:01 +00005097 RecordLocation Loc = getLocalBitOffset(Offset);
5098 llvm::BitstreamCursor &Cursor = Loc.F->DeclsCursor;
Douglas Gregor7c789c12010-10-29 22:39:52 +00005099 SavedStreamPosition SavedPosition(Cursor);
Douglas Gregor8f1231b2011-07-22 06:10:01 +00005100 Cursor.JumpToBit(Loc.Offset);
Douglas Gregor7c789c12010-10-29 22:39:52 +00005101 ReadingKindTracker ReadingKind(Read_Decl, *this);
5102 RecordData Record;
5103 unsigned Code = Cursor.ReadCode();
5104 unsigned RecCode = Cursor.ReadRecord(Code, Record);
5105 if (RecCode != DECL_CXX_BASE_SPECIFIERS) {
5106 Error("Malformed AST file: missing C++ base specifiers");
5107 return 0;
5108 }
5109
5110 unsigned Idx = 0;
5111 unsigned NumBases = Record[Idx++];
Douglas Gregor35942772011-09-09 21:34:22 +00005112 void *Mem = Context.Allocate(sizeof(CXXBaseSpecifier) * NumBases);
Douglas Gregor7c789c12010-10-29 22:39:52 +00005113 CXXBaseSpecifier *Bases = new (Mem) CXXBaseSpecifier [NumBases];
5114 for (unsigned I = 0; I != NumBases; ++I)
Douglas Gregor8f1231b2011-07-22 06:10:01 +00005115 Bases[I] = ReadCXXBaseSpecifier(*Loc.F, Record, Idx);
Douglas Gregor7c789c12010-10-29 22:39:52 +00005116 return Bases;
5117}
5118
Douglas Gregor409448c2011-07-21 22:35:25 +00005119serialization::DeclID
Argyrios Kyrtzidis2093e0b2012-10-02 21:09:13 +00005120ASTReader::getGlobalDeclID(ModuleFile &F, LocalDeclID LocalID) const {
Douglas Gregor0a14e4b2011-08-03 16:05:40 +00005121 if (LocalID < NUM_PREDEF_DECL_IDS)
Douglas Gregor496c7092011-08-03 15:48:04 +00005122 return LocalID;
5123
5124 ContinuousRangeMap<uint32_t, int, 2>::iterator I
Douglas Gregor0a14e4b2011-08-03 16:05:40 +00005125 = F.DeclRemap.find(LocalID - NUM_PREDEF_DECL_IDS);
Douglas Gregor496c7092011-08-03 15:48:04 +00005126 assert(I != F.DeclRemap.end() && "Invalid index into decl index remap");
5127
5128 return LocalID + I->second;
Douglas Gregor409448c2011-07-21 22:35:25 +00005129}
5130
Argyrios Kyrtzidise6b8d682011-09-01 00:58:55 +00005131bool ASTReader::isDeclIDFromModule(serialization::GlobalDeclID ID,
Douglas Gregor1a4761e2011-11-30 23:21:26 +00005132 ModuleFile &M) const {
Argyrios Kyrtzidise6b8d682011-09-01 00:58:55 +00005133 GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(ID);
5134 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
5135 return &M == I->second;
5136}
5137
Douglas Gregorcff9f262012-01-27 01:47:08 +00005138ModuleFile *ASTReader::getOwningModuleFile(Decl *D) {
5139 if (!D->isFromASTFile())
5140 return 0;
5141 GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(D->getGlobalID());
5142 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
5143 return I->second;
5144}
5145
Argyrios Kyrtzidisdfb332d2011-11-03 02:20:32 +00005146SourceLocation ASTReader::getSourceLocationForDeclID(GlobalDeclID ID) {
5147 if (ID < NUM_PREDEF_DECL_IDS)
5148 return SourceLocation();
5149
5150 unsigned Index = ID - NUM_PREDEF_DECL_IDS;
5151
5152 if (Index > DeclsLoaded.size()) {
5153 Error("declaration ID out-of-range for AST file");
5154 return SourceLocation();
5155 }
5156
5157 if (Decl *D = DeclsLoaded[Index])
5158 return D->getLocation();
5159
5160 unsigned RawLocation = 0;
5161 RecordLocation Rec = DeclCursorForID(ID, RawLocation);
5162 return ReadSourceLocation(*Rec.F, RawLocation);
5163}
5164
Sebastian Redl8538e8d2010-08-18 23:57:32 +00005165Decl *ASTReader::GetDecl(DeclID ID) {
Douglas Gregor0a14e4b2011-08-03 16:05:40 +00005166 if (ID < NUM_PREDEF_DECL_IDS) {
5167 switch ((PredefinedDeclIDs)ID) {
Douglas Gregor6bf2b9f2011-08-12 00:15:20 +00005168 case PREDEF_DECL_NULL_ID:
Douglas Gregor0a14e4b2011-08-03 16:05:40 +00005169 return 0;
Douglas Gregor6bf2b9f2011-08-12 00:15:20 +00005170
5171 case PREDEF_DECL_TRANSLATION_UNIT_ID:
Douglas Gregor35942772011-09-09 21:34:22 +00005172 return Context.getTranslationUnitDecl();
Douglas Gregor4dfd02a2011-08-12 05:46:01 +00005173
5174 case PREDEF_DECL_OBJC_ID_ID:
Douglas Gregor35942772011-09-09 21:34:22 +00005175 return Context.getObjCIdDecl();
Douglas Gregor79d67262011-08-12 05:59:41 +00005176
Douglas Gregor7a27ea52011-08-12 06:17:30 +00005177 case PREDEF_DECL_OBJC_SEL_ID:
Douglas Gregor35942772011-09-09 21:34:22 +00005178 return Context.getObjCSelDecl();
Douglas Gregor7a27ea52011-08-12 06:17:30 +00005179
Douglas Gregor79d67262011-08-12 05:59:41 +00005180 case PREDEF_DECL_OBJC_CLASS_ID:
Douglas Gregor35942772011-09-09 21:34:22 +00005181 return Context.getObjCClassDecl();
Douglas Gregor772eeae2011-08-12 06:49:56 +00005182
Douglas Gregora6ea10e2012-01-17 18:09:05 +00005183 case PREDEF_DECL_OBJC_PROTOCOL_ID:
5184 return Context.getObjCProtocolDecl();
5185
Douglas Gregor772eeae2011-08-12 06:49:56 +00005186 case PREDEF_DECL_INT_128_ID:
Douglas Gregor35942772011-09-09 21:34:22 +00005187 return Context.getInt128Decl();
Douglas Gregor772eeae2011-08-12 06:49:56 +00005188
5189 case PREDEF_DECL_UNSIGNED_INT_128_ID:
Douglas Gregor35942772011-09-09 21:34:22 +00005190 return Context.getUInt128Decl();
Douglas Gregore97179c2011-09-08 01:46:34 +00005191
5192 case PREDEF_DECL_OBJC_INSTANCETYPE_ID:
Douglas Gregor35942772011-09-09 21:34:22 +00005193 return Context.getObjCInstanceTypeDecl();
Meador Ingec5613b22012-06-16 03:34:49 +00005194
5195 case PREDEF_DECL_BUILTIN_VA_LIST_ID:
5196 return Context.getBuiltinVaListDecl();
Douglas Gregor0a14e4b2011-08-03 16:05:40 +00005197 }
Douglas Gregor0a14e4b2011-08-03 16:05:40 +00005198 }
5199
Douglas Gregor6bf2b9f2011-08-12 00:15:20 +00005200 unsigned Index = ID - NUM_PREDEF_DECL_IDS;
5201
Richard Smith2fbf3732011-12-20 04:39:57 +00005202 if (Index >= DeclsLoaded.size()) {
Argyrios Kyrtzidis7518b372012-07-02 19:19:01 +00005203 assert(0 && "declaration ID out-of-range for AST file");
Sebastian Redl3c7f4132010-08-18 23:57:06 +00005204 Error("declaration ID out-of-range for AST file");
Argyrios Kyrtzidis7518b372012-07-02 19:19:01 +00005205 return 0;
Douglas Gregor8f5dc7f2009-04-25 18:35:21 +00005206 }
Douglas Gregor6bf2b9f2011-08-12 00:15:20 +00005207
Douglas Gregorfd002a72011-12-16 22:37:11 +00005208 if (!DeclsLoaded[Index]) {
Douglas Gregor496c7092011-08-03 15:48:04 +00005209 ReadDeclRecord(ID);
Sebastian Redl30c514c2010-07-14 23:45:08 +00005210 if (DeserializationListener)
5211 DeserializationListener->DeclRead(ID, DeclsLoaded[Index]);
5212 }
Douglas Gregor8f5dc7f2009-04-25 18:35:21 +00005213
5214 return DeclsLoaded[Index];
Douglas Gregor2cf26342009-04-09 22:27:44 +00005215}
5216
Douglas Gregora1be2782011-12-17 23:38:30 +00005217DeclID ASTReader::mapGlobalIDToModuleFileGlobalID(ModuleFile &M,
5218 DeclID GlobalID) {
5219 if (GlobalID < NUM_PREDEF_DECL_IDS)
5220 return GlobalID;
5221
5222 GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(GlobalID);
5223 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
5224 ModuleFile *Owner = I->second;
5225
5226 llvm::DenseMap<ModuleFile *, serialization::DeclID>::iterator Pos
5227 = M.GlobalToLocalDeclIDs.find(Owner);
5228 if (Pos == M.GlobalToLocalDeclIDs.end())
5229 return 0;
5230
5231 return GlobalID - Owner->BaseDeclID + Pos->second;
5232}
5233
Douglas Gregor1a4761e2011-11-30 23:21:26 +00005234serialization::DeclID ASTReader::ReadDeclID(ModuleFile &F,
Douglas Gregor409448c2011-07-21 22:35:25 +00005235 const RecordData &Record,
5236 unsigned &Idx) {
5237 if (Idx >= Record.size()) {
5238 Error("Corrupted AST file");
5239 return 0;
5240 }
5241
5242 return getGlobalDeclID(F, Record[Idx++]);
5243}
5244
Chris Lattner887e2b32009-04-27 05:46:25 +00005245/// \brief Resolve the offset of a statement into a statement.
5246///
5247/// This operation will read a new statement from the external
5248/// source each time it is called, and is meant to be used via a
5249/// LazyOffsetPtr (which is used by Decls for the body of functions, etc).
Sebastian Redlc43b54c2010-08-18 23:56:43 +00005250Stmt *ASTReader::GetExternalDeclStmt(uint64_t Offset) {
Argyrios Kyrtzidise09a2752010-10-28 09:29:32 +00005251 // Switch case IDs are per Decl.
5252 ClearSwitchCaseIDs();
5253
Sebastian Redl0fa7d0b2010-07-22 17:01:13 +00005254 // Offset here is a global offset across the entire chain.
Douglas Gregor8f1231b2011-07-22 06:10:01 +00005255 RecordLocation Loc = getLocalBitOffset(Offset);
5256 Loc.F->DeclsCursor.JumpToBit(Loc.Offset);
5257 return ReadStmtFromStream(*Loc.F);
Douglas Gregor250fc9c2009-04-18 00:07:54 +00005258}
5259
Douglas Gregor851c75a2011-08-24 21:27:34 +00005260namespace {
5261 class FindExternalLexicalDeclsVisitor {
5262 ASTReader &Reader;
5263 const DeclContext *DC;
5264 bool (*isKindWeWant)(Decl::Kind);
Douglas Gregor2ea054f2011-08-26 22:04:51 +00005265
Douglas Gregor851c75a2011-08-24 21:27:34 +00005266 SmallVectorImpl<Decl*> &Decls;
5267 bool PredefsVisited[NUM_PREDEF_DECL_IDS];
5268
5269 public:
5270 FindExternalLexicalDeclsVisitor(ASTReader &Reader, const DeclContext *DC,
5271 bool (*isKindWeWant)(Decl::Kind),
5272 SmallVectorImpl<Decl*> &Decls)
5273 : Reader(Reader), DC(DC), isKindWeWant(isKindWeWant), Decls(Decls)
5274 {
5275 for (unsigned I = 0; I != NUM_PREDEF_DECL_IDS; ++I)
5276 PredefsVisited[I] = false;
5277 }
5278
Douglas Gregor1a4761e2011-11-30 23:21:26 +00005279 static bool visit(ModuleFile &M, bool Preorder, void *UserData) {
Douglas Gregor851c75a2011-08-24 21:27:34 +00005280 if (Preorder)
5281 return false;
5282
5283 FindExternalLexicalDeclsVisitor *This
5284 = static_cast<FindExternalLexicalDeclsVisitor *>(UserData);
5285
Douglas Gregor1a4761e2011-11-30 23:21:26 +00005286 ModuleFile::DeclContextInfosMap::iterator Info
Douglas Gregor851c75a2011-08-24 21:27:34 +00005287 = M.DeclContextInfos.find(This->DC);
5288 if (Info == M.DeclContextInfos.end() || !Info->second.LexicalDecls)
5289 return false;
5290
5291 // Load all of the declaration IDs
5292 for (const KindDeclIDPair *ID = Info->second.LexicalDecls,
5293 *IDE = ID + Info->second.NumLexicalDecls;
5294 ID != IDE; ++ID) {
5295 if (This->isKindWeWant && !This->isKindWeWant((Decl::Kind)ID->first))
5296 continue;
5297
5298 // Don't add predefined declarations to the lexical context more
5299 // than once.
5300 if (ID->second < NUM_PREDEF_DECL_IDS) {
5301 if (This->PredefsVisited[ID->second])
5302 continue;
5303
5304 This->PredefsVisited[ID->second] = true;
5305 }
5306
Douglas Gregor2ea054f2011-08-26 22:04:51 +00005307 if (Decl *D = This->Reader.GetLocalDecl(M, ID->second)) {
5308 if (!This->DC->isDeclInLexicalTraversal(D))
5309 This->Decls.push_back(D);
5310 }
Douglas Gregor851c75a2011-08-24 21:27:34 +00005311 }
5312
5313 return false;
5314 }
5315 };
5316}
5317
Douglas Gregorba6ffaf2011-07-15 21:46:17 +00005318ExternalLoadResult ASTReader::FindExternalLexicalDecls(const DeclContext *DC,
Argyrios Kyrtzidiseb5e9982010-10-14 20:14:34 +00005319 bool (*isKindWeWant)(Decl::Kind),
Chris Lattner5f9e2722011-07-23 10:55:15 +00005320 SmallVectorImpl<Decl*> &Decls) {
Douglas Gregor0d95f772011-08-24 19:03:07 +00005321 // There might be lexical decls in multiple modules, for the TU at
Douglas Gregor851c75a2011-08-24 21:27:34 +00005322 // least. Walk all of the modules in the order they were loaded.
5323 FindExternalLexicalDeclsVisitor Visitor(*this, DC, isKindWeWant, Decls);
5324 ModuleMgr.visitDepthFirst(&FindExternalLexicalDeclsVisitor::visit, &Visitor);
Douglas Gregor25123082009-04-22 22:34:57 +00005325 ++NumLexicalDeclContextsRead;
Douglas Gregorba6ffaf2011-07-15 21:46:17 +00005326 return ELR_Success;
Douglas Gregor2cf26342009-04-09 22:27:44 +00005327}
5328
Douglas Gregor0d95f772011-08-24 19:03:07 +00005329namespace {
Argyrios Kyrtzidisdfb332d2011-11-03 02:20:32 +00005330
5331class DeclIDComp {
5332 ASTReader &Reader;
Douglas Gregor1a4761e2011-11-30 23:21:26 +00005333 ModuleFile &Mod;
Argyrios Kyrtzidisdfb332d2011-11-03 02:20:32 +00005334
5335public:
Douglas Gregor1a4761e2011-11-30 23:21:26 +00005336 DeclIDComp(ASTReader &Reader, ModuleFile &M) : Reader(Reader), Mod(M) {}
Argyrios Kyrtzidisdfb332d2011-11-03 02:20:32 +00005337
5338 bool operator()(LocalDeclID L, LocalDeclID R) const {
5339 SourceLocation LHS = getLocation(L);
5340 SourceLocation RHS = getLocation(R);
5341 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
5342 }
5343
5344 bool operator()(SourceLocation LHS, LocalDeclID R) const {
5345 SourceLocation RHS = getLocation(R);
5346 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
5347 }
5348
5349 bool operator()(LocalDeclID L, SourceLocation RHS) const {
5350 SourceLocation LHS = getLocation(L);
5351 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
5352 }
5353
5354 SourceLocation getLocation(LocalDeclID ID) const {
5355 return Reader.getSourceManager().getFileLoc(
5356 Reader.getSourceLocationForDeclID(Reader.getGlobalDeclID(Mod, ID)));
5357 }
5358};
5359
5360}
5361
5362void ASTReader::FindFileRegionDecls(FileID File,
5363 unsigned Offset, unsigned Length,
5364 SmallVectorImpl<Decl *> &Decls) {
5365 SourceManager &SM = getSourceManager();
5366
5367 llvm::DenseMap<FileID, FileDeclsInfo>::iterator I = FileDeclIDs.find(File);
5368 if (I == FileDeclIDs.end())
5369 return;
5370
5371 FileDeclsInfo &DInfo = I->second;
5372 if (DInfo.Decls.empty())
5373 return;
5374
5375 SourceLocation
5376 BeginLoc = SM.getLocForStartOfFile(File).getLocWithOffset(Offset);
5377 SourceLocation EndLoc = BeginLoc.getLocWithOffset(Length);
5378
5379 DeclIDComp DIDComp(*this, *DInfo.Mod);
5380 ArrayRef<serialization::LocalDeclID>::iterator
5381 BeginIt = std::lower_bound(DInfo.Decls.begin(), DInfo.Decls.end(),
5382 BeginLoc, DIDComp);
5383 if (BeginIt != DInfo.Decls.begin())
5384 --BeginIt;
5385
Argyrios Kyrtzidisc14a03d2011-11-23 20:27:36 +00005386 // If we are pointing at a top-level decl inside an objc container, we need
5387 // to backtrack until we find it otherwise we will fail to report that the
5388 // region overlaps with an objc container.
5389 while (BeginIt != DInfo.Decls.begin() &&
5390 GetDecl(getGlobalDeclID(*DInfo.Mod, *BeginIt))
5391 ->isTopLevelDeclInObjCContainer())
5392 --BeginIt;
5393
Argyrios Kyrtzidisdfb332d2011-11-03 02:20:32 +00005394 ArrayRef<serialization::LocalDeclID>::iterator
5395 EndIt = std::upper_bound(DInfo.Decls.begin(), DInfo.Decls.end(),
5396 EndLoc, DIDComp);
5397 if (EndIt != DInfo.Decls.end())
5398 ++EndIt;
5399
5400 for (ArrayRef<serialization::LocalDeclID>::iterator
5401 DIt = BeginIt; DIt != EndIt; ++DIt)
5402 Decls.push_back(GetDecl(getGlobalDeclID(*DInfo.Mod, *DIt)));
5403}
5404
5405namespace {
Douglas Gregor1a4761e2011-11-30 23:21:26 +00005406 /// \brief ModuleFile visitor used to perform name lookup into a
Douglas Gregor0d95f772011-08-24 19:03:07 +00005407 /// declaration context.
5408 class DeclContextNameLookupVisitor {
5409 ASTReader &Reader;
Douglas Gregorc6c8e0e2012-01-09 17:30:44 +00005410 llvm::SmallVectorImpl<const DeclContext *> &Contexts;
Douglas Gregor0d95f772011-08-24 19:03:07 +00005411 DeclarationName Name;
5412 SmallVectorImpl<NamedDecl *> &Decls;
5413
5414 public:
5415 DeclContextNameLookupVisitor(ASTReader &Reader,
Douglas Gregorc6c8e0e2012-01-09 17:30:44 +00005416 SmallVectorImpl<const DeclContext *> &Contexts,
5417 DeclarationName Name,
Douglas Gregor0d95f772011-08-24 19:03:07 +00005418 SmallVectorImpl<NamedDecl *> &Decls)
Douglas Gregorc6c8e0e2012-01-09 17:30:44 +00005419 : Reader(Reader), Contexts(Contexts), Name(Name), Decls(Decls) { }
Douglas Gregor0d95f772011-08-24 19:03:07 +00005420
Douglas Gregor1a4761e2011-11-30 23:21:26 +00005421 static bool visit(ModuleFile &M, void *UserData) {
Douglas Gregor0d95f772011-08-24 19:03:07 +00005422 DeclContextNameLookupVisitor *This
5423 = static_cast<DeclContextNameLookupVisitor *>(UserData);
5424
5425 // Check whether we have any visible declaration information for
5426 // this context in this module.
Douglas Gregorc6c8e0e2012-01-09 17:30:44 +00005427 ModuleFile::DeclContextInfosMap::iterator Info;
5428 bool FoundInfo = false;
5429 for (unsigned I = 0, N = This->Contexts.size(); I != N; ++I) {
5430 Info = M.DeclContextInfos.find(This->Contexts[I]);
5431 if (Info != M.DeclContextInfos.end() &&
5432 Info->second.NameLookupTableData) {
5433 FoundInfo = true;
5434 break;
5435 }
5436 }
Douglas Gregor0d95f772011-08-24 19:03:07 +00005437
Douglas Gregorc6c8e0e2012-01-09 17:30:44 +00005438 if (!FoundInfo)
5439 return false;
5440
Douglas Gregor0d95f772011-08-24 19:03:07 +00005441 // Look for this name within this module.
5442 ASTDeclContextNameLookupTable *LookupTable =
Benjamin Kramerb1758c62012-04-15 12:36:49 +00005443 Info->second.NameLookupTableData;
Douglas Gregor0d95f772011-08-24 19:03:07 +00005444 ASTDeclContextNameLookupTable::iterator Pos
5445 = LookupTable->find(This->Name);
5446 if (Pos == LookupTable->end())
5447 return false;
5448
5449 bool FoundAnything = false;
5450 ASTDeclContextNameLookupTrait::data_type Data = *Pos;
5451 for (; Data.first != Data.second; ++Data.first) {
5452 NamedDecl *ND = This->Reader.GetLocalDeclAs<NamedDecl>(M, *Data.first);
5453 if (!ND)
5454 continue;
5455
5456 if (ND->getDeclName() != This->Name) {
Axel Naumann3dd82f72012-10-01 09:51:27 +00005457 // A name might be null because the decl's redeclarable part is
5458 // currently read before reading its name. The lookup is triggered by
5459 // building that decl (likely indirectly), and so it is later in the
5460 // sense of "already existing" and can be ignored here.
Douglas Gregor0d95f772011-08-24 19:03:07 +00005461 continue;
5462 }
5463
5464 // Record this declaration.
5465 FoundAnything = true;
5466 This->Decls.push_back(ND);
5467 }
5468
5469 return FoundAnything;
5470 }
5471 };
5472}
5473
John McCall76bd1f32010-06-01 09:23:16 +00005474DeclContext::lookup_result
Sebastian Redlc43b54c2010-08-18 23:56:43 +00005475ASTReader::FindExternalVisibleDeclsByName(const DeclContext *DC,
John McCall76bd1f32010-06-01 09:23:16 +00005476 DeclarationName Name) {
Mike Stump1eb44332009-09-09 15:08:12 +00005477 assert(DC->hasExternalVisibleStorage() &&
Douglas Gregor2cf26342009-04-09 22:27:44 +00005478 "DeclContext has no visible decls in storage");
Argyrios Kyrtzidis074dcc82010-08-20 16:04:35 +00005479 if (!Name)
5480 return DeclContext::lookup_result(DeclContext::lookup_iterator(0),
5481 DeclContext::lookup_iterator(0));
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00005482
Chris Lattner5f9e2722011-07-23 10:55:15 +00005483 SmallVector<NamedDecl *, 64> Decls;
Douglas Gregorc6c8e0e2012-01-09 17:30:44 +00005484
5485 // Compute the declaration contexts we need to look into. Multiple such
5486 // declaration contexts occur when two declaration contexts from disjoint
5487 // modules get merged, e.g., when two namespaces with the same name are
5488 // independently defined in separate modules.
5489 SmallVector<const DeclContext *, 2> Contexts;
5490 Contexts.push_back(DC);
5491
5492 if (DC->isNamespace()) {
5493 MergedDeclsMap::iterator Merged
5494 = MergedDecls.find(const_cast<Decl *>(cast<Decl>(DC)));
5495 if (Merged != MergedDecls.end()) {
5496 for (unsigned I = 0, N = Merged->second.size(); I != N; ++I)
5497 Contexts.push_back(cast<DeclContext>(GetDecl(Merged->second[I])));
5498 }
5499 }
5500
5501 DeclContextNameLookupVisitor Visitor(*this, Contexts, Name, Decls);
Douglas Gregor0d95f772011-08-24 19:03:07 +00005502 ModuleMgr.visit(&DeclContextNameLookupVisitor::visit, &Visitor);
Douglas Gregor25123082009-04-22 22:34:57 +00005503 ++NumVisibleDeclContextsRead;
Argyrios Kyrtzidis074dcc82010-08-20 16:04:35 +00005504 SetExternalVisibleDeclsForName(DC, Name, Decls);
John McCall76bd1f32010-06-01 09:23:16 +00005505 return const_cast<DeclContext*>(DC)->lookup(Name);
Douglas Gregor2cf26342009-04-09 22:27:44 +00005506}
5507
Argyrios Kyrtzidis643586f2012-03-22 16:08:04 +00005508namespace {
Nick Lewyckyb346d2f2012-04-16 02:51:46 +00005509 /// \brief ModuleFile visitor used to retrieve all visible names in a
Argyrios Kyrtzidis643586f2012-03-22 16:08:04 +00005510 /// declaration context.
Nick Lewyckyb346d2f2012-04-16 02:51:46 +00005511 class DeclContextAllNamesVisitor {
Argyrios Kyrtzidis643586f2012-03-22 16:08:04 +00005512 ASTReader &Reader;
Nick Lewyckyb346d2f2012-04-16 02:51:46 +00005513 llvm::SmallVectorImpl<const DeclContext *> &Contexts;
Nick Lewyckyb346d2f2012-04-16 02:51:46 +00005514 llvm::DenseMap<DeclarationName, SmallVector<NamedDecl *, 8> > &Decls;
Argyrios Kyrtzidis643586f2012-03-22 16:08:04 +00005515
5516 public:
Nick Lewyckyb346d2f2012-04-16 02:51:46 +00005517 DeclContextAllNamesVisitor(ASTReader &Reader,
5518 SmallVectorImpl<const DeclContext *> &Contexts,
5519 llvm::DenseMap<DeclarationName,
5520 SmallVector<NamedDecl *, 8> > &Decls)
5521 : Reader(Reader), Contexts(Contexts), Decls(Decls) { }
Argyrios Kyrtzidis643586f2012-03-22 16:08:04 +00005522
5523 static bool visit(ModuleFile &M, void *UserData) {
Nick Lewyckyb346d2f2012-04-16 02:51:46 +00005524 DeclContextAllNamesVisitor *This
5525 = static_cast<DeclContextAllNamesVisitor *>(UserData);
Argyrios Kyrtzidis643586f2012-03-22 16:08:04 +00005526
Argyrios Kyrtzidis643586f2012-03-22 16:08:04 +00005527 // Check whether we have any visible declaration information for
5528 // this context in this module.
Nick Lewyckyb346d2f2012-04-16 02:51:46 +00005529 ModuleFile::DeclContextInfosMap::iterator Info;
5530 bool FoundInfo = false;
5531 for (unsigned I = 0, N = This->Contexts.size(); I != N; ++I) {
5532 Info = M.DeclContextInfos.find(This->Contexts[I]);
5533 if (Info != M.DeclContextInfos.end() &&
5534 Info->second.NameLookupTableData) {
5535 FoundInfo = true;
5536 break;
5537 }
Argyrios Kyrtzidis643586f2012-03-22 16:08:04 +00005538 }
5539
Nick Lewyckyb346d2f2012-04-16 02:51:46 +00005540 if (!FoundInfo)
5541 return false;
5542
5543 ASTDeclContextNameLookupTable *LookupTable =
5544 Info->second.NameLookupTableData;
5545 bool FoundAnything = false;
5546 for (ASTDeclContextNameLookupTable::data_iterator
5547 I = LookupTable->data_begin(), E = LookupTable->data_end();
5548 I != E; ++I) {
5549 ASTDeclContextNameLookupTrait::data_type Data = *I;
5550 for (; Data.first != Data.second; ++Data.first) {
5551 NamedDecl *ND = This->Reader.GetLocalDeclAs<NamedDecl>(M,
5552 *Data.first);
5553 if (!ND)
5554 continue;
5555
5556 // Record this declaration.
5557 FoundAnything = true;
5558 This->Decls[ND->getDeclName()].push_back(ND);
5559 }
5560 }
5561
5562 return FoundAnything;
Argyrios Kyrtzidis643586f2012-03-22 16:08:04 +00005563 }
5564 };
5565}
5566
Nick Lewyckyb346d2f2012-04-16 02:51:46 +00005567void ASTReader::completeVisibleDeclsMap(const DeclContext *DC) {
Argyrios Kyrtzidis643586f2012-03-22 16:08:04 +00005568 if (!DC->hasExternalVisibleStorage())
5569 return;
Nick Lewyckyb346d2f2012-04-16 02:51:46 +00005570 llvm::DenseMap<DeclarationName, llvm::SmallVector<NamedDecl*, 8> > Decls;
5571
5572 // Compute the declaration contexts we need to look into. Multiple such
5573 // declaration contexts occur when two declaration contexts from disjoint
5574 // modules get merged, e.g., when two namespaces with the same name are
5575 // independently defined in separate modules.
5576 SmallVector<const DeclContext *, 2> Contexts;
5577 Contexts.push_back(DC);
5578
5579 if (DC->isNamespace()) {
5580 MergedDeclsMap::iterator Merged
5581 = MergedDecls.find(const_cast<Decl *>(cast<Decl>(DC)));
5582 if (Merged != MergedDecls.end()) {
5583 for (unsigned I = 0, N = Merged->second.size(); I != N; ++I)
5584 Contexts.push_back(cast<DeclContext>(GetDecl(Merged->second[I])));
5585 }
5586 }
5587
5588 DeclContextAllNamesVisitor Visitor(*this, Contexts, Decls);
5589 ModuleMgr.visit(&DeclContextAllNamesVisitor::visit, &Visitor);
5590 ++NumVisibleDeclContextsRead;
5591
5592 for (llvm::DenseMap<DeclarationName,
5593 llvm::SmallVector<NamedDecl*, 8> >::iterator
5594 I = Decls.begin(), E = Decls.end(); I != E; ++I) {
5595 SetExternalVisibleDeclsForName(DC, I->first, I->second);
5596 }
Argyrios Kyrtzidis394e5392012-04-26 18:34:14 +00005597 const_cast<DeclContext *>(DC)->setHasExternalVisibleStorage(false);
Argyrios Kyrtzidis643586f2012-03-22 16:08:04 +00005598}
5599
Argyrios Kyrtzidis144b38a2011-09-13 21:35:00 +00005600/// \brief Under non-PCH compilation the consumer receives the objc methods
5601/// before receiving the implementation, and codegen depends on this.
5602/// We simulate this by deserializing and passing to consumer the methods of the
5603/// implementation before passing the deserialized implementation decl.
5604static void PassObjCImplDeclToConsumer(ObjCImplDecl *ImplD,
5605 ASTConsumer *Consumer) {
5606 assert(ImplD && Consumer);
5607
5608 for (ObjCImplDecl::method_iterator
5609 I = ImplD->meth_begin(), E = ImplD->meth_end(); I != E; ++I)
David Blaikie581deb32012-06-06 20:45:41 +00005610 Consumer->HandleInterestingDecl(DeclGroupRef(*I));
Argyrios Kyrtzidis144b38a2011-09-13 21:35:00 +00005611
5612 Consumer->HandleInterestingDecl(DeclGroupRef(ImplD));
5613}
5614
Sebastian Redlc43b54c2010-08-18 23:56:43 +00005615void ASTReader::PassInterestingDeclsToConsumer() {
Argyrios Kyrtzidisbb80a8e2010-07-07 15:46:26 +00005616 assert(Consumer);
5617 while (!InterestingDecls.empty()) {
Argyrios Kyrtzidis144b38a2011-09-13 21:35:00 +00005618 Decl *D = InterestingDecls.front();
Argyrios Kyrtzidisbb80a8e2010-07-07 15:46:26 +00005619 InterestingDecls.pop_front();
Argyrios Kyrtzidis144b38a2011-09-13 21:35:00 +00005620
Argyrios Kyrtzidis8d39c3d2011-11-30 23:18:26 +00005621 PassInterestingDeclToConsumer(D);
Argyrios Kyrtzidisbb80a8e2010-07-07 15:46:26 +00005622 }
5623}
5624
Argyrios Kyrtzidis8d39c3d2011-11-30 23:18:26 +00005625void ASTReader::PassInterestingDeclToConsumer(Decl *D) {
5626 if (ObjCImplDecl *ImplD = dyn_cast<ObjCImplDecl>(D))
5627 PassObjCImplDeclToConsumer(ImplD, Consumer);
5628 else
5629 Consumer->HandleInterestingDecl(DeclGroupRef(D));
5630}
5631
Sebastian Redlc43b54c2010-08-18 23:56:43 +00005632void ASTReader::StartTranslationUnit(ASTConsumer *Consumer) {
Douglas Gregor0af2ca42009-04-22 19:09:20 +00005633 this->Consumer = Consumer;
5634
Douglas Gregorfdd01722009-04-14 00:24:19 +00005635 if (!Consumer)
5636 return;
5637
5638 for (unsigned I = 0, N = ExternalDefinitions.size(); I != N; ++I) {
Argyrios Kyrtzidisbb80a8e2010-07-07 15:46:26 +00005639 // Force deserialization of this decl, which will cause it to be queued for
5640 // passing to the consumer.
Daniel Dunbar04a0b502009-09-17 03:06:44 +00005641 GetDecl(ExternalDefinitions[I]);
Douglas Gregorfdd01722009-04-14 00:24:19 +00005642 }
Douglas Gregor1a995dd2011-09-15 18:47:32 +00005643 ExternalDefinitions.clear();
Douglas Gregorc62a2fe2009-04-25 00:41:30 +00005644
Argyrios Kyrtzidisbb80a8e2010-07-07 15:46:26 +00005645 PassInterestingDeclsToConsumer();
Douglas Gregorfdd01722009-04-14 00:24:19 +00005646}
5647
Sebastian Redlc43b54c2010-08-18 23:56:43 +00005648void ASTReader::PrintStats() {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00005649 std::fprintf(stderr, "*** AST File Statistics:\n");
Douglas Gregor2cf26342009-04-09 22:27:44 +00005650
Mike Stump1eb44332009-09-09 15:08:12 +00005651 unsigned NumTypesLoaded
Douglas Gregor2b3a5a82009-04-25 19:10:14 +00005652 = TypesLoaded.size() - std::count(TypesLoaded.begin(), TypesLoaded.end(),
John McCall0953e762009-09-24 19:53:00 +00005653 QualType());
Douglas Gregor2b3a5a82009-04-25 19:10:14 +00005654 unsigned NumDeclsLoaded
5655 = DeclsLoaded.size() - std::count(DeclsLoaded.begin(), DeclsLoaded.end(),
5656 (Decl *)0);
5657 unsigned NumIdentifiersLoaded
5658 = IdentifiersLoaded.size() - std::count(IdentifiersLoaded.begin(),
5659 IdentifiersLoaded.end(),
5660 (IdentifierInfo *)0);
Douglas Gregora8235d62012-10-09 23:05:51 +00005661 unsigned NumMacrosLoaded
5662 = MacrosLoaded.size() - std::count(MacrosLoaded.begin(),
5663 MacrosLoaded.end(),
5664 (MacroInfo *)0);
Mike Stump1eb44332009-09-09 15:08:12 +00005665 unsigned NumSelectorsLoaded
Douglas Gregor2b3a5a82009-04-25 19:10:14 +00005666 = SelectorsLoaded.size() - std::count(SelectorsLoaded.begin(),
5667 SelectorsLoaded.end(),
5668 Selector());
Douglas Gregor2d41cc12009-04-13 20:50:16 +00005669
Douglas Gregor4fed3f42009-04-27 18:38:38 +00005670 std::fprintf(stderr, " %u stat cache hits\n", NumStatHits);
5671 std::fprintf(stderr, " %u stat cache misses\n", NumStatMisses);
Douglas Gregor0cdd7982011-07-21 18:46:38 +00005672 if (unsigned TotalNumSLocEntries = getTotalNumSLocs())
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00005673 std::fprintf(stderr, " %u/%u source location entries read (%f%%)\n",
5674 NumSLocEntriesRead, TotalNumSLocEntries,
5675 ((float)NumSLocEntriesRead/TotalNumSLocEntries * 100));
Douglas Gregor8f5dc7f2009-04-25 18:35:21 +00005676 if (!TypesLoaded.empty())
Douglas Gregor83941df2009-04-25 17:48:32 +00005677 std::fprintf(stderr, " %u/%u types read (%f%%)\n",
Douglas Gregor8f5dc7f2009-04-25 18:35:21 +00005678 NumTypesLoaded, (unsigned)TypesLoaded.size(),
5679 ((float)NumTypesLoaded/TypesLoaded.size() * 100));
5680 if (!DeclsLoaded.empty())
Douglas Gregor83941df2009-04-25 17:48:32 +00005681 std::fprintf(stderr, " %u/%u declarations read (%f%%)\n",
Douglas Gregor8f5dc7f2009-04-25 18:35:21 +00005682 NumDeclsLoaded, (unsigned)DeclsLoaded.size(),
5683 ((float)NumDeclsLoaded/DeclsLoaded.size() * 100));
Douglas Gregor2b3a5a82009-04-25 19:10:14 +00005684 if (!IdentifiersLoaded.empty())
Douglas Gregor83941df2009-04-25 17:48:32 +00005685 std::fprintf(stderr, " %u/%u identifiers read (%f%%)\n",
Douglas Gregor2b3a5a82009-04-25 19:10:14 +00005686 NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(),
5687 ((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100));
Douglas Gregora8235d62012-10-09 23:05:51 +00005688 if (!MacrosLoaded.empty())
5689 std::fprintf(stderr, " %u/%u macros read (%f%%)\n",
5690 NumMacrosLoaded, (unsigned)MacrosLoaded.size(),
5691 ((float)NumMacrosLoaded/MacrosLoaded.size() * 100));
Sebastian Redl725cd962010-08-04 20:40:17 +00005692 if (!SelectorsLoaded.empty())
Douglas Gregor83941df2009-04-25 17:48:32 +00005693 std::fprintf(stderr, " %u/%u selectors read (%f%%)\n",
Sebastian Redl725cd962010-08-04 20:40:17 +00005694 NumSelectorsLoaded, (unsigned)SelectorsLoaded.size(),
5695 ((float)NumSelectorsLoaded/SelectorsLoaded.size() * 100));
Douglas Gregor83941df2009-04-25 17:48:32 +00005696 if (TotalNumStatements)
5697 std::fprintf(stderr, " %u/%u statements read (%f%%)\n",
5698 NumStatementsRead, TotalNumStatements,
5699 ((float)NumStatementsRead/TotalNumStatements * 100));
5700 if (TotalNumMacros)
5701 std::fprintf(stderr, " %u/%u macros read (%f%%)\n",
5702 NumMacrosRead, TotalNumMacros,
5703 ((float)NumMacrosRead/TotalNumMacros * 100));
5704 if (TotalLexicalDeclContexts)
5705 std::fprintf(stderr, " %u/%u lexical declcontexts read (%f%%)\n",
5706 NumLexicalDeclContextsRead, TotalLexicalDeclContexts,
5707 ((float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts
5708 * 100));
5709 if (TotalVisibleDeclContexts)
5710 std::fprintf(stderr, " %u/%u visible declcontexts read (%f%%)\n",
5711 NumVisibleDeclContextsRead, TotalVisibleDeclContexts,
5712 ((float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts
5713 * 100));
Sebastian Redlfa78dec2010-08-04 21:22:45 +00005714 if (TotalNumMethodPoolEntries) {
Douglas Gregor83941df2009-04-25 17:48:32 +00005715 std::fprintf(stderr, " %u/%u method pool entries read (%f%%)\n",
Sebastian Redlfa78dec2010-08-04 21:22:45 +00005716 NumMethodPoolEntriesRead, TotalNumMethodPoolEntries,
5717 ((float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries
Douglas Gregor83941df2009-04-25 17:48:32 +00005718 * 100));
Sebastian Redlfa78dec2010-08-04 21:22:45 +00005719 std::fprintf(stderr, " %u method pool misses\n", NumMethodPoolMisses);
Douglas Gregor83941df2009-04-25 17:48:32 +00005720 }
Douglas Gregor2cf26342009-04-09 22:27:44 +00005721 std::fprintf(stderr, "\n");
Douglas Gregor23d7df52011-07-21 19:50:14 +00005722 dump();
5723 std::fprintf(stderr, "\n");
5724}
5725
Douglas Gregor1a4761e2011-11-30 23:21:26 +00005726template<typename Key, typename ModuleFile, unsigned InitialCapacity>
Douglas Gregor23d7df52011-07-21 19:50:14 +00005727static void
Chris Lattner5f9e2722011-07-23 10:55:15 +00005728dumpModuleIDMap(StringRef Name,
Douglas Gregor1a4761e2011-11-30 23:21:26 +00005729 const ContinuousRangeMap<Key, ModuleFile *,
Douglas Gregor23d7df52011-07-21 19:50:14 +00005730 InitialCapacity> &Map) {
5731 if (Map.begin() == Map.end())
5732 return;
5733
Douglas Gregor1a4761e2011-11-30 23:21:26 +00005734 typedef ContinuousRangeMap<Key, ModuleFile *, InitialCapacity> MapType;
Douglas Gregor23d7df52011-07-21 19:50:14 +00005735 llvm::errs() << Name << ":\n";
5736 for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end();
5737 I != IEnd; ++I) {
5738 llvm::errs() << " " << I->first << " -> " << I->second->FileName
5739 << "\n";
5740 }
5741}
5742
Douglas Gregor23d7df52011-07-21 19:50:14 +00005743void ASTReader::dump() {
Douglas Gregor1a4761e2011-11-30 23:21:26 +00005744 llvm::errs() << "*** PCH/ModuleFile Remappings:\n";
Douglas Gregor8f1231b2011-07-22 06:10:01 +00005745 dumpModuleIDMap("Global bit offset map", GlobalBitOffsetsMap);
Douglas Gregor23d7df52011-07-21 19:50:14 +00005746 dumpModuleIDMap("Global source location entry map", GlobalSLocEntryMap);
Douglas Gregor1e849b62011-07-29 00:21:44 +00005747 dumpModuleIDMap("Global type map", GlobalTypeMap);
Douglas Gregor9827a802011-07-29 00:56:45 +00005748 dumpModuleIDMap("Global declaration map", GlobalDeclMap);
Douglas Gregor9827a802011-07-29 00:56:45 +00005749 dumpModuleIDMap("Global identifier map", GlobalIdentifierMap);
Douglas Gregora8235d62012-10-09 23:05:51 +00005750 dumpModuleIDMap("Global macro map", GlobalMacroMap);
Douglas Gregor26ced122011-12-01 00:59:36 +00005751 dumpModuleIDMap("Global submodule map", GlobalSubmoduleMap);
Douglas Gregor9827a802011-07-29 00:56:45 +00005752 dumpModuleIDMap("Global selector map", GlobalSelectorMap);
Douglas Gregor9827a802011-07-29 00:56:45 +00005753 dumpModuleIDMap("Global preprocessed entity map",
5754 GlobalPreprocessedEntityMap);
Douglas Gregor8df5c9b2011-08-02 11:12:41 +00005755
5756 llvm::errs() << "\n*** PCH/Modules Loaded:";
5757 for (ModuleManager::ModuleConstIterator M = ModuleMgr.begin(),
5758 MEnd = ModuleMgr.end();
5759 M != MEnd; ++M)
5760 (*M)->dump();
Douglas Gregor2cf26342009-04-09 22:27:44 +00005761}
5762
Ted Kremeneke9b5f3d2011-04-28 23:46:20 +00005763/// Return the amount of memory used by memory buffers, breaking down
5764/// by heap-backed versus mmap'ed memory.
5765void ASTReader::getMemoryBufferSizes(MemoryBufferSizes &sizes) const {
Jonathan D. Turner5d6d89f2011-07-25 20:32:21 +00005766 for (ModuleConstIterator I = ModuleMgr.begin(),
5767 E = ModuleMgr.end(); I != E; ++I) {
5768 if (llvm::MemoryBuffer *buf = (*I)->Buffer.get()) {
Ted Kremeneke9b5f3d2011-04-28 23:46:20 +00005769 size_t bytes = buf->getBufferSize();
5770 switch (buf->getBufferKind()) {
5771 case llvm::MemoryBuffer::MemoryBuffer_Malloc:
5772 sizes.malloc_bytes += bytes;
5773 break;
5774 case llvm::MemoryBuffer::MemoryBuffer_MMap:
5775 sizes.mmap_bytes += bytes;
5776 break;
5777 }
5778 }
Jonathan D. Turner5d6d89f2011-07-25 20:32:21 +00005779 }
Ted Kremeneke9b5f3d2011-04-28 23:46:20 +00005780}
5781
Sebastian Redlc43b54c2010-08-18 23:56:43 +00005782void ASTReader::InitializeSema(Sema &S) {
Douglas Gregor668c1a42009-04-21 22:25:48 +00005783 SemaObj = &S;
Axel Naumann0ec56b72012-10-18 19:05:02 +00005784 S.addExternalSource(this);
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +00005785
Douglas Gregor6cfc1a82009-04-22 21:15:06 +00005786 // Makes sure any declarations that were deserialized "too early"
5787 // still get added to the identifier's declaration chains.
Douglas Gregor76dc8892010-09-24 23:29:12 +00005788 for (unsigned I = 0, N = PreloadedDecls.size(); I != N; ++I) {
Douglas Gregoreee242f2011-10-27 09:33:13 +00005789 SemaObj->pushExternalDeclIntoScope(PreloadedDecls[I],
5790 PreloadedDecls[I]->getDeclName());
Douglas Gregor668c1a42009-04-21 22:25:48 +00005791 }
Douglas Gregor6cfc1a82009-04-22 21:15:06 +00005792 PreloadedDecls.clear();
Douglas Gregor4c0e86b2009-04-22 22:02:47 +00005793
Argyrios Kyrtzidis76c38d32010-08-02 07:14:54 +00005794 // Load the offsets of the declarations that Sema references.
5795 // They will be lazily deserialized when needed.
5796 if (!SemaDeclRefs.empty()) {
5797 assert(SemaDeclRefs.size() == 2 && "More decl refs than expected!");
Douglas Gregor1e5b6f62011-07-28 00:57:24 +00005798 if (!SemaObj->StdNamespace)
5799 SemaObj->StdNamespace = SemaDeclRefs[0];
5800 if (!SemaObj->StdBadAlloc)
5801 SemaObj->StdBadAlloc = SemaDeclRefs[1];
Argyrios Kyrtzidis76c38d32010-08-02 07:14:54 +00005802 }
5803
Peter Collingbourne84bccea2011-02-15 19:46:30 +00005804 if (!FPPragmaOptions.empty()) {
5805 assert(FPPragmaOptions.size() == 1 && "Wrong number of FP_PRAGMA_OPTIONS");
5806 SemaObj->FPFeatures.fp_contract = FPPragmaOptions[0];
5807 }
5808
5809 if (!OpenCLExtensions.empty()) {
5810 unsigned I = 0;
5811#define OPENCLEXT(nm) SemaObj->OpenCLFeatures.nm = OpenCLExtensions[I++];
5812#include "clang/Basic/OpenCLExtensions.def"
5813
5814 assert(OpenCLExtensions.size() == I && "Wrong number of OPENCL_EXTENSIONS");
5815 }
Douglas Gregor668c1a42009-04-21 22:25:48 +00005816}
5817
Douglas Gregor211f6e82011-08-20 04:39:52 +00005818IdentifierInfo* ASTReader::get(const char *NameStart, const char *NameEnd) {
Douglas Gregor6c6c54a2012-10-11 00:46:49 +00005819 // Note that we are loading an identifier.
5820 Deserializing AnIdentifier(this);
5821
Douglas Gregor057df202012-01-18 20:56:22 +00005822 IdentifierLookupVisitor Visitor(StringRef(NameStart, NameEnd - NameStart),
5823 /*PriorGeneration=*/0);
Douglas Gregor211f6e82011-08-20 04:39:52 +00005824 ModuleMgr.visit(IdentifierLookupVisitor::visit, &Visitor);
Douglas Gregoreee242f2011-10-27 09:33:13 +00005825 IdentifierInfo *II = Visitor.getIdentifierInfo();
Douglas Gregor057df202012-01-18 20:56:22 +00005826 markIdentifierUpToDate(II);
Douglas Gregoreee242f2011-10-27 09:33:13 +00005827 return II;
Douglas Gregor668c1a42009-04-21 22:25:48 +00005828}
5829
Douglas Gregor95f42922010-10-14 22:11:03 +00005830namespace clang {
5831 /// \brief An identifier-lookup iterator that enumerates all of the
5832 /// identifiers stored within a set of AST files.
5833 class ASTIdentifierIterator : public IdentifierIterator {
5834 /// \brief The AST reader whose identifiers are being enumerated.
5835 const ASTReader &Reader;
5836
5837 /// \brief The current index into the chain of AST files stored in
5838 /// the AST reader.
5839 unsigned Index;
5840
5841 /// \brief The current position within the identifier lookup table
5842 /// of the current AST file.
5843 ASTIdentifierLookupTable::key_iterator Current;
5844
5845 /// \brief The end position within the identifier lookup table of
5846 /// the current AST file.
5847 ASTIdentifierLookupTable::key_iterator End;
5848
5849 public:
5850 explicit ASTIdentifierIterator(const ASTReader &Reader);
5851
Chris Lattner5f9e2722011-07-23 10:55:15 +00005852 virtual StringRef Next();
Douglas Gregor95f42922010-10-14 22:11:03 +00005853 };
5854}
5855
5856ASTIdentifierIterator::ASTIdentifierIterator(const ASTReader &Reader)
Jonathan D. Turner5d6d89f2011-07-25 20:32:21 +00005857 : Reader(Reader), Index(Reader.ModuleMgr.size() - 1) {
Douglas Gregor95f42922010-10-14 22:11:03 +00005858 ASTIdentifierLookupTable *IdTable
Jonathan D. Turner5d6d89f2011-07-25 20:32:21 +00005859 = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index].IdentifierLookupTable;
Douglas Gregor95f42922010-10-14 22:11:03 +00005860 Current = IdTable->key_begin();
5861 End = IdTable->key_end();
5862}
5863
Chris Lattner5f9e2722011-07-23 10:55:15 +00005864StringRef ASTIdentifierIterator::Next() {
Douglas Gregor95f42922010-10-14 22:11:03 +00005865 while (Current == End) {
5866 // If we have exhausted all of our AST files, we're done.
5867 if (Index == 0)
Chris Lattner5f9e2722011-07-23 10:55:15 +00005868 return StringRef();
Douglas Gregor95f42922010-10-14 22:11:03 +00005869
5870 --Index;
5871 ASTIdentifierLookupTable *IdTable
Jonathan D. Turner5d6d89f2011-07-25 20:32:21 +00005872 = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index].
5873 IdentifierLookupTable;
Douglas Gregor95f42922010-10-14 22:11:03 +00005874 Current = IdTable->key_begin();
5875 End = IdTable->key_end();
5876 }
5877
5878 // We have any identifiers remaining in the current AST file; return
5879 // the next one.
5880 std::pair<const char*, unsigned> Key = *Current;
5881 ++Current;
Chris Lattner5f9e2722011-07-23 10:55:15 +00005882 return StringRef(Key.first, Key.second);
Douglas Gregor95f42922010-10-14 22:11:03 +00005883}
5884
5885IdentifierIterator *ASTReader::getIdentifiers() const {
5886 return new ASTIdentifierIterator(*this);
5887}
5888
Douglas Gregor3d15ab82011-08-25 14:51:20 +00005889namespace clang { namespace serialization {
5890 class ReadMethodPoolVisitor {
5891 ASTReader &Reader;
Douglas Gregor8efca6b2012-01-25 01:14:32 +00005892 Selector Sel;
5893 unsigned PriorGeneration;
Douglas Gregor3d15ab82011-08-25 14:51:20 +00005894 llvm::SmallVector<ObjCMethodDecl *, 4> InstanceMethods;
5895 llvm::SmallVector<ObjCMethodDecl *, 4> FactoryMethods;
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +00005896
Douglas Gregor3d15ab82011-08-25 14:51:20 +00005897 public:
Douglas Gregor8efca6b2012-01-25 01:14:32 +00005898 ReadMethodPoolVisitor(ASTReader &Reader, Selector Sel,
5899 unsigned PriorGeneration)
5900 : Reader(Reader), Sel(Sel), PriorGeneration(PriorGeneration) { }
Douglas Gregor3d15ab82011-08-25 14:51:20 +00005901
Douglas Gregor1a4761e2011-11-30 23:21:26 +00005902 static bool visit(ModuleFile &M, void *UserData) {
Douglas Gregor3d15ab82011-08-25 14:51:20 +00005903 ReadMethodPoolVisitor *This
5904 = static_cast<ReadMethodPoolVisitor *>(UserData);
5905
5906 if (!M.SelectorLookupTable)
5907 return false;
5908
Douglas Gregor8efca6b2012-01-25 01:14:32 +00005909 // If we've already searched this module file, skip it now.
5910 if (M.Generation <= This->PriorGeneration)
5911 return true;
5912
Douglas Gregor3d15ab82011-08-25 14:51:20 +00005913 ASTSelectorLookupTable *PoolTable
5914 = (ASTSelectorLookupTable*)M.SelectorLookupTable;
5915 ASTSelectorLookupTable::iterator Pos = PoolTable->find(This->Sel);
5916 if (Pos == PoolTable->end())
5917 return false;
5918
5919 ++This->Reader.NumSelectorsRead;
Sebastian Redlfa78dec2010-08-04 21:22:45 +00005920 // FIXME: Not quite happy with the statistics here. We probably should
5921 // disable this tracking when called via LoadSelector.
5922 // Also, should entries without methods count as misses?
Douglas Gregor3d15ab82011-08-25 14:51:20 +00005923 ++This->Reader.NumMethodPoolEntriesRead;
Sebastian Redl3c7f4132010-08-18 23:57:06 +00005924 ASTSelectorLookupTrait::data_type Data = *Pos;
Douglas Gregor3d15ab82011-08-25 14:51:20 +00005925 if (This->Reader.DeserializationListener)
5926 This->Reader.DeserializationListener->SelectorRead(Data.ID,
5927 This->Sel);
5928
5929 This->InstanceMethods.append(Data.Instance.begin(), Data.Instance.end());
5930 This->FactoryMethods.append(Data.Factory.begin(), Data.Factory.end());
5931 return true;
Sebastian Redl725cd962010-08-04 20:40:17 +00005932 }
Douglas Gregor3d15ab82011-08-25 14:51:20 +00005933
5934 /// \brief Retrieve the instance methods found by this visitor.
Douglas Gregor5ac4b692012-01-25 00:49:42 +00005935 ArrayRef<ObjCMethodDecl *> getInstanceMethods() const {
5936 return InstanceMethods;
Douglas Gregor3d15ab82011-08-25 14:51:20 +00005937 }
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +00005938
Douglas Gregor3d15ab82011-08-25 14:51:20 +00005939 /// \brief Retrieve the instance methods found by this visitor.
Douglas Gregor5ac4b692012-01-25 00:49:42 +00005940 ArrayRef<ObjCMethodDecl *> getFactoryMethods() const {
5941 return FactoryMethods;
Douglas Gregor3d15ab82011-08-25 14:51:20 +00005942 }
5943 };
5944} } // end namespace clang::serialization
5945
Douglas Gregor5ac4b692012-01-25 00:49:42 +00005946/// \brief Add the given set of methods to the method list.
5947static void addMethodsToPool(Sema &S, ArrayRef<ObjCMethodDecl *> Methods,
5948 ObjCMethodList &List) {
5949 for (unsigned I = 0, N = Methods.size(); I != N; ++I) {
5950 S.addMethodToGlobalList(&List, Methods[I]);
5951 }
5952}
5953
5954void ASTReader::ReadMethodPool(Selector Sel) {
Douglas Gregor8efca6b2012-01-25 01:14:32 +00005955 // Get the selector generation and update it to the current generation.
5956 unsigned &Generation = SelectorGeneration[Sel];
5957 unsigned PriorGeneration = Generation;
5958 Generation = CurrentGeneration;
5959
5960 // Search for methods defined with this selector.
5961 ReadMethodPoolVisitor Visitor(*this, Sel, PriorGeneration);
Douglas Gregor3d15ab82011-08-25 14:51:20 +00005962 ModuleMgr.visit(&ReadMethodPoolVisitor::visit, &Visitor);
Douglas Gregor3d15ab82011-08-25 14:51:20 +00005963
Douglas Gregor5ac4b692012-01-25 00:49:42 +00005964 if (Visitor.getInstanceMethods().empty() &&
5965 Visitor.getFactoryMethods().empty()) {
Douglas Gregor3d15ab82011-08-25 14:51:20 +00005966 ++NumMethodPoolMisses;
Douglas Gregor5ac4b692012-01-25 00:49:42 +00005967 return;
5968 }
5969
5970 if (!getSema())
5971 return;
5972
5973 Sema &S = *getSema();
5974 Sema::GlobalMethodPool::iterator Pos
5975 = S.MethodPool.insert(std::make_pair(Sel, Sema::GlobalMethods())).first;
5976
5977 addMethodsToPool(S, Visitor.getInstanceMethods(), Pos->second.first);
5978 addMethodsToPool(S, Visitor.getFactoryMethods(), Pos->second.second);
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +00005979}
5980
Douglas Gregord8bba9c2011-06-28 16:20:02 +00005981void ASTReader::ReadKnownNamespaces(
Chris Lattner5f9e2722011-07-23 10:55:15 +00005982 SmallVectorImpl<NamespaceDecl *> &Namespaces) {
Douglas Gregord8bba9c2011-06-28 16:20:02 +00005983 Namespaces.clear();
5984
5985 for (unsigned I = 0, N = KnownNamespaces.size(); I != N; ++I) {
5986 if (NamespaceDecl *Namespace
5987 = dyn_cast_or_null<NamespaceDecl>(GetDecl(KnownNamespaces[I])))
5988 Namespaces.push_back(Namespace);
5989 }
5990}
5991
Douglas Gregora8623202011-07-27 20:58:46 +00005992void ASTReader::ReadTentativeDefinitions(
5993 SmallVectorImpl<VarDecl *> &TentativeDefs) {
5994 for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) {
5995 VarDecl *Var = dyn_cast_or_null<VarDecl>(GetDecl(TentativeDefinitions[I]));
5996 if (Var)
5997 TentativeDefs.push_back(Var);
5998 }
5999 TentativeDefinitions.clear();
6000}
6001
Douglas Gregora2ee20a2011-07-27 21:45:57 +00006002void ASTReader::ReadUnusedFileScopedDecls(
6003 SmallVectorImpl<const DeclaratorDecl *> &Decls) {
6004 for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) {
6005 DeclaratorDecl *D
6006 = dyn_cast_or_null<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I]));
6007 if (D)
6008 Decls.push_back(D);
6009 }
6010 UnusedFileScopedDecls.clear();
6011}
6012
Douglas Gregor0129b562011-07-27 21:57:17 +00006013void ASTReader::ReadDelegatingConstructors(
6014 SmallVectorImpl<CXXConstructorDecl *> &Decls) {
6015 for (unsigned I = 0, N = DelegatingCtorDecls.size(); I != N; ++I) {
6016 CXXConstructorDecl *D
6017 = dyn_cast_or_null<CXXConstructorDecl>(GetDecl(DelegatingCtorDecls[I]));
6018 if (D)
6019 Decls.push_back(D);
6020 }
6021 DelegatingCtorDecls.clear();
6022}
6023
Douglas Gregord58a0a52011-07-28 00:39:29 +00006024void ASTReader::ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl *> &Decls) {
6025 for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) {
6026 TypedefNameDecl *D
6027 = dyn_cast_or_null<TypedefNameDecl>(GetDecl(ExtVectorDecls[I]));
6028 if (D)
6029 Decls.push_back(D);
6030 }
6031 ExtVectorDecls.clear();
6032}
6033
Douglas Gregora126f172011-07-28 00:53:40 +00006034void ASTReader::ReadDynamicClasses(SmallVectorImpl<CXXRecordDecl *> &Decls) {
6035 for (unsigned I = 0, N = DynamicClasses.size(); I != N; ++I) {
6036 CXXRecordDecl *D
6037 = dyn_cast_or_null<CXXRecordDecl>(GetDecl(DynamicClasses[I]));
6038 if (D)
6039 Decls.push_back(D);
6040 }
6041 DynamicClasses.clear();
6042}
6043
Douglas Gregorec12ce22011-07-28 14:20:37 +00006044void
6045ASTReader::ReadLocallyScopedExternalDecls(SmallVectorImpl<NamedDecl *> &Decls) {
6046 for (unsigned I = 0, N = LocallyScopedExternalDecls.size(); I != N; ++I) {
6047 NamedDecl *D
6048 = dyn_cast_or_null<NamedDecl>(GetDecl(LocallyScopedExternalDecls[I]));
6049 if (D)
6050 Decls.push_back(D);
6051 }
6052 LocallyScopedExternalDecls.clear();
6053}
6054
Douglas Gregor5b9dc7c2011-07-28 14:54:22 +00006055void ASTReader::ReadReferencedSelectors(
6056 SmallVectorImpl<std::pair<Selector, SourceLocation> > &Sels) {
6057 if (ReferencedSelectorsData.empty())
6058 return;
6059
6060 // If there are @selector references added them to its pool. This is for
6061 // implementation of -Wselector.
6062 unsigned int DataSize = ReferencedSelectorsData.size()-1;
6063 unsigned I = 0;
6064 while (I < DataSize) {
6065 Selector Sel = DecodeSelector(ReferencedSelectorsData[I++]);
6066 SourceLocation SelLoc
6067 = SourceLocation::getFromRawEncoding(ReferencedSelectorsData[I++]);
6068 Sels.push_back(std::make_pair(Sel, SelLoc));
6069 }
6070 ReferencedSelectorsData.clear();
6071}
6072
Douglas Gregor31e37b22011-07-28 18:09:57 +00006073void ASTReader::ReadWeakUndeclaredIdentifiers(
6074 SmallVectorImpl<std::pair<IdentifierInfo *, WeakInfo> > &WeakIDs) {
6075 if (WeakUndeclaredIdentifiers.empty())
6076 return;
6077
6078 for (unsigned I = 0, N = WeakUndeclaredIdentifiers.size(); I < N; /*none*/) {
6079 IdentifierInfo *WeakId
6080 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
6081 IdentifierInfo *AliasId
6082 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
6083 SourceLocation Loc
6084 = SourceLocation::getFromRawEncoding(WeakUndeclaredIdentifiers[I++]);
6085 bool Used = WeakUndeclaredIdentifiers[I++];
6086 WeakInfo WI(AliasId, Loc);
6087 WI.setUsed(Used);
6088 WeakIDs.push_back(std::make_pair(WeakId, WI));
6089 }
6090 WeakUndeclaredIdentifiers.clear();
6091}
6092
Douglas Gregordfe65432011-07-28 19:11:31 +00006093void ASTReader::ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) {
6094 for (unsigned Idx = 0, N = VTableUses.size(); Idx < N; /* In loop */) {
6095 ExternalVTableUse VT;
6096 VT.Record = dyn_cast_or_null<CXXRecordDecl>(GetDecl(VTableUses[Idx++]));
6097 VT.Location = SourceLocation::getFromRawEncoding(VTableUses[Idx++]);
6098 VT.DefinitionRequired = VTableUses[Idx++];
6099 VTables.push_back(VT);
6100 }
6101
6102 VTableUses.clear();
6103}
6104
Douglas Gregor6e4a3f52011-07-28 19:49:54 +00006105void ASTReader::ReadPendingInstantiations(
6106 SmallVectorImpl<std::pair<ValueDecl *, SourceLocation> > &Pending) {
6107 for (unsigned Idx = 0, N = PendingInstantiations.size(); Idx < N;) {
6108 ValueDecl *D = cast<ValueDecl>(GetDecl(PendingInstantiations[Idx++]));
6109 SourceLocation Loc
6110 = SourceLocation::getFromRawEncoding(PendingInstantiations[Idx++]);
Axel Naumann39d26c32012-10-02 09:09:43 +00006111
Douglas Gregore5fa3c22012-10-03 18:34:48 +00006112 Pending.push_back(std::make_pair(D, Loc));
Douglas Gregor6e4a3f52011-07-28 19:49:54 +00006113 }
6114 PendingInstantiations.clear();
6115}
6116
Sebastian Redlc43b54c2010-08-18 23:56:43 +00006117void ASTReader::LoadSelector(Selector Sel) {
Sebastian Redle58aa892010-08-04 18:21:41 +00006118 // It would be complicated to avoid reading the methods anyway. So don't.
6119 ReadMethodPool(Sel);
6120}
6121
Douglas Gregor95eab172011-07-28 20:55:49 +00006122void ASTReader::SetIdentifierInfo(IdentifierID ID, IdentifierInfo *II) {
Douglas Gregor668c1a42009-04-21 22:25:48 +00006123 assert(ID && "Non-zero identifier ID required");
Douglas Gregora02b1472009-04-28 21:53:25 +00006124 assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range");
Douglas Gregor2b3a5a82009-04-25 19:10:14 +00006125 IdentifiersLoaded[ID - 1] = II;
Sebastian Redlf2f0f032010-07-23 23:49:55 +00006126 if (DeserializationListener)
6127 DeserializationListener->IdentifierRead(ID, II);
Douglas Gregor668c1a42009-04-21 22:25:48 +00006128}
6129
Douglas Gregord89275b2009-07-06 18:54:52 +00006130/// \brief Set the globally-visible declarations associated with the given
6131/// identifier.
6132///
Sebastian Redl3c7f4132010-08-18 23:57:06 +00006133/// If the AST reader is currently in a state where the given declaration IDs
Mike Stump1eb44332009-09-09 15:08:12 +00006134/// cannot safely be resolved, they are queued until it is safe to resolve
Douglas Gregord89275b2009-07-06 18:54:52 +00006135/// them.
6136///
6137/// \param II an IdentifierInfo that refers to one or more globally-visible
6138/// declarations.
6139///
6140/// \param DeclIDs the set of declaration IDs with the name @p II that are
6141/// visible at global scope.
6142///
6143/// \param Nonrecursive should be true to indicate that the caller knows that
6144/// this call is non-recursive, and therefore the globally-visible declarations
6145/// will not be placed onto the pending queue.
Mike Stump1eb44332009-09-09 15:08:12 +00006146void
Sebastian Redlc43b54c2010-08-18 23:56:43 +00006147ASTReader::SetGloballyVisibleDecls(IdentifierInfo *II,
Chris Lattner5f9e2722011-07-23 10:55:15 +00006148 const SmallVectorImpl<uint32_t> &DeclIDs,
Douglas Gregord89275b2009-07-06 18:54:52 +00006149 bool Nonrecursive) {
Argyrios Kyrtzidis29ee3a22010-07-30 10:03:16 +00006150 if (NumCurrentElementsDeserializing && !Nonrecursive) {
Douglas Gregord89275b2009-07-06 18:54:52 +00006151 PendingIdentifierInfos.push_back(PendingIdentifierInfo());
6152 PendingIdentifierInfo &PII = PendingIdentifierInfos.back();
6153 PII.II = II;
Benjamin Kramer4ea884b2010-09-06 23:43:28 +00006154 PII.DeclIDs.append(DeclIDs.begin(), DeclIDs.end());
Douglas Gregord89275b2009-07-06 18:54:52 +00006155 return;
6156 }
Mike Stump1eb44332009-09-09 15:08:12 +00006157
Douglas Gregord89275b2009-07-06 18:54:52 +00006158 for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) {
6159 NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I]));
6160 if (SemaObj) {
Douglas Gregoreee242f2011-10-27 09:33:13 +00006161 // Introduce this declaration into the translation-unit scope
6162 // and add it to the declaration chain for this identifier, so
6163 // that (unqualified) name lookup will find it.
6164 SemaObj->pushExternalDeclIntoScope(D, II);
Douglas Gregord89275b2009-07-06 18:54:52 +00006165 } else {
6166 // Queue this declaration so that it will be added to the
6167 // translation unit scope and identifier's declaration chain
6168 // once a Sema object is known.
6169 PreloadedDecls.push_back(D);
6170 }
6171 }
6172}
6173
Douglas Gregor95eab172011-07-28 20:55:49 +00006174IdentifierInfo *ASTReader::DecodeIdentifierInfo(IdentifierID ID) {
Douglas Gregorafaf3082009-04-11 00:14:32 +00006175 if (ID == 0)
6176 return 0;
Mike Stump1eb44332009-09-09 15:08:12 +00006177
Sebastian Redl11f5ccf2010-07-21 00:46:22 +00006178 if (IdentifiersLoaded.empty()) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00006179 Error("no identifier table in AST file");
Douglas Gregorafaf3082009-04-11 00:14:32 +00006180 return 0;
6181 }
Mike Stump1eb44332009-09-09 15:08:12 +00006182
Sebastian Redl11f5ccf2010-07-21 00:46:22 +00006183 ID -= 1;
6184 if (!IdentifiersLoaded[ID]) {
Douglas Gregor67268d02011-07-20 00:59:32 +00006185 GlobalIdentifierMapType::iterator I = GlobalIdentifierMap.find(ID + 1);
6186 assert(I != GlobalIdentifierMap.end() && "Corrupted global identifier map");
Douglas Gregor1a4761e2011-11-30 23:21:26 +00006187 ModuleFile *M = I->second;
Douglas Gregor9827a802011-07-29 00:56:45 +00006188 unsigned Index = ID - M->BaseIdentifierID;
6189 const char *Str = M->IdentifierTableData + M->IdentifierOffsets[Index];
Douglas Gregord6595a42009-04-25 21:04:17 +00006190
Sebastian Redl3c7f4132010-08-18 23:57:06 +00006191 // All of the strings in the AST file are preceded by a 16-bit length.
6192 // Extract that 16-bit length to avoid having to execute strlen().
Ted Kremenek231bc0b2009-10-23 04:45:31 +00006193 // NOTE: 'StrLenPtr' is an 'unsigned char*' so that we load bytes as
6194 // unsigned integers. This is important to avoid integer overflow when
6195 // we cast them to 'unsigned'.
Ted Kremenekff1ea462009-10-23 03:57:22 +00006196 const unsigned char *StrLenPtr = (const unsigned char*) Str - 2;
Douglas Gregor02fc7512009-04-28 20:01:51 +00006197 unsigned StrLen = (((unsigned) StrLenPtr[0])
6198 | (((unsigned) StrLenPtr[1]) << 8)) - 1;
Sebastian Redl11f5ccf2010-07-21 00:46:22 +00006199 IdentifiersLoaded[ID]
Douglas Gregor712f2fc2011-09-09 22:02:16 +00006200 = &PP.getIdentifierTable().get(StringRef(Str, StrLen));
Sebastian Redlf2f0f032010-07-23 23:49:55 +00006201 if (DeserializationListener)
6202 DeserializationListener->IdentifierRead(ID + 1, IdentifiersLoaded[ID]);
Douglas Gregorafaf3082009-04-11 00:14:32 +00006203 }
Mike Stump1eb44332009-09-09 15:08:12 +00006204
Sebastian Redl11f5ccf2010-07-21 00:46:22 +00006205 return IdentifiersLoaded[ID];
Douglas Gregor2cf26342009-04-09 22:27:44 +00006206}
6207
Douglas Gregor1a4761e2011-11-30 23:21:26 +00006208IdentifierInfo *ASTReader::getLocalIdentifier(ModuleFile &M, unsigned LocalID) {
Douglas Gregor95eab172011-07-28 20:55:49 +00006209 return DecodeIdentifierInfo(getGlobalIdentifierID(M, LocalID));
6210}
6211
Douglas Gregor1a4761e2011-11-30 23:21:26 +00006212IdentifierID ASTReader::getGlobalIdentifierID(ModuleFile &M, unsigned LocalID) {
Douglas Gregor6ec60e02011-08-03 21:49:18 +00006213 if (LocalID < NUM_PREDEF_IDENT_IDS)
6214 return LocalID;
6215
6216 ContinuousRangeMap<uint32_t, int, 2>::iterator I
6217 = M.IdentifierRemap.find(LocalID - NUM_PREDEF_IDENT_IDS);
6218 assert(I != M.IdentifierRemap.end()
6219 && "Invalid index into identifier index remap");
6220
6221 return LocalID + I->second;
Douglas Gregor95eab172011-07-28 20:55:49 +00006222}
6223
Douglas Gregor3ab50fe2012-10-11 17:41:54 +00006224MacroInfo *ASTReader::getMacro(MacroID ID, MacroInfo *Hint) {
Douglas Gregora8235d62012-10-09 23:05:51 +00006225 if (ID == 0)
6226 return 0;
6227
6228 if (MacrosLoaded.empty()) {
6229 Error("no macro table in AST file");
6230 return 0;
6231 }
6232
6233 ID -= NUM_PREDEF_MACRO_IDS;
6234 if (!MacrosLoaded[ID]) {
6235 GlobalMacroMapType::iterator I
6236 = GlobalMacroMap.find(ID + NUM_PREDEF_MACRO_IDS);
6237 assert(I != GlobalMacroMap.end() && "Corrupted global macro map");
6238 ModuleFile *M = I->second;
6239 unsigned Index = ID - M->BaseMacroID;
Douglas Gregor3ab50fe2012-10-11 17:41:54 +00006240 ReadMacroRecord(*M, M->MacroOffsets[Index], Hint);
Douglas Gregora8235d62012-10-09 23:05:51 +00006241 }
6242
6243 return MacrosLoaded[ID];
6244}
6245
6246MacroID ASTReader::getGlobalMacroID(ModuleFile &M, unsigned LocalID) {
6247 if (LocalID < NUM_PREDEF_MACRO_IDS)
6248 return LocalID;
6249
6250 ContinuousRangeMap<uint32_t, int, 2>::iterator I
6251 = M.MacroRemap.find(LocalID - NUM_PREDEF_MACRO_IDS);
6252 assert(I != M.MacroRemap.end() && "Invalid index into macro index remap");
6253
6254 return LocalID + I->second;
6255}
6256
Douglas Gregor26ced122011-12-01 00:59:36 +00006257serialization::SubmoduleID
6258ASTReader::getGlobalSubmoduleID(ModuleFile &M, unsigned LocalID) {
6259 if (LocalID < NUM_PREDEF_SUBMODULE_IDS)
6260 return LocalID;
6261
6262 ContinuousRangeMap<uint32_t, int, 2>::iterator I
6263 = M.SubmoduleRemap.find(LocalID - NUM_PREDEF_SUBMODULE_IDS);
6264 assert(I != M.SubmoduleRemap.end()
Douglas Gregora8235d62012-10-09 23:05:51 +00006265 && "Invalid index into submodule index remap");
Douglas Gregor26ced122011-12-01 00:59:36 +00006266
6267 return LocalID + I->second;
6268}
6269
6270Module *ASTReader::getSubmodule(SubmoduleID GlobalID) {
6271 if (GlobalID < NUM_PREDEF_SUBMODULE_IDS) {
6272 assert(GlobalID == 0 && "Unhandled global submodule ID");
6273 return 0;
6274 }
6275
6276 if (GlobalID > SubmodulesLoaded.size()) {
6277 Error("submodule ID out of range in AST file");
6278 return 0;
6279 }
6280
6281 return SubmodulesLoaded[GlobalID - NUM_PREDEF_SUBMODULE_IDS];
6282}
6283
Douglas Gregor1a4761e2011-11-30 23:21:26 +00006284Selector ASTReader::getLocalSelector(ModuleFile &M, unsigned LocalID) {
Douglas Gregor2d2689a2011-07-28 21:16:51 +00006285 return DecodeSelector(getGlobalSelectorID(M, LocalID));
6286}
6287
6288Selector ASTReader::DecodeSelector(serialization::SelectorID ID) {
Steve Naroff90cd1bb2009-04-23 10:39:46 +00006289 if (ID == 0)
6290 return Selector();
Mike Stump1eb44332009-09-09 15:08:12 +00006291
Sebastian Redl725cd962010-08-04 20:40:17 +00006292 if (ID > SelectorsLoaded.size()) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00006293 Error("selector ID out of range in AST file");
Steve Naroff90cd1bb2009-04-23 10:39:46 +00006294 return Selector();
6295 }
Douglas Gregor83941df2009-04-25 17:48:32 +00006296
Sebastian Redl725cd962010-08-04 20:40:17 +00006297 if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == 0) {
Douglas Gregor83941df2009-04-25 17:48:32 +00006298 // Load this selector from the selector table.
Douglas Gregor96958cb2011-07-20 01:10:58 +00006299 GlobalSelectorMapType::iterator I = GlobalSelectorMap.find(ID);
6300 assert(I != GlobalSelectorMap.end() && "Corrupted global selector map");
Douglas Gregor1a4761e2011-11-30 23:21:26 +00006301 ModuleFile &M = *I->second;
Douglas Gregor9827a802011-07-29 00:56:45 +00006302 ASTSelectorLookupTrait Trait(*this, M);
Douglas Gregorb18b1fd2011-08-03 23:28:44 +00006303 unsigned Idx = ID - M.BaseSelectorID - NUM_PREDEF_SELECTOR_IDS;
Douglas Gregor96958cb2011-07-20 01:10:58 +00006304 SelectorsLoaded[ID - 1] =
Douglas Gregor9827a802011-07-29 00:56:45 +00006305 Trait.ReadKey(M.SelectorLookupTableData + M.SelectorOffsets[Idx], 0);
Douglas Gregor96958cb2011-07-20 01:10:58 +00006306 if (DeserializationListener)
6307 DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]);
Douglas Gregor83941df2009-04-25 17:48:32 +00006308 }
6309
Sebastian Redl725cd962010-08-04 20:40:17 +00006310 return SelectorsLoaded[ID - 1];
Steve Naroff90cd1bb2009-04-23 10:39:46 +00006311}
6312
Douglas Gregor8451ec72011-07-28 14:41:43 +00006313Selector ASTReader::GetExternalSelector(serialization::SelectorID ID) {
Douglas Gregor719770d2010-04-06 17:30:22 +00006314 return DecodeSelector(ID);
6315}
6316
Sebastian Redlc43b54c2010-08-18 23:56:43 +00006317uint32_t ASTReader::GetNumExternalSelectors() {
Sebastian Redl725cd962010-08-04 20:40:17 +00006318 // ID 0 (the null selector) is considered an external selector.
6319 return getTotalNumSelectors() + 1;
Douglas Gregor719770d2010-04-06 17:30:22 +00006320}
6321
Douglas Gregorb18b1fd2011-08-03 23:28:44 +00006322serialization::SelectorID
Douglas Gregor1a4761e2011-11-30 23:21:26 +00006323ASTReader::getGlobalSelectorID(ModuleFile &M, unsigned LocalID) const {
Douglas Gregorb18b1fd2011-08-03 23:28:44 +00006324 if (LocalID < NUM_PREDEF_SELECTOR_IDS)
6325 return LocalID;
6326
6327 ContinuousRangeMap<uint32_t, int, 2>::iterator I
6328 = M.SelectorRemap.find(LocalID - NUM_PREDEF_SELECTOR_IDS);
6329 assert(I != M.SelectorRemap.end()
Douglas Gregora8235d62012-10-09 23:05:51 +00006330 && "Invalid index into selector index remap");
Douglas Gregorb18b1fd2011-08-03 23:28:44 +00006331
6332 return LocalID + I->second;
Douglas Gregor8451ec72011-07-28 14:41:43 +00006333}
6334
Mike Stump1eb44332009-09-09 15:08:12 +00006335DeclarationName
Douglas Gregor1a4761e2011-11-30 23:21:26 +00006336ASTReader::ReadDeclarationName(ModuleFile &F,
Douglas Gregor393f2492011-07-22 00:38:23 +00006337 const RecordData &Record, unsigned &Idx) {
Douglas Gregor2cf26342009-04-09 22:27:44 +00006338 DeclarationName::NameKind Kind = (DeclarationName::NameKind)Record[Idx++];
6339 switch (Kind) {
6340 case DeclarationName::Identifier:
Douglas Gregor95eab172011-07-28 20:55:49 +00006341 return DeclarationName(GetIdentifierInfo(F, Record, Idx));
Douglas Gregor2cf26342009-04-09 22:27:44 +00006342
6343 case DeclarationName::ObjCZeroArgSelector:
6344 case DeclarationName::ObjCOneArgSelector:
6345 case DeclarationName::ObjCMultiArgSelector:
Douglas Gregor2d2689a2011-07-28 21:16:51 +00006346 return DeclarationName(ReadSelector(F, Record, Idx));
Douglas Gregor2cf26342009-04-09 22:27:44 +00006347
6348 case DeclarationName::CXXConstructorName:
Douglas Gregor35942772011-09-09 21:34:22 +00006349 return Context.DeclarationNames.getCXXConstructorName(
6350 Context.getCanonicalType(readType(F, Record, Idx)));
Douglas Gregor2cf26342009-04-09 22:27:44 +00006351
6352 case DeclarationName::CXXDestructorName:
Douglas Gregor35942772011-09-09 21:34:22 +00006353 return Context.DeclarationNames.getCXXDestructorName(
6354 Context.getCanonicalType(readType(F, Record, Idx)));
Douglas Gregor2cf26342009-04-09 22:27:44 +00006355
6356 case DeclarationName::CXXConversionFunctionName:
Douglas Gregor35942772011-09-09 21:34:22 +00006357 return Context.DeclarationNames.getCXXConversionFunctionName(
6358 Context.getCanonicalType(readType(F, Record, Idx)));
Douglas Gregor2cf26342009-04-09 22:27:44 +00006359
6360 case DeclarationName::CXXOperatorName:
Douglas Gregor35942772011-09-09 21:34:22 +00006361 return Context.DeclarationNames.getCXXOperatorName(
Douglas Gregor2cf26342009-04-09 22:27:44 +00006362 (OverloadedOperatorKind)Record[Idx++]);
6363
Sean Hunt3e518bd2009-11-29 07:34:05 +00006364 case DeclarationName::CXXLiteralOperatorName:
Douglas Gregor35942772011-09-09 21:34:22 +00006365 return Context.DeclarationNames.getCXXLiteralOperatorName(
Douglas Gregor95eab172011-07-28 20:55:49 +00006366 GetIdentifierInfo(F, Record, Idx));
Sean Hunt3e518bd2009-11-29 07:34:05 +00006367
Douglas Gregor2cf26342009-04-09 22:27:44 +00006368 case DeclarationName::CXXUsingDirective:
6369 return DeclarationName::getUsingDirectiveName();
6370 }
6371
David Blaikie7530c032012-01-17 06:56:22 +00006372 llvm_unreachable("Invalid NameKind!");
Douglas Gregor2cf26342009-04-09 22:27:44 +00006373}
Douglas Gregor0a0428e2009-04-10 20:39:37 +00006374
Douglas Gregor1a4761e2011-11-30 23:21:26 +00006375void ASTReader::ReadDeclarationNameLoc(ModuleFile &F,
Argyrios Kyrtzidis40451072010-10-15 18:21:24 +00006376 DeclarationNameLoc &DNLoc,
6377 DeclarationName Name,
6378 const RecordData &Record, unsigned &Idx) {
6379 switch (Name.getNameKind()) {
6380 case DeclarationName::CXXConstructorName:
6381 case DeclarationName::CXXDestructorName:
6382 case DeclarationName::CXXConversionFunctionName:
6383 DNLoc.NamedType.TInfo = GetTypeSourceInfo(F, Record, Idx);
6384 break;
6385
6386 case DeclarationName::CXXOperatorName:
6387 DNLoc.CXXOperatorName.BeginOpNameLoc
6388 = ReadSourceLocation(F, Record, Idx).getRawEncoding();
6389 DNLoc.CXXOperatorName.EndOpNameLoc
6390 = ReadSourceLocation(F, Record, Idx).getRawEncoding();
6391 break;
6392
6393 case DeclarationName::CXXLiteralOperatorName:
6394 DNLoc.CXXLiteralOperatorName.OpNameLoc
6395 = ReadSourceLocation(F, Record, Idx).getRawEncoding();
6396 break;
6397
6398 case DeclarationName::Identifier:
6399 case DeclarationName::ObjCZeroArgSelector:
6400 case DeclarationName::ObjCOneArgSelector:
6401 case DeclarationName::ObjCMultiArgSelector:
6402 case DeclarationName::CXXUsingDirective:
6403 break;
6404 }
6405}
6406
Douglas Gregor1a4761e2011-11-30 23:21:26 +00006407void ASTReader::ReadDeclarationNameInfo(ModuleFile &F,
Argyrios Kyrtzidis40451072010-10-15 18:21:24 +00006408 DeclarationNameInfo &NameInfo,
6409 const RecordData &Record, unsigned &Idx) {
Douglas Gregor393f2492011-07-22 00:38:23 +00006410 NameInfo.setName(ReadDeclarationName(F, Record, Idx));
Argyrios Kyrtzidis40451072010-10-15 18:21:24 +00006411 NameInfo.setLoc(ReadSourceLocation(F, Record, Idx));
6412 DeclarationNameLoc DNLoc;
6413 ReadDeclarationNameLoc(F, DNLoc, NameInfo.getName(), Record, Idx);
6414 NameInfo.setInfo(DNLoc);
6415}
6416
Douglas Gregor1a4761e2011-11-30 23:21:26 +00006417void ASTReader::ReadQualifierInfo(ModuleFile &F, QualifierInfo &Info,
Argyrios Kyrtzidis40451072010-10-15 18:21:24 +00006418 const RecordData &Record, unsigned &Idx) {
Douglas Gregorc22b5ff2011-02-25 02:25:35 +00006419 Info.QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx);
Argyrios Kyrtzidis40451072010-10-15 18:21:24 +00006420 unsigned NumTPLists = Record[Idx++];
6421 Info.NumTemplParamLists = NumTPLists;
6422 if (NumTPLists) {
Douglas Gregor35942772011-09-09 21:34:22 +00006423 Info.TemplParamLists = new (Context) TemplateParameterList*[NumTPLists];
Argyrios Kyrtzidis40451072010-10-15 18:21:24 +00006424 for (unsigned i=0; i != NumTPLists; ++i)
6425 Info.TemplParamLists[i] = ReadTemplateParameterList(F, Record, Idx);
6426 }
6427}
6428
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00006429TemplateName
Douglas Gregor1a4761e2011-11-30 23:21:26 +00006430ASTReader::ReadTemplateName(ModuleFile &F, const RecordData &Record,
Douglas Gregor1aee05d2011-01-15 06:45:20 +00006431 unsigned &Idx) {
Michael J. Spencer20249a12010-10-21 03:16:25 +00006432 TemplateName::NameKind Kind = (TemplateName::NameKind)Record[Idx++];
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00006433 switch (Kind) {
6434 case TemplateName::Template:
Douglas Gregor409448c2011-07-21 22:35:25 +00006435 return TemplateName(ReadDeclAs<TemplateDecl>(F, Record, Idx));
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00006436
6437 case TemplateName::OverloadedTemplate: {
6438 unsigned size = Record[Idx++];
6439 UnresolvedSet<8> Decls;
6440 while (size--)
Douglas Gregor409448c2011-07-21 22:35:25 +00006441 Decls.addDecl(ReadDeclAs<NamedDecl>(F, Record, Idx));
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00006442
Douglas Gregor35942772011-09-09 21:34:22 +00006443 return Context.getOverloadedTemplateName(Decls.begin(), Decls.end());
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00006444 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00006445
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00006446 case TemplateName::QualifiedTemplate: {
Douglas Gregor409448c2011-07-21 22:35:25 +00006447 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00006448 bool hasTemplKeyword = Record[Idx++];
Douglas Gregor409448c2011-07-21 22:35:25 +00006449 TemplateDecl *Template = ReadDeclAs<TemplateDecl>(F, Record, Idx);
Douglas Gregor35942772011-09-09 21:34:22 +00006450 return Context.getQualifiedTemplateName(NNS, hasTemplKeyword, Template);
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00006451 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00006452
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00006453 case TemplateName::DependentTemplate: {
Douglas Gregor409448c2011-07-21 22:35:25 +00006454 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00006455 if (Record[Idx++]) // isIdentifier
Douglas Gregor35942772011-09-09 21:34:22 +00006456 return Context.getDependentTemplateName(NNS,
Douglas Gregor95eab172011-07-28 20:55:49 +00006457 GetIdentifierInfo(F, Record,
6458 Idx));
Douglas Gregor35942772011-09-09 21:34:22 +00006459 return Context.getDependentTemplateName(NNS,
Argyrios Kyrtzidis17cfded2010-06-28 09:31:42 +00006460 (OverloadedOperatorKind)Record[Idx++]);
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00006461 }
John McCall14606042011-06-30 08:33:18 +00006462
6463 case TemplateName::SubstTemplateTemplateParm: {
6464 TemplateTemplateParmDecl *param
Douglas Gregor409448c2011-07-21 22:35:25 +00006465 = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
John McCall14606042011-06-30 08:33:18 +00006466 if (!param) return TemplateName();
6467 TemplateName replacement = ReadTemplateName(F, Record, Idx);
Douglas Gregor35942772011-09-09 21:34:22 +00006468 return Context.getSubstTemplateTemplateParm(param, replacement);
John McCall14606042011-06-30 08:33:18 +00006469 }
Douglas Gregor1aee05d2011-01-15 06:45:20 +00006470
6471 case TemplateName::SubstTemplateTemplateParmPack: {
6472 TemplateTemplateParmDecl *Param
Douglas Gregor409448c2011-07-21 22:35:25 +00006473 = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
Douglas Gregor1aee05d2011-01-15 06:45:20 +00006474 if (!Param)
6475 return TemplateName();
6476
6477 TemplateArgument ArgPack = ReadTemplateArgument(F, Record, Idx);
6478 if (ArgPack.getKind() != TemplateArgument::Pack)
6479 return TemplateName();
6480
Douglas Gregor35942772011-09-09 21:34:22 +00006481 return Context.getSubstTemplateTemplateParmPack(Param, ArgPack);
Douglas Gregor1aee05d2011-01-15 06:45:20 +00006482 }
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00006483 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00006484
David Blaikieb219cfc2011-09-23 05:06:16 +00006485 llvm_unreachable("Unhandled template name kind!");
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00006486}
6487
6488TemplateArgument
Douglas Gregor1a4761e2011-11-30 23:21:26 +00006489ASTReader::ReadTemplateArgument(ModuleFile &F,
Sebastian Redl577d4792010-07-22 22:43:28 +00006490 const RecordData &Record, unsigned &Idx) {
Douglas Gregora7fc9012011-01-05 18:58:31 +00006491 TemplateArgument::ArgKind Kind = (TemplateArgument::ArgKind)Record[Idx++];
6492 switch (Kind) {
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00006493 case TemplateArgument::Null:
6494 return TemplateArgument();
6495 case TemplateArgument::Type:
Douglas Gregor393f2492011-07-22 00:38:23 +00006496 return TemplateArgument(readType(F, Record, Idx));
Eli Friedmand7a6b162012-09-26 02:36:12 +00006497 case TemplateArgument::Declaration: {
6498 ValueDecl *D = ReadDeclAs<ValueDecl>(F, Record, Idx);
6499 bool ForReferenceParam = Record[Idx++];
6500 return TemplateArgument(D, ForReferenceParam);
6501 }
6502 case TemplateArgument::NullPtr:
6503 return TemplateArgument(readType(F, Record, Idx), /*isNullPtr*/true);
Argyrios Kyrtzidisdc767e32010-06-28 09:31:34 +00006504 case TemplateArgument::Integral: {
6505 llvm::APSInt Value = ReadAPSInt(Record, Idx);
Douglas Gregor393f2492011-07-22 00:38:23 +00006506 QualType T = readType(F, Record, Idx);
Benjamin Kramer85524372012-06-07 15:09:51 +00006507 return TemplateArgument(Context, Value, T);
Argyrios Kyrtzidisdc767e32010-06-28 09:31:34 +00006508 }
Douglas Gregora7fc9012011-01-05 18:58:31 +00006509 case TemplateArgument::Template:
Douglas Gregor1aee05d2011-01-15 06:45:20 +00006510 return TemplateArgument(ReadTemplateName(F, Record, Idx));
Douglas Gregora7fc9012011-01-05 18:58:31 +00006511 case TemplateArgument::TemplateExpansion: {
Douglas Gregor1aee05d2011-01-15 06:45:20 +00006512 TemplateName Name = ReadTemplateName(F, Record, Idx);
Douglas Gregor2be29f42011-01-14 23:41:42 +00006513 llvm::Optional<unsigned> NumTemplateExpansions;
6514 if (unsigned NumExpansions = Record[Idx++])
6515 NumTemplateExpansions = NumExpansions - 1;
6516 return TemplateArgument(Name, NumTemplateExpansions);
Douglas Gregorba68eca2011-01-05 17:40:24 +00006517 }
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00006518 case TemplateArgument::Expression:
Sebastian Redlc3632732010-10-05 15:59:54 +00006519 return TemplateArgument(ReadExpr(F));
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00006520 case TemplateArgument::Pack: {
6521 unsigned NumArgs = Record[Idx++];
Douglas Gregor35942772011-09-09 21:34:22 +00006522 TemplateArgument *Args = new (Context) TemplateArgument[NumArgs];
Douglas Gregor910f8002010-11-07 23:05:16 +00006523 for (unsigned I = 0; I != NumArgs; ++I)
6524 Args[I] = ReadTemplateArgument(F, Record, Idx);
6525 return TemplateArgument(Args, NumArgs);
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00006526 }
6527 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00006528
David Blaikieb219cfc2011-09-23 05:06:16 +00006529 llvm_unreachable("Unhandled template argument kind!");
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00006530}
6531
Argyrios Kyrtzidisdd41c142010-06-23 13:48:30 +00006532TemplateParameterList *
Douglas Gregor1a4761e2011-11-30 23:21:26 +00006533ASTReader::ReadTemplateParameterList(ModuleFile &F,
Sebastian Redlc3632732010-10-05 15:59:54 +00006534 const RecordData &Record, unsigned &Idx) {
6535 SourceLocation TemplateLoc = ReadSourceLocation(F, Record, Idx);
6536 SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Idx);
6537 SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Idx);
Argyrios Kyrtzidisdd41c142010-06-23 13:48:30 +00006538
6539 unsigned NumParams = Record[Idx++];
Chris Lattner5f9e2722011-07-23 10:55:15 +00006540 SmallVector<NamedDecl *, 16> Params;
Argyrios Kyrtzidisdd41c142010-06-23 13:48:30 +00006541 Params.reserve(NumParams);
6542 while (NumParams--)
Douglas Gregor409448c2011-07-21 22:35:25 +00006543 Params.push_back(ReadDeclAs<NamedDecl>(F, Record, Idx));
Michael J. Spencer20249a12010-10-21 03:16:25 +00006544
6545 TemplateParameterList* TemplateParams =
Douglas Gregor35942772011-09-09 21:34:22 +00006546 TemplateParameterList::Create(Context, TemplateLoc, LAngleLoc,
Argyrios Kyrtzidisdd41c142010-06-23 13:48:30 +00006547 Params.data(), Params.size(), RAngleLoc);
6548 return TemplateParams;
6549}
6550
6551void
Sebastian Redlc43b54c2010-08-18 23:56:43 +00006552ASTReader::
Chris Lattner5f9e2722011-07-23 10:55:15 +00006553ReadTemplateArgumentList(SmallVector<TemplateArgument, 8> &TemplArgs,
Douglas Gregor1a4761e2011-11-30 23:21:26 +00006554 ModuleFile &F, const RecordData &Record,
Sebastian Redlc3632732010-10-05 15:59:54 +00006555 unsigned &Idx) {
Argyrios Kyrtzidisdd41c142010-06-23 13:48:30 +00006556 unsigned NumTemplateArgs = Record[Idx++];
6557 TemplArgs.reserve(NumTemplateArgs);
6558 while (NumTemplateArgs--)
Sebastian Redlc3632732010-10-05 15:59:54 +00006559 TemplArgs.push_back(ReadTemplateArgument(F, Record, Idx));
Argyrios Kyrtzidisdd41c142010-06-23 13:48:30 +00006560}
6561
Argyrios Kyrtzidis37ffed32010-07-02 11:55:32 +00006562/// \brief Read a UnresolvedSet structure.
Douglas Gregor1a4761e2011-11-30 23:21:26 +00006563void ASTReader::ReadUnresolvedSet(ModuleFile &F, UnresolvedSetImpl &Set,
Argyrios Kyrtzidis37ffed32010-07-02 11:55:32 +00006564 const RecordData &Record, unsigned &Idx) {
6565 unsigned NumDecls = Record[Idx++];
6566 while (NumDecls--) {
Douglas Gregor409448c2011-07-21 22:35:25 +00006567 NamedDecl *D = ReadDeclAs<NamedDecl>(F, Record, Idx);
Argyrios Kyrtzidis37ffed32010-07-02 11:55:32 +00006568 AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
6569 Set.addDecl(D, AS);
6570 }
6571}
6572
Argyrios Kyrtzidis0745d0a2010-07-02 23:30:27 +00006573CXXBaseSpecifier
Douglas Gregor1a4761e2011-11-30 23:21:26 +00006574ASTReader::ReadCXXBaseSpecifier(ModuleFile &F,
Nick Lewycky56062202010-07-26 16:56:01 +00006575 const RecordData &Record, unsigned &Idx) {
Argyrios Kyrtzidis0745d0a2010-07-02 23:30:27 +00006576 bool isVirtual = static_cast<bool>(Record[Idx++]);
6577 bool isBaseOfClass = static_cast<bool>(Record[Idx++]);
6578 AccessSpecifier AS = static_cast<AccessSpecifier>(Record[Idx++]);
Sebastian Redlf677ea32011-02-05 19:23:19 +00006579 bool inheritConstructors = static_cast<bool>(Record[Idx++]);
Sebastian Redlc3632732010-10-05 15:59:54 +00006580 TypeSourceInfo *TInfo = GetTypeSourceInfo(F, Record, Idx);
6581 SourceRange Range = ReadSourceRange(F, Record, Idx);
Douglas Gregorf90b27a2011-01-03 22:36:02 +00006582 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Idx);
Sebastian Redlf677ea32011-02-05 19:23:19 +00006583 CXXBaseSpecifier Result(Range, isVirtual, isBaseOfClass, AS, TInfo,
Douglas Gregorf90b27a2011-01-03 22:36:02 +00006584 EllipsisLoc);
Sebastian Redlf677ea32011-02-05 19:23:19 +00006585 Result.setInheritConstructors(inheritConstructors);
6586 return Result;
Argyrios Kyrtzidis0745d0a2010-07-02 23:30:27 +00006587}
6588
Sean Huntcbb67482011-01-08 20:30:50 +00006589std::pair<CXXCtorInitializer **, unsigned>
Douglas Gregor1a4761e2011-11-30 23:21:26 +00006590ASTReader::ReadCXXCtorInitializers(ModuleFile &F, const RecordData &Record,
Sean Huntcbb67482011-01-08 20:30:50 +00006591 unsigned &Idx) {
6592 CXXCtorInitializer **CtorInitializers = 0;
Argyrios Kyrtzidis8e706f42010-08-09 10:54:12 +00006593 unsigned NumInitializers = Record[Idx++];
6594 if (NumInitializers) {
Sean Huntcbb67482011-01-08 20:30:50 +00006595 CtorInitializers
Douglas Gregor35942772011-09-09 21:34:22 +00006596 = new (Context) CXXCtorInitializer*[NumInitializers];
Argyrios Kyrtzidis8e706f42010-08-09 10:54:12 +00006597 for (unsigned i=0; i != NumInitializers; ++i) {
Douglas Gregor76852c22011-11-01 01:16:03 +00006598 TypeSourceInfo *TInfo = 0;
Argyrios Kyrtzidis8e706f42010-08-09 10:54:12 +00006599 bool IsBaseVirtual = false;
6600 FieldDecl *Member = 0;
Francois Pichet00eb3f92010-12-04 09:14:42 +00006601 IndirectFieldDecl *IndirectMember = 0;
Michael J. Spencer20249a12010-10-21 03:16:25 +00006602
Sean Hunt156b6402011-05-04 01:19:08 +00006603 CtorInitializerType Type = (CtorInitializerType)Record[Idx++];
6604 switch (Type) {
Douglas Gregor76852c22011-11-01 01:16:03 +00006605 case CTOR_INITIALIZER_BASE:
6606 TInfo = GetTypeSourceInfo(F, Record, Idx);
Argyrios Kyrtzidis8e706f42010-08-09 10:54:12 +00006607 IsBaseVirtual = Record[Idx++];
Sean Hunt156b6402011-05-04 01:19:08 +00006608 break;
Douglas Gregor76852c22011-11-01 01:16:03 +00006609
6610 case CTOR_INITIALIZER_DELEGATING:
6611 TInfo = GetTypeSourceInfo(F, Record, Idx);
Sean Hunt156b6402011-05-04 01:19:08 +00006612 break;
6613
6614 case CTOR_INITIALIZER_MEMBER:
Douglas Gregor409448c2011-07-21 22:35:25 +00006615 Member = ReadDeclAs<FieldDecl>(F, Record, Idx);
Sean Hunt156b6402011-05-04 01:19:08 +00006616 break;
6617
6618 case CTOR_INITIALIZER_INDIRECT_MEMBER:
Douglas Gregor409448c2011-07-21 22:35:25 +00006619 IndirectMember = ReadDeclAs<IndirectFieldDecl>(F, Record, Idx);
Sean Hunt156b6402011-05-04 01:19:08 +00006620 break;
Argyrios Kyrtzidis8e706f42010-08-09 10:54:12 +00006621 }
Sean Hunt156b6402011-05-04 01:19:08 +00006622
Douglas Gregor3fb9e4b2011-01-04 00:32:56 +00006623 SourceLocation MemberOrEllipsisLoc = ReadSourceLocation(F, Record, Idx);
Sebastian Redlc3632732010-10-05 15:59:54 +00006624 Expr *Init = ReadExpr(F);
Sebastian Redlc3632732010-10-05 15:59:54 +00006625 SourceLocation LParenLoc = ReadSourceLocation(F, Record, Idx);
6626 SourceLocation RParenLoc = ReadSourceLocation(F, Record, Idx);
Argyrios Kyrtzidis8e706f42010-08-09 10:54:12 +00006627 bool IsWritten = Record[Idx++];
6628 unsigned SourceOrderOrNumArrayIndices;
Chris Lattner5f9e2722011-07-23 10:55:15 +00006629 SmallVector<VarDecl *, 8> Indices;
Argyrios Kyrtzidis8e706f42010-08-09 10:54:12 +00006630 if (IsWritten) {
6631 SourceOrderOrNumArrayIndices = Record[Idx++];
6632 } else {
6633 SourceOrderOrNumArrayIndices = Record[Idx++];
6634 Indices.reserve(SourceOrderOrNumArrayIndices);
6635 for (unsigned i=0; i != SourceOrderOrNumArrayIndices; ++i)
Douglas Gregor409448c2011-07-21 22:35:25 +00006636 Indices.push_back(ReadDeclAs<VarDecl>(F, Record, Idx));
Argyrios Kyrtzidis8e706f42010-08-09 10:54:12 +00006637 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00006638
Sean Huntcbb67482011-01-08 20:30:50 +00006639 CXXCtorInitializer *BOMInit;
Sean Hunt156b6402011-05-04 01:19:08 +00006640 if (Type == CTOR_INITIALIZER_BASE) {
Douglas Gregor76852c22011-11-01 01:16:03 +00006641 BOMInit = new (Context) CXXCtorInitializer(Context, TInfo, IsBaseVirtual,
Sean Huntcbb67482011-01-08 20:30:50 +00006642 LParenLoc, Init, RParenLoc,
6643 MemberOrEllipsisLoc);
Sean Hunt156b6402011-05-04 01:19:08 +00006644 } else if (Type == CTOR_INITIALIZER_DELEGATING) {
Douglas Gregor76852c22011-11-01 01:16:03 +00006645 BOMInit = new (Context) CXXCtorInitializer(Context, TInfo, LParenLoc,
6646 Init, RParenLoc);
Argyrios Kyrtzidis8e706f42010-08-09 10:54:12 +00006647 } else if (IsWritten) {
Francois Pichet00eb3f92010-12-04 09:14:42 +00006648 if (Member)
Douglas Gregor35942772011-09-09 21:34:22 +00006649 BOMInit = new (Context) CXXCtorInitializer(Context, Member, MemberOrEllipsisLoc,
Sean Huntcbb67482011-01-08 20:30:50 +00006650 LParenLoc, Init, RParenLoc);
Francois Pichet00eb3f92010-12-04 09:14:42 +00006651 else
Douglas Gregor35942772011-09-09 21:34:22 +00006652 BOMInit = new (Context) CXXCtorInitializer(Context, IndirectMember,
Sean Huntcbb67482011-01-08 20:30:50 +00006653 MemberOrEllipsisLoc, LParenLoc,
6654 Init, RParenLoc);
Argyrios Kyrtzidis8e706f42010-08-09 10:54:12 +00006655 } else {
Douglas Gregor35942772011-09-09 21:34:22 +00006656 BOMInit = CXXCtorInitializer::Create(Context, Member, MemberOrEllipsisLoc,
Sean Huntcbb67482011-01-08 20:30:50 +00006657 LParenLoc, Init, RParenLoc,
6658 Indices.data(), Indices.size());
Argyrios Kyrtzidis8e706f42010-08-09 10:54:12 +00006659 }
6660
Argyrios Kyrtzidisf84cde12010-09-06 19:04:27 +00006661 if (IsWritten)
6662 BOMInit->setSourceOrder(SourceOrderOrNumArrayIndices);
Sean Huntcbb67482011-01-08 20:30:50 +00006663 CtorInitializers[i] = BOMInit;
Argyrios Kyrtzidis8e706f42010-08-09 10:54:12 +00006664 }
6665 }
6666
Sean Huntcbb67482011-01-08 20:30:50 +00006667 return std::make_pair(CtorInitializers, NumInitializers);
Argyrios Kyrtzidis8e706f42010-08-09 10:54:12 +00006668}
6669
Chris Lattner6ad9ac02010-05-07 21:43:38 +00006670NestedNameSpecifier *
Douglas Gregor1a4761e2011-11-30 23:21:26 +00006671ASTReader::ReadNestedNameSpecifier(ModuleFile &F,
Douglas Gregor409448c2011-07-21 22:35:25 +00006672 const RecordData &Record, unsigned &Idx) {
Chris Lattner6ad9ac02010-05-07 21:43:38 +00006673 unsigned N = Record[Idx++];
6674 NestedNameSpecifier *NNS = 0, *Prev = 0;
6675 for (unsigned I = 0; I != N; ++I) {
6676 NestedNameSpecifier::SpecifierKind Kind
6677 = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
6678 switch (Kind) {
6679 case NestedNameSpecifier::Identifier: {
Douglas Gregor95eab172011-07-28 20:55:49 +00006680 IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx);
Douglas Gregor35942772011-09-09 21:34:22 +00006681 NNS = NestedNameSpecifier::Create(Context, Prev, II);
Chris Lattner6ad9ac02010-05-07 21:43:38 +00006682 break;
6683 }
6684
6685 case NestedNameSpecifier::Namespace: {
Douglas Gregor409448c2011-07-21 22:35:25 +00006686 NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
Douglas Gregor35942772011-09-09 21:34:22 +00006687 NNS = NestedNameSpecifier::Create(Context, Prev, NS);
Chris Lattner6ad9ac02010-05-07 21:43:38 +00006688 break;
6689 }
6690
Douglas Gregor14aba762011-02-24 02:36:08 +00006691 case NestedNameSpecifier::NamespaceAlias: {
Douglas Gregor409448c2011-07-21 22:35:25 +00006692 NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
Douglas Gregor35942772011-09-09 21:34:22 +00006693 NNS = NestedNameSpecifier::Create(Context, Prev, Alias);
Douglas Gregor14aba762011-02-24 02:36:08 +00006694 break;
6695 }
6696
Chris Lattner6ad9ac02010-05-07 21:43:38 +00006697 case NestedNameSpecifier::TypeSpec:
6698 case NestedNameSpecifier::TypeSpecWithTemplate: {
Douglas Gregor393f2492011-07-22 00:38:23 +00006699 const Type *T = readType(F, Record, Idx).getTypePtrOrNull();
Douglas Gregor1ab55e92010-12-10 17:03:06 +00006700 if (!T)
6701 return 0;
6702
Chris Lattner6ad9ac02010-05-07 21:43:38 +00006703 bool Template = Record[Idx++];
Douglas Gregor35942772011-09-09 21:34:22 +00006704 NNS = NestedNameSpecifier::Create(Context, Prev, Template, T);
Chris Lattner6ad9ac02010-05-07 21:43:38 +00006705 break;
6706 }
6707
6708 case NestedNameSpecifier::Global: {
Douglas Gregor35942772011-09-09 21:34:22 +00006709 NNS = NestedNameSpecifier::GlobalSpecifier(Context);
Chris Lattner6ad9ac02010-05-07 21:43:38 +00006710 // No associated value, and there can't be a prefix.
6711 break;
6712 }
Chris Lattner6ad9ac02010-05-07 21:43:38 +00006713 }
Argyrios Kyrtzidisd2bb2c02010-07-07 15:46:30 +00006714 Prev = NNS;
Chris Lattner6ad9ac02010-05-07 21:43:38 +00006715 }
6716 return NNS;
6717}
6718
Douglas Gregordc355712011-02-25 00:36:19 +00006719NestedNameSpecifierLoc
Douglas Gregor1a4761e2011-11-30 23:21:26 +00006720ASTReader::ReadNestedNameSpecifierLoc(ModuleFile &F, const RecordData &Record,
Douglas Gregordc355712011-02-25 00:36:19 +00006721 unsigned &Idx) {
6722 unsigned N = Record[Idx++];
Douglas Gregor5f791bb2011-02-28 23:58:31 +00006723 NestedNameSpecifierLocBuilder Builder;
Douglas Gregordc355712011-02-25 00:36:19 +00006724 for (unsigned I = 0; I != N; ++I) {
6725 NestedNameSpecifier::SpecifierKind Kind
6726 = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
6727 switch (Kind) {
6728 case NestedNameSpecifier::Identifier: {
Douglas Gregor95eab172011-07-28 20:55:49 +00006729 IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx);
Douglas Gregordc355712011-02-25 00:36:19 +00006730 SourceRange Range = ReadSourceRange(F, Record, Idx);
Douglas Gregor35942772011-09-09 21:34:22 +00006731 Builder.Extend(Context, II, Range.getBegin(), Range.getEnd());
Douglas Gregordc355712011-02-25 00:36:19 +00006732 break;
6733 }
6734
6735 case NestedNameSpecifier::Namespace: {
Douglas Gregor409448c2011-07-21 22:35:25 +00006736 NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
Douglas Gregordc355712011-02-25 00:36:19 +00006737 SourceRange Range = ReadSourceRange(F, Record, Idx);
Douglas Gregor35942772011-09-09 21:34:22 +00006738 Builder.Extend(Context, NS, Range.getBegin(), Range.getEnd());
Douglas Gregordc355712011-02-25 00:36:19 +00006739 break;
6740 }
6741
6742 case NestedNameSpecifier::NamespaceAlias: {
Douglas Gregor409448c2011-07-21 22:35:25 +00006743 NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
Douglas Gregordc355712011-02-25 00:36:19 +00006744 SourceRange Range = ReadSourceRange(F, Record, Idx);
Douglas Gregor35942772011-09-09 21:34:22 +00006745 Builder.Extend(Context, Alias, Range.getBegin(), Range.getEnd());
Douglas Gregordc355712011-02-25 00:36:19 +00006746 break;
6747 }
6748
6749 case NestedNameSpecifier::TypeSpec:
6750 case NestedNameSpecifier::TypeSpecWithTemplate: {
Douglas Gregordc355712011-02-25 00:36:19 +00006751 bool Template = Record[Idx++];
6752 TypeSourceInfo *T = GetTypeSourceInfo(F, Record, Idx);
6753 if (!T)
6754 return NestedNameSpecifierLoc();
Douglas Gregordc355712011-02-25 00:36:19 +00006755 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
Douglas Gregor5f791bb2011-02-28 23:58:31 +00006756
6757 // FIXME: 'template' keyword location not saved anywhere, so we fake it.
Douglas Gregor35942772011-09-09 21:34:22 +00006758 Builder.Extend(Context,
Douglas Gregor5f791bb2011-02-28 23:58:31 +00006759 Template? T->getTypeLoc().getBeginLoc() : SourceLocation(),
6760 T->getTypeLoc(), ColonColonLoc);
Douglas Gregordc355712011-02-25 00:36:19 +00006761 break;
6762 }
6763
6764 case NestedNameSpecifier::Global: {
Douglas Gregordc355712011-02-25 00:36:19 +00006765 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
Douglas Gregor35942772011-09-09 21:34:22 +00006766 Builder.MakeGlobal(Context, ColonColonLoc);
Douglas Gregordc355712011-02-25 00:36:19 +00006767 break;
6768 }
6769 }
Douglas Gregordc355712011-02-25 00:36:19 +00006770 }
6771
Douglas Gregor35942772011-09-09 21:34:22 +00006772 return Builder.getWithLocInContext(Context);
Douglas Gregordc355712011-02-25 00:36:19 +00006773}
6774
Chris Lattner6ad9ac02010-05-07 21:43:38 +00006775SourceRange
Douglas Gregor1a4761e2011-11-30 23:21:26 +00006776ASTReader::ReadSourceRange(ModuleFile &F, const RecordData &Record,
Sebastian Redlc3632732010-10-05 15:59:54 +00006777 unsigned &Idx) {
6778 SourceLocation beg = ReadSourceLocation(F, Record, Idx);
6779 SourceLocation end = ReadSourceLocation(F, Record, Idx);
Daniel Dunbar8ee59392010-06-02 15:47:10 +00006780 return SourceRange(beg, end);
Chris Lattner6ad9ac02010-05-07 21:43:38 +00006781}
6782
Douglas Gregor0a2b45e2009-04-13 18:14:40 +00006783/// \brief Read an integral value
Sebastian Redlc43b54c2010-08-18 23:56:43 +00006784llvm::APInt ASTReader::ReadAPInt(const RecordData &Record, unsigned &Idx) {
Douglas Gregor0a2b45e2009-04-13 18:14:40 +00006785 unsigned BitWidth = Record[Idx++];
6786 unsigned NumWords = llvm::APInt::getNumWords(BitWidth);
6787 llvm::APInt Result(BitWidth, NumWords, &Record[Idx]);
6788 Idx += NumWords;
6789 return Result;
6790}
6791
6792/// \brief Read a signed integral value
Sebastian Redlc43b54c2010-08-18 23:56:43 +00006793llvm::APSInt ASTReader::ReadAPSInt(const RecordData &Record, unsigned &Idx) {
Douglas Gregor0a2b45e2009-04-13 18:14:40 +00006794 bool isUnsigned = Record[Idx++];
6795 return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned);
6796}
6797
Douglas Gregor17fc2232009-04-14 21:55:33 +00006798/// \brief Read a floating-point value
Sebastian Redlc43b54c2010-08-18 23:56:43 +00006799llvm::APFloat ASTReader::ReadAPFloat(const RecordData &Record, unsigned &Idx) {
Douglas Gregor17fc2232009-04-14 21:55:33 +00006800 return llvm::APFloat(ReadAPInt(Record, Idx));
6801}
6802
Douglas Gregor68a2eb02009-04-15 21:30:51 +00006803// \brief Read a string
Sebastian Redlc43b54c2010-08-18 23:56:43 +00006804std::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) {
Douglas Gregor68a2eb02009-04-15 21:30:51 +00006805 unsigned Len = Record[Idx++];
Jay Foadbeaaccd2009-05-21 09:52:38 +00006806 std::string Result(Record.data() + Idx, Record.data() + Idx + Len);
Douglas Gregor68a2eb02009-04-15 21:30:51 +00006807 Idx += Len;
6808 return Result;
6809}
6810
Douglas Gregor0a0d2b12011-03-23 00:50:03 +00006811VersionTuple ASTReader::ReadVersionTuple(const RecordData &Record,
6812 unsigned &Idx) {
6813 unsigned Major = Record[Idx++];
6814 unsigned Minor = Record[Idx++];
6815 unsigned Subminor = Record[Idx++];
6816 if (Minor == 0)
6817 return VersionTuple(Major);
6818 if (Subminor == 0)
6819 return VersionTuple(Major, Minor - 1);
6820 return VersionTuple(Major, Minor - 1, Subminor - 1);
6821}
6822
Douglas Gregor1a4761e2011-11-30 23:21:26 +00006823CXXTemporary *ASTReader::ReadCXXTemporary(ModuleFile &F,
Douglas Gregor409448c2011-07-21 22:35:25 +00006824 const RecordData &Record,
Chris Lattnerd2598362010-05-10 00:25:06 +00006825 unsigned &Idx) {
Douglas Gregor409448c2011-07-21 22:35:25 +00006826 CXXDestructorDecl *Decl = ReadDeclAs<CXXDestructorDecl>(F, Record, Idx);
Douglas Gregor35942772011-09-09 21:34:22 +00006827 return CXXTemporary::Create(Context, Decl);
Chris Lattnerd2598362010-05-10 00:25:06 +00006828}
6829
Sebastian Redlc43b54c2010-08-18 23:56:43 +00006830DiagnosticBuilder ASTReader::Diag(unsigned DiagID) {
Douglas Gregore1d918e2009-04-10 23:10:45 +00006831 return Diag(SourceLocation(), DiagID);
6832}
6833
Sebastian Redlc43b54c2010-08-18 23:56:43 +00006834DiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) {
Argyrios Kyrtzidis33e4e702010-11-18 20:06:41 +00006835 return Diags.Report(Loc, DiagID);
Douglas Gregor0a0428e2009-04-10 20:39:37 +00006836}
Douglas Gregor025452f2009-04-17 00:04:06 +00006837
Douglas Gregor668c1a42009-04-21 22:25:48 +00006838/// \brief Retrieve the identifier table associated with the
6839/// preprocessor.
Sebastian Redlc43b54c2010-08-18 23:56:43 +00006840IdentifierTable &ASTReader::getIdentifierTable() {
Douglas Gregor712f2fc2011-09-09 22:02:16 +00006841 return PP.getIdentifierTable();
Douglas Gregor668c1a42009-04-21 22:25:48 +00006842}
6843
Douglas Gregor025452f2009-04-17 00:04:06 +00006844/// \brief Record that the given ID maps to the given switch-case
6845/// statement.
Sebastian Redlc43b54c2010-08-18 23:56:43 +00006846void ASTReader::RecordSwitchCaseID(SwitchCase *SC, unsigned ID) {
Argyrios Kyrtzidisb88acb02012-05-04 01:49:36 +00006847 assert((*CurrSwitchCaseStmts)[ID] == 0 &&
6848 "Already have a SwitchCase with this ID");
6849 (*CurrSwitchCaseStmts)[ID] = SC;
Douglas Gregor025452f2009-04-17 00:04:06 +00006850}
6851
6852/// \brief Retrieve the switch-case statement with the given ID.
Sebastian Redlc43b54c2010-08-18 23:56:43 +00006853SwitchCase *ASTReader::getSwitchCaseWithID(unsigned ID) {
Argyrios Kyrtzidisb88acb02012-05-04 01:49:36 +00006854 assert((*CurrSwitchCaseStmts)[ID] != 0 && "No SwitchCase with this ID");
6855 return (*CurrSwitchCaseStmts)[ID];
Douglas Gregor025452f2009-04-17 00:04:06 +00006856}
Douglas Gregor1de05fe2009-04-17 18:18:49 +00006857
Argyrios Kyrtzidise09a2752010-10-28 09:29:32 +00006858void ASTReader::ClearSwitchCaseIDs() {
Argyrios Kyrtzidisb88acb02012-05-04 01:49:36 +00006859 CurrSwitchCaseStmts->clear();
Argyrios Kyrtzidise09a2752010-10-28 09:29:32 +00006860}
6861
Dmitri Gribenkoaa0cd852012-06-20 00:34:58 +00006862void ASTReader::ReadComments() {
Dmitri Gribenko811c8202012-07-06 18:19:34 +00006863 std::vector<RawComment *> Comments;
Dmitri Gribenkoaa0cd852012-06-20 00:34:58 +00006864 for (SmallVectorImpl<std::pair<llvm::BitstreamCursor,
6865 serialization::ModuleFile *> >::iterator
6866 I = CommentsCursors.begin(),
6867 E = CommentsCursors.end();
6868 I != E; ++I) {
6869 llvm::BitstreamCursor &Cursor = I->first;
6870 serialization::ModuleFile &F = *I->second;
6871 SavedStreamPosition SavedPosition(Cursor);
6872
6873 RecordData Record;
6874 while (true) {
6875 unsigned Code = Cursor.ReadCode();
6876 if (Code == llvm::bitc::END_BLOCK)
6877 break;
6878
6879 if (Code == llvm::bitc::ENTER_SUBBLOCK) {
6880 // No known subblocks, always skip them.
6881 Cursor.ReadSubBlockID();
6882 if (Cursor.SkipBlock()) {
6883 Error("malformed block record in AST file");
6884 return;
6885 }
6886 continue;
6887 }
6888
6889 if (Code == llvm::bitc::DEFINE_ABBREV) {
6890 Cursor.ReadAbbrevRecord();
6891 continue;
6892 }
6893
6894 // Read a record.
6895 Record.clear();
6896 switch ((CommentRecordTypes) Cursor.ReadRecord(Code, Record)) {
Chandler Carruth13691bb2012-06-20 06:47:54 +00006897 case COMMENTS_RAW_COMMENT: {
6898 unsigned Idx = 0;
6899 SourceRange SR = ReadSourceRange(F, Record, Idx);
6900 RawComment::CommentKind Kind =
6901 (RawComment::CommentKind) Record[Idx++];
6902 bool IsTrailingComment = Record[Idx++];
6903 bool IsAlmostTrailingComment = Record[Idx++];
Dmitri Gribenko811c8202012-07-06 18:19:34 +00006904 Comments.push_back(new (Context) RawComment(SR, Kind,
6905 IsTrailingComment,
6906 IsAlmostTrailingComment));
Chandler Carruth13691bb2012-06-20 06:47:54 +00006907 break;
Dmitri Gribenkoaa0cd852012-06-20 00:34:58 +00006908 }
6909 }
6910 }
6911 }
6912 Context.Comments.addCommentsToFront(Comments);
6913}
6914
Argyrios Kyrtzidis91707832011-12-17 08:11:25 +00006915void ASTReader::finishPendingActions() {
Douglas Gregor6c6c54a2012-10-11 00:46:49 +00006916 while (!PendingIdentifierInfos.empty() || !PendingDeclChains.empty() ||
6917 !PendingMacroIDs.empty()) {
Argyrios Kyrtzidis91707832011-12-17 08:11:25 +00006918 // If any identifiers with corresponding top-level declarations have
6919 // been loaded, load those declarations now.
6920 while (!PendingIdentifierInfos.empty()) {
6921 SetGloballyVisibleDecls(PendingIdentifierInfos.front().II,
6922 PendingIdentifierInfos.front().DeclIDs, true);
6923 PendingIdentifierInfos.pop_front();
6924 }
6925
Douglas Gregora1be2782011-12-17 23:38:30 +00006926 // Load pending declaration chains.
6927 for (unsigned I = 0; I != PendingDeclChains.size(); ++I) {
6928 loadPendingDeclChain(PendingDeclChains[I]);
Douglas Gregor56ca8a92012-01-17 19:21:53 +00006929 PendingDeclChainsKnown.erase(PendingDeclChains[I]);
Douglas Gregora1be2782011-12-17 23:38:30 +00006930 }
6931 PendingDeclChains.clear();
Douglas Gregor6c6c54a2012-10-11 00:46:49 +00006932
6933 // Load any pending macro definitions.
Douglas Gregore9652bf2012-10-11 17:31:34 +00006934 for (unsigned I = 0; I != PendingMacroIDs.size(); ++I) {
6935 // FIXME: std::move here
6936 SmallVector<MacroID, 2> GlobalIDs = PendingMacroIDs.begin()[I].second;
Douglas Gregor3ab50fe2012-10-11 17:41:54 +00006937 MacroInfo *Hint = 0;
Douglas Gregore9652bf2012-10-11 17:31:34 +00006938 for (unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx != NumIDs;
6939 ++IDIdx) {
Douglas Gregor3ab50fe2012-10-11 17:41:54 +00006940 Hint = getMacro(GlobalIDs[IDIdx], Hint);
Douglas Gregore9652bf2012-10-11 17:31:34 +00006941 }
6942 }
6943 PendingMacroIDs.clear();
Argyrios Kyrtzidis91707832011-12-17 08:11:25 +00006944 }
Douglas Gregorfc529f72011-12-19 19:00:47 +00006945
Douglas Gregor7c99bb5c2012-01-14 15:13:49 +00006946 // If we deserialized any C++ or Objective-C class definitions, any
6947 // Objective-C protocol definitions, or any redeclarable templates, make sure
6948 // that all redeclarations point to the definitions. Note that this can only
6949 // happen now, after the redeclaration chains have been fully wired.
Douglas Gregorfc529f72011-12-19 19:00:47 +00006950 for (llvm::SmallPtrSet<Decl *, 4>::iterator D = PendingDefinitions.begin(),
6951 DEnd = PendingDefinitions.end();
6952 D != DEnd; ++D) {
Douglas Gregor56ca8a92012-01-17 19:21:53 +00006953 if (TagDecl *TD = dyn_cast<TagDecl>(*D)) {
6954 if (const TagType *TagT = dyn_cast<TagType>(TD->TypeForDecl)) {
6955 // Make sure that the TagType points at the definition.
6956 const_cast<TagType*>(TagT)->decl = TD;
6957 }
Douglas Gregorfc529f72011-12-19 19:00:47 +00006958
Douglas Gregor56ca8a92012-01-17 19:21:53 +00006959 if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(*D)) {
6960 for (CXXRecordDecl::redecl_iterator R = RD->redecls_begin(),
6961 REnd = RD->redecls_end();
6962 R != REnd; ++R)
6963 cast<CXXRecordDecl>(*R)->DefinitionData = RD->DefinitionData;
6964
6965 }
6966
Douglas Gregorfc529f72011-12-19 19:00:47 +00006967 continue;
6968 }
6969
Douglas Gregor1d784b22012-01-01 19:51:50 +00006970 if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(*D)) {
Douglas Gregor56ca8a92012-01-17 19:21:53 +00006971 // Make sure that the ObjCInterfaceType points at the definition.
6972 const_cast<ObjCInterfaceType *>(cast<ObjCInterfaceType>(ID->TypeForDecl))
6973 ->Decl = ID;
6974
Douglas Gregor1d784b22012-01-01 19:51:50 +00006975 for (ObjCInterfaceDecl::redecl_iterator R = ID->redecls_begin(),
6976 REnd = ID->redecls_end();
6977 R != REnd; ++R)
6978 R->Data = ID->Data;
6979
6980 continue;
6981 }
6982
Douglas Gregor7c99bb5c2012-01-14 15:13:49 +00006983 if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(*D)) {
6984 for (ObjCProtocolDecl::redecl_iterator R = PD->redecls_begin(),
6985 REnd = PD->redecls_end();
6986 R != REnd; ++R)
6987 R->Data = PD->Data;
6988
6989 continue;
6990 }
6991
6992 RedeclarableTemplateDecl *RTD
6993 = cast<RedeclarableTemplateDecl>(*D)->getCanonicalDecl();
6994 for (RedeclarableTemplateDecl::redecl_iterator R = RTD->redecls_begin(),
6995 REnd = RTD->redecls_end();
Douglas Gregorfc529f72011-12-19 19:00:47 +00006996 R != REnd; ++R)
Douglas Gregor5456b0fe2012-10-09 17:21:28 +00006997 R->Common = RTD->Common;
Douglas Gregorfc529f72011-12-19 19:00:47 +00006998 }
6999 PendingDefinitions.clear();
Douglas Gregor5456b0fe2012-10-09 17:21:28 +00007000
7001 // Load the bodies of any functions or methods we've encountered. We do
7002 // this now (delayed) so that we can be sure that the declaration chains
7003 // have been fully wired up.
Douglas Gregorce12d2f2012-10-09 17:50:23 +00007004 for (PendingBodiesMap::iterator PB = PendingBodies.begin(),
7005 PBEnd = PendingBodies.end();
Douglas Gregor5456b0fe2012-10-09 17:21:28 +00007006 PB != PBEnd; ++PB) {
7007 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(PB->first)) {
7008 // FIXME: Check for =delete/=default?
7009 // FIXME: Complain about ODR violations here?
7010 if (!getContext().getLangOpts().Modules || !FD->hasBody())
7011 FD->setLazyBody(PB->second);
7012 continue;
7013 }
7014
7015 ObjCMethodDecl *MD = cast<ObjCMethodDecl>(PB->first);
7016 if (!getContext().getLangOpts().Modules || !MD->hasBody())
7017 MD->setLazyBody(PB->second);
7018 }
7019 PendingBodies.clear();
Argyrios Kyrtzidis91707832011-12-17 08:11:25 +00007020}
7021
Sebastian Redlc43b54c2010-08-18 23:56:43 +00007022void ASTReader::FinishedDeserializing() {
Argyrios Kyrtzidis29ee3a22010-07-30 10:03:16 +00007023 assert(NumCurrentElementsDeserializing &&
7024 "FinishedDeserializing not paired with StartedDeserializing");
7025 if (NumCurrentElementsDeserializing == 1) {
Argyrios Kyrtzidis44d2dbd2012-02-09 07:31:52 +00007026 // We decrease NumCurrentElementsDeserializing only after pending actions
7027 // are finished, to avoid recursively re-calling finishPendingActions().
7028 finishPendingActions();
7029 }
7030 --NumCurrentElementsDeserializing;
Argyrios Kyrtzidis71168332011-12-17 04:13:28 +00007031
Argyrios Kyrtzidis44d2dbd2012-02-09 07:31:52 +00007032 if (NumCurrentElementsDeserializing == 0 &&
7033 Consumer && !PassingDeclsToConsumer) {
7034 // Guard variable to avoid recursively redoing the process of passing
7035 // decls to consumer.
7036 SaveAndRestore<bool> GuardPassingDeclsToConsumer(PassingDeclsToConsumer,
7037 true);
Argyrios Kyrtzidis71168332011-12-17 04:13:28 +00007038
Argyrios Kyrtzidis44d2dbd2012-02-09 07:31:52 +00007039 while (!InterestingDecls.empty()) {
Argyrios Kyrtzidis8d39c3d2011-11-30 23:18:26 +00007040 // We are not in recursive loading, so it's safe to pass the "interesting"
7041 // decls to the consumer.
Argyrios Kyrtzidis91707832011-12-17 08:11:25 +00007042 Decl *D = InterestingDecls.front();
7043 InterestingDecls.pop_front();
Argyrios Kyrtzidis91707832011-12-17 08:11:25 +00007044 PassInterestingDeclToConsumer(D);
7045 }
Douglas Gregord89275b2009-07-06 18:54:52 +00007046 }
Douglas Gregord89275b2009-07-06 18:54:52 +00007047}
Douglas Gregor501c1032010-08-19 00:28:17 +00007048
Douglas Gregorf8a1e512011-09-02 00:26:20 +00007049ASTReader::ASTReader(Preprocessor &PP, ASTContext &Context,
Douglas Gregor832d6202011-07-22 16:35:34 +00007050 StringRef isysroot, bool DisableValidation,
Argyrios Kyrtzidisbef35c92012-03-07 01:51:17 +00007051 bool DisableStatCache, bool AllowASTWithCompilerErrors)
Sebastian Redle1dde812010-08-24 00:50:04 +00007052 : Listener(new PCHValidator(PP, *this)), DeserializationListener(0),
7053 SourceMgr(PP.getSourceManager()), FileMgr(PP.getFileManager()),
Douglas Gregor712f2fc2011-09-09 22:02:16 +00007054 Diags(PP.getDiagnostics()), SemaObj(0), PP(PP), Context(Context),
Argyrios Kyrtzidisd64c26f2012-10-03 01:58:42 +00007055 Consumer(0), ModuleMgr(PP.getFileManager()),
Douglas Gregorcaed0602012-10-18 21:31:35 +00007056 isysroot(isysroot), DisableValidation(DisableValidation),
Argyrios Kyrtzidisbef35c92012-03-07 01:51:17 +00007057 DisableStatCache(DisableStatCache),
7058 AllowASTWithCompilerErrors(AllowASTWithCompilerErrors),
Argyrios Kyrtzidisb88acb02012-05-04 01:49:36 +00007059 CurrentGeneration(0), CurrSwitchCaseStmts(&SwitchCaseStmts),
7060 NumStatHits(0), NumStatMisses(0),
Douglas Gregorf62d43d2011-07-19 16:10:42 +00007061 NumSLocEntriesRead(0), TotalNumSLocEntries(0),
Douglas Gregor8ef6c8c2011-02-05 19:42:43 +00007062 NumStatementsRead(0), TotalNumStatements(0), NumMacrosRead(0),
7063 TotalNumMacros(0), NumSelectorsRead(0), NumMethodPoolEntriesRead(0),
7064 NumMethodPoolMisses(0), TotalNumMethodPoolEntries(0),
7065 NumLexicalDeclContextsRead(0), TotalLexicalDeclContexts(0),
Jonathan D. Turner1da90142011-07-21 21:15:19 +00007066 NumVisibleDeclContextsRead(0), TotalVisibleDeclContexts(0),
7067 TotalModulesSizeInBits(0), NumCurrentElementsDeserializing(0),
Argyrios Kyrtzidis44d2dbd2012-02-09 07:31:52 +00007068 PassingDeclsToConsumer(false),
Jonathan D. Turner1da90142011-07-21 21:15:19 +00007069 NumCXXBaseSpecifiersLoaded(0)
Douglas Gregor8ef6c8c2011-02-05 19:42:43 +00007070{
Douglas Gregorf62d43d2011-07-19 16:10:42 +00007071 SourceMgr.setExternalSLocEntrySource(this);
Sebastian Redle1dde812010-08-24 00:50:04 +00007072}
7073
Sebastian Redle1dde812010-08-24 00:50:04 +00007074ASTReader::~ASTReader() {
Sebastian Redle1dde812010-08-24 00:50:04 +00007075 for (DeclContextVisibleUpdatesPending::iterator
7076 I = PendingVisibleUpdates.begin(),
7077 E = PendingVisibleUpdates.end();
7078 I != E; ++I) {
7079 for (DeclContextVisibleUpdates::iterator J = I->second.begin(),
7080 F = I->second.end();
7081 J != F; ++J)
Benjamin Kramerb1758c62012-04-15 12:36:49 +00007082 delete J->first;
Sebastian Redle1dde812010-08-24 00:50:04 +00007083 }
7084}