blob: 3525c7020782a755a228ed0dcb3177a517d4975e [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"
Argyrios Kyrtzidis0eca89e2010-08-20 16:03:52 +000016#include "ASTCommon.h"
Douglas Gregor0a0428e2009-04-10 20:39:37 +000017#include "clang/Frontend/FrontendDiagnostic.h"
Daniel Dunbarc7162932009-11-11 23:58:53 +000018#include "clang/Frontend/Utils.h"
Douglas Gregore737f502010-08-12 20:07:10 +000019#include "clang/Sema/Sema.h"
John McCall5f1e0942010-08-24 08:50:51 +000020#include "clang/Sema/Scope.h"
Douglas Gregorfdd01722009-04-14 00:24:19 +000021#include "clang/AST/ASTConsumer.h"
Douglas Gregor2cf26342009-04-09 22:27:44 +000022#include "clang/AST/ASTContext.h"
John McCall2a7fb272010-08-25 05:32:35 +000023#include "clang/AST/DeclTemplate.h"
Douglas Gregor0b748912009-04-14 21:18:50 +000024#include "clang/AST/Expr.h"
John McCall7a1fad32010-08-24 07:32:53 +000025#include "clang/AST/ExprCXX.h"
Douglas Gregor5f791bb2011-02-28 23:58:31 +000026#include "clang/AST/NestedNameSpecifier.h"
Douglas Gregor2cf26342009-04-09 22:27:44 +000027#include "clang/AST/Type.h"
John McCalla1ee0c52009-10-16 21:56:05 +000028#include "clang/AST/TypeLocVisitor.h"
Chris Lattner42d42b52009-04-10 21:41:48 +000029#include "clang/Lex/MacroInfo.h"
Douglas Gregor6a5a23f2010-03-19 21:51:54 +000030#include "clang/Lex/PreprocessingRecord.h"
Douglas Gregor14f79002009-04-10 03:52:48 +000031#include "clang/Lex/Preprocessor.h"
Steve Naroff83d63c72009-04-24 20:03:17 +000032#include "clang/Lex/HeaderSearch.h"
Douglas Gregor668c1a42009-04-21 22:25:48 +000033#include "clang/Basic/OnDiskHashTable.h"
Douglas Gregor14f79002009-04-10 03:52:48 +000034#include "clang/Basic/SourceManager.h"
Douglas Gregorbd945002009-04-13 16:31:14 +000035#include "clang/Basic/SourceManagerInternals.h"
Douglas Gregor14f79002009-04-10 03:52:48 +000036#include "clang/Basic/FileManager.h"
Chris Lattner10e286a2010-11-23 19:19:34 +000037#include "clang/Basic/FileSystemStatCache.h"
Douglas Gregor2bec0412009-04-10 21:16:55 +000038#include "clang/Basic/TargetInfo.h"
Douglas Gregor445e23e2009-10-05 21:07:28 +000039#include "clang/Basic/Version.h"
Douglas Gregor0a0d2b12011-03-23 00:50:03 +000040#include "clang/Basic/VersionTuple.h"
Daniel Dunbar2596e422009-10-17 23:52:28 +000041#include "llvm/ADT/StringExtras.h"
Douglas Gregor2cf26342009-04-09 22:27:44 +000042#include "llvm/Bitcode/BitstreamReader.h"
Douglas Gregor2cf26342009-04-09 22:27:44 +000043#include "llvm/Support/MemoryBuffer.h"
John McCall833ca992009-10-29 08:12:44 +000044#include "llvm/Support/ErrorHandling.h"
Douglas Gregorcfbf1c72011-02-10 17:09:37 +000045#include "llvm/Support/FileSystem.h"
Michael J. Spencer03013fa2010-11-29 18:12:39 +000046#include "llvm/Support/Path.h"
Michael J. Spencer3a321e22010-12-09 17:36:38 +000047#include "llvm/Support/system_error.h"
Douglas Gregor2cf26342009-04-09 22:27:44 +000048#include <algorithm>
Douglas Gregore721f952009-04-28 18:58:38 +000049#include <iterator>
Douglas Gregor2cf26342009-04-09 22:27:44 +000050#include <cstdio>
Douglas Gregor4fed3f42009-04-27 18:38:38 +000051#include <sys/stat.h>
Douglas Gregorcfbf1c72011-02-10 17:09:37 +000052
Douglas Gregor2cf26342009-04-09 22:27:44 +000053using namespace clang;
Sebastian Redl8538e8d2010-08-18 23:57:32 +000054using namespace clang::serialization;
Douglas Gregor2cf26342009-04-09 22:27:44 +000055
56//===----------------------------------------------------------------------===//
Sebastian Redl3c7f4132010-08-18 23:57:06 +000057// PCH validator implementation
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +000058//===----------------------------------------------------------------------===//
59
Sebastian Redl571db7f2010-08-18 23:56:56 +000060ASTReaderListener::~ASTReaderListener() {}
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +000061
62bool
63PCHValidator::ReadLanguageOptions(const LangOptions &LangOpts) {
64 const LangOptions &PPLangOpts = PP.getLangOptions();
65#define PARSE_LANGOPT_BENIGN(Option)
66#define PARSE_LANGOPT_IMPORTANT(Option, DiagID) \
67 if (PPLangOpts.Option != LangOpts.Option) { \
68 Reader.Diag(DiagID) << LangOpts.Option << PPLangOpts.Option; \
69 return true; \
70 }
71
72 PARSE_LANGOPT_BENIGN(Trigraphs);
73 PARSE_LANGOPT_BENIGN(BCPLComment);
74 PARSE_LANGOPT_BENIGN(DollarIdents);
75 PARSE_LANGOPT_BENIGN(AsmPreprocessor);
76 PARSE_LANGOPT_IMPORTANT(GNUMode, diag::warn_pch_gnu_extensions);
Chandler Carrutheb5d7b72010-04-17 20:17:31 +000077 PARSE_LANGOPT_IMPORTANT(GNUKeywords, diag::warn_pch_gnu_keywords);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +000078 PARSE_LANGOPT_BENIGN(ImplicitInt);
79 PARSE_LANGOPT_BENIGN(Digraphs);
80 PARSE_LANGOPT_BENIGN(HexFloats);
81 PARSE_LANGOPT_IMPORTANT(C99, diag::warn_pch_c99);
Peter Collingbourne7e7fbd02011-04-15 00:35:23 +000082 PARSE_LANGOPT_IMPORTANT(C1X, diag::warn_pch_c1x);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +000083 PARSE_LANGOPT_IMPORTANT(Microsoft, diag::warn_pch_microsoft_extensions);
Michael J. Spencerdae4ac42010-10-21 05:21:48 +000084 PARSE_LANGOPT_BENIGN(MSCVersion);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +000085 PARSE_LANGOPT_IMPORTANT(CPlusPlus, diag::warn_pch_cplusplus);
86 PARSE_LANGOPT_IMPORTANT(CPlusPlus0x, diag::warn_pch_cplusplus0x);
87 PARSE_LANGOPT_BENIGN(CXXOperatorName);
88 PARSE_LANGOPT_IMPORTANT(ObjC1, diag::warn_pch_objective_c);
89 PARSE_LANGOPT_IMPORTANT(ObjC2, diag::warn_pch_objective_c2);
90 PARSE_LANGOPT_IMPORTANT(ObjCNonFragileABI, diag::warn_pch_nonfragile_abi);
Fariborz Jahanian412e7982010-02-09 19:31:38 +000091 PARSE_LANGOPT_IMPORTANT(ObjCNonFragileABI2, diag::warn_pch_nonfragile_abi2);
Fariborz Jahanianf84109e2011-01-07 18:59:25 +000092 PARSE_LANGOPT_IMPORTANT(AppleKext, diag::warn_pch_apple_kext);
Ted Kremenekc32647d2010-12-23 21:35:43 +000093 PARSE_LANGOPT_IMPORTANT(ObjCDefaultSynthProperties,
94 diag::warn_pch_objc_auto_properties);
Michael J. Spencer20249a12010-10-21 03:16:25 +000095 PARSE_LANGOPT_IMPORTANT(NoConstantCFStrings,
Fariborz Jahanian4c9d8d02010-04-22 21:01:59 +000096 diag::warn_pch_no_constant_cfstrings);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +000097 PARSE_LANGOPT_BENIGN(PascalStrings);
98 PARSE_LANGOPT_BENIGN(WritableStrings);
Mike Stump1eb44332009-09-09 15:08:12 +000099 PARSE_LANGOPT_IMPORTANT(LaxVectorConversions,
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000100 diag::warn_pch_lax_vector_conversions);
Nate Begeman69cfb9b2009-06-25 22:57:40 +0000101 PARSE_LANGOPT_IMPORTANT(AltiVec, diag::warn_pch_altivec);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000102 PARSE_LANGOPT_IMPORTANT(Exceptions, diag::warn_pch_exceptions);
Anders Carlssonda4b7cf2011-02-19 23:53:54 +0000103 PARSE_LANGOPT_IMPORTANT(ObjCExceptions, diag::warn_pch_objc_exceptions);
Anders Carlsson7da99b02011-02-23 03:04:54 +0000104 PARSE_LANGOPT_IMPORTANT(CXXExceptions, diag::warn_pch_cxx_exceptions);
105 PARSE_LANGOPT_IMPORTANT(SjLjExceptions, diag::warn_pch_sjlj_exceptions);
Douglas Gregor6f755502011-02-01 15:15:22 +0000106 PARSE_LANGOPT_IMPORTANT(MSBitfields, diag::warn_pch_ms_bitfields);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000107 PARSE_LANGOPT_IMPORTANT(NeXTRuntime, diag::warn_pch_objc_runtime);
108 PARSE_LANGOPT_IMPORTANT(Freestanding, diag::warn_pch_freestanding);
109 PARSE_LANGOPT_IMPORTANT(NoBuiltin, diag::warn_pch_builtins);
Mike Stump1eb44332009-09-09 15:08:12 +0000110 PARSE_LANGOPT_IMPORTANT(ThreadsafeStatics,
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000111 diag::warn_pch_thread_safe_statics);
Daniel Dunbar5345c392009-09-03 04:54:28 +0000112 PARSE_LANGOPT_IMPORTANT(POSIXThreads, diag::warn_pch_posix_threads);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000113 PARSE_LANGOPT_IMPORTANT(Blocks, diag::warn_pch_blocks);
114 PARSE_LANGOPT_BENIGN(EmitAllDecls);
115 PARSE_LANGOPT_IMPORTANT(MathErrno, diag::warn_pch_math_errno);
Chris Lattnera4d71452010-06-26 21:25:03 +0000116 PARSE_LANGOPT_BENIGN(getSignedOverflowBehavior());
Mike Stump1eb44332009-09-09 15:08:12 +0000117 PARSE_LANGOPT_IMPORTANT(HeinousExtensions,
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000118 diag::warn_pch_heinous_extensions);
119 // FIXME: Most of the options below are benign if the macro wasn't
120 // used. Unfortunately, this means that a PCH compiled without
121 // optimization can't be used with optimization turned on, even
122 // though the only thing that changes is whether __OPTIMIZE__ was
123 // defined... but if __OPTIMIZE__ never showed up in the header, it
124 // doesn't matter. We could consider making this some special kind
125 // of check.
126 PARSE_LANGOPT_IMPORTANT(Optimize, diag::warn_pch_optimize);
127 PARSE_LANGOPT_IMPORTANT(OptimizeSize, diag::warn_pch_optimize_size);
128 PARSE_LANGOPT_IMPORTANT(Static, diag::warn_pch_static);
129 PARSE_LANGOPT_IMPORTANT(PICLevel, diag::warn_pch_pic_level);
130 PARSE_LANGOPT_IMPORTANT(GNUInline, diag::warn_pch_gnu_inline);
131 PARSE_LANGOPT_IMPORTANT(NoInline, diag::warn_pch_no_inline);
Chandler Carruth0d2d1bc2011-04-23 20:05:38 +0000132 PARSE_LANGOPT_IMPORTANT(Deprecated, diag::warn_pch_deprecated);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000133 PARSE_LANGOPT_IMPORTANT(AccessControl, diag::warn_pch_access_control);
134 PARSE_LANGOPT_IMPORTANT(CharIsSigned, diag::warn_pch_char_signed);
John Thompsona6fda122009-11-05 20:14:16 +0000135 PARSE_LANGOPT_IMPORTANT(ShortWChar, diag::warn_pch_short_wchar);
Argyrios Kyrtzidis9a2b9d72010-10-08 00:25:19 +0000136 PARSE_LANGOPT_IMPORTANT(ShortEnums, diag::warn_pch_short_enums);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000137 if ((PPLangOpts.getGCMode() != 0) != (LangOpts.getGCMode() != 0)) {
Mike Stump1eb44332009-09-09 15:08:12 +0000138 Reader.Diag(diag::warn_pch_gc_mode)
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000139 << LangOpts.getGCMode() << PPLangOpts.getGCMode();
140 return true;
141 }
142 PARSE_LANGOPT_BENIGN(getVisibilityMode());
Daniel Dunbarab8e2812009-09-21 04:16:19 +0000143 PARSE_LANGOPT_IMPORTANT(getStackProtectorMode(),
144 diag::warn_pch_stack_protector);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000145 PARSE_LANGOPT_BENIGN(InstantiationDepth);
Nate Begeman69cfb9b2009-06-25 22:57:40 +0000146 PARSE_LANGOPT_IMPORTANT(OpenCL, diag::warn_pch_opencl);
Peter Collingbourne08a53262010-12-01 19:14:57 +0000147 PARSE_LANGOPT_IMPORTANT(CUDA, diag::warn_pch_cuda);
Mike Stump9c276ae2009-12-12 01:27:46 +0000148 PARSE_LANGOPT_BENIGN(CatchUndefined);
Daniel Dunbarab8e2812009-09-21 04:16:19 +0000149 PARSE_LANGOPT_IMPORTANT(ElideConstructors, diag::warn_pch_elide_constructors);
Douglas Gregora0068fc2010-07-09 17:35:33 +0000150 PARSE_LANGOPT_BENIGN(SpellChecking);
Peter Collingbourne84bccea2011-02-15 19:46:30 +0000151 PARSE_LANGOPT_BENIGN(DefaultFPContract);
Kovarththanan Rajaratnam6b82f642010-03-07 19:10:13 +0000152#undef PARSE_LANGOPT_IMPORTANT
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000153#undef PARSE_LANGOPT_BENIGN
154
155 return false;
156}
157
Daniel Dunbardc3c0d22009-11-11 00:52:11 +0000158bool PCHValidator::ReadTargetTriple(llvm::StringRef Triple) {
159 if (Triple == PP.getTargetInfo().getTriple().str())
160 return false;
161
162 Reader.Diag(diag::warn_pch_target_triple)
163 << Triple << PP.getTargetInfo().getTriple().str();
164 return true;
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000165}
166
Benjamin Kramer54353f42010-11-25 18:29:30 +0000167namespace {
168 struct EmptyStringRef {
169 bool operator ()(llvm::StringRef r) const { return r.empty(); }
170 };
171 struct EmptyBlock {
172 bool operator ()(const PCHPredefinesBlock &r) const {return r.Data.empty();}
173 };
174}
Sebastian Redl7e9ad8b2010-07-14 17:49:11 +0000175
176static bool EqualConcatenations(llvm::SmallVector<llvm::StringRef, 2> L,
177 PCHPredefinesBlocks R) {
178 // First, sum up the lengths.
179 unsigned LL = 0, RL = 0;
180 for (unsigned I = 0, N = L.size(); I != N; ++I) {
181 LL += L[I].size();
182 }
183 for (unsigned I = 0, N = R.size(); I != N; ++I) {
184 RL += R[I].Data.size();
185 }
186 if (LL != RL)
187 return false;
188 if (LL == 0 && RL == 0)
189 return true;
190
191 // Kick out empty parts, they confuse the algorithm below.
192 L.erase(std::remove_if(L.begin(), L.end(), EmptyStringRef()), L.end());
193 R.erase(std::remove_if(R.begin(), R.end(), EmptyBlock()), R.end());
194
195 // Do it the hard way. At this point, both vectors must be non-empty.
196 llvm::StringRef LR = L[0], RR = R[0].Data;
197 unsigned LI = 0, RI = 0, LN = L.size(), RN = R.size();
Daniel Dunbarc76c9e02010-07-16 00:00:11 +0000198 (void) RN;
Sebastian Redl7e9ad8b2010-07-14 17:49:11 +0000199 for (;;) {
200 // Compare the current pieces.
201 if (LR.size() == RR.size()) {
202 // If they're the same length, it's pretty easy.
203 if (LR != RR)
204 return false;
205 // Both pieces are done, advance.
206 ++LI;
207 ++RI;
208 // If either string is done, they're both done, since they're the same
209 // length.
210 if (LI == LN) {
211 assert(RI == RN && "Strings not the same length after all?");
212 return true;
213 }
214 LR = L[LI];
215 RR = R[RI].Data;
216 } else if (LR.size() < RR.size()) {
217 // Right piece is longer.
218 if (!RR.startswith(LR))
219 return false;
220 ++LI;
221 assert(LI != LN && "Strings not the same length after all?");
222 RR = RR.substr(LR.size());
223 LR = L[LI];
224 } else {
225 // Left piece is longer.
226 if (!LR.startswith(RR))
227 return false;
228 ++RI;
229 assert(RI != RN && "Strings not the same length after all?");
230 LR = LR.substr(RR.size());
231 RR = R[RI].Data;
232 }
233 }
234}
235
236static std::pair<FileID, llvm::StringRef::size_type>
237FindMacro(const PCHPredefinesBlocks &Buffers, llvm::StringRef MacroDef) {
238 std::pair<FileID, llvm::StringRef::size_type> Res;
239 for (unsigned I = 0, N = Buffers.size(); I != N; ++I) {
240 Res.second = Buffers[I].Data.find(MacroDef);
241 if (Res.second != llvm::StringRef::npos) {
242 Res.first = Buffers[I].BufferID;
243 break;
244 }
245 }
246 return Res;
247}
248
249bool PCHValidator::ReadPredefinesBuffer(const PCHPredefinesBlocks &Buffers,
Daniel Dunbar7b5a1212009-11-11 05:29:04 +0000250 llvm::StringRef OriginalFileName,
Nick Lewycky277a6e72011-02-23 21:16:44 +0000251 std::string &SuggestedPredefines,
252 FileManager &FileMgr) {
Daniel Dunbarc7162932009-11-11 23:58:53 +0000253 // We are in the context of an implicit include, so the predefines buffer will
254 // have a #include entry for the PCH file itself (as normalized by the
255 // preprocessor initialization). Find it and skip over it in the checking
256 // below.
Daniel Dunbar7b5a1212009-11-11 05:29:04 +0000257 llvm::SmallString<256> PCHInclude;
258 PCHInclude += "#include \"";
Nick Lewycky277a6e72011-02-23 21:16:44 +0000259 PCHInclude += NormalizeDashIncludePath(OriginalFileName, FileMgr);
Daniel Dunbar7b5a1212009-11-11 05:29:04 +0000260 PCHInclude += "\"\n";
261 std::pair<llvm::StringRef,llvm::StringRef> Split =
262 llvm::StringRef(PP.getPredefines()).split(PCHInclude.str());
263 llvm::StringRef Left = Split.first, Right = Split.second;
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +0000264 if (Left == PP.getPredefines()) {
265 Error("Missing PCH include entry!");
266 return true;
267 }
Daniel Dunbar7b5a1212009-11-11 05:29:04 +0000268
Sebastian Redl7e9ad8b2010-07-14 17:49:11 +0000269 // If the concatenation of all the PCH buffers is equal to the adjusted
270 // command line, we're done.
Sebastian Redl7e9ad8b2010-07-14 17:49:11 +0000271 llvm::SmallVector<llvm::StringRef, 2> CommandLine;
272 CommandLine.push_back(Left);
273 CommandLine.push_back(Right);
274 if (EqualConcatenations(CommandLine, Buffers))
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000275 return false;
276
277 SourceManager &SourceMgr = PP.getSourceManager();
Mike Stump1eb44332009-09-09 15:08:12 +0000278
Daniel Dunbar10014aa2009-11-11 03:45:59 +0000279 // The predefines buffers are different. Determine what the differences are,
280 // and whether they require us to reject the PCH file.
Daniel Dunbare6750492009-11-13 16:46:11 +0000281 llvm::SmallVector<llvm::StringRef, 8> PCHLines;
Sebastian Redl7e9ad8b2010-07-14 17:49:11 +0000282 for (unsigned I = 0, N = Buffers.size(); I != N; ++I)
283 Buffers[I].Data.split(PCHLines, "\n", /*MaxSplit=*/-1, /*KeepEmpty=*/false);
Daniel Dunbare6750492009-11-13 16:46:11 +0000284
285 llvm::SmallVector<llvm::StringRef, 8> CmdLineLines;
286 Left.split(CmdLineLines, "\n", /*MaxSplit=*/-1, /*KeepEmpty=*/false);
Argyrios Kyrtzidis297c7062010-09-30 16:53:50 +0000287
288 // Pick out implicit #includes after the PCH and don't consider them for
289 // validation; we will insert them into SuggestedPredefines so that the
290 // preprocessor includes them.
291 std::string IncludesAfterPCH;
292 llvm::SmallVector<llvm::StringRef, 8> AfterPCHLines;
293 Right.split(AfterPCHLines, "\n", /*MaxSplit=*/-1, /*KeepEmpty=*/false);
294 for (unsigned i = 0, e = AfterPCHLines.size(); i != e; ++i) {
295 if (AfterPCHLines[i].startswith("#include ")) {
296 IncludesAfterPCH += AfterPCHLines[i];
297 IncludesAfterPCH += '\n';
298 } else {
299 CmdLineLines.push_back(AfterPCHLines[i]);
300 }
301 }
302
303 // Make sure we add the includes last into SuggestedPredefines before we
304 // exit this function.
305 struct AddIncludesRAII {
306 std::string &SuggestedPredefines;
307 std::string &IncludesAfterPCH;
308
309 AddIncludesRAII(std::string &SuggestedPredefines,
310 std::string &IncludesAfterPCH)
311 : SuggestedPredefines(SuggestedPredefines),
312 IncludesAfterPCH(IncludesAfterPCH) { }
313 ~AddIncludesRAII() {
314 SuggestedPredefines += IncludesAfterPCH;
315 }
316 } AddIncludes(SuggestedPredefines, IncludesAfterPCH);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000317
Daniel Dunbar4d5936a2009-11-11 05:26:28 +0000318 // Sort both sets of predefined buffer lines, since we allow some extra
319 // definitions and they may appear at any point in the output.
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000320 std::sort(CmdLineLines.begin(), CmdLineLines.end());
321 std::sort(PCHLines.begin(), PCHLines.end());
322
Daniel Dunbar4d5936a2009-11-11 05:26:28 +0000323 // Determine which predefines that were used to build the PCH file are missing
324 // from the command line.
325 std::vector<llvm::StringRef> MissingPredefines;
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000326 std::set_difference(PCHLines.begin(), PCHLines.end(),
327 CmdLineLines.begin(), CmdLineLines.end(),
328 std::back_inserter(MissingPredefines));
329
330 bool MissingDefines = false;
331 bool ConflictingDefines = false;
332 for (unsigned I = 0, N = MissingPredefines.size(); I != N; ++I) {
Daniel Dunbar4d5936a2009-11-11 05:26:28 +0000333 llvm::StringRef Missing = MissingPredefines[I];
Argyrios Kyrtzidis297c7062010-09-30 16:53:50 +0000334 if (Missing.startswith("#include ")) {
335 // An -include was specified when generating the PCH; it is included in
336 // the PCH, just ignore it.
337 continue;
338 }
Daniel Dunbar4d5936a2009-11-11 05:26:28 +0000339 if (!Missing.startswith("#define ")) {
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000340 Reader.Diag(diag::warn_pch_compiler_options_mismatch);
341 return true;
342 }
Mike Stump1eb44332009-09-09 15:08:12 +0000343
Daniel Dunbar10014aa2009-11-11 03:45:59 +0000344 // This is a macro definition. Determine the name of the macro we're
345 // defining.
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000346 std::string::size_type StartOfMacroName = strlen("#define ");
Mike Stump1eb44332009-09-09 15:08:12 +0000347 std::string::size_type EndOfMacroName
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000348 = Missing.find_first_of("( \n\r", StartOfMacroName);
349 assert(EndOfMacroName != std::string::npos &&
350 "Couldn't find the end of the macro name");
Daniel Dunbar4d5936a2009-11-11 05:26:28 +0000351 llvm::StringRef MacroName = Missing.slice(StartOfMacroName, EndOfMacroName);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000352
Daniel Dunbar10014aa2009-11-11 03:45:59 +0000353 // Determine whether this macro was given a different definition on the
354 // command line.
Daniel Dunbar4d5936a2009-11-11 05:26:28 +0000355 std::string MacroDefStart = "#define " + MacroName.str();
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000356 std::string::size_type MacroDefLen = MacroDefStart.size();
Daniel Dunbare6750492009-11-13 16:46:11 +0000357 llvm::SmallVector<llvm::StringRef, 8>::iterator ConflictPos
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000358 = std::lower_bound(CmdLineLines.begin(), CmdLineLines.end(),
359 MacroDefStart);
360 for (; ConflictPos != CmdLineLines.end(); ++ConflictPos) {
Daniel Dunbar10014aa2009-11-11 03:45:59 +0000361 if (!ConflictPos->startswith(MacroDefStart)) {
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000362 // Different macro; we're done.
363 ConflictPos = CmdLineLines.end();
Mike Stump1eb44332009-09-09 15:08:12 +0000364 break;
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000365 }
Mike Stump1eb44332009-09-09 15:08:12 +0000366
367 assert(ConflictPos->size() > MacroDefLen &&
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000368 "Invalid #define in predefines buffer?");
Mike Stump1eb44332009-09-09 15:08:12 +0000369 if ((*ConflictPos)[MacroDefLen] != ' ' &&
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000370 (*ConflictPos)[MacroDefLen] != '(')
371 continue; // Longer macro name; keep trying.
Mike Stump1eb44332009-09-09 15:08:12 +0000372
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000373 // We found a conflicting macro definition.
374 break;
375 }
Mike Stump1eb44332009-09-09 15:08:12 +0000376
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000377 if (ConflictPos != CmdLineLines.end()) {
378 Reader.Diag(diag::warn_cmdline_conflicting_macro_def)
379 << MacroName;
380
381 // Show the definition of this macro within the PCH file.
Sebastian Redl7e9ad8b2010-07-14 17:49:11 +0000382 std::pair<FileID, llvm::StringRef::size_type> MacroLoc =
383 FindMacro(Buffers, Missing);
384 assert(MacroLoc.second!=llvm::StringRef::npos && "Unable to find macro!");
385 SourceLocation PCHMissingLoc =
386 SourceMgr.getLocForStartOfFile(MacroLoc.first)
387 .getFileLocWithOffset(MacroLoc.second);
Daniel Dunbar4d5936a2009-11-11 05:26:28 +0000388 Reader.Diag(PCHMissingLoc, diag::note_pch_macro_defined_as) << MacroName;
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000389
390 ConflictingDefines = true;
391 continue;
392 }
Mike Stump1eb44332009-09-09 15:08:12 +0000393
Daniel Dunbar10014aa2009-11-11 03:45:59 +0000394 // If the macro doesn't conflict, then we'll just pick up the macro
395 // definition from the PCH file. Warn the user that they made a mistake.
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000396 if (ConflictingDefines)
397 continue; // Don't complain if there are already conflicting defs
Mike Stump1eb44332009-09-09 15:08:12 +0000398
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000399 if (!MissingDefines) {
400 Reader.Diag(diag::warn_cmdline_missing_macro_defs);
401 MissingDefines = true;
402 }
403
404 // Show the definition of this macro within the PCH file.
Sebastian Redl7e9ad8b2010-07-14 17:49:11 +0000405 std::pair<FileID, llvm::StringRef::size_type> MacroLoc =
406 FindMacro(Buffers, Missing);
407 assert(MacroLoc.second!=llvm::StringRef::npos && "Unable to find macro!");
408 SourceLocation PCHMissingLoc =
409 SourceMgr.getLocForStartOfFile(MacroLoc.first)
410 .getFileLocWithOffset(MacroLoc.second);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000411 Reader.Diag(PCHMissingLoc, diag::note_using_macro_def_from_pch);
412 }
Mike Stump1eb44332009-09-09 15:08:12 +0000413
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000414 if (ConflictingDefines)
415 return true;
Mike Stump1eb44332009-09-09 15:08:12 +0000416
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000417 // Determine what predefines were introduced based on command-line
418 // parameters that were not present when building the PCH
419 // file. Extra #defines are okay, so long as the identifiers being
420 // defined were not used within the precompiled header.
Daniel Dunbar4d5936a2009-11-11 05:26:28 +0000421 std::vector<llvm::StringRef> ExtraPredefines;
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000422 std::set_difference(CmdLineLines.begin(), CmdLineLines.end(),
423 PCHLines.begin(), PCHLines.end(),
Mike Stump1eb44332009-09-09 15:08:12 +0000424 std::back_inserter(ExtraPredefines));
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000425 for (unsigned I = 0, N = ExtraPredefines.size(); I != N; ++I) {
Daniel Dunbar4d5936a2009-11-11 05:26:28 +0000426 llvm::StringRef &Extra = ExtraPredefines[I];
427 if (!Extra.startswith("#define ")) {
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000428 Reader.Diag(diag::warn_pch_compiler_options_mismatch);
429 return true;
430 }
431
432 // This is an extra macro definition. Determine the name of the
433 // macro we're defining.
434 std::string::size_type StartOfMacroName = strlen("#define ");
Mike Stump1eb44332009-09-09 15:08:12 +0000435 std::string::size_type EndOfMacroName
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000436 = Extra.find_first_of("( \n\r", StartOfMacroName);
437 assert(EndOfMacroName != std::string::npos &&
438 "Couldn't find the end of the macro name");
Daniel Dunbar4d5936a2009-11-11 05:26:28 +0000439 llvm::StringRef MacroName = Extra.slice(StartOfMacroName, EndOfMacroName);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000440
441 // Check whether this name was used somewhere in the PCH file. If
442 // so, defining it as a macro could change behavior, so we reject
443 // the PCH file.
Daniel Dunbar4d5936a2009-11-11 05:26:28 +0000444 if (IdentifierInfo *II = Reader.get(MacroName)) {
Daniel Dunbar4fda42e2009-11-11 00:52:00 +0000445 Reader.Diag(diag::warn_macro_name_used_in_pch) << II;
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000446 return true;
447 }
448
449 // Add this definition to the suggested predefines buffer.
450 SuggestedPredefines += Extra;
451 SuggestedPredefines += '\n';
452 }
453
454 // If we get here, it's because the predefines buffer had compatible
455 // contents. Accept the PCH file.
456 return false;
457}
458
Douglas Gregor12fab312010-03-16 16:35:32 +0000459void PCHValidator::ReadHeaderFileInfo(const HeaderFileInfo &HFI,
460 unsigned ID) {
461 PP.getHeaderSearchInfo().setHeaderFileInfoForUID(HFI, ID);
462 ++NumHeaderInfos;
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000463}
464
465void PCHValidator::ReadCounter(unsigned Value) {
466 PP.setCounterValue(Value);
467}
468
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000469//===----------------------------------------------------------------------===//
Sebastian Redlc43b54c2010-08-18 23:56:43 +0000470// AST reader implementation
Douglas Gregor668c1a42009-04-21 22:25:48 +0000471//===----------------------------------------------------------------------===//
472
Sebastian Redlffaab3e2010-07-30 00:29:29 +0000473void
Sebastian Redl571db7f2010-08-18 23:56:56 +0000474ASTReader::setDeserializationListener(ASTDeserializationListener *Listener) {
Sebastian Redlffaab3e2010-07-30 00:29:29 +0000475 DeserializationListener = Listener;
Sebastian Redlffaab3e2010-07-30 00:29:29 +0000476}
477
Chris Lattner4c6f9522009-04-27 05:14:47 +0000478
Douglas Gregor668c1a42009-04-21 22:25:48 +0000479namespace {
Sebastian Redl3c7f4132010-08-18 23:57:06 +0000480class ASTSelectorLookupTrait {
Sebastian Redlc43b54c2010-08-18 23:56:43 +0000481 ASTReader &Reader;
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000482
483public:
Sebastian Redl5d050072010-08-04 17:20:04 +0000484 struct data_type {
Sebastian Redl8538e8d2010-08-18 23:57:32 +0000485 SelectorID ID;
Sebastian Redl5d050072010-08-04 17:20:04 +0000486 ObjCMethodList Instance, Factory;
487 };
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000488
489 typedef Selector external_key_type;
490 typedef external_key_type internal_key_type;
491
Sebastian Redl3c7f4132010-08-18 23:57:06 +0000492 explicit ASTSelectorLookupTrait(ASTReader &Reader) : Reader(Reader) { }
Mike Stump1eb44332009-09-09 15:08:12 +0000493
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000494 static bool EqualKey(const internal_key_type& a,
495 const internal_key_type& b) {
496 return a == b;
497 }
Mike Stump1eb44332009-09-09 15:08:12 +0000498
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000499 static unsigned ComputeHash(Selector Sel) {
Argyrios Kyrtzidis0eca89e2010-08-20 16:03:52 +0000500 return serialization::ComputeHash(Sel);
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000501 }
Mike Stump1eb44332009-09-09 15:08:12 +0000502
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000503 // This hopefully will just get inlined and removed by the optimizer.
504 static const internal_key_type&
505 GetInternalKey(const external_key_type& x) { return x; }
Mike Stump1eb44332009-09-09 15:08:12 +0000506
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000507 static std::pair<unsigned, unsigned>
508 ReadKeyDataLength(const unsigned char*& d) {
509 using namespace clang::io;
510 unsigned KeyLen = ReadUnalignedLE16(d);
511 unsigned DataLen = ReadUnalignedLE16(d);
512 return std::make_pair(KeyLen, DataLen);
513 }
Mike Stump1eb44332009-09-09 15:08:12 +0000514
Douglas Gregor83941df2009-04-25 17:48:32 +0000515 internal_key_type ReadKey(const unsigned char* d, unsigned) {
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000516 using namespace clang::io;
Chris Lattnerd1d64a02009-04-27 21:45:14 +0000517 SelectorTable &SelTable = Reader.getContext()->Selectors;
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000518 unsigned N = ReadUnalignedLE16(d);
Mike Stump1eb44332009-09-09 15:08:12 +0000519 IdentifierInfo *FirstII
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000520 = Reader.DecodeIdentifierInfo(ReadUnalignedLE32(d));
521 if (N == 0)
522 return SelTable.getNullarySelector(FirstII);
523 else if (N == 1)
524 return SelTable.getUnarySelector(FirstII);
525
526 llvm::SmallVector<IdentifierInfo *, 16> Args;
527 Args.push_back(FirstII);
528 for (unsigned I = 1; I != N; ++I)
529 Args.push_back(Reader.DecodeIdentifierInfo(ReadUnalignedLE32(d)));
530
Douglas Gregor75fdb232009-05-22 22:45:36 +0000531 return SelTable.getSelector(N, Args.data());
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000532 }
Mike Stump1eb44332009-09-09 15:08:12 +0000533
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000534 data_type ReadData(Selector, const unsigned char* d, unsigned DataLen) {
535 using namespace clang::io;
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000536
537 data_type Result;
538
Sebastian Redl5d050072010-08-04 17:20:04 +0000539 Result.ID = ReadUnalignedLE32(d);
540 unsigned NumInstanceMethods = ReadUnalignedLE16(d);
541 unsigned NumFactoryMethods = ReadUnalignedLE16(d);
542
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000543 // Load instance methods
544 ObjCMethodList *Prev = 0;
545 for (unsigned I = 0; I != NumInstanceMethods; ++I) {
Mike Stump1eb44332009-09-09 15:08:12 +0000546 ObjCMethodDecl *Method
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000547 = cast<ObjCMethodDecl>(Reader.GetDecl(ReadUnalignedLE32(d)));
Sebastian Redl5d050072010-08-04 17:20:04 +0000548 if (!Result.Instance.Method) {
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000549 // This is the first method, which is the easy case.
Sebastian Redl5d050072010-08-04 17:20:04 +0000550 Result.Instance.Method = Method;
551 Prev = &Result.Instance;
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000552 continue;
553 }
554
Ted Kremenek298ed872010-02-11 00:53:01 +0000555 ObjCMethodList *Mem =
556 Reader.getSema()->BumpAlloc.Allocate<ObjCMethodList>();
557 Prev->Next = new (Mem) ObjCMethodList(Method, 0);
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000558 Prev = Prev->Next;
559 }
560
561 // Load factory methods
562 Prev = 0;
563 for (unsigned I = 0; I != NumFactoryMethods; ++I) {
Mike Stump1eb44332009-09-09 15:08:12 +0000564 ObjCMethodDecl *Method
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000565 = cast<ObjCMethodDecl>(Reader.GetDecl(ReadUnalignedLE32(d)));
Sebastian Redl5d050072010-08-04 17:20:04 +0000566 if (!Result.Factory.Method) {
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000567 // This is the first method, which is the easy case.
Sebastian Redl5d050072010-08-04 17:20:04 +0000568 Result.Factory.Method = Method;
569 Prev = &Result.Factory;
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000570 continue;
571 }
572
Ted Kremenek298ed872010-02-11 00:53:01 +0000573 ObjCMethodList *Mem =
574 Reader.getSema()->BumpAlloc.Allocate<ObjCMethodList>();
575 Prev->Next = new (Mem) ObjCMethodList(Method, 0);
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000576 Prev = Prev->Next;
577 }
578
579 return Result;
580 }
581};
Mike Stump1eb44332009-09-09 15:08:12 +0000582
583} // end anonymous namespace
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000584
585/// \brief The on-disk hash table used for the global method pool.
Sebastian Redl3c7f4132010-08-18 23:57:06 +0000586typedef OnDiskChainedHashTable<ASTSelectorLookupTrait>
587 ASTSelectorLookupTable;
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000588
Sebastian Redlc3632732010-10-05 15:59:54 +0000589namespace clang {
Sebastian Redl3c7f4132010-08-18 23:57:06 +0000590class ASTIdentifierLookupTrait {
Sebastian Redlc43b54c2010-08-18 23:56:43 +0000591 ASTReader &Reader;
Sebastian Redlc3632732010-10-05 15:59:54 +0000592 ASTReader::PerFileData &F;
Douglas Gregor668c1a42009-04-21 22:25:48 +0000593
594 // If we know the IdentifierInfo in advance, it is here and we will
595 // not build a new one. Used when deserializing information about an
Sebastian Redl3c7f4132010-08-18 23:57:06 +0000596 // identifier that was constructed before the AST file was read.
Douglas Gregor668c1a42009-04-21 22:25:48 +0000597 IdentifierInfo *KnownII;
598
599public:
600 typedef IdentifierInfo * data_type;
601
602 typedef const std::pair<const char*, unsigned> external_key_type;
603
604 typedef external_key_type internal_key_type;
605
Sebastian Redlc3632732010-10-05 15:59:54 +0000606 ASTIdentifierLookupTrait(ASTReader &Reader, ASTReader::PerFileData &F,
Sebastian Redld27d3fc2010-07-21 22:31:37 +0000607 IdentifierInfo *II = 0)
Sebastian Redlc3632732010-10-05 15:59:54 +0000608 : Reader(Reader), F(F), KnownII(II) { }
Mike Stump1eb44332009-09-09 15:08:12 +0000609
Douglas Gregor668c1a42009-04-21 22:25:48 +0000610 static bool EqualKey(const internal_key_type& a,
611 const internal_key_type& b) {
612 return (a.second == b.second) ? memcmp(a.first, b.first, a.second) == 0
613 : false;
614 }
Mike Stump1eb44332009-09-09 15:08:12 +0000615
Douglas Gregor668c1a42009-04-21 22:25:48 +0000616 static unsigned ComputeHash(const internal_key_type& a) {
Daniel Dunbar2596e422009-10-17 23:52:28 +0000617 return llvm::HashString(llvm::StringRef(a.first, a.second));
Douglas Gregor668c1a42009-04-21 22:25:48 +0000618 }
Mike Stump1eb44332009-09-09 15:08:12 +0000619
Douglas Gregor668c1a42009-04-21 22:25:48 +0000620 // This hopefully will just get inlined and removed by the optimizer.
621 static const internal_key_type&
622 GetInternalKey(const external_key_type& x) { return x; }
Mike Stump1eb44332009-09-09 15:08:12 +0000623
Douglas Gregor95f42922010-10-14 22:11:03 +0000624 // This hopefully will just get inlined and removed by the optimizer.
625 static const external_key_type&
626 GetExternalKey(const internal_key_type& x) { return x; }
627
Douglas Gregor668c1a42009-04-21 22:25:48 +0000628 static std::pair<unsigned, unsigned>
629 ReadKeyDataLength(const unsigned char*& d) {
630 using namespace clang::io;
Douglas Gregor5f8e3302009-04-25 20:26:24 +0000631 unsigned DataLen = ReadUnalignedLE16(d);
Douglas Gregord6595a42009-04-25 21:04:17 +0000632 unsigned KeyLen = ReadUnalignedLE16(d);
Douglas Gregor668c1a42009-04-21 22:25:48 +0000633 return std::make_pair(KeyLen, DataLen);
634 }
Mike Stump1eb44332009-09-09 15:08:12 +0000635
Douglas Gregor668c1a42009-04-21 22:25:48 +0000636 static std::pair<const char*, unsigned>
637 ReadKey(const unsigned char* d, unsigned n) {
638 assert(n >= 2 && d[n-1] == '\0');
639 return std::make_pair((const char*) d, n-1);
640 }
Mike Stump1eb44332009-09-09 15:08:12 +0000641
642 IdentifierInfo *ReadData(const internal_key_type& k,
Douglas Gregor668c1a42009-04-21 22:25:48 +0000643 const unsigned char* d,
644 unsigned DataLen) {
645 using namespace clang::io;
Sebastian Redl8538e8d2010-08-18 23:57:32 +0000646 IdentID ID = ReadUnalignedLE32(d);
Douglas Gregora92193e2009-04-28 21:18:29 +0000647 bool IsInteresting = ID & 0x01;
648
649 // Wipe out the "is interesting" bit.
650 ID = ID >> 1;
651
652 if (!IsInteresting) {
Sebastian Redl083abdf2010-07-27 23:01:28 +0000653 // For uninteresting identifiers, just build the IdentifierInfo
Douglas Gregora92193e2009-04-28 21:18:29 +0000654 // and associate it with the persistent ID.
655 IdentifierInfo *II = KnownII;
656 if (!II)
Sebastian Redlffaab3e2010-07-30 00:29:29 +0000657 II = &Reader.getIdentifierTable().getOwn(k.first, k.first + k.second);
Douglas Gregora92193e2009-04-28 21:18:29 +0000658 Reader.SetIdentifierInfo(ID, II);
Sebastian Redl3c7f4132010-08-18 23:57:06 +0000659 II->setIsFromAST();
Douglas Gregora92193e2009-04-28 21:18:29 +0000660 return II;
661 }
662
Douglas Gregor5998da52009-04-28 21:32:13 +0000663 unsigned Bits = ReadUnalignedLE16(d);
Douglas Gregor2deaea32009-04-22 18:49:13 +0000664 bool CPlusPlusOperatorKeyword = Bits & 0x01;
665 Bits >>= 1;
Argyrios Kyrtzidis646395b2010-08-11 22:55:12 +0000666 bool HasRevertedTokenIDToIdentifier = Bits & 0x01;
667 Bits >>= 1;
Douglas Gregor2deaea32009-04-22 18:49:13 +0000668 bool Poisoned = Bits & 0x01;
669 Bits >>= 1;
670 bool ExtensionToken = Bits & 0x01;
671 Bits >>= 1;
672 bool hasMacroDefinition = Bits & 0x01;
673 Bits >>= 1;
674 unsigned ObjCOrBuiltinID = Bits & 0x3FF;
675 Bits >>= 10;
Mike Stump1eb44332009-09-09 15:08:12 +0000676
Douglas Gregor2deaea32009-04-22 18:49:13 +0000677 assert(Bits == 0 && "Extra bits in the identifier?");
Douglas Gregor5998da52009-04-28 21:32:13 +0000678 DataLen -= 6;
Douglas Gregor668c1a42009-04-21 22:25:48 +0000679
680 // Build the IdentifierInfo itself and link the identifier ID with
681 // the new IdentifierInfo.
682 IdentifierInfo *II = KnownII;
683 if (!II)
Sebastian Redlffaab3e2010-07-30 00:29:29 +0000684 II = &Reader.getIdentifierTable().getOwn(k.first, k.first + k.second);
Douglas Gregor668c1a42009-04-21 22:25:48 +0000685 Reader.SetIdentifierInfo(ID, II);
686
Douglas Gregor2deaea32009-04-22 18:49:13 +0000687 // Set or check the various bits in the IdentifierInfo structure.
Argyrios Kyrtzidis646395b2010-08-11 22:55:12 +0000688 // Token IDs are read-only.
689 if (HasRevertedTokenIDToIdentifier)
690 II->RevertTokenIDToIdentifier();
Douglas Gregor2deaea32009-04-22 18:49:13 +0000691 II->setObjCOrBuiltinID(ObjCOrBuiltinID);
Mike Stump1eb44332009-09-09 15:08:12 +0000692 assert(II->isExtensionToken() == ExtensionToken &&
Douglas Gregor2deaea32009-04-22 18:49:13 +0000693 "Incorrect extension token flag");
694 (void)ExtensionToken;
695 II->setIsPoisoned(Poisoned);
696 assert(II->isCPlusPlusOperatorKeyword() == CPlusPlusOperatorKeyword &&
697 "Incorrect C++ operator keyword flag");
698 (void)CPlusPlusOperatorKeyword;
699
Douglas Gregor37e26842009-04-21 23:56:24 +0000700 // If this identifier is a macro, deserialize the macro
701 // definition.
702 if (hasMacroDefinition) {
Douglas Gregor5998da52009-04-28 21:32:13 +0000703 uint32_t Offset = ReadUnalignedLE32(d);
Douglas Gregor295a2a62010-10-30 00:23:06 +0000704 Reader.SetIdentifierIsMacro(II, F, Offset);
Douglas Gregor5998da52009-04-28 21:32:13 +0000705 DataLen -= 4;
Douglas Gregor37e26842009-04-21 23:56:24 +0000706 }
Douglas Gregor668c1a42009-04-21 22:25:48 +0000707
708 // Read all of the declarations visible at global scope with this
709 // name.
Chris Lattner6bf690f2009-04-27 22:17:41 +0000710 if (Reader.getContext() == 0) return II;
Douglas Gregord89275b2009-07-06 18:54:52 +0000711 if (DataLen > 0) {
712 llvm::SmallVector<uint32_t, 4> DeclIDs;
713 for (; DataLen > 0; DataLen -= 4)
714 DeclIDs.push_back(ReadUnalignedLE32(d));
715 Reader.SetGloballyVisibleDecls(II, DeclIDs);
Douglas Gregor668c1a42009-04-21 22:25:48 +0000716 }
Mike Stump1eb44332009-09-09 15:08:12 +0000717
Sebastian Redl3c7f4132010-08-18 23:57:06 +0000718 II->setIsFromAST();
Douglas Gregor668c1a42009-04-21 22:25:48 +0000719 return II;
720 }
721};
Mike Stump1eb44332009-09-09 15:08:12 +0000722
723} // end anonymous namespace
Douglas Gregor668c1a42009-04-21 22:25:48 +0000724
725/// \brief The on-disk hash table used to contain information about
726/// all of the identifiers in the program.
Sebastian Redl3c7f4132010-08-18 23:57:06 +0000727typedef OnDiskChainedHashTable<ASTIdentifierLookupTrait>
728 ASTIdentifierLookupTable;
Douglas Gregor668c1a42009-04-21 22:25:48 +0000729
Argyrios Kyrtzidis5d267682010-08-20 16:04:27 +0000730namespace {
731class ASTDeclContextNameLookupTrait {
732 ASTReader &Reader;
733
734public:
735 /// \brief Pair of begin/end iterators for DeclIDs.
736 typedef std::pair<DeclID *, DeclID *> data_type;
737
738 /// \brief Special internal key for declaration names.
739 /// The hash table creates keys for comparison; we do not create
740 /// a DeclarationName for the internal key to avoid deserializing types.
741 struct DeclNameKey {
742 DeclarationName::NameKind Kind;
743 uint64_t Data;
744 DeclNameKey() : Kind((DeclarationName::NameKind)0), Data(0) { }
745 };
746
747 typedef DeclarationName external_key_type;
748 typedef DeclNameKey internal_key_type;
749
750 explicit ASTDeclContextNameLookupTrait(ASTReader &Reader) : Reader(Reader) { }
751
752 static bool EqualKey(const internal_key_type& a,
753 const internal_key_type& b) {
754 return a.Kind == b.Kind && a.Data == b.Data;
755 }
756
757 unsigned ComputeHash(const DeclNameKey &Key) const {
758 llvm::FoldingSetNodeID ID;
759 ID.AddInteger(Key.Kind);
760
761 switch (Key.Kind) {
762 case DeclarationName::Identifier:
763 case DeclarationName::CXXLiteralOperatorName:
764 ID.AddString(((IdentifierInfo*)Key.Data)->getName());
765 break;
766 case DeclarationName::ObjCZeroArgSelector:
767 case DeclarationName::ObjCOneArgSelector:
768 case DeclarationName::ObjCMultiArgSelector:
769 ID.AddInteger(serialization::ComputeHash(Selector(Key.Data)));
770 break;
771 case DeclarationName::CXXConstructorName:
772 case DeclarationName::CXXDestructorName:
773 case DeclarationName::CXXConversionFunctionName:
774 ID.AddInteger((TypeID)Key.Data);
775 break;
776 case DeclarationName::CXXOperatorName:
777 ID.AddInteger((OverloadedOperatorKind)Key.Data);
778 break;
779 case DeclarationName::CXXUsingDirective:
780 break;
781 }
782
783 return ID.ComputeHash();
784 }
785
786 internal_key_type GetInternalKey(const external_key_type& Name) const {
787 DeclNameKey Key;
788 Key.Kind = Name.getNameKind();
789 switch (Name.getNameKind()) {
790 case DeclarationName::Identifier:
791 Key.Data = (uint64_t)Name.getAsIdentifierInfo();
792 break;
793 case DeclarationName::ObjCZeroArgSelector:
794 case DeclarationName::ObjCOneArgSelector:
795 case DeclarationName::ObjCMultiArgSelector:
796 Key.Data = (uint64_t)Name.getObjCSelector().getAsOpaquePtr();
797 break;
798 case DeclarationName::CXXConstructorName:
799 case DeclarationName::CXXDestructorName:
800 case DeclarationName::CXXConversionFunctionName:
801 Key.Data = Reader.GetTypeID(Name.getCXXNameType());
802 break;
803 case DeclarationName::CXXOperatorName:
804 Key.Data = Name.getCXXOverloadedOperator();
805 break;
806 case DeclarationName::CXXLiteralOperatorName:
807 Key.Data = (uint64_t)Name.getCXXLiteralIdentifier();
808 break;
809 case DeclarationName::CXXUsingDirective:
810 break;
811 }
Michael J. Spencer20249a12010-10-21 03:16:25 +0000812
Argyrios Kyrtzidis5d267682010-08-20 16:04:27 +0000813 return Key;
814 }
815
Argyrios Kyrtzidisa60786b2010-08-20 23:35:55 +0000816 external_key_type GetExternalKey(const internal_key_type& Key) const {
817 ASTContext *Context = Reader.getContext();
818 switch (Key.Kind) {
819 case DeclarationName::Identifier:
820 return DeclarationName((IdentifierInfo*)Key.Data);
821
822 case DeclarationName::ObjCZeroArgSelector:
823 case DeclarationName::ObjCOneArgSelector:
824 case DeclarationName::ObjCMultiArgSelector:
825 return DeclarationName(Selector(Key.Data));
826
827 case DeclarationName::CXXConstructorName:
828 return Context->DeclarationNames.getCXXConstructorName(
829 Context->getCanonicalType(Reader.GetType(Key.Data)));
830
831 case DeclarationName::CXXDestructorName:
832 return Context->DeclarationNames.getCXXDestructorName(
833 Context->getCanonicalType(Reader.GetType(Key.Data)));
834
835 case DeclarationName::CXXConversionFunctionName:
836 return Context->DeclarationNames.getCXXConversionFunctionName(
837 Context->getCanonicalType(Reader.GetType(Key.Data)));
838
839 case DeclarationName::CXXOperatorName:
840 return Context->DeclarationNames.getCXXOperatorName(
841 (OverloadedOperatorKind)Key.Data);
842
843 case DeclarationName::CXXLiteralOperatorName:
844 return Context->DeclarationNames.getCXXLiteralOperatorName(
845 (IdentifierInfo*)Key.Data);
846
847 case DeclarationName::CXXUsingDirective:
848 return DeclarationName::getUsingDirectiveName();
849 }
850
851 llvm_unreachable("Invalid Name Kind ?");
852 }
853
Argyrios Kyrtzidis5d267682010-08-20 16:04:27 +0000854 static std::pair<unsigned, unsigned>
855 ReadKeyDataLength(const unsigned char*& d) {
856 using namespace clang::io;
857 unsigned KeyLen = ReadUnalignedLE16(d);
858 unsigned DataLen = ReadUnalignedLE16(d);
859 return std::make_pair(KeyLen, DataLen);
860 }
861
862 internal_key_type ReadKey(const unsigned char* d, unsigned) {
863 using namespace clang::io;
864
865 DeclNameKey Key;
866 Key.Kind = (DeclarationName::NameKind)*d++;
867 switch (Key.Kind) {
868 case DeclarationName::Identifier:
869 Key.Data = (uint64_t)Reader.DecodeIdentifierInfo(ReadUnalignedLE32(d));
870 break;
871 case DeclarationName::ObjCZeroArgSelector:
872 case DeclarationName::ObjCOneArgSelector:
873 case DeclarationName::ObjCMultiArgSelector:
Michael J. Spencer20249a12010-10-21 03:16:25 +0000874 Key.Data =
Argyrios Kyrtzidis5d267682010-08-20 16:04:27 +0000875 (uint64_t)Reader.DecodeSelector(ReadUnalignedLE32(d)).getAsOpaquePtr();
876 break;
877 case DeclarationName::CXXConstructorName:
878 case DeclarationName::CXXDestructorName:
879 case DeclarationName::CXXConversionFunctionName:
880 Key.Data = ReadUnalignedLE32(d); // TypeID
881 break;
882 case DeclarationName::CXXOperatorName:
883 Key.Data = *d++; // OverloadedOperatorKind
884 break;
885 case DeclarationName::CXXLiteralOperatorName:
886 Key.Data = (uint64_t)Reader.DecodeIdentifierInfo(ReadUnalignedLE32(d));
887 break;
888 case DeclarationName::CXXUsingDirective:
889 break;
890 }
Michael J. Spencer20249a12010-10-21 03:16:25 +0000891
Argyrios Kyrtzidis5d267682010-08-20 16:04:27 +0000892 return Key;
893 }
894
895 data_type ReadData(internal_key_type, const unsigned char* d,
896 unsigned DataLen) {
897 using namespace clang::io;
898 unsigned NumDecls = ReadUnalignedLE16(d);
899 DeclID *Start = (DeclID *)d;
900 return std::make_pair(Start, Start + NumDecls);
901 }
902};
903
904} // end anonymous namespace
905
906/// \brief The on-disk hash table used for the DeclContext's Name lookup table.
907typedef OnDiskChainedHashTable<ASTDeclContextNameLookupTrait>
908 ASTDeclContextNameLookupTable;
909
Argyrios Kyrtzidis074dcc82010-08-20 16:04:35 +0000910bool ASTReader::ReadDeclContextStorage(llvm::BitstreamCursor &Cursor,
911 const std::pair<uint64_t, uint64_t> &Offsets,
912 DeclContextInfo &Info) {
913 SavedStreamPosition SavedPosition(Cursor);
914 // First the lexical decls.
915 if (Offsets.first != 0) {
916 Cursor.JumpToBit(Offsets.first);
917
918 RecordData Record;
919 const char *Blob;
920 unsigned BlobLen;
921 unsigned Code = Cursor.ReadCode();
922 unsigned RecCode = Cursor.ReadRecord(Code, Record, &Blob, &BlobLen);
923 if (RecCode != DECL_CONTEXT_LEXICAL) {
924 Error("Expected lexical block");
925 return true;
926 }
927
Argyrios Kyrtzidiseb5e9982010-10-14 20:14:34 +0000928 Info.LexicalDecls = reinterpret_cast<const KindDeclIDPair*>(Blob);
929 Info.NumLexicalDecls = BlobLen / sizeof(KindDeclIDPair);
Argyrios Kyrtzidis074dcc82010-08-20 16:04:35 +0000930 } else {
931 Info.LexicalDecls = 0;
932 Info.NumLexicalDecls = 0;
933 }
934
935 // Now the lookup table.
936 if (Offsets.second != 0) {
937 Cursor.JumpToBit(Offsets.second);
938
939 RecordData Record;
940 const char *Blob;
941 unsigned BlobLen;
942 unsigned Code = Cursor.ReadCode();
943 unsigned RecCode = Cursor.ReadRecord(Code, Record, &Blob, &BlobLen);
944 if (RecCode != DECL_CONTEXT_VISIBLE) {
945 Error("Expected visible lookup table block");
946 return true;
947 }
948 Info.NameLookupTableData
949 = ASTDeclContextNameLookupTable::Create(
950 (const unsigned char *)Blob + Record[0],
951 (const unsigned char *)Blob,
952 ASTDeclContextNameLookupTrait(*this));
Sebastian Redl0ea8f7f2010-08-24 00:50:00 +0000953 } else {
954 Info.NameLookupTableData = 0;
Argyrios Kyrtzidis074dcc82010-08-20 16:04:35 +0000955 }
956
957 return false;
958}
959
Sebastian Redlc43b54c2010-08-18 23:56:43 +0000960void ASTReader::Error(const char *Msg) {
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +0000961 Diag(diag::err_fe_pch_malformed) << Msg;
Douglas Gregor2cf26342009-04-09 22:27:44 +0000962}
963
Sebastian Redl3c7f4132010-08-18 23:57:06 +0000964/// \brief Tell the AST listener about the predefines buffers in the chain.
Sebastian Redlc43b54c2010-08-18 23:56:43 +0000965bool ASTReader::CheckPredefinesBuffers() {
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000966 if (Listener)
Sebastian Redl7e9ad8b2010-07-14 17:49:11 +0000967 return Listener->ReadPredefinesBuffer(PCHPredefinesBuffers,
Daniel Dunbar7b5a1212009-11-11 05:29:04 +0000968 ActualOriginalFileName,
Nick Lewycky277a6e72011-02-23 21:16:44 +0000969 SuggestedPredefines,
970 FileMgr);
Douglas Gregore721f952009-04-28 18:58:38 +0000971 return false;
Douglas Gregore1d918e2009-04-10 23:10:45 +0000972}
973
Douglas Gregor4fed3f42009-04-27 18:38:38 +0000974//===----------------------------------------------------------------------===//
975// Source Manager Deserialization
976//===----------------------------------------------------------------------===//
977
Douglas Gregorbd945002009-04-13 16:31:14 +0000978/// \brief Read the line table in the source manager block.
Sebastian Redlc3632732010-10-05 15:59:54 +0000979/// \returns true if there was an error.
980bool ASTReader::ParseLineTable(PerFileData &F,
981 llvm::SmallVectorImpl<uint64_t> &Record) {
Douglas Gregorbd945002009-04-13 16:31:14 +0000982 unsigned Idx = 0;
983 LineTableInfo &LineTable = SourceMgr.getLineTable();
984
985 // Parse the file names
Douglas Gregorff0a9872009-04-13 17:12:42 +0000986 std::map<int, int> FileIDs;
987 for (int I = 0, N = Record[Idx++]; I != N; ++I) {
Douglas Gregorbd945002009-04-13 16:31:14 +0000988 // Extract the file name
989 unsigned FilenameLen = Record[Idx++];
990 std::string Filename(&Record[Idx], &Record[Idx] + FilenameLen);
991 Idx += FilenameLen;
Douglas Gregore650c8c2009-07-07 00:12:59 +0000992 MaybeAddSystemRootToFilename(Filename);
Mike Stump1eb44332009-09-09 15:08:12 +0000993 FileIDs[I] = LineTable.getLineTableFilenameID(Filename.c_str(),
Douglas Gregorff0a9872009-04-13 17:12:42 +0000994 Filename.size());
Douglas Gregorbd945002009-04-13 16:31:14 +0000995 }
996
997 // Parse the line entries
998 std::vector<LineEntry> Entries;
999 while (Idx < Record.size()) {
Argyrios Kyrtzidisf52a5d22010-07-02 11:55:05 +00001000 int FID = Record[Idx++];
Douglas Gregorbd945002009-04-13 16:31:14 +00001001
1002 // Extract the line entries
1003 unsigned NumEntries = Record[Idx++];
Argyrios Kyrtzidisf52a5d22010-07-02 11:55:05 +00001004 assert(NumEntries && "Numentries is 00000");
Douglas Gregorbd945002009-04-13 16:31:14 +00001005 Entries.clear();
1006 Entries.reserve(NumEntries);
1007 for (unsigned I = 0; I != NumEntries; ++I) {
1008 unsigned FileOffset = Record[Idx++];
1009 unsigned LineNo = Record[Idx++];
Argyrios Kyrtzidisf52a5d22010-07-02 11:55:05 +00001010 int FilenameID = FileIDs[Record[Idx++]];
Mike Stump1eb44332009-09-09 15:08:12 +00001011 SrcMgr::CharacteristicKind FileKind
Douglas Gregorbd945002009-04-13 16:31:14 +00001012 = (SrcMgr::CharacteristicKind)Record[Idx++];
1013 unsigned IncludeOffset = Record[Idx++];
1014 Entries.push_back(LineEntry::get(FileOffset, LineNo, FilenameID,
1015 FileKind, IncludeOffset));
1016 }
1017 LineTable.AddEntry(FID, Entries);
1018 }
1019
1020 return false;
1021}
1022
Douglas Gregor4fed3f42009-04-27 18:38:38 +00001023namespace {
1024
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001025class ASTStatData {
Douglas Gregor4fed3f42009-04-27 18:38:38 +00001026public:
Douglas Gregor4fed3f42009-04-27 18:38:38 +00001027 const ino_t ino;
1028 const dev_t dev;
1029 const mode_t mode;
1030 const time_t mtime;
1031 const off_t size;
Mike Stump1eb44332009-09-09 15:08:12 +00001032
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001033 ASTStatData(ino_t i, dev_t d, mode_t mo, time_t m, off_t s)
Chris Lattner74e976b2010-11-23 19:28:12 +00001034 : ino(i), dev(d), mode(mo), mtime(m), size(s) {}
Douglas Gregor4fed3f42009-04-27 18:38:38 +00001035};
1036
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001037class ASTStatLookupTrait {
Douglas Gregor4fed3f42009-04-27 18:38:38 +00001038 public:
1039 typedef const char *external_key_type;
1040 typedef const char *internal_key_type;
1041
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001042 typedef ASTStatData data_type;
Douglas Gregor4fed3f42009-04-27 18:38:38 +00001043
1044 static unsigned ComputeHash(const char *path) {
Daniel Dunbar2596e422009-10-17 23:52:28 +00001045 return llvm::HashString(path);
Douglas Gregor4fed3f42009-04-27 18:38:38 +00001046 }
1047
1048 static internal_key_type GetInternalKey(const char *path) { return path; }
1049
1050 static bool EqualKey(internal_key_type a, internal_key_type b) {
1051 return strcmp(a, b) == 0;
1052 }
1053
1054 static std::pair<unsigned, unsigned>
1055 ReadKeyDataLength(const unsigned char*& d) {
1056 unsigned KeyLen = (unsigned) clang::io::ReadUnalignedLE16(d);
1057 unsigned DataLen = (unsigned) *d++;
1058 return std::make_pair(KeyLen + 1, DataLen);
1059 }
1060
1061 static internal_key_type ReadKey(const unsigned char *d, unsigned) {
1062 return (const char *)d;
1063 }
1064
1065 static data_type ReadData(const internal_key_type, const unsigned char *d,
1066 unsigned /*DataLen*/) {
1067 using namespace clang::io;
1068
Douglas Gregor4fed3f42009-04-27 18:38:38 +00001069 ino_t ino = (ino_t) ReadUnalignedLE32(d);
1070 dev_t dev = (dev_t) ReadUnalignedLE32(d);
1071 mode_t mode = (mode_t) ReadUnalignedLE16(d);
Mike Stump1eb44332009-09-09 15:08:12 +00001072 time_t mtime = (time_t) ReadUnalignedLE64(d);
Douglas Gregor4fed3f42009-04-27 18:38:38 +00001073 off_t size = (off_t) ReadUnalignedLE64(d);
1074 return data_type(ino, dev, mode, mtime, size);
1075 }
1076};
1077
1078/// \brief stat() cache for precompiled headers.
1079///
1080/// This cache is very similar to the stat cache used by pretokenized
1081/// headers.
Chris Lattner10e286a2010-11-23 19:19:34 +00001082class ASTStatCache : public FileSystemStatCache {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001083 typedef OnDiskChainedHashTable<ASTStatLookupTrait> CacheTy;
Douglas Gregor4fed3f42009-04-27 18:38:38 +00001084 CacheTy *Cache;
1085
1086 unsigned &NumStatHits, &NumStatMisses;
Mike Stump1eb44332009-09-09 15:08:12 +00001087public:
Chris Lattner74e976b2010-11-23 19:28:12 +00001088 ASTStatCache(const unsigned char *Buckets, const unsigned char *Base,
1089 unsigned &NumStatHits, unsigned &NumStatMisses)
Douglas Gregor4fed3f42009-04-27 18:38:38 +00001090 : Cache(0), NumStatHits(NumStatHits), NumStatMisses(NumStatMisses) {
1091 Cache = CacheTy::Create(Buckets, Base);
1092 }
1093
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001094 ~ASTStatCache() { delete Cache; }
Mike Stump1eb44332009-09-09 15:08:12 +00001095
Chris Lattner898a0612010-11-23 21:17:56 +00001096 LookupResult getStat(const char *Path, struct stat &StatBuf,
1097 int *FileDescriptor) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001098 // Do the lookup for the file's data in the AST file.
Chris Lattner10e286a2010-11-23 19:19:34 +00001099 CacheTy::iterator I = Cache->find(Path);
Douglas Gregor4fed3f42009-04-27 18:38:38 +00001100
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001101 // If we don't get a hit in the AST file just forward to 'stat'.
Douglas Gregor4fed3f42009-04-27 18:38:38 +00001102 if (I == Cache->end()) {
1103 ++NumStatMisses;
Chris Lattner898a0612010-11-23 21:17:56 +00001104 return statChained(Path, StatBuf, FileDescriptor);
Douglas Gregor4fed3f42009-04-27 18:38:38 +00001105 }
Mike Stump1eb44332009-09-09 15:08:12 +00001106
Douglas Gregor4fed3f42009-04-27 18:38:38 +00001107 ++NumStatHits;
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001108 ASTStatData Data = *I;
Mike Stump1eb44332009-09-09 15:08:12 +00001109
Chris Lattner10e286a2010-11-23 19:19:34 +00001110 StatBuf.st_ino = Data.ino;
1111 StatBuf.st_dev = Data.dev;
1112 StatBuf.st_mtime = Data.mtime;
1113 StatBuf.st_mode = Data.mode;
1114 StatBuf.st_size = Data.size;
Chris Lattnerd6f61112010-11-23 20:05:15 +00001115 return CacheExists;
Douglas Gregor4fed3f42009-04-27 18:38:38 +00001116 }
1117};
1118} // end anonymous namespace
1119
1120
Sebastian Redl93fb9ed2010-07-19 20:52:06 +00001121/// \brief Read a source manager block
Sebastian Redlc43b54c2010-08-18 23:56:43 +00001122ASTReader::ASTReadResult ASTReader::ReadSourceManagerBlock(PerFileData &F) {
Douglas Gregor14f79002009-04-10 03:52:48 +00001123 using namespace SrcMgr;
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001124
Sebastian Redl93fb9ed2010-07-19 20:52:06 +00001125 llvm::BitstreamCursor &SLocEntryCursor = F.SLocEntryCursor;
Sebastian Redl9137a522010-07-16 17:50:48 +00001126
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001127 // Set the source-location entry cursor to the current position in
1128 // the stream. This cursor will be used to read the contents of the
1129 // source manager block initially, and then lazily read
1130 // source-location entries as needed.
Sebastian Redl93fb9ed2010-07-19 20:52:06 +00001131 SLocEntryCursor = F.Stream;
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001132
1133 // The stream itself is going to skip over the source manager block.
Sebastian Redl93fb9ed2010-07-19 20:52:06 +00001134 if (F.Stream.SkipBlock()) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001135 Error("malformed block record in AST file");
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001136 return Failure;
1137 }
1138
1139 // Enter the source manager block.
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001140 if (SLocEntryCursor.EnterSubBlock(SOURCE_MANAGER_BLOCK_ID)) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001141 Error("malformed source manager block record in AST file");
Douglas Gregore1d918e2009-04-10 23:10:45 +00001142 return Failure;
1143 }
Douglas Gregor14f79002009-04-10 03:52:48 +00001144
Douglas Gregor14f79002009-04-10 03:52:48 +00001145 RecordData Record;
1146 while (true) {
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001147 unsigned Code = SLocEntryCursor.ReadCode();
Douglas Gregor14f79002009-04-10 03:52:48 +00001148 if (Code == llvm::bitc::END_BLOCK) {
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001149 if (SLocEntryCursor.ReadBlockEnd()) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001150 Error("error at end of Source Manager block in AST file");
Douglas Gregore1d918e2009-04-10 23:10:45 +00001151 return Failure;
1152 }
Douglas Gregore1d918e2009-04-10 23:10:45 +00001153 return Success;
Douglas Gregor14f79002009-04-10 03:52:48 +00001154 }
Mike Stump1eb44332009-09-09 15:08:12 +00001155
Douglas Gregor14f79002009-04-10 03:52:48 +00001156 if (Code == llvm::bitc::ENTER_SUBBLOCK) {
1157 // No known subblocks, always skip them.
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001158 SLocEntryCursor.ReadSubBlockID();
1159 if (SLocEntryCursor.SkipBlock()) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001160 Error("malformed block record in AST file");
Douglas Gregore1d918e2009-04-10 23:10:45 +00001161 return Failure;
1162 }
Douglas Gregor14f79002009-04-10 03:52:48 +00001163 continue;
1164 }
Mike Stump1eb44332009-09-09 15:08:12 +00001165
Douglas Gregor14f79002009-04-10 03:52:48 +00001166 if (Code == llvm::bitc::DEFINE_ABBREV) {
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001167 SLocEntryCursor.ReadAbbrevRecord();
Douglas Gregor14f79002009-04-10 03:52:48 +00001168 continue;
1169 }
Mike Stump1eb44332009-09-09 15:08:12 +00001170
Douglas Gregor14f79002009-04-10 03:52:48 +00001171 // Read a record.
1172 const char *BlobStart;
1173 unsigned BlobLen;
1174 Record.clear();
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001175 switch (SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) {
Douglas Gregor14f79002009-04-10 03:52:48 +00001176 default: // Default behavior: ignore.
1177 break;
1178
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001179 case SM_LINE_TABLE:
Sebastian Redlc3632732010-10-05 15:59:54 +00001180 if (ParseLineTable(F, Record))
Douglas Gregorbd945002009-04-13 16:31:14 +00001181 return Failure;
Chris Lattner2c78b872009-04-14 23:22:57 +00001182 break;
Douglas Gregor2eafc1b2009-04-26 00:07:37 +00001183
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001184 case SM_SLOC_FILE_ENTRY:
1185 case SM_SLOC_BUFFER_ENTRY:
1186 case SM_SLOC_INSTANTIATION_ENTRY:
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001187 // Once we hit one of the source location entries, we're done.
1188 return Success;
Douglas Gregor14f79002009-04-10 03:52:48 +00001189 }
1190 }
1191}
1192
Argyrios Kyrtzidis8e3df4d2011-02-15 17:54:22 +00001193/// \brief If a header file is not found at the path that we expect it to be
1194/// and the PCH file was moved from its original location, try to resolve the
1195/// file by assuming that header+PCH were moved together and the header is in
1196/// the same place relative to the PCH.
1197static std::string
1198resolveFileRelativeToOriginalDir(const std::string &Filename,
1199 const std::string &OriginalDir,
1200 const std::string &CurrDir) {
1201 assert(OriginalDir != CurrDir &&
1202 "No point trying to resolve the file if the PCH dir didn't change");
1203 using namespace llvm::sys;
1204 llvm::SmallString<128> filePath(Filename);
1205 fs::make_absolute(filePath);
1206 assert(path::is_absolute(OriginalDir));
1207 llvm::SmallString<128> currPCHPath(CurrDir);
1208
1209 path::const_iterator fileDirI = path::begin(path::parent_path(filePath)),
1210 fileDirE = path::end(path::parent_path(filePath));
1211 path::const_iterator origDirI = path::begin(OriginalDir),
1212 origDirE = path::end(OriginalDir);
1213 // Skip the common path components from filePath and OriginalDir.
1214 while (fileDirI != fileDirE && origDirI != origDirE &&
1215 *fileDirI == *origDirI) {
1216 ++fileDirI;
1217 ++origDirI;
1218 }
1219 for (; origDirI != origDirE; ++origDirI)
1220 path::append(currPCHPath, "..");
1221 path::append(currPCHPath, fileDirI, fileDirE);
1222 path::append(currPCHPath, path::filename(Filename));
1223 return currPCHPath.str();
1224}
1225
Sebastian Redl190faf72010-07-20 21:50:20 +00001226/// \brief Get a cursor that's correctly positioned for reading the source
1227/// location entry with the given ID.
Sebastian Redlc3632732010-10-05 15:59:54 +00001228ASTReader::PerFileData *ASTReader::SLocCursorForID(unsigned ID) {
Sebastian Redl190faf72010-07-20 21:50:20 +00001229 assert(ID != 0 && ID <= TotalNumSLocEntries &&
1230 "SLocCursorForID should only be called for real IDs.");
1231
1232 ID -= 1;
1233 PerFileData *F = 0;
1234 for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
1235 F = Chain[N - I - 1];
1236 if (ID < F->LocalNumSLocEntries)
1237 break;
1238 ID -= F->LocalNumSLocEntries;
1239 }
1240 assert(F && F->LocalNumSLocEntries > ID && "Chain corrupted");
1241
1242 F->SLocEntryCursor.JumpToBit(F->SLocOffsets[ID]);
Sebastian Redlc3632732010-10-05 15:59:54 +00001243 return F;
Sebastian Redl190faf72010-07-20 21:50:20 +00001244}
1245
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001246/// \brief Read in the source location entry with the given ID.
Sebastian Redlc43b54c2010-08-18 23:56:43 +00001247ASTReader::ASTReadResult ASTReader::ReadSLocEntryRecord(unsigned ID) {
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001248 if (ID == 0)
1249 return Success;
1250
1251 if (ID > TotalNumSLocEntries) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001252 Error("source location entry ID out-of-range for AST file");
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001253 return Failure;
1254 }
1255
Sebastian Redlc3632732010-10-05 15:59:54 +00001256 PerFileData *F = SLocCursorForID(ID);
1257 llvm::BitstreamCursor &SLocEntryCursor = F->SLocEntryCursor;
Sebastian Redl9137a522010-07-16 17:50:48 +00001258
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001259 ++NumSLocEntriesRead;
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001260 unsigned Code = SLocEntryCursor.ReadCode();
1261 if (Code == llvm::bitc::END_BLOCK ||
1262 Code == llvm::bitc::ENTER_SUBBLOCK ||
1263 Code == llvm::bitc::DEFINE_ABBREV) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001264 Error("incorrectly-formatted source location entry in AST file");
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001265 return Failure;
1266 }
1267
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001268 RecordData Record;
1269 const char *BlobStart;
1270 unsigned BlobLen;
1271 switch (SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) {
1272 default:
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001273 Error("incorrectly-formatted source location entry in AST file");
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001274 return Failure;
1275
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001276 case SM_SLOC_FILE_ENTRY: {
Douglas Gregore650c8c2009-07-07 00:12:59 +00001277 std::string Filename(BlobStart, BlobStart + BlobLen);
1278 MaybeAddSystemRootToFilename(Filename);
Chris Lattner39b49bc2010-11-23 08:35:12 +00001279 const FileEntry *File = FileMgr.getFile(Filename);
Argyrios Kyrtzidis8e3df4d2011-02-15 17:54:22 +00001280 if (File == 0 && !OriginalDir.empty() && !CurrentDir.empty() &&
1281 OriginalDir != CurrentDir) {
1282 std::string resolved = resolveFileRelativeToOriginalDir(Filename,
1283 OriginalDir,
1284 CurrentDir);
1285 if (!resolved.empty())
1286 File = FileMgr.getFile(resolved);
1287 }
Axel Naumann04331162011-01-27 10:55:51 +00001288 if (File == 0)
1289 File = FileMgr.getVirtualFile(Filename, (off_t)Record[4],
1290 (time_t)Record[5]);
Chris Lattnerd3555ae2009-06-15 04:35:16 +00001291 if (File == 0) {
1292 std::string ErrorStr = "could not find file '";
Douglas Gregore650c8c2009-07-07 00:12:59 +00001293 ErrorStr += Filename;
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001294 ErrorStr += "' referenced by AST file";
Chris Lattnerd3555ae2009-06-15 04:35:16 +00001295 Error(ErrorStr.c_str());
1296 return Failure;
1297 }
Mike Stump1eb44332009-09-09 15:08:12 +00001298
Douglas Gregorcfbf1c72011-02-10 17:09:37 +00001299 if (Record.size() < 6) {
Ted Kremenek1857f622010-03-18 21:23:05 +00001300 Error("source location entry is incorrect");
1301 return Failure;
1302 }
1303
Douglas Gregorfae3b2f2010-07-27 00:27:13 +00001304 if (!DisableValidation &&
1305 ((off_t)Record[4] != File->getSize()
Douglas Gregor9f692a02010-04-09 15:54:22 +00001306#if !defined(LLVM_ON_WIN32)
1307 // In our regression testing, the Windows file system seems to
1308 // have inconsistent modification times that sometimes
1309 // erroneously trigger this error-handling path.
Douglas Gregorfae3b2f2010-07-27 00:27:13 +00001310 || (time_t)Record[5] != File->getModificationTime()
Douglas Gregor9f692a02010-04-09 15:54:22 +00001311#endif
Douglas Gregorfae3b2f2010-07-27 00:27:13 +00001312 )) {
Douglas Gregor2d52be52010-03-21 22:49:54 +00001313 Diag(diag::err_fe_pch_file_modified)
1314 << Filename;
1315 return Failure;
1316 }
1317
Chris Lattner75dfb652010-11-23 09:19:42 +00001318 FileID FID = SourceMgr.createFileID(File, ReadSourceLocation(*F, Record[1]),
1319 (SrcMgr::CharacteristicKind)Record[2],
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001320 ID, Record[0]);
1321 if (Record[3])
1322 const_cast<SrcMgr::FileInfo&>(SourceMgr.getSLocEntry(FID).getFile())
1323 .setHasLineDirectives();
Douglas Gregorcfbf1c72011-02-10 17:09:37 +00001324
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001325 break;
1326 }
1327
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001328 case SM_SLOC_BUFFER_ENTRY: {
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001329 const char *Name = BlobStart;
1330 unsigned Offset = Record[0];
1331 unsigned Code = SLocEntryCursor.ReadCode();
1332 Record.clear();
Mike Stump1eb44332009-09-09 15:08:12 +00001333 unsigned RecCode
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001334 = SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen);
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00001335
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001336 if (RecCode != SM_SLOC_BUFFER_BLOB) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001337 Error("AST record has invalid code");
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00001338 return Failure;
1339 }
1340
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001341 llvm::MemoryBuffer *Buffer
Chris Lattnera0a270c2010-04-05 22:42:27 +00001342 = llvm::MemoryBuffer::getMemBuffer(llvm::StringRef(BlobStart, BlobLen - 1),
1343 Name);
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001344 FileID BufferID = SourceMgr.createFileIDForMemBuffer(Buffer, ID, Offset);
Mike Stump1eb44332009-09-09 15:08:12 +00001345
Douglas Gregor92b059e2009-04-28 20:33:11 +00001346 if (strcmp(Name, "<built-in>") == 0) {
Sebastian Redl7e9ad8b2010-07-14 17:49:11 +00001347 PCHPredefinesBlock Block = {
1348 BufferID,
1349 llvm::StringRef(BlobStart, BlobLen - 1)
1350 };
1351 PCHPredefinesBuffers.push_back(Block);
Douglas Gregor92b059e2009-04-28 20:33:11 +00001352 }
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001353
1354 break;
1355 }
1356
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001357 case SM_SLOC_INSTANTIATION_ENTRY: {
Sebastian Redlc3632732010-10-05 15:59:54 +00001358 SourceLocation SpellingLoc = ReadSourceLocation(*F, Record[1]);
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001359 SourceMgr.createInstantiationLoc(SpellingLoc,
Sebastian Redlc3632732010-10-05 15:59:54 +00001360 ReadSourceLocation(*F, Record[2]),
1361 ReadSourceLocation(*F, Record[3]),
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001362 Record[4],
1363 ID,
1364 Record[0]);
1365 break;
Mike Stump1eb44332009-09-09 15:08:12 +00001366 }
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001367 }
1368
1369 return Success;
1370}
1371
Chris Lattner6367f6d2009-04-27 01:05:14 +00001372/// ReadBlockAbbrevs - Enter a subblock of the specified BlockID with the
1373/// specified cursor. Read the abbreviations that are at the top of the block
1374/// and then leave the cursor pointing into the block.
Sebastian Redlc43b54c2010-08-18 23:56:43 +00001375bool ASTReader::ReadBlockAbbrevs(llvm::BitstreamCursor &Cursor,
Chris Lattner6367f6d2009-04-27 01:05:14 +00001376 unsigned BlockID) {
1377 if (Cursor.EnterSubBlock(BlockID)) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001378 Error("malformed block record in AST file");
Chris Lattner6367f6d2009-04-27 01:05:14 +00001379 return Failure;
1380 }
Mike Stump1eb44332009-09-09 15:08:12 +00001381
Chris Lattner6367f6d2009-04-27 01:05:14 +00001382 while (true) {
Douglas Gregorecdcb882010-10-20 22:00:55 +00001383 uint64_t Offset = Cursor.GetCurrentBitNo();
Chris Lattner6367f6d2009-04-27 01:05:14 +00001384 unsigned Code = Cursor.ReadCode();
Michael J. Spencer20249a12010-10-21 03:16:25 +00001385
Chris Lattner6367f6d2009-04-27 01:05:14 +00001386 // We expect all abbrevs to be at the start of the block.
Douglas Gregorecdcb882010-10-20 22:00:55 +00001387 if (Code != llvm::bitc::DEFINE_ABBREV) {
1388 Cursor.JumpToBit(Offset);
Chris Lattner6367f6d2009-04-27 01:05:14 +00001389 return false;
Douglas Gregorecdcb882010-10-20 22:00:55 +00001390 }
Chris Lattner6367f6d2009-04-27 01:05:14 +00001391 Cursor.ReadAbbrevRecord();
1392 }
1393}
1394
Douglas Gregor89d99802010-11-30 06:16:57 +00001395PreprocessedEntity *ASTReader::ReadMacroRecord(PerFileData &F, uint64_t Offset) {
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00001396 assert(PP && "Forgot to set Preprocessor ?");
Douglas Gregorecdcb882010-10-20 22:00:55 +00001397 llvm::BitstreamCursor &Stream = F.MacroCursor;
Mike Stump1eb44332009-09-09 15:08:12 +00001398
Douglas Gregor37e26842009-04-21 23:56:24 +00001399 // Keep track of where we are in the stream, then jump back there
1400 // after reading this macro.
1401 SavedStreamPosition SavedPosition(Stream);
1402
1403 Stream.JumpToBit(Offset);
1404 RecordData Record;
1405 llvm::SmallVector<IdentifierInfo*, 16> MacroArgs;
1406 MacroInfo *Macro = 0;
Mike Stump1eb44332009-09-09 15:08:12 +00001407
Douglas Gregor37e26842009-04-21 23:56:24 +00001408 while (true) {
1409 unsigned Code = Stream.ReadCode();
1410 switch (Code) {
1411 case llvm::bitc::END_BLOCK:
Douglas Gregor89d99802010-11-30 06:16:57 +00001412 return 0;
Douglas Gregor37e26842009-04-21 23:56:24 +00001413
1414 case llvm::bitc::ENTER_SUBBLOCK:
1415 // No known subblocks, always skip them.
1416 Stream.ReadSubBlockID();
1417 if (Stream.SkipBlock()) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001418 Error("malformed block record in AST file");
Douglas Gregor89d99802010-11-30 06:16:57 +00001419 return 0;
Douglas Gregor37e26842009-04-21 23:56:24 +00001420 }
1421 continue;
Mike Stump1eb44332009-09-09 15:08:12 +00001422
Douglas Gregor37e26842009-04-21 23:56:24 +00001423 case llvm::bitc::DEFINE_ABBREV:
1424 Stream.ReadAbbrevRecord();
1425 continue;
1426 default: break;
1427 }
1428
1429 // Read a record.
Douglas Gregorecdcb882010-10-20 22:00:55 +00001430 const char *BlobStart = 0;
1431 unsigned BlobLen = 0;
Douglas Gregor37e26842009-04-21 23:56:24 +00001432 Record.clear();
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001433 PreprocessorRecordTypes RecType =
Michael J. Spencer20249a12010-10-21 03:16:25 +00001434 (PreprocessorRecordTypes)Stream.ReadRecord(Code, Record, BlobStart,
Douglas Gregorecdcb882010-10-20 22:00:55 +00001435 BlobLen);
Douglas Gregor37e26842009-04-21 23:56:24 +00001436 switch (RecType) {
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001437 case PP_MACRO_OBJECT_LIKE:
1438 case PP_MACRO_FUNCTION_LIKE: {
Douglas Gregor37e26842009-04-21 23:56:24 +00001439 // If we already have a macro, that means that we've hit the end
1440 // of the definition of the macro we were looking for. We're
1441 // done.
1442 if (Macro)
Douglas Gregor89d99802010-11-30 06:16:57 +00001443 return 0;
Douglas Gregor37e26842009-04-21 23:56:24 +00001444
1445 IdentifierInfo *II = DecodeIdentifierInfo(Record[0]);
1446 if (II == 0) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001447 Error("macro must have a name in AST file");
Douglas Gregor89d99802010-11-30 06:16:57 +00001448 return 0;
Douglas Gregor37e26842009-04-21 23:56:24 +00001449 }
Sebastian Redlc3632732010-10-05 15:59:54 +00001450 SourceLocation Loc = ReadSourceLocation(F, Record[1]);
Douglas Gregor37e26842009-04-21 23:56:24 +00001451 bool isUsed = Record[2];
Mike Stump1eb44332009-09-09 15:08:12 +00001452
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00001453 MacroInfo *MI = PP->AllocateMacroInfo(Loc);
Douglas Gregor37e26842009-04-21 23:56:24 +00001454 MI->setIsUsed(isUsed);
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001455 MI->setIsFromAST();
Mike Stump1eb44332009-09-09 15:08:12 +00001456
Douglas Gregor6a5a23f2010-03-19 21:51:54 +00001457 unsigned NextIndex = 3;
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001458 if (RecType == PP_MACRO_FUNCTION_LIKE) {
Douglas Gregor37e26842009-04-21 23:56:24 +00001459 // Decode function-like macro info.
1460 bool isC99VarArgs = Record[3];
1461 bool isGNUVarArgs = Record[4];
1462 MacroArgs.clear();
1463 unsigned NumArgs = Record[5];
Douglas Gregor6a5a23f2010-03-19 21:51:54 +00001464 NextIndex = 6 + NumArgs;
Douglas Gregor37e26842009-04-21 23:56:24 +00001465 for (unsigned i = 0; i != NumArgs; ++i)
1466 MacroArgs.push_back(DecodeIdentifierInfo(Record[6+i]));
1467
1468 // Install function-like macro info.
1469 MI->setIsFunctionLike();
1470 if (isC99VarArgs) MI->setIsC99Varargs();
1471 if (isGNUVarArgs) MI->setIsGNUVarargs();
Douglas Gregor75fdb232009-05-22 22:45:36 +00001472 MI->setArgumentList(MacroArgs.data(), MacroArgs.size(),
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00001473 PP->getPreprocessorAllocator());
Douglas Gregor37e26842009-04-21 23:56:24 +00001474 }
1475
1476 // Finally, install the macro.
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00001477 PP->setMacroInfo(II, MI);
Douglas Gregor37e26842009-04-21 23:56:24 +00001478
1479 // Remember that we saw this macro last so that we add the tokens that
1480 // form its body to it.
1481 Macro = MI;
Michael J. Spencer20249a12010-10-21 03:16:25 +00001482
Douglas Gregor6a5a23f2010-03-19 21:51:54 +00001483 if (NextIndex + 1 == Record.size() && PP->getPreprocessingRecord()) {
1484 // We have a macro definition. Load it now.
1485 PP->getPreprocessingRecord()->RegisterMacroDefinition(Macro,
1486 getMacroDefinition(Record[NextIndex]));
1487 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00001488
Douglas Gregor37e26842009-04-21 23:56:24 +00001489 ++NumMacrosRead;
1490 break;
1491 }
Mike Stump1eb44332009-09-09 15:08:12 +00001492
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001493 case PP_TOKEN: {
Douglas Gregor37e26842009-04-21 23:56:24 +00001494 // If we see a TOKEN before a PP_MACRO_*, then the file is
1495 // erroneous, just pretend we didn't see this.
1496 if (Macro == 0) break;
Mike Stump1eb44332009-09-09 15:08:12 +00001497
Douglas Gregor37e26842009-04-21 23:56:24 +00001498 Token Tok;
1499 Tok.startToken();
Sebastian Redlc3632732010-10-05 15:59:54 +00001500 Tok.setLocation(ReadSourceLocation(F, Record[0]));
Douglas Gregor37e26842009-04-21 23:56:24 +00001501 Tok.setLength(Record[1]);
1502 if (IdentifierInfo *II = DecodeIdentifierInfo(Record[2]))
1503 Tok.setIdentifierInfo(II);
1504 Tok.setKind((tok::TokenKind)Record[3]);
1505 Tok.setFlag((Token::TokenFlags)Record[4]);
1506 Macro->AddTokenToBody(Tok);
1507 break;
1508 }
Douglas Gregor4800a5c2011-02-08 21:58:10 +00001509 }
Douglas Gregor37e26842009-04-21 23:56:24 +00001510 }
Douglas Gregor89d99802010-11-30 06:16:57 +00001511
1512 return 0;
Douglas Gregor37e26842009-04-21 23:56:24 +00001513}
1514
Douglas Gregor4800a5c2011-02-08 21:58:10 +00001515PreprocessedEntity *ASTReader::LoadPreprocessedEntity(PerFileData &F) {
1516 assert(PP && "Forgot to set Preprocessor ?");
1517 unsigned Code = F.PreprocessorDetailCursor.ReadCode();
1518 switch (Code) {
1519 case llvm::bitc::END_BLOCK:
1520 return 0;
1521
1522 case llvm::bitc::ENTER_SUBBLOCK:
1523 Error("unexpected subblock record in preprocessor detail block");
1524 return 0;
1525
1526 case llvm::bitc::DEFINE_ABBREV:
1527 Error("unexpected abbrevation record in preprocessor detail block");
1528 return 0;
1529
1530 default:
1531 break;
1532 }
1533
1534 if (!PP->getPreprocessingRecord()) {
1535 Error("no preprocessing record");
1536 return 0;
1537 }
1538
1539 // Read the record.
1540 PreprocessingRecord &PPRec = *PP->getPreprocessingRecord();
1541 const char *BlobStart = 0;
1542 unsigned BlobLen = 0;
1543 RecordData Record;
1544 PreprocessorDetailRecordTypes RecType =
1545 (PreprocessorDetailRecordTypes)F.PreprocessorDetailCursor.ReadRecord(
1546 Code, Record, BlobStart, BlobLen);
1547 switch (RecType) {
1548 case PPD_MACRO_INSTANTIATION: {
1549 if (PreprocessedEntity *PE = PPRec.getPreprocessedEntity(Record[0]))
1550 return PE;
1551
1552 MacroInstantiation *MI
1553 = new (PPRec) MacroInstantiation(DecodeIdentifierInfo(Record[3]),
1554 SourceRange(ReadSourceLocation(F, Record[1]),
1555 ReadSourceLocation(F, Record[2])),
1556 getMacroDefinition(Record[4]));
1557 PPRec.SetPreallocatedEntity(Record[0], MI);
1558 return MI;
1559 }
1560
1561 case PPD_MACRO_DEFINITION: {
1562 if (PreprocessedEntity *PE = PPRec.getPreprocessedEntity(Record[0]))
1563 return PE;
1564
1565 if (Record[1] > MacroDefinitionsLoaded.size()) {
1566 Error("out-of-bounds macro definition record");
1567 return 0;
1568 }
1569
1570 // Decode the identifier info and then check again; if the macro is
1571 // still defined and associated with the identifier,
1572 IdentifierInfo *II = DecodeIdentifierInfo(Record[4]);
1573 if (!MacroDefinitionsLoaded[Record[1] - 1]) {
1574 MacroDefinition *MD
1575 = new (PPRec) MacroDefinition(II,
1576 ReadSourceLocation(F, Record[5]),
1577 SourceRange(
1578 ReadSourceLocation(F, Record[2]),
1579 ReadSourceLocation(F, Record[3])));
1580
1581 PPRec.SetPreallocatedEntity(Record[0], MD);
1582 MacroDefinitionsLoaded[Record[1] - 1] = MD;
1583
1584 if (DeserializationListener)
1585 DeserializationListener->MacroDefinitionRead(Record[1], MD);
1586 }
1587
1588 return MacroDefinitionsLoaded[Record[1] - 1];
1589 }
1590
1591 case PPD_INCLUSION_DIRECTIVE: {
1592 if (PreprocessedEntity *PE = PPRec.getPreprocessedEntity(Record[0]))
1593 return PE;
1594
1595 const char *FullFileNameStart = BlobStart + Record[3];
1596 const FileEntry *File
1597 = PP->getFileManager().getFile(llvm::StringRef(FullFileNameStart,
1598 BlobLen - Record[3]));
1599
1600 // FIXME: Stable encoding
1601 InclusionDirective::InclusionKind Kind
1602 = static_cast<InclusionDirective::InclusionKind>(Record[5]);
1603 InclusionDirective *ID
1604 = new (PPRec) InclusionDirective(PPRec, Kind,
1605 llvm::StringRef(BlobStart, Record[3]),
1606 Record[4],
1607 File,
1608 SourceRange(ReadSourceLocation(F, Record[1]),
1609 ReadSourceLocation(F, Record[2])));
1610 PPRec.SetPreallocatedEntity(Record[0], ID);
1611 return ID;
1612 }
1613 }
1614
1615 Error("invalid offset in preprocessor detail block");
1616 return 0;
1617}
1618
Douglas Gregorcfbf1c72011-02-10 17:09:37 +00001619namespace {
1620 /// \brief Trait class used to search the on-disk hash table containing all of
1621 /// the header search information.
1622 ///
1623 /// The on-disk hash table contains a mapping from each header path to
1624 /// information about that header (how many times it has been included, its
1625 /// controlling macro, etc.). Note that we actually hash based on the
1626 /// filename, and support "deep" comparisons of file names based on current
1627 /// inode numbers, so that the search can cope with non-normalized path names
1628 /// and symlinks.
1629 class HeaderFileInfoTrait {
1630 const char *SearchPath;
1631 struct stat SearchPathStatBuf;
1632 llvm::Optional<int> SearchPathStatResult;
1633
1634 int StatSimpleCache(const char *Path, struct stat *StatBuf) {
1635 if (Path == SearchPath) {
1636 if (!SearchPathStatResult)
1637 SearchPathStatResult = stat(Path, &SearchPathStatBuf);
1638
1639 *StatBuf = SearchPathStatBuf;
1640 return *SearchPathStatResult;
1641 }
1642
1643 return stat(Path, StatBuf);
1644 }
1645
1646 public:
1647 typedef const char *external_key_type;
1648 typedef const char *internal_key_type;
1649
1650 typedef HeaderFileInfo data_type;
1651
1652 HeaderFileInfoTrait(const char *SearchPath = 0) : SearchPath(SearchPath) { }
1653
1654 static unsigned ComputeHash(const char *path) {
1655 return llvm::HashString(llvm::sys::path::filename(path));
1656 }
1657
1658 static internal_key_type GetInternalKey(const char *path) { return path; }
1659
1660 bool EqualKey(internal_key_type a, internal_key_type b) {
1661 if (strcmp(a, b) == 0)
1662 return true;
1663
1664 if (llvm::sys::path::filename(a) != llvm::sys::path::filename(b))
1665 return false;
1666
1667 // The file names match, but the path names don't. stat() the files to
1668 // see if they are the same.
1669 struct stat StatBufA, StatBufB;
1670 if (StatSimpleCache(a, &StatBufA) || StatSimpleCache(b, &StatBufB))
1671 return false;
1672
1673 return StatBufA.st_ino == StatBufB.st_ino;
1674 }
1675
1676 static std::pair<unsigned, unsigned>
1677 ReadKeyDataLength(const unsigned char*& d) {
1678 unsigned KeyLen = (unsigned) clang::io::ReadUnalignedLE16(d);
1679 unsigned DataLen = (unsigned) *d++;
1680 return std::make_pair(KeyLen + 1, DataLen);
1681 }
1682
1683 static internal_key_type ReadKey(const unsigned char *d, unsigned) {
1684 return (const char *)d;
1685 }
1686
1687 static data_type ReadData(const internal_key_type, const unsigned char *d,
1688 unsigned DataLen) {
1689 const unsigned char *End = d + DataLen;
1690 using namespace clang::io;
1691 HeaderFileInfo HFI;
1692 unsigned Flags = *d++;
1693 HFI.isImport = (Flags >> 3) & 0x01;
1694 HFI.DirInfo = (Flags >> 1) & 0x03;
1695 HFI.Resolved = Flags & 0x01;
1696 HFI.NumIncludes = ReadUnalignedLE16(d);
1697 HFI.ControllingMacroID = ReadUnalignedLE32(d);
1698 assert(End == d && "Wrong data length in HeaderFileInfo deserialization");
1699 (void)End;
1700
1701 // This HeaderFileInfo was externally loaded.
1702 HFI.External = true;
1703 return HFI;
1704 }
1705 };
1706}
1707
1708/// \brief The on-disk hash table used for the global method pool.
1709typedef OnDiskChainedHashTable<HeaderFileInfoTrait>
1710 HeaderFileInfoLookupTable;
1711
Douglas Gregor295a2a62010-10-30 00:23:06 +00001712void ASTReader::SetIdentifierIsMacro(IdentifierInfo *II, PerFileData &F,
1713 uint64_t Offset) {
1714 // Note that this identifier has a macro definition.
1715 II->setHasMacroDefinition(true);
1716
1717 // Adjust the offset based on our position in the chain.
1718 for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
1719 if (Chain[I] == &F)
1720 break;
1721
1722 Offset += Chain[I]->SizeInBits;
1723 }
1724
1725 UnreadMacroRecordOffsets[II] = Offset;
1726}
1727
Sebastian Redlc43b54c2010-08-18 23:56:43 +00001728void ASTReader::ReadDefinedMacros() {
Sebastian Redld27d3fc2010-07-21 22:31:37 +00001729 for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
Sebastian Redlc3632732010-10-05 15:59:54 +00001730 PerFileData &F = *Chain[N - I - 1];
1731 llvm::BitstreamCursor &MacroCursor = F.MacroCursor;
Sebastian Redl9137a522010-07-16 17:50:48 +00001732
Sebastian Redld27d3fc2010-07-21 22:31:37 +00001733 // If there was no preprocessor block, skip this file.
1734 if (!MacroCursor.getBitStreamReader())
1735 continue;
Kovarththanan Rajaratnam6b82f642010-03-07 19:10:13 +00001736
Sebastian Redld27d3fc2010-07-21 22:31:37 +00001737 llvm::BitstreamCursor Cursor = MacroCursor;
Douglas Gregorecdcb882010-10-20 22:00:55 +00001738 Cursor.JumpToBit(F.MacroStartOffset);
Michael J. Spencer20249a12010-10-21 03:16:25 +00001739
Sebastian Redld27d3fc2010-07-21 22:31:37 +00001740 RecordData Record;
1741 while (true) {
1742 unsigned Code = Cursor.ReadCode();
Douglas Gregorecdcb882010-10-20 22:00:55 +00001743 if (Code == llvm::bitc::END_BLOCK)
Sebastian Redld27d3fc2010-07-21 22:31:37 +00001744 break;
Kovarththanan Rajaratnam6b82f642010-03-07 19:10:13 +00001745
Sebastian Redld27d3fc2010-07-21 22:31:37 +00001746 if (Code == llvm::bitc::ENTER_SUBBLOCK) {
1747 // No known subblocks, always skip them.
1748 Cursor.ReadSubBlockID();
1749 if (Cursor.SkipBlock()) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001750 Error("malformed block record in AST file");
Sebastian Redld27d3fc2010-07-21 22:31:37 +00001751 return;
1752 }
1753 continue;
1754 }
Kovarththanan Rajaratnam6b82f642010-03-07 19:10:13 +00001755
Sebastian Redld27d3fc2010-07-21 22:31:37 +00001756 if (Code == llvm::bitc::DEFINE_ABBREV) {
1757 Cursor.ReadAbbrevRecord();
1758 continue;
1759 }
Kovarththanan Rajaratnam6b82f642010-03-07 19:10:13 +00001760
Sebastian Redld27d3fc2010-07-21 22:31:37 +00001761 // Read a record.
1762 const char *BlobStart;
1763 unsigned BlobLen;
1764 Record.clear();
1765 switch (Cursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) {
1766 default: // Default behavior: ignore.
1767 break;
Douglas Gregor88a35862010-01-04 19:18:44 +00001768
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001769 case PP_MACRO_OBJECT_LIKE:
1770 case PP_MACRO_FUNCTION_LIKE:
Sebastian Redld27d3fc2010-07-21 22:31:37 +00001771 DecodeIdentifierInfo(Record[0]);
1772 break;
1773
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001774 case PP_TOKEN:
Sebastian Redld27d3fc2010-07-21 22:31:37 +00001775 // Ignore tokens.
1776 break;
Sebastian Redld27d3fc2010-07-21 22:31:37 +00001777 }
Douglas Gregor88a35862010-01-04 19:18:44 +00001778 }
1779 }
Douglas Gregor295a2a62010-10-30 00:23:06 +00001780
1781 // Drain the unread macro-record offsets map.
1782 while (!UnreadMacroRecordOffsets.empty())
1783 LoadMacroDefinition(UnreadMacroRecordOffsets.begin());
1784}
1785
1786void ASTReader::LoadMacroDefinition(
1787 llvm::DenseMap<IdentifierInfo *, uint64_t>::iterator Pos) {
1788 assert(Pos != UnreadMacroRecordOffsets.end() && "Unknown macro definition");
1789 PerFileData *F = 0;
1790 uint64_t Offset = Pos->second;
1791 UnreadMacroRecordOffsets.erase(Pos);
1792
1793 for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
1794 if (Offset < Chain[I]->SizeInBits) {
1795 F = Chain[I];
1796 break;
1797 }
1798
1799 Offset -= Chain[I]->SizeInBits;
1800 }
1801 if (!F) {
1802 Error("Malformed macro record offset");
1803 return;
1804 }
1805
1806 ReadMacroRecord(*F, Offset);
1807}
1808
1809void ASTReader::LoadMacroDefinition(IdentifierInfo *II) {
1810 llvm::DenseMap<IdentifierInfo *, uint64_t>::iterator Pos
1811 = UnreadMacroRecordOffsets.find(II);
1812 LoadMacroDefinition(Pos);
Douglas Gregor88a35862010-01-04 19:18:44 +00001813}
1814
Sebastian Redlf73c93f2010-09-15 19:54:06 +00001815MacroDefinition *ASTReader::getMacroDefinition(MacroID ID) {
Douglas Gregor77424bc2010-10-02 19:29:26 +00001816 if (ID == 0 || ID > MacroDefinitionsLoaded.size())
Douglas Gregor6a5a23f2010-03-19 21:51:54 +00001817 return 0;
Sebastian Redld27d3fc2010-07-21 22:31:37 +00001818
Douglas Gregor77424bc2010-10-02 19:29:26 +00001819 if (!MacroDefinitionsLoaded[ID - 1]) {
1820 unsigned Index = ID - 1;
Sebastian Redld27d3fc2010-07-21 22:31:37 +00001821 for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
1822 PerFileData &F = *Chain[N - I - 1];
1823 if (Index < F.LocalNumMacroDefinitions) {
Douglas Gregor4800a5c2011-02-08 21:58:10 +00001824 SavedStreamPosition SavedPosition(F.PreprocessorDetailCursor);
1825 F.PreprocessorDetailCursor.JumpToBit(F.MacroDefinitionOffsets[Index]);
1826 LoadPreprocessedEntity(F);
Sebastian Redld27d3fc2010-07-21 22:31:37 +00001827 break;
1828 }
1829 Index -= F.LocalNumMacroDefinitions;
1830 }
Douglas Gregor77424bc2010-10-02 19:29:26 +00001831 assert(MacroDefinitionsLoaded[ID - 1] && "Broken chain");
Sebastian Redld27d3fc2010-07-21 22:31:37 +00001832 }
1833
Douglas Gregor77424bc2010-10-02 19:29:26 +00001834 return MacroDefinitionsLoaded[ID - 1];
Douglas Gregor6a5a23f2010-03-19 21:51:54 +00001835}
1836
Douglas Gregore650c8c2009-07-07 00:12:59 +00001837/// \brief If we are loading a relocatable PCH file, and the filename is
1838/// not an absolute path, add the system root to the beginning of the file
1839/// name.
Sebastian Redlc43b54c2010-08-18 23:56:43 +00001840void ASTReader::MaybeAddSystemRootToFilename(std::string &Filename) {
Douglas Gregore650c8c2009-07-07 00:12:59 +00001841 // If this is not a relocatable PCH file, there's nothing to do.
1842 if (!RelocatablePCH)
1843 return;
Mike Stump1eb44332009-09-09 15:08:12 +00001844
Michael J. Spencer256053b2010-12-17 21:22:22 +00001845 if (Filename.empty() || llvm::sys::path::is_absolute(Filename))
Douglas Gregore650c8c2009-07-07 00:12:59 +00001846 return;
1847
Douglas Gregore650c8c2009-07-07 00:12:59 +00001848 if (isysroot == 0) {
1849 // If no system root was given, default to '/'
1850 Filename.insert(Filename.begin(), '/');
1851 return;
1852 }
Mike Stump1eb44332009-09-09 15:08:12 +00001853
Douglas Gregore650c8c2009-07-07 00:12:59 +00001854 unsigned Length = strlen(isysroot);
1855 if (isysroot[Length - 1] != '/')
1856 Filename.insert(Filename.begin(), '/');
Mike Stump1eb44332009-09-09 15:08:12 +00001857
Douglas Gregore650c8c2009-07-07 00:12:59 +00001858 Filename.insert(Filename.begin(), isysroot, isysroot + Length);
1859}
1860
Sebastian Redlc43b54c2010-08-18 23:56:43 +00001861ASTReader::ASTReadResult
Sebastian Redl571db7f2010-08-18 23:56:56 +00001862ASTReader::ReadASTBlock(PerFileData &F) {
Sebastian Redl9137a522010-07-16 17:50:48 +00001863 llvm::BitstreamCursor &Stream = F.Stream;
1864
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001865 if (Stream.EnterSubBlock(AST_BLOCK_ID)) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001866 Error("malformed block record in AST file");
Douglas Gregor0a0428e2009-04-10 20:39:37 +00001867 return Failure;
1868 }
Douglas Gregor2cf26342009-04-09 22:27:44 +00001869
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001870 // Read all of the records and blocks for the ASt file.
Douglas Gregor8038d512009-04-10 17:25:41 +00001871 RecordData Record;
Sebastian Redl93fb9ed2010-07-19 20:52:06 +00001872 bool First = true;
Douglas Gregor2cf26342009-04-09 22:27:44 +00001873 while (!Stream.AtEndOfStream()) {
1874 unsigned Code = Stream.ReadCode();
1875 if (Code == llvm::bitc::END_BLOCK) {
Douglas Gregor0a0428e2009-04-10 20:39:37 +00001876 if (Stream.ReadBlockEnd()) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001877 Error("error at end of module block in AST file");
Douglas Gregor0a0428e2009-04-10 20:39:37 +00001878 return Failure;
1879 }
Chris Lattner7356a312009-04-11 21:15:38 +00001880
Douglas Gregor0a0428e2009-04-10 20:39:37 +00001881 return Success;
Douglas Gregor2cf26342009-04-09 22:27:44 +00001882 }
1883
1884 if (Code == llvm::bitc::ENTER_SUBBLOCK) {
1885 switch (Stream.ReadSubBlockID()) {
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001886 case DECLTYPES_BLOCK_ID:
Chris Lattner6367f6d2009-04-27 01:05:14 +00001887 // We lazily load the decls block, but we want to set up the
1888 // DeclsCursor cursor to point into it. Clone our current bitcode
1889 // cursor to it, enter the block and read the abbrevs in that block.
1890 // With the main cursor, we just skip over it.
Sebastian Redl9137a522010-07-16 17:50:48 +00001891 F.DeclsCursor = Stream;
Chris Lattner6367f6d2009-04-27 01:05:14 +00001892 if (Stream.SkipBlock() || // Skip with the main cursor.
1893 // Read the abbrevs.
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001894 ReadBlockAbbrevs(F.DeclsCursor, DECLTYPES_BLOCK_ID)) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001895 Error("malformed block record in AST file");
Chris Lattner6367f6d2009-04-27 01:05:14 +00001896 return Failure;
1897 }
1898 break;
Mike Stump1eb44332009-09-09 15:08:12 +00001899
Argyrios Kyrtzidis7b903402010-10-24 17:26:36 +00001900 case DECL_UPDATES_BLOCK_ID:
1901 if (Stream.SkipBlock()) {
1902 Error("malformed block record in AST file");
1903 return Failure;
1904 }
1905 break;
1906
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001907 case PREPROCESSOR_BLOCK_ID:
Sebastian Redl9137a522010-07-16 17:50:48 +00001908 F.MacroCursor = Stream;
Douglas Gregor88a35862010-01-04 19:18:44 +00001909 if (PP)
1910 PP->setExternalSource(this);
1911
Douglas Gregorecdcb882010-10-20 22:00:55 +00001912 if (Stream.SkipBlock() ||
1913 ReadBlockAbbrevs(F.MacroCursor, PREPROCESSOR_BLOCK_ID)) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001914 Error("malformed block record in AST file");
Chris Lattner7356a312009-04-11 21:15:38 +00001915 return Failure;
1916 }
Douglas Gregorecdcb882010-10-20 22:00:55 +00001917 F.MacroStartOffset = F.MacroCursor.GetCurrentBitNo();
Chris Lattner7356a312009-04-11 21:15:38 +00001918 break;
Steve Naroff90cd1bb2009-04-23 10:39:46 +00001919
Douglas Gregor4800a5c2011-02-08 21:58:10 +00001920 case PREPROCESSOR_DETAIL_BLOCK_ID:
1921 F.PreprocessorDetailCursor = Stream;
1922 if (Stream.SkipBlock() ||
1923 ReadBlockAbbrevs(F.PreprocessorDetailCursor,
1924 PREPROCESSOR_DETAIL_BLOCK_ID)) {
1925 Error("malformed preprocessor detail record in AST file");
1926 return Failure;
1927 }
1928 F.PreprocessorDetailStartOffset
1929 = F.PreprocessorDetailCursor.GetCurrentBitNo();
1930 break;
1931
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001932 case SOURCE_MANAGER_BLOCK_ID:
Sebastian Redl93fb9ed2010-07-19 20:52:06 +00001933 switch (ReadSourceManagerBlock(F)) {
Douglas Gregore1d918e2009-04-10 23:10:45 +00001934 case Success:
1935 break;
1936
1937 case Failure:
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001938 Error("malformed source manager block in AST file");
Douglas Gregor0a0428e2009-04-10 20:39:37 +00001939 return Failure;
Douglas Gregore1d918e2009-04-10 23:10:45 +00001940
1941 case IgnorePCH:
1942 return IgnorePCH;
Douglas Gregor0a0428e2009-04-10 20:39:37 +00001943 }
Douglas Gregor14f79002009-04-10 03:52:48 +00001944 break;
Douglas Gregor2cf26342009-04-09 22:27:44 +00001945 }
Sebastian Redl93fb9ed2010-07-19 20:52:06 +00001946 First = false;
Douglas Gregor8038d512009-04-10 17:25:41 +00001947 continue;
1948 }
1949
1950 if (Code == llvm::bitc::DEFINE_ABBREV) {
1951 Stream.ReadAbbrevRecord();
1952 continue;
1953 }
1954
1955 // Read and process a record.
1956 Record.clear();
Douglas Gregor2bec0412009-04-10 21:16:55 +00001957 const char *BlobStart = 0;
1958 unsigned BlobLen = 0;
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001959 switch ((ASTRecordTypes)Stream.ReadRecord(Code, Record,
Sebastian Redlc3632732010-10-05 15:59:54 +00001960 &BlobStart, &BlobLen)) {
Douglas Gregor8038d512009-04-10 17:25:41 +00001961 default: // Default behavior: ignore.
1962 break;
1963
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001964 case METADATA: {
1965 if (Record[0] != VERSION_MAJOR && !DisableValidation) {
1966 Diag(Record[0] < VERSION_MAJOR? diag::warn_pch_version_too_old
Sebastian Redlfbd4bf12010-07-17 00:12:06 +00001967 : diag::warn_pch_version_too_new);
1968 return IgnorePCH;
1969 }
1970
1971 RelocatablePCH = Record[4];
1972 if (Listener) {
1973 std::string TargetTriple(BlobStart, BlobLen);
1974 if (Listener->ReadTargetTriple(TargetTriple))
1975 return IgnorePCH;
1976 }
1977 break;
1978 }
1979
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001980 case CHAINED_METADATA: {
Sebastian Redl93fb9ed2010-07-19 20:52:06 +00001981 if (!First) {
1982 Error("CHAINED_METADATA is not first record in block");
1983 return Failure;
1984 }
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001985 if (Record[0] != VERSION_MAJOR && !DisableValidation) {
1986 Diag(Record[0] < VERSION_MAJOR? diag::warn_pch_version_too_old
Sebastian Redlfbd4bf12010-07-17 00:12:06 +00001987 : diag::warn_pch_version_too_new);
1988 return IgnorePCH;
1989 }
1990
Sebastian Redl1d9f1fe2010-10-05 16:15:19 +00001991 // Load the chained file, which is always a PCH file.
1992 switch(ReadASTCore(llvm::StringRef(BlobStart, BlobLen), PCH)) {
Sebastian Redlfbd4bf12010-07-17 00:12:06 +00001993 case Failure: return Failure;
1994 // If we have to ignore the dependency, we'll have to ignore this too.
1995 case IgnorePCH: return IgnorePCH;
1996 case Success: break;
1997 }
1998 break;
1999 }
2000
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002001 case TYPE_OFFSET:
Sebastian Redl12d6da02010-07-19 22:06:55 +00002002 if (F.LocalNumTypes != 0) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002003 Error("duplicate TYPE_OFFSET record in AST file");
Douglas Gregor0a0428e2009-04-10 20:39:37 +00002004 return Failure;
2005 }
Sebastian Redl12d6da02010-07-19 22:06:55 +00002006 F.TypeOffsets = (const uint32_t *)BlobStart;
2007 F.LocalNumTypes = Record[0];
Douglas Gregor8038d512009-04-10 17:25:41 +00002008 break;
2009
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002010 case DECL_OFFSET:
Sebastian Redl12d6da02010-07-19 22:06:55 +00002011 if (F.LocalNumDecls != 0) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002012 Error("duplicate DECL_OFFSET record in AST file");
Douglas Gregor0a0428e2009-04-10 20:39:37 +00002013 return Failure;
2014 }
Sebastian Redl12d6da02010-07-19 22:06:55 +00002015 F.DeclOffsets = (const uint32_t *)BlobStart;
2016 F.LocalNumDecls = Record[0];
Douglas Gregor8038d512009-04-10 17:25:41 +00002017 break;
Douglas Gregor0a0428e2009-04-10 20:39:37 +00002018
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002019 case TU_UPDATE_LEXICAL: {
Sebastian Redld692af72010-07-27 18:24:41 +00002020 DeclContextInfo Info = {
Argyrios Kyrtzidis074dcc82010-08-20 16:04:35 +00002021 /* No visible information */ 0,
Argyrios Kyrtzidiseb5e9982010-10-14 20:14:34 +00002022 reinterpret_cast<const KindDeclIDPair *>(BlobStart),
2023 BlobLen / sizeof(KindDeclIDPair)
Sebastian Redld692af72010-07-27 18:24:41 +00002024 };
Douglas Gregor3747ee72010-10-01 01:18:02 +00002025 DeclContextOffsets[Context ? Context->getTranslationUnitDecl() : 0]
2026 .push_back(Info);
Sebastian Redld692af72010-07-27 18:24:41 +00002027 break;
2028 }
2029
Sebastian Redle1dde812010-08-24 00:50:04 +00002030 case UPDATE_VISIBLE: {
2031 serialization::DeclID ID = Record[0];
2032 void *Table = ASTDeclContextNameLookupTable::Create(
2033 (const unsigned char *)BlobStart + Record[1],
2034 (const unsigned char *)BlobStart,
2035 ASTDeclContextNameLookupTrait(*this));
Douglas Gregor3747ee72010-10-01 01:18:02 +00002036 if (ID == 1 && Context) { // Is it the TU?
Sebastian Redle1dde812010-08-24 00:50:04 +00002037 DeclContextInfo Info = {
2038 Table, /* No lexical inforamtion */ 0, 0
2039 };
2040 DeclContextOffsets[Context->getTranslationUnitDecl()].push_back(Info);
2041 } else
2042 PendingVisibleUpdates[ID].push_back(Table);
2043 break;
2044 }
2045
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002046 case REDECLS_UPDATE_LATEST: {
Argyrios Kyrtzidisa8650052010-08-03 17:30:10 +00002047 assert(Record.size() % 2 == 0 && "Expected pairs of DeclIDs");
2048 for (unsigned i = 0, e = Record.size(); i < e; i += 2) {
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002049 DeclID First = Record[i], Latest = Record[i+1];
Argyrios Kyrtzidisa8650052010-08-03 17:30:10 +00002050 assert((FirstLatestDeclIDs.find(First) == FirstLatestDeclIDs.end() ||
2051 Latest > FirstLatestDeclIDs[First]) &&
2052 "The new latest is supposed to come after the previous latest");
2053 FirstLatestDeclIDs[First] = Latest;
2054 }
2055 break;
2056 }
2057
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002058 case LANGUAGE_OPTIONS:
Douglas Gregorfae3b2f2010-07-27 00:27:13 +00002059 if (ParseLanguageOptions(Record) && !DisableValidation)
Douglas Gregor0a0428e2009-04-10 20:39:37 +00002060 return IgnorePCH;
2061 break;
Douglas Gregor2bec0412009-04-10 21:16:55 +00002062
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002063 case IDENTIFIER_TABLE:
Sebastian Redl93fb9ed2010-07-19 20:52:06 +00002064 F.IdentifierTableData = BlobStart;
Douglas Gregor2b3a5a82009-04-25 19:10:14 +00002065 if (Record[0]) {
Sebastian Redl93fb9ed2010-07-19 20:52:06 +00002066 F.IdentifierLookupTable
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002067 = ASTIdentifierLookupTable::Create(
Sebastian Redl93fb9ed2010-07-19 20:52:06 +00002068 (const unsigned char *)F.IdentifierTableData + Record[0],
2069 (const unsigned char *)F.IdentifierTableData,
Sebastian Redlc3632732010-10-05 15:59:54 +00002070 ASTIdentifierLookupTrait(*this, F));
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00002071 if (PP)
2072 PP->getIdentifierTable().setExternalIdentifierLookup(this);
Douglas Gregor2b3a5a82009-04-25 19:10:14 +00002073 }
Douglas Gregorafaf3082009-04-11 00:14:32 +00002074 break;
2075
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002076 case IDENTIFIER_OFFSET:
Sebastian Redl2da08f92010-07-19 22:28:42 +00002077 if (F.LocalNumIdentifiers != 0) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002078 Error("duplicate IDENTIFIER_OFFSET record in AST file");
Douglas Gregorafaf3082009-04-11 00:14:32 +00002079 return Failure;
2080 }
Sebastian Redl2da08f92010-07-19 22:28:42 +00002081 F.IdentifierOffsets = (const uint32_t *)BlobStart;
2082 F.LocalNumIdentifiers = Record[0];
Douglas Gregorafaf3082009-04-11 00:14:32 +00002083 break;
Douglas Gregorfdd01722009-04-14 00:24:19 +00002084
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002085 case EXTERNAL_DEFINITIONS:
Sebastian Redl518d8cb2010-07-20 21:20:32 +00002086 // Optimization for the first block.
2087 if (ExternalDefinitions.empty())
2088 ExternalDefinitions.swap(Record);
2089 else
2090 ExternalDefinitions.insert(ExternalDefinitions.end(),
2091 Record.begin(), Record.end());
Douglas Gregorfdd01722009-04-14 00:24:19 +00002092 break;
Douglas Gregor3e1af842009-04-17 22:13:46 +00002093
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002094 case SPECIAL_TYPES:
Sebastian Redl518d8cb2010-07-20 21:20:32 +00002095 // Optimization for the first block
2096 if (SpecialTypes.empty())
2097 SpecialTypes.swap(Record);
2098 else
2099 SpecialTypes.insert(SpecialTypes.end(), Record.begin(), Record.end());
Douglas Gregorad1de002009-04-18 05:55:16 +00002100 break;
2101
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002102 case STATISTICS:
Sebastian Redl518d8cb2010-07-20 21:20:32 +00002103 TotalNumStatements += Record[0];
2104 TotalNumMacros += Record[1];
2105 TotalLexicalDeclContexts += Record[2];
2106 TotalVisibleDeclContexts += Record[3];
Douglas Gregor3e1af842009-04-17 22:13:46 +00002107 break;
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00002108
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002109 case TENTATIVE_DEFINITIONS:
Sebastian Redl518d8cb2010-07-20 21:20:32 +00002110 // Optimization for the first block.
2111 if (TentativeDefinitions.empty())
2112 TentativeDefinitions.swap(Record);
2113 else
2114 TentativeDefinitions.insert(TentativeDefinitions.end(),
2115 Record.begin(), Record.end());
Douglas Gregor4c0e86b2009-04-22 22:02:47 +00002116 break;
Douglas Gregor14c22f22009-04-22 22:18:58 +00002117
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002118 case UNUSED_FILESCOPED_DECLS:
Sebastian Redl518d8cb2010-07-20 21:20:32 +00002119 // Optimization for the first block.
Argyrios Kyrtzidis49b96d12010-08-13 18:42:17 +00002120 if (UnusedFileScopedDecls.empty())
2121 UnusedFileScopedDecls.swap(Record);
Sebastian Redl518d8cb2010-07-20 21:20:32 +00002122 else
Argyrios Kyrtzidis49b96d12010-08-13 18:42:17 +00002123 UnusedFileScopedDecls.insert(UnusedFileScopedDecls.end(),
2124 Record.begin(), Record.end());
Tanya Lattnere6bbc012010-02-12 00:07:30 +00002125 break;
Kovarththanan Rajaratnam6b82f642010-03-07 19:10:13 +00002126
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002127 case WEAK_UNDECLARED_IDENTIFIERS:
Sebastian Redl40566802010-08-05 18:21:25 +00002128 // Later blocks overwrite earlier ones.
2129 WeakUndeclaredIdentifiers.swap(Record);
Argyrios Kyrtzidis72b90572010-08-05 09:48:08 +00002130 break;
2131
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002132 case LOCALLY_SCOPED_EXTERNAL_DECLS:
Sebastian Redl518d8cb2010-07-20 21:20:32 +00002133 // Optimization for the first block.
2134 if (LocallyScopedExternalDecls.empty())
2135 LocallyScopedExternalDecls.swap(Record);
2136 else
2137 LocallyScopedExternalDecls.insert(LocallyScopedExternalDecls.end(),
2138 Record.begin(), Record.end());
Douglas Gregor14c22f22009-04-22 22:18:58 +00002139 break;
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +00002140
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002141 case SELECTOR_OFFSETS:
Sebastian Redl059612d2010-08-03 21:58:15 +00002142 F.SelectorOffsets = (const uint32_t *)BlobStart;
Sebastian Redl725cd962010-08-04 20:40:17 +00002143 F.LocalNumSelectors = Record[0];
Douglas Gregor83941df2009-04-25 17:48:32 +00002144 break;
2145
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002146 case METHOD_POOL:
Sebastian Redl725cd962010-08-04 20:40:17 +00002147 F.SelectorLookupTableData = (const unsigned char *)BlobStart;
Douglas Gregor83941df2009-04-25 17:48:32 +00002148 if (Record[0])
Sebastian Redl725cd962010-08-04 20:40:17 +00002149 F.SelectorLookupTable
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002150 = ASTSelectorLookupTable::Create(
Sebastian Redl725cd962010-08-04 20:40:17 +00002151 F.SelectorLookupTableData + Record[0],
2152 F.SelectorLookupTableData,
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002153 ASTSelectorLookupTrait(*this));
Sebastian Redlfa78dec2010-08-04 21:22:45 +00002154 TotalNumMethodPoolEntries += Record[1];
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +00002155 break;
Douglas Gregor2eafc1b2009-04-26 00:07:37 +00002156
Sebastian Redl4ee5a6f2010-09-22 00:42:30 +00002157 case REFERENCED_SELECTOR_POOL:
Sebastian Redlc3632732010-10-05 15:59:54 +00002158 F.ReferencedSelectorsData.swap(Record);
Fariborz Jahanian32019832010-07-23 19:11:11 +00002159 break;
2160
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002161 case PP_COUNTER_VALUE:
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00002162 if (!Record.empty() && Listener)
2163 Listener->ReadCounter(Record[0]);
Douglas Gregor2eafc1b2009-04-26 00:07:37 +00002164 break;
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00002165
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002166 case SOURCE_LOCATION_OFFSETS:
Sebastian Redl518d8cb2010-07-20 21:20:32 +00002167 F.SLocOffsets = (const uint32_t *)BlobStart;
2168 F.LocalNumSLocEntries = Record[0];
Sebastian Redl8db9fae2010-09-22 20:19:08 +00002169 F.LocalSLocSize = Record[1];
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00002170 break;
2171
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002172 case SOURCE_LOCATION_PRELOADS:
Sebastian Redl4ee5a6f2010-09-22 00:42:30 +00002173 if (PreloadSLocEntries.empty())
2174 PreloadSLocEntries.swap(Record);
2175 else
2176 PreloadSLocEntries.insert(PreloadSLocEntries.end(),
2177 Record.begin(), Record.end());
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00002178 break;
Douglas Gregor4fed3f42009-04-27 18:38:38 +00002179
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002180 case STAT_CACHE: {
Douglas Gregor8ef6c8c2011-02-05 19:42:43 +00002181 if (!DisableStatCache) {
2182 ASTStatCache *MyStatCache =
2183 new ASTStatCache((const unsigned char *)BlobStart + Record[0],
2184 (const unsigned char *)BlobStart,
2185 NumStatHits, NumStatMisses);
2186 FileMgr.addStatCache(MyStatCache);
2187 F.StatCache = MyStatCache;
2188 }
Douglas Gregor4fed3f42009-04-27 18:38:38 +00002189 break;
Douglas Gregor52e71082009-10-16 18:18:30 +00002190 }
Kovarththanan Rajaratnam6b82f642010-03-07 19:10:13 +00002191
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002192 case EXT_VECTOR_DECLS:
Sebastian Redla9f23682010-07-28 21:38:49 +00002193 // Optimization for the first block.
2194 if (ExtVectorDecls.empty())
2195 ExtVectorDecls.swap(Record);
2196 else
2197 ExtVectorDecls.insert(ExtVectorDecls.end(),
2198 Record.begin(), Record.end());
Douglas Gregorb81c1702009-04-27 20:06:05 +00002199 break;
2200
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002201 case VTABLE_USES:
Sebastian Redl40566802010-08-05 18:21:25 +00002202 // Later tables overwrite earlier ones.
Argyrios Kyrtzidisd455add2010-07-06 15:37:04 +00002203 VTableUses.swap(Record);
2204 break;
2205
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002206 case DYNAMIC_CLASSES:
Sebastian Redl40566802010-08-05 18:21:25 +00002207 // Optimization for the first block.
2208 if (DynamicClasses.empty())
2209 DynamicClasses.swap(Record);
2210 else
2211 DynamicClasses.insert(DynamicClasses.end(),
2212 Record.begin(), Record.end());
Argyrios Kyrtzidisd455add2010-07-06 15:37:04 +00002213 break;
2214
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002215 case PENDING_IMPLICIT_INSTANTIATIONS:
Sebastian Redlc3632732010-10-05 15:59:54 +00002216 F.PendingInstantiations.swap(Record);
Argyrios Kyrtzidis0e036382010-08-05 09:48:16 +00002217 break;
2218
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002219 case SEMA_DECL_REFS:
Sebastian Redl40566802010-08-05 18:21:25 +00002220 // Later tables overwrite earlier ones.
Argyrios Kyrtzidis76c38d32010-08-02 07:14:54 +00002221 SemaDeclRefs.swap(Record);
2222 break;
2223
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002224 case ORIGINAL_FILE_NAME:
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002225 // The primary AST will be the last to get here, so it will be the one
Sebastian Redl518d8cb2010-07-20 21:20:32 +00002226 // that's used.
Daniel Dunbar7b5a1212009-11-11 05:29:04 +00002227 ActualOriginalFileName.assign(BlobStart, BlobLen);
2228 OriginalFileName = ActualOriginalFileName;
Douglas Gregore650c8c2009-07-07 00:12:59 +00002229 MaybeAddSystemRootToFilename(OriginalFileName);
Douglas Gregorb64c1932009-05-12 01:31:05 +00002230 break;
Mike Stump1eb44332009-09-09 15:08:12 +00002231
Argyrios Kyrtzidis8e3df4d2011-02-15 17:54:22 +00002232 case ORIGINAL_PCH_DIR:
2233 // The primary AST will be the last to get here, so it will be the one
2234 // that's used.
2235 OriginalDir.assign(BlobStart, BlobLen);
2236 break;
2237
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002238 case VERSION_CONTROL_BRANCH_REVISION: {
Ted Kremenek974be4d2010-02-12 23:31:14 +00002239 const std::string &CurBranch = getClangFullRepositoryVersion();
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002240 llvm::StringRef ASTBranch(BlobStart, BlobLen);
2241 if (llvm::StringRef(CurBranch) != ASTBranch && !DisableValidation) {
2242 Diag(diag::warn_pch_different_branch) << ASTBranch << CurBranch;
Douglas Gregor445e23e2009-10-05 21:07:28 +00002243 return IgnorePCH;
2244 }
2245 break;
2246 }
Sebastian Redl04e6fd42010-07-21 20:07:32 +00002247
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002248 case MACRO_DEFINITION_OFFSETS:
Sebastian Redl04e6fd42010-07-21 20:07:32 +00002249 F.MacroDefinitionOffsets = (const uint32_t *)BlobStart;
2250 F.NumPreallocatedPreprocessingEntities = Record[0];
2251 F.LocalNumMacroDefinitions = Record[1];
Douglas Gregor6a5a23f2010-03-19 21:51:54 +00002252 break;
Sebastian Redl0b17c612010-08-13 00:28:03 +00002253
Argyrios Kyrtzidis7b903402010-10-24 17:26:36 +00002254 case DECL_UPDATE_OFFSETS: {
2255 if (Record.size() % 2 != 0) {
2256 Error("invalid DECL_UPDATE_OFFSETS block in AST file");
2257 return Failure;
2258 }
2259 for (unsigned I = 0, N = Record.size(); I != N; I += 2)
2260 DeclUpdateOffsets[static_cast<DeclID>(Record[I])]
2261 .push_back(std::make_pair(&F, Record[I+1]));
2262 break;
2263 }
2264
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002265 case DECL_REPLACEMENTS: {
Sebastian Redl0b17c612010-08-13 00:28:03 +00002266 if (Record.size() % 2 != 0) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002267 Error("invalid DECL_REPLACEMENTS block in AST file");
Sebastian Redl0b17c612010-08-13 00:28:03 +00002268 return Failure;
2269 }
2270 for (unsigned I = 0, N = Record.size(); I != N; I += 2)
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002271 ReplacedDecls[static_cast<DeclID>(Record[I])] =
Sebastian Redl0b17c612010-08-13 00:28:03 +00002272 std::make_pair(&F, Record[I+1]);
2273 break;
2274 }
Douglas Gregor7c789c12010-10-29 22:39:52 +00002275
2276 case CXX_BASE_SPECIFIER_OFFSETS: {
2277 if (F.LocalNumCXXBaseSpecifiers != 0) {
2278 Error("duplicate CXX_BASE_SPECIFIER_OFFSETS record in AST file");
2279 return Failure;
2280 }
2281
2282 F.LocalNumCXXBaseSpecifiers = Record[0];
2283 F.CXXBaseSpecifiersOffsets = (const uint32_t *)BlobStart;
2284 break;
2285 }
Argyrios Kyrtzidisf41d3be2010-11-05 22:10:18 +00002286
Argyrios Kyrtzidis3efd52c2011-01-14 20:54:07 +00002287 case DIAG_PRAGMA_MAPPINGS:
Argyrios Kyrtzidisf41d3be2010-11-05 22:10:18 +00002288 if (Record.size() % 2 != 0) {
2289 Error("invalid DIAG_USER_MAPPINGS block in AST file");
2290 return Failure;
2291 }
Argyrios Kyrtzidis3efd52c2011-01-14 20:54:07 +00002292 if (PragmaDiagMappings.empty())
2293 PragmaDiagMappings.swap(Record);
Argyrios Kyrtzidisf41d3be2010-11-05 22:10:18 +00002294 else
Argyrios Kyrtzidis3efd52c2011-01-14 20:54:07 +00002295 PragmaDiagMappings.insert(PragmaDiagMappings.end(),
Argyrios Kyrtzidisf41d3be2010-11-05 22:10:18 +00002296 Record.begin(), Record.end());
2297 break;
Douglas Gregorcfbf1c72011-02-10 17:09:37 +00002298
Peter Collingbourne14b6ba72011-02-09 21:04:32 +00002299 case CUDA_SPECIAL_DECL_REFS:
2300 // Later tables overwrite earlier ones.
2301 CUDASpecialDeclRefs.swap(Record);
2302 break;
Douglas Gregorcfbf1c72011-02-10 17:09:37 +00002303
2304 case HEADER_SEARCH_TABLE:
2305 F.HeaderFileInfoTableData = BlobStart;
2306 F.LocalNumHeaderFileInfos = Record[1];
2307 if (Record[0]) {
2308 F.HeaderFileInfoTable
2309 = HeaderFileInfoLookupTable::Create(
2310 (const unsigned char *)F.HeaderFileInfoTableData + Record[0],
2311 (const unsigned char *)F.HeaderFileInfoTableData);
2312 if (PP)
2313 PP->getHeaderSearchInfo().SetExternalSource(this);
2314 }
2315 break;
Peter Collingbourne84bccea2011-02-15 19:46:30 +00002316
2317 case FP_PRAGMA_OPTIONS:
2318 // Later tables overwrite earlier ones.
2319 FPPragmaOptions.swap(Record);
2320 break;
2321
2322 case OPENCL_EXTENSIONS:
2323 // Later tables overwrite earlier ones.
2324 OpenCLExtensions.swap(Record);
2325 break;
Douglas Gregorafaf3082009-04-11 00:14:32 +00002326 }
Sebastian Redl93fb9ed2010-07-19 20:52:06 +00002327 First = false;
Douglas Gregor2cf26342009-04-09 22:27:44 +00002328 }
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002329 Error("premature end of bitstream in AST file");
Douglas Gregor0a0428e2009-04-10 20:39:37 +00002330 return Failure;
Douglas Gregor2cf26342009-04-09 22:27:44 +00002331}
2332
Sebastian Redl1d9f1fe2010-10-05 16:15:19 +00002333ASTReader::ASTReadResult ASTReader::ReadAST(const std::string &FileName,
2334 ASTFileType Type) {
2335 switch(ReadASTCore(FileName, Type)) {
Sebastian Redlcdf3b832010-07-16 20:41:52 +00002336 case Failure: return Failure;
2337 case IgnorePCH: return IgnorePCH;
2338 case Success: break;
2339 }
Sebastian Redlfbd4bf12010-07-17 00:12:06 +00002340
2341 // Here comes stuff that we only do once the entire chain is loaded.
2342
Sebastian Redl4ee5a6f2010-09-22 00:42:30 +00002343 // Allocate space for loaded slocentries, identifiers, decls and types.
Sebastian Redl04e6fd42010-07-21 20:07:32 +00002344 unsigned TotalNumIdentifiers = 0, TotalNumTypes = 0, TotalNumDecls = 0,
Sebastian Redl725cd962010-08-04 20:40:17 +00002345 TotalNumPreallocatedPreprocessingEntities = 0, TotalNumMacroDefs = 0,
2346 TotalNumSelectors = 0;
Sebastian Redl12d6da02010-07-19 22:06:55 +00002347 for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
Sebastian Redl4ee5a6f2010-09-22 00:42:30 +00002348 TotalNumSLocEntries += Chain[I]->LocalNumSLocEntries;
Sebastian Redl8db9fae2010-09-22 20:19:08 +00002349 NextSLocOffset += Chain[I]->LocalSLocSize;
Sebastian Redl2da08f92010-07-19 22:28:42 +00002350 TotalNumIdentifiers += Chain[I]->LocalNumIdentifiers;
Sebastian Redl12d6da02010-07-19 22:06:55 +00002351 TotalNumTypes += Chain[I]->LocalNumTypes;
2352 TotalNumDecls += Chain[I]->LocalNumDecls;
Sebastian Redl04e6fd42010-07-21 20:07:32 +00002353 TotalNumPreallocatedPreprocessingEntities +=
2354 Chain[I]->NumPreallocatedPreprocessingEntities;
2355 TotalNumMacroDefs += Chain[I]->LocalNumMacroDefinitions;
Sebastian Redl725cd962010-08-04 20:40:17 +00002356 TotalNumSelectors += Chain[I]->LocalNumSelectors;
Sebastian Redl12d6da02010-07-19 22:06:55 +00002357 }
Sebastian Redl8db9fae2010-09-22 20:19:08 +00002358 SourceMgr.PreallocateSLocEntries(this, TotalNumSLocEntries, NextSLocOffset);
Sebastian Redl2da08f92010-07-19 22:28:42 +00002359 IdentifiersLoaded.resize(TotalNumIdentifiers);
Sebastian Redl12d6da02010-07-19 22:06:55 +00002360 TypesLoaded.resize(TotalNumTypes);
2361 DeclsLoaded.resize(TotalNumDecls);
Sebastian Redl04e6fd42010-07-21 20:07:32 +00002362 MacroDefinitionsLoaded.resize(TotalNumMacroDefs);
2363 if (PP) {
2364 if (TotalNumIdentifiers > 0)
2365 PP->getHeaderSearchInfo().SetExternalLookup(this);
2366 if (TotalNumPreallocatedPreprocessingEntities > 0) {
2367 if (!PP->getPreprocessingRecord())
2368 PP->createPreprocessingRecord();
2369 PP->getPreprocessingRecord()->SetExternalSource(*this,
2370 TotalNumPreallocatedPreprocessingEntities);
2371 }
2372 }
Sebastian Redl725cd962010-08-04 20:40:17 +00002373 SelectorsLoaded.resize(TotalNumSelectors);
Sebastian Redl4ee5a6f2010-09-22 00:42:30 +00002374 // Preload SLocEntries.
2375 for (unsigned I = 0, N = PreloadSLocEntries.size(); I != N; ++I) {
2376 ASTReadResult Result = ReadSLocEntryRecord(PreloadSLocEntries[I]);
2377 if (Result != Success)
2378 return Result;
2379 }
Sebastian Redl12d6da02010-07-19 22:06:55 +00002380
Sebastian Redlfbd4bf12010-07-17 00:12:06 +00002381 // Check the predefines buffers.
Douglas Gregorfae3b2f2010-07-27 00:27:13 +00002382 if (!DisableValidation && CheckPredefinesBuffers())
Sebastian Redlfbd4bf12010-07-17 00:12:06 +00002383 return IgnorePCH;
2384
2385 if (PP) {
2386 // Initialization of keywords and pragmas occurs before the
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002387 // AST file is read, so there may be some identifiers that were
Sebastian Redlfbd4bf12010-07-17 00:12:06 +00002388 // loaded into the IdentifierTable before we intercepted the
2389 // creation of identifiers. Iterate through the list of known
2390 // identifiers and determine whether we have to establish
2391 // preprocessor definitions or top-level identifier declaration
2392 // chains for those identifiers.
2393 //
2394 // We copy the IdentifierInfo pointers to a small vector first,
2395 // since de-serializing declarations or macro definitions can add
2396 // new entries into the identifier table, invalidating the
2397 // iterators.
2398 llvm::SmallVector<IdentifierInfo *, 128> Identifiers;
2399 for (IdentifierTable::iterator Id = PP->getIdentifierTable().begin(),
2400 IdEnd = PP->getIdentifierTable().end();
2401 Id != IdEnd; ++Id)
2402 Identifiers.push_back(Id->second);
Sebastian Redl04e6fd42010-07-21 20:07:32 +00002403 // We need to search the tables in all files.
Sebastian Redl04e6fd42010-07-21 20:07:32 +00002404 for (unsigned J = 0, M = Chain.size(); J != M; ++J) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002405 ASTIdentifierLookupTable *IdTable
2406 = (ASTIdentifierLookupTable *)Chain[J]->IdentifierLookupTable;
2407 // Not all AST files necessarily have identifier tables, only the useful
Sebastian Redl0fa7d0b2010-07-22 17:01:13 +00002408 // ones.
2409 if (!IdTable)
2410 continue;
Sebastian Redl04e6fd42010-07-21 20:07:32 +00002411 for (unsigned I = 0, N = Identifiers.size(); I != N; ++I) {
2412 IdentifierInfo *II = Identifiers[I];
2413 // Look in the on-disk hash tables for an entry for this identifier
Sebastian Redlc3632732010-10-05 15:59:54 +00002414 ASTIdentifierLookupTrait Info(*this, *Chain[J], II);
Sebastian Redl04e6fd42010-07-21 20:07:32 +00002415 std::pair<const char*,unsigned> Key(II->getNameStart(),II->getLength());
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002416 ASTIdentifierLookupTable::iterator Pos = IdTable->find(Key, &Info);
Sebastian Redl518d8cb2010-07-20 21:20:32 +00002417 if (Pos == IdTable->end())
2418 continue;
Sebastian Redlfbd4bf12010-07-17 00:12:06 +00002419
Sebastian Redl518d8cb2010-07-20 21:20:32 +00002420 // Dereferencing the iterator has the effect of populating the
2421 // IdentifierInfo node with the various declarations it needs.
2422 (void)*Pos;
2423 }
Sebastian Redlfbd4bf12010-07-17 00:12:06 +00002424 }
2425 }
2426
2427 if (Context)
2428 InitializeContext(*Context);
2429
Argyrios Kyrtzidis7b903402010-10-24 17:26:36 +00002430 if (DeserializationListener)
2431 DeserializationListener->ReaderInitialized(this);
2432
Douglas Gregor414cb642010-11-30 05:23:00 +00002433 // If this AST file is a precompiled preamble, then set the main file ID of
2434 // the source manager to the file source file from which the preamble was
2435 // built. This is the only valid way to use a precompiled preamble.
2436 if (Type == Preamble) {
2437 SourceLocation Loc
2438 = SourceMgr.getLocation(FileMgr.getFile(getOriginalSourceFile()), 1, 1);
2439 if (Loc.isValid()) {
2440 std::pair<FileID, unsigned> Decomposed = SourceMgr.getDecomposedLoc(Loc);
2441 SourceMgr.SetPreambleFileID(Decomposed.first);
2442 }
2443 }
2444
Sebastian Redlfbd4bf12010-07-17 00:12:06 +00002445 return Success;
2446}
2447
Sebastian Redl1d9f1fe2010-10-05 16:15:19 +00002448ASTReader::ASTReadResult ASTReader::ReadASTCore(llvm::StringRef FileName,
2449 ASTFileType Type) {
Sebastian Redla866e652010-10-01 19:59:12 +00002450 PerFileData *Prev = Chain.empty() ? 0 : Chain.back();
Sebastian Redl1d9f1fe2010-10-05 16:15:19 +00002451 Chain.push_back(new PerFileData(Type));
Sebastian Redl9137a522010-07-16 17:50:48 +00002452 PerFileData &F = *Chain.back();
Sebastian Redla866e652010-10-01 19:59:12 +00002453 if (Prev)
2454 Prev->NextInSource = &F;
2455 else
2456 FirstInSource = &F;
2457 F.Loaders.push_back(Prev);
Sebastian Redlfbd4bf12010-07-17 00:12:06 +00002458
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002459 // Set the AST file name.
Sebastian Redlfbd4bf12010-07-17 00:12:06 +00002460 F.FileName = FileName;
2461
Argyrios Kyrtzidis8e3df4d2011-02-15 17:54:22 +00002462 if (FileName != "-") {
2463 CurrentDir = llvm::sys::path::parent_path(FileName);
2464 if (CurrentDir.empty()) CurrentDir = ".";
2465 }
2466
Argyrios Kyrtzidisb0f4b9a2011-03-09 17:21:42 +00002467 if (!ASTBuffers.empty()) {
Sebastian Redl56558372011-04-14 14:07:41 +00002468 F.Buffer.reset(ASTBuffers.back());
2469 ASTBuffers.pop_back();
Argyrios Kyrtzidisb0f4b9a2011-03-09 17:21:42 +00002470 assert(F.Buffer && "Passed null buffer");
2471 } else {
2472 // Open the AST file.
2473 //
2474 // FIXME: This shouldn't be here, we should just take a raw_ostream.
2475 std::string ErrStr;
2476 llvm::error_code ec;
2477 if (FileName == "-") {
2478 ec = llvm::MemoryBuffer::getSTDIN(F.Buffer);
2479 if (ec)
2480 ErrStr = ec.message();
2481 } else
2482 F.Buffer.reset(FileMgr.getBufferForFile(FileName, &ErrStr));
2483 if (!F.Buffer) {
2484 Error(ErrStr.c_str());
2485 return IgnorePCH;
2486 }
Sebastian Redlfbd4bf12010-07-17 00:12:06 +00002487 }
2488
2489 // Initialize the stream
2490 F.StreamFile.init((const unsigned char *)F.Buffer->getBufferStart(),
2491 (const unsigned char *)F.Buffer->getBufferEnd());
Sebastian Redl9137a522010-07-16 17:50:48 +00002492 llvm::BitstreamCursor &Stream = F.Stream;
Sebastian Redlfbd4bf12010-07-17 00:12:06 +00002493 Stream.init(F.StreamFile);
Sebastian Redl04e6fd42010-07-21 20:07:32 +00002494 F.SizeInBits = F.Buffer->getBufferSize() * 8;
Sebastian Redlfbd4bf12010-07-17 00:12:06 +00002495
2496 // Sniff for the signature.
2497 if (Stream.Read(8) != 'C' ||
2498 Stream.Read(8) != 'P' ||
2499 Stream.Read(8) != 'C' ||
2500 Stream.Read(8) != 'H') {
2501 Diag(diag::err_not_a_pch_file) << FileName;
2502 return Failure;
2503 }
Douglas Gregor2cf26342009-04-09 22:27:44 +00002504
Douglas Gregor2cf26342009-04-09 22:27:44 +00002505 while (!Stream.AtEndOfStream()) {
2506 unsigned Code = Stream.ReadCode();
Mike Stump1eb44332009-09-09 15:08:12 +00002507
Douglas Gregore1d918e2009-04-10 23:10:45 +00002508 if (Code != llvm::bitc::ENTER_SUBBLOCK) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002509 Error("invalid record at top-level of AST file");
Douglas Gregore1d918e2009-04-10 23:10:45 +00002510 return Failure;
2511 }
Douglas Gregor2cf26342009-04-09 22:27:44 +00002512
2513 unsigned BlockID = Stream.ReadSubBlockID();
Douglas Gregor668c1a42009-04-21 22:25:48 +00002514
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002515 // We only know the AST subblock ID.
Douglas Gregor2cf26342009-04-09 22:27:44 +00002516 switch (BlockID) {
2517 case llvm::bitc::BLOCKINFO_BLOCK_ID:
Douglas Gregore1d918e2009-04-10 23:10:45 +00002518 if (Stream.ReadBlockInfoBlock()) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002519 Error("malformed BlockInfoBlock in AST file");
Douglas Gregore1d918e2009-04-10 23:10:45 +00002520 return Failure;
2521 }
Douglas Gregor2cf26342009-04-09 22:27:44 +00002522 break;
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002523 case AST_BLOCK_ID:
Sebastian Redl571db7f2010-08-18 23:56:56 +00002524 switch (ReadASTBlock(F)) {
Douglas Gregor0a0428e2009-04-10 20:39:37 +00002525 case Success:
2526 break;
2527
2528 case Failure:
Douglas Gregore1d918e2009-04-10 23:10:45 +00002529 return Failure;
Douglas Gregor0a0428e2009-04-10 20:39:37 +00002530
2531 case IgnorePCH:
Douglas Gregor2bec0412009-04-10 21:16:55 +00002532 // FIXME: We could consider reading through to the end of this
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002533 // AST block, skipping subblocks, to see if there are other
2534 // AST blocks elsewhere.
Douglas Gregor2bf1eb02009-04-27 21:28:04 +00002535
2536 // Clear out any preallocated source location entries, so that
2537 // the source manager does not try to resolve them later.
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00002538 SourceMgr.ClearPreallocatedSLocEntries();
Douglas Gregor2bf1eb02009-04-27 21:28:04 +00002539
2540 // Remove the stat cache.
Sebastian Redl9137a522010-07-16 17:50:48 +00002541 if (F.StatCache)
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002542 FileMgr.removeStatCache((ASTStatCache*)F.StatCache);
Douglas Gregor2bf1eb02009-04-27 21:28:04 +00002543
Douglas Gregore1d918e2009-04-10 23:10:45 +00002544 return IgnorePCH;
Douglas Gregor0a0428e2009-04-10 20:39:37 +00002545 }
Douglas Gregor2cf26342009-04-09 22:27:44 +00002546 break;
2547 default:
Douglas Gregore1d918e2009-04-10 23:10:45 +00002548 if (Stream.SkipBlock()) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002549 Error("malformed block record in AST file");
Douglas Gregore1d918e2009-04-10 23:10:45 +00002550 return Failure;
2551 }
Douglas Gregor2cf26342009-04-09 22:27:44 +00002552 break;
2553 }
Mike Stump1eb44332009-09-09 15:08:12 +00002554 }
2555
Sebastian Redlcdf3b832010-07-16 20:41:52 +00002556 return Success;
2557}
2558
Sebastian Redlc43b54c2010-08-18 23:56:43 +00002559void ASTReader::setPreprocessor(Preprocessor &pp) {
Douglas Gregor6a5a23f2010-03-19 21:51:54 +00002560 PP = &pp;
Sebastian Redl04e6fd42010-07-21 20:07:32 +00002561
2562 unsigned TotalNum = 0;
2563 for (unsigned I = 0, N = Chain.size(); I != N; ++I)
2564 TotalNum += Chain[I]->NumPreallocatedPreprocessingEntities;
2565 if (TotalNum) {
Douglas Gregor6a5a23f2010-03-19 21:51:54 +00002566 if (!PP->getPreprocessingRecord())
2567 PP->createPreprocessingRecord();
Sebastian Redl04e6fd42010-07-21 20:07:32 +00002568 PP->getPreprocessingRecord()->SetExternalSource(*this, TotalNum);
Douglas Gregor6a5a23f2010-03-19 21:51:54 +00002569 }
2570}
2571
Sebastian Redlc43b54c2010-08-18 23:56:43 +00002572void ASTReader::InitializeContext(ASTContext &Ctx) {
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00002573 Context = &Ctx;
2574 assert(Context && "Passed null context!");
2575
2576 assert(PP && "Forgot to set Preprocessor ?");
2577 PP->getIdentifierTable().setExternalIdentifierLookup(this);
2578 PP->getHeaderSearchInfo().SetExternalLookup(this);
Douglas Gregor88a35862010-01-04 19:18:44 +00002579 PP->setExternalSource(this);
Douglas Gregorcfbf1c72011-02-10 17:09:37 +00002580 PP->getHeaderSearchInfo().SetExternalSource(this);
2581
Douglas Gregor3747ee72010-10-01 01:18:02 +00002582 // If we have an update block for the TU waiting, we have to add it before
2583 // deserializing the decl.
2584 DeclContextOffsetsMap::iterator DCU = DeclContextOffsets.find(0);
2585 if (DCU != DeclContextOffsets.end()) {
2586 // Insertion could invalidate map, so grab vector.
2587 DeclContextInfos T;
2588 T.swap(DCU->second);
2589 DeclContextOffsets.erase(DCU);
2590 DeclContextOffsets[Ctx.getTranslationUnitDecl()].swap(T);
2591 }
2592
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00002593 // Load the translation unit declaration
Argyrios Kyrtzidis8871a442010-07-08 17:13:02 +00002594 GetTranslationUnitDecl();
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00002595
2596 // Load the special types.
2597 Context->setBuiltinVaListType(
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002598 GetType(SpecialTypes[SPECIAL_TYPE_BUILTIN_VA_LIST]));
2599 if (unsigned Id = SpecialTypes[SPECIAL_TYPE_OBJC_ID])
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00002600 Context->setObjCIdType(GetType(Id));
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002601 if (unsigned Sel = SpecialTypes[SPECIAL_TYPE_OBJC_SELECTOR])
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00002602 Context->setObjCSelType(GetType(Sel));
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002603 if (unsigned Proto = SpecialTypes[SPECIAL_TYPE_OBJC_PROTOCOL])
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00002604 Context->setObjCProtoType(GetType(Proto));
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002605 if (unsigned Class = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS])
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00002606 Context->setObjCClassType(GetType(Class));
Steve Naroff14108da2009-07-10 23:34:53 +00002607
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002608 if (unsigned String = SpecialTypes[SPECIAL_TYPE_CF_CONSTANT_STRING])
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00002609 Context->setCFConstantStringType(GetType(String));
Mike Stump1eb44332009-09-09 15:08:12 +00002610 if (unsigned FastEnum
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002611 = SpecialTypes[SPECIAL_TYPE_OBJC_FAST_ENUMERATION_STATE])
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00002612 Context->setObjCFastEnumerationStateType(GetType(FastEnum));
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002613 if (unsigned File = SpecialTypes[SPECIAL_TYPE_FILE]) {
Douglas Gregorc29f77b2009-07-07 16:35:42 +00002614 QualType FileType = GetType(File);
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00002615 if (FileType.isNull()) {
2616 Error("FILE type is NULL");
2617 return;
2618 }
John McCall183700f2009-09-21 23:43:11 +00002619 if (const TypedefType *Typedef = FileType->getAs<TypedefType>())
Douglas Gregorc29f77b2009-07-07 16:35:42 +00002620 Context->setFILEDecl(Typedef->getDecl());
2621 else {
Ted Kremenek6217b802009-07-29 21:53:49 +00002622 const TagType *Tag = FileType->getAs<TagType>();
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00002623 if (!Tag) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002624 Error("Invalid FILE type in AST file");
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00002625 return;
2626 }
Douglas Gregorc29f77b2009-07-07 16:35:42 +00002627 Context->setFILEDecl(Tag->getDecl());
2628 }
2629 }
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002630 if (unsigned Jmp_buf = SpecialTypes[SPECIAL_TYPE_jmp_buf]) {
Mike Stump782fa302009-07-28 02:25:19 +00002631 QualType Jmp_bufType = GetType(Jmp_buf);
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00002632 if (Jmp_bufType.isNull()) {
2633 Error("jmp_bug type is NULL");
2634 return;
2635 }
John McCall183700f2009-09-21 23:43:11 +00002636 if (const TypedefType *Typedef = Jmp_bufType->getAs<TypedefType>())
Mike Stump782fa302009-07-28 02:25:19 +00002637 Context->setjmp_bufDecl(Typedef->getDecl());
2638 else {
Ted Kremenek6217b802009-07-29 21:53:49 +00002639 const TagType *Tag = Jmp_bufType->getAs<TagType>();
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00002640 if (!Tag) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002641 Error("Invalid jmp_buf type in AST file");
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00002642 return;
2643 }
Mike Stump782fa302009-07-28 02:25:19 +00002644 Context->setjmp_bufDecl(Tag->getDecl());
2645 }
2646 }
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002647 if (unsigned Sigjmp_buf = SpecialTypes[SPECIAL_TYPE_sigjmp_buf]) {
Mike Stump782fa302009-07-28 02:25:19 +00002648 QualType Sigjmp_bufType = GetType(Sigjmp_buf);
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00002649 if (Sigjmp_bufType.isNull()) {
2650 Error("sigjmp_buf type is NULL");
2651 return;
2652 }
John McCall183700f2009-09-21 23:43:11 +00002653 if (const TypedefType *Typedef = Sigjmp_bufType->getAs<TypedefType>())
Mike Stump782fa302009-07-28 02:25:19 +00002654 Context->setsigjmp_bufDecl(Typedef->getDecl());
2655 else {
Ted Kremenek6217b802009-07-29 21:53:49 +00002656 const TagType *Tag = Sigjmp_bufType->getAs<TagType>();
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002657 assert(Tag && "Invalid sigjmp_buf type in AST file");
Mike Stump782fa302009-07-28 02:25:19 +00002658 Context->setsigjmp_bufDecl(Tag->getDecl());
2659 }
2660 }
Mike Stump1eb44332009-09-09 15:08:12 +00002661 if (unsigned ObjCIdRedef
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002662 = SpecialTypes[SPECIAL_TYPE_OBJC_ID_REDEFINITION])
Douglas Gregord1571ac2009-08-21 00:27:50 +00002663 Context->ObjCIdRedefinitionType = GetType(ObjCIdRedef);
Mike Stump1eb44332009-09-09 15:08:12 +00002664 if (unsigned ObjCClassRedef
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002665 = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS_REDEFINITION])
Douglas Gregord1571ac2009-08-21 00:27:50 +00002666 Context->ObjCClassRedefinitionType = GetType(ObjCClassRedef);
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002667 if (unsigned String = SpecialTypes[SPECIAL_TYPE_BLOCK_DESCRIPTOR])
Mike Stumpadaaad32009-10-20 02:12:22 +00002668 Context->setBlockDescriptorType(GetType(String));
Mike Stump083c25e2009-10-22 00:49:09 +00002669 if (unsigned String
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002670 = SpecialTypes[SPECIAL_TYPE_BLOCK_EXTENDED_DESCRIPTOR])
Mike Stump083c25e2009-10-22 00:49:09 +00002671 Context->setBlockDescriptorExtendedType(GetType(String));
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00002672 if (unsigned ObjCSelRedef
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002673 = SpecialTypes[SPECIAL_TYPE_OBJC_SEL_REDEFINITION])
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00002674 Context->ObjCSelRedefinitionType = GetType(ObjCSelRedef);
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002675 if (unsigned String = SpecialTypes[SPECIAL_TYPE_NS_CONSTANT_STRING])
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00002676 Context->setNSConstantStringType(GetType(String));
Argyrios Kyrtzidis00611382010-07-04 21:44:19 +00002677
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002678 if (SpecialTypes[SPECIAL_TYPE_INT128_INSTALLED])
Argyrios Kyrtzidis00611382010-07-04 21:44:19 +00002679 Context->setInt128Installed();
Argyrios Kyrtzidisf41d3be2010-11-05 22:10:18 +00002680
Richard Smithad762fc2011-04-14 22:09:26 +00002681 if (unsigned AutoDeduct = SpecialTypes[SPECIAL_TYPE_AUTO_DEDUCT])
2682 Context->AutoDeductTy = GetType(AutoDeduct);
2683 if (unsigned AutoRRefDeduct = SpecialTypes[SPECIAL_TYPE_AUTO_RREF_DEDUCT])
2684 Context->AutoRRefDeductTy = GetType(AutoRRefDeduct);
2685
Argyrios Kyrtzidis3efd52c2011-01-14 20:54:07 +00002686 ReadPragmaDiagnosticMappings(Context->getDiagnostics());
Peter Collingbourne14b6ba72011-02-09 21:04:32 +00002687
2688 // If there were any CUDA special declarations, deserialize them.
2689 if (!CUDASpecialDeclRefs.empty()) {
2690 assert(CUDASpecialDeclRefs.size() == 1 && "More decl refs than expected!");
2691 Context->setcudaConfigureCallDecl(
2692 cast<FunctionDecl>(GetDecl(CUDASpecialDeclRefs[0])));
2693 }
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00002694}
2695
Douglas Gregorb64c1932009-05-12 01:31:05 +00002696/// \brief Retrieve the name of the original source file name
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002697/// directly from the AST file, without actually loading the AST
Douglas Gregorb64c1932009-05-12 01:31:05 +00002698/// file.
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002699std::string ASTReader::getOriginalSourceFile(const std::string &ASTFileName,
Argyrios Kyrtzidis389db162010-11-03 22:45:23 +00002700 FileManager &FileMgr,
Daniel Dunbar93ebb1b2009-12-03 09:13:06 +00002701 Diagnostic &Diags) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002702 // Open the AST file.
Douglas Gregorb64c1932009-05-12 01:31:05 +00002703 std::string ErrStr;
2704 llvm::OwningPtr<llvm::MemoryBuffer> Buffer;
Chris Lattner39b49bc2010-11-23 08:35:12 +00002705 Buffer.reset(FileMgr.getBufferForFile(ASTFileName, &ErrStr));
Douglas Gregorb64c1932009-05-12 01:31:05 +00002706 if (!Buffer) {
Daniel Dunbar93ebb1b2009-12-03 09:13:06 +00002707 Diags.Report(diag::err_fe_unable_to_read_pch_file) << ErrStr;
Douglas Gregorb64c1932009-05-12 01:31:05 +00002708 return std::string();
2709 }
2710
2711 // Initialize the stream
2712 llvm::BitstreamReader StreamFile;
2713 llvm::BitstreamCursor Stream;
Mike Stump1eb44332009-09-09 15:08:12 +00002714 StreamFile.init((const unsigned char *)Buffer->getBufferStart(),
Douglas Gregorb64c1932009-05-12 01:31:05 +00002715 (const unsigned char *)Buffer->getBufferEnd());
2716 Stream.init(StreamFile);
2717
2718 // Sniff for the signature.
2719 if (Stream.Read(8) != 'C' ||
2720 Stream.Read(8) != 'P' ||
2721 Stream.Read(8) != 'C' ||
2722 Stream.Read(8) != 'H') {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002723 Diags.Report(diag::err_fe_not_a_pch_file) << ASTFileName;
Douglas Gregorb64c1932009-05-12 01:31:05 +00002724 return std::string();
2725 }
2726
2727 RecordData Record;
2728 while (!Stream.AtEndOfStream()) {
2729 unsigned Code = Stream.ReadCode();
Mike Stump1eb44332009-09-09 15:08:12 +00002730
Douglas Gregorb64c1932009-05-12 01:31:05 +00002731 if (Code == llvm::bitc::ENTER_SUBBLOCK) {
2732 unsigned BlockID = Stream.ReadSubBlockID();
Mike Stump1eb44332009-09-09 15:08:12 +00002733
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002734 // We only know the AST subblock ID.
Douglas Gregorb64c1932009-05-12 01:31:05 +00002735 switch (BlockID) {
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002736 case AST_BLOCK_ID:
2737 if (Stream.EnterSubBlock(AST_BLOCK_ID)) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002738 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
Douglas Gregorb64c1932009-05-12 01:31:05 +00002739 return std::string();
2740 }
2741 break;
Mike Stump1eb44332009-09-09 15:08:12 +00002742
Douglas Gregorb64c1932009-05-12 01:31:05 +00002743 default:
2744 if (Stream.SkipBlock()) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002745 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
Douglas Gregorb64c1932009-05-12 01:31:05 +00002746 return std::string();
2747 }
2748 break;
2749 }
2750 continue;
2751 }
2752
2753 if (Code == llvm::bitc::END_BLOCK) {
2754 if (Stream.ReadBlockEnd()) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002755 Diags.Report(diag::err_fe_pch_error_at_end_block) << ASTFileName;
Douglas Gregorb64c1932009-05-12 01:31:05 +00002756 return std::string();
2757 }
2758 continue;
2759 }
2760
2761 if (Code == llvm::bitc::DEFINE_ABBREV) {
2762 Stream.ReadAbbrevRecord();
2763 continue;
2764 }
2765
2766 Record.clear();
2767 const char *BlobStart = 0;
2768 unsigned BlobLen = 0;
Mike Stump1eb44332009-09-09 15:08:12 +00002769 if (Stream.ReadRecord(Code, Record, &BlobStart, &BlobLen)
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002770 == ORIGINAL_FILE_NAME)
Douglas Gregorb64c1932009-05-12 01:31:05 +00002771 return std::string(BlobStart, BlobLen);
Mike Stump1eb44332009-09-09 15:08:12 +00002772 }
Douglas Gregorb64c1932009-05-12 01:31:05 +00002773
2774 return std::string();
2775}
2776
Douglas Gregor0a0428e2009-04-10 20:39:37 +00002777/// \brief Parse the record that corresponds to a LangOptions data
2778/// structure.
2779///
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002780/// This routine parses the language options from the AST file and then gives
2781/// them to the AST listener if one is set.
Douglas Gregor0a0428e2009-04-10 20:39:37 +00002782///
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002783/// \returns true if the listener deems the file unacceptable, false otherwise.
Sebastian Redlc43b54c2010-08-18 23:56:43 +00002784bool ASTReader::ParseLanguageOptions(
Douglas Gregor0a0428e2009-04-10 20:39:37 +00002785 const llvm::SmallVectorImpl<uint64_t> &Record) {
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00002786 if (Listener) {
2787 LangOptions LangOpts;
Mike Stump1eb44332009-09-09 15:08:12 +00002788
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00002789 #define PARSE_LANGOPT(Option) \
2790 LangOpts.Option = Record[Idx]; \
2791 ++Idx
Mike Stump1eb44332009-09-09 15:08:12 +00002792
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00002793 unsigned Idx = 0;
2794 PARSE_LANGOPT(Trigraphs);
2795 PARSE_LANGOPT(BCPLComment);
2796 PARSE_LANGOPT(DollarIdents);
2797 PARSE_LANGOPT(AsmPreprocessor);
2798 PARSE_LANGOPT(GNUMode);
Chandler Carrutheb5d7b72010-04-17 20:17:31 +00002799 PARSE_LANGOPT(GNUKeywords);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00002800 PARSE_LANGOPT(ImplicitInt);
2801 PARSE_LANGOPT(Digraphs);
2802 PARSE_LANGOPT(HexFloats);
2803 PARSE_LANGOPT(C99);
Peter Collingbourne7e7fbd02011-04-15 00:35:23 +00002804 PARSE_LANGOPT(C1X);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00002805 PARSE_LANGOPT(Microsoft);
2806 PARSE_LANGOPT(CPlusPlus);
2807 PARSE_LANGOPT(CPlusPlus0x);
2808 PARSE_LANGOPT(CXXOperatorNames);
2809 PARSE_LANGOPT(ObjC1);
2810 PARSE_LANGOPT(ObjC2);
2811 PARSE_LANGOPT(ObjCNonFragileABI);
Fariborz Jahanian412e7982010-02-09 19:31:38 +00002812 PARSE_LANGOPT(ObjCNonFragileABI2);
Fariborz Jahanianf84109e2011-01-07 18:59:25 +00002813 PARSE_LANGOPT(AppleKext);
Ted Kremenekc32647d2010-12-23 21:35:43 +00002814 PARSE_LANGOPT(ObjCDefaultSynthProperties);
Fariborz Jahanian4c9d8d02010-04-22 21:01:59 +00002815 PARSE_LANGOPT(NoConstantCFStrings);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00002816 PARSE_LANGOPT(PascalStrings);
2817 PARSE_LANGOPT(WritableStrings);
2818 PARSE_LANGOPT(LaxVectorConversions);
Nate Begemanb9e7e632009-06-25 23:01:11 +00002819 PARSE_LANGOPT(AltiVec);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00002820 PARSE_LANGOPT(Exceptions);
Anders Carlssonda4b7cf2011-02-19 23:53:54 +00002821 PARSE_LANGOPT(ObjCExceptions);
Anders Carlsson7da99b02011-02-23 03:04:54 +00002822 PARSE_LANGOPT(CXXExceptions);
2823 PARSE_LANGOPT(SjLjExceptions);
Douglas Gregor6f755502011-02-01 15:15:22 +00002824 PARSE_LANGOPT(MSBitfields);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00002825 PARSE_LANGOPT(NeXTRuntime);
2826 PARSE_LANGOPT(Freestanding);
2827 PARSE_LANGOPT(NoBuiltin);
2828 PARSE_LANGOPT(ThreadsafeStatics);
Douglas Gregor972d9542009-09-03 14:36:33 +00002829 PARSE_LANGOPT(POSIXThreads);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00002830 PARSE_LANGOPT(Blocks);
2831 PARSE_LANGOPT(EmitAllDecls);
2832 PARSE_LANGOPT(MathErrno);
Chris Lattnera4d71452010-06-26 21:25:03 +00002833 LangOpts.setSignedOverflowBehavior((LangOptions::SignedOverflowBehaviorTy)
2834 Record[Idx++]);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00002835 PARSE_LANGOPT(HeinousExtensions);
2836 PARSE_LANGOPT(Optimize);
2837 PARSE_LANGOPT(OptimizeSize);
2838 PARSE_LANGOPT(Static);
2839 PARSE_LANGOPT(PICLevel);
2840 PARSE_LANGOPT(GNUInline);
2841 PARSE_LANGOPT(NoInline);
Chandler Carruth0d2d1bc2011-04-23 20:05:38 +00002842 PARSE_LANGOPT(Deprecated);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00002843 PARSE_LANGOPT(AccessControl);
2844 PARSE_LANGOPT(CharIsSigned);
John Thompsona6fda122009-11-05 20:14:16 +00002845 PARSE_LANGOPT(ShortWChar);
Argyrios Kyrtzidisb1bdced2011-01-15 02:56:16 +00002846 PARSE_LANGOPT(ShortEnums);
Chris Lattnera4d71452010-06-26 21:25:03 +00002847 LangOpts.setGCMode((LangOptions::GCMode)Record[Idx++]);
John McCall1fb0caa2010-10-22 21:05:15 +00002848 LangOpts.setVisibilityMode((Visibility)Record[Idx++]);
Daniel Dunbarab8e2812009-09-21 04:16:19 +00002849 LangOpts.setStackProtectorMode((LangOptions::StackProtectorMode)
Chris Lattnera4d71452010-06-26 21:25:03 +00002850 Record[Idx++]);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00002851 PARSE_LANGOPT(InstantiationDepth);
Nate Begemanb9e7e632009-06-25 23:01:11 +00002852 PARSE_LANGOPT(OpenCL);
Peter Collingbourne08a53262010-12-01 19:14:57 +00002853 PARSE_LANGOPT(CUDA);
Mike Stump9c276ae2009-12-12 01:27:46 +00002854 PARSE_LANGOPT(CatchUndefined);
Peter Collingbourne84bccea2011-02-15 19:46:30 +00002855 PARSE_LANGOPT(DefaultFPContract);
Roman Divacky1c51b1c2011-03-01 17:36:40 +00002856 PARSE_LANGOPT(ElideConstructors);
2857 PARSE_LANGOPT(SpellChecking);
Roman Divackycfe9af22011-03-01 17:40:53 +00002858 PARSE_LANGOPT(MRTD);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00002859 #undef PARSE_LANGOPT
Douglas Gregor0a0428e2009-04-10 20:39:37 +00002860
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00002861 return Listener->ReadLanguageOptions(LangOpts);
Douglas Gregor0a0428e2009-04-10 20:39:37 +00002862 }
Douglas Gregor0a0428e2009-04-10 20:39:37 +00002863
2864 return false;
2865}
2866
Sebastian Redlc43b54c2010-08-18 23:56:43 +00002867void ASTReader::ReadPreprocessedEntities() {
Douglas Gregor4800a5c2011-02-08 21:58:10 +00002868 for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
2869 PerFileData &F = *Chain[I];
2870 if (!F.PreprocessorDetailCursor.getBitStreamReader())
2871 continue;
2872
2873 SavedStreamPosition SavedPosition(F.PreprocessorDetailCursor);
2874 F.PreprocessorDetailCursor.JumpToBit(F.PreprocessorDetailStartOffset);
2875 while (LoadPreprocessedEntity(F)) { }
2876 }
Douglas Gregor6a5a23f2010-03-19 21:51:54 +00002877}
2878
Douglas Gregor0a480292011-02-11 19:46:30 +00002879PreprocessedEntity *ASTReader::ReadPreprocessedEntityAtOffset(uint64_t Offset) {
Douglas Gregor89d99802010-11-30 06:16:57 +00002880 PerFileData *F = 0;
2881 for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
2882 if (Offset < Chain[I]->SizeInBits) {
2883 F = Chain[I];
2884 break;
2885 }
2886
2887 Offset -= Chain[I]->SizeInBits;
2888 }
2889
2890 if (!F) {
2891 Error("Malformed preprocessed entity offset");
2892 return 0;
2893 }
2894
Douglas Gregor4800a5c2011-02-08 21:58:10 +00002895 // Keep track of where we are in the stream, then jump back there
2896 // after reading this entity.
2897 SavedStreamPosition SavedPosition(F->PreprocessorDetailCursor);
2898 F->PreprocessorDetailCursor.JumpToBit(Offset);
2899 return LoadPreprocessedEntity(*F);
Douglas Gregor89d99802010-11-30 06:16:57 +00002900}
2901
Douglas Gregorcfbf1c72011-02-10 17:09:37 +00002902HeaderFileInfo ASTReader::GetHeaderFileInfo(const FileEntry *FE) {
2903 HeaderFileInfoTrait Trait(FE->getName());
2904 for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
2905 PerFileData &F = *Chain[I];
2906 HeaderFileInfoLookupTable *Table
2907 = static_cast<HeaderFileInfoLookupTable *>(F.HeaderFileInfoTable);
2908 if (!Table)
2909 continue;
2910
2911 // Look in the on-disk hash table for an entry for this file name.
2912 HeaderFileInfoLookupTable::iterator Pos = Table->find(FE->getName(),
2913 &Trait);
2914 if (Pos == Table->end())
2915 continue;
2916
2917 HeaderFileInfo HFI = *Pos;
2918 if (Listener)
2919 Listener->ReadHeaderFileInfo(HFI, FE->getUID());
2920
2921 return HFI;
2922 }
2923
2924 return HeaderFileInfo();
2925}
2926
Argyrios Kyrtzidis3efd52c2011-01-14 20:54:07 +00002927void ASTReader::ReadPragmaDiagnosticMappings(Diagnostic &Diag) {
Argyrios Kyrtzidisf41d3be2010-11-05 22:10:18 +00002928 unsigned Idx = 0;
Argyrios Kyrtzidis3efd52c2011-01-14 20:54:07 +00002929 while (Idx < PragmaDiagMappings.size()) {
2930 SourceLocation
2931 Loc = SourceLocation::getFromRawEncoding(PragmaDiagMappings[Idx++]);
2932 while (1) {
2933 assert(Idx < PragmaDiagMappings.size() &&
2934 "Invalid data, didn't find '-1' marking end of diag/map pairs");
2935 if (Idx >= PragmaDiagMappings.size())
2936 break; // Something is messed up but at least avoid infinite loop in
2937 // release build.
2938 unsigned DiagID = PragmaDiagMappings[Idx++];
2939 if (DiagID == (unsigned)-1)
2940 break; // no more diag/map pairs for this location.
2941 diag::Mapping Map = (diag::Mapping)PragmaDiagMappings[Idx++];
2942 Diag.setDiagnosticMapping(DiagID, Map, Loc);
2943 }
Argyrios Kyrtzidisf41d3be2010-11-05 22:10:18 +00002944 }
2945}
2946
Sebastian Redlaaec0aa2010-07-20 22:37:49 +00002947/// \brief Get the correct cursor and offset for loading a type.
Sebastian Redlc43b54c2010-08-18 23:56:43 +00002948ASTReader::RecordLocation ASTReader::TypeCursorForIndex(unsigned Index) {
Sebastian Redlaaec0aa2010-07-20 22:37:49 +00002949 PerFileData *F = 0;
2950 for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
2951 F = Chain[N - I - 1];
2952 if (Index < F->LocalNumTypes)
2953 break;
2954 Index -= F->LocalNumTypes;
2955 }
2956 assert(F && F->LocalNumTypes > Index && "Broken chain");
Sebastian Redlc3632732010-10-05 15:59:54 +00002957 return RecordLocation(F, F->TypeOffsets[Index]);
Sebastian Redlaaec0aa2010-07-20 22:37:49 +00002958}
2959
2960/// \brief Read and return the type with the given index..
Douglas Gregor2cf26342009-04-09 22:27:44 +00002961///
Sebastian Redlaaec0aa2010-07-20 22:37:49 +00002962/// The index is the type ID, shifted and minus the number of predefs. This
2963/// routine actually reads the record corresponding to the type at the given
2964/// location. It is a helper routine for GetType, which deals with reading type
2965/// IDs.
Sebastian Redlc43b54c2010-08-18 23:56:43 +00002966QualType ASTReader::ReadTypeRecord(unsigned Index) {
Sebastian Redlaaec0aa2010-07-20 22:37:49 +00002967 RecordLocation Loc = TypeCursorForIndex(Index);
Sebastian Redlc3632732010-10-05 15:59:54 +00002968 llvm::BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;
Sebastian Redl9137a522010-07-16 17:50:48 +00002969
Douglas Gregor0b748912009-04-14 21:18:50 +00002970 // Keep track of where we are in the stream, then jump back there
2971 // after reading this type.
Douglas Gregor61d60ee2009-10-17 00:13:19 +00002972 SavedStreamPosition SavedPosition(DeclsCursor);
Douglas Gregor0b748912009-04-14 21:18:50 +00002973
Argyrios Kyrtzidis919e6932010-06-28 22:28:35 +00002974 ReadingKindTracker ReadingKind(Read_Type, *this);
Sebastian Redl27372b42010-08-11 18:52:41 +00002975
Douglas Gregord89275b2009-07-06 18:54:52 +00002976 // Note that we are loading a type record.
Argyrios Kyrtzidis29ee3a22010-07-30 10:03:16 +00002977 Deserializing AType(this);
Mike Stump1eb44332009-09-09 15:08:12 +00002978
Sebastian Redlc3632732010-10-05 15:59:54 +00002979 DeclsCursor.JumpToBit(Loc.Offset);
Douglas Gregor2cf26342009-04-09 22:27:44 +00002980 RecordData Record;
Douglas Gregor61d60ee2009-10-17 00:13:19 +00002981 unsigned Code = DeclsCursor.ReadCode();
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002982 switch ((TypeCode)DeclsCursor.ReadRecord(Code, Record)) {
2983 case TYPE_EXT_QUAL: {
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00002984 if (Record.size() != 2) {
2985 Error("Incorrect encoding of extended qualifier type");
2986 return QualType();
2987 }
Douglas Gregor6d473962009-04-15 22:00:08 +00002988 QualType Base = GetType(Record[0]);
John McCall0953e762009-09-24 19:53:00 +00002989 Qualifiers Quals = Qualifiers::fromOpaqueValue(Record[1]);
2990 return Context->getQualifiedType(Base, Quals);
Douglas Gregor6d473962009-04-15 22:00:08 +00002991 }
Douglas Gregorb4e715b2009-04-13 20:46:52 +00002992
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002993 case TYPE_COMPLEX: {
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00002994 if (Record.size() != 1) {
2995 Error("Incorrect encoding of complex type");
2996 return QualType();
2997 }
Douglas Gregor2cf26342009-04-09 22:27:44 +00002998 QualType ElemType = GetType(Record[0]);
Chris Lattnerd1d64a02009-04-27 21:45:14 +00002999 return Context->getComplexType(ElemType);
Douglas Gregor2cf26342009-04-09 22:27:44 +00003000 }
3001
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003002 case TYPE_POINTER: {
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00003003 if (Record.size() != 1) {
3004 Error("Incorrect encoding of pointer type");
3005 return QualType();
3006 }
Douglas Gregor2cf26342009-04-09 22:27:44 +00003007 QualType PointeeType = GetType(Record[0]);
Chris Lattnerd1d64a02009-04-27 21:45:14 +00003008 return Context->getPointerType(PointeeType);
Douglas Gregor2cf26342009-04-09 22:27:44 +00003009 }
3010
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003011 case TYPE_BLOCK_POINTER: {
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00003012 if (Record.size() != 1) {
3013 Error("Incorrect encoding of block pointer type");
3014 return QualType();
3015 }
Douglas Gregor2cf26342009-04-09 22:27:44 +00003016 QualType PointeeType = GetType(Record[0]);
Chris Lattnerd1d64a02009-04-27 21:45:14 +00003017 return Context->getBlockPointerType(PointeeType);
Douglas Gregor2cf26342009-04-09 22:27:44 +00003018 }
3019
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003020 case TYPE_LVALUE_REFERENCE: {
Richard Smithdf1550f2011-04-12 10:38:03 +00003021 if (Record.size() != 2) {
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00003022 Error("Incorrect encoding of lvalue reference type");
3023 return QualType();
3024 }
Douglas Gregor2cf26342009-04-09 22:27:44 +00003025 QualType PointeeType = GetType(Record[0]);
Richard Smithdf1550f2011-04-12 10:38:03 +00003026 return Context->getLValueReferenceType(PointeeType, Record[1]);
Douglas Gregor2cf26342009-04-09 22:27:44 +00003027 }
3028
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003029 case TYPE_RVALUE_REFERENCE: {
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00003030 if (Record.size() != 1) {
3031 Error("Incorrect encoding of rvalue reference type");
3032 return QualType();
3033 }
Douglas Gregor2cf26342009-04-09 22:27:44 +00003034 QualType PointeeType = GetType(Record[0]);
Chris Lattnerd1d64a02009-04-27 21:45:14 +00003035 return Context->getRValueReferenceType(PointeeType);
Douglas Gregor2cf26342009-04-09 22:27:44 +00003036 }
3037
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003038 case TYPE_MEMBER_POINTER: {
Argyrios Kyrtzidis240437b2010-07-02 11:55:15 +00003039 if (Record.size() != 2) {
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00003040 Error("Incorrect encoding of member pointer type");
3041 return QualType();
3042 }
Douglas Gregor2cf26342009-04-09 22:27:44 +00003043 QualType PointeeType = GetType(Record[0]);
3044 QualType ClassType = GetType(Record[1]);
Douglas Gregor1ab55e92010-12-10 17:03:06 +00003045 if (PointeeType.isNull() || ClassType.isNull())
3046 return QualType();
3047
Chris Lattnerd1d64a02009-04-27 21:45:14 +00003048 return Context->getMemberPointerType(PointeeType, ClassType.getTypePtr());
Douglas Gregor2cf26342009-04-09 22:27:44 +00003049 }
3050
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003051 case TYPE_CONSTANT_ARRAY: {
Douglas Gregorb4e715b2009-04-13 20:46:52 +00003052 QualType ElementType = GetType(Record[0]);
3053 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
3054 unsigned IndexTypeQuals = Record[2];
3055 unsigned Idx = 3;
3056 llvm::APInt Size = ReadAPInt(Record, Idx);
Douglas Gregor7e7eb3d2009-07-06 15:59:29 +00003057 return Context->getConstantArrayType(ElementType, Size,
3058 ASM, IndexTypeQuals);
3059 }
3060
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003061 case TYPE_INCOMPLETE_ARRAY: {
Douglas Gregorb4e715b2009-04-13 20:46:52 +00003062 QualType ElementType = GetType(Record[0]);
3063 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
3064 unsigned IndexTypeQuals = Record[2];
Chris Lattnerd1d64a02009-04-27 21:45:14 +00003065 return Context->getIncompleteArrayType(ElementType, ASM, IndexTypeQuals);
Douglas Gregorb4e715b2009-04-13 20:46:52 +00003066 }
3067
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003068 case TYPE_VARIABLE_ARRAY: {
Douglas Gregor0b748912009-04-14 21:18:50 +00003069 QualType ElementType = GetType(Record[0]);
3070 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
3071 unsigned IndexTypeQuals = Record[2];
Sebastian Redlc3632732010-10-05 15:59:54 +00003072 SourceLocation LBLoc = ReadSourceLocation(*Loc.F, Record[3]);
3073 SourceLocation RBLoc = ReadSourceLocation(*Loc.F, Record[4]);
3074 return Context->getVariableArrayType(ElementType, ReadExpr(*Loc.F),
Douglas Gregor7e7eb3d2009-07-06 15:59:29 +00003075 ASM, IndexTypeQuals,
3076 SourceRange(LBLoc, RBLoc));
Douglas Gregorb4e715b2009-04-13 20:46:52 +00003077 }
3078
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003079 case TYPE_VECTOR: {
Chris Lattner788b0fd2010-06-23 06:00:24 +00003080 if (Record.size() != 3) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00003081 Error("incorrect encoding of vector type in AST file");
Douglas Gregorb4e715b2009-04-13 20:46:52 +00003082 return QualType();
3083 }
3084
3085 QualType ElementType = GetType(Record[0]);
3086 unsigned NumElements = Record[1];
Bob Wilsone86d78c2010-11-10 21:56:12 +00003087 unsigned VecKind = Record[2];
Chris Lattner788b0fd2010-06-23 06:00:24 +00003088 return Context->getVectorType(ElementType, NumElements,
Bob Wilsone86d78c2010-11-10 21:56:12 +00003089 (VectorType::VectorKind)VecKind);
Douglas Gregorb4e715b2009-04-13 20:46:52 +00003090 }
3091
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003092 case TYPE_EXT_VECTOR: {
Chris Lattner788b0fd2010-06-23 06:00:24 +00003093 if (Record.size() != 3) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00003094 Error("incorrect encoding of extended vector type in AST file");
Douglas Gregorb4e715b2009-04-13 20:46:52 +00003095 return QualType();
3096 }
3097
3098 QualType ElementType = GetType(Record[0]);
3099 unsigned NumElements = Record[1];
Chris Lattnerd1d64a02009-04-27 21:45:14 +00003100 return Context->getExtVectorType(ElementType, NumElements);
Douglas Gregorb4e715b2009-04-13 20:46:52 +00003101 }
3102
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003103 case TYPE_FUNCTION_NO_PROTO: {
Eli Friedmana49218e2011-04-09 08:18:08 +00003104 if (Record.size() != 5) {
Douglas Gregora02b1472009-04-28 21:53:25 +00003105 Error("incorrect encoding of no-proto function type");
Douglas Gregorb4e715b2009-04-13 20:46:52 +00003106 return QualType();
3107 }
3108 QualType ResultType = GetType(Record[0]);
Eli Friedmana49218e2011-04-09 08:18:08 +00003109 FunctionType::ExtInfo Info(Record[1], Record[2], Record[3], (CallingConv)Record[4]);
Rafael Espindola264ba482010-03-30 20:24:48 +00003110 return Context->getFunctionNoProtoType(ResultType, Info);
Douglas Gregorb4e715b2009-04-13 20:46:52 +00003111 }
3112
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003113 case TYPE_FUNCTION_PROTO: {
Douglas Gregorb4e715b2009-04-13 20:46:52 +00003114 QualType ResultType = GetType(Record[0]);
John McCalle23cf432010-12-14 08:05:40 +00003115
3116 FunctionProtoType::ExtProtoInfo EPI;
3117 EPI.ExtInfo = FunctionType::ExtInfo(/*noreturn*/ Record[1],
Eli Friedmana49218e2011-04-09 08:18:08 +00003118 /*hasregparm*/ Record[2],
3119 /*regparm*/ Record[3],
3120 static_cast<CallingConv>(Record[4]));
John McCalle23cf432010-12-14 08:05:40 +00003121
Eli Friedmana49218e2011-04-09 08:18:08 +00003122 unsigned Idx = 5;
Douglas Gregorb4e715b2009-04-13 20:46:52 +00003123 unsigned NumParams = Record[Idx++];
3124 llvm::SmallVector<QualType, 16> ParamTypes;
3125 for (unsigned I = 0; I != NumParams; ++I)
3126 ParamTypes.push_back(GetType(Record[Idx++]));
John McCalle23cf432010-12-14 08:05:40 +00003127
3128 EPI.Variadic = Record[Idx++];
3129 EPI.TypeQuals = Record[Idx++];
Douglas Gregorc938c162011-01-26 05:01:58 +00003130 EPI.RefQualifier = static_cast<RefQualifierKind>(Record[Idx++]);
Sebastian Redl60618fa2011-03-12 11:50:43 +00003131 ExceptionSpecificationType EST =
3132 static_cast<ExceptionSpecificationType>(Record[Idx++]);
3133 EPI.ExceptionSpecType = EST;
3134 if (EST == EST_Dynamic) {
3135 EPI.NumExceptions = Record[Idx++];
3136 llvm::SmallVector<QualType, 2> Exceptions;
3137 for (unsigned I = 0; I != EPI.NumExceptions; ++I)
3138 Exceptions.push_back(GetType(Record[Idx++]));
3139 EPI.Exceptions = Exceptions.data();
3140 } else if (EST == EST_ComputedNoexcept) {
3141 EPI.NoexceptExpr = ReadExpr(*Loc.F);
3142 }
Jay Foadbeaaccd2009-05-21 09:52:38 +00003143 return Context->getFunctionType(ResultType, ParamTypes.data(), NumParams,
John McCalle23cf432010-12-14 08:05:40 +00003144 EPI);
Douglas Gregorb4e715b2009-04-13 20:46:52 +00003145 }
3146
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003147 case TYPE_UNRESOLVED_USING:
John McCalled976492009-12-04 22:46:56 +00003148 return Context->getTypeDeclType(
3149 cast<UnresolvedUsingTypenameDecl>(GetDecl(Record[0])));
3150
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003151 case TYPE_TYPEDEF: {
Argyrios Kyrtzidis9763e222010-07-02 11:55:11 +00003152 if (Record.size() != 2) {
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00003153 Error("incorrect encoding of typedef type");
3154 return QualType();
3155 }
Richard Smith162e1c12011-04-15 14:24:37 +00003156 TypedefNameDecl *Decl = cast<TypedefNameDecl>(GetDecl(Record[0]));
Argyrios Kyrtzidis9763e222010-07-02 11:55:11 +00003157 QualType Canonical = GetType(Record[1]);
Douglas Gregor32adc8b2010-10-26 00:51:02 +00003158 if (!Canonical.isNull())
3159 Canonical = Context->getCanonicalType(Canonical);
Argyrios Kyrtzidis9763e222010-07-02 11:55:11 +00003160 return Context->getTypedefType(Decl, Canonical);
3161 }
Douglas Gregorb4e715b2009-04-13 20:46:52 +00003162
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003163 case TYPE_TYPEOF_EXPR:
Sebastian Redlc3632732010-10-05 15:59:54 +00003164 return Context->getTypeOfExprType(ReadExpr(*Loc.F));
Douglas Gregorb4e715b2009-04-13 20:46:52 +00003165
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003166 case TYPE_TYPEOF: {
Douglas Gregorb4e715b2009-04-13 20:46:52 +00003167 if (Record.size() != 1) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00003168 Error("incorrect encoding of typeof(type) in AST file");
Douglas Gregorb4e715b2009-04-13 20:46:52 +00003169 return QualType();
3170 }
3171 QualType UnderlyingType = GetType(Record[0]);
Chris Lattnerd1d64a02009-04-27 21:45:14 +00003172 return Context->getTypeOfType(UnderlyingType);
Douglas Gregorb4e715b2009-04-13 20:46:52 +00003173 }
Mike Stump1eb44332009-09-09 15:08:12 +00003174
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003175 case TYPE_DECLTYPE:
Sebastian Redlc3632732010-10-05 15:59:54 +00003176 return Context->getDecltypeType(ReadExpr(*Loc.F));
Anders Carlsson395b4752009-06-24 19:06:50 +00003177
Richard Smith34b41d92011-02-20 03:19:35 +00003178 case TYPE_AUTO:
3179 return Context->getAutoType(GetType(Record[0]));
3180
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003181 case TYPE_RECORD: {
Argyrios Kyrtzidisbe191102010-07-08 13:09:53 +00003182 if (Record.size() != 2) {
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00003183 Error("incorrect encoding of record type");
3184 return QualType();
3185 }
Argyrios Kyrtzidisbe191102010-07-08 13:09:53 +00003186 bool IsDependent = Record[0];
3187 QualType T = Context->getRecordType(cast<RecordDecl>(GetDecl(Record[1])));
John McCallf4c73712011-01-19 06:33:43 +00003188 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
Argyrios Kyrtzidisbe191102010-07-08 13:09:53 +00003189 return T;
3190 }
Douglas Gregorb4e715b2009-04-13 20:46:52 +00003191
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003192 case TYPE_ENUM: {
Argyrios Kyrtzidisbe191102010-07-08 13:09:53 +00003193 if (Record.size() != 2) {
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00003194 Error("incorrect encoding of enum type");
3195 return QualType();
3196 }
Argyrios Kyrtzidisbe191102010-07-08 13:09:53 +00003197 bool IsDependent = Record[0];
3198 QualType T = Context->getEnumType(cast<EnumDecl>(GetDecl(Record[1])));
John McCallf4c73712011-01-19 06:33:43 +00003199 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
Argyrios Kyrtzidisbe191102010-07-08 13:09:53 +00003200 return T;
3201 }
Douglas Gregor0a2b45e2009-04-13 18:14:40 +00003202
John McCall9d156a72011-01-06 01:58:22 +00003203 case TYPE_ATTRIBUTED: {
3204 if (Record.size() != 3) {
3205 Error("incorrect encoding of attributed type");
3206 return QualType();
3207 }
3208 QualType modifiedType = GetType(Record[0]);
3209 QualType equivalentType = GetType(Record[1]);
3210 AttributedType::Kind kind = static_cast<AttributedType::Kind>(Record[2]);
3211 return Context->getAttributedType(kind, modifiedType, equivalentType);
3212 }
3213
Abramo Bagnara075f8f12010-12-10 16:29:40 +00003214 case TYPE_PAREN: {
3215 if (Record.size() != 1) {
3216 Error("incorrect encoding of paren type");
3217 return QualType();
3218 }
3219 QualType InnerType = GetType(Record[0]);
3220 return Context->getParenType(InnerType);
3221 }
3222
Douglas Gregor7536dd52010-12-20 02:24:11 +00003223 case TYPE_PACK_EXPANSION: {
Douglas Gregorf9997a02011-02-01 15:24:58 +00003224 if (Record.size() != 2) {
Douglas Gregor7536dd52010-12-20 02:24:11 +00003225 Error("incorrect encoding of pack expansion type");
3226 return QualType();
3227 }
3228 QualType Pattern = GetType(Record[0]);
3229 if (Pattern.isNull())
3230 return QualType();
Douglas Gregorcded4f62011-01-14 17:04:44 +00003231 llvm::Optional<unsigned> NumExpansions;
3232 if (Record[1])
3233 NumExpansions = Record[1] - 1;
3234 return Context->getPackExpansionType(Pattern, NumExpansions);
Douglas Gregor7536dd52010-12-20 02:24:11 +00003235 }
3236
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003237 case TYPE_ELABORATED: {
Argyrios Kyrtzidis3acad622010-06-25 16:24:58 +00003238 unsigned Idx = 0;
3239 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
3240 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(Record, Idx);
3241 QualType NamedType = GetType(Record[Idx++]);
3242 return Context->getElaboratedType(Keyword, NNS, NamedType);
John McCall7da24312009-09-05 00:15:47 +00003243 }
3244
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003245 case TYPE_OBJC_INTERFACE: {
Chris Lattnerc6fa4452009-04-22 06:45:28 +00003246 unsigned Idx = 0;
3247 ObjCInterfaceDecl *ItfD = cast<ObjCInterfaceDecl>(GetDecl(Record[Idx++]));
John McCallc12c5bb2010-05-15 11:32:37 +00003248 return Context->getObjCInterfaceType(ItfD);
3249 }
3250
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003251 case TYPE_OBJC_OBJECT: {
John McCallc12c5bb2010-05-15 11:32:37 +00003252 unsigned Idx = 0;
3253 QualType Base = GetType(Record[Idx++]);
Chris Lattnerc6fa4452009-04-22 06:45:28 +00003254 unsigned NumProtos = Record[Idx++];
3255 llvm::SmallVector<ObjCProtocolDecl*, 4> Protos;
3256 for (unsigned I = 0; I != NumProtos; ++I)
3257 Protos.push_back(cast<ObjCProtocolDecl>(GetDecl(Record[Idx++])));
Michael J. Spencer20249a12010-10-21 03:16:25 +00003258 return Context->getObjCObjectType(Base, Protos.data(), NumProtos);
Chris Lattnerc6fa4452009-04-22 06:45:28 +00003259 }
Douglas Gregorb4e715b2009-04-13 20:46:52 +00003260
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003261 case TYPE_OBJC_OBJECT_POINTER: {
Chris Lattnerd7a3fcd2009-04-22 06:40:03 +00003262 unsigned Idx = 0;
John McCallc12c5bb2010-05-15 11:32:37 +00003263 QualType Pointee = GetType(Record[Idx++]);
3264 return Context->getObjCObjectPointerType(Pointee);
Chris Lattnerd7a3fcd2009-04-22 06:40:03 +00003265 }
Argyrios Kyrtzidis24fab412009-09-29 19:42:55 +00003266
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003267 case TYPE_SUBST_TEMPLATE_TYPE_PARM: {
John McCall49a832b2009-10-18 09:09:24 +00003268 unsigned Idx = 0;
3269 QualType Parm = GetType(Record[Idx++]);
3270 QualType Replacement = GetType(Record[Idx++]);
3271 return
3272 Context->getSubstTemplateTypeParmType(cast<TemplateTypeParmType>(Parm),
3273 Replacement);
3274 }
John McCall3cb0ebd2010-03-10 03:28:59 +00003275
Douglas Gregorc3069d62011-01-14 02:55:32 +00003276 case TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK: {
3277 unsigned Idx = 0;
3278 QualType Parm = GetType(Record[Idx++]);
3279 TemplateArgument ArgPack = ReadTemplateArgument(*Loc.F, Record, Idx);
3280 return Context->getSubstTemplateTypeParmPackType(
3281 cast<TemplateTypeParmType>(Parm),
3282 ArgPack);
3283 }
3284
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003285 case TYPE_INJECTED_CLASS_NAME: {
John McCall3cb0ebd2010-03-10 03:28:59 +00003286 CXXRecordDecl *D = cast<CXXRecordDecl>(GetDecl(Record[0]));
3287 QualType TST = GetType(Record[1]); // probably derivable
Argyrios Kyrtzidis43921b52010-07-02 11:55:20 +00003288 // FIXME: ASTContext::getInjectedClassNameType is not currently suitable
Sebastian Redl3c7f4132010-08-18 23:57:06 +00003289 // for AST reading, too much interdependencies.
Argyrios Kyrtzidis43921b52010-07-02 11:55:20 +00003290 return
3291 QualType(new (*Context, TypeAlignment) InjectedClassNameType(D, TST), 0);
John McCall3cb0ebd2010-03-10 03:28:59 +00003292 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00003293
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003294 case TYPE_TEMPLATE_TYPE_PARM: {
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00003295 unsigned Idx = 0;
3296 unsigned Depth = Record[Idx++];
3297 unsigned Index = Record[Idx++];
3298 bool Pack = Record[Idx++];
3299 IdentifierInfo *Name = GetIdentifierInfo(Record, Idx);
3300 return Context->getTemplateTypeParmType(Depth, Index, Pack, Name);
3301 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00003302
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003303 case TYPE_DEPENDENT_NAME: {
Argyrios Kyrtzidis8dfbd8b2010-06-24 08:57:31 +00003304 unsigned Idx = 0;
3305 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
3306 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(Record, Idx);
3307 const IdentifierInfo *Name = this->GetIdentifierInfo(Record, Idx);
Argyrios Kyrtzidisf48d45e2010-07-02 11:55:24 +00003308 QualType Canon = GetType(Record[Idx++]);
Douglas Gregor32adc8b2010-10-26 00:51:02 +00003309 if (!Canon.isNull())
3310 Canon = Context->getCanonicalType(Canon);
Argyrios Kyrtzidisf48d45e2010-07-02 11:55:24 +00003311 return Context->getDependentNameType(Keyword, NNS, Name, Canon);
Argyrios Kyrtzidis8dfbd8b2010-06-24 08:57:31 +00003312 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00003313
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003314 case TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION: {
Argyrios Kyrtzidis3acad622010-06-25 16:24:58 +00003315 unsigned Idx = 0;
3316 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
3317 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(Record, Idx);
3318 const IdentifierInfo *Name = this->GetIdentifierInfo(Record, Idx);
3319 unsigned NumArgs = Record[Idx++];
3320 llvm::SmallVector<TemplateArgument, 8> Args;
3321 Args.reserve(NumArgs);
3322 while (NumArgs--)
Sebastian Redlc3632732010-10-05 15:59:54 +00003323 Args.push_back(ReadTemplateArgument(*Loc.F, Record, Idx));
Argyrios Kyrtzidis3acad622010-06-25 16:24:58 +00003324 return Context->getDependentTemplateSpecializationType(Keyword, NNS, Name,
3325 Args.size(), Args.data());
3326 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00003327
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003328 case TYPE_DEPENDENT_SIZED_ARRAY: {
Argyrios Kyrtzidisae8b17f2010-06-30 08:49:25 +00003329 unsigned Idx = 0;
3330
3331 // ArrayType
3332 QualType ElementType = GetType(Record[Idx++]);
3333 ArrayType::ArraySizeModifier ASM
3334 = (ArrayType::ArraySizeModifier)Record[Idx++];
3335 unsigned IndexTypeQuals = Record[Idx++];
3336
3337 // DependentSizedArrayType
Sebastian Redlc3632732010-10-05 15:59:54 +00003338 Expr *NumElts = ReadExpr(*Loc.F);
3339 SourceRange Brackets = ReadSourceRange(*Loc.F, Record, Idx);
Argyrios Kyrtzidisae8b17f2010-06-30 08:49:25 +00003340
3341 return Context->getDependentSizedArrayType(ElementType, NumElts, ASM,
3342 IndexTypeQuals, Brackets);
3343 }
Argyrios Kyrtzidis90b715e2010-06-19 19:28:53 +00003344
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003345 case TYPE_TEMPLATE_SPECIALIZATION: {
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00003346 unsigned Idx = 0;
Argyrios Kyrtzidisbe191102010-07-08 13:09:53 +00003347 bool IsDependent = Record[Idx++];
Douglas Gregor1aee05d2011-01-15 06:45:20 +00003348 TemplateName Name = ReadTemplateName(*Loc.F, Record, Idx);
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00003349 llvm::SmallVector<TemplateArgument, 8> Args;
Sebastian Redlc3632732010-10-05 15:59:54 +00003350 ReadTemplateArgumentList(Args, *Loc.F, Record, Idx);
Argyrios Kyrtzidisdd41c142010-06-23 13:48:30 +00003351 QualType Canon = GetType(Record[Idx++]);
Argyrios Kyrtzidisbe191102010-07-08 13:09:53 +00003352 QualType T;
Argyrios Kyrtzidis9763e222010-07-02 11:55:11 +00003353 if (Canon.isNull())
Argyrios Kyrtzidisbe191102010-07-08 13:09:53 +00003354 T = Context->getCanonicalTemplateSpecializationType(Name, Args.data(),
3355 Args.size());
Argyrios Kyrtzidis9763e222010-07-02 11:55:11 +00003356 else
Argyrios Kyrtzidisbe191102010-07-08 13:09:53 +00003357 T = Context->getTemplateSpecializationType(Name, Args.data(),
3358 Args.size(), Canon);
John McCallf4c73712011-01-19 06:33:43 +00003359 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
Argyrios Kyrtzidisbe191102010-07-08 13:09:53 +00003360 return T;
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00003361 }
Douglas Gregor2cf26342009-04-09 22:27:44 +00003362 }
Douglas Gregor2cf26342009-04-09 22:27:44 +00003363 // Suppress a GCC warning
3364 return QualType();
3365}
3366
Sebastian Redlc3632732010-10-05 15:59:54 +00003367class clang::TypeLocReader : public TypeLocVisitor<TypeLocReader> {
Sebastian Redlc43b54c2010-08-18 23:56:43 +00003368 ASTReader &Reader;
Sebastian Redlc3632732010-10-05 15:59:54 +00003369 ASTReader::PerFileData &F;
Sebastian Redl577d4792010-07-22 22:43:28 +00003370 llvm::BitstreamCursor &DeclsCursor;
Sebastian Redlc43b54c2010-08-18 23:56:43 +00003371 const ASTReader::RecordData &Record;
John McCalla1ee0c52009-10-16 21:56:05 +00003372 unsigned &Idx;
3373
Sebastian Redlc3632732010-10-05 15:59:54 +00003374 SourceLocation ReadSourceLocation(const ASTReader::RecordData &R,
3375 unsigned &I) {
3376 return Reader.ReadSourceLocation(F, R, I);
3377 }
3378
John McCalla1ee0c52009-10-16 21:56:05 +00003379public:
Sebastian Redlc3632732010-10-05 15:59:54 +00003380 TypeLocReader(ASTReader &Reader, ASTReader::PerFileData &F,
Sebastian Redlc43b54c2010-08-18 23:56:43 +00003381 const ASTReader::RecordData &Record, unsigned &Idx)
Sebastian Redlc3632732010-10-05 15:59:54 +00003382 : Reader(Reader), F(F), DeclsCursor(F.DeclsCursor), Record(Record), Idx(Idx)
3383 { }
John McCalla1ee0c52009-10-16 21:56:05 +00003384
John McCall51bd8032009-10-18 01:05:36 +00003385 // We want compile-time assurance that we've enumerated all of
3386 // these, so unfortunately we have to declare them first, then
3387 // define them out-of-line.
3388#define ABSTRACT_TYPELOC(CLASS, PARENT)
John McCalla1ee0c52009-10-16 21:56:05 +00003389#define TYPELOC(CLASS, PARENT) \
John McCall51bd8032009-10-18 01:05:36 +00003390 void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc);
John McCalla1ee0c52009-10-16 21:56:05 +00003391#include "clang/AST/TypeLocNodes.def"
3392
John McCall51bd8032009-10-18 01:05:36 +00003393 void VisitFunctionTypeLoc(FunctionTypeLoc);
3394 void VisitArrayTypeLoc(ArrayTypeLoc);
John McCalla1ee0c52009-10-16 21:56:05 +00003395};
3396
John McCall51bd8032009-10-18 01:05:36 +00003397void TypeLocReader::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
John McCalla1ee0c52009-10-16 21:56:05 +00003398 // nothing to do
3399}
John McCall51bd8032009-10-18 01:05:36 +00003400void TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003401 TL.setBuiltinLoc(ReadSourceLocation(Record, Idx));
Douglas Gregorddf889a2010-01-18 18:04:31 +00003402 if (TL.needsExtraLocalData()) {
3403 TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Record[Idx++]));
3404 TL.setWrittenSignSpec(static_cast<DeclSpec::TSS>(Record[Idx++]));
3405 TL.setWrittenWidthSpec(static_cast<DeclSpec::TSW>(Record[Idx++]));
3406 TL.setModeAttr(Record[Idx++]);
3407 }
John McCalla1ee0c52009-10-16 21:56:05 +00003408}
John McCall51bd8032009-10-18 01:05:36 +00003409void TypeLocReader::VisitComplexTypeLoc(ComplexTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003410 TL.setNameLoc(ReadSourceLocation(Record, Idx));
John McCalla1ee0c52009-10-16 21:56:05 +00003411}
John McCall51bd8032009-10-18 01:05:36 +00003412void TypeLocReader::VisitPointerTypeLoc(PointerTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003413 TL.setStarLoc(ReadSourceLocation(Record, Idx));
John McCalla1ee0c52009-10-16 21:56:05 +00003414}
John McCall51bd8032009-10-18 01:05:36 +00003415void TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003416 TL.setCaretLoc(ReadSourceLocation(Record, Idx));
John McCalla1ee0c52009-10-16 21:56:05 +00003417}
John McCall51bd8032009-10-18 01:05:36 +00003418void TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003419 TL.setAmpLoc(ReadSourceLocation(Record, Idx));
John McCalla1ee0c52009-10-16 21:56:05 +00003420}
John McCall51bd8032009-10-18 01:05:36 +00003421void TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003422 TL.setAmpAmpLoc(ReadSourceLocation(Record, Idx));
John McCalla1ee0c52009-10-16 21:56:05 +00003423}
John McCall51bd8032009-10-18 01:05:36 +00003424void TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003425 TL.setStarLoc(ReadSourceLocation(Record, Idx));
Abramo Bagnarab6ab6c12011-03-05 14:42:21 +00003426 TL.setClassTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
John McCalla1ee0c52009-10-16 21:56:05 +00003427}
John McCall51bd8032009-10-18 01:05:36 +00003428void TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003429 TL.setLBracketLoc(ReadSourceLocation(Record, Idx));
3430 TL.setRBracketLoc(ReadSourceLocation(Record, Idx));
John McCalla1ee0c52009-10-16 21:56:05 +00003431 if (Record[Idx++])
Sebastian Redlc3632732010-10-05 15:59:54 +00003432 TL.setSizeExpr(Reader.ReadExpr(F));
Douglas Gregor61d60ee2009-10-17 00:13:19 +00003433 else
John McCall51bd8032009-10-18 01:05:36 +00003434 TL.setSizeExpr(0);
3435}
3436void TypeLocReader::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) {
3437 VisitArrayTypeLoc(TL);
3438}
3439void TypeLocReader::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) {
3440 VisitArrayTypeLoc(TL);
3441}
3442void TypeLocReader::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) {
3443 VisitArrayTypeLoc(TL);
3444}
3445void TypeLocReader::VisitDependentSizedArrayTypeLoc(
3446 DependentSizedArrayTypeLoc TL) {
3447 VisitArrayTypeLoc(TL);
3448}
3449void TypeLocReader::VisitDependentSizedExtVectorTypeLoc(
3450 DependentSizedExtVectorTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003451 TL.setNameLoc(ReadSourceLocation(Record, Idx));
John McCall51bd8032009-10-18 01:05:36 +00003452}
3453void TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003454 TL.setNameLoc(ReadSourceLocation(Record, Idx));
John McCall51bd8032009-10-18 01:05:36 +00003455}
3456void TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003457 TL.setNameLoc(ReadSourceLocation(Record, Idx));
John McCall51bd8032009-10-18 01:05:36 +00003458}
3459void TypeLocReader::VisitFunctionTypeLoc(FunctionTypeLoc TL) {
Abramo Bagnara796aa442011-03-12 11:17:06 +00003460 TL.setLocalRangeBegin(ReadSourceLocation(Record, Idx));
3461 TL.setLocalRangeEnd(ReadSourceLocation(Record, Idx));
Douglas Gregordab60ad2010-10-01 18:44:50 +00003462 TL.setTrailingReturn(Record[Idx++]);
John McCall51bd8032009-10-18 01:05:36 +00003463 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) {
John McCall86acc2a2009-10-23 01:28:53 +00003464 TL.setArg(i, cast_or_null<ParmVarDecl>(Reader.GetDecl(Record[Idx++])));
John McCall51bd8032009-10-18 01:05:36 +00003465 }
3466}
3467void TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) {
3468 VisitFunctionTypeLoc(TL);
3469}
3470void TypeLocReader::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) {
3471 VisitFunctionTypeLoc(TL);
3472}
John McCalled976492009-12-04 22:46:56 +00003473void TypeLocReader::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003474 TL.setNameLoc(ReadSourceLocation(Record, Idx));
John McCalled976492009-12-04 22:46:56 +00003475}
John McCall51bd8032009-10-18 01:05:36 +00003476void TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003477 TL.setNameLoc(ReadSourceLocation(Record, Idx));
John McCall51bd8032009-10-18 01:05:36 +00003478}
3479void TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003480 TL.setTypeofLoc(ReadSourceLocation(Record, Idx));
3481 TL.setLParenLoc(ReadSourceLocation(Record, Idx));
3482 TL.setRParenLoc(ReadSourceLocation(Record, Idx));
John McCall51bd8032009-10-18 01:05:36 +00003483}
3484void TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003485 TL.setTypeofLoc(ReadSourceLocation(Record, Idx));
3486 TL.setLParenLoc(ReadSourceLocation(Record, Idx));
3487 TL.setRParenLoc(ReadSourceLocation(Record, Idx));
3488 TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
John McCall51bd8032009-10-18 01:05:36 +00003489}
3490void TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003491 TL.setNameLoc(ReadSourceLocation(Record, Idx));
John McCall51bd8032009-10-18 01:05:36 +00003492}
Richard Smith34b41d92011-02-20 03:19:35 +00003493void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) {
3494 TL.setNameLoc(ReadSourceLocation(Record, Idx));
3495}
John McCall51bd8032009-10-18 01:05:36 +00003496void TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003497 TL.setNameLoc(ReadSourceLocation(Record, Idx));
John McCall51bd8032009-10-18 01:05:36 +00003498}
3499void TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003500 TL.setNameLoc(ReadSourceLocation(Record, Idx));
John McCall51bd8032009-10-18 01:05:36 +00003501}
John McCall9d156a72011-01-06 01:58:22 +00003502void TypeLocReader::VisitAttributedTypeLoc(AttributedTypeLoc TL) {
3503 TL.setAttrNameLoc(ReadSourceLocation(Record, Idx));
3504 if (TL.hasAttrOperand()) {
3505 SourceRange range;
3506 range.setBegin(ReadSourceLocation(Record, Idx));
3507 range.setEnd(ReadSourceLocation(Record, Idx));
3508 TL.setAttrOperandParensRange(range);
3509 }
3510 if (TL.hasAttrExprOperand()) {
3511 if (Record[Idx++])
3512 TL.setAttrExprOperand(Reader.ReadExpr(F));
3513 else
3514 TL.setAttrExprOperand(0);
3515 } else if (TL.hasAttrEnumOperand())
3516 TL.setAttrEnumOperandLoc(ReadSourceLocation(Record, Idx));
3517}
John McCall51bd8032009-10-18 01:05:36 +00003518void TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003519 TL.setNameLoc(ReadSourceLocation(Record, Idx));
John McCall51bd8032009-10-18 01:05:36 +00003520}
John McCall49a832b2009-10-18 09:09:24 +00003521void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc(
3522 SubstTemplateTypeParmTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003523 TL.setNameLoc(ReadSourceLocation(Record, Idx));
John McCall49a832b2009-10-18 09:09:24 +00003524}
Douglas Gregorc3069d62011-01-14 02:55:32 +00003525void TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc(
3526 SubstTemplateTypeParmPackTypeLoc TL) {
3527 TL.setNameLoc(ReadSourceLocation(Record, Idx));
3528}
John McCall51bd8032009-10-18 01:05:36 +00003529void TypeLocReader::VisitTemplateSpecializationTypeLoc(
3530 TemplateSpecializationTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003531 TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx));
3532 TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
3533 TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
John McCall833ca992009-10-29 08:12:44 +00003534 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
3535 TL.setArgLocInfo(i,
Sebastian Redlc3632732010-10-05 15:59:54 +00003536 Reader.GetTemplateArgumentLocInfo(F,
3537 TL.getTypePtr()->getArg(i).getKind(),
3538 Record, Idx));
John McCall51bd8032009-10-18 01:05:36 +00003539}
Abramo Bagnara075f8f12010-12-10 16:29:40 +00003540void TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) {
3541 TL.setLParenLoc(ReadSourceLocation(Record, Idx));
3542 TL.setRParenLoc(ReadSourceLocation(Record, Idx));
3543}
Abramo Bagnara465d41b2010-05-11 21:36:43 +00003544void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003545 TL.setKeywordLoc(ReadSourceLocation(Record, Idx));
Douglas Gregor9e876872011-03-01 18:12:44 +00003546 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
John McCall51bd8032009-10-18 01:05:36 +00003547}
John McCall3cb0ebd2010-03-10 03:28:59 +00003548void TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003549 TL.setNameLoc(ReadSourceLocation(Record, Idx));
John McCall3cb0ebd2010-03-10 03:28:59 +00003550}
Douglas Gregor4714c122010-03-31 17:34:00 +00003551void TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003552 TL.setKeywordLoc(ReadSourceLocation(Record, Idx));
Douglas Gregor2494dd02011-03-01 01:34:45 +00003553 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
Sebastian Redlc3632732010-10-05 15:59:54 +00003554 TL.setNameLoc(ReadSourceLocation(Record, Idx));
John McCall51bd8032009-10-18 01:05:36 +00003555}
John McCall33500952010-06-11 00:33:02 +00003556void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc(
3557 DependentTemplateSpecializationTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003558 TL.setKeywordLoc(ReadSourceLocation(Record, Idx));
Douglas Gregor94fdffa2011-03-01 20:11:18 +00003559 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
Sebastian Redlc3632732010-10-05 15:59:54 +00003560 TL.setNameLoc(ReadSourceLocation(Record, Idx));
3561 TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
3562 TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
John McCall33500952010-06-11 00:33:02 +00003563 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I)
3564 TL.setArgLocInfo(I,
Sebastian Redlc3632732010-10-05 15:59:54 +00003565 Reader.GetTemplateArgumentLocInfo(F,
3566 TL.getTypePtr()->getArg(I).getKind(),
3567 Record, Idx));
John McCall33500952010-06-11 00:33:02 +00003568}
Douglas Gregor7536dd52010-12-20 02:24:11 +00003569void TypeLocReader::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
3570 TL.setEllipsisLoc(ReadSourceLocation(Record, Idx));
3571}
John McCall51bd8032009-10-18 01:05:36 +00003572void TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003573 TL.setNameLoc(ReadSourceLocation(Record, Idx));
John McCallc12c5bb2010-05-15 11:32:37 +00003574}
3575void TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
3576 TL.setHasBaseTypeAsWritten(Record[Idx++]);
Sebastian Redlc3632732010-10-05 15:59:54 +00003577 TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
3578 TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
John McCall51bd8032009-10-18 01:05:36 +00003579 for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
Sebastian Redlc3632732010-10-05 15:59:54 +00003580 TL.setProtocolLoc(i, ReadSourceLocation(Record, Idx));
John McCalla1ee0c52009-10-16 21:56:05 +00003581}
John McCall54e14c42009-10-22 22:37:11 +00003582void TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003583 TL.setStarLoc(ReadSourceLocation(Record, Idx));
John McCall54e14c42009-10-22 22:37:11 +00003584}
John McCalla1ee0c52009-10-16 21:56:05 +00003585
Sebastian Redlc3632732010-10-05 15:59:54 +00003586TypeSourceInfo *ASTReader::GetTypeSourceInfo(PerFileData &F,
Sebastian Redl577d4792010-07-22 22:43:28 +00003587 const RecordData &Record,
John McCalla1ee0c52009-10-16 21:56:05 +00003588 unsigned &Idx) {
3589 QualType InfoTy = GetType(Record[Idx++]);
3590 if (InfoTy.isNull())
3591 return 0;
3592
John McCalla93c9342009-12-07 02:54:59 +00003593 TypeSourceInfo *TInfo = getContext()->CreateTypeSourceInfo(InfoTy);
Sebastian Redlc3632732010-10-05 15:59:54 +00003594 TypeLocReader TLR(*this, F, Record, Idx);
John McCalla93c9342009-12-07 02:54:59 +00003595 for (TypeLoc TL = TInfo->getTypeLoc(); !TL.isNull(); TL = TL.getNextTypeLoc())
John McCalla1ee0c52009-10-16 21:56:05 +00003596 TLR.Visit(TL);
John McCalla93c9342009-12-07 02:54:59 +00003597 return TInfo;
John McCalla1ee0c52009-10-16 21:56:05 +00003598}
Douglas Gregor2cf26342009-04-09 22:27:44 +00003599
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003600QualType ASTReader::GetType(TypeID ID) {
John McCall0953e762009-09-24 19:53:00 +00003601 unsigned FastQuals = ID & Qualifiers::FastMask;
3602 unsigned Index = ID >> Qualifiers::FastWidth;
Douglas Gregor2cf26342009-04-09 22:27:44 +00003603
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003604 if (Index < NUM_PREDEF_TYPE_IDS) {
Douglas Gregor2cf26342009-04-09 22:27:44 +00003605 QualType T;
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003606 switch ((PredefinedTypeIDs)Index) {
3607 case PREDEF_TYPE_NULL_ID: return QualType();
3608 case PREDEF_TYPE_VOID_ID: T = Context->VoidTy; break;
3609 case PREDEF_TYPE_BOOL_ID: T = Context->BoolTy; break;
Douglas Gregor2cf26342009-04-09 22:27:44 +00003610
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003611 case PREDEF_TYPE_CHAR_U_ID:
3612 case PREDEF_TYPE_CHAR_S_ID:
Douglas Gregor2cf26342009-04-09 22:27:44 +00003613 // FIXME: Check that the signedness of CharTy is correct!
Chris Lattnerd1d64a02009-04-27 21:45:14 +00003614 T = Context->CharTy;
Douglas Gregor2cf26342009-04-09 22:27:44 +00003615 break;
3616
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003617 case PREDEF_TYPE_UCHAR_ID: T = Context->UnsignedCharTy; break;
3618 case PREDEF_TYPE_USHORT_ID: T = Context->UnsignedShortTy; break;
3619 case PREDEF_TYPE_UINT_ID: T = Context->UnsignedIntTy; break;
3620 case PREDEF_TYPE_ULONG_ID: T = Context->UnsignedLongTy; break;
3621 case PREDEF_TYPE_ULONGLONG_ID: T = Context->UnsignedLongLongTy; break;
3622 case PREDEF_TYPE_UINT128_ID: T = Context->UnsignedInt128Ty; break;
3623 case PREDEF_TYPE_SCHAR_ID: T = Context->SignedCharTy; break;
3624 case PREDEF_TYPE_WCHAR_ID: T = Context->WCharTy; break;
3625 case PREDEF_TYPE_SHORT_ID: T = Context->ShortTy; break;
3626 case PREDEF_TYPE_INT_ID: T = Context->IntTy; break;
3627 case PREDEF_TYPE_LONG_ID: T = Context->LongTy; break;
3628 case PREDEF_TYPE_LONGLONG_ID: T = Context->LongLongTy; break;
3629 case PREDEF_TYPE_INT128_ID: T = Context->Int128Ty; break;
3630 case PREDEF_TYPE_FLOAT_ID: T = Context->FloatTy; break;
3631 case PREDEF_TYPE_DOUBLE_ID: T = Context->DoubleTy; break;
3632 case PREDEF_TYPE_LONGDOUBLE_ID: T = Context->LongDoubleTy; break;
3633 case PREDEF_TYPE_OVERLOAD_ID: T = Context->OverloadTy; break;
3634 case PREDEF_TYPE_DEPENDENT_ID: T = Context->DependentTy; break;
John McCall1de4d4e2011-04-07 08:22:57 +00003635 case PREDEF_TYPE_UNKNOWN_ANY: T = Context->UnknownAnyTy; break;
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003636 case PREDEF_TYPE_NULLPTR_ID: T = Context->NullPtrTy; break;
3637 case PREDEF_TYPE_CHAR16_ID: T = Context->Char16Ty; break;
3638 case PREDEF_TYPE_CHAR32_ID: T = Context->Char32Ty; break;
3639 case PREDEF_TYPE_OBJC_ID: T = Context->ObjCBuiltinIdTy; break;
3640 case PREDEF_TYPE_OBJC_CLASS: T = Context->ObjCBuiltinClassTy; break;
3641 case PREDEF_TYPE_OBJC_SEL: T = Context->ObjCBuiltinSelTy; break;
Douglas Gregor2cf26342009-04-09 22:27:44 +00003642 }
3643
3644 assert(!T.isNull() && "Unknown predefined type");
John McCall0953e762009-09-24 19:53:00 +00003645 return T.withFastQualifiers(FastQuals);
Douglas Gregor2cf26342009-04-09 22:27:44 +00003646 }
3647
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003648 Index -= NUM_PREDEF_TYPE_IDS;
Sebastian Redlaaec0aa2010-07-20 22:37:49 +00003649 assert(Index < TypesLoaded.size() && "Type index out-of-range");
Sebastian Redl07a353c2010-07-14 20:26:45 +00003650 if (TypesLoaded[Index].isNull()) {
Sebastian Redlaaec0aa2010-07-20 22:37:49 +00003651 TypesLoaded[Index] = ReadTypeRecord(Index);
Douglas Gregor97475832010-10-05 18:37:06 +00003652 if (TypesLoaded[Index].isNull())
3653 return QualType();
3654
Sebastian Redl3c7f4132010-08-18 23:57:06 +00003655 TypesLoaded[Index]->setFromAST();
Argyrios Kyrtzidis5d267682010-08-20 16:04:27 +00003656 TypeIdxs[TypesLoaded[Index]] = TypeIdx::fromTypeID(ID);
Sebastian Redl30c514c2010-07-14 23:45:08 +00003657 if (DeserializationListener)
Argyrios Kyrtzidisc8e5d512010-08-20 16:03:59 +00003658 DeserializationListener->TypeRead(TypeIdx::fromTypeID(ID),
Sebastian Redl1476ed42010-07-16 16:36:56 +00003659 TypesLoaded[Index]);
Sebastian Redl07a353c2010-07-14 20:26:45 +00003660 }
Mike Stump1eb44332009-09-09 15:08:12 +00003661
John McCall0953e762009-09-24 19:53:00 +00003662 return TypesLoaded[Index].withFastQualifiers(FastQuals);
Douglas Gregor2cf26342009-04-09 22:27:44 +00003663}
3664
Argyrios Kyrtzidis5d267682010-08-20 16:04:27 +00003665TypeID ASTReader::GetTypeID(QualType T) const {
3666 return MakeTypeID(T,
3667 std::bind1st(std::mem_fun(&ASTReader::GetTypeIdx), this));
3668}
3669
3670TypeIdx ASTReader::GetTypeIdx(QualType T) const {
3671 if (T.isNull())
3672 return TypeIdx();
3673 assert(!T.getLocalFastQualifiers());
3674
3675 TypeIdxMap::const_iterator I = TypeIdxs.find(T);
3676 // GetTypeIdx is mostly used for computing the hash of DeclarationNames and
3677 // comparing keys of ASTDeclContextNameLookupTable.
3678 // If the type didn't come from the AST file use a specially marked index
3679 // so that any hash/key comparison fail since no such index is stored
3680 // in a AST file.
3681 if (I == TypeIdxs.end())
3682 return TypeIdx(-1);
3683 return I->second;
3684}
3685
Douglas Gregor7c789c12010-10-29 22:39:52 +00003686unsigned ASTReader::getTotalNumCXXBaseSpecifiers() const {
3687 unsigned Result = 0;
3688 for (unsigned I = 0, N = Chain.size(); I != N; ++I)
3689 Result += Chain[I]->LocalNumCXXBaseSpecifiers;
3690
3691 return Result;
3692}
3693
John McCall833ca992009-10-29 08:12:44 +00003694TemplateArgumentLocInfo
Sebastian Redlc3632732010-10-05 15:59:54 +00003695ASTReader::GetTemplateArgumentLocInfo(PerFileData &F,
3696 TemplateArgument::ArgKind Kind,
John McCall833ca992009-10-29 08:12:44 +00003697 const RecordData &Record,
Argyrios Kyrtzidis919e6932010-06-28 22:28:35 +00003698 unsigned &Index) {
John McCall833ca992009-10-29 08:12:44 +00003699 switch (Kind) {
3700 case TemplateArgument::Expression:
Sebastian Redlc3632732010-10-05 15:59:54 +00003701 return ReadExpr(F);
John McCall833ca992009-10-29 08:12:44 +00003702 case TemplateArgument::Type:
Sebastian Redlc3632732010-10-05 15:59:54 +00003703 return GetTypeSourceInfo(F, Record, Index);
Douglas Gregor788cd062009-11-11 01:00:40 +00003704 case TemplateArgument::Template: {
Douglas Gregorb6744ef2011-03-02 17:09:35 +00003705 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
3706 Index);
Sebastian Redlc3632732010-10-05 15:59:54 +00003707 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
Douglas Gregorb6744ef2011-03-02 17:09:35 +00003708 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
Douglas Gregora7fc9012011-01-05 18:58:31 +00003709 SourceLocation());
3710 }
3711 case TemplateArgument::TemplateExpansion: {
Douglas Gregorb6744ef2011-03-02 17:09:35 +00003712 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
3713 Index);
Douglas Gregora7fc9012011-01-05 18:58:31 +00003714 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
Douglas Gregorba68eca2011-01-05 17:40:24 +00003715 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Index);
Douglas Gregorb6744ef2011-03-02 17:09:35 +00003716 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
Douglas Gregorba68eca2011-01-05 17:40:24 +00003717 EllipsisLoc);
Douglas Gregor788cd062009-11-11 01:00:40 +00003718 }
John McCall833ca992009-10-29 08:12:44 +00003719 case TemplateArgument::Null:
3720 case TemplateArgument::Integral:
3721 case TemplateArgument::Declaration:
3722 case TemplateArgument::Pack:
3723 return TemplateArgumentLocInfo();
3724 }
Jeffrey Yasskin9f61aa92009-12-12 05:05:38 +00003725 llvm_unreachable("unexpected template argument loc");
John McCall833ca992009-10-29 08:12:44 +00003726 return TemplateArgumentLocInfo();
3727}
3728
Argyrios Kyrtzidis17cfded2010-06-28 09:31:42 +00003729TemplateArgumentLoc
Sebastian Redlc3632732010-10-05 15:59:54 +00003730ASTReader::ReadTemplateArgumentLoc(PerFileData &F,
Sebastian Redl577d4792010-07-22 22:43:28 +00003731 const RecordData &Record, unsigned &Index) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003732 TemplateArgument Arg = ReadTemplateArgument(F, Record, Index);
Argyrios Kyrtzidis17cfded2010-06-28 09:31:42 +00003733
3734 if (Arg.getKind() == TemplateArgument::Expression) {
3735 if (Record[Index++]) // bool InfoHasSameExpr.
3736 return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo(Arg.getAsExpr()));
3737 }
Sebastian Redlc3632732010-10-05 15:59:54 +00003738 return TemplateArgumentLoc(Arg, GetTemplateArgumentLocInfo(F, Arg.getKind(),
Argyrios Kyrtzidis919e6932010-06-28 22:28:35 +00003739 Record, Index));
Argyrios Kyrtzidis44f8c372010-06-22 09:54:59 +00003740}
3741
Sebastian Redlc43b54c2010-08-18 23:56:43 +00003742Decl *ASTReader::GetExternalDecl(uint32_t ID) {
John McCall76bd1f32010-06-01 09:23:16 +00003743 return GetDecl(ID);
3744}
3745
Douglas Gregor7c789c12010-10-29 22:39:52 +00003746uint64_t
3747ASTReader::GetCXXBaseSpecifiersOffset(serialization::CXXBaseSpecifiersID ID) {
3748 if (ID == 0)
3749 return 0;
3750
3751 --ID;
3752 uint64_t Offset = 0;
3753 for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
Anders Carlssonf25330b2011-03-09 05:09:32 +00003754 PerFileData &F = *Chain[N - I - 1];
3755
3756 if (ID < F.LocalNumCXXBaseSpecifiers)
3757 return Offset + F.CXXBaseSpecifiersOffsets[ID];
Douglas Gregor7c789c12010-10-29 22:39:52 +00003758
Anders Carlssonf25330b2011-03-09 05:09:32 +00003759 ID -= F.LocalNumCXXBaseSpecifiers;
3760 Offset += F.SizeInBits;
Douglas Gregor7c789c12010-10-29 22:39:52 +00003761 }
3762
3763 assert(false && "CXXBaseSpecifiers not found");
3764 return 0;
3765}
3766
3767CXXBaseSpecifier *ASTReader::GetExternalCXXBaseSpecifiers(uint64_t Offset) {
3768 // Figure out which AST file contains this offset.
3769 PerFileData *F = 0;
3770 for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
Anders Carlssonf25330b2011-03-09 05:09:32 +00003771 if (Offset < Chain[N - I - 1]->SizeInBits) {
3772 F = Chain[N - I - 1];
Douglas Gregor7c789c12010-10-29 22:39:52 +00003773 break;
3774 }
3775
Anders Carlssonf25330b2011-03-09 05:09:32 +00003776 Offset -= Chain[N - I - 1]->SizeInBits;
Douglas Gregor7c789c12010-10-29 22:39:52 +00003777 }
Anders Carlssonf25330b2011-03-09 05:09:32 +00003778
Douglas Gregor7c789c12010-10-29 22:39:52 +00003779 if (!F) {
3780 Error("Malformed AST file: C++ base specifiers at impossible offset");
3781 return 0;
3782 }
3783
3784 llvm::BitstreamCursor &Cursor = F->DeclsCursor;
3785 SavedStreamPosition SavedPosition(Cursor);
3786 Cursor.JumpToBit(Offset);
3787 ReadingKindTracker ReadingKind(Read_Decl, *this);
3788 RecordData Record;
3789 unsigned Code = Cursor.ReadCode();
3790 unsigned RecCode = Cursor.ReadRecord(Code, Record);
3791 if (RecCode != DECL_CXX_BASE_SPECIFIERS) {
3792 Error("Malformed AST file: missing C++ base specifiers");
3793 return 0;
3794 }
3795
3796 unsigned Idx = 0;
3797 unsigned NumBases = Record[Idx++];
3798 void *Mem = Context->Allocate(sizeof(CXXBaseSpecifier) * NumBases);
3799 CXXBaseSpecifier *Bases = new (Mem) CXXBaseSpecifier [NumBases];
3800 for (unsigned I = 0; I != NumBases; ++I)
3801 Bases[I] = ReadCXXBaseSpecifier(*F, Record, Idx);
3802 return Bases;
3803}
3804
Sebastian Redlc43b54c2010-08-18 23:56:43 +00003805TranslationUnitDecl *ASTReader::GetTranslationUnitDecl() {
Sebastian Redl30c514c2010-07-14 23:45:08 +00003806 if (!DeclsLoaded[0]) {
Sebastian Redle1dde812010-08-24 00:50:04 +00003807 ReadDeclRecord(0, 1);
Sebastian Redl30c514c2010-07-14 23:45:08 +00003808 if (DeserializationListener)
Sebastian Redl1476ed42010-07-16 16:36:56 +00003809 DeserializationListener->DeclRead(1, DeclsLoaded[0]);
Sebastian Redl30c514c2010-07-14 23:45:08 +00003810 }
Argyrios Kyrtzidis8871a442010-07-08 17:13:02 +00003811
3812 return cast<TranslationUnitDecl>(DeclsLoaded[0]);
3813}
3814
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003815Decl *ASTReader::GetDecl(DeclID ID) {
Douglas Gregor2cf26342009-04-09 22:27:44 +00003816 if (ID == 0)
3817 return 0;
3818
Douglas Gregor8f5dc7f2009-04-25 18:35:21 +00003819 if (ID > DeclsLoaded.size()) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00003820 Error("declaration ID out-of-range for AST file");
Douglas Gregor8f5dc7f2009-04-25 18:35:21 +00003821 return 0;
3822 }
Douglas Gregor2cf26342009-04-09 22:27:44 +00003823
Douglas Gregor8f5dc7f2009-04-25 18:35:21 +00003824 unsigned Index = ID - 1;
Sebastian Redl30c514c2010-07-14 23:45:08 +00003825 if (!DeclsLoaded[Index]) {
Argyrios Kyrtzidisa8650052010-08-03 17:30:10 +00003826 ReadDeclRecord(Index, ID);
Sebastian Redl30c514c2010-07-14 23:45:08 +00003827 if (DeserializationListener)
3828 DeserializationListener->DeclRead(ID, DeclsLoaded[Index]);
3829 }
Douglas Gregor8f5dc7f2009-04-25 18:35:21 +00003830
3831 return DeclsLoaded[Index];
Douglas Gregor2cf26342009-04-09 22:27:44 +00003832}
3833
Chris Lattner887e2b32009-04-27 05:46:25 +00003834/// \brief Resolve the offset of a statement into a statement.
3835///
3836/// This operation will read a new statement from the external
3837/// source each time it is called, and is meant to be used via a
3838/// LazyOffsetPtr (which is used by Decls for the body of functions, etc).
Sebastian Redlc43b54c2010-08-18 23:56:43 +00003839Stmt *ASTReader::GetExternalDeclStmt(uint64_t Offset) {
Argyrios Kyrtzidise09a2752010-10-28 09:29:32 +00003840 // Switch case IDs are per Decl.
3841 ClearSwitchCaseIDs();
3842
Sebastian Redl0fa7d0b2010-07-22 17:01:13 +00003843 // Offset here is a global offset across the entire chain.
3844 for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
3845 PerFileData &F = *Chain[N - I - 1];
3846 if (Offset < F.SizeInBits) {
3847 // Since we know that this statement is part of a decl, make sure to use
3848 // the decl cursor to read it.
3849 F.DeclsCursor.JumpToBit(Offset);
Sebastian Redlc3632732010-10-05 15:59:54 +00003850 return ReadStmtFromStream(F);
Sebastian Redl0fa7d0b2010-07-22 17:01:13 +00003851 }
3852 Offset -= F.SizeInBits;
3853 }
3854 llvm_unreachable("Broken chain");
Douglas Gregor250fc9c2009-04-18 00:07:54 +00003855}
3856
Sebastian Redlc43b54c2010-08-18 23:56:43 +00003857bool ASTReader::FindExternalLexicalDecls(const DeclContext *DC,
Argyrios Kyrtzidiseb5e9982010-10-14 20:14:34 +00003858 bool (*isKindWeWant)(Decl::Kind),
John McCall76bd1f32010-06-01 09:23:16 +00003859 llvm::SmallVectorImpl<Decl*> &Decls) {
Mike Stump1eb44332009-09-09 15:08:12 +00003860 assert(DC->hasExternalLexicalStorage() &&
Douglas Gregor2cf26342009-04-09 22:27:44 +00003861 "DeclContext has no lexical decls in storage");
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00003862
Sebastian Redl0fa7d0b2010-07-22 17:01:13 +00003863 // There might be lexical decls in multiple parts of the chain, for the TU
3864 // at least.
Sebastian Redl4a9eb262010-09-28 02:24:44 +00003865 // DeclContextOffsets might reallocate as we load additional decls below,
3866 // so make a copy of the vector.
3867 DeclContextInfos Infos = DeclContextOffsets[DC];
Sebastian Redl0fa7d0b2010-07-22 17:01:13 +00003868 for (DeclContextInfos::iterator I = Infos.begin(), E = Infos.end();
3869 I != E; ++I) {
Sebastian Redl681d7232010-07-27 00:17:23 +00003870 // IDs can be 0 if this context doesn't contain declarations.
3871 if (!I->LexicalDecls)
Sebastian Redl0fa7d0b2010-07-22 17:01:13 +00003872 continue;
Sebastian Redl0fa7d0b2010-07-22 17:01:13 +00003873
3874 // Load all of the declaration IDs
Argyrios Kyrtzidiseb5e9982010-10-14 20:14:34 +00003875 for (const KindDeclIDPair *ID = I->LexicalDecls,
3876 *IDE = ID + I->NumLexicalDecls; ID != IDE; ++ID) {
3877 if (isKindWeWant && !isKindWeWant((Decl::Kind)ID->first))
3878 continue;
3879
3880 Decl *D = GetDecl(ID->second);
Sebastian Redl4a9eb262010-09-28 02:24:44 +00003881 assert(D && "Null decl in lexical decls");
3882 Decls.push_back(D);
3883 }
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00003884 }
Douglas Gregor2cf26342009-04-09 22:27:44 +00003885
Douglas Gregor25123082009-04-22 22:34:57 +00003886 ++NumLexicalDeclContextsRead;
Douglas Gregor2cf26342009-04-09 22:27:44 +00003887 return false;
3888}
3889
John McCall76bd1f32010-06-01 09:23:16 +00003890DeclContext::lookup_result
Sebastian Redlc43b54c2010-08-18 23:56:43 +00003891ASTReader::FindExternalVisibleDeclsByName(const DeclContext *DC,
John McCall76bd1f32010-06-01 09:23:16 +00003892 DeclarationName Name) {
Mike Stump1eb44332009-09-09 15:08:12 +00003893 assert(DC->hasExternalVisibleStorage() &&
Douglas Gregor2cf26342009-04-09 22:27:44 +00003894 "DeclContext has no visible decls in storage");
Argyrios Kyrtzidis074dcc82010-08-20 16:04:35 +00003895 if (!Name)
3896 return DeclContext::lookup_result(DeclContext::lookup_iterator(0),
3897 DeclContext::lookup_iterator(0));
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00003898
Argyrios Kyrtzidis074dcc82010-08-20 16:04:35 +00003899 llvm::SmallVector<NamedDecl *, 64> Decls;
Sebastian Redl8b122732010-08-24 00:49:55 +00003900 // There might be visible decls in multiple parts of the chain, for the TU
Sebastian Redl5967d622010-08-24 00:50:16 +00003901 // and namespaces. For any given name, the last available results replace
3902 // all earlier ones. For this reason, we walk in reverse.
Sebastian Redl0fa7d0b2010-07-22 17:01:13 +00003903 DeclContextInfos &Infos = DeclContextOffsets[DC];
Sebastian Redl5967d622010-08-24 00:50:16 +00003904 for (DeclContextInfos::reverse_iterator I = Infos.rbegin(), E = Infos.rend();
Sebastian Redl0fa7d0b2010-07-22 17:01:13 +00003905 I != E; ++I) {
Argyrios Kyrtzidis074dcc82010-08-20 16:04:35 +00003906 if (!I->NameLookupTableData)
Sebastian Redl0fa7d0b2010-07-22 17:01:13 +00003907 continue;
Douglas Gregor2cf26342009-04-09 22:27:44 +00003908
Argyrios Kyrtzidis074dcc82010-08-20 16:04:35 +00003909 ASTDeclContextNameLookupTable *LookupTable =
3910 (ASTDeclContextNameLookupTable*)I->NameLookupTableData;
3911 ASTDeclContextNameLookupTable::iterator Pos = LookupTable->find(Name);
3912 if (Pos == LookupTable->end())
Sebastian Redl0fa7d0b2010-07-22 17:01:13 +00003913 continue;
3914
Argyrios Kyrtzidis074dcc82010-08-20 16:04:35 +00003915 ASTDeclContextNameLookupTrait::data_type Data = *Pos;
3916 for (; Data.first != Data.second; ++Data.first)
3917 Decls.push_back(cast<NamedDecl>(GetDecl(*Data.first)));
Sebastian Redl5967d622010-08-24 00:50:16 +00003918 break;
Douglas Gregor2cf26342009-04-09 22:27:44 +00003919 }
3920
Douglas Gregor25123082009-04-22 22:34:57 +00003921 ++NumVisibleDeclContextsRead;
John McCall76bd1f32010-06-01 09:23:16 +00003922
Argyrios Kyrtzidis074dcc82010-08-20 16:04:35 +00003923 SetExternalVisibleDeclsForName(DC, Name, Decls);
John McCall76bd1f32010-06-01 09:23:16 +00003924 return const_cast<DeclContext*>(DC)->lookup(Name);
Douglas Gregor2cf26342009-04-09 22:27:44 +00003925}
3926
Argyrios Kyrtzidisa60786b2010-08-20 23:35:55 +00003927void ASTReader::MaterializeVisibleDecls(const DeclContext *DC) {
3928 assert(DC->hasExternalVisibleStorage() &&
3929 "DeclContext has no visible decls in storage");
3930
3931 llvm::SmallVector<NamedDecl *, 64> Decls;
3932 // There might be visible decls in multiple parts of the chain, for the TU
3933 // and namespaces.
3934 DeclContextInfos &Infos = DeclContextOffsets[DC];
3935 for (DeclContextInfos::iterator I = Infos.begin(), E = Infos.end();
3936 I != E; ++I) {
3937 if (!I->NameLookupTableData)
3938 continue;
3939
3940 ASTDeclContextNameLookupTable *LookupTable =
3941 (ASTDeclContextNameLookupTable*)I->NameLookupTableData;
3942 for (ASTDeclContextNameLookupTable::item_iterator
3943 ItemI = LookupTable->item_begin(),
3944 ItemEnd = LookupTable->item_end() ; ItemI != ItemEnd; ++ItemI) {
3945 ASTDeclContextNameLookupTable::item_iterator::value_type Val
3946 = *ItemI;
3947 ASTDeclContextNameLookupTrait::data_type Data = Val.second;
3948 Decls.clear();
3949 for (; Data.first != Data.second; ++Data.first)
3950 Decls.push_back(cast<NamedDecl>(GetDecl(*Data.first)));
3951 MaterializeVisibleDeclsForName(DC, Val.first, Decls);
3952 }
3953 }
3954}
3955
Sebastian Redlc43b54c2010-08-18 23:56:43 +00003956void ASTReader::PassInterestingDeclsToConsumer() {
Argyrios Kyrtzidisbb80a8e2010-07-07 15:46:26 +00003957 assert(Consumer);
3958 while (!InterestingDecls.empty()) {
3959 DeclGroupRef DG(InterestingDecls.front());
3960 InterestingDecls.pop_front();
Sebastian Redl27372b42010-08-11 18:52:41 +00003961 Consumer->HandleInterestingDecl(DG);
Argyrios Kyrtzidisbb80a8e2010-07-07 15:46:26 +00003962 }
3963}
3964
Sebastian Redlc43b54c2010-08-18 23:56:43 +00003965void ASTReader::StartTranslationUnit(ASTConsumer *Consumer) {
Douglas Gregor0af2ca42009-04-22 19:09:20 +00003966 this->Consumer = Consumer;
3967
Douglas Gregorfdd01722009-04-14 00:24:19 +00003968 if (!Consumer)
3969 return;
3970
3971 for (unsigned I = 0, N = ExternalDefinitions.size(); I != N; ++I) {
Argyrios Kyrtzidisbb80a8e2010-07-07 15:46:26 +00003972 // Force deserialization of this decl, which will cause it to be queued for
3973 // passing to the consumer.
Daniel Dunbar04a0b502009-09-17 03:06:44 +00003974 GetDecl(ExternalDefinitions[I]);
Douglas Gregorfdd01722009-04-14 00:24:19 +00003975 }
Douglas Gregorc62a2fe2009-04-25 00:41:30 +00003976
Argyrios Kyrtzidisbb80a8e2010-07-07 15:46:26 +00003977 PassInterestingDeclsToConsumer();
Douglas Gregorfdd01722009-04-14 00:24:19 +00003978}
3979
Sebastian Redlc43b54c2010-08-18 23:56:43 +00003980void ASTReader::PrintStats() {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00003981 std::fprintf(stderr, "*** AST File Statistics:\n");
Douglas Gregor2cf26342009-04-09 22:27:44 +00003982
Mike Stump1eb44332009-09-09 15:08:12 +00003983 unsigned NumTypesLoaded
Douglas Gregor2b3a5a82009-04-25 19:10:14 +00003984 = TypesLoaded.size() - std::count(TypesLoaded.begin(), TypesLoaded.end(),
John McCall0953e762009-09-24 19:53:00 +00003985 QualType());
Douglas Gregor2b3a5a82009-04-25 19:10:14 +00003986 unsigned NumDeclsLoaded
3987 = DeclsLoaded.size() - std::count(DeclsLoaded.begin(), DeclsLoaded.end(),
3988 (Decl *)0);
3989 unsigned NumIdentifiersLoaded
3990 = IdentifiersLoaded.size() - std::count(IdentifiersLoaded.begin(),
3991 IdentifiersLoaded.end(),
3992 (IdentifierInfo *)0);
Mike Stump1eb44332009-09-09 15:08:12 +00003993 unsigned NumSelectorsLoaded
Douglas Gregor2b3a5a82009-04-25 19:10:14 +00003994 = SelectorsLoaded.size() - std::count(SelectorsLoaded.begin(),
3995 SelectorsLoaded.end(),
3996 Selector());
Douglas Gregor2d41cc12009-04-13 20:50:16 +00003997
Douglas Gregor4fed3f42009-04-27 18:38:38 +00003998 std::fprintf(stderr, " %u stat cache hits\n", NumStatHits);
3999 std::fprintf(stderr, " %u stat cache misses\n", NumStatMisses);
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00004000 if (TotalNumSLocEntries)
4001 std::fprintf(stderr, " %u/%u source location entries read (%f%%)\n",
4002 NumSLocEntriesRead, TotalNumSLocEntries,
4003 ((float)NumSLocEntriesRead/TotalNumSLocEntries * 100));
Douglas Gregor8f5dc7f2009-04-25 18:35:21 +00004004 if (!TypesLoaded.empty())
Douglas Gregor83941df2009-04-25 17:48:32 +00004005 std::fprintf(stderr, " %u/%u types read (%f%%)\n",
Douglas Gregor8f5dc7f2009-04-25 18:35:21 +00004006 NumTypesLoaded, (unsigned)TypesLoaded.size(),
4007 ((float)NumTypesLoaded/TypesLoaded.size() * 100));
4008 if (!DeclsLoaded.empty())
Douglas Gregor83941df2009-04-25 17:48:32 +00004009 std::fprintf(stderr, " %u/%u declarations read (%f%%)\n",
Douglas Gregor8f5dc7f2009-04-25 18:35:21 +00004010 NumDeclsLoaded, (unsigned)DeclsLoaded.size(),
4011 ((float)NumDeclsLoaded/DeclsLoaded.size() * 100));
Douglas Gregor2b3a5a82009-04-25 19:10:14 +00004012 if (!IdentifiersLoaded.empty())
Douglas Gregor83941df2009-04-25 17:48:32 +00004013 std::fprintf(stderr, " %u/%u identifiers read (%f%%)\n",
Douglas Gregor2b3a5a82009-04-25 19:10:14 +00004014 NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(),
4015 ((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100));
Sebastian Redl725cd962010-08-04 20:40:17 +00004016 if (!SelectorsLoaded.empty())
Douglas Gregor83941df2009-04-25 17:48:32 +00004017 std::fprintf(stderr, " %u/%u selectors read (%f%%)\n",
Sebastian Redl725cd962010-08-04 20:40:17 +00004018 NumSelectorsLoaded, (unsigned)SelectorsLoaded.size(),
4019 ((float)NumSelectorsLoaded/SelectorsLoaded.size() * 100));
Douglas Gregor83941df2009-04-25 17:48:32 +00004020 if (TotalNumStatements)
4021 std::fprintf(stderr, " %u/%u statements read (%f%%)\n",
4022 NumStatementsRead, TotalNumStatements,
4023 ((float)NumStatementsRead/TotalNumStatements * 100));
4024 if (TotalNumMacros)
4025 std::fprintf(stderr, " %u/%u macros read (%f%%)\n",
4026 NumMacrosRead, TotalNumMacros,
4027 ((float)NumMacrosRead/TotalNumMacros * 100));
4028 if (TotalLexicalDeclContexts)
4029 std::fprintf(stderr, " %u/%u lexical declcontexts read (%f%%)\n",
4030 NumLexicalDeclContextsRead, TotalLexicalDeclContexts,
4031 ((float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts
4032 * 100));
4033 if (TotalVisibleDeclContexts)
4034 std::fprintf(stderr, " %u/%u visible declcontexts read (%f%%)\n",
4035 NumVisibleDeclContextsRead, TotalVisibleDeclContexts,
4036 ((float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts
4037 * 100));
Sebastian Redlfa78dec2010-08-04 21:22:45 +00004038 if (TotalNumMethodPoolEntries) {
Douglas Gregor83941df2009-04-25 17:48:32 +00004039 std::fprintf(stderr, " %u/%u method pool entries read (%f%%)\n",
Sebastian Redlfa78dec2010-08-04 21:22:45 +00004040 NumMethodPoolEntriesRead, TotalNumMethodPoolEntries,
4041 ((float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries
Douglas Gregor83941df2009-04-25 17:48:32 +00004042 * 100));
Sebastian Redlfa78dec2010-08-04 21:22:45 +00004043 std::fprintf(stderr, " %u method pool misses\n", NumMethodPoolMisses);
Douglas Gregor83941df2009-04-25 17:48:32 +00004044 }
Douglas Gregor2cf26342009-04-09 22:27:44 +00004045 std::fprintf(stderr, "\n");
4046}
4047
Sebastian Redlc43b54c2010-08-18 23:56:43 +00004048void ASTReader::InitializeSema(Sema &S) {
Douglas Gregor668c1a42009-04-21 22:25:48 +00004049 SemaObj = &S;
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +00004050 S.ExternalSource = this;
4051
Douglas Gregor6cfc1a82009-04-22 21:15:06 +00004052 // Makes sure any declarations that were deserialized "too early"
4053 // still get added to the identifier's declaration chains.
Douglas Gregor76dc8892010-09-24 23:29:12 +00004054 for (unsigned I = 0, N = PreloadedDecls.size(); I != N; ++I) {
4055 if (SemaObj->TUScope)
John McCalld226f652010-08-21 09:40:31 +00004056 SemaObj->TUScope->AddDecl(PreloadedDecls[I]);
Douglas Gregor76dc8892010-09-24 23:29:12 +00004057
4058 SemaObj->IdResolver.AddDecl(PreloadedDecls[I]);
Douglas Gregor668c1a42009-04-21 22:25:48 +00004059 }
Douglas Gregor6cfc1a82009-04-22 21:15:06 +00004060 PreloadedDecls.clear();
Douglas Gregor4c0e86b2009-04-22 22:02:47 +00004061
4062 // If there were any tentative definitions, deserialize them and add
Sebastian Redle9d12b62010-01-31 22:27:38 +00004063 // them to Sema's list of tentative definitions.
Douglas Gregor4c0e86b2009-04-22 22:02:47 +00004064 for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) {
4065 VarDecl *Var = cast<VarDecl>(GetDecl(TentativeDefinitions[I]));
Sebastian Redle9d12b62010-01-31 22:27:38 +00004066 SemaObj->TentativeDefinitions.push_back(Var);
Douglas Gregor4c0e86b2009-04-22 22:02:47 +00004067 }
Kovarththanan Rajaratnam6b82f642010-03-07 19:10:13 +00004068
Argyrios Kyrtzidis49b96d12010-08-13 18:42:17 +00004069 // If there were any unused file scoped decls, deserialize them and add to
4070 // Sema's list of unused file scoped decls.
4071 for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) {
4072 DeclaratorDecl *D = cast<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I]));
4073 SemaObj->UnusedFileScopedDecls.push_back(D);
Tanya Lattnere6bbc012010-02-12 00:07:30 +00004074 }
Douglas Gregor14c22f22009-04-22 22:18:58 +00004075
4076 // If there were any locally-scoped external declarations,
4077 // deserialize them and add them to Sema's table of locally-scoped
4078 // external declarations.
4079 for (unsigned I = 0, N = LocallyScopedExternalDecls.size(); I != N; ++I) {
4080 NamedDecl *D = cast<NamedDecl>(GetDecl(LocallyScopedExternalDecls[I]));
4081 SemaObj->LocallyScopedExternalDecls[D->getDeclName()] = D;
4082 }
Douglas Gregorb81c1702009-04-27 20:06:05 +00004083
4084 // If there were any ext_vector type declarations, deserialize them
4085 // and add them to Sema's vector of such declarations.
4086 for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I)
4087 SemaObj->ExtVectorDecls.push_back(
Richard Smith162e1c12011-04-15 14:24:37 +00004088 cast<TypedefNameDecl>(GetDecl(ExtVectorDecls[I])));
Argyrios Kyrtzidisd455add2010-07-06 15:37:04 +00004089
4090 // FIXME: Do VTable uses and dynamic classes deserialize too much ?
4091 // Can we cut them down before writing them ?
4092
Argyrios Kyrtzidisd455add2010-07-06 15:37:04 +00004093 // If there were any dynamic classes declarations, deserialize them
4094 // and add them to Sema's vector of such declarations.
4095 for (unsigned I = 0, N = DynamicClasses.size(); I != N; ++I)
4096 SemaObj->DynamicClasses.push_back(
4097 cast<CXXRecordDecl>(GetDecl(DynamicClasses[I])));
Fariborz Jahanian32019832010-07-23 19:11:11 +00004098
Argyrios Kyrtzidis76c38d32010-08-02 07:14:54 +00004099 // Load the offsets of the declarations that Sema references.
4100 // They will be lazily deserialized when needed.
4101 if (!SemaDeclRefs.empty()) {
4102 assert(SemaDeclRefs.size() == 2 && "More decl refs than expected!");
4103 SemaObj->StdNamespace = SemaDeclRefs[0];
4104 SemaObj->StdBadAlloc = SemaDeclRefs[1];
4105 }
4106
Sebastian Redlc3632732010-10-05 15:59:54 +00004107 for (PerFileData *F = FirstInSource; F; F = F->NextInSource) {
4108
4109 // If there are @selector references added them to its pool. This is for
4110 // implementation of -Wselector.
4111 if (!F->ReferencedSelectorsData.empty()) {
4112 unsigned int DataSize = F->ReferencedSelectorsData.size()-1;
4113 unsigned I = 0;
4114 while (I < DataSize) {
4115 Selector Sel = DecodeSelector(F->ReferencedSelectorsData[I++]);
4116 SourceLocation SelLoc = ReadSourceLocation(
4117 *F, F->ReferencedSelectorsData, I);
4118 SemaObj->ReferencedSelectors.insert(std::make_pair(Sel, SelLoc));
4119 }
4120 }
4121
4122 // If there were any pending implicit instantiations, deserialize them
4123 // and add them to Sema's queue of such instantiations.
4124 assert(F->PendingInstantiations.size() % 2 == 0 &&
4125 "Expected pairs of entries");
4126 for (unsigned Idx = 0, N = F->PendingInstantiations.size(); Idx < N;) {
4127 ValueDecl *D=cast<ValueDecl>(GetDecl(F->PendingInstantiations[Idx++]));
4128 SourceLocation Loc = ReadSourceLocation(*F, F->PendingInstantiations,Idx);
4129 SemaObj->PendingInstantiations.push_back(std::make_pair(D, Loc));
4130 }
4131 }
4132
4133 // The two special data sets below always come from the most recent PCH,
4134 // which is at the front of the chain.
4135 PerFileData &F = *Chain.front();
4136
4137 // If there were any weak undeclared identifiers, deserialize them and add to
4138 // Sema's list of weak undeclared identifiers.
4139 if (!WeakUndeclaredIdentifiers.empty()) {
4140 unsigned Idx = 0;
4141 for (unsigned I = 0, N = WeakUndeclaredIdentifiers[Idx++]; I != N; ++I) {
4142 IdentifierInfo *WeakId = GetIdentifierInfo(WeakUndeclaredIdentifiers,Idx);
4143 IdentifierInfo *AliasId= GetIdentifierInfo(WeakUndeclaredIdentifiers,Idx);
4144 SourceLocation Loc = ReadSourceLocation(F, WeakUndeclaredIdentifiers,Idx);
4145 bool Used = WeakUndeclaredIdentifiers[Idx++];
4146 Sema::WeakInfo WI(AliasId, Loc);
4147 WI.setUsed(Used);
4148 SemaObj->WeakUndeclaredIdentifiers.insert(std::make_pair(WeakId, WI));
4149 }
4150 }
4151
4152 // If there were any VTable uses, deserialize the information and add it
4153 // to Sema's vector and map of VTable uses.
4154 if (!VTableUses.empty()) {
4155 unsigned Idx = 0;
4156 for (unsigned I = 0, N = VTableUses[Idx++]; I != N; ++I) {
4157 CXXRecordDecl *Class = cast<CXXRecordDecl>(GetDecl(VTableUses[Idx++]));
4158 SourceLocation Loc = ReadSourceLocation(F, VTableUses, Idx);
4159 bool DefinitionRequired = VTableUses[Idx++];
4160 SemaObj->VTableUses.push_back(std::make_pair(Class, Loc));
4161 SemaObj->VTablesUsed[Class] = DefinitionRequired;
Fariborz Jahanian32019832010-07-23 19:11:11 +00004162 }
4163 }
Peter Collingbourne84bccea2011-02-15 19:46:30 +00004164
4165 if (!FPPragmaOptions.empty()) {
4166 assert(FPPragmaOptions.size() == 1 && "Wrong number of FP_PRAGMA_OPTIONS");
4167 SemaObj->FPFeatures.fp_contract = FPPragmaOptions[0];
4168 }
4169
4170 if (!OpenCLExtensions.empty()) {
4171 unsigned I = 0;
4172#define OPENCLEXT(nm) SemaObj->OpenCLFeatures.nm = OpenCLExtensions[I++];
4173#include "clang/Basic/OpenCLExtensions.def"
4174
4175 assert(OpenCLExtensions.size() == I && "Wrong number of OPENCL_EXTENSIONS");
4176 }
Douglas Gregor668c1a42009-04-21 22:25:48 +00004177}
4178
Sebastian Redlc43b54c2010-08-18 23:56:43 +00004179IdentifierInfo* ASTReader::get(const char *NameStart, const char *NameEnd) {
Sebastian Redld8c5abb2010-08-02 18:30:12 +00004180 // Try to find this name within our on-disk hash tables. We start with the
4181 // most recent one, since that one contains the most up-to-date info.
Sebastian Redld27d3fc2010-07-21 22:31:37 +00004182 for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00004183 ASTIdentifierLookupTable *IdTable
4184 = (ASTIdentifierLookupTable *)Chain[I]->IdentifierLookupTable;
Sebastian Redl0fa7d0b2010-07-22 17:01:13 +00004185 if (!IdTable)
4186 continue;
Sebastian Redld27d3fc2010-07-21 22:31:37 +00004187 std::pair<const char*, unsigned> Key(NameStart, NameEnd - NameStart);
Sebastian Redl3c7f4132010-08-18 23:57:06 +00004188 ASTIdentifierLookupTable::iterator Pos = IdTable->find(Key);
Sebastian Redld27d3fc2010-07-21 22:31:37 +00004189 if (Pos == IdTable->end())
4190 continue;
Douglas Gregor668c1a42009-04-21 22:25:48 +00004191
Sebastian Redld27d3fc2010-07-21 22:31:37 +00004192 // Dereferencing the iterator has the effect of building the
4193 // IdentifierInfo node and populating it with the various
4194 // declarations it needs.
Sebastian Redld8c5abb2010-08-02 18:30:12 +00004195 return *Pos;
Sebastian Redld27d3fc2010-07-21 22:31:37 +00004196 }
Sebastian Redld8c5abb2010-08-02 18:30:12 +00004197 return 0;
Douglas Gregor668c1a42009-04-21 22:25:48 +00004198}
4199
Douglas Gregor95f42922010-10-14 22:11:03 +00004200namespace clang {
4201 /// \brief An identifier-lookup iterator that enumerates all of the
4202 /// identifiers stored within a set of AST files.
4203 class ASTIdentifierIterator : public IdentifierIterator {
4204 /// \brief The AST reader whose identifiers are being enumerated.
4205 const ASTReader &Reader;
4206
4207 /// \brief The current index into the chain of AST files stored in
4208 /// the AST reader.
4209 unsigned Index;
4210
4211 /// \brief The current position within the identifier lookup table
4212 /// of the current AST file.
4213 ASTIdentifierLookupTable::key_iterator Current;
4214
4215 /// \brief The end position within the identifier lookup table of
4216 /// the current AST file.
4217 ASTIdentifierLookupTable::key_iterator End;
4218
4219 public:
4220 explicit ASTIdentifierIterator(const ASTReader &Reader);
4221
4222 virtual llvm::StringRef Next();
4223 };
4224}
4225
4226ASTIdentifierIterator::ASTIdentifierIterator(const ASTReader &Reader)
4227 : Reader(Reader), Index(Reader.Chain.size() - 1) {
4228 ASTIdentifierLookupTable *IdTable
4229 = (ASTIdentifierLookupTable *)Reader.Chain[Index]->IdentifierLookupTable;
4230 Current = IdTable->key_begin();
4231 End = IdTable->key_end();
4232}
4233
4234llvm::StringRef ASTIdentifierIterator::Next() {
4235 while (Current == End) {
4236 // If we have exhausted all of our AST files, we're done.
4237 if (Index == 0)
4238 return llvm::StringRef();
4239
4240 --Index;
4241 ASTIdentifierLookupTable *IdTable
4242 = (ASTIdentifierLookupTable *)Reader.Chain[Index]->IdentifierLookupTable;
4243 Current = IdTable->key_begin();
4244 End = IdTable->key_end();
4245 }
4246
4247 // We have any identifiers remaining in the current AST file; return
4248 // the next one.
4249 std::pair<const char*, unsigned> Key = *Current;
4250 ++Current;
4251 return llvm::StringRef(Key.first, Key.second);
4252}
4253
4254IdentifierIterator *ASTReader::getIdentifiers() const {
4255 return new ASTIdentifierIterator(*this);
4256}
4257
Mike Stump1eb44332009-09-09 15:08:12 +00004258std::pair<ObjCMethodList, ObjCMethodList>
Sebastian Redlc43b54c2010-08-18 23:56:43 +00004259ASTReader::ReadMethodPool(Selector Sel) {
Sebastian Redl725cd962010-08-04 20:40:17 +00004260 // Find this selector in a hash table. We want to find the most recent entry.
4261 for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
4262 PerFileData &F = *Chain[I];
4263 if (!F.SelectorLookupTable)
4264 continue;
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +00004265
Sebastian Redl3c7f4132010-08-18 23:57:06 +00004266 ASTSelectorLookupTable *PoolTable
4267 = (ASTSelectorLookupTable*)F.SelectorLookupTable;
4268 ASTSelectorLookupTable::iterator Pos = PoolTable->find(Sel);
Sebastian Redl725cd962010-08-04 20:40:17 +00004269 if (Pos != PoolTable->end()) {
4270 ++NumSelectorsRead;
Sebastian Redlfa78dec2010-08-04 21:22:45 +00004271 // FIXME: Not quite happy with the statistics here. We probably should
4272 // disable this tracking when called via LoadSelector.
4273 // Also, should entries without methods count as misses?
4274 ++NumMethodPoolEntriesRead;
Sebastian Redl3c7f4132010-08-18 23:57:06 +00004275 ASTSelectorLookupTrait::data_type Data = *Pos;
Sebastian Redl725cd962010-08-04 20:40:17 +00004276 if (DeserializationListener)
4277 DeserializationListener->SelectorRead(Data.ID, Sel);
4278 return std::make_pair(Data.Instance, Data.Factory);
4279 }
Douglas Gregor83941df2009-04-25 17:48:32 +00004280 }
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +00004281
Sebastian Redlfa78dec2010-08-04 21:22:45 +00004282 ++NumMethodPoolMisses;
Sebastian Redl725cd962010-08-04 20:40:17 +00004283 return std::pair<ObjCMethodList, ObjCMethodList>();
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +00004284}
4285
Sebastian Redlc43b54c2010-08-18 23:56:43 +00004286void ASTReader::LoadSelector(Selector Sel) {
Sebastian Redle58aa892010-08-04 18:21:41 +00004287 // It would be complicated to avoid reading the methods anyway. So don't.
4288 ReadMethodPool(Sel);
4289}
4290
Sebastian Redlc43b54c2010-08-18 23:56:43 +00004291void ASTReader::SetIdentifierInfo(unsigned ID, IdentifierInfo *II) {
Douglas Gregor668c1a42009-04-21 22:25:48 +00004292 assert(ID && "Non-zero identifier ID required");
Douglas Gregora02b1472009-04-28 21:53:25 +00004293 assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range");
Douglas Gregor2b3a5a82009-04-25 19:10:14 +00004294 IdentifiersLoaded[ID - 1] = II;
Sebastian Redlf2f0f032010-07-23 23:49:55 +00004295 if (DeserializationListener)
4296 DeserializationListener->IdentifierRead(ID, II);
Douglas Gregor668c1a42009-04-21 22:25:48 +00004297}
4298
Douglas Gregord89275b2009-07-06 18:54:52 +00004299/// \brief Set the globally-visible declarations associated with the given
4300/// identifier.
4301///
Sebastian Redl3c7f4132010-08-18 23:57:06 +00004302/// If the AST reader is currently in a state where the given declaration IDs
Mike Stump1eb44332009-09-09 15:08:12 +00004303/// cannot safely be resolved, they are queued until it is safe to resolve
Douglas Gregord89275b2009-07-06 18:54:52 +00004304/// them.
4305///
4306/// \param II an IdentifierInfo that refers to one or more globally-visible
4307/// declarations.
4308///
4309/// \param DeclIDs the set of declaration IDs with the name @p II that are
4310/// visible at global scope.
4311///
4312/// \param Nonrecursive should be true to indicate that the caller knows that
4313/// this call is non-recursive, and therefore the globally-visible declarations
4314/// will not be placed onto the pending queue.
Mike Stump1eb44332009-09-09 15:08:12 +00004315void
Sebastian Redlc43b54c2010-08-18 23:56:43 +00004316ASTReader::SetGloballyVisibleDecls(IdentifierInfo *II,
Douglas Gregord89275b2009-07-06 18:54:52 +00004317 const llvm::SmallVectorImpl<uint32_t> &DeclIDs,
4318 bool Nonrecursive) {
Argyrios Kyrtzidis29ee3a22010-07-30 10:03:16 +00004319 if (NumCurrentElementsDeserializing && !Nonrecursive) {
Douglas Gregord89275b2009-07-06 18:54:52 +00004320 PendingIdentifierInfos.push_back(PendingIdentifierInfo());
4321 PendingIdentifierInfo &PII = PendingIdentifierInfos.back();
4322 PII.II = II;
Benjamin Kramer4ea884b2010-09-06 23:43:28 +00004323 PII.DeclIDs.append(DeclIDs.begin(), DeclIDs.end());
Douglas Gregord89275b2009-07-06 18:54:52 +00004324 return;
4325 }
Mike Stump1eb44332009-09-09 15:08:12 +00004326
Douglas Gregord89275b2009-07-06 18:54:52 +00004327 for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) {
4328 NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I]));
4329 if (SemaObj) {
Douglas Gregor914ed9d2010-08-13 03:15:25 +00004330 if (SemaObj->TUScope) {
4331 // Introduce this declaration into the translation-unit scope
4332 // and add it to the declaration chain for this identifier, so
4333 // that (unqualified) name lookup will find it.
John McCalld226f652010-08-21 09:40:31 +00004334 SemaObj->TUScope->AddDecl(D);
Douglas Gregor914ed9d2010-08-13 03:15:25 +00004335 }
Douglas Gregor76dc8892010-09-24 23:29:12 +00004336 SemaObj->IdResolver.AddDeclToIdentifierChain(II, D);
Douglas Gregord89275b2009-07-06 18:54:52 +00004337 } else {
4338 // Queue this declaration so that it will be added to the
4339 // translation unit scope and identifier's declaration chain
4340 // once a Sema object is known.
4341 PreloadedDecls.push_back(D);
4342 }
4343 }
4344}
4345
Sebastian Redlc43b54c2010-08-18 23:56:43 +00004346IdentifierInfo *ASTReader::DecodeIdentifierInfo(unsigned ID) {
Douglas Gregorafaf3082009-04-11 00:14:32 +00004347 if (ID == 0)
4348 return 0;
Mike Stump1eb44332009-09-09 15:08:12 +00004349
Sebastian Redl11f5ccf2010-07-21 00:46:22 +00004350 if (IdentifiersLoaded.empty()) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00004351 Error("no identifier table in AST file");
Douglas Gregorafaf3082009-04-11 00:14:32 +00004352 return 0;
4353 }
Mike Stump1eb44332009-09-09 15:08:12 +00004354
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00004355 assert(PP && "Forgot to set Preprocessor ?");
Sebastian Redl11f5ccf2010-07-21 00:46:22 +00004356 ID -= 1;
4357 if (!IdentifiersLoaded[ID]) {
4358 unsigned Index = ID;
4359 const char *Str = 0;
4360 for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
4361 PerFileData *F = Chain[N - I - 1];
4362 if (Index < F->LocalNumIdentifiers) {
4363 uint32_t Offset = F->IdentifierOffsets[Index];
4364 Str = F->IdentifierTableData + Offset;
4365 break;
4366 }
4367 Index -= F->LocalNumIdentifiers;
4368 }
4369 assert(Str && "Broken Chain");
Douglas Gregord6595a42009-04-25 21:04:17 +00004370
Sebastian Redl3c7f4132010-08-18 23:57:06 +00004371 // All of the strings in the AST file are preceded by a 16-bit length.
4372 // Extract that 16-bit length to avoid having to execute strlen().
Ted Kremenek231bc0b2009-10-23 04:45:31 +00004373 // NOTE: 'StrLenPtr' is an 'unsigned char*' so that we load bytes as
4374 // unsigned integers. This is important to avoid integer overflow when
4375 // we cast them to 'unsigned'.
Ted Kremenekff1ea462009-10-23 03:57:22 +00004376 const unsigned char *StrLenPtr = (const unsigned char*) Str - 2;
Douglas Gregor02fc7512009-04-28 20:01:51 +00004377 unsigned StrLen = (((unsigned) StrLenPtr[0])
4378 | (((unsigned) StrLenPtr[1]) << 8)) - 1;
Sebastian Redl11f5ccf2010-07-21 00:46:22 +00004379 IdentifiersLoaded[ID]
Kovarththanan Rajaratnam811f4262010-03-12 10:32:27 +00004380 = &PP->getIdentifierTable().get(Str, StrLen);
Sebastian Redlf2f0f032010-07-23 23:49:55 +00004381 if (DeserializationListener)
4382 DeserializationListener->IdentifierRead(ID + 1, IdentifiersLoaded[ID]);
Douglas Gregorafaf3082009-04-11 00:14:32 +00004383 }
Mike Stump1eb44332009-09-09 15:08:12 +00004384
Sebastian Redl11f5ccf2010-07-21 00:46:22 +00004385 return IdentifiersLoaded[ID];
Douglas Gregor2cf26342009-04-09 22:27:44 +00004386}
4387
Douglas Gregore23ac652011-04-20 00:21:03 +00004388bool ASTReader::ReadSLocEntry(unsigned ID) {
4389 return ReadSLocEntryRecord(ID) != Success;
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00004390}
4391
Sebastian Redlc43b54c2010-08-18 23:56:43 +00004392Selector ASTReader::DecodeSelector(unsigned ID) {
Steve Naroff90cd1bb2009-04-23 10:39:46 +00004393 if (ID == 0)
4394 return Selector();
Mike Stump1eb44332009-09-09 15:08:12 +00004395
Sebastian Redl725cd962010-08-04 20:40:17 +00004396 if (ID > SelectorsLoaded.size()) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00004397 Error("selector ID out of range in AST file");
Steve Naroff90cd1bb2009-04-23 10:39:46 +00004398 return Selector();
4399 }
Douglas Gregor83941df2009-04-25 17:48:32 +00004400
Sebastian Redl725cd962010-08-04 20:40:17 +00004401 if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == 0) {
Douglas Gregor83941df2009-04-25 17:48:32 +00004402 // Load this selector from the selector table.
Sebastian Redl725cd962010-08-04 20:40:17 +00004403 unsigned Idx = ID - 1;
4404 for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
4405 PerFileData &F = *Chain[N - I - 1];
4406 if (Idx < F.LocalNumSelectors) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00004407 ASTSelectorLookupTrait Trait(*this);
Sebastian Redl725cd962010-08-04 20:40:17 +00004408 SelectorsLoaded[ID - 1] =
4409 Trait.ReadKey(F.SelectorLookupTableData + F.SelectorOffsets[Idx], 0);
4410 if (DeserializationListener)
4411 DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]);
4412 break;
4413 }
4414 Idx -= F.LocalNumSelectors;
4415 }
Douglas Gregor83941df2009-04-25 17:48:32 +00004416 }
4417
Sebastian Redl725cd962010-08-04 20:40:17 +00004418 return SelectorsLoaded[ID - 1];
Steve Naroff90cd1bb2009-04-23 10:39:46 +00004419}
4420
Michael J. Spencer20249a12010-10-21 03:16:25 +00004421Selector ASTReader::GetExternalSelector(uint32_t ID) {
Douglas Gregor719770d2010-04-06 17:30:22 +00004422 return DecodeSelector(ID);
4423}
4424
Sebastian Redlc43b54c2010-08-18 23:56:43 +00004425uint32_t ASTReader::GetNumExternalSelectors() {
Sebastian Redl725cd962010-08-04 20:40:17 +00004426 // ID 0 (the null selector) is considered an external selector.
4427 return getTotalNumSelectors() + 1;
Douglas Gregor719770d2010-04-06 17:30:22 +00004428}
4429
Mike Stump1eb44332009-09-09 15:08:12 +00004430DeclarationName
Sebastian Redlc43b54c2010-08-18 23:56:43 +00004431ASTReader::ReadDeclarationName(const RecordData &Record, unsigned &Idx) {
Douglas Gregor2cf26342009-04-09 22:27:44 +00004432 DeclarationName::NameKind Kind = (DeclarationName::NameKind)Record[Idx++];
4433 switch (Kind) {
4434 case DeclarationName::Identifier:
4435 return DeclarationName(GetIdentifierInfo(Record, Idx));
4436
4437 case DeclarationName::ObjCZeroArgSelector:
4438 case DeclarationName::ObjCOneArgSelector:
4439 case DeclarationName::ObjCMultiArgSelector:
Steve Naroffa7503a72009-04-23 15:15:40 +00004440 return DeclarationName(GetSelector(Record, Idx));
Douglas Gregor2cf26342009-04-09 22:27:44 +00004441
4442 case DeclarationName::CXXConstructorName:
Chris Lattnerd1d64a02009-04-27 21:45:14 +00004443 return Context->DeclarationNames.getCXXConstructorName(
Douglas Gregor50d62d12009-08-05 05:36:45 +00004444 Context->getCanonicalType(GetType(Record[Idx++])));
Douglas Gregor2cf26342009-04-09 22:27:44 +00004445
4446 case DeclarationName::CXXDestructorName:
Chris Lattnerd1d64a02009-04-27 21:45:14 +00004447 return Context->DeclarationNames.getCXXDestructorName(
Douglas Gregor50d62d12009-08-05 05:36:45 +00004448 Context->getCanonicalType(GetType(Record[Idx++])));
Douglas Gregor2cf26342009-04-09 22:27:44 +00004449
4450 case DeclarationName::CXXConversionFunctionName:
Chris Lattnerd1d64a02009-04-27 21:45:14 +00004451 return Context->DeclarationNames.getCXXConversionFunctionName(
Douglas Gregor50d62d12009-08-05 05:36:45 +00004452 Context->getCanonicalType(GetType(Record[Idx++])));
Douglas Gregor2cf26342009-04-09 22:27:44 +00004453
4454 case DeclarationName::CXXOperatorName:
Chris Lattnerd1d64a02009-04-27 21:45:14 +00004455 return Context->DeclarationNames.getCXXOperatorName(
Douglas Gregor2cf26342009-04-09 22:27:44 +00004456 (OverloadedOperatorKind)Record[Idx++]);
4457
Sean Hunt3e518bd2009-11-29 07:34:05 +00004458 case DeclarationName::CXXLiteralOperatorName:
4459 return Context->DeclarationNames.getCXXLiteralOperatorName(
4460 GetIdentifierInfo(Record, Idx));
4461
Douglas Gregor2cf26342009-04-09 22:27:44 +00004462 case DeclarationName::CXXUsingDirective:
4463 return DeclarationName::getUsingDirectiveName();
4464 }
4465
4466 // Required to silence GCC warning
4467 return DeclarationName();
4468}
Douglas Gregor0a0428e2009-04-10 20:39:37 +00004469
Argyrios Kyrtzidis40451072010-10-15 18:21:24 +00004470void ASTReader::ReadDeclarationNameLoc(PerFileData &F,
4471 DeclarationNameLoc &DNLoc,
4472 DeclarationName Name,
4473 const RecordData &Record, unsigned &Idx) {
4474 switch (Name.getNameKind()) {
4475 case DeclarationName::CXXConstructorName:
4476 case DeclarationName::CXXDestructorName:
4477 case DeclarationName::CXXConversionFunctionName:
4478 DNLoc.NamedType.TInfo = GetTypeSourceInfo(F, Record, Idx);
4479 break;
4480
4481 case DeclarationName::CXXOperatorName:
4482 DNLoc.CXXOperatorName.BeginOpNameLoc
4483 = ReadSourceLocation(F, Record, Idx).getRawEncoding();
4484 DNLoc.CXXOperatorName.EndOpNameLoc
4485 = ReadSourceLocation(F, Record, Idx).getRawEncoding();
4486 break;
4487
4488 case DeclarationName::CXXLiteralOperatorName:
4489 DNLoc.CXXLiteralOperatorName.OpNameLoc
4490 = ReadSourceLocation(F, Record, Idx).getRawEncoding();
4491 break;
4492
4493 case DeclarationName::Identifier:
4494 case DeclarationName::ObjCZeroArgSelector:
4495 case DeclarationName::ObjCOneArgSelector:
4496 case DeclarationName::ObjCMultiArgSelector:
4497 case DeclarationName::CXXUsingDirective:
4498 break;
4499 }
4500}
4501
4502void ASTReader::ReadDeclarationNameInfo(PerFileData &F,
4503 DeclarationNameInfo &NameInfo,
4504 const RecordData &Record, unsigned &Idx) {
4505 NameInfo.setName(ReadDeclarationName(Record, Idx));
4506 NameInfo.setLoc(ReadSourceLocation(F, Record, Idx));
4507 DeclarationNameLoc DNLoc;
4508 ReadDeclarationNameLoc(F, DNLoc, NameInfo.getName(), Record, Idx);
4509 NameInfo.setInfo(DNLoc);
4510}
4511
4512void ASTReader::ReadQualifierInfo(PerFileData &F, QualifierInfo &Info,
4513 const RecordData &Record, unsigned &Idx) {
Douglas Gregorc22b5ff2011-02-25 02:25:35 +00004514 Info.QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx);
Argyrios Kyrtzidis40451072010-10-15 18:21:24 +00004515 unsigned NumTPLists = Record[Idx++];
4516 Info.NumTemplParamLists = NumTPLists;
4517 if (NumTPLists) {
4518 Info.TemplParamLists = new (*Context) TemplateParameterList*[NumTPLists];
4519 for (unsigned i=0; i != NumTPLists; ++i)
4520 Info.TemplParamLists[i] = ReadTemplateParameterList(F, Record, Idx);
4521 }
4522}
4523
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00004524TemplateName
Douglas Gregor1aee05d2011-01-15 06:45:20 +00004525ASTReader::ReadTemplateName(PerFileData &F, const RecordData &Record,
4526 unsigned &Idx) {
Michael J. Spencer20249a12010-10-21 03:16:25 +00004527 TemplateName::NameKind Kind = (TemplateName::NameKind)Record[Idx++];
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00004528 switch (Kind) {
4529 case TemplateName::Template:
4530 return TemplateName(cast_or_null<TemplateDecl>(GetDecl(Record[Idx++])));
4531
4532 case TemplateName::OverloadedTemplate: {
4533 unsigned size = Record[Idx++];
4534 UnresolvedSet<8> Decls;
4535 while (size--)
4536 Decls.addDecl(cast<NamedDecl>(GetDecl(Record[Idx++])));
4537
4538 return Context->getOverloadedTemplateName(Decls.begin(), Decls.end());
4539 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00004540
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00004541 case TemplateName::QualifiedTemplate: {
4542 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(Record, Idx);
4543 bool hasTemplKeyword = Record[Idx++];
4544 TemplateDecl *Template = cast<TemplateDecl>(GetDecl(Record[Idx++]));
4545 return Context->getQualifiedTemplateName(NNS, hasTemplKeyword, Template);
4546 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00004547
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00004548 case TemplateName::DependentTemplate: {
4549 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(Record, Idx);
4550 if (Record[Idx++]) // isIdentifier
4551 return Context->getDependentTemplateName(NNS,
4552 GetIdentifierInfo(Record, Idx));
4553 return Context->getDependentTemplateName(NNS,
Argyrios Kyrtzidis17cfded2010-06-28 09:31:42 +00004554 (OverloadedOperatorKind)Record[Idx++]);
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00004555 }
Douglas Gregor1aee05d2011-01-15 06:45:20 +00004556
4557 case TemplateName::SubstTemplateTemplateParmPack: {
4558 TemplateTemplateParmDecl *Param
4559 = cast_or_null<TemplateTemplateParmDecl>(GetDecl(Record[Idx++]));
4560 if (!Param)
4561 return TemplateName();
4562
4563 TemplateArgument ArgPack = ReadTemplateArgument(F, Record, Idx);
4564 if (ArgPack.getKind() != TemplateArgument::Pack)
4565 return TemplateName();
4566
4567 return Context->getSubstTemplateTemplateParmPack(Param, ArgPack);
4568 }
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00004569 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00004570
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00004571 assert(0 && "Unhandled template name kind!");
4572 return TemplateName();
4573}
4574
4575TemplateArgument
Sebastian Redlc3632732010-10-05 15:59:54 +00004576ASTReader::ReadTemplateArgument(PerFileData &F,
Sebastian Redl577d4792010-07-22 22:43:28 +00004577 const RecordData &Record, unsigned &Idx) {
Douglas Gregora7fc9012011-01-05 18:58:31 +00004578 TemplateArgument::ArgKind Kind = (TemplateArgument::ArgKind)Record[Idx++];
4579 switch (Kind) {
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00004580 case TemplateArgument::Null:
4581 return TemplateArgument();
4582 case TemplateArgument::Type:
4583 return TemplateArgument(GetType(Record[Idx++]));
4584 case TemplateArgument::Declaration:
4585 return TemplateArgument(GetDecl(Record[Idx++]));
Argyrios Kyrtzidisdc767e32010-06-28 09:31:34 +00004586 case TemplateArgument::Integral: {
4587 llvm::APSInt Value = ReadAPSInt(Record, Idx);
4588 QualType T = GetType(Record[Idx++]);
4589 return TemplateArgument(Value, T);
4590 }
Douglas Gregora7fc9012011-01-05 18:58:31 +00004591 case TemplateArgument::Template:
Douglas Gregor1aee05d2011-01-15 06:45:20 +00004592 return TemplateArgument(ReadTemplateName(F, Record, Idx));
Douglas Gregora7fc9012011-01-05 18:58:31 +00004593 case TemplateArgument::TemplateExpansion: {
Douglas Gregor1aee05d2011-01-15 06:45:20 +00004594 TemplateName Name = ReadTemplateName(F, Record, Idx);
Douglas Gregor2be29f42011-01-14 23:41:42 +00004595 llvm::Optional<unsigned> NumTemplateExpansions;
4596 if (unsigned NumExpansions = Record[Idx++])
4597 NumTemplateExpansions = NumExpansions - 1;
4598 return TemplateArgument(Name, NumTemplateExpansions);
Douglas Gregorba68eca2011-01-05 17:40:24 +00004599 }
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00004600 case TemplateArgument::Expression:
Sebastian Redlc3632732010-10-05 15:59:54 +00004601 return TemplateArgument(ReadExpr(F));
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00004602 case TemplateArgument::Pack: {
4603 unsigned NumArgs = Record[Idx++];
Douglas Gregor910f8002010-11-07 23:05:16 +00004604 TemplateArgument *Args = new (*Context) TemplateArgument[NumArgs];
4605 for (unsigned I = 0; I != NumArgs; ++I)
4606 Args[I] = ReadTemplateArgument(F, Record, Idx);
4607 return TemplateArgument(Args, NumArgs);
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00004608 }
4609 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00004610
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00004611 assert(0 && "Unhandled template argument kind!");
4612 return TemplateArgument();
4613}
4614
Argyrios Kyrtzidisdd41c142010-06-23 13:48:30 +00004615TemplateParameterList *
Sebastian Redlc3632732010-10-05 15:59:54 +00004616ASTReader::ReadTemplateParameterList(PerFileData &F,
4617 const RecordData &Record, unsigned &Idx) {
4618 SourceLocation TemplateLoc = ReadSourceLocation(F, Record, Idx);
4619 SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Idx);
4620 SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Idx);
Argyrios Kyrtzidisdd41c142010-06-23 13:48:30 +00004621
4622 unsigned NumParams = Record[Idx++];
4623 llvm::SmallVector<NamedDecl *, 16> Params;
4624 Params.reserve(NumParams);
4625 while (NumParams--)
4626 Params.push_back(cast<NamedDecl>(GetDecl(Record[Idx++])));
Michael J. Spencer20249a12010-10-21 03:16:25 +00004627
4628 TemplateParameterList* TemplateParams =
Argyrios Kyrtzidisdd41c142010-06-23 13:48:30 +00004629 TemplateParameterList::Create(*Context, TemplateLoc, LAngleLoc,
4630 Params.data(), Params.size(), RAngleLoc);
4631 return TemplateParams;
4632}
4633
4634void
Sebastian Redlc43b54c2010-08-18 23:56:43 +00004635ASTReader::
Argyrios Kyrtzidisdd41c142010-06-23 13:48:30 +00004636ReadTemplateArgumentList(llvm::SmallVector<TemplateArgument, 8> &TemplArgs,
Sebastian Redlc3632732010-10-05 15:59:54 +00004637 PerFileData &F, const RecordData &Record,
4638 unsigned &Idx) {
Argyrios Kyrtzidisdd41c142010-06-23 13:48:30 +00004639 unsigned NumTemplateArgs = Record[Idx++];
4640 TemplArgs.reserve(NumTemplateArgs);
4641 while (NumTemplateArgs--)
Sebastian Redlc3632732010-10-05 15:59:54 +00004642 TemplArgs.push_back(ReadTemplateArgument(F, Record, Idx));
Argyrios Kyrtzidisdd41c142010-06-23 13:48:30 +00004643}
4644
Argyrios Kyrtzidis37ffed32010-07-02 11:55:32 +00004645/// \brief Read a UnresolvedSet structure.
Sebastian Redlc43b54c2010-08-18 23:56:43 +00004646void ASTReader::ReadUnresolvedSet(UnresolvedSetImpl &Set,
Argyrios Kyrtzidis37ffed32010-07-02 11:55:32 +00004647 const RecordData &Record, unsigned &Idx) {
4648 unsigned NumDecls = Record[Idx++];
4649 while (NumDecls--) {
4650 NamedDecl *D = cast<NamedDecl>(GetDecl(Record[Idx++]));
4651 AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
4652 Set.addDecl(D, AS);
4653 }
4654}
4655
Argyrios Kyrtzidis0745d0a2010-07-02 23:30:27 +00004656CXXBaseSpecifier
Sebastian Redlc3632732010-10-05 15:59:54 +00004657ASTReader::ReadCXXBaseSpecifier(PerFileData &F,
Nick Lewycky56062202010-07-26 16:56:01 +00004658 const RecordData &Record, unsigned &Idx) {
Argyrios Kyrtzidis0745d0a2010-07-02 23:30:27 +00004659 bool isVirtual = static_cast<bool>(Record[Idx++]);
4660 bool isBaseOfClass = static_cast<bool>(Record[Idx++]);
4661 AccessSpecifier AS = static_cast<AccessSpecifier>(Record[Idx++]);
Sebastian Redlf677ea32011-02-05 19:23:19 +00004662 bool inheritConstructors = static_cast<bool>(Record[Idx++]);
Sebastian Redlc3632732010-10-05 15:59:54 +00004663 TypeSourceInfo *TInfo = GetTypeSourceInfo(F, Record, Idx);
4664 SourceRange Range = ReadSourceRange(F, Record, Idx);
Douglas Gregorf90b27a2011-01-03 22:36:02 +00004665 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Idx);
Sebastian Redlf677ea32011-02-05 19:23:19 +00004666 CXXBaseSpecifier Result(Range, isVirtual, isBaseOfClass, AS, TInfo,
Douglas Gregorf90b27a2011-01-03 22:36:02 +00004667 EllipsisLoc);
Sebastian Redlf677ea32011-02-05 19:23:19 +00004668 Result.setInheritConstructors(inheritConstructors);
4669 return Result;
Argyrios Kyrtzidis0745d0a2010-07-02 23:30:27 +00004670}
4671
Sean Huntcbb67482011-01-08 20:30:50 +00004672std::pair<CXXCtorInitializer **, unsigned>
4673ASTReader::ReadCXXCtorInitializers(PerFileData &F, const RecordData &Record,
4674 unsigned &Idx) {
4675 CXXCtorInitializer **CtorInitializers = 0;
Argyrios Kyrtzidis8e706f42010-08-09 10:54:12 +00004676 unsigned NumInitializers = Record[Idx++];
4677 if (NumInitializers) {
4678 ASTContext &C = *getContext();
4679
Sean Huntcbb67482011-01-08 20:30:50 +00004680 CtorInitializers
4681 = new (C) CXXCtorInitializer*[NumInitializers];
Argyrios Kyrtzidis8e706f42010-08-09 10:54:12 +00004682 for (unsigned i=0; i != NumInitializers; ++i) {
4683 TypeSourceInfo *BaseClassInfo = 0;
4684 bool IsBaseVirtual = false;
4685 FieldDecl *Member = 0;
Francois Pichet00eb3f92010-12-04 09:14:42 +00004686 IndirectFieldDecl *IndirectMember = 0;
Michael J. Spencer20249a12010-10-21 03:16:25 +00004687
Argyrios Kyrtzidis8e706f42010-08-09 10:54:12 +00004688 bool IsBaseInitializer = Record[Idx++];
4689 if (IsBaseInitializer) {
Sebastian Redlc3632732010-10-05 15:59:54 +00004690 BaseClassInfo = GetTypeSourceInfo(F, Record, Idx);
Argyrios Kyrtzidis8e706f42010-08-09 10:54:12 +00004691 IsBaseVirtual = Record[Idx++];
4692 } else {
Francois Pichet00eb3f92010-12-04 09:14:42 +00004693 bool IsIndirectMemberInitializer = Record[Idx++];
4694 if (IsIndirectMemberInitializer)
4695 IndirectMember = cast<IndirectFieldDecl>(GetDecl(Record[Idx++]));
4696 else
4697 Member = cast<FieldDecl>(GetDecl(Record[Idx++]));
Argyrios Kyrtzidis8e706f42010-08-09 10:54:12 +00004698 }
Douglas Gregor3fb9e4b2011-01-04 00:32:56 +00004699 SourceLocation MemberOrEllipsisLoc = ReadSourceLocation(F, Record, Idx);
Sebastian Redlc3632732010-10-05 15:59:54 +00004700 Expr *Init = ReadExpr(F);
Sebastian Redlc3632732010-10-05 15:59:54 +00004701 SourceLocation LParenLoc = ReadSourceLocation(F, Record, Idx);
4702 SourceLocation RParenLoc = ReadSourceLocation(F, Record, Idx);
Argyrios Kyrtzidis8e706f42010-08-09 10:54:12 +00004703 bool IsWritten = Record[Idx++];
4704 unsigned SourceOrderOrNumArrayIndices;
4705 llvm::SmallVector<VarDecl *, 8> Indices;
4706 if (IsWritten) {
4707 SourceOrderOrNumArrayIndices = Record[Idx++];
4708 } else {
4709 SourceOrderOrNumArrayIndices = Record[Idx++];
4710 Indices.reserve(SourceOrderOrNumArrayIndices);
4711 for (unsigned i=0; i != SourceOrderOrNumArrayIndices; ++i)
4712 Indices.push_back(cast<VarDecl>(GetDecl(Record[Idx++])));
4713 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00004714
Sean Huntcbb67482011-01-08 20:30:50 +00004715 CXXCtorInitializer *BOMInit;
Argyrios Kyrtzidis8e706f42010-08-09 10:54:12 +00004716 if (IsBaseInitializer) {
Sean Huntcbb67482011-01-08 20:30:50 +00004717 BOMInit = new (C) CXXCtorInitializer(C, BaseClassInfo, IsBaseVirtual,
4718 LParenLoc, Init, RParenLoc,
4719 MemberOrEllipsisLoc);
Argyrios Kyrtzidis8e706f42010-08-09 10:54:12 +00004720 } else if (IsWritten) {
Francois Pichet00eb3f92010-12-04 09:14:42 +00004721 if (Member)
Sean Huntcbb67482011-01-08 20:30:50 +00004722 BOMInit = new (C) CXXCtorInitializer(C, Member, MemberOrEllipsisLoc,
4723 LParenLoc, Init, RParenLoc);
Francois Pichet00eb3f92010-12-04 09:14:42 +00004724 else
Sean Huntcbb67482011-01-08 20:30:50 +00004725 BOMInit = new (C) CXXCtorInitializer(C, IndirectMember,
4726 MemberOrEllipsisLoc, LParenLoc,
4727 Init, RParenLoc);
Argyrios Kyrtzidis8e706f42010-08-09 10:54:12 +00004728 } else {
Sean Huntcbb67482011-01-08 20:30:50 +00004729 BOMInit = CXXCtorInitializer::Create(C, Member, MemberOrEllipsisLoc,
4730 LParenLoc, Init, RParenLoc,
4731 Indices.data(), Indices.size());
Argyrios Kyrtzidis8e706f42010-08-09 10:54:12 +00004732 }
4733
Argyrios Kyrtzidisf84cde12010-09-06 19:04:27 +00004734 if (IsWritten)
4735 BOMInit->setSourceOrder(SourceOrderOrNumArrayIndices);
Sean Huntcbb67482011-01-08 20:30:50 +00004736 CtorInitializers[i] = BOMInit;
Argyrios Kyrtzidis8e706f42010-08-09 10:54:12 +00004737 }
4738 }
4739
Sean Huntcbb67482011-01-08 20:30:50 +00004740 return std::make_pair(CtorInitializers, NumInitializers);
Argyrios Kyrtzidis8e706f42010-08-09 10:54:12 +00004741}
4742
Chris Lattner6ad9ac02010-05-07 21:43:38 +00004743NestedNameSpecifier *
Sebastian Redlc43b54c2010-08-18 23:56:43 +00004744ASTReader::ReadNestedNameSpecifier(const RecordData &Record, unsigned &Idx) {
Chris Lattner6ad9ac02010-05-07 21:43:38 +00004745 unsigned N = Record[Idx++];
4746 NestedNameSpecifier *NNS = 0, *Prev = 0;
4747 for (unsigned I = 0; I != N; ++I) {
4748 NestedNameSpecifier::SpecifierKind Kind
4749 = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
4750 switch (Kind) {
4751 case NestedNameSpecifier::Identifier: {
4752 IdentifierInfo *II = GetIdentifierInfo(Record, Idx);
4753 NNS = NestedNameSpecifier::Create(*Context, Prev, II);
4754 break;
4755 }
4756
4757 case NestedNameSpecifier::Namespace: {
4758 NamespaceDecl *NS = cast<NamespaceDecl>(GetDecl(Record[Idx++]));
4759 NNS = NestedNameSpecifier::Create(*Context, Prev, NS);
4760 break;
4761 }
4762
Douglas Gregor14aba762011-02-24 02:36:08 +00004763 case NestedNameSpecifier::NamespaceAlias: {
4764 NamespaceAliasDecl *Alias
4765 = cast<NamespaceAliasDecl>(GetDecl(Record[Idx++]));
4766 NNS = NestedNameSpecifier::Create(*Context, Prev, Alias);
4767 break;
4768 }
4769
Chris Lattner6ad9ac02010-05-07 21:43:38 +00004770 case NestedNameSpecifier::TypeSpec:
4771 case NestedNameSpecifier::TypeSpecWithTemplate: {
John McCallf4c73712011-01-19 06:33:43 +00004772 const Type *T = GetType(Record[Idx++]).getTypePtrOrNull();
Douglas Gregor1ab55e92010-12-10 17:03:06 +00004773 if (!T)
4774 return 0;
4775
Chris Lattner6ad9ac02010-05-07 21:43:38 +00004776 bool Template = Record[Idx++];
4777 NNS = NestedNameSpecifier::Create(*Context, Prev, Template, T);
4778 break;
4779 }
4780
4781 case NestedNameSpecifier::Global: {
4782 NNS = NestedNameSpecifier::GlobalSpecifier(*Context);
4783 // No associated value, and there can't be a prefix.
4784 break;
4785 }
Chris Lattner6ad9ac02010-05-07 21:43:38 +00004786 }
Argyrios Kyrtzidisd2bb2c02010-07-07 15:46:30 +00004787 Prev = NNS;
Chris Lattner6ad9ac02010-05-07 21:43:38 +00004788 }
4789 return NNS;
4790}
4791
Douglas Gregordc355712011-02-25 00:36:19 +00004792NestedNameSpecifierLoc
4793ASTReader::ReadNestedNameSpecifierLoc(PerFileData &F, const RecordData &Record,
4794 unsigned &Idx) {
4795 unsigned N = Record[Idx++];
Douglas Gregor5f791bb2011-02-28 23:58:31 +00004796 NestedNameSpecifierLocBuilder Builder;
Douglas Gregordc355712011-02-25 00:36:19 +00004797 for (unsigned I = 0; I != N; ++I) {
4798 NestedNameSpecifier::SpecifierKind Kind
4799 = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
4800 switch (Kind) {
4801 case NestedNameSpecifier::Identifier: {
Douglas Gregor5f791bb2011-02-28 23:58:31 +00004802 IdentifierInfo *II = GetIdentifierInfo(Record, Idx);
Douglas Gregordc355712011-02-25 00:36:19 +00004803 SourceRange Range = ReadSourceRange(F, Record, Idx);
Douglas Gregor5f791bb2011-02-28 23:58:31 +00004804 Builder.Extend(*Context, II, Range.getBegin(), Range.getEnd());
Douglas Gregordc355712011-02-25 00:36:19 +00004805 break;
4806 }
4807
4808 case NestedNameSpecifier::Namespace: {
Douglas Gregordc355712011-02-25 00:36:19 +00004809 NamespaceDecl *NS = cast<NamespaceDecl>(GetDecl(Record[Idx++]));
Douglas Gregordc355712011-02-25 00:36:19 +00004810 SourceRange Range = ReadSourceRange(F, Record, Idx);
Douglas Gregor5f791bb2011-02-28 23:58:31 +00004811 Builder.Extend(*Context, NS, Range.getBegin(), Range.getEnd());
Douglas Gregordc355712011-02-25 00:36:19 +00004812 break;
4813 }
4814
4815 case NestedNameSpecifier::NamespaceAlias: {
Douglas Gregordc355712011-02-25 00:36:19 +00004816 NamespaceAliasDecl *Alias
4817 = cast<NamespaceAliasDecl>(GetDecl(Record[Idx++]));
Douglas Gregordc355712011-02-25 00:36:19 +00004818 SourceRange Range = ReadSourceRange(F, Record, Idx);
Douglas Gregor5f791bb2011-02-28 23:58:31 +00004819 Builder.Extend(*Context, Alias, Range.getBegin(), Range.getEnd());
Douglas Gregordc355712011-02-25 00:36:19 +00004820 break;
4821 }
4822
4823 case NestedNameSpecifier::TypeSpec:
4824 case NestedNameSpecifier::TypeSpecWithTemplate: {
Douglas Gregordc355712011-02-25 00:36:19 +00004825 bool Template = Record[Idx++];
4826 TypeSourceInfo *T = GetTypeSourceInfo(F, Record, Idx);
4827 if (!T)
4828 return NestedNameSpecifierLoc();
Douglas Gregordc355712011-02-25 00:36:19 +00004829 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
Douglas Gregor5f791bb2011-02-28 23:58:31 +00004830
4831 // FIXME: 'template' keyword location not saved anywhere, so we fake it.
4832 Builder.Extend(*Context,
4833 Template? T->getTypeLoc().getBeginLoc() : SourceLocation(),
4834 T->getTypeLoc(), ColonColonLoc);
Douglas Gregordc355712011-02-25 00:36:19 +00004835 break;
4836 }
4837
4838 case NestedNameSpecifier::Global: {
Douglas Gregordc355712011-02-25 00:36:19 +00004839 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
Douglas Gregor5f791bb2011-02-28 23:58:31 +00004840 Builder.MakeGlobal(*Context, ColonColonLoc);
Douglas Gregordc355712011-02-25 00:36:19 +00004841 break;
4842 }
4843 }
Douglas Gregordc355712011-02-25 00:36:19 +00004844 }
4845
Douglas Gregor5f791bb2011-02-28 23:58:31 +00004846 return Builder.getWithLocInContext(*Context);
Douglas Gregordc355712011-02-25 00:36:19 +00004847}
4848
Chris Lattner6ad9ac02010-05-07 21:43:38 +00004849SourceRange
Sebastian Redlc3632732010-10-05 15:59:54 +00004850ASTReader::ReadSourceRange(PerFileData &F, const RecordData &Record,
4851 unsigned &Idx) {
4852 SourceLocation beg = ReadSourceLocation(F, Record, Idx);
4853 SourceLocation end = ReadSourceLocation(F, Record, Idx);
Daniel Dunbar8ee59392010-06-02 15:47:10 +00004854 return SourceRange(beg, end);
Chris Lattner6ad9ac02010-05-07 21:43:38 +00004855}
4856
Douglas Gregor0a2b45e2009-04-13 18:14:40 +00004857/// \brief Read an integral value
Sebastian Redlc43b54c2010-08-18 23:56:43 +00004858llvm::APInt ASTReader::ReadAPInt(const RecordData &Record, unsigned &Idx) {
Douglas Gregor0a2b45e2009-04-13 18:14:40 +00004859 unsigned BitWidth = Record[Idx++];
4860 unsigned NumWords = llvm::APInt::getNumWords(BitWidth);
4861 llvm::APInt Result(BitWidth, NumWords, &Record[Idx]);
4862 Idx += NumWords;
4863 return Result;
4864}
4865
4866/// \brief Read a signed integral value
Sebastian Redlc43b54c2010-08-18 23:56:43 +00004867llvm::APSInt ASTReader::ReadAPSInt(const RecordData &Record, unsigned &Idx) {
Douglas Gregor0a2b45e2009-04-13 18:14:40 +00004868 bool isUnsigned = Record[Idx++];
4869 return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned);
4870}
4871
Douglas Gregor17fc2232009-04-14 21:55:33 +00004872/// \brief Read a floating-point value
Sebastian Redlc43b54c2010-08-18 23:56:43 +00004873llvm::APFloat ASTReader::ReadAPFloat(const RecordData &Record, unsigned &Idx) {
Douglas Gregor17fc2232009-04-14 21:55:33 +00004874 return llvm::APFloat(ReadAPInt(Record, Idx));
4875}
4876
Douglas Gregor68a2eb02009-04-15 21:30:51 +00004877// \brief Read a string
Sebastian Redlc43b54c2010-08-18 23:56:43 +00004878std::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) {
Douglas Gregor68a2eb02009-04-15 21:30:51 +00004879 unsigned Len = Record[Idx++];
Jay Foadbeaaccd2009-05-21 09:52:38 +00004880 std::string Result(Record.data() + Idx, Record.data() + Idx + Len);
Douglas Gregor68a2eb02009-04-15 21:30:51 +00004881 Idx += Len;
4882 return Result;
4883}
4884
Douglas Gregor0a0d2b12011-03-23 00:50:03 +00004885VersionTuple ASTReader::ReadVersionTuple(const RecordData &Record,
4886 unsigned &Idx) {
4887 unsigned Major = Record[Idx++];
4888 unsigned Minor = Record[Idx++];
4889 unsigned Subminor = Record[Idx++];
4890 if (Minor == 0)
4891 return VersionTuple(Major);
4892 if (Subminor == 0)
4893 return VersionTuple(Major, Minor - 1);
4894 return VersionTuple(Major, Minor - 1, Subminor - 1);
4895}
4896
Sebastian Redlc43b54c2010-08-18 23:56:43 +00004897CXXTemporary *ASTReader::ReadCXXTemporary(const RecordData &Record,
Chris Lattnerd2598362010-05-10 00:25:06 +00004898 unsigned &Idx) {
4899 CXXDestructorDecl *Decl = cast<CXXDestructorDecl>(GetDecl(Record[Idx++]));
4900 return CXXTemporary::Create(*Context, Decl);
4901}
4902
Sebastian Redlc43b54c2010-08-18 23:56:43 +00004903DiagnosticBuilder ASTReader::Diag(unsigned DiagID) {
Douglas Gregore1d918e2009-04-10 23:10:45 +00004904 return Diag(SourceLocation(), DiagID);
4905}
4906
Sebastian Redlc43b54c2010-08-18 23:56:43 +00004907DiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) {
Argyrios Kyrtzidis33e4e702010-11-18 20:06:41 +00004908 return Diags.Report(Loc, DiagID);
Douglas Gregor0a0428e2009-04-10 20:39:37 +00004909}
Douglas Gregor025452f2009-04-17 00:04:06 +00004910
Douglas Gregor668c1a42009-04-21 22:25:48 +00004911/// \brief Retrieve the identifier table associated with the
4912/// preprocessor.
Sebastian Redlc43b54c2010-08-18 23:56:43 +00004913IdentifierTable &ASTReader::getIdentifierTable() {
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00004914 assert(PP && "Forgot to set Preprocessor ?");
4915 return PP->getIdentifierTable();
Douglas Gregor668c1a42009-04-21 22:25:48 +00004916}
4917
Douglas Gregor025452f2009-04-17 00:04:06 +00004918/// \brief Record that the given ID maps to the given switch-case
4919/// statement.
Sebastian Redlc43b54c2010-08-18 23:56:43 +00004920void ASTReader::RecordSwitchCaseID(SwitchCase *SC, unsigned ID) {
Douglas Gregor025452f2009-04-17 00:04:06 +00004921 assert(SwitchCaseStmts[ID] == 0 && "Already have a SwitchCase with this ID");
4922 SwitchCaseStmts[ID] = SC;
4923}
4924
4925/// \brief Retrieve the switch-case statement with the given ID.
Sebastian Redlc43b54c2010-08-18 23:56:43 +00004926SwitchCase *ASTReader::getSwitchCaseWithID(unsigned ID) {
Douglas Gregor025452f2009-04-17 00:04:06 +00004927 assert(SwitchCaseStmts[ID] != 0 && "No SwitchCase with this ID");
4928 return SwitchCaseStmts[ID];
4929}
Douglas Gregor1de05fe2009-04-17 18:18:49 +00004930
Argyrios Kyrtzidise09a2752010-10-28 09:29:32 +00004931void ASTReader::ClearSwitchCaseIDs() {
4932 SwitchCaseStmts.clear();
4933}
4934
Sebastian Redlc43b54c2010-08-18 23:56:43 +00004935void ASTReader::FinishedDeserializing() {
Argyrios Kyrtzidis29ee3a22010-07-30 10:03:16 +00004936 assert(NumCurrentElementsDeserializing &&
4937 "FinishedDeserializing not paired with StartedDeserializing");
4938 if (NumCurrentElementsDeserializing == 1) {
Douglas Gregord89275b2009-07-06 18:54:52 +00004939 // If any identifiers with corresponding top-level declarations have
4940 // been loaded, load those declarations now.
Argyrios Kyrtzidis29ee3a22010-07-30 10:03:16 +00004941 while (!PendingIdentifierInfos.empty()) {
4942 SetGloballyVisibleDecls(PendingIdentifierInfos.front().II,
4943 PendingIdentifierInfos.front().DeclIDs, true);
4944 PendingIdentifierInfos.pop_front();
Douglas Gregord89275b2009-07-06 18:54:52 +00004945 }
Argyrios Kyrtzidisbb80a8e2010-07-07 15:46:26 +00004946
Argyrios Kyrtzidis0895d152011-02-12 07:50:47 +00004947 // Ready to load previous declarations of Decls that were delayed.
4948 while (!PendingPreviousDecls.empty()) {
4949 loadAndAttachPreviousDecl(PendingPreviousDecls.front().first,
4950 PendingPreviousDecls.front().second);
4951 PendingPreviousDecls.pop_front();
4952 }
4953
Argyrios Kyrtzidisbb80a8e2010-07-07 15:46:26 +00004954 // We are not in recursive loading, so it's safe to pass the "interesting"
4955 // decls to the consumer.
Argyrios Kyrtzidis29ee3a22010-07-30 10:03:16 +00004956 if (Consumer)
4957 PassInterestingDeclsToConsumer();
Argyrios Kyrtzidis134db1f2010-10-24 17:26:31 +00004958
4959 assert(PendingForwardRefs.size() == 0 &&
4960 "Some forward refs did not get linked to the definition!");
Douglas Gregord89275b2009-07-06 18:54:52 +00004961 }
Argyrios Kyrtzidis29ee3a22010-07-30 10:03:16 +00004962 --NumCurrentElementsDeserializing;
Douglas Gregord89275b2009-07-06 18:54:52 +00004963}
Douglas Gregor501c1032010-08-19 00:28:17 +00004964
Sebastian Redle1dde812010-08-24 00:50:04 +00004965ASTReader::ASTReader(Preprocessor &PP, ASTContext *Context,
Douglas Gregor8ef6c8c2011-02-05 19:42:43 +00004966 const char *isysroot, bool DisableValidation,
4967 bool DisableStatCache)
Sebastian Redle1dde812010-08-24 00:50:04 +00004968 : Listener(new PCHValidator(PP, *this)), DeserializationListener(0),
4969 SourceMgr(PP.getSourceManager()), FileMgr(PP.getFileManager()),
4970 Diags(PP.getDiagnostics()), SemaObj(0), PP(&PP), Context(Context),
4971 Consumer(0), isysroot(isysroot), DisableValidation(DisableValidation),
Douglas Gregor8ef6c8c2011-02-05 19:42:43 +00004972 DisableStatCache(DisableStatCache), NumStatHits(0), NumStatMisses(0),
4973 NumSLocEntriesRead(0), TotalNumSLocEntries(0), NextSLocOffset(0),
4974 NumStatementsRead(0), TotalNumStatements(0), NumMacrosRead(0),
4975 TotalNumMacros(0), NumSelectorsRead(0), NumMethodPoolEntriesRead(0),
4976 NumMethodPoolMisses(0), TotalNumMethodPoolEntries(0),
4977 NumLexicalDeclContextsRead(0), TotalLexicalDeclContexts(0),
4978 NumVisibleDeclContextsRead(0), TotalVisibleDeclContexts(0),
4979 NumCurrentElementsDeserializing(0)
4980{
Sebastian Redle1dde812010-08-24 00:50:04 +00004981 RelocatablePCH = false;
4982}
4983
4984ASTReader::ASTReader(SourceManager &SourceMgr, FileManager &FileMgr,
4985 Diagnostic &Diags, const char *isysroot,
Douglas Gregor8ef6c8c2011-02-05 19:42:43 +00004986 bool DisableValidation, bool DisableStatCache)
Sebastian Redle1dde812010-08-24 00:50:04 +00004987 : DeserializationListener(0), SourceMgr(SourceMgr), FileMgr(FileMgr),
4988 Diags(Diags), SemaObj(0), PP(0), Context(0), Consumer(0),
Douglas Gregor8ef6c8c2011-02-05 19:42:43 +00004989 isysroot(isysroot), DisableValidation(DisableValidation),
4990 DisableStatCache(DisableStatCache), NumStatHits(0), NumStatMisses(0),
4991 NumSLocEntriesRead(0), TotalNumSLocEntries(0),
Sebastian Redl8db9fae2010-09-22 20:19:08 +00004992 NextSLocOffset(0), NumStatementsRead(0), TotalNumStatements(0),
4993 NumMacrosRead(0), TotalNumMacros(0), NumSelectorsRead(0),
4994 NumMethodPoolEntriesRead(0), NumMethodPoolMisses(0),
4995 TotalNumMethodPoolEntries(0), NumLexicalDeclContextsRead(0),
4996 TotalLexicalDeclContexts(0), NumVisibleDeclContextsRead(0),
4997 TotalVisibleDeclContexts(0), NumCurrentElementsDeserializing(0) {
Sebastian Redle1dde812010-08-24 00:50:04 +00004998 RelocatablePCH = false;
4999}
5000
5001ASTReader::~ASTReader() {
5002 for (unsigned i = 0, e = Chain.size(); i != e; ++i)
5003 delete Chain[e - i - 1];
5004 // Delete all visible decl lookup tables
5005 for (DeclContextOffsetsMap::iterator I = DeclContextOffsets.begin(),
5006 E = DeclContextOffsets.end();
5007 I != E; ++I) {
5008 for (DeclContextInfos::iterator J = I->second.begin(), F = I->second.end();
5009 J != F; ++J) {
5010 if (J->NameLookupTableData)
5011 delete static_cast<ASTDeclContextNameLookupTable*>(
5012 J->NameLookupTableData);
5013 }
5014 }
5015 for (DeclContextVisibleUpdatesPending::iterator
5016 I = PendingVisibleUpdates.begin(),
5017 E = PendingVisibleUpdates.end();
5018 I != E; ++I) {
5019 for (DeclContextVisibleUpdates::iterator J = I->second.begin(),
5020 F = I->second.end();
5021 J != F; ++J)
5022 delete static_cast<ASTDeclContextNameLookupTable*>(*J);
5023 }
5024}
5025
Sebastian Redl1d9f1fe2010-10-05 16:15:19 +00005026ASTReader::PerFileData::PerFileData(ASTFileType Ty)
5027 : Type(Ty), SizeInBits(0), LocalNumSLocEntries(0), SLocOffsets(0), LocalSLocSize(0),
Sebastian Redl301c9b02010-09-22 00:42:27 +00005028 LocalNumIdentifiers(0), IdentifierOffsets(0), IdentifierTableData(0),
5029 IdentifierLookupTable(0), LocalNumMacroDefinitions(0),
Douglas Gregorcfbf1c72011-02-10 17:09:37 +00005030 MacroDefinitionOffsets(0),
5031 LocalNumHeaderFileInfos(0), HeaderFileInfoTableData(0),
5032 HeaderFileInfoTable(0),
5033 LocalNumSelectors(0), SelectorOffsets(0),
Sebastian Redl301c9b02010-09-22 00:42:27 +00005034 SelectorLookupTableData(0), SelectorLookupTable(0), LocalNumDecls(0),
Douglas Gregor7c789c12010-10-29 22:39:52 +00005035 DeclOffsets(0), LocalNumCXXBaseSpecifiers(0), CXXBaseSpecifiersOffsets(0),
5036 LocalNumTypes(0), TypeOffsets(0), StatCache(0),
Sebastian Redla866e652010-10-01 19:59:12 +00005037 NumPreallocatedPreprocessingEntities(0), NextInSource(0)
Douglas Gregor501c1032010-08-19 00:28:17 +00005038{}
5039
5040ASTReader::PerFileData::~PerFileData() {
5041 delete static_cast<ASTIdentifierLookupTable *>(IdentifierLookupTable);
Douglas Gregorcfbf1c72011-02-10 17:09:37 +00005042 delete static_cast<HeaderFileInfoLookupTable *>(HeaderFileInfoTable);
Douglas Gregor501c1032010-08-19 00:28:17 +00005043 delete static_cast<ASTSelectorLookupTable *>(SelectorLookupTable);
5044}