blob: ae90fb1d2bee7f8982b3c2572c30051f6b5508dd [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 Gregorf62d43d2011-07-19 16:10:42 +000052#include <iostream>
Douglas Gregorcfbf1c72011-02-10 17:09:37 +000053
Douglas Gregor2cf26342009-04-09 22:27:44 +000054using namespace clang;
Sebastian Redl8538e8d2010-08-18 23:57:32 +000055using namespace clang::serialization;
Douglas Gregor2cf26342009-04-09 22:27:44 +000056
57//===----------------------------------------------------------------------===//
Sebastian Redl3c7f4132010-08-18 23:57:06 +000058// PCH validator implementation
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +000059//===----------------------------------------------------------------------===//
60
Sebastian Redl571db7f2010-08-18 23:56:56 +000061ASTReaderListener::~ASTReaderListener() {}
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +000062
63bool
64PCHValidator::ReadLanguageOptions(const LangOptions &LangOpts) {
65 const LangOptions &PPLangOpts = PP.getLangOptions();
66#define PARSE_LANGOPT_BENIGN(Option)
67#define PARSE_LANGOPT_IMPORTANT(Option, DiagID) \
68 if (PPLangOpts.Option != LangOpts.Option) { \
69 Reader.Diag(DiagID) << LangOpts.Option << PPLangOpts.Option; \
70 return true; \
71 }
72
73 PARSE_LANGOPT_BENIGN(Trigraphs);
74 PARSE_LANGOPT_BENIGN(BCPLComment);
75 PARSE_LANGOPT_BENIGN(DollarIdents);
76 PARSE_LANGOPT_BENIGN(AsmPreprocessor);
77 PARSE_LANGOPT_IMPORTANT(GNUMode, diag::warn_pch_gnu_extensions);
Chandler Carrutheb5d7b72010-04-17 20:17:31 +000078 PARSE_LANGOPT_IMPORTANT(GNUKeywords, diag::warn_pch_gnu_keywords);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +000079 PARSE_LANGOPT_BENIGN(ImplicitInt);
80 PARSE_LANGOPT_BENIGN(Digraphs);
81 PARSE_LANGOPT_BENIGN(HexFloats);
82 PARSE_LANGOPT_IMPORTANT(C99, diag::warn_pch_c99);
Peter Collingbourne7e7fbd02011-04-15 00:35:23 +000083 PARSE_LANGOPT_IMPORTANT(C1X, diag::warn_pch_c1x);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +000084 PARSE_LANGOPT_IMPORTANT(Microsoft, diag::warn_pch_microsoft_extensions);
Michael J. Spencerdae4ac42010-10-21 05:21:48 +000085 PARSE_LANGOPT_BENIGN(MSCVersion);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +000086 PARSE_LANGOPT_IMPORTANT(CPlusPlus, diag::warn_pch_cplusplus);
87 PARSE_LANGOPT_IMPORTANT(CPlusPlus0x, diag::warn_pch_cplusplus0x);
88 PARSE_LANGOPT_BENIGN(CXXOperatorName);
89 PARSE_LANGOPT_IMPORTANT(ObjC1, diag::warn_pch_objective_c);
90 PARSE_LANGOPT_IMPORTANT(ObjC2, diag::warn_pch_objective_c2);
91 PARSE_LANGOPT_IMPORTANT(ObjCNonFragileABI, diag::warn_pch_nonfragile_abi);
Fariborz Jahanian412e7982010-02-09 19:31:38 +000092 PARSE_LANGOPT_IMPORTANT(ObjCNonFragileABI2, diag::warn_pch_nonfragile_abi2);
Fariborz Jahanianf84109e2011-01-07 18:59:25 +000093 PARSE_LANGOPT_IMPORTANT(AppleKext, diag::warn_pch_apple_kext);
Ted Kremenekc32647d2010-12-23 21:35:43 +000094 PARSE_LANGOPT_IMPORTANT(ObjCDefaultSynthProperties,
95 diag::warn_pch_objc_auto_properties);
Douglas Gregor74da19f2011-06-14 23:20:43 +000096 PARSE_LANGOPT_BENIGN(ObjCInferRelatedResultType)
Michael J. Spencer20249a12010-10-21 03:16:25 +000097 PARSE_LANGOPT_IMPORTANT(NoConstantCFStrings,
Fariborz Jahanian4c9d8d02010-04-22 21:01:59 +000098 diag::warn_pch_no_constant_cfstrings);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +000099 PARSE_LANGOPT_BENIGN(PascalStrings);
100 PARSE_LANGOPT_BENIGN(WritableStrings);
Mike Stump1eb44332009-09-09 15:08:12 +0000101 PARSE_LANGOPT_IMPORTANT(LaxVectorConversions,
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000102 diag::warn_pch_lax_vector_conversions);
Nate Begeman69cfb9b2009-06-25 22:57:40 +0000103 PARSE_LANGOPT_IMPORTANT(AltiVec, diag::warn_pch_altivec);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000104 PARSE_LANGOPT_IMPORTANT(Exceptions, diag::warn_pch_exceptions);
Anders Carlssonda4b7cf2011-02-19 23:53:54 +0000105 PARSE_LANGOPT_IMPORTANT(ObjCExceptions, diag::warn_pch_objc_exceptions);
Anders Carlsson7da99b02011-02-23 03:04:54 +0000106 PARSE_LANGOPT_IMPORTANT(CXXExceptions, diag::warn_pch_cxx_exceptions);
107 PARSE_LANGOPT_IMPORTANT(SjLjExceptions, diag::warn_pch_sjlj_exceptions);
Douglas Gregor6f755502011-02-01 15:15:22 +0000108 PARSE_LANGOPT_IMPORTANT(MSBitfields, diag::warn_pch_ms_bitfields);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000109 PARSE_LANGOPT_IMPORTANT(NeXTRuntime, diag::warn_pch_objc_runtime);
110 PARSE_LANGOPT_IMPORTANT(Freestanding, diag::warn_pch_freestanding);
111 PARSE_LANGOPT_IMPORTANT(NoBuiltin, diag::warn_pch_builtins);
Mike Stump1eb44332009-09-09 15:08:12 +0000112 PARSE_LANGOPT_IMPORTANT(ThreadsafeStatics,
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000113 diag::warn_pch_thread_safe_statics);
Daniel Dunbar5345c392009-09-03 04:54:28 +0000114 PARSE_LANGOPT_IMPORTANT(POSIXThreads, diag::warn_pch_posix_threads);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000115 PARSE_LANGOPT_IMPORTANT(Blocks, diag::warn_pch_blocks);
116 PARSE_LANGOPT_BENIGN(EmitAllDecls);
117 PARSE_LANGOPT_IMPORTANT(MathErrno, diag::warn_pch_math_errno);
Chris Lattnera4d71452010-06-26 21:25:03 +0000118 PARSE_LANGOPT_BENIGN(getSignedOverflowBehavior());
Mike Stump1eb44332009-09-09 15:08:12 +0000119 PARSE_LANGOPT_IMPORTANT(HeinousExtensions,
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000120 diag::warn_pch_heinous_extensions);
121 // FIXME: Most of the options below are benign if the macro wasn't
122 // used. Unfortunately, this means that a PCH compiled without
123 // optimization can't be used with optimization turned on, even
124 // though the only thing that changes is whether __OPTIMIZE__ was
125 // defined... but if __OPTIMIZE__ never showed up in the header, it
126 // doesn't matter. We could consider making this some special kind
127 // of check.
128 PARSE_LANGOPT_IMPORTANT(Optimize, diag::warn_pch_optimize);
129 PARSE_LANGOPT_IMPORTANT(OptimizeSize, diag::warn_pch_optimize_size);
130 PARSE_LANGOPT_IMPORTANT(Static, diag::warn_pch_static);
131 PARSE_LANGOPT_IMPORTANT(PICLevel, diag::warn_pch_pic_level);
132 PARSE_LANGOPT_IMPORTANT(GNUInline, diag::warn_pch_gnu_inline);
133 PARSE_LANGOPT_IMPORTANT(NoInline, diag::warn_pch_no_inline);
Chandler Carruth0d2d1bc2011-04-23 20:05:38 +0000134 PARSE_LANGOPT_IMPORTANT(Deprecated, diag::warn_pch_deprecated);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000135 PARSE_LANGOPT_IMPORTANT(AccessControl, diag::warn_pch_access_control);
136 PARSE_LANGOPT_IMPORTANT(CharIsSigned, diag::warn_pch_char_signed);
John Thompsona6fda122009-11-05 20:14:16 +0000137 PARSE_LANGOPT_IMPORTANT(ShortWChar, diag::warn_pch_short_wchar);
Argyrios Kyrtzidis9a2b9d72010-10-08 00:25:19 +0000138 PARSE_LANGOPT_IMPORTANT(ShortEnums, diag::warn_pch_short_enums);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000139 if ((PPLangOpts.getGCMode() != 0) != (LangOpts.getGCMode() != 0)) {
Mike Stump1eb44332009-09-09 15:08:12 +0000140 Reader.Diag(diag::warn_pch_gc_mode)
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000141 << LangOpts.getGCMode() << PPLangOpts.getGCMode();
142 return true;
143 }
144 PARSE_LANGOPT_BENIGN(getVisibilityMode());
Daniel Dunbarab8e2812009-09-21 04:16:19 +0000145 PARSE_LANGOPT_IMPORTANT(getStackProtectorMode(),
146 diag::warn_pch_stack_protector);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000147 PARSE_LANGOPT_BENIGN(InstantiationDepth);
Nate Begeman69cfb9b2009-06-25 22:57:40 +0000148 PARSE_LANGOPT_IMPORTANT(OpenCL, diag::warn_pch_opencl);
Peter Collingbourne08a53262010-12-01 19:14:57 +0000149 PARSE_LANGOPT_IMPORTANT(CUDA, diag::warn_pch_cuda);
Mike Stump9c276ae2009-12-12 01:27:46 +0000150 PARSE_LANGOPT_BENIGN(CatchUndefined);
John McCallf85e1932011-06-15 23:02:42 +0000151 PARSE_LANGOPT_BENIGN(DefaultFPContract);
Daniel Dunbarab8e2812009-09-21 04:16:19 +0000152 PARSE_LANGOPT_IMPORTANT(ElideConstructors, diag::warn_pch_elide_constructors);
Douglas Gregora0068fc2010-07-09 17:35:33 +0000153 PARSE_LANGOPT_BENIGN(SpellChecking);
John McCallf85e1932011-06-15 23:02:42 +0000154 PARSE_LANGOPT_IMPORTANT(ObjCAutoRefCount, diag::warn_pch_auto_ref_count);
155 PARSE_LANGOPT_BENIGN(ObjCInferRelatedReturnType);
Kovarththanan Rajaratnam6b82f642010-03-07 19:10:13 +0000156#undef PARSE_LANGOPT_IMPORTANT
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000157#undef PARSE_LANGOPT_BENIGN
158
159 return false;
160}
161
Chris Lattner5f9e2722011-07-23 10:55:15 +0000162bool PCHValidator::ReadTargetTriple(StringRef Triple) {
Daniel Dunbardc3c0d22009-11-11 00:52:11 +0000163 if (Triple == PP.getTargetInfo().getTriple().str())
164 return false;
165
166 Reader.Diag(diag::warn_pch_target_triple)
167 << Triple << PP.getTargetInfo().getTriple().str();
168 return true;
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000169}
170
Benjamin Kramer54353f42010-11-25 18:29:30 +0000171namespace {
172 struct EmptyStringRef {
Chris Lattner5f9e2722011-07-23 10:55:15 +0000173 bool operator ()(StringRef r) const { return r.empty(); }
Benjamin Kramer54353f42010-11-25 18:29:30 +0000174 };
175 struct EmptyBlock {
176 bool operator ()(const PCHPredefinesBlock &r) const {return r.Data.empty();}
177 };
178}
Sebastian Redl7e9ad8b2010-07-14 17:49:11 +0000179
Chris Lattner5f9e2722011-07-23 10:55:15 +0000180static bool EqualConcatenations(SmallVector<StringRef, 2> L,
Sebastian Redl7e9ad8b2010-07-14 17:49:11 +0000181 PCHPredefinesBlocks R) {
182 // First, sum up the lengths.
183 unsigned LL = 0, RL = 0;
184 for (unsigned I = 0, N = L.size(); I != N; ++I) {
185 LL += L[I].size();
186 }
187 for (unsigned I = 0, N = R.size(); I != N; ++I) {
188 RL += R[I].Data.size();
189 }
190 if (LL != RL)
191 return false;
192 if (LL == 0 && RL == 0)
193 return true;
194
195 // Kick out empty parts, they confuse the algorithm below.
196 L.erase(std::remove_if(L.begin(), L.end(), EmptyStringRef()), L.end());
197 R.erase(std::remove_if(R.begin(), R.end(), EmptyBlock()), R.end());
198
199 // Do it the hard way. At this point, both vectors must be non-empty.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000200 StringRef LR = L[0], RR = R[0].Data;
Sebastian Redl7e9ad8b2010-07-14 17:49:11 +0000201 unsigned LI = 0, RI = 0, LN = L.size(), RN = R.size();
Daniel Dunbarc76c9e02010-07-16 00:00:11 +0000202 (void) RN;
Sebastian Redl7e9ad8b2010-07-14 17:49:11 +0000203 for (;;) {
204 // Compare the current pieces.
205 if (LR.size() == RR.size()) {
206 // If they're the same length, it's pretty easy.
207 if (LR != RR)
208 return false;
209 // Both pieces are done, advance.
210 ++LI;
211 ++RI;
212 // If either string is done, they're both done, since they're the same
213 // length.
214 if (LI == LN) {
215 assert(RI == RN && "Strings not the same length after all?");
216 return true;
217 }
218 LR = L[LI];
219 RR = R[RI].Data;
220 } else if (LR.size() < RR.size()) {
221 // Right piece is longer.
222 if (!RR.startswith(LR))
223 return false;
224 ++LI;
225 assert(LI != LN && "Strings not the same length after all?");
226 RR = RR.substr(LR.size());
227 LR = L[LI];
228 } else {
229 // Left piece is longer.
230 if (!LR.startswith(RR))
231 return false;
232 ++RI;
233 assert(RI != RN && "Strings not the same length after all?");
234 LR = LR.substr(RR.size());
235 RR = R[RI].Data;
236 }
237 }
238}
239
Chris Lattner5f9e2722011-07-23 10:55:15 +0000240static std::pair<FileID, StringRef::size_type>
241FindMacro(const PCHPredefinesBlocks &Buffers, StringRef MacroDef) {
242 std::pair<FileID, StringRef::size_type> Res;
Sebastian Redl7e9ad8b2010-07-14 17:49:11 +0000243 for (unsigned I = 0, N = Buffers.size(); I != N; ++I) {
244 Res.second = Buffers[I].Data.find(MacroDef);
Chris Lattner5f9e2722011-07-23 10:55:15 +0000245 if (Res.second != StringRef::npos) {
Sebastian Redl7e9ad8b2010-07-14 17:49:11 +0000246 Res.first = Buffers[I].BufferID;
247 break;
248 }
249 }
250 return Res;
251}
252
253bool PCHValidator::ReadPredefinesBuffer(const PCHPredefinesBlocks &Buffers,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000254 StringRef OriginalFileName,
Nick Lewycky277a6e72011-02-23 21:16:44 +0000255 std::string &SuggestedPredefines,
256 FileManager &FileMgr) {
Daniel Dunbarc7162932009-11-11 23:58:53 +0000257 // We are in the context of an implicit include, so the predefines buffer will
258 // have a #include entry for the PCH file itself (as normalized by the
259 // preprocessor initialization). Find it and skip over it in the checking
260 // below.
Daniel Dunbar7b5a1212009-11-11 05:29:04 +0000261 llvm::SmallString<256> PCHInclude;
262 PCHInclude += "#include \"";
Nick Lewycky277a6e72011-02-23 21:16:44 +0000263 PCHInclude += NormalizeDashIncludePath(OriginalFileName, FileMgr);
Daniel Dunbar7b5a1212009-11-11 05:29:04 +0000264 PCHInclude += "\"\n";
Chris Lattner5f9e2722011-07-23 10:55:15 +0000265 std::pair<StringRef,StringRef> Split =
266 StringRef(PP.getPredefines()).split(PCHInclude.str());
267 StringRef Left = Split.first, Right = Split.second;
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +0000268 if (Left == PP.getPredefines()) {
269 Error("Missing PCH include entry!");
270 return true;
271 }
Daniel Dunbar7b5a1212009-11-11 05:29:04 +0000272
Sebastian Redl7e9ad8b2010-07-14 17:49:11 +0000273 // If the concatenation of all the PCH buffers is equal to the adjusted
274 // command line, we're done.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000275 SmallVector<StringRef, 2> CommandLine;
Sebastian Redl7e9ad8b2010-07-14 17:49:11 +0000276 CommandLine.push_back(Left);
277 CommandLine.push_back(Right);
278 if (EqualConcatenations(CommandLine, Buffers))
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000279 return false;
280
281 SourceManager &SourceMgr = PP.getSourceManager();
Mike Stump1eb44332009-09-09 15:08:12 +0000282
Daniel Dunbar10014aa2009-11-11 03:45:59 +0000283 // The predefines buffers are different. Determine what the differences are,
284 // and whether they require us to reject the PCH file.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000285 SmallVector<StringRef, 8> PCHLines;
Sebastian Redl7e9ad8b2010-07-14 17:49:11 +0000286 for (unsigned I = 0, N = Buffers.size(); I != N; ++I)
287 Buffers[I].Data.split(PCHLines, "\n", /*MaxSplit=*/-1, /*KeepEmpty=*/false);
Daniel Dunbare6750492009-11-13 16:46:11 +0000288
Chris Lattner5f9e2722011-07-23 10:55:15 +0000289 SmallVector<StringRef, 8> CmdLineLines;
Daniel Dunbare6750492009-11-13 16:46:11 +0000290 Left.split(CmdLineLines, "\n", /*MaxSplit=*/-1, /*KeepEmpty=*/false);
Argyrios Kyrtzidis297c7062010-09-30 16:53:50 +0000291
292 // Pick out implicit #includes after the PCH and don't consider them for
293 // validation; we will insert them into SuggestedPredefines so that the
294 // preprocessor includes them.
295 std::string IncludesAfterPCH;
Chris Lattner5f9e2722011-07-23 10:55:15 +0000296 SmallVector<StringRef, 8> AfterPCHLines;
Argyrios Kyrtzidis297c7062010-09-30 16:53:50 +0000297 Right.split(AfterPCHLines, "\n", /*MaxSplit=*/-1, /*KeepEmpty=*/false);
298 for (unsigned i = 0, e = AfterPCHLines.size(); i != e; ++i) {
299 if (AfterPCHLines[i].startswith("#include ")) {
300 IncludesAfterPCH += AfterPCHLines[i];
301 IncludesAfterPCH += '\n';
302 } else {
303 CmdLineLines.push_back(AfterPCHLines[i]);
304 }
305 }
306
307 // Make sure we add the includes last into SuggestedPredefines before we
308 // exit this function.
309 struct AddIncludesRAII {
310 std::string &SuggestedPredefines;
311 std::string &IncludesAfterPCH;
312
313 AddIncludesRAII(std::string &SuggestedPredefines,
314 std::string &IncludesAfterPCH)
315 : SuggestedPredefines(SuggestedPredefines),
316 IncludesAfterPCH(IncludesAfterPCH) { }
317 ~AddIncludesRAII() {
318 SuggestedPredefines += IncludesAfterPCH;
319 }
320 } AddIncludes(SuggestedPredefines, IncludesAfterPCH);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000321
Daniel Dunbar4d5936a2009-11-11 05:26:28 +0000322 // Sort both sets of predefined buffer lines, since we allow some extra
323 // definitions and they may appear at any point in the output.
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000324 std::sort(CmdLineLines.begin(), CmdLineLines.end());
325 std::sort(PCHLines.begin(), PCHLines.end());
326
Daniel Dunbar4d5936a2009-11-11 05:26:28 +0000327 // Determine which predefines that were used to build the PCH file are missing
328 // from the command line.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000329 std::vector<StringRef> MissingPredefines;
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000330 std::set_difference(PCHLines.begin(), PCHLines.end(),
331 CmdLineLines.begin(), CmdLineLines.end(),
332 std::back_inserter(MissingPredefines));
333
334 bool MissingDefines = false;
335 bool ConflictingDefines = false;
336 for (unsigned I = 0, N = MissingPredefines.size(); I != N; ++I) {
Chris Lattner5f9e2722011-07-23 10:55:15 +0000337 StringRef Missing = MissingPredefines[I];
Argyrios Kyrtzidis297c7062010-09-30 16:53:50 +0000338 if (Missing.startswith("#include ")) {
339 // An -include was specified when generating the PCH; it is included in
340 // the PCH, just ignore it.
341 continue;
342 }
Daniel Dunbar4d5936a2009-11-11 05:26:28 +0000343 if (!Missing.startswith("#define ")) {
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000344 Reader.Diag(diag::warn_pch_compiler_options_mismatch);
345 return true;
346 }
Mike Stump1eb44332009-09-09 15:08:12 +0000347
Daniel Dunbar10014aa2009-11-11 03:45:59 +0000348 // This is a macro definition. Determine the name of the macro we're
349 // defining.
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000350 std::string::size_type StartOfMacroName = strlen("#define ");
Mike Stump1eb44332009-09-09 15:08:12 +0000351 std::string::size_type EndOfMacroName
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000352 = Missing.find_first_of("( \n\r", StartOfMacroName);
353 assert(EndOfMacroName != std::string::npos &&
354 "Couldn't find the end of the macro name");
Chris Lattner5f9e2722011-07-23 10:55:15 +0000355 StringRef MacroName = Missing.slice(StartOfMacroName, EndOfMacroName);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000356
Daniel Dunbar10014aa2009-11-11 03:45:59 +0000357 // Determine whether this macro was given a different definition on the
358 // command line.
Daniel Dunbar4d5936a2009-11-11 05:26:28 +0000359 std::string MacroDefStart = "#define " + MacroName.str();
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000360 std::string::size_type MacroDefLen = MacroDefStart.size();
Chris Lattner5f9e2722011-07-23 10:55:15 +0000361 SmallVector<StringRef, 8>::iterator ConflictPos
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000362 = std::lower_bound(CmdLineLines.begin(), CmdLineLines.end(),
363 MacroDefStart);
364 for (; ConflictPos != CmdLineLines.end(); ++ConflictPos) {
Daniel Dunbar10014aa2009-11-11 03:45:59 +0000365 if (!ConflictPos->startswith(MacroDefStart)) {
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000366 // Different macro; we're done.
367 ConflictPos = CmdLineLines.end();
Mike Stump1eb44332009-09-09 15:08:12 +0000368 break;
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000369 }
Mike Stump1eb44332009-09-09 15:08:12 +0000370
371 assert(ConflictPos->size() > MacroDefLen &&
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000372 "Invalid #define in predefines buffer?");
Mike Stump1eb44332009-09-09 15:08:12 +0000373 if ((*ConflictPos)[MacroDefLen] != ' ' &&
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000374 (*ConflictPos)[MacroDefLen] != '(')
375 continue; // Longer macro name; keep trying.
Mike Stump1eb44332009-09-09 15:08:12 +0000376
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000377 // We found a conflicting macro definition.
378 break;
379 }
Mike Stump1eb44332009-09-09 15:08:12 +0000380
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000381 if (ConflictPos != CmdLineLines.end()) {
382 Reader.Diag(diag::warn_cmdline_conflicting_macro_def)
383 << MacroName;
384
385 // Show the definition of this macro within the PCH file.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000386 std::pair<FileID, StringRef::size_type> MacroLoc =
Sebastian Redl7e9ad8b2010-07-14 17:49:11 +0000387 FindMacro(Buffers, Missing);
Chris Lattner5f9e2722011-07-23 10:55:15 +0000388 assert(MacroLoc.second!=StringRef::npos && "Unable to find macro!");
Sebastian Redl7e9ad8b2010-07-14 17:49:11 +0000389 SourceLocation PCHMissingLoc =
390 SourceMgr.getLocForStartOfFile(MacroLoc.first)
391 .getFileLocWithOffset(MacroLoc.second);
Daniel Dunbar4d5936a2009-11-11 05:26:28 +0000392 Reader.Diag(PCHMissingLoc, diag::note_pch_macro_defined_as) << MacroName;
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000393
394 ConflictingDefines = true;
395 continue;
396 }
Mike Stump1eb44332009-09-09 15:08:12 +0000397
Daniel Dunbar10014aa2009-11-11 03:45:59 +0000398 // If the macro doesn't conflict, then we'll just pick up the macro
399 // definition from the PCH file. Warn the user that they made a mistake.
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000400 if (ConflictingDefines)
401 continue; // Don't complain if there are already conflicting defs
Mike Stump1eb44332009-09-09 15:08:12 +0000402
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000403 if (!MissingDefines) {
404 Reader.Diag(diag::warn_cmdline_missing_macro_defs);
405 MissingDefines = true;
406 }
407
408 // Show the definition of this macro within the PCH file.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000409 std::pair<FileID, StringRef::size_type> MacroLoc =
Sebastian Redl7e9ad8b2010-07-14 17:49:11 +0000410 FindMacro(Buffers, Missing);
Chris Lattner5f9e2722011-07-23 10:55:15 +0000411 assert(MacroLoc.second!=StringRef::npos && "Unable to find macro!");
Sebastian Redl7e9ad8b2010-07-14 17:49:11 +0000412 SourceLocation PCHMissingLoc =
413 SourceMgr.getLocForStartOfFile(MacroLoc.first)
414 .getFileLocWithOffset(MacroLoc.second);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000415 Reader.Diag(PCHMissingLoc, diag::note_using_macro_def_from_pch);
416 }
Mike Stump1eb44332009-09-09 15:08:12 +0000417
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000418 if (ConflictingDefines)
419 return true;
Mike Stump1eb44332009-09-09 15:08:12 +0000420
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000421 // Determine what predefines were introduced based on command-line
422 // parameters that were not present when building the PCH
423 // file. Extra #defines are okay, so long as the identifiers being
424 // defined were not used within the precompiled header.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000425 std::vector<StringRef> ExtraPredefines;
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000426 std::set_difference(CmdLineLines.begin(), CmdLineLines.end(),
427 PCHLines.begin(), PCHLines.end(),
Mike Stump1eb44332009-09-09 15:08:12 +0000428 std::back_inserter(ExtraPredefines));
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000429 for (unsigned I = 0, N = ExtraPredefines.size(); I != N; ++I) {
Chris Lattner5f9e2722011-07-23 10:55:15 +0000430 StringRef &Extra = ExtraPredefines[I];
Daniel Dunbar4d5936a2009-11-11 05:26:28 +0000431 if (!Extra.startswith("#define ")) {
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000432 Reader.Diag(diag::warn_pch_compiler_options_mismatch);
433 return true;
434 }
435
436 // This is an extra macro definition. Determine the name of the
437 // macro we're defining.
438 std::string::size_type StartOfMacroName = strlen("#define ");
Mike Stump1eb44332009-09-09 15:08:12 +0000439 std::string::size_type EndOfMacroName
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000440 = Extra.find_first_of("( \n\r", StartOfMacroName);
441 assert(EndOfMacroName != std::string::npos &&
442 "Couldn't find the end of the macro name");
Chris Lattner5f9e2722011-07-23 10:55:15 +0000443 StringRef MacroName = Extra.slice(StartOfMacroName, EndOfMacroName);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000444
445 // Check whether this name was used somewhere in the PCH file. If
446 // so, defining it as a macro could change behavior, so we reject
447 // the PCH file.
Daniel Dunbar4d5936a2009-11-11 05:26:28 +0000448 if (IdentifierInfo *II = Reader.get(MacroName)) {
Daniel Dunbar4fda42e2009-11-11 00:52:00 +0000449 Reader.Diag(diag::warn_macro_name_used_in_pch) << II;
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000450 return true;
451 }
452
453 // Add this definition to the suggested predefines buffer.
454 SuggestedPredefines += Extra;
455 SuggestedPredefines += '\n';
456 }
457
458 // If we get here, it's because the predefines buffer had compatible
459 // contents. Accept the PCH file.
460 return false;
461}
462
Douglas Gregor12fab312010-03-16 16:35:32 +0000463void PCHValidator::ReadHeaderFileInfo(const HeaderFileInfo &HFI,
464 unsigned ID) {
465 PP.getHeaderSearchInfo().setHeaderFileInfoForUID(HFI, ID);
466 ++NumHeaderInfos;
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000467}
468
469void PCHValidator::ReadCounter(unsigned Value) {
470 PP.setCounterValue(Value);
471}
472
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000473//===----------------------------------------------------------------------===//
Sebastian Redlc43b54c2010-08-18 23:56:43 +0000474// AST reader implementation
Douglas Gregor668c1a42009-04-21 22:25:48 +0000475//===----------------------------------------------------------------------===//
476
Sebastian Redlffaab3e2010-07-30 00:29:29 +0000477void
Sebastian Redl571db7f2010-08-18 23:56:56 +0000478ASTReader::setDeserializationListener(ASTDeserializationListener *Listener) {
Sebastian Redlffaab3e2010-07-30 00:29:29 +0000479 DeserializationListener = Listener;
Sebastian Redlffaab3e2010-07-30 00:29:29 +0000480}
481
Chris Lattner4c6f9522009-04-27 05:14:47 +0000482
Douglas Gregor668c1a42009-04-21 22:25:48 +0000483namespace {
Sebastian Redl3c7f4132010-08-18 23:57:06 +0000484class ASTSelectorLookupTrait {
Sebastian Redlc43b54c2010-08-18 23:56:43 +0000485 ASTReader &Reader;
Douglas Gregor72a9ae12011-07-22 16:00:58 +0000486 Module &F;
Douglas Gregor409448c2011-07-21 22:35:25 +0000487
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000488public:
Sebastian Redl5d050072010-08-04 17:20:04 +0000489 struct data_type {
Sebastian Redl8538e8d2010-08-18 23:57:32 +0000490 SelectorID ID;
Sebastian Redl5d050072010-08-04 17:20:04 +0000491 ObjCMethodList Instance, Factory;
492 };
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000493
494 typedef Selector external_key_type;
495 typedef external_key_type internal_key_type;
496
Douglas Gregor72a9ae12011-07-22 16:00:58 +0000497 ASTSelectorLookupTrait(ASTReader &Reader, Module &F)
Douglas Gregor409448c2011-07-21 22:35:25 +0000498 : Reader(Reader), F(F) { }
Mike Stump1eb44332009-09-09 15:08:12 +0000499
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000500 static bool EqualKey(const internal_key_type& a,
501 const internal_key_type& b) {
502 return a == b;
503 }
Mike Stump1eb44332009-09-09 15:08:12 +0000504
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000505 static unsigned ComputeHash(Selector Sel) {
Argyrios Kyrtzidis0eca89e2010-08-20 16:03:52 +0000506 return serialization::ComputeHash(Sel);
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000507 }
Mike Stump1eb44332009-09-09 15:08:12 +0000508
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000509 // This hopefully will just get inlined and removed by the optimizer.
510 static const internal_key_type&
511 GetInternalKey(const external_key_type& x) { return x; }
Mike Stump1eb44332009-09-09 15:08:12 +0000512
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000513 static std::pair<unsigned, unsigned>
514 ReadKeyDataLength(const unsigned char*& d) {
515 using namespace clang::io;
516 unsigned KeyLen = ReadUnalignedLE16(d);
517 unsigned DataLen = ReadUnalignedLE16(d);
518 return std::make_pair(KeyLen, DataLen);
519 }
Mike Stump1eb44332009-09-09 15:08:12 +0000520
Douglas Gregor83941df2009-04-25 17:48:32 +0000521 internal_key_type ReadKey(const unsigned char* d, unsigned) {
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000522 using namespace clang::io;
Chris Lattnerd1d64a02009-04-27 21:45:14 +0000523 SelectorTable &SelTable = Reader.getContext()->Selectors;
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000524 unsigned N = ReadUnalignedLE16(d);
Mike Stump1eb44332009-09-09 15:08:12 +0000525 IdentifierInfo *FirstII
Douglas Gregor95eab172011-07-28 20:55:49 +0000526 = Reader.getLocalIdentifier(F, ReadUnalignedLE32(d));
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000527 if (N == 0)
528 return SelTable.getNullarySelector(FirstII);
529 else if (N == 1)
530 return SelTable.getUnarySelector(FirstII);
531
Chris Lattner5f9e2722011-07-23 10:55:15 +0000532 SmallVector<IdentifierInfo *, 16> Args;
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000533 Args.push_back(FirstII);
534 for (unsigned I = 1; I != N; ++I)
Douglas Gregor95eab172011-07-28 20:55:49 +0000535 Args.push_back(Reader.getLocalIdentifier(F, ReadUnalignedLE32(d)));
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000536
Douglas Gregor75fdb232009-05-22 22:45:36 +0000537 return SelTable.getSelector(N, Args.data());
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000538 }
Mike Stump1eb44332009-09-09 15:08:12 +0000539
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000540 data_type ReadData(Selector, const unsigned char* d, unsigned DataLen) {
541 using namespace clang::io;
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000542
543 data_type Result;
544
Douglas Gregor2d2689a2011-07-28 21:16:51 +0000545 Result.ID = Reader.getGlobalSelectorID(F, ReadUnalignedLE32(d));
Sebastian Redl5d050072010-08-04 17:20:04 +0000546 unsigned NumInstanceMethods = ReadUnalignedLE16(d);
547 unsigned NumFactoryMethods = ReadUnalignedLE16(d);
548
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000549 // Load instance methods
550 ObjCMethodList *Prev = 0;
551 for (unsigned I = 0; I != NumInstanceMethods; ++I) {
Mike Stump1eb44332009-09-09 15:08:12 +0000552 ObjCMethodDecl *Method
Douglas Gregor409448c2011-07-21 22:35:25 +0000553 = Reader.GetLocalDeclAs<ObjCMethodDecl>(F, ReadUnalignedLE32(d));
Sebastian Redl5d050072010-08-04 17:20:04 +0000554 if (!Result.Instance.Method) {
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000555 // This is the first method, which is the easy case.
Sebastian Redl5d050072010-08-04 17:20:04 +0000556 Result.Instance.Method = Method;
557 Prev = &Result.Instance;
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000558 continue;
559 }
560
Ted Kremenek298ed872010-02-11 00:53:01 +0000561 ObjCMethodList *Mem =
562 Reader.getSema()->BumpAlloc.Allocate<ObjCMethodList>();
563 Prev->Next = new (Mem) ObjCMethodList(Method, 0);
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000564 Prev = Prev->Next;
565 }
566
567 // Load factory methods
568 Prev = 0;
569 for (unsigned I = 0; I != NumFactoryMethods; ++I) {
Mike Stump1eb44332009-09-09 15:08:12 +0000570 ObjCMethodDecl *Method
Douglas Gregor409448c2011-07-21 22:35:25 +0000571 = Reader.GetLocalDeclAs<ObjCMethodDecl>(F, ReadUnalignedLE32(d));
Sebastian Redl5d050072010-08-04 17:20:04 +0000572 if (!Result.Factory.Method) {
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000573 // This is the first method, which is the easy case.
Sebastian Redl5d050072010-08-04 17:20:04 +0000574 Result.Factory.Method = Method;
575 Prev = &Result.Factory;
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000576 continue;
577 }
578
Ted Kremenek298ed872010-02-11 00:53:01 +0000579 ObjCMethodList *Mem =
580 Reader.getSema()->BumpAlloc.Allocate<ObjCMethodList>();
581 Prev->Next = new (Mem) ObjCMethodList(Method, 0);
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000582 Prev = Prev->Next;
583 }
584
585 return Result;
586 }
587};
Mike Stump1eb44332009-09-09 15:08:12 +0000588
589} // end anonymous namespace
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000590
591/// \brief The on-disk hash table used for the global method pool.
Sebastian Redl3c7f4132010-08-18 23:57:06 +0000592typedef OnDiskChainedHashTable<ASTSelectorLookupTrait>
593 ASTSelectorLookupTable;
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000594
Sebastian Redlc3632732010-10-05 15:59:54 +0000595namespace clang {
Sebastian Redl3c7f4132010-08-18 23:57:06 +0000596class ASTIdentifierLookupTrait {
Sebastian Redlc43b54c2010-08-18 23:56:43 +0000597 ASTReader &Reader;
Douglas Gregor72a9ae12011-07-22 16:00:58 +0000598 Module &F;
Douglas Gregor668c1a42009-04-21 22:25:48 +0000599
600 // If we know the IdentifierInfo in advance, it is here and we will
601 // not build a new one. Used when deserializing information about an
Sebastian Redl3c7f4132010-08-18 23:57:06 +0000602 // identifier that was constructed before the AST file was read.
Douglas Gregor668c1a42009-04-21 22:25:48 +0000603 IdentifierInfo *KnownII;
604
605public:
606 typedef IdentifierInfo * data_type;
607
608 typedef const std::pair<const char*, unsigned> external_key_type;
609
610 typedef external_key_type internal_key_type;
611
Douglas Gregor72a9ae12011-07-22 16:00:58 +0000612 ASTIdentifierLookupTrait(ASTReader &Reader, Module &F,
Sebastian Redld27d3fc2010-07-21 22:31:37 +0000613 IdentifierInfo *II = 0)
Sebastian Redlc3632732010-10-05 15:59:54 +0000614 : Reader(Reader), F(F), KnownII(II) { }
Mike Stump1eb44332009-09-09 15:08:12 +0000615
Douglas Gregor668c1a42009-04-21 22:25:48 +0000616 static bool EqualKey(const internal_key_type& a,
617 const internal_key_type& b) {
618 return (a.second == b.second) ? memcmp(a.first, b.first, a.second) == 0
619 : false;
620 }
Mike Stump1eb44332009-09-09 15:08:12 +0000621
Douglas Gregor668c1a42009-04-21 22:25:48 +0000622 static unsigned ComputeHash(const internal_key_type& a) {
Chris Lattner5f9e2722011-07-23 10:55:15 +0000623 return llvm::HashString(StringRef(a.first, a.second));
Douglas Gregor668c1a42009-04-21 22:25:48 +0000624 }
Mike Stump1eb44332009-09-09 15:08:12 +0000625
Douglas Gregor668c1a42009-04-21 22:25:48 +0000626 // This hopefully will just get inlined and removed by the optimizer.
627 static const internal_key_type&
628 GetInternalKey(const external_key_type& x) { return x; }
Mike Stump1eb44332009-09-09 15:08:12 +0000629
Douglas Gregor95f42922010-10-14 22:11:03 +0000630 // This hopefully will just get inlined and removed by the optimizer.
631 static const external_key_type&
632 GetExternalKey(const internal_key_type& x) { return x; }
633
Douglas Gregor668c1a42009-04-21 22:25:48 +0000634 static std::pair<unsigned, unsigned>
635 ReadKeyDataLength(const unsigned char*& d) {
636 using namespace clang::io;
Douglas Gregor5f8e3302009-04-25 20:26:24 +0000637 unsigned DataLen = ReadUnalignedLE16(d);
Douglas Gregord6595a42009-04-25 21:04:17 +0000638 unsigned KeyLen = ReadUnalignedLE16(d);
Douglas Gregor668c1a42009-04-21 22:25:48 +0000639 return std::make_pair(KeyLen, DataLen);
640 }
Mike Stump1eb44332009-09-09 15:08:12 +0000641
Douglas Gregor668c1a42009-04-21 22:25:48 +0000642 static std::pair<const char*, unsigned>
643 ReadKey(const unsigned char* d, unsigned n) {
644 assert(n >= 2 && d[n-1] == '\0');
645 return std::make_pair((const char*) d, n-1);
646 }
Mike Stump1eb44332009-09-09 15:08:12 +0000647
648 IdentifierInfo *ReadData(const internal_key_type& k,
Douglas Gregor668c1a42009-04-21 22:25:48 +0000649 const unsigned char* d,
650 unsigned DataLen) {
651 using namespace clang::io;
Douglas Gregor2d2689a2011-07-28 21:16:51 +0000652 IdentID ID = Reader.getGlobalSelectorID(F, ReadUnalignedLE32(d));
Douglas Gregora92193e2009-04-28 21:18:29 +0000653 bool IsInteresting = ID & 0x01;
654
655 // Wipe out the "is interesting" bit.
656 ID = ID >> 1;
657
658 if (!IsInteresting) {
Sebastian Redl083abdf2010-07-27 23:01:28 +0000659 // For uninteresting identifiers, just build the IdentifierInfo
Douglas Gregora92193e2009-04-28 21:18:29 +0000660 // and associate it with the persistent ID.
661 IdentifierInfo *II = KnownII;
662 if (!II)
Chris Lattner5f9e2722011-07-23 10:55:15 +0000663 II = &Reader.getIdentifierTable().getOwn(StringRef(k.first,
Jay Foad65aa6882011-06-21 15:13:30 +0000664 k.second));
Douglas Gregora92193e2009-04-28 21:18:29 +0000665 Reader.SetIdentifierInfo(ID, II);
Sebastian Redl3c7f4132010-08-18 23:57:06 +0000666 II->setIsFromAST();
Douglas Gregora92193e2009-04-28 21:18:29 +0000667 return II;
668 }
669
Douglas Gregor5998da52009-04-28 21:32:13 +0000670 unsigned Bits = ReadUnalignedLE16(d);
Douglas Gregor2deaea32009-04-22 18:49:13 +0000671 bool CPlusPlusOperatorKeyword = Bits & 0x01;
672 Bits >>= 1;
Argyrios Kyrtzidis646395b2010-08-11 22:55:12 +0000673 bool HasRevertedTokenIDToIdentifier = Bits & 0x01;
674 Bits >>= 1;
Douglas Gregor2deaea32009-04-22 18:49:13 +0000675 bool Poisoned = Bits & 0x01;
676 Bits >>= 1;
677 bool ExtensionToken = Bits & 0x01;
678 Bits >>= 1;
679 bool hasMacroDefinition = Bits & 0x01;
680 Bits >>= 1;
681 unsigned ObjCOrBuiltinID = Bits & 0x3FF;
682 Bits >>= 10;
Mike Stump1eb44332009-09-09 15:08:12 +0000683
Douglas Gregor2deaea32009-04-22 18:49:13 +0000684 assert(Bits == 0 && "Extra bits in the identifier?");
Douglas Gregor5998da52009-04-28 21:32:13 +0000685 DataLen -= 6;
Douglas Gregor668c1a42009-04-21 22:25:48 +0000686
687 // Build the IdentifierInfo itself and link the identifier ID with
688 // the new IdentifierInfo.
689 IdentifierInfo *II = KnownII;
690 if (!II)
Chris Lattner5f9e2722011-07-23 10:55:15 +0000691 II = &Reader.getIdentifierTable().getOwn(StringRef(k.first,
Jay Foad65aa6882011-06-21 15:13:30 +0000692 k.second));
Douglas Gregor668c1a42009-04-21 22:25:48 +0000693 Reader.SetIdentifierInfo(ID, II);
694
Douglas Gregor2deaea32009-04-22 18:49:13 +0000695 // Set or check the various bits in the IdentifierInfo structure.
Argyrios Kyrtzidis646395b2010-08-11 22:55:12 +0000696 // Token IDs are read-only.
697 if (HasRevertedTokenIDToIdentifier)
698 II->RevertTokenIDToIdentifier();
Douglas Gregor2deaea32009-04-22 18:49:13 +0000699 II->setObjCOrBuiltinID(ObjCOrBuiltinID);
Mike Stump1eb44332009-09-09 15:08:12 +0000700 assert(II->isExtensionToken() == ExtensionToken &&
Douglas Gregor2deaea32009-04-22 18:49:13 +0000701 "Incorrect extension token flag");
702 (void)ExtensionToken;
703 II->setIsPoisoned(Poisoned);
704 assert(II->isCPlusPlusOperatorKeyword() == CPlusPlusOperatorKeyword &&
705 "Incorrect C++ operator keyword flag");
706 (void)CPlusPlusOperatorKeyword;
707
Douglas Gregor37e26842009-04-21 23:56:24 +0000708 // If this identifier is a macro, deserialize the macro
709 // definition.
710 if (hasMacroDefinition) {
Douglas Gregor5998da52009-04-28 21:32:13 +0000711 uint32_t Offset = ReadUnalignedLE32(d);
Douglas Gregor295a2a62010-10-30 00:23:06 +0000712 Reader.SetIdentifierIsMacro(II, F, Offset);
Douglas Gregor5998da52009-04-28 21:32:13 +0000713 DataLen -= 4;
Douglas Gregor37e26842009-04-21 23:56:24 +0000714 }
Douglas Gregor668c1a42009-04-21 22:25:48 +0000715
716 // Read all of the declarations visible at global scope with this
717 // name.
Chris Lattner6bf690f2009-04-27 22:17:41 +0000718 if (Reader.getContext() == 0) return II;
Douglas Gregord89275b2009-07-06 18:54:52 +0000719 if (DataLen > 0) {
Chris Lattner5f9e2722011-07-23 10:55:15 +0000720 SmallVector<uint32_t, 4> DeclIDs;
Douglas Gregord89275b2009-07-06 18:54:52 +0000721 for (; DataLen > 0; DataLen -= 4)
Douglas Gregorf5bb9ae2011-07-21 23:29:11 +0000722 DeclIDs.push_back(Reader.getGlobalDeclID(F, ReadUnalignedLE32(d)));
Douglas Gregord89275b2009-07-06 18:54:52 +0000723 Reader.SetGloballyVisibleDecls(II, DeclIDs);
Douglas Gregor668c1a42009-04-21 22:25:48 +0000724 }
Mike Stump1eb44332009-09-09 15:08:12 +0000725
Sebastian Redl3c7f4132010-08-18 23:57:06 +0000726 II->setIsFromAST();
Douglas Gregor668c1a42009-04-21 22:25:48 +0000727 return II;
728 }
729};
Mike Stump1eb44332009-09-09 15:08:12 +0000730
731} // end anonymous namespace
Douglas Gregor668c1a42009-04-21 22:25:48 +0000732
733/// \brief The on-disk hash table used to contain information about
734/// all of the identifiers in the program.
Sebastian Redl3c7f4132010-08-18 23:57:06 +0000735typedef OnDiskChainedHashTable<ASTIdentifierLookupTrait>
736 ASTIdentifierLookupTable;
Douglas Gregor668c1a42009-04-21 22:25:48 +0000737
Argyrios Kyrtzidis5d267682010-08-20 16:04:27 +0000738namespace {
739class ASTDeclContextNameLookupTrait {
740 ASTReader &Reader;
Douglas Gregor72a9ae12011-07-22 16:00:58 +0000741 Module &F;
Douglas Gregor393f2492011-07-22 00:38:23 +0000742
Argyrios Kyrtzidis5d267682010-08-20 16:04:27 +0000743public:
744 /// \brief Pair of begin/end iterators for DeclIDs.
Douglas Gregore144c702011-07-28 22:16:57 +0000745 ///
746 /// Note that these declaration IDs are local to the module that contains this
747 /// particular lookup t
Argyrios Kyrtzidis5d267682010-08-20 16:04:27 +0000748 typedef std::pair<DeclID *, DeclID *> data_type;
749
750 /// \brief Special internal key for declaration names.
751 /// The hash table creates keys for comparison; we do not create
752 /// a DeclarationName for the internal key to avoid deserializing types.
753 struct DeclNameKey {
754 DeclarationName::NameKind Kind;
755 uint64_t Data;
756 DeclNameKey() : Kind((DeclarationName::NameKind)0), Data(0) { }
757 };
758
759 typedef DeclarationName external_key_type;
760 typedef DeclNameKey internal_key_type;
761
Douglas Gregor393f2492011-07-22 00:38:23 +0000762 explicit ASTDeclContextNameLookupTrait(ASTReader &Reader,
Douglas Gregor72a9ae12011-07-22 16:00:58 +0000763 Module &F)
Douglas Gregor393f2492011-07-22 00:38:23 +0000764 : Reader(Reader), F(F) { }
Argyrios Kyrtzidis5d267682010-08-20 16:04:27 +0000765
766 static bool EqualKey(const internal_key_type& a,
767 const internal_key_type& b) {
768 return a.Kind == b.Kind && a.Data == b.Data;
769 }
770
771 unsigned ComputeHash(const DeclNameKey &Key) const {
772 llvm::FoldingSetNodeID ID;
773 ID.AddInteger(Key.Kind);
774
775 switch (Key.Kind) {
776 case DeclarationName::Identifier:
777 case DeclarationName::CXXLiteralOperatorName:
778 ID.AddString(((IdentifierInfo*)Key.Data)->getName());
779 break;
780 case DeclarationName::ObjCZeroArgSelector:
781 case DeclarationName::ObjCOneArgSelector:
782 case DeclarationName::ObjCMultiArgSelector:
783 ID.AddInteger(serialization::ComputeHash(Selector(Key.Data)));
784 break;
785 case DeclarationName::CXXConstructorName:
786 case DeclarationName::CXXDestructorName:
787 case DeclarationName::CXXConversionFunctionName:
788 ID.AddInteger((TypeID)Key.Data);
789 break;
790 case DeclarationName::CXXOperatorName:
791 ID.AddInteger((OverloadedOperatorKind)Key.Data);
792 break;
793 case DeclarationName::CXXUsingDirective:
794 break;
795 }
796
797 return ID.ComputeHash();
798 }
799
800 internal_key_type GetInternalKey(const external_key_type& Name) const {
801 DeclNameKey Key;
802 Key.Kind = Name.getNameKind();
803 switch (Name.getNameKind()) {
804 case DeclarationName::Identifier:
805 Key.Data = (uint64_t)Name.getAsIdentifierInfo();
806 break;
807 case DeclarationName::ObjCZeroArgSelector:
808 case DeclarationName::ObjCOneArgSelector:
809 case DeclarationName::ObjCMultiArgSelector:
810 Key.Data = (uint64_t)Name.getObjCSelector().getAsOpaquePtr();
811 break;
812 case DeclarationName::CXXConstructorName:
813 case DeclarationName::CXXDestructorName:
814 case DeclarationName::CXXConversionFunctionName:
815 Key.Data = Reader.GetTypeID(Name.getCXXNameType());
816 break;
817 case DeclarationName::CXXOperatorName:
818 Key.Data = Name.getCXXOverloadedOperator();
819 break;
820 case DeclarationName::CXXLiteralOperatorName:
821 Key.Data = (uint64_t)Name.getCXXLiteralIdentifier();
822 break;
823 case DeclarationName::CXXUsingDirective:
824 break;
825 }
Michael J. Spencer20249a12010-10-21 03:16:25 +0000826
Argyrios Kyrtzidis5d267682010-08-20 16:04:27 +0000827 return Key;
828 }
829
Argyrios Kyrtzidisa60786b2010-08-20 23:35:55 +0000830 external_key_type GetExternalKey(const internal_key_type& Key) const {
831 ASTContext *Context = Reader.getContext();
832 switch (Key.Kind) {
833 case DeclarationName::Identifier:
834 return DeclarationName((IdentifierInfo*)Key.Data);
835
836 case DeclarationName::ObjCZeroArgSelector:
837 case DeclarationName::ObjCOneArgSelector:
838 case DeclarationName::ObjCMultiArgSelector:
839 return DeclarationName(Selector(Key.Data));
840
841 case DeclarationName::CXXConstructorName:
842 return Context->DeclarationNames.getCXXConstructorName(
Douglas Gregor393f2492011-07-22 00:38:23 +0000843 Context->getCanonicalType(Reader.getLocalType(F, Key.Data)));
Argyrios Kyrtzidisa60786b2010-08-20 23:35:55 +0000844
845 case DeclarationName::CXXDestructorName:
846 return Context->DeclarationNames.getCXXDestructorName(
Douglas Gregor393f2492011-07-22 00:38:23 +0000847 Context->getCanonicalType(Reader.getLocalType(F, Key.Data)));
Argyrios Kyrtzidisa60786b2010-08-20 23:35:55 +0000848
849 case DeclarationName::CXXConversionFunctionName:
850 return Context->DeclarationNames.getCXXConversionFunctionName(
Douglas Gregor393f2492011-07-22 00:38:23 +0000851 Context->getCanonicalType(Reader.getLocalType(F, Key.Data)));
Argyrios Kyrtzidisa60786b2010-08-20 23:35:55 +0000852
853 case DeclarationName::CXXOperatorName:
854 return Context->DeclarationNames.getCXXOperatorName(
855 (OverloadedOperatorKind)Key.Data);
856
857 case DeclarationName::CXXLiteralOperatorName:
858 return Context->DeclarationNames.getCXXLiteralOperatorName(
859 (IdentifierInfo*)Key.Data);
860
861 case DeclarationName::CXXUsingDirective:
862 return DeclarationName::getUsingDirectiveName();
863 }
864
865 llvm_unreachable("Invalid Name Kind ?");
866 }
867
Argyrios Kyrtzidis5d267682010-08-20 16:04:27 +0000868 static std::pair<unsigned, unsigned>
869 ReadKeyDataLength(const unsigned char*& d) {
870 using namespace clang::io;
871 unsigned KeyLen = ReadUnalignedLE16(d);
872 unsigned DataLen = ReadUnalignedLE16(d);
873 return std::make_pair(KeyLen, DataLen);
874 }
875
876 internal_key_type ReadKey(const unsigned char* d, unsigned) {
877 using namespace clang::io;
878
879 DeclNameKey Key;
880 Key.Kind = (DeclarationName::NameKind)*d++;
881 switch (Key.Kind) {
882 case DeclarationName::Identifier:
Douglas Gregor95eab172011-07-28 20:55:49 +0000883 Key.Data = (uint64_t)Reader.getLocalIdentifier(F, ReadUnalignedLE32(d));
Argyrios Kyrtzidis5d267682010-08-20 16:04:27 +0000884 break;
885 case DeclarationName::ObjCZeroArgSelector:
886 case DeclarationName::ObjCOneArgSelector:
887 case DeclarationName::ObjCMultiArgSelector:
Michael J. Spencer20249a12010-10-21 03:16:25 +0000888 Key.Data =
Douglas Gregor2d2689a2011-07-28 21:16:51 +0000889 (uint64_t)Reader.getLocalSelector(F, ReadUnalignedLE32(d))
890 .getAsOpaquePtr();
Argyrios Kyrtzidis5d267682010-08-20 16:04:27 +0000891 break;
892 case DeclarationName::CXXConstructorName:
893 case DeclarationName::CXXDestructorName:
894 case DeclarationName::CXXConversionFunctionName:
Douglas Gregor2d2689a2011-07-28 21:16:51 +0000895 Key.Data = Reader.getGlobalTypeID(F, ReadUnalignedLE32(d)); // TypeID
Argyrios Kyrtzidis5d267682010-08-20 16:04:27 +0000896 break;
897 case DeclarationName::CXXOperatorName:
898 Key.Data = *d++; // OverloadedOperatorKind
899 break;
900 case DeclarationName::CXXLiteralOperatorName:
Douglas Gregor95eab172011-07-28 20:55:49 +0000901 Key.Data = (uint64_t)Reader.getLocalIdentifier(F, ReadUnalignedLE32(d));
Argyrios Kyrtzidis5d267682010-08-20 16:04:27 +0000902 break;
903 case DeclarationName::CXXUsingDirective:
904 break;
905 }
Michael J. Spencer20249a12010-10-21 03:16:25 +0000906
Argyrios Kyrtzidis5d267682010-08-20 16:04:27 +0000907 return Key;
908 }
909
910 data_type ReadData(internal_key_type, const unsigned char* d,
911 unsigned DataLen) {
912 using namespace clang::io;
913 unsigned NumDecls = ReadUnalignedLE16(d);
914 DeclID *Start = (DeclID *)d;
915 return std::make_pair(Start, Start + NumDecls);
916 }
917};
918
919} // end anonymous namespace
920
921/// \brief The on-disk hash table used for the DeclContext's Name lookup table.
922typedef OnDiskChainedHashTable<ASTDeclContextNameLookupTrait>
923 ASTDeclContextNameLookupTable;
924
Argyrios Kyrtzidis074dcc82010-08-20 16:04:35 +0000925bool ASTReader::ReadDeclContextStorage(llvm::BitstreamCursor &Cursor,
926 const std::pair<uint64_t, uint64_t> &Offsets,
927 DeclContextInfo &Info) {
928 SavedStreamPosition SavedPosition(Cursor);
929 // First the lexical decls.
930 if (Offsets.first != 0) {
931 Cursor.JumpToBit(Offsets.first);
932
933 RecordData Record;
934 const char *Blob;
935 unsigned BlobLen;
936 unsigned Code = Cursor.ReadCode();
937 unsigned RecCode = Cursor.ReadRecord(Code, Record, &Blob, &BlobLen);
938 if (RecCode != DECL_CONTEXT_LEXICAL) {
939 Error("Expected lexical block");
940 return true;
941 }
942
Argyrios Kyrtzidiseb5e9982010-10-14 20:14:34 +0000943 Info.LexicalDecls = reinterpret_cast<const KindDeclIDPair*>(Blob);
944 Info.NumLexicalDecls = BlobLen / sizeof(KindDeclIDPair);
Argyrios Kyrtzidis074dcc82010-08-20 16:04:35 +0000945 } else {
946 Info.LexicalDecls = 0;
947 Info.NumLexicalDecls = 0;
948 }
949
950 // Now the lookup table.
951 if (Offsets.second != 0) {
952 Cursor.JumpToBit(Offsets.second);
953
954 RecordData Record;
955 const char *Blob;
956 unsigned BlobLen;
957 unsigned Code = Cursor.ReadCode();
958 unsigned RecCode = Cursor.ReadRecord(Code, Record, &Blob, &BlobLen);
959 if (RecCode != DECL_CONTEXT_VISIBLE) {
960 Error("Expected visible lookup table block");
961 return true;
962 }
963 Info.NameLookupTableData
964 = ASTDeclContextNameLookupTable::Create(
965 (const unsigned char *)Blob + Record[0],
966 (const unsigned char *)Blob,
Douglas Gregor393f2492011-07-22 00:38:23 +0000967 ASTDeclContextNameLookupTrait(*this, *Info.F));
Sebastian Redl0ea8f7f2010-08-24 00:50:00 +0000968 } else {
969 Info.NameLookupTableData = 0;
Argyrios Kyrtzidis074dcc82010-08-20 16:04:35 +0000970 }
971
972 return false;
973}
974
Chris Lattner5f9e2722011-07-23 10:55:15 +0000975void ASTReader::Error(StringRef Msg) {
Argyrios Kyrtzidis8d8f2c22011-04-25 22:23:56 +0000976 Error(diag::err_fe_pch_malformed, Msg);
977}
978
979void ASTReader::Error(unsigned DiagID,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000980 StringRef Arg1, StringRef Arg2) {
Argyrios Kyrtzidis8d8f2c22011-04-25 22:23:56 +0000981 if (Diags.isDiagnosticInFlight())
982 Diags.SetDelayedDiagnostic(DiagID, Arg1, Arg2);
983 else
984 Diag(DiagID) << Arg1 << Arg2;
Douglas Gregor2cf26342009-04-09 22:27:44 +0000985}
986
Sebastian Redl3c7f4132010-08-18 23:57:06 +0000987/// \brief Tell the AST listener about the predefines buffers in the chain.
Sebastian Redlc43b54c2010-08-18 23:56:43 +0000988bool ASTReader::CheckPredefinesBuffers() {
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +0000989 if (Listener)
Sebastian Redl7e9ad8b2010-07-14 17:49:11 +0000990 return Listener->ReadPredefinesBuffer(PCHPredefinesBuffers,
Daniel Dunbar7b5a1212009-11-11 05:29:04 +0000991 ActualOriginalFileName,
Nick Lewycky277a6e72011-02-23 21:16:44 +0000992 SuggestedPredefines,
993 FileMgr);
Douglas Gregore721f952009-04-28 18:58:38 +0000994 return false;
Douglas Gregore1d918e2009-04-10 23:10:45 +0000995}
996
Douglas Gregor4fed3f42009-04-27 18:38:38 +0000997//===----------------------------------------------------------------------===//
998// Source Manager Deserialization
999//===----------------------------------------------------------------------===//
1000
Douglas Gregorbd945002009-04-13 16:31:14 +00001001/// \brief Read the line table in the source manager block.
Sebastian Redlc3632732010-10-05 15:59:54 +00001002/// \returns true if there was an error.
Douglas Gregor72a9ae12011-07-22 16:00:58 +00001003bool ASTReader::ParseLineTable(Module &F,
Chris Lattner5f9e2722011-07-23 10:55:15 +00001004 SmallVectorImpl<uint64_t> &Record) {
Douglas Gregorbd945002009-04-13 16:31:14 +00001005 unsigned Idx = 0;
1006 LineTableInfo &LineTable = SourceMgr.getLineTable();
1007
1008 // Parse the file names
Douglas Gregorff0a9872009-04-13 17:12:42 +00001009 std::map<int, int> FileIDs;
1010 for (int I = 0, N = Record[Idx++]; I != N; ++I) {
Douglas Gregorbd945002009-04-13 16:31:14 +00001011 // Extract the file name
1012 unsigned FilenameLen = Record[Idx++];
1013 std::string Filename(&Record[Idx], &Record[Idx] + FilenameLen);
1014 Idx += FilenameLen;
Douglas Gregore650c8c2009-07-07 00:12:59 +00001015 MaybeAddSystemRootToFilename(Filename);
Jay Foad65aa6882011-06-21 15:13:30 +00001016 FileIDs[I] = LineTable.getLineTableFilenameID(Filename);
Douglas Gregorbd945002009-04-13 16:31:14 +00001017 }
1018
1019 // Parse the line entries
1020 std::vector<LineEntry> Entries;
1021 while (Idx < Record.size()) {
Argyrios Kyrtzidisf52a5d22010-07-02 11:55:05 +00001022 int FID = Record[Idx++];
Douglas Gregorf62d43d2011-07-19 16:10:42 +00001023 assert(FID >= 0 && "Serialized line entries for non-local file.");
1024 // Remap FileID from 1-based old view.
1025 FID += F.SLocEntryBaseID - 1;
Douglas Gregorbd945002009-04-13 16:31:14 +00001026
1027 // Extract the line entries
1028 unsigned NumEntries = Record[Idx++];
Argyrios Kyrtzidisf52a5d22010-07-02 11:55:05 +00001029 assert(NumEntries && "Numentries is 00000");
Douglas Gregorbd945002009-04-13 16:31:14 +00001030 Entries.clear();
1031 Entries.reserve(NumEntries);
1032 for (unsigned I = 0; I != NumEntries; ++I) {
1033 unsigned FileOffset = Record[Idx++];
1034 unsigned LineNo = Record[Idx++];
Argyrios Kyrtzidisf52a5d22010-07-02 11:55:05 +00001035 int FilenameID = FileIDs[Record[Idx++]];
Mike Stump1eb44332009-09-09 15:08:12 +00001036 SrcMgr::CharacteristicKind FileKind
Douglas Gregorbd945002009-04-13 16:31:14 +00001037 = (SrcMgr::CharacteristicKind)Record[Idx++];
1038 unsigned IncludeOffset = Record[Idx++];
1039 Entries.push_back(LineEntry::get(FileOffset, LineNo, FilenameID,
1040 FileKind, IncludeOffset));
1041 }
1042 LineTable.AddEntry(FID, Entries);
1043 }
1044
1045 return false;
1046}
1047
Douglas Gregor4fed3f42009-04-27 18:38:38 +00001048namespace {
1049
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001050class ASTStatData {
Douglas Gregor4fed3f42009-04-27 18:38:38 +00001051public:
Douglas Gregor4fed3f42009-04-27 18:38:38 +00001052 const ino_t ino;
1053 const dev_t dev;
1054 const mode_t mode;
1055 const time_t mtime;
1056 const off_t size;
Mike Stump1eb44332009-09-09 15:08:12 +00001057
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001058 ASTStatData(ino_t i, dev_t d, mode_t mo, time_t m, off_t s)
Chris Lattner74e976b2010-11-23 19:28:12 +00001059 : ino(i), dev(d), mode(mo), mtime(m), size(s) {}
Douglas Gregor4fed3f42009-04-27 18:38:38 +00001060};
1061
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001062class ASTStatLookupTrait {
Douglas Gregor4fed3f42009-04-27 18:38:38 +00001063 public:
1064 typedef const char *external_key_type;
1065 typedef const char *internal_key_type;
1066
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001067 typedef ASTStatData data_type;
Douglas Gregor4fed3f42009-04-27 18:38:38 +00001068
1069 static unsigned ComputeHash(const char *path) {
Daniel Dunbar2596e422009-10-17 23:52:28 +00001070 return llvm::HashString(path);
Douglas Gregor4fed3f42009-04-27 18:38:38 +00001071 }
1072
1073 static internal_key_type GetInternalKey(const char *path) { return path; }
1074
1075 static bool EqualKey(internal_key_type a, internal_key_type b) {
1076 return strcmp(a, b) == 0;
1077 }
1078
1079 static std::pair<unsigned, unsigned>
1080 ReadKeyDataLength(const unsigned char*& d) {
1081 unsigned KeyLen = (unsigned) clang::io::ReadUnalignedLE16(d);
1082 unsigned DataLen = (unsigned) *d++;
1083 return std::make_pair(KeyLen + 1, DataLen);
1084 }
1085
1086 static internal_key_type ReadKey(const unsigned char *d, unsigned) {
1087 return (const char *)d;
1088 }
1089
1090 static data_type ReadData(const internal_key_type, const unsigned char *d,
1091 unsigned /*DataLen*/) {
1092 using namespace clang::io;
1093
Douglas Gregor4fed3f42009-04-27 18:38:38 +00001094 ino_t ino = (ino_t) ReadUnalignedLE32(d);
1095 dev_t dev = (dev_t) ReadUnalignedLE32(d);
1096 mode_t mode = (mode_t) ReadUnalignedLE16(d);
Mike Stump1eb44332009-09-09 15:08:12 +00001097 time_t mtime = (time_t) ReadUnalignedLE64(d);
Douglas Gregor4fed3f42009-04-27 18:38:38 +00001098 off_t size = (off_t) ReadUnalignedLE64(d);
1099 return data_type(ino, dev, mode, mtime, size);
1100 }
1101};
1102
1103/// \brief stat() cache for precompiled headers.
1104///
1105/// This cache is very similar to the stat cache used by pretokenized
1106/// headers.
Chris Lattner10e286a2010-11-23 19:19:34 +00001107class ASTStatCache : public FileSystemStatCache {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001108 typedef OnDiskChainedHashTable<ASTStatLookupTrait> CacheTy;
Douglas Gregor4fed3f42009-04-27 18:38:38 +00001109 CacheTy *Cache;
1110
1111 unsigned &NumStatHits, &NumStatMisses;
Mike Stump1eb44332009-09-09 15:08:12 +00001112public:
Chris Lattner74e976b2010-11-23 19:28:12 +00001113 ASTStatCache(const unsigned char *Buckets, const unsigned char *Base,
1114 unsigned &NumStatHits, unsigned &NumStatMisses)
Douglas Gregor4fed3f42009-04-27 18:38:38 +00001115 : Cache(0), NumStatHits(NumStatHits), NumStatMisses(NumStatMisses) {
1116 Cache = CacheTy::Create(Buckets, Base);
1117 }
1118
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001119 ~ASTStatCache() { delete Cache; }
Mike Stump1eb44332009-09-09 15:08:12 +00001120
Chris Lattner898a0612010-11-23 21:17:56 +00001121 LookupResult getStat(const char *Path, struct stat &StatBuf,
1122 int *FileDescriptor) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001123 // Do the lookup for the file's data in the AST file.
Chris Lattner10e286a2010-11-23 19:19:34 +00001124 CacheTy::iterator I = Cache->find(Path);
Douglas Gregor4fed3f42009-04-27 18:38:38 +00001125
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001126 // If we don't get a hit in the AST file just forward to 'stat'.
Douglas Gregor4fed3f42009-04-27 18:38:38 +00001127 if (I == Cache->end()) {
1128 ++NumStatMisses;
Chris Lattner898a0612010-11-23 21:17:56 +00001129 return statChained(Path, StatBuf, FileDescriptor);
Douglas Gregor4fed3f42009-04-27 18:38:38 +00001130 }
Mike Stump1eb44332009-09-09 15:08:12 +00001131
Douglas Gregor4fed3f42009-04-27 18:38:38 +00001132 ++NumStatHits;
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001133 ASTStatData Data = *I;
Mike Stump1eb44332009-09-09 15:08:12 +00001134
Chris Lattner10e286a2010-11-23 19:19:34 +00001135 StatBuf.st_ino = Data.ino;
1136 StatBuf.st_dev = Data.dev;
1137 StatBuf.st_mtime = Data.mtime;
1138 StatBuf.st_mode = Data.mode;
1139 StatBuf.st_size = Data.size;
Chris Lattnerd6f61112010-11-23 20:05:15 +00001140 return CacheExists;
Douglas Gregor4fed3f42009-04-27 18:38:38 +00001141 }
1142};
1143} // end anonymous namespace
1144
1145
Sebastian Redl93fb9ed2010-07-19 20:52:06 +00001146/// \brief Read a source manager block
Douglas Gregor72a9ae12011-07-22 16:00:58 +00001147ASTReader::ASTReadResult ASTReader::ReadSourceManagerBlock(Module &F) {
Douglas Gregor14f79002009-04-10 03:52:48 +00001148 using namespace SrcMgr;
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001149
Sebastian Redl93fb9ed2010-07-19 20:52:06 +00001150 llvm::BitstreamCursor &SLocEntryCursor = F.SLocEntryCursor;
Sebastian Redl9137a522010-07-16 17:50:48 +00001151
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001152 // Set the source-location entry cursor to the current position in
1153 // the stream. This cursor will be used to read the contents of the
1154 // source manager block initially, and then lazily read
1155 // source-location entries as needed.
Sebastian Redl93fb9ed2010-07-19 20:52:06 +00001156 SLocEntryCursor = F.Stream;
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001157
1158 // The stream itself is going to skip over the source manager block.
Sebastian Redl93fb9ed2010-07-19 20:52:06 +00001159 if (F.Stream.SkipBlock()) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001160 Error("malformed block record in AST file");
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001161 return Failure;
1162 }
1163
1164 // Enter the source manager block.
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001165 if (SLocEntryCursor.EnterSubBlock(SOURCE_MANAGER_BLOCK_ID)) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001166 Error("malformed source manager block record in AST file");
Douglas Gregore1d918e2009-04-10 23:10:45 +00001167 return Failure;
1168 }
Douglas Gregor14f79002009-04-10 03:52:48 +00001169
Douglas Gregor14f79002009-04-10 03:52:48 +00001170 RecordData Record;
1171 while (true) {
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001172 unsigned Code = SLocEntryCursor.ReadCode();
Douglas Gregor14f79002009-04-10 03:52:48 +00001173 if (Code == llvm::bitc::END_BLOCK) {
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001174 if (SLocEntryCursor.ReadBlockEnd()) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001175 Error("error at end of Source Manager block in AST file");
Douglas Gregore1d918e2009-04-10 23:10:45 +00001176 return Failure;
1177 }
Douglas Gregore1d918e2009-04-10 23:10:45 +00001178 return Success;
Douglas Gregor14f79002009-04-10 03:52:48 +00001179 }
Mike Stump1eb44332009-09-09 15:08:12 +00001180
Douglas Gregor14f79002009-04-10 03:52:48 +00001181 if (Code == llvm::bitc::ENTER_SUBBLOCK) {
1182 // No known subblocks, always skip them.
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001183 SLocEntryCursor.ReadSubBlockID();
1184 if (SLocEntryCursor.SkipBlock()) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001185 Error("malformed block record in AST file");
Douglas Gregore1d918e2009-04-10 23:10:45 +00001186 return Failure;
1187 }
Douglas Gregor14f79002009-04-10 03:52:48 +00001188 continue;
1189 }
Mike Stump1eb44332009-09-09 15:08:12 +00001190
Douglas Gregor14f79002009-04-10 03:52:48 +00001191 if (Code == llvm::bitc::DEFINE_ABBREV) {
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001192 SLocEntryCursor.ReadAbbrevRecord();
Douglas Gregor14f79002009-04-10 03:52:48 +00001193 continue;
1194 }
Mike Stump1eb44332009-09-09 15:08:12 +00001195
Douglas Gregor14f79002009-04-10 03:52:48 +00001196 // Read a record.
1197 const char *BlobStart;
1198 unsigned BlobLen;
1199 Record.clear();
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001200 switch (SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) {
Douglas Gregor14f79002009-04-10 03:52:48 +00001201 default: // Default behavior: ignore.
1202 break;
1203
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001204 case SM_SLOC_FILE_ENTRY:
1205 case SM_SLOC_BUFFER_ENTRY:
Chandler Carruthf70d12d2011-07-15 07:25:21 +00001206 case SM_SLOC_EXPANSION_ENTRY:
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001207 // Once we hit one of the source location entries, we're done.
1208 return Success;
Douglas Gregor14f79002009-04-10 03:52:48 +00001209 }
1210 }
1211}
1212
Argyrios Kyrtzidis8e3df4d2011-02-15 17:54:22 +00001213/// \brief If a header file is not found at the path that we expect it to be
1214/// and the PCH file was moved from its original location, try to resolve the
1215/// file by assuming that header+PCH were moved together and the header is in
1216/// the same place relative to the PCH.
1217static std::string
1218resolveFileRelativeToOriginalDir(const std::string &Filename,
1219 const std::string &OriginalDir,
1220 const std::string &CurrDir) {
1221 assert(OriginalDir != CurrDir &&
1222 "No point trying to resolve the file if the PCH dir didn't change");
1223 using namespace llvm::sys;
1224 llvm::SmallString<128> filePath(Filename);
1225 fs::make_absolute(filePath);
1226 assert(path::is_absolute(OriginalDir));
1227 llvm::SmallString<128> currPCHPath(CurrDir);
1228
1229 path::const_iterator fileDirI = path::begin(path::parent_path(filePath)),
1230 fileDirE = path::end(path::parent_path(filePath));
1231 path::const_iterator origDirI = path::begin(OriginalDir),
1232 origDirE = path::end(OriginalDir);
1233 // Skip the common path components from filePath and OriginalDir.
1234 while (fileDirI != fileDirE && origDirI != origDirE &&
1235 *fileDirI == *origDirI) {
1236 ++fileDirI;
1237 ++origDirI;
1238 }
1239 for (; origDirI != origDirE; ++origDirI)
1240 path::append(currPCHPath, "..");
1241 path::append(currPCHPath, fileDirI, fileDirE);
1242 path::append(currPCHPath, path::filename(Filename));
1243 return currPCHPath.str();
1244}
1245
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001246/// \brief Read in the source location entry with the given ID.
Douglas Gregorf62d43d2011-07-19 16:10:42 +00001247ASTReader::ASTReadResult ASTReader::ReadSLocEntryRecord(int ID) {
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001248 if (ID == 0)
1249 return Success;
1250
Douglas Gregor0cdd7982011-07-21 18:46:38 +00001251 if (unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {
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
Douglas Gregor72a9ae12011-07-22 16:00:58 +00001256 Module *F = GlobalSLocEntryMap.find(-ID)->second;
Douglas Gregorf62d43d2011-07-19 16:10:42 +00001257 F->SLocEntryCursor.JumpToBit(F->SLocEntryOffsets[ID - F->SLocEntryBaseID]);
Sebastian Redlc3632732010-10-05 15:59:54 +00001258 llvm::BitstreamCursor &SLocEntryCursor = F->SLocEntryCursor;
Douglas Gregorf62d43d2011-07-19 16:10:42 +00001259 unsigned BaseOffset = F->SLocEntryBaseOffset;
Sebastian Redl9137a522010-07-16 17:50:48 +00001260
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001261 ++NumSLocEntriesRead;
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001262 unsigned Code = SLocEntryCursor.ReadCode();
1263 if (Code == llvm::bitc::END_BLOCK ||
1264 Code == llvm::bitc::ENTER_SUBBLOCK ||
1265 Code == llvm::bitc::DEFINE_ABBREV) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001266 Error("incorrectly-formatted source location entry in AST file");
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001267 return Failure;
1268 }
1269
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001270 RecordData Record;
1271 const char *BlobStart;
1272 unsigned BlobLen;
1273 switch (SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) {
1274 default:
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001275 Error("incorrectly-formatted source location entry in AST file");
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001276 return Failure;
1277
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001278 case SM_SLOC_FILE_ENTRY: {
Douglas Gregore650c8c2009-07-07 00:12:59 +00001279 std::string Filename(BlobStart, BlobStart + BlobLen);
1280 MaybeAddSystemRootToFilename(Filename);
Chris Lattner39b49bc2010-11-23 08:35:12 +00001281 const FileEntry *File = FileMgr.getFile(Filename);
Argyrios Kyrtzidis8e3df4d2011-02-15 17:54:22 +00001282 if (File == 0 && !OriginalDir.empty() && !CurrentDir.empty() &&
1283 OriginalDir != CurrentDir) {
1284 std::string resolved = resolveFileRelativeToOriginalDir(Filename,
1285 OriginalDir,
1286 CurrentDir);
1287 if (!resolved.empty())
1288 File = FileMgr.getFile(resolved);
1289 }
Axel Naumann04331162011-01-27 10:55:51 +00001290 if (File == 0)
1291 File = FileMgr.getVirtualFile(Filename, (off_t)Record[4],
1292 (time_t)Record[5]);
Chris Lattnerd3555ae2009-06-15 04:35:16 +00001293 if (File == 0) {
1294 std::string ErrorStr = "could not find file '";
Douglas Gregore650c8c2009-07-07 00:12:59 +00001295 ErrorStr += Filename;
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001296 ErrorStr += "' referenced by AST file";
Chris Lattnerd3555ae2009-06-15 04:35:16 +00001297 Error(ErrorStr.c_str());
1298 return Failure;
1299 }
Mike Stump1eb44332009-09-09 15:08:12 +00001300
Douglas Gregorcfbf1c72011-02-10 17:09:37 +00001301 if (Record.size() < 6) {
Ted Kremenek1857f622010-03-18 21:23:05 +00001302 Error("source location entry is incorrect");
1303 return Failure;
1304 }
1305
Douglas Gregorfae3b2f2010-07-27 00:27:13 +00001306 if (!DisableValidation &&
1307 ((off_t)Record[4] != File->getSize()
Douglas Gregor9f692a02010-04-09 15:54:22 +00001308#if !defined(LLVM_ON_WIN32)
1309 // In our regression testing, the Windows file system seems to
1310 // have inconsistent modification times that sometimes
1311 // erroneously trigger this error-handling path.
Douglas Gregorfae3b2f2010-07-27 00:27:13 +00001312 || (time_t)Record[5] != File->getModificationTime()
Douglas Gregor9f692a02010-04-09 15:54:22 +00001313#endif
Douglas Gregorfae3b2f2010-07-27 00:27:13 +00001314 )) {
Argyrios Kyrtzidis8d8f2c22011-04-25 22:23:56 +00001315 Error(diag::err_fe_pch_file_modified, Filename);
Douglas Gregor2d52be52010-03-21 22:49:54 +00001316 return Failure;
1317 }
1318
Douglas Gregorf62d43d2011-07-19 16:10:42 +00001319 SourceLocation IncludeLoc = ReadSourceLocation(*F, Record[1]);
Douglas Gregor72a9ae12011-07-22 16:00:58 +00001320 if (IncludeLoc.isInvalid() && F->Kind != MK_MainFile) {
Douglas Gregorf62d43d2011-07-19 16:10:42 +00001321 // This is the module's main file.
1322 IncludeLoc = getImportLocation(F);
1323 }
1324 FileID FID = SourceMgr.createFileID(File, IncludeLoc,
Chris Lattner75dfb652010-11-23 09:19:42 +00001325 (SrcMgr::CharacteristicKind)Record[2],
Douglas Gregorf62d43d2011-07-19 16:10:42 +00001326 ID, BaseOffset + Record[0]);
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001327 if (Record[3])
1328 const_cast<SrcMgr::FileInfo&>(SourceMgr.getSLocEntry(FID).getFile())
1329 .setHasLineDirectives();
Douglas Gregorcfbf1c72011-02-10 17:09:37 +00001330
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001331 break;
1332 }
1333
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001334 case SM_SLOC_BUFFER_ENTRY: {
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001335 const char *Name = BlobStart;
1336 unsigned Offset = Record[0];
1337 unsigned Code = SLocEntryCursor.ReadCode();
1338 Record.clear();
Mike Stump1eb44332009-09-09 15:08:12 +00001339 unsigned RecCode
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001340 = SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen);
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00001341
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001342 if (RecCode != SM_SLOC_BUFFER_BLOB) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001343 Error("AST record has invalid code");
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00001344 return Failure;
1345 }
1346
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001347 llvm::MemoryBuffer *Buffer
Chris Lattner5f9e2722011-07-23 10:55:15 +00001348 = llvm::MemoryBuffer::getMemBuffer(StringRef(BlobStart, BlobLen - 1),
Chris Lattnera0a270c2010-04-05 22:42:27 +00001349 Name);
Douglas Gregorf62d43d2011-07-19 16:10:42 +00001350 FileID BufferID = SourceMgr.createFileIDForMemBuffer(Buffer, ID,
1351 BaseOffset + Offset);
Mike Stump1eb44332009-09-09 15:08:12 +00001352
Douglas Gregor92b059e2009-04-28 20:33:11 +00001353 if (strcmp(Name, "<built-in>") == 0) {
Sebastian Redl7e9ad8b2010-07-14 17:49:11 +00001354 PCHPredefinesBlock Block = {
1355 BufferID,
Chris Lattner5f9e2722011-07-23 10:55:15 +00001356 StringRef(BlobStart, BlobLen - 1)
Sebastian Redl7e9ad8b2010-07-14 17:49:11 +00001357 };
1358 PCHPredefinesBuffers.push_back(Block);
Douglas Gregor92b059e2009-04-28 20:33:11 +00001359 }
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001360
1361 break;
1362 }
1363
Chandler Carruthf70d12d2011-07-15 07:25:21 +00001364 case SM_SLOC_EXPANSION_ENTRY: {
Sebastian Redlc3632732010-10-05 15:59:54 +00001365 SourceLocation SpellingLoc = ReadSourceLocation(*F, Record[1]);
Chandler Carruthbf340e42011-07-26 03:03:05 +00001366 SourceMgr.createExpansionLoc(SpellingLoc,
Sebastian Redlc3632732010-10-05 15:59:54 +00001367 ReadSourceLocation(*F, Record[2]),
1368 ReadSourceLocation(*F, Record[3]),
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001369 Record[4],
1370 ID,
Douglas Gregorf62d43d2011-07-19 16:10:42 +00001371 BaseOffset + Record[0]);
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001372 break;
Mike Stump1eb44332009-09-09 15:08:12 +00001373 }
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00001374 }
1375
1376 return Success;
1377}
1378
Douglas Gregorf62d43d2011-07-19 16:10:42 +00001379/// \brief Find the location where the module F is imported.
Douglas Gregor72a9ae12011-07-22 16:00:58 +00001380SourceLocation ASTReader::getImportLocation(Module *F) {
Douglas Gregorf62d43d2011-07-19 16:10:42 +00001381 if (F->ImportLoc.isValid())
1382 return F->ImportLoc;
1383 // Otherwise we have a PCH. It's considered to be "imported" at the first
1384 // location of its includer.
1385 if (F->Loaders.empty() || !F->Loaders[0]) {
1386 // Main file is the importer. We assume that it is the first entry in the
1387 // entry table. We can't ask the manager, because at the time of PCH loading
1388 // the main file entry doesn't exist yet.
1389 // The very first entry is the invalid instantiation loc, which takes up
1390 // offsets 0 and 1.
1391 return SourceLocation::getFromRawEncoding(2U);
1392 }
1393 return F->Loaders[0]->FirstLoc;
1394}
1395
Chris Lattner6367f6d2009-04-27 01:05:14 +00001396/// ReadBlockAbbrevs - Enter a subblock of the specified BlockID with the
1397/// specified cursor. Read the abbreviations that are at the top of the block
1398/// and then leave the cursor pointing into the block.
Sebastian Redlc43b54c2010-08-18 23:56:43 +00001399bool ASTReader::ReadBlockAbbrevs(llvm::BitstreamCursor &Cursor,
Chris Lattner6367f6d2009-04-27 01:05:14 +00001400 unsigned BlockID) {
1401 if (Cursor.EnterSubBlock(BlockID)) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001402 Error("malformed block record in AST file");
Chris Lattner6367f6d2009-04-27 01:05:14 +00001403 return Failure;
1404 }
Mike Stump1eb44332009-09-09 15:08:12 +00001405
Chris Lattner6367f6d2009-04-27 01:05:14 +00001406 while (true) {
Douglas Gregorecdcb882010-10-20 22:00:55 +00001407 uint64_t Offset = Cursor.GetCurrentBitNo();
Chris Lattner6367f6d2009-04-27 01:05:14 +00001408 unsigned Code = Cursor.ReadCode();
Michael J. Spencer20249a12010-10-21 03:16:25 +00001409
Chris Lattner6367f6d2009-04-27 01:05:14 +00001410 // We expect all abbrevs to be at the start of the block.
Douglas Gregorecdcb882010-10-20 22:00:55 +00001411 if (Code != llvm::bitc::DEFINE_ABBREV) {
1412 Cursor.JumpToBit(Offset);
Chris Lattner6367f6d2009-04-27 01:05:14 +00001413 return false;
Douglas Gregorecdcb882010-10-20 22:00:55 +00001414 }
Chris Lattner6367f6d2009-04-27 01:05:14 +00001415 Cursor.ReadAbbrevRecord();
1416 }
1417}
1418
Douglas Gregor72a9ae12011-07-22 16:00:58 +00001419PreprocessedEntity *ASTReader::ReadMacroRecord(Module &F, uint64_t Offset) {
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00001420 assert(PP && "Forgot to set Preprocessor ?");
Douglas Gregorecdcb882010-10-20 22:00:55 +00001421 llvm::BitstreamCursor &Stream = F.MacroCursor;
Mike Stump1eb44332009-09-09 15:08:12 +00001422
Douglas Gregor37e26842009-04-21 23:56:24 +00001423 // Keep track of where we are in the stream, then jump back there
1424 // after reading this macro.
1425 SavedStreamPosition SavedPosition(Stream);
1426
1427 Stream.JumpToBit(Offset);
1428 RecordData Record;
Chris Lattner5f9e2722011-07-23 10:55:15 +00001429 SmallVector<IdentifierInfo*, 16> MacroArgs;
Douglas Gregor37e26842009-04-21 23:56:24 +00001430 MacroInfo *Macro = 0;
Mike Stump1eb44332009-09-09 15:08:12 +00001431
Douglas Gregor37e26842009-04-21 23:56:24 +00001432 while (true) {
1433 unsigned Code = Stream.ReadCode();
1434 switch (Code) {
1435 case llvm::bitc::END_BLOCK:
Douglas Gregor89d99802010-11-30 06:16:57 +00001436 return 0;
Douglas Gregor37e26842009-04-21 23:56:24 +00001437
1438 case llvm::bitc::ENTER_SUBBLOCK:
1439 // No known subblocks, always skip them.
1440 Stream.ReadSubBlockID();
1441 if (Stream.SkipBlock()) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001442 Error("malformed block record in AST file");
Douglas Gregor89d99802010-11-30 06:16:57 +00001443 return 0;
Douglas Gregor37e26842009-04-21 23:56:24 +00001444 }
1445 continue;
Mike Stump1eb44332009-09-09 15:08:12 +00001446
Douglas Gregor37e26842009-04-21 23:56:24 +00001447 case llvm::bitc::DEFINE_ABBREV:
1448 Stream.ReadAbbrevRecord();
1449 continue;
1450 default: break;
1451 }
1452
1453 // Read a record.
Douglas Gregorecdcb882010-10-20 22:00:55 +00001454 const char *BlobStart = 0;
1455 unsigned BlobLen = 0;
Douglas Gregor37e26842009-04-21 23:56:24 +00001456 Record.clear();
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001457 PreprocessorRecordTypes RecType =
Michael J. Spencer20249a12010-10-21 03:16:25 +00001458 (PreprocessorRecordTypes)Stream.ReadRecord(Code, Record, BlobStart,
Douglas Gregorecdcb882010-10-20 22:00:55 +00001459 BlobLen);
Douglas Gregor37e26842009-04-21 23:56:24 +00001460 switch (RecType) {
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001461 case PP_MACRO_OBJECT_LIKE:
1462 case PP_MACRO_FUNCTION_LIKE: {
Douglas Gregor37e26842009-04-21 23:56:24 +00001463 // If we already have a macro, that means that we've hit the end
1464 // of the definition of the macro we were looking for. We're
1465 // done.
1466 if (Macro)
Douglas Gregor89d99802010-11-30 06:16:57 +00001467 return 0;
Douglas Gregor37e26842009-04-21 23:56:24 +00001468
Douglas Gregor95eab172011-07-28 20:55:49 +00001469 IdentifierInfo *II = getLocalIdentifier(F, Record[0]);
Douglas Gregor37e26842009-04-21 23:56:24 +00001470 if (II == 0) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001471 Error("macro must have a name in AST file");
Douglas Gregor89d99802010-11-30 06:16:57 +00001472 return 0;
Douglas Gregor37e26842009-04-21 23:56:24 +00001473 }
Sebastian Redlc3632732010-10-05 15:59:54 +00001474 SourceLocation Loc = ReadSourceLocation(F, Record[1]);
Douglas Gregor37e26842009-04-21 23:56:24 +00001475 bool isUsed = Record[2];
Mike Stump1eb44332009-09-09 15:08:12 +00001476
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00001477 MacroInfo *MI = PP->AllocateMacroInfo(Loc);
Douglas Gregor37e26842009-04-21 23:56:24 +00001478 MI->setIsUsed(isUsed);
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001479 MI->setIsFromAST();
Mike Stump1eb44332009-09-09 15:08:12 +00001480
Douglas Gregor6a5a23f2010-03-19 21:51:54 +00001481 unsigned NextIndex = 3;
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001482 if (RecType == PP_MACRO_FUNCTION_LIKE) {
Douglas Gregor37e26842009-04-21 23:56:24 +00001483 // Decode function-like macro info.
1484 bool isC99VarArgs = Record[3];
1485 bool isGNUVarArgs = Record[4];
1486 MacroArgs.clear();
1487 unsigned NumArgs = Record[5];
Douglas Gregor6a5a23f2010-03-19 21:51:54 +00001488 NextIndex = 6 + NumArgs;
Douglas Gregor37e26842009-04-21 23:56:24 +00001489 for (unsigned i = 0; i != NumArgs; ++i)
Douglas Gregor95eab172011-07-28 20:55:49 +00001490 MacroArgs.push_back(getLocalIdentifier(F, Record[6+i]));
Douglas Gregor37e26842009-04-21 23:56:24 +00001491
1492 // Install function-like macro info.
1493 MI->setIsFunctionLike();
1494 if (isC99VarArgs) MI->setIsC99Varargs();
1495 if (isGNUVarArgs) MI->setIsGNUVarargs();
Douglas Gregor75fdb232009-05-22 22:45:36 +00001496 MI->setArgumentList(MacroArgs.data(), MacroArgs.size(),
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00001497 PP->getPreprocessorAllocator());
Douglas Gregor37e26842009-04-21 23:56:24 +00001498 }
1499
1500 // Finally, install the macro.
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00001501 PP->setMacroInfo(II, MI);
Douglas Gregor37e26842009-04-21 23:56:24 +00001502
1503 // Remember that we saw this macro last so that we add the tokens that
1504 // form its body to it.
1505 Macro = MI;
Michael J. Spencer20249a12010-10-21 03:16:25 +00001506
Douglas Gregor6a5a23f2010-03-19 21:51:54 +00001507 if (NextIndex + 1 == Record.size() && PP->getPreprocessingRecord()) {
1508 // We have a macro definition. Load it now.
1509 PP->getPreprocessingRecord()->RegisterMacroDefinition(Macro,
Douglas Gregore144c702011-07-28 22:16:57 +00001510 getLocalMacroDefinition(F, Record[NextIndex]));
Douglas Gregor6a5a23f2010-03-19 21:51:54 +00001511 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00001512
Douglas Gregor37e26842009-04-21 23:56:24 +00001513 ++NumMacrosRead;
1514 break;
1515 }
Mike Stump1eb44332009-09-09 15:08:12 +00001516
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001517 case PP_TOKEN: {
Douglas Gregor37e26842009-04-21 23:56:24 +00001518 // If we see a TOKEN before a PP_MACRO_*, then the file is
1519 // erroneous, just pretend we didn't see this.
1520 if (Macro == 0) break;
Mike Stump1eb44332009-09-09 15:08:12 +00001521
Douglas Gregor37e26842009-04-21 23:56:24 +00001522 Token Tok;
1523 Tok.startToken();
Sebastian Redlc3632732010-10-05 15:59:54 +00001524 Tok.setLocation(ReadSourceLocation(F, Record[0]));
Douglas Gregor37e26842009-04-21 23:56:24 +00001525 Tok.setLength(Record[1]);
Douglas Gregor95eab172011-07-28 20:55:49 +00001526 if (IdentifierInfo *II = getLocalIdentifier(F, Record[2]))
Douglas Gregor37e26842009-04-21 23:56:24 +00001527 Tok.setIdentifierInfo(II);
1528 Tok.setKind((tok::TokenKind)Record[3]);
1529 Tok.setFlag((Token::TokenFlags)Record[4]);
1530 Macro->AddTokenToBody(Tok);
1531 break;
1532 }
Douglas Gregor4800a5c2011-02-08 21:58:10 +00001533 }
Douglas Gregor37e26842009-04-21 23:56:24 +00001534 }
Douglas Gregor89d99802010-11-30 06:16:57 +00001535
1536 return 0;
Douglas Gregor37e26842009-04-21 23:56:24 +00001537}
1538
Douglas Gregor72a9ae12011-07-22 16:00:58 +00001539PreprocessedEntity *ASTReader::LoadPreprocessedEntity(Module &F) {
Douglas Gregor4800a5c2011-02-08 21:58:10 +00001540 assert(PP && "Forgot to set Preprocessor ?");
1541 unsigned Code = F.PreprocessorDetailCursor.ReadCode();
1542 switch (Code) {
1543 case llvm::bitc::END_BLOCK:
1544 return 0;
1545
1546 case llvm::bitc::ENTER_SUBBLOCK:
1547 Error("unexpected subblock record in preprocessor detail block");
1548 return 0;
1549
1550 case llvm::bitc::DEFINE_ABBREV:
1551 Error("unexpected abbrevation record in preprocessor detail block");
1552 return 0;
1553
1554 default:
1555 break;
1556 }
1557
1558 if (!PP->getPreprocessingRecord()) {
1559 Error("no preprocessing record");
1560 return 0;
1561 }
1562
1563 // Read the record.
1564 PreprocessingRecord &PPRec = *PP->getPreprocessingRecord();
1565 const char *BlobStart = 0;
1566 unsigned BlobLen = 0;
1567 RecordData Record;
1568 PreprocessorDetailRecordTypes RecType =
1569 (PreprocessorDetailRecordTypes)F.PreprocessorDetailCursor.ReadRecord(
1570 Code, Record, BlobStart, BlobLen);
1571 switch (RecType) {
Chandler Carruthf70d12d2011-07-15 07:25:21 +00001572 case PPD_MACRO_EXPANSION: {
Douglas Gregor86c67d82011-07-28 22:39:26 +00001573 PreprocessedEntityID GlobalID = getGlobalPreprocessedEntityID(F, Record[0]);
1574 if (PreprocessedEntity *PE = PPRec.getLoadedPreprocessedEntity(GlobalID))
Douglas Gregor4800a5c2011-02-08 21:58:10 +00001575 return PE;
1576
Chandler Carruth9e5bb852011-07-14 08:20:46 +00001577 MacroExpansion *ME =
Douglas Gregor95eab172011-07-28 20:55:49 +00001578 new (PPRec) MacroExpansion(getLocalIdentifier(F, Record[3]),
Douglas Gregor4800a5c2011-02-08 21:58:10 +00001579 SourceRange(ReadSourceLocation(F, Record[1]),
1580 ReadSourceLocation(F, Record[2])),
Douglas Gregore144c702011-07-28 22:16:57 +00001581 getLocalMacroDefinition(F, Record[4]));
Douglas Gregor86c67d82011-07-28 22:39:26 +00001582 PPRec.setLoadedPreallocatedEntity(GlobalID, ME);
Chandler Carruth9e5bb852011-07-14 08:20:46 +00001583 return ME;
Douglas Gregor4800a5c2011-02-08 21:58:10 +00001584 }
1585
1586 case PPD_MACRO_DEFINITION: {
Douglas Gregor86c67d82011-07-28 22:39:26 +00001587 PreprocessedEntityID GlobalID = getGlobalPreprocessedEntityID(F, Record[0]);
1588 if (PreprocessedEntity *PE = PPRec.getLoadedPreprocessedEntity(GlobalID))
Douglas Gregor4800a5c2011-02-08 21:58:10 +00001589 return PE;
Douglas Gregor86c67d82011-07-28 22:39:26 +00001590
1591 unsigned MacroDefID = getGlobalMacroDefinitionID(F, Record[1]);
1592 if (MacroDefID > MacroDefinitionsLoaded.size()) {
Douglas Gregor4800a5c2011-02-08 21:58:10 +00001593 Error("out-of-bounds macro definition record");
1594 return 0;
1595 }
1596
1597 // Decode the identifier info and then check again; if the macro is
1598 // still defined and associated with the identifier,
Douglas Gregor95eab172011-07-28 20:55:49 +00001599 IdentifierInfo *II = getLocalIdentifier(F, Record[4]);
Douglas Gregor86c67d82011-07-28 22:39:26 +00001600 if (!MacroDefinitionsLoaded[MacroDefID - 1]) {
Douglas Gregor4800a5c2011-02-08 21:58:10 +00001601 MacroDefinition *MD
1602 = new (PPRec) MacroDefinition(II,
1603 ReadSourceLocation(F, Record[5]),
1604 SourceRange(
1605 ReadSourceLocation(F, Record[2]),
1606 ReadSourceLocation(F, Record[3])));
1607
Douglas Gregor86c67d82011-07-28 22:39:26 +00001608 PPRec.setLoadedPreallocatedEntity(GlobalID, MD);
1609 MacroDefinitionsLoaded[MacroDefID - 1] = MD;
Douglas Gregor4800a5c2011-02-08 21:58:10 +00001610
1611 if (DeserializationListener)
Douglas Gregor86c67d82011-07-28 22:39:26 +00001612 DeserializationListener->MacroDefinitionRead(MacroDefID, MD);
Douglas Gregor4800a5c2011-02-08 21:58:10 +00001613 }
1614
Douglas Gregor86c67d82011-07-28 22:39:26 +00001615 return MacroDefinitionsLoaded[MacroDefID - 1];
Douglas Gregor4800a5c2011-02-08 21:58:10 +00001616 }
1617
1618 case PPD_INCLUSION_DIRECTIVE: {
Douglas Gregor86c67d82011-07-28 22:39:26 +00001619 PreprocessedEntityID GlobalID = getGlobalPreprocessedEntityID(F, Record[0]);
1620 if (PreprocessedEntity *PE = PPRec.getLoadedPreprocessedEntity(GlobalID))
Douglas Gregor4800a5c2011-02-08 21:58:10 +00001621 return PE;
1622
1623 const char *FullFileNameStart = BlobStart + Record[3];
1624 const FileEntry *File
Chris Lattner5f9e2722011-07-23 10:55:15 +00001625 = PP->getFileManager().getFile(StringRef(FullFileNameStart,
Douglas Gregor86c67d82011-07-28 22:39:26 +00001626 BlobLen - Record[3]));
Douglas Gregor4800a5c2011-02-08 21:58:10 +00001627
1628 // FIXME: Stable encoding
1629 InclusionDirective::InclusionKind Kind
1630 = static_cast<InclusionDirective::InclusionKind>(Record[5]);
1631 InclusionDirective *ID
1632 = new (PPRec) InclusionDirective(PPRec, Kind,
Chris Lattner5f9e2722011-07-23 10:55:15 +00001633 StringRef(BlobStart, Record[3]),
Douglas Gregor4800a5c2011-02-08 21:58:10 +00001634 Record[4],
1635 File,
1636 SourceRange(ReadSourceLocation(F, Record[1]),
1637 ReadSourceLocation(F, Record[2])));
Douglas Gregor86c67d82011-07-28 22:39:26 +00001638 PPRec.setLoadedPreallocatedEntity(GlobalID, ID);
Douglas Gregor4800a5c2011-02-08 21:58:10 +00001639 return ID;
1640 }
1641 }
1642
1643 Error("invalid offset in preprocessor detail block");
1644 return 0;
1645}
1646
Douglas Gregor86c67d82011-07-28 22:39:26 +00001647PreprocessedEntityID
1648ASTReader::getGlobalPreprocessedEntityID(Module &M, unsigned LocalID) {
1649 // FIXME: Local-to-global mapping
1650 return LocalID;
1651}
1652
Douglas Gregorcfbf1c72011-02-10 17:09:37 +00001653namespace {
1654 /// \brief Trait class used to search the on-disk hash table containing all of
1655 /// the header search information.
1656 ///
1657 /// The on-disk hash table contains a mapping from each header path to
1658 /// information about that header (how many times it has been included, its
1659 /// controlling macro, etc.). Note that we actually hash based on the
1660 /// filename, and support "deep" comparisons of file names based on current
1661 /// inode numbers, so that the search can cope with non-normalized path names
1662 /// and symlinks.
1663 class HeaderFileInfoTrait {
Douglas Gregor95eab172011-07-28 20:55:49 +00001664 ASTReader &Reader;
1665 Module &M;
Douglas Gregorb4dc4852011-07-28 04:50:02 +00001666 HeaderSearch *HS;
1667 const char *FrameworkStrings;
Douglas Gregorcfbf1c72011-02-10 17:09:37 +00001668 const char *SearchPath;
1669 struct stat SearchPathStatBuf;
1670 llvm::Optional<int> SearchPathStatResult;
1671
1672 int StatSimpleCache(const char *Path, struct stat *StatBuf) {
1673 if (Path == SearchPath) {
1674 if (!SearchPathStatResult)
1675 SearchPathStatResult = stat(Path, &SearchPathStatBuf);
1676
1677 *StatBuf = SearchPathStatBuf;
1678 return *SearchPathStatResult;
1679 }
1680
1681 return stat(Path, StatBuf);
1682 }
1683
1684 public:
1685 typedef const char *external_key_type;
1686 typedef const char *internal_key_type;
1687
1688 typedef HeaderFileInfo data_type;
1689
Douglas Gregor95eab172011-07-28 20:55:49 +00001690 HeaderFileInfoTrait(ASTReader &Reader, Module &M, HeaderSearch *HS,
Douglas Gregorb4dc4852011-07-28 04:50:02 +00001691 const char *FrameworkStrings,
1692 const char *SearchPath = 0)
Douglas Gregor95eab172011-07-28 20:55:49 +00001693 : Reader(Reader), M(M), HS(HS), FrameworkStrings(FrameworkStrings),
1694 SearchPath(SearchPath) { }
Douglas Gregorcfbf1c72011-02-10 17:09:37 +00001695
1696 static unsigned ComputeHash(const char *path) {
1697 return llvm::HashString(llvm::sys::path::filename(path));
1698 }
1699
1700 static internal_key_type GetInternalKey(const char *path) { return path; }
1701
1702 bool EqualKey(internal_key_type a, internal_key_type b) {
1703 if (strcmp(a, b) == 0)
1704 return true;
1705
1706 if (llvm::sys::path::filename(a) != llvm::sys::path::filename(b))
1707 return false;
1708
1709 // The file names match, but the path names don't. stat() the files to
1710 // see if they are the same.
1711 struct stat StatBufA, StatBufB;
1712 if (StatSimpleCache(a, &StatBufA) || StatSimpleCache(b, &StatBufB))
1713 return false;
1714
1715 return StatBufA.st_ino == StatBufB.st_ino;
1716 }
1717
1718 static std::pair<unsigned, unsigned>
1719 ReadKeyDataLength(const unsigned char*& d) {
1720 unsigned KeyLen = (unsigned) clang::io::ReadUnalignedLE16(d);
1721 unsigned DataLen = (unsigned) *d++;
1722 return std::make_pair(KeyLen + 1, DataLen);
1723 }
1724
1725 static internal_key_type ReadKey(const unsigned char *d, unsigned) {
1726 return (const char *)d;
1727 }
1728
Douglas Gregorb4dc4852011-07-28 04:50:02 +00001729 data_type ReadData(const internal_key_type, const unsigned char *d,
1730 unsigned DataLen) {
Douglas Gregorcfbf1c72011-02-10 17:09:37 +00001731 const unsigned char *End = d + DataLen;
1732 using namespace clang::io;
1733 HeaderFileInfo HFI;
1734 unsigned Flags = *d++;
Douglas Gregorb4dc4852011-07-28 04:50:02 +00001735 HFI.isImport = (Flags >> 5) & 0x01;
1736 HFI.isPragmaOnce = (Flags >> 4) & 0x01;
1737 HFI.DirInfo = (Flags >> 2) & 0x03;
1738 HFI.Resolved = (Flags >> 1) & 0x01;
1739 HFI.IndexHeaderMapHeader = Flags & 0x01;
Douglas Gregorcfbf1c72011-02-10 17:09:37 +00001740 HFI.NumIncludes = ReadUnalignedLE16(d);
Douglas Gregor95eab172011-07-28 20:55:49 +00001741 HFI.ControllingMacroID = Reader.getGlobalDeclID(M, ReadUnalignedLE32(d));
Douglas Gregorb4dc4852011-07-28 04:50:02 +00001742 if (unsigned FrameworkOffset = ReadUnalignedLE32(d)) {
1743 // The framework offset is 1 greater than the actual offset,
1744 // since 0 is used as an indicator for "no framework name".
1745 StringRef FrameworkName(FrameworkStrings + FrameworkOffset - 1);
1746 HFI.Framework = HS->getUniqueFrameworkName(FrameworkName);
1747 }
1748
Douglas Gregorcfbf1c72011-02-10 17:09:37 +00001749 assert(End == d && "Wrong data length in HeaderFileInfo deserialization");
1750 (void)End;
Douglas Gregorb4dc4852011-07-28 04:50:02 +00001751
Douglas Gregorcfbf1c72011-02-10 17:09:37 +00001752 // This HeaderFileInfo was externally loaded.
1753 HFI.External = true;
1754 return HFI;
1755 }
1756 };
1757}
1758
1759/// \brief The on-disk hash table used for the global method pool.
1760typedef OnDiskChainedHashTable<HeaderFileInfoTrait>
1761 HeaderFileInfoLookupTable;
1762
Douglas Gregor72a9ae12011-07-22 16:00:58 +00001763void ASTReader::SetIdentifierIsMacro(IdentifierInfo *II, Module &F,
Douglas Gregor2d2689a2011-07-28 21:16:51 +00001764 uint64_t LocalOffset) {
Douglas Gregor295a2a62010-10-30 00:23:06 +00001765 // Note that this identifier has a macro definition.
1766 II->setHasMacroDefinition(true);
1767
Douglas Gregor8f1231b2011-07-22 06:10:01 +00001768 // Adjust the offset to a global offset.
Douglas Gregor2d2689a2011-07-28 21:16:51 +00001769 UnreadMacroRecordOffsets[II] = F.GlobalBitOffset + LocalOffset;
Douglas Gregor295a2a62010-10-30 00:23:06 +00001770}
1771
Sebastian Redlc43b54c2010-08-18 23:56:43 +00001772void ASTReader::ReadDefinedMacros() {
Jonathan D. Turner5d6d89f2011-07-25 20:32:21 +00001773 for (ModuleReverseIterator I = ModuleMgr.rbegin(),
1774 E = ModuleMgr.rend(); I != E; ++I) {
1775 llvm::BitstreamCursor &MacroCursor = (*I)->MacroCursor;
Sebastian Redl9137a522010-07-16 17:50:48 +00001776
Sebastian Redld27d3fc2010-07-21 22:31:37 +00001777 // If there was no preprocessor block, skip this file.
1778 if (!MacroCursor.getBitStreamReader())
1779 continue;
Kovarththanan Rajaratnam6b82f642010-03-07 19:10:13 +00001780
Sebastian Redld27d3fc2010-07-21 22:31:37 +00001781 llvm::BitstreamCursor Cursor = MacroCursor;
Jonathan D. Turner5d6d89f2011-07-25 20:32:21 +00001782 Cursor.JumpToBit((*I)->MacroStartOffset);
Michael J. Spencer20249a12010-10-21 03:16:25 +00001783
Sebastian Redld27d3fc2010-07-21 22:31:37 +00001784 RecordData Record;
1785 while (true) {
1786 unsigned Code = Cursor.ReadCode();
Douglas Gregorecdcb882010-10-20 22:00:55 +00001787 if (Code == llvm::bitc::END_BLOCK)
Sebastian Redld27d3fc2010-07-21 22:31:37 +00001788 break;
Kovarththanan Rajaratnam6b82f642010-03-07 19:10:13 +00001789
Sebastian Redld27d3fc2010-07-21 22:31:37 +00001790 if (Code == llvm::bitc::ENTER_SUBBLOCK) {
1791 // No known subblocks, always skip them.
1792 Cursor.ReadSubBlockID();
1793 if (Cursor.SkipBlock()) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001794 Error("malformed block record in AST file");
Sebastian Redld27d3fc2010-07-21 22:31:37 +00001795 return;
1796 }
1797 continue;
1798 }
Kovarththanan Rajaratnam6b82f642010-03-07 19:10:13 +00001799
Sebastian Redld27d3fc2010-07-21 22:31:37 +00001800 if (Code == llvm::bitc::DEFINE_ABBREV) {
1801 Cursor.ReadAbbrevRecord();
1802 continue;
1803 }
Kovarththanan Rajaratnam6b82f642010-03-07 19:10:13 +00001804
Sebastian Redld27d3fc2010-07-21 22:31:37 +00001805 // Read a record.
1806 const char *BlobStart;
1807 unsigned BlobLen;
1808 Record.clear();
1809 switch (Cursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) {
1810 default: // Default behavior: ignore.
1811 break;
Douglas Gregor88a35862010-01-04 19:18:44 +00001812
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001813 case PP_MACRO_OBJECT_LIKE:
1814 case PP_MACRO_FUNCTION_LIKE:
Douglas Gregor95eab172011-07-28 20:55:49 +00001815 getLocalIdentifier(**I, Record[0]);
Sebastian Redld27d3fc2010-07-21 22:31:37 +00001816 break;
1817
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001818 case PP_TOKEN:
Sebastian Redld27d3fc2010-07-21 22:31:37 +00001819 // Ignore tokens.
1820 break;
Sebastian Redld27d3fc2010-07-21 22:31:37 +00001821 }
Douglas Gregor88a35862010-01-04 19:18:44 +00001822 }
1823 }
Douglas Gregor295a2a62010-10-30 00:23:06 +00001824
1825 // Drain the unread macro-record offsets map.
1826 while (!UnreadMacroRecordOffsets.empty())
1827 LoadMacroDefinition(UnreadMacroRecordOffsets.begin());
1828}
1829
1830void ASTReader::LoadMacroDefinition(
1831 llvm::DenseMap<IdentifierInfo *, uint64_t>::iterator Pos) {
1832 assert(Pos != UnreadMacroRecordOffsets.end() && "Unknown macro definition");
Douglas Gregor295a2a62010-10-30 00:23:06 +00001833 uint64_t Offset = Pos->second;
1834 UnreadMacroRecordOffsets.erase(Pos);
1835
Douglas Gregor8f1231b2011-07-22 06:10:01 +00001836 RecordLocation Loc = getLocalBitOffset(Offset);
1837 ReadMacroRecord(*Loc.F, Loc.Offset);
Douglas Gregor295a2a62010-10-30 00:23:06 +00001838}
1839
1840void ASTReader::LoadMacroDefinition(IdentifierInfo *II) {
1841 llvm::DenseMap<IdentifierInfo *, uint64_t>::iterator Pos
1842 = UnreadMacroRecordOffsets.find(II);
1843 LoadMacroDefinition(Pos);
Douglas Gregor88a35862010-01-04 19:18:44 +00001844}
1845
Sebastian Redlf73c93f2010-09-15 19:54:06 +00001846MacroDefinition *ASTReader::getMacroDefinition(MacroID ID) {
Douglas Gregor77424bc2010-10-02 19:29:26 +00001847 if (ID == 0 || ID > MacroDefinitionsLoaded.size())
Douglas Gregor6a5a23f2010-03-19 21:51:54 +00001848 return 0;
Sebastian Redld27d3fc2010-07-21 22:31:37 +00001849
Douglas Gregor77424bc2010-10-02 19:29:26 +00001850 if (!MacroDefinitionsLoaded[ID - 1]) {
Douglas Gregor14ad03b2011-07-20 01:29:15 +00001851 GlobalMacroDefinitionMapType::iterator I =GlobalMacroDefinitionMap.find(ID);
1852 assert(I != GlobalMacroDefinitionMap.end() &&
1853 "Corrupted global macro definition map");
Douglas Gregor9827a802011-07-29 00:56:45 +00001854 Module &M = *I->second;
1855 unsigned Index = ID - 1 - M.BaseMacroDefinitionID;
1856 SavedStreamPosition SavedPosition(M.PreprocessorDetailCursor);
1857 M.PreprocessorDetailCursor.JumpToBit(M.MacroDefinitionOffsets[Index]);
1858 LoadPreprocessedEntity(M);
Sebastian Redld27d3fc2010-07-21 22:31:37 +00001859 }
1860
Douglas Gregor77424bc2010-10-02 19:29:26 +00001861 return MacroDefinitionsLoaded[ID - 1];
Douglas Gregor6a5a23f2010-03-19 21:51:54 +00001862}
1863
Chris Lattner5f9e2722011-07-23 10:55:15 +00001864const FileEntry *ASTReader::getFileEntry(StringRef filenameStrRef) {
Argyrios Kyrtzidisb68ffb12011-06-01 05:43:53 +00001865 std::string Filename = filenameStrRef;
1866 MaybeAddSystemRootToFilename(Filename);
1867 const FileEntry *File = FileMgr.getFile(Filename);
1868 if (File == 0 && !OriginalDir.empty() && !CurrentDir.empty() &&
1869 OriginalDir != CurrentDir) {
1870 std::string resolved = resolveFileRelativeToOriginalDir(Filename,
1871 OriginalDir,
1872 CurrentDir);
1873 if (!resolved.empty())
1874 File = FileMgr.getFile(resolved);
1875 }
1876
1877 return File;
1878}
1879
Douglas Gregore144c702011-07-28 22:16:57 +00001880MacroID ASTReader::getGlobalMacroDefinitionID(Module &M, unsigned LocalID) {
1881 // FIXME: Local-to-global mapping
1882 return LocalID;
1883}
1884
Douglas Gregore650c8c2009-07-07 00:12:59 +00001885/// \brief If we are loading a relocatable PCH file, and the filename is
1886/// not an absolute path, add the system root to the beginning of the file
1887/// name.
Sebastian Redlc43b54c2010-08-18 23:56:43 +00001888void ASTReader::MaybeAddSystemRootToFilename(std::string &Filename) {
Douglas Gregore650c8c2009-07-07 00:12:59 +00001889 // If this is not a relocatable PCH file, there's nothing to do.
1890 if (!RelocatablePCH)
1891 return;
Mike Stump1eb44332009-09-09 15:08:12 +00001892
Michael J. Spencer256053b2010-12-17 21:22:22 +00001893 if (Filename.empty() || llvm::sys::path::is_absolute(Filename))
Douglas Gregore650c8c2009-07-07 00:12:59 +00001894 return;
1895
Douglas Gregor832d6202011-07-22 16:35:34 +00001896 if (isysroot.empty()) {
Douglas Gregore650c8c2009-07-07 00:12:59 +00001897 // If no system root was given, default to '/'
1898 Filename.insert(Filename.begin(), '/');
1899 return;
1900 }
Mike Stump1eb44332009-09-09 15:08:12 +00001901
Douglas Gregor832d6202011-07-22 16:35:34 +00001902 unsigned Length = isysroot.size();
Douglas Gregore650c8c2009-07-07 00:12:59 +00001903 if (isysroot[Length - 1] != '/')
1904 Filename.insert(Filename.begin(), '/');
Mike Stump1eb44332009-09-09 15:08:12 +00001905
Douglas Gregor832d6202011-07-22 16:35:34 +00001906 Filename.insert(Filename.begin(), isysroot.begin(), isysroot.end());
Douglas Gregore650c8c2009-07-07 00:12:59 +00001907}
1908
Sebastian Redlc43b54c2010-08-18 23:56:43 +00001909ASTReader::ASTReadResult
Douglas Gregor72a9ae12011-07-22 16:00:58 +00001910ASTReader::ReadASTBlock(Module &F) {
Sebastian Redl9137a522010-07-16 17:50:48 +00001911 llvm::BitstreamCursor &Stream = F.Stream;
1912
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001913 if (Stream.EnterSubBlock(AST_BLOCK_ID)) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001914 Error("malformed block record in AST file");
Douglas Gregor0a0428e2009-04-10 20:39:37 +00001915 return Failure;
1916 }
Douglas Gregor2cf26342009-04-09 22:27:44 +00001917
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001918 // Read all of the records and blocks for the ASt file.
Douglas Gregor8038d512009-04-10 17:25:41 +00001919 RecordData Record;
Sebastian Redl93fb9ed2010-07-19 20:52:06 +00001920 bool First = true;
Douglas Gregor2cf26342009-04-09 22:27:44 +00001921 while (!Stream.AtEndOfStream()) {
1922 unsigned Code = Stream.ReadCode();
1923 if (Code == llvm::bitc::END_BLOCK) {
Douglas Gregor0a0428e2009-04-10 20:39:37 +00001924 if (Stream.ReadBlockEnd()) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001925 Error("error at end of module block in AST file");
Douglas Gregor0a0428e2009-04-10 20:39:37 +00001926 return Failure;
1927 }
Chris Lattner7356a312009-04-11 21:15:38 +00001928
Douglas Gregor0a0428e2009-04-10 20:39:37 +00001929 return Success;
Douglas Gregor2cf26342009-04-09 22:27:44 +00001930 }
1931
1932 if (Code == llvm::bitc::ENTER_SUBBLOCK) {
1933 switch (Stream.ReadSubBlockID()) {
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001934 case DECLTYPES_BLOCK_ID:
Chris Lattner6367f6d2009-04-27 01:05:14 +00001935 // We lazily load the decls block, but we want to set up the
1936 // DeclsCursor cursor to point into it. Clone our current bitcode
1937 // cursor to it, enter the block and read the abbrevs in that block.
1938 // With the main cursor, we just skip over it.
Sebastian Redl9137a522010-07-16 17:50:48 +00001939 F.DeclsCursor = Stream;
Chris Lattner6367f6d2009-04-27 01:05:14 +00001940 if (Stream.SkipBlock() || // Skip with the main cursor.
1941 // Read the abbrevs.
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001942 ReadBlockAbbrevs(F.DeclsCursor, DECLTYPES_BLOCK_ID)) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001943 Error("malformed block record in AST file");
Chris Lattner6367f6d2009-04-27 01:05:14 +00001944 return Failure;
1945 }
1946 break;
Mike Stump1eb44332009-09-09 15:08:12 +00001947
Argyrios Kyrtzidis7b903402010-10-24 17:26:36 +00001948 case DECL_UPDATES_BLOCK_ID:
1949 if (Stream.SkipBlock()) {
1950 Error("malformed block record in AST file");
1951 return Failure;
1952 }
1953 break;
1954
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001955 case PREPROCESSOR_BLOCK_ID:
Sebastian Redl9137a522010-07-16 17:50:48 +00001956 F.MacroCursor = Stream;
Douglas Gregor88a35862010-01-04 19:18:44 +00001957 if (PP)
1958 PP->setExternalSource(this);
1959
Douglas Gregorecdcb882010-10-20 22:00:55 +00001960 if (Stream.SkipBlock() ||
1961 ReadBlockAbbrevs(F.MacroCursor, PREPROCESSOR_BLOCK_ID)) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001962 Error("malformed block record in AST file");
Chris Lattner7356a312009-04-11 21:15:38 +00001963 return Failure;
1964 }
Douglas Gregorecdcb882010-10-20 22:00:55 +00001965 F.MacroStartOffset = F.MacroCursor.GetCurrentBitNo();
Chris Lattner7356a312009-04-11 21:15:38 +00001966 break;
Steve Naroff90cd1bb2009-04-23 10:39:46 +00001967
Douglas Gregor4800a5c2011-02-08 21:58:10 +00001968 case PREPROCESSOR_DETAIL_BLOCK_ID:
1969 F.PreprocessorDetailCursor = Stream;
1970 if (Stream.SkipBlock() ||
1971 ReadBlockAbbrevs(F.PreprocessorDetailCursor,
1972 PREPROCESSOR_DETAIL_BLOCK_ID)) {
1973 Error("malformed preprocessor detail record in AST file");
1974 return Failure;
1975 }
1976 F.PreprocessorDetailStartOffset
1977 = F.PreprocessorDetailCursor.GetCurrentBitNo();
1978 break;
1979
Sebastian Redl8538e8d2010-08-18 23:57:32 +00001980 case SOURCE_MANAGER_BLOCK_ID:
Sebastian Redl93fb9ed2010-07-19 20:52:06 +00001981 switch (ReadSourceManagerBlock(F)) {
Douglas Gregore1d918e2009-04-10 23:10:45 +00001982 case Success:
1983 break;
1984
1985 case Failure:
Sebastian Redl3c7f4132010-08-18 23:57:06 +00001986 Error("malformed source manager block in AST file");
Douglas Gregor0a0428e2009-04-10 20:39:37 +00001987 return Failure;
Douglas Gregore1d918e2009-04-10 23:10:45 +00001988
1989 case IgnorePCH:
1990 return IgnorePCH;
Douglas Gregor0a0428e2009-04-10 20:39:37 +00001991 }
Douglas Gregor14f79002009-04-10 03:52:48 +00001992 break;
Douglas Gregor2cf26342009-04-09 22:27:44 +00001993 }
Sebastian Redl93fb9ed2010-07-19 20:52:06 +00001994 First = false;
Douglas Gregor8038d512009-04-10 17:25:41 +00001995 continue;
1996 }
1997
1998 if (Code == llvm::bitc::DEFINE_ABBREV) {
1999 Stream.ReadAbbrevRecord();
2000 continue;
2001 }
2002
2003 // Read and process a record.
2004 Record.clear();
Douglas Gregor2bec0412009-04-10 21:16:55 +00002005 const char *BlobStart = 0;
2006 unsigned BlobLen = 0;
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002007 switch ((ASTRecordTypes)Stream.ReadRecord(Code, Record,
Sebastian Redlc3632732010-10-05 15:59:54 +00002008 &BlobStart, &BlobLen)) {
Douglas Gregor8038d512009-04-10 17:25:41 +00002009 default: // Default behavior: ignore.
2010 break;
2011
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002012 case METADATA: {
2013 if (Record[0] != VERSION_MAJOR && !DisableValidation) {
2014 Diag(Record[0] < VERSION_MAJOR? diag::warn_pch_version_too_old
Sebastian Redlfbd4bf12010-07-17 00:12:06 +00002015 : diag::warn_pch_version_too_new);
2016 return IgnorePCH;
2017 }
2018
2019 RelocatablePCH = Record[4];
2020 if (Listener) {
2021 std::string TargetTriple(BlobStart, BlobLen);
2022 if (Listener->ReadTargetTriple(TargetTriple))
2023 return IgnorePCH;
2024 }
2025 break;
2026 }
2027
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002028 case CHAINED_METADATA: {
Sebastian Redl93fb9ed2010-07-19 20:52:06 +00002029 if (!First) {
2030 Error("CHAINED_METADATA is not first record in block");
2031 return Failure;
2032 }
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002033 if (Record[0] != VERSION_MAJOR && !DisableValidation) {
2034 Diag(Record[0] < VERSION_MAJOR? diag::warn_pch_version_too_old
Sebastian Redlfbd4bf12010-07-17 00:12:06 +00002035 : diag::warn_pch_version_too_new);
2036 return IgnorePCH;
2037 }
2038
Sebastian Redl1d9f1fe2010-10-05 16:15:19 +00002039 // Load the chained file, which is always a PCH file.
Douglas Gregor72a9ae12011-07-22 16:00:58 +00002040 // FIXME: This could end up being a module.
Chris Lattner5f9e2722011-07-23 10:55:15 +00002041 switch(ReadASTCore(StringRef(BlobStart, BlobLen), MK_PCH)) {
Sebastian Redlfbd4bf12010-07-17 00:12:06 +00002042 case Failure: return Failure;
2043 // If we have to ignore the dependency, we'll have to ignore this too.
2044 case IgnorePCH: return IgnorePCH;
2045 case Success: break;
Douglas Gregor8f1231b2011-07-22 06:10:01 +00002046 }
Sebastian Redlfbd4bf12010-07-17 00:12:06 +00002047 break;
2048 }
2049
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002050 case TYPE_OFFSET:
Sebastian Redl12d6da02010-07-19 22:06:55 +00002051 if (F.LocalNumTypes != 0) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002052 Error("duplicate TYPE_OFFSET record in AST file");
Douglas Gregor0a0428e2009-04-10 20:39:37 +00002053 return Failure;
2054 }
Sebastian Redl12d6da02010-07-19 22:06:55 +00002055 F.TypeOffsets = (const uint32_t *)BlobStart;
2056 F.LocalNumTypes = Record[0];
Douglas Gregor1e849b62011-07-29 00:21:44 +00002057 F.BaseTypeID = getTotalNumTypes();
2058
Jonathan D. Turnere9b76c12011-07-20 21:31:32 +00002059 // Introduce the global -> local mapping for types within this
2060 // AST file.
Douglas Gregor1e849b62011-07-29 00:21:44 +00002061 GlobalTypeMap.insert(std::make_pair(getTotalNumTypes() + 1, &F));
Jonathan D. Turnere9b76c12011-07-20 21:31:32 +00002062 TypesLoaded.resize(TypesLoaded.size() + F.LocalNumTypes);
Douglas Gregor8038d512009-04-10 17:25:41 +00002063 break;
2064
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002065 case DECL_OFFSET:
Sebastian Redl12d6da02010-07-19 22:06:55 +00002066 if (F.LocalNumDecls != 0) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002067 Error("duplicate DECL_OFFSET record in AST file");
Douglas Gregor0a0428e2009-04-10 20:39:37 +00002068 return Failure;
2069 }
Sebastian Redl12d6da02010-07-19 22:06:55 +00002070 F.DeclOffsets = (const uint32_t *)BlobStart;
2071 F.LocalNumDecls = Record[0];
Douglas Gregor9827a802011-07-29 00:56:45 +00002072 F.BaseDeclID = getTotalNumDecls();
Douglas Gregor96e973f2011-07-20 00:27:43 +00002073
2074 // Introduce the global -> local mapping for declarations within this
Douglas Gregor67268d02011-07-20 00:59:32 +00002075 // AST file.
Douglas Gregor9827a802011-07-29 00:56:45 +00002076 GlobalDeclMap.insert(std::make_pair(getTotalNumDecls() + 1, &F));
Douglas Gregor67268d02011-07-20 00:59:32 +00002077 DeclsLoaded.resize(DeclsLoaded.size() + F.LocalNumDecls);
Douglas Gregor8038d512009-04-10 17:25:41 +00002078 break;
Douglas Gregor0a0428e2009-04-10 20:39:37 +00002079
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002080 case TU_UPDATE_LEXICAL: {
Sebastian Redld692af72010-07-27 18:24:41 +00002081 DeclContextInfo Info = {
Douglas Gregorf5bb9ae2011-07-21 23:29:11 +00002082 &F,
Argyrios Kyrtzidis074dcc82010-08-20 16:04:35 +00002083 /* No visible information */ 0,
Argyrios Kyrtzidiseb5e9982010-10-14 20:14:34 +00002084 reinterpret_cast<const KindDeclIDPair *>(BlobStart),
Douglas Gregorec12ce22011-07-28 14:20:37 +00002085 static_cast<unsigned int>(BlobLen / sizeof(KindDeclIDPair))
Sebastian Redld692af72010-07-27 18:24:41 +00002086 };
Douglas Gregor3747ee72010-10-01 01:18:02 +00002087 DeclContextOffsets[Context ? Context->getTranslationUnitDecl() : 0]
2088 .push_back(Info);
Sebastian Redld692af72010-07-27 18:24:41 +00002089 break;
2090 }
2091
Sebastian Redle1dde812010-08-24 00:50:04 +00002092 case UPDATE_VISIBLE: {
2093 serialization::DeclID ID = Record[0];
2094 void *Table = ASTDeclContextNameLookupTable::Create(
2095 (const unsigned char *)BlobStart + Record[1],
2096 (const unsigned char *)BlobStart,
Douglas Gregor393f2492011-07-22 00:38:23 +00002097 ASTDeclContextNameLookupTrait(*this, F));
Douglas Gregor3747ee72010-10-01 01:18:02 +00002098 if (ID == 1 && Context) { // Is it the TU?
Sebastian Redle1dde812010-08-24 00:50:04 +00002099 DeclContextInfo Info = {
Douglas Gregorf5bb9ae2011-07-21 23:29:11 +00002100 &F, Table, /* No lexical inforamtion */ 0, 0
Sebastian Redle1dde812010-08-24 00:50:04 +00002101 };
2102 DeclContextOffsets[Context->getTranslationUnitDecl()].push_back(Info);
2103 } else
2104 PendingVisibleUpdates[ID].push_back(Table);
2105 break;
2106 }
2107
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002108 case REDECLS_UPDATE_LATEST: {
Argyrios Kyrtzidisa8650052010-08-03 17:30:10 +00002109 assert(Record.size() % 2 == 0 && "Expected pairs of DeclIDs");
2110 for (unsigned i = 0, e = Record.size(); i < e; i += 2) {
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002111 DeclID First = Record[i], Latest = Record[i+1];
Argyrios Kyrtzidisa8650052010-08-03 17:30:10 +00002112 assert((FirstLatestDeclIDs.find(First) == FirstLatestDeclIDs.end() ||
2113 Latest > FirstLatestDeclIDs[First]) &&
2114 "The new latest is supposed to come after the previous latest");
2115 FirstLatestDeclIDs[First] = Latest;
2116 }
2117 break;
2118 }
2119
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002120 case LANGUAGE_OPTIONS:
Douglas Gregorfae3b2f2010-07-27 00:27:13 +00002121 if (ParseLanguageOptions(Record) && !DisableValidation)
Douglas Gregor0a0428e2009-04-10 20:39:37 +00002122 return IgnorePCH;
2123 break;
Douglas Gregor2bec0412009-04-10 21:16:55 +00002124
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002125 case IDENTIFIER_TABLE:
Sebastian Redl93fb9ed2010-07-19 20:52:06 +00002126 F.IdentifierTableData = BlobStart;
Douglas Gregor2b3a5a82009-04-25 19:10:14 +00002127 if (Record[0]) {
Sebastian Redl93fb9ed2010-07-19 20:52:06 +00002128 F.IdentifierLookupTable
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002129 = ASTIdentifierLookupTable::Create(
Sebastian Redl93fb9ed2010-07-19 20:52:06 +00002130 (const unsigned char *)F.IdentifierTableData + Record[0],
2131 (const unsigned char *)F.IdentifierTableData,
Sebastian Redlc3632732010-10-05 15:59:54 +00002132 ASTIdentifierLookupTrait(*this, F));
Douglas Gregor0cdd7982011-07-21 18:46:38 +00002133 if (PP) {
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00002134 PP->getIdentifierTable().setExternalIdentifierLookup(this);
Douglas Gregor0cdd7982011-07-21 18:46:38 +00002135 PP->getHeaderSearchInfo().SetExternalLookup(this);
2136 }
Douglas Gregor2b3a5a82009-04-25 19:10:14 +00002137 }
Douglas Gregorafaf3082009-04-11 00:14:32 +00002138 break;
2139
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002140 case IDENTIFIER_OFFSET:
Sebastian Redl2da08f92010-07-19 22:28:42 +00002141 if (F.LocalNumIdentifiers != 0) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002142 Error("duplicate IDENTIFIER_OFFSET record in AST file");
Douglas Gregorafaf3082009-04-11 00:14:32 +00002143 return Failure;
2144 }
Sebastian Redl2da08f92010-07-19 22:28:42 +00002145 F.IdentifierOffsets = (const uint32_t *)BlobStart;
2146 F.LocalNumIdentifiers = Record[0];
Douglas Gregor9827a802011-07-29 00:56:45 +00002147 F.BaseIdentifierID = getTotalNumIdentifiers();
Douglas Gregor67268d02011-07-20 00:59:32 +00002148
2149 // Introduce the global -> local mapping for identifiers within this AST
2150 // file
Douglas Gregor9827a802011-07-29 00:56:45 +00002151 GlobalIdentifierMap.insert(std::make_pair(getTotalNumIdentifiers() + 1,
2152 &F));
Douglas Gregor67268d02011-07-20 00:59:32 +00002153 IdentifiersLoaded.resize(IdentifiersLoaded.size() +F.LocalNumIdentifiers);
Douglas Gregorafaf3082009-04-11 00:14:32 +00002154 break;
Douglas Gregorfdd01722009-04-14 00:24:19 +00002155
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002156 case EXTERNAL_DEFINITIONS:
Douglas Gregor409448c2011-07-21 22:35:25 +00002157 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2158 ExternalDefinitions.push_back(getGlobalDeclID(F, Record[I]));
Douglas Gregorfdd01722009-04-14 00:24:19 +00002159 break;
Douglas Gregor3e1af842009-04-17 22:13:46 +00002160
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002161 case SPECIAL_TYPES:
Douglas Gregor393f2492011-07-22 00:38:23 +00002162 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2163 SpecialTypes.push_back(getGlobalTypeID(F, Record[I]));
Douglas Gregorad1de002009-04-18 05:55:16 +00002164 break;
2165
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002166 case STATISTICS:
Sebastian Redl518d8cb2010-07-20 21:20:32 +00002167 TotalNumStatements += Record[0];
2168 TotalNumMacros += Record[1];
2169 TotalLexicalDeclContexts += Record[2];
2170 TotalVisibleDeclContexts += Record[3];
Douglas Gregor3e1af842009-04-17 22:13:46 +00002171 break;
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00002172
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002173 case UNUSED_FILESCOPED_DECLS:
Douglas Gregor409448c2011-07-21 22:35:25 +00002174 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2175 UnusedFileScopedDecls.push_back(getGlobalDeclID(F, Record[I]));
Tanya Lattnere6bbc012010-02-12 00:07:30 +00002176 break;
Kovarththanan Rajaratnam6b82f642010-03-07 19:10:13 +00002177
Sean Huntebcbe1d2011-05-04 23:29:54 +00002178 case DELEGATING_CTORS:
Douglas Gregor409448c2011-07-21 22:35:25 +00002179 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2180 DelegatingCtorDecls.push_back(getGlobalDeclID(F, Record[I]));
Sean Huntebcbe1d2011-05-04 23:29:54 +00002181 break;
2182
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002183 case WEAK_UNDECLARED_IDENTIFIERS:
Douglas Gregor31e37b22011-07-28 18:09:57 +00002184 if (Record.size() % 4 != 0) {
2185 Error("invalid weak identifiers record");
2186 return Failure;
2187 }
2188
2189 // FIXME: Ignore weak undeclared identifiers from non-original PCH
2190 // files. This isn't the way to do it :)
2191 WeakUndeclaredIdentifiers.clear();
2192
2193 // Translate the weak, undeclared identifiers into global IDs.
2194 for (unsigned I = 0, N = Record.size(); I < N; /* in loop */) {
2195 WeakUndeclaredIdentifiers.push_back(
2196 getGlobalIdentifierID(F, Record[I++]));
2197 WeakUndeclaredIdentifiers.push_back(
2198 getGlobalIdentifierID(F, Record[I++]));
2199 WeakUndeclaredIdentifiers.push_back(
2200 ReadSourceLocation(F, Record, I).getRawEncoding());
2201 WeakUndeclaredIdentifiers.push_back(Record[I++]);
2202 }
Argyrios Kyrtzidis72b90572010-08-05 09:48:08 +00002203 break;
2204
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002205 case LOCALLY_SCOPED_EXTERNAL_DECLS:
Douglas Gregor409448c2011-07-21 22:35:25 +00002206 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2207 LocallyScopedExternalDecls.push_back(getGlobalDeclID(F, Record[I]));
Douglas Gregor14c22f22009-04-22 22:18:58 +00002208 break;
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +00002209
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002210 case SELECTOR_OFFSETS:
Sebastian Redl059612d2010-08-03 21:58:15 +00002211 F.SelectorOffsets = (const uint32_t *)BlobStart;
Sebastian Redl725cd962010-08-04 20:40:17 +00002212 F.LocalNumSelectors = Record[0];
Douglas Gregor9827a802011-07-29 00:56:45 +00002213 F.BaseSelectorID = getTotalNumSelectors();
Douglas Gregor96958cb2011-07-20 01:10:58 +00002214
2215 // Introduce the global -> local mapping for identifiers within this AST
2216 // file
Douglas Gregor9827a802011-07-29 00:56:45 +00002217 GlobalSelectorMap.insert(std::make_pair(getTotalNumSelectors() + 1, &F));
Douglas Gregor96958cb2011-07-20 01:10:58 +00002218 SelectorsLoaded.resize(SelectorsLoaded.size() + F.LocalNumSelectors);
Douglas Gregor83941df2009-04-25 17:48:32 +00002219 break;
2220
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002221 case METHOD_POOL:
Sebastian Redl725cd962010-08-04 20:40:17 +00002222 F.SelectorLookupTableData = (const unsigned char *)BlobStart;
Douglas Gregor83941df2009-04-25 17:48:32 +00002223 if (Record[0])
Sebastian Redl725cd962010-08-04 20:40:17 +00002224 F.SelectorLookupTable
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002225 = ASTSelectorLookupTable::Create(
Sebastian Redl725cd962010-08-04 20:40:17 +00002226 F.SelectorLookupTableData + Record[0],
2227 F.SelectorLookupTableData,
Douglas Gregor409448c2011-07-21 22:35:25 +00002228 ASTSelectorLookupTrait(*this, F));
Sebastian Redlfa78dec2010-08-04 21:22:45 +00002229 TotalNumMethodPoolEntries += Record[1];
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +00002230 break;
Douglas Gregor2eafc1b2009-04-26 00:07:37 +00002231
Sebastian Redl4ee5a6f2010-09-22 00:42:30 +00002232 case REFERENCED_SELECTOR_POOL:
Douglas Gregor8451ec72011-07-28 14:41:43 +00002233 if (!Record.empty()) {
2234 for (unsigned Idx = 0, N = Record.size() - 1; Idx < N; /* in loop */) {
2235 ReferencedSelectorsData.push_back(getGlobalSelectorID(F,
2236 Record[Idx++]));
2237 ReferencedSelectorsData.push_back(ReadSourceLocation(F, Record, Idx).
2238 getRawEncoding());
2239 }
2240 }
Fariborz Jahanian32019832010-07-23 19:11:11 +00002241 break;
2242
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002243 case PP_COUNTER_VALUE:
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00002244 if (!Record.empty() && Listener)
2245 Listener->ReadCounter(Record[0]);
Douglas Gregor2eafc1b2009-04-26 00:07:37 +00002246 break;
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00002247
Douglas Gregorf62d43d2011-07-19 16:10:42 +00002248 case SOURCE_LOCATION_OFFSETS: {
2249 F.SLocEntryOffsets = (const uint32_t *)BlobStart;
Sebastian Redl518d8cb2010-07-20 21:20:32 +00002250 F.LocalNumSLocEntries = Record[0];
Douglas Gregorf62d43d2011-07-19 16:10:42 +00002251 llvm::tie(F.SLocEntryBaseID, F.SLocEntryBaseOffset) =
2252 SourceMgr.AllocateLoadedSLocEntries(F.LocalNumSLocEntries, Record[1]);
2253 // Make our entry in the range map. BaseID is negative and growing, so
2254 // we invert it. Because we invert it, though, we need the other end of
2255 // the range.
2256 unsigned RangeStart =
2257 unsigned(-F.SLocEntryBaseID) - F.LocalNumSLocEntries + 1;
2258 GlobalSLocEntryMap.insert(std::make_pair(RangeStart, &F));
2259 F.FirstLoc = SourceLocation::getFromRawEncoding(F.SLocEntryBaseOffset);
2260
2261 // Initialize the remapping table.
2262 // Invalid stays invalid.
2263 F.SLocRemap.insert(std::make_pair(0U, 0));
2264 // This module. Base was 2 when being compiled.
2265 F.SLocRemap.insert(std::make_pair(2U,
2266 static_cast<int>(F.SLocEntryBaseOffset - 2)));
Douglas Gregor0cdd7982011-07-21 18:46:38 +00002267
2268 TotalNumSLocEntries += F.LocalNumSLocEntries;
Douglas Gregorf62d43d2011-07-19 16:10:42 +00002269 break;
2270 }
2271
2272 case SOURCE_LOCATION_MAP: {
2273 // Additional remapping information.
2274 const unsigned char *Data = (const unsigned char*)BlobStart;
2275 const unsigned char *DataEnd = Data + BlobLen;
2276 while(Data < DataEnd) {
2277 uint32_t Offset = io::ReadUnalignedLE32(Data);
2278 uint16_t Len = io::ReadUnalignedLE16(Data);
Chris Lattner5f9e2722011-07-23 10:55:15 +00002279 StringRef Name = StringRef((const char*)Data, Len);
Jonathan D. Turner48d2c3f2011-07-26 18:21:30 +00002280 Module *OM = ModuleMgr.lookup(Name);
Douglas Gregorf62d43d2011-07-19 16:10:42 +00002281 if (!OM) {
2282 Error("SourceLocation remap refers to unknown module");
2283 return Failure;
2284 }
2285 // My Offset is mapped to OM->SLocEntryBaseOffset.
2286 F.SLocRemap.insert(std::make_pair(Offset,
2287 static_cast<int>(OM->SLocEntryBaseOffset - Offset)));
2288 Data += Len;
2289 }
2290 break;
2291 }
2292
Douglas Gregorf62d43d2011-07-19 16:10:42 +00002293 case SOURCE_MANAGER_LINE_TABLE:
2294 if (ParseLineTable(F, Record))
2295 return Failure;
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00002296 break;
2297
Argyrios Kyrtzidis4cdb0e22011-06-02 20:01:46 +00002298 case FILE_SOURCE_LOCATION_OFFSETS:
2299 F.SLocFileOffsets = (const uint32_t *)BlobStart;
2300 F.LocalNumSLocFileEntries = Record[0];
2301 break;
2302
Douglas Gregorf62d43d2011-07-19 16:10:42 +00002303 case SOURCE_LOCATION_PRELOADS: {
2304 // Need to transform from the local view (1-based IDs) to the global view,
2305 // which is based off F.SLocEntryBaseID.
2306 PreloadSLocEntries.reserve(PreloadSLocEntries.size() + Record.size());
2307 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2308 PreloadSLocEntries.push_back(int(Record[I] - 1) + F.SLocEntryBaseID);
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00002309 break;
Douglas Gregorf62d43d2011-07-19 16:10:42 +00002310 }
Douglas Gregor4fed3f42009-04-27 18:38:38 +00002311
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002312 case STAT_CACHE: {
Douglas Gregor8ef6c8c2011-02-05 19:42:43 +00002313 if (!DisableStatCache) {
2314 ASTStatCache *MyStatCache =
2315 new ASTStatCache((const unsigned char *)BlobStart + Record[0],
2316 (const unsigned char *)BlobStart,
2317 NumStatHits, NumStatMisses);
2318 FileMgr.addStatCache(MyStatCache);
2319 F.StatCache = MyStatCache;
2320 }
Douglas Gregor4fed3f42009-04-27 18:38:38 +00002321 break;
Douglas Gregor52e71082009-10-16 18:18:30 +00002322 }
Kovarththanan Rajaratnam6b82f642010-03-07 19:10:13 +00002323
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002324 case EXT_VECTOR_DECLS:
Douglas Gregor409448c2011-07-21 22:35:25 +00002325 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2326 ExtVectorDecls.push_back(getGlobalDeclID(F, Record[I]));
Douglas Gregorb81c1702009-04-27 20:06:05 +00002327 break;
2328
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002329 case VTABLE_USES:
Douglas Gregordfe65432011-07-28 19:11:31 +00002330 if (Record.size() % 3 != 0) {
2331 Error("Invalid VTABLE_USES record");
2332 return Failure;
2333 }
2334
Sebastian Redl40566802010-08-05 18:21:25 +00002335 // Later tables overwrite earlier ones.
Douglas Gregordfe65432011-07-28 19:11:31 +00002336 // FIXME: Modules will have some trouble with this. This is clearly not
2337 // the right way to do this.
Douglas Gregor409448c2011-07-21 22:35:25 +00002338 VTableUses.clear();
Douglas Gregordfe65432011-07-28 19:11:31 +00002339
2340 for (unsigned Idx = 0, N = Record.size(); Idx != N; /* In loop */) {
2341 VTableUses.push_back(getGlobalDeclID(F, Record[Idx++]));
2342 VTableUses.push_back(
2343 ReadSourceLocation(F, Record, Idx).getRawEncoding());
2344 VTableUses.push_back(Record[Idx++]);
2345 }
Argyrios Kyrtzidisd455add2010-07-06 15:37:04 +00002346 break;
2347
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002348 case DYNAMIC_CLASSES:
Douglas Gregor409448c2011-07-21 22:35:25 +00002349 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2350 DynamicClasses.push_back(getGlobalDeclID(F, Record[I]));
Argyrios Kyrtzidisd455add2010-07-06 15:37:04 +00002351 break;
2352
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002353 case PENDING_IMPLICIT_INSTANTIATIONS:
Douglas Gregorf2abb522011-07-28 19:26:52 +00002354 if (PendingInstantiations.size() % 2 != 0) {
2355 Error("Invalid PENDING_IMPLICIT_INSTANTIATIONS block");
2356 return Failure;
2357 }
2358
2359 // Later lists of pending instantiations overwrite earlier ones.
2360 // FIXME: This is most certainly wrong for modules.
2361 PendingInstantiations.clear();
2362 for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) {
2363 PendingInstantiations.push_back(getGlobalDeclID(F, Record[I++]));
2364 PendingInstantiations.push_back(
2365 ReadSourceLocation(F, Record, I).getRawEncoding());
2366 }
Argyrios Kyrtzidis0e036382010-08-05 09:48:16 +00002367 break;
2368
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002369 case SEMA_DECL_REFS:
Sebastian Redl40566802010-08-05 18:21:25 +00002370 // Later tables overwrite earlier ones.
Douglas Gregor409448c2011-07-21 22:35:25 +00002371 // FIXME: Modules will have some trouble with this.
2372 SemaDeclRefs.clear();
2373 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2374 SemaDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
Argyrios Kyrtzidis76c38d32010-08-02 07:14:54 +00002375 break;
2376
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002377 case ORIGINAL_FILE_NAME:
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002378 // The primary AST will be the last to get here, so it will be the one
Sebastian Redl518d8cb2010-07-20 21:20:32 +00002379 // that's used.
Daniel Dunbar7b5a1212009-11-11 05:29:04 +00002380 ActualOriginalFileName.assign(BlobStart, BlobLen);
2381 OriginalFileName = ActualOriginalFileName;
Douglas Gregore650c8c2009-07-07 00:12:59 +00002382 MaybeAddSystemRootToFilename(OriginalFileName);
Douglas Gregorb64c1932009-05-12 01:31:05 +00002383 break;
Mike Stump1eb44332009-09-09 15:08:12 +00002384
Douglas Gregor31d375f2011-05-06 21:43:30 +00002385 case ORIGINAL_FILE_ID:
2386 OriginalFileID = FileID::get(Record[0]);
2387 break;
2388
Argyrios Kyrtzidis8e3df4d2011-02-15 17:54:22 +00002389 case ORIGINAL_PCH_DIR:
2390 // The primary AST will be the last to get here, so it will be the one
2391 // that's used.
2392 OriginalDir.assign(BlobStart, BlobLen);
2393 break;
2394
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002395 case VERSION_CONTROL_BRANCH_REVISION: {
Ted Kremenek974be4d2010-02-12 23:31:14 +00002396 const std::string &CurBranch = getClangFullRepositoryVersion();
Chris Lattner5f9e2722011-07-23 10:55:15 +00002397 StringRef ASTBranch(BlobStart, BlobLen);
2398 if (StringRef(CurBranch) != ASTBranch && !DisableValidation) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002399 Diag(diag::warn_pch_different_branch) << ASTBranch << CurBranch;
Douglas Gregor445e23e2009-10-05 21:07:28 +00002400 return IgnorePCH;
2401 }
2402 break;
2403 }
Sebastian Redl04e6fd42010-07-21 20:07:32 +00002404
Douglas Gregor4c30bb12011-07-21 00:47:40 +00002405 case MACRO_DEFINITION_OFFSETS: {
Sebastian Redl04e6fd42010-07-21 20:07:32 +00002406 F.MacroDefinitionOffsets = (const uint32_t *)BlobStart;
2407 F.NumPreallocatedPreprocessingEntities = Record[0];
2408 F.LocalNumMacroDefinitions = Record[1];
Douglas Gregor4c30bb12011-07-21 00:47:40 +00002409
2410 // Introduce the global -> local mapping for preprocessed entities within
2411 // this AST file.
2412 unsigned StartingID;
2413 if (PP) {
2414 if (!PP->getPreprocessingRecord())
2415 PP->createPreprocessingRecord(true);
2416 if (!PP->getPreprocessingRecord()->getExternalSource())
2417 PP->getPreprocessingRecord()->SetExternalSource(*this);
2418 StartingID
2419 = PP->getPreprocessingRecord()
2420 ->allocateLoadedEntities(F.NumPreallocatedPreprocessingEntities);
2421 } else {
2422 // FIXME: We'll eventually want to kill this path, since it assumes
2423 // a particular allocation strategy in the preprocessing record.
2424 StartingID = getTotalNumPreprocessedEntities();
2425 }
2426
Douglas Gregor9827a802011-07-29 00:56:45 +00002427 F.BaseMacroDefinitionID = getTotalNumMacroDefinitions();
2428 F.BasePreprocessedEntityID = StartingID;
Douglas Gregor4c30bb12011-07-21 00:47:40 +00002429
2430 // Introduce the global -> local mapping for macro definitions within
2431 // this AST file.
Douglas Gregor9827a802011-07-29 00:56:45 +00002432 GlobalPreprocessedEntityMap.insert(std::make_pair(StartingID, &F));
Douglas Gregor14ad03b2011-07-20 01:29:15 +00002433 GlobalMacroDefinitionMap.insert(
Douglas Gregor9827a802011-07-29 00:56:45 +00002434 std::make_pair(getTotalNumMacroDefinitions() + 1, &F));
Douglas Gregor14ad03b2011-07-20 01:29:15 +00002435 MacroDefinitionsLoaded.resize(
2436 MacroDefinitionsLoaded.size() + F.LocalNumMacroDefinitions);
Douglas Gregor6a5a23f2010-03-19 21:51:54 +00002437 break;
Douglas Gregor4c30bb12011-07-21 00:47:40 +00002438 }
2439
Argyrios Kyrtzidis7b903402010-10-24 17:26:36 +00002440 case DECL_UPDATE_OFFSETS: {
2441 if (Record.size() % 2 != 0) {
2442 Error("invalid DECL_UPDATE_OFFSETS block in AST file");
2443 return Failure;
2444 }
2445 for (unsigned I = 0, N = Record.size(); I != N; I += 2)
2446 DeclUpdateOffsets[static_cast<DeclID>(Record[I])]
2447 .push_back(std::make_pair(&F, Record[I+1]));
2448 break;
2449 }
2450
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002451 case DECL_REPLACEMENTS: {
Sebastian Redl0b17c612010-08-13 00:28:03 +00002452 if (Record.size() % 2 != 0) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002453 Error("invalid DECL_REPLACEMENTS block in AST file");
Sebastian Redl0b17c612010-08-13 00:28:03 +00002454 return Failure;
2455 }
2456 for (unsigned I = 0, N = Record.size(); I != N; I += 2)
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002457 ReplacedDecls[static_cast<DeclID>(Record[I])] =
Sebastian Redl0b17c612010-08-13 00:28:03 +00002458 std::make_pair(&F, Record[I+1]);
2459 break;
2460 }
Douglas Gregor7c789c12010-10-29 22:39:52 +00002461
2462 case CXX_BASE_SPECIFIER_OFFSETS: {
2463 if (F.LocalNumCXXBaseSpecifiers != 0) {
2464 Error("duplicate CXX_BASE_SPECIFIER_OFFSETS record in AST file");
2465 return Failure;
2466 }
2467
2468 F.LocalNumCXXBaseSpecifiers = Record[0];
2469 F.CXXBaseSpecifiersOffsets = (const uint32_t *)BlobStart;
Douglas Gregor9827a802011-07-29 00:56:45 +00002470 F.BaseCXXBaseSpecifiersID = getTotalNumCXXBaseSpecifiers();
2471 GlobalCXXBaseSpecifiersMap.insert(
2472 std::make_pair(getTotalNumCXXBaseSpecifiers() + 1, &F));
Jonathan D. Turner1da90142011-07-21 21:15:19 +00002473
2474 NumCXXBaseSpecifiersLoaded += F.LocalNumCXXBaseSpecifiers;
Douglas Gregor7c789c12010-10-29 22:39:52 +00002475 break;
2476 }
Argyrios Kyrtzidisf41d3be2010-11-05 22:10:18 +00002477
Argyrios Kyrtzidis3efd52c2011-01-14 20:54:07 +00002478 case DIAG_PRAGMA_MAPPINGS:
Argyrios Kyrtzidisf41d3be2010-11-05 22:10:18 +00002479 if (Record.size() % 2 != 0) {
2480 Error("invalid DIAG_USER_MAPPINGS block in AST file");
2481 return Failure;
2482 }
Douglas Gregorf62d43d2011-07-19 16:10:42 +00002483
2484 if (F.PragmaDiagMappings.empty())
2485 F.PragmaDiagMappings.swap(Record);
Argyrios Kyrtzidisf41d3be2010-11-05 22:10:18 +00002486 else
Douglas Gregorf62d43d2011-07-19 16:10:42 +00002487 F.PragmaDiagMappings.insert(F.PragmaDiagMappings.end(),
2488 Record.begin(), Record.end());
Argyrios Kyrtzidisf41d3be2010-11-05 22:10:18 +00002489 break;
Douglas Gregorcfbf1c72011-02-10 17:09:37 +00002490
Peter Collingbourne14b6ba72011-02-09 21:04:32 +00002491 case CUDA_SPECIAL_DECL_REFS:
2492 // Later tables overwrite earlier ones.
Douglas Gregor409448c2011-07-21 22:35:25 +00002493 // FIXME: Modules will have trouble with this.
2494 CUDASpecialDeclRefs.clear();
2495 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2496 CUDASpecialDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
Peter Collingbourne14b6ba72011-02-09 21:04:32 +00002497 break;
Douglas Gregorcfbf1c72011-02-10 17:09:37 +00002498
Douglas Gregorb4dc4852011-07-28 04:50:02 +00002499 case HEADER_SEARCH_TABLE: {
Douglas Gregorcfbf1c72011-02-10 17:09:37 +00002500 F.HeaderFileInfoTableData = BlobStart;
2501 F.LocalNumHeaderFileInfos = Record[1];
Douglas Gregorb4dc4852011-07-28 04:50:02 +00002502 F.HeaderFileFrameworkStrings = BlobStart + Record[2];
Douglas Gregorcfbf1c72011-02-10 17:09:37 +00002503 if (Record[0]) {
2504 F.HeaderFileInfoTable
2505 = HeaderFileInfoLookupTable::Create(
2506 (const unsigned char *)F.HeaderFileInfoTableData + Record[0],
Douglas Gregorb4dc4852011-07-28 04:50:02 +00002507 (const unsigned char *)F.HeaderFileInfoTableData,
Douglas Gregor95eab172011-07-28 20:55:49 +00002508 HeaderFileInfoTrait(*this, F,
2509 PP? &PP->getHeaderSearchInfo() : 0,
Douglas Gregorb4dc4852011-07-28 04:50:02 +00002510 BlobStart + Record[2]));
Douglas Gregorcfbf1c72011-02-10 17:09:37 +00002511 if (PP)
2512 PP->getHeaderSearchInfo().SetExternalSource(this);
2513 }
2514 break;
Douglas Gregorb4dc4852011-07-28 04:50:02 +00002515 }
2516
Peter Collingbourne84bccea2011-02-15 19:46:30 +00002517 case FP_PRAGMA_OPTIONS:
2518 // Later tables overwrite earlier ones.
2519 FPPragmaOptions.swap(Record);
2520 break;
2521
2522 case OPENCL_EXTENSIONS:
2523 // Later tables overwrite earlier ones.
2524 OpenCLExtensions.swap(Record);
2525 break;
Sean Huntebcbe1d2011-05-04 23:29:54 +00002526
2527 case TENTATIVE_DEFINITIONS:
Douglas Gregor409448c2011-07-21 22:35:25 +00002528 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2529 TentativeDefinitions.push_back(getGlobalDeclID(F, Record[I]));
Sean Huntebcbe1d2011-05-04 23:29:54 +00002530 break;
Douglas Gregord8bba9c2011-06-28 16:20:02 +00002531
2532 case KNOWN_NAMESPACES:
Douglas Gregor409448c2011-07-21 22:35:25 +00002533 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2534 KnownNamespaces.push_back(getGlobalDeclID(F, Record[I]));
Douglas Gregord8bba9c2011-06-28 16:20:02 +00002535 break;
Douglas Gregorafaf3082009-04-11 00:14:32 +00002536 }
Sebastian Redl93fb9ed2010-07-19 20:52:06 +00002537 First = false;
Douglas Gregor2cf26342009-04-09 22:27:44 +00002538 }
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002539 Error("premature end of bitstream in AST file");
Douglas Gregor0a0428e2009-04-10 20:39:37 +00002540 return Failure;
Douglas Gregor2cf26342009-04-09 22:27:44 +00002541}
2542
Argyrios Kyrtzidisb68ffb12011-06-01 05:43:53 +00002543ASTReader::ASTReadResult ASTReader::validateFileEntries() {
Jonathan D. Turner5d6d89f2011-07-25 20:32:21 +00002544 for (ModuleIterator I = ModuleMgr.begin(),
2545 E = ModuleMgr.end(); I != E; ++I) {
2546 Module *F = *I;
Argyrios Kyrtzidisb68ffb12011-06-01 05:43:53 +00002547 llvm::BitstreamCursor &SLocEntryCursor = F->SLocEntryCursor;
2548
Argyrios Kyrtzidis4cdb0e22011-06-02 20:01:46 +00002549 for (unsigned i = 0, e = F->LocalNumSLocFileEntries; i != e; ++i) {
2550 SLocEntryCursor.JumpToBit(F->SLocFileOffsets[i]);
Argyrios Kyrtzidisb68ffb12011-06-01 05:43:53 +00002551 unsigned Code = SLocEntryCursor.ReadCode();
2552 if (Code == llvm::bitc::END_BLOCK ||
2553 Code == llvm::bitc::ENTER_SUBBLOCK ||
2554 Code == llvm::bitc::DEFINE_ABBREV) {
2555 Error("incorrectly-formatted source location entry in AST file");
2556 return Failure;
2557 }
2558
2559 RecordData Record;
2560 const char *BlobStart;
2561 unsigned BlobLen;
2562 switch (SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) {
2563 default:
2564 Error("incorrectly-formatted source location entry in AST file");
2565 return Failure;
2566
2567 case SM_SLOC_FILE_ENTRY: {
Chris Lattner5f9e2722011-07-23 10:55:15 +00002568 StringRef Filename(BlobStart, BlobLen);
Argyrios Kyrtzidisb68ffb12011-06-01 05:43:53 +00002569 const FileEntry *File = getFileEntry(Filename);
2570
2571 if (File == 0) {
2572 std::string ErrorStr = "could not find file '";
2573 ErrorStr += Filename;
2574 ErrorStr += "' referenced by AST file";
2575 Error(ErrorStr.c_str());
2576 return IgnorePCH;
2577 }
2578
2579 if (Record.size() < 6) {
2580 Error("source location entry is incorrect");
2581 return Failure;
2582 }
2583
2584 // The stat info from the FileEntry came from the cached stat
2585 // info of the PCH, so we cannot trust it.
2586 struct stat StatBuf;
2587 if (::stat(File->getName(), &StatBuf) != 0) {
2588 StatBuf.st_size = File->getSize();
2589 StatBuf.st_mtime = File->getModificationTime();
2590 }
2591
2592 if (((off_t)Record[4] != StatBuf.st_size
2593#if !defined(LLVM_ON_WIN32)
2594 // In our regression testing, the Windows file system seems to
2595 // have inconsistent modification times that sometimes
2596 // erroneously trigger this error-handling path.
2597 || (time_t)Record[5] != StatBuf.st_mtime
2598#endif
2599 )) {
2600 Error(diag::err_fe_pch_file_modified, Filename);
2601 return IgnorePCH;
2602 }
2603
2604 break;
2605 }
Argyrios Kyrtzidisb68ffb12011-06-01 05:43:53 +00002606 }
2607 }
2608 }
2609
2610 return Success;
2611}
2612
Sebastian Redl1d9f1fe2010-10-05 16:15:19 +00002613ASTReader::ASTReadResult ASTReader::ReadAST(const std::string &FileName,
Douglas Gregor72a9ae12011-07-22 16:00:58 +00002614 ModuleKind Type) {
Sebastian Redl1d9f1fe2010-10-05 16:15:19 +00002615 switch(ReadASTCore(FileName, Type)) {
Sebastian Redlcdf3b832010-07-16 20:41:52 +00002616 case Failure: return Failure;
2617 case IgnorePCH: return IgnorePCH;
2618 case Success: break;
2619 }
Sebastian Redlfbd4bf12010-07-17 00:12:06 +00002620
2621 // Here comes stuff that we only do once the entire chain is loaded.
2622
Argyrios Kyrtzidisb68ffb12011-06-01 05:43:53 +00002623 if (!DisableValidation) {
2624 switch(validateFileEntries()) {
2625 case Failure: return Failure;
2626 case IgnorePCH: return IgnorePCH;
2627 case Success: break;
2628 }
2629 }
2630
Sebastian Redl4ee5a6f2010-09-22 00:42:30 +00002631 // Preload SLocEntries.
2632 for (unsigned I = 0, N = PreloadSLocEntries.size(); I != N; ++I) {
2633 ASTReadResult Result = ReadSLocEntryRecord(PreloadSLocEntries[I]);
2634 if (Result != Success)
Douglas Gregorf62d43d2011-07-19 16:10:42 +00002635 return Failure;
Sebastian Redl4ee5a6f2010-09-22 00:42:30 +00002636 }
Douglas Gregor0cdd7982011-07-21 18:46:38 +00002637 PreloadSLocEntries.clear();
2638
Sebastian Redlfbd4bf12010-07-17 00:12:06 +00002639 // Check the predefines buffers.
Douglas Gregora7d445a2011-07-27 16:30:06 +00002640 if (!DisableValidation && Type != MK_Module && CheckPredefinesBuffers())
Sebastian Redlfbd4bf12010-07-17 00:12:06 +00002641 return IgnorePCH;
2642
2643 if (PP) {
2644 // Initialization of keywords and pragmas occurs before the
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002645 // AST file is read, so there may be some identifiers that were
Sebastian Redlfbd4bf12010-07-17 00:12:06 +00002646 // loaded into the IdentifierTable before we intercepted the
2647 // creation of identifiers. Iterate through the list of known
2648 // identifiers and determine whether we have to establish
2649 // preprocessor definitions or top-level identifier declaration
2650 // chains for those identifiers.
2651 //
2652 // We copy the IdentifierInfo pointers to a small vector first,
2653 // since de-serializing declarations or macro definitions can add
2654 // new entries into the identifier table, invalidating the
2655 // iterators.
Douglas Gregora7d445a2011-07-27 16:30:06 +00002656 //
2657 // FIXME: We need a lazier way to load this information, e.g., by marking
2658 // the identifier data as 'dirty', so that it will be looked up in the
2659 // AST file(s) if it is uttered in the source. This could save us some
2660 // module load time.
Chris Lattner5f9e2722011-07-23 10:55:15 +00002661 SmallVector<IdentifierInfo *, 128> Identifiers;
Sebastian Redlfbd4bf12010-07-17 00:12:06 +00002662 for (IdentifierTable::iterator Id = PP->getIdentifierTable().begin(),
2663 IdEnd = PP->getIdentifierTable().end();
2664 Id != IdEnd; ++Id)
2665 Identifiers.push_back(Id->second);
Sebastian Redl04e6fd42010-07-21 20:07:32 +00002666 // We need to search the tables in all files.
Jonathan D. Turner5d6d89f2011-07-25 20:32:21 +00002667 for (ModuleIterator J = ModuleMgr.begin(),
2668 M = ModuleMgr.end(); J != M; ++J) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002669 ASTIdentifierLookupTable *IdTable
Jonathan D. Turner5d6d89f2011-07-25 20:32:21 +00002670 = (ASTIdentifierLookupTable *)(*J)->IdentifierLookupTable;
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002671 // Not all AST files necessarily have identifier tables, only the useful
Sebastian Redl0fa7d0b2010-07-22 17:01:13 +00002672 // ones.
2673 if (!IdTable)
2674 continue;
Sebastian Redl04e6fd42010-07-21 20:07:32 +00002675 for (unsigned I = 0, N = Identifiers.size(); I != N; ++I) {
2676 IdentifierInfo *II = Identifiers[I];
2677 // Look in the on-disk hash tables for an entry for this identifier
Jonathan D. Turner5d6d89f2011-07-25 20:32:21 +00002678 ASTIdentifierLookupTrait Info(*this, *(*J), II);
Sebastian Redl04e6fd42010-07-21 20:07:32 +00002679 std::pair<const char*,unsigned> Key(II->getNameStart(),II->getLength());
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002680 ASTIdentifierLookupTable::iterator Pos = IdTable->find(Key, &Info);
Sebastian Redl518d8cb2010-07-20 21:20:32 +00002681 if (Pos == IdTable->end())
2682 continue;
Sebastian Redlfbd4bf12010-07-17 00:12:06 +00002683
Sebastian Redl518d8cb2010-07-20 21:20:32 +00002684 // Dereferencing the iterator has the effect of populating the
2685 // IdentifierInfo node with the various declarations it needs.
2686 (void)*Pos;
2687 }
Sebastian Redlfbd4bf12010-07-17 00:12:06 +00002688 }
2689 }
2690
2691 if (Context)
2692 InitializeContext(*Context);
2693
Argyrios Kyrtzidis7b903402010-10-24 17:26:36 +00002694 if (DeserializationListener)
2695 DeserializationListener->ReaderInitialized(this);
2696
Douglas Gregor414cb642010-11-30 05:23:00 +00002697 // If this AST file is a precompiled preamble, then set the main file ID of
2698 // the source manager to the file source file from which the preamble was
2699 // built. This is the only valid way to use a precompiled preamble.
Douglas Gregor72a9ae12011-07-22 16:00:58 +00002700 if (Type == MK_Preamble) {
Douglas Gregor31d375f2011-05-06 21:43:30 +00002701 if (OriginalFileID.isInvalid()) {
2702 SourceLocation Loc
2703 = SourceMgr.getLocation(FileMgr.getFile(getOriginalSourceFile()), 1, 1);
2704 if (Loc.isValid())
2705 OriginalFileID = SourceMgr.getDecomposedLoc(Loc).first;
Douglas Gregor414cb642010-11-30 05:23:00 +00002706 }
Douglas Gregorf62d43d2011-07-19 16:10:42 +00002707 else {
Jonathan D. Turner5d6d89f2011-07-25 20:32:21 +00002708 OriginalFileID = FileID::get(ModuleMgr.getPrimaryModule().SLocEntryBaseID
Douglas Gregorf62d43d2011-07-19 16:10:42 +00002709 + OriginalFileID.getOpaqueValue() - 1);
2710 }
2711
Douglas Gregor31d375f2011-05-06 21:43:30 +00002712 if (!OriginalFileID.isInvalid())
2713 SourceMgr.SetPreambleFileID(OriginalFileID);
Douglas Gregor414cb642010-11-30 05:23:00 +00002714 }
2715
Sebastian Redlfbd4bf12010-07-17 00:12:06 +00002716 return Success;
2717}
2718
Chris Lattner5f9e2722011-07-23 10:55:15 +00002719ASTReader::ASTReadResult ASTReader::ReadASTCore(StringRef FileName,
Douglas Gregor72a9ae12011-07-22 16:00:58 +00002720 ModuleKind Type) {
Jonathan D. Turner48d2c3f2011-07-26 18:21:30 +00002721 Module &F = ModuleMgr.addModule(FileName, Type);
Sebastian Redlfbd4bf12010-07-17 00:12:06 +00002722
Argyrios Kyrtzidis8e3df4d2011-02-15 17:54:22 +00002723 if (FileName != "-") {
2724 CurrentDir = llvm::sys::path::parent_path(FileName);
2725 if (CurrentDir.empty()) CurrentDir = ".";
2726 }
2727
Argyrios Kyrtzidisb0f4b9a2011-03-09 17:21:42 +00002728 if (!ASTBuffers.empty()) {
Sebastian Redl56558372011-04-14 14:07:41 +00002729 F.Buffer.reset(ASTBuffers.back());
2730 ASTBuffers.pop_back();
Argyrios Kyrtzidisb0f4b9a2011-03-09 17:21:42 +00002731 assert(F.Buffer && "Passed null buffer");
2732 } else {
2733 // Open the AST file.
2734 //
2735 // FIXME: This shouldn't be here, we should just take a raw_ostream.
2736 std::string ErrStr;
2737 llvm::error_code ec;
2738 if (FileName == "-") {
2739 ec = llvm::MemoryBuffer::getSTDIN(F.Buffer);
2740 if (ec)
2741 ErrStr = ec.message();
2742 } else
2743 F.Buffer.reset(FileMgr.getBufferForFile(FileName, &ErrStr));
2744 if (!F.Buffer) {
2745 Error(ErrStr.c_str());
2746 return IgnorePCH;
2747 }
Sebastian Redlfbd4bf12010-07-17 00:12:06 +00002748 }
2749
2750 // Initialize the stream
2751 F.StreamFile.init((const unsigned char *)F.Buffer->getBufferStart(),
2752 (const unsigned char *)F.Buffer->getBufferEnd());
Sebastian Redl9137a522010-07-16 17:50:48 +00002753 llvm::BitstreamCursor &Stream = F.Stream;
Sebastian Redlfbd4bf12010-07-17 00:12:06 +00002754 Stream.init(F.StreamFile);
Sebastian Redl04e6fd42010-07-21 20:07:32 +00002755 F.SizeInBits = F.Buffer->getBufferSize() * 8;
Douglas Gregor8f1231b2011-07-22 06:10:01 +00002756
Sebastian Redlfbd4bf12010-07-17 00:12:06 +00002757 // Sniff for the signature.
2758 if (Stream.Read(8) != 'C' ||
2759 Stream.Read(8) != 'P' ||
2760 Stream.Read(8) != 'C' ||
2761 Stream.Read(8) != 'H') {
2762 Diag(diag::err_not_a_pch_file) << FileName;
2763 return Failure;
2764 }
Douglas Gregor2cf26342009-04-09 22:27:44 +00002765
Douglas Gregor2cf26342009-04-09 22:27:44 +00002766 while (!Stream.AtEndOfStream()) {
2767 unsigned Code = Stream.ReadCode();
Mike Stump1eb44332009-09-09 15:08:12 +00002768
Douglas Gregore1d918e2009-04-10 23:10:45 +00002769 if (Code != llvm::bitc::ENTER_SUBBLOCK) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002770 Error("invalid record at top-level of AST file");
Douglas Gregore1d918e2009-04-10 23:10:45 +00002771 return Failure;
2772 }
Douglas Gregor2cf26342009-04-09 22:27:44 +00002773
2774 unsigned BlockID = Stream.ReadSubBlockID();
Douglas Gregor668c1a42009-04-21 22:25:48 +00002775
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002776 // We only know the AST subblock ID.
Douglas Gregor2cf26342009-04-09 22:27:44 +00002777 switch (BlockID) {
2778 case llvm::bitc::BLOCKINFO_BLOCK_ID:
Douglas Gregore1d918e2009-04-10 23:10:45 +00002779 if (Stream.ReadBlockInfoBlock()) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002780 Error("malformed BlockInfoBlock in AST file");
Douglas Gregore1d918e2009-04-10 23:10:45 +00002781 return Failure;
2782 }
Douglas Gregor2cf26342009-04-09 22:27:44 +00002783 break;
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002784 case AST_BLOCK_ID:
Sebastian Redl571db7f2010-08-18 23:56:56 +00002785 switch (ReadASTBlock(F)) {
Douglas Gregor0a0428e2009-04-10 20:39:37 +00002786 case Success:
2787 break;
2788
2789 case Failure:
Douglas Gregore1d918e2009-04-10 23:10:45 +00002790 return Failure;
Douglas Gregor0a0428e2009-04-10 20:39:37 +00002791
2792 case IgnorePCH:
Douglas Gregor2bec0412009-04-10 21:16:55 +00002793 // FIXME: We could consider reading through to the end of this
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002794 // AST block, skipping subblocks, to see if there are other
2795 // AST blocks elsewhere.
Douglas Gregor2bf1eb02009-04-27 21:28:04 +00002796
Douglas Gregorf62d43d2011-07-19 16:10:42 +00002797 // FIXME: We can't clear loaded slocentries anymore.
2798 //SourceMgr.ClearPreallocatedSLocEntries();
Douglas Gregor2bf1eb02009-04-27 21:28:04 +00002799
2800 // Remove the stat cache.
Sebastian Redl9137a522010-07-16 17:50:48 +00002801 if (F.StatCache)
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002802 FileMgr.removeStatCache((ASTStatCache*)F.StatCache);
Douglas Gregor2bf1eb02009-04-27 21:28:04 +00002803
Douglas Gregore1d918e2009-04-10 23:10:45 +00002804 return IgnorePCH;
Douglas Gregor0a0428e2009-04-10 20:39:37 +00002805 }
Douglas Gregor2cf26342009-04-09 22:27:44 +00002806 break;
2807 default:
Douglas Gregore1d918e2009-04-10 23:10:45 +00002808 if (Stream.SkipBlock()) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002809 Error("malformed block record in AST file");
Douglas Gregore1d918e2009-04-10 23:10:45 +00002810 return Failure;
2811 }
Douglas Gregor2cf26342009-04-09 22:27:44 +00002812 break;
2813 }
Mike Stump1eb44332009-09-09 15:08:12 +00002814 }
Douglas Gregor8f1231b2011-07-22 06:10:01 +00002815
Douglas Gregor72a9ae12011-07-22 16:00:58 +00002816 // Once read, set the Module bit base offset and update the size in
Douglas Gregor8f1231b2011-07-22 06:10:01 +00002817 // bits of all files we've seen.
2818 F.GlobalBitOffset = TotalModulesSizeInBits;
2819 TotalModulesSizeInBits += F.SizeInBits;
2820 GlobalBitOffsetsMap.insert(std::make_pair(F.GlobalBitOffset, &F));
Sebastian Redlcdf3b832010-07-16 20:41:52 +00002821 return Success;
2822}
2823
Sebastian Redlc43b54c2010-08-18 23:56:43 +00002824void ASTReader::setPreprocessor(Preprocessor &pp) {
Douglas Gregor6a5a23f2010-03-19 21:51:54 +00002825 PP = &pp;
Douglas Gregor4c30bb12011-07-21 00:47:40 +00002826
2827 if (unsigned N = getTotalNumPreprocessedEntities()) {
Douglas Gregor6a5a23f2010-03-19 21:51:54 +00002828 if (!PP->getPreprocessingRecord())
Douglas Gregordca8ee82011-05-06 16:33:08 +00002829 PP->createPreprocessingRecord(true);
Douglas Gregor4c30bb12011-07-21 00:47:40 +00002830 PP->getPreprocessingRecord()->SetExternalSource(*this);
2831 PP->getPreprocessingRecord()->allocateLoadedEntities(N);
Douglas Gregor6a5a23f2010-03-19 21:51:54 +00002832 }
Douglas Gregor4c30bb12011-07-21 00:47:40 +00002833
2834 PP->getHeaderSearchInfo().SetExternalLookup(this);
Douglas Gregor0cdd7982011-07-21 18:46:38 +00002835 PP->getHeaderSearchInfo().SetExternalSource(this);
Douglas Gregor6a5a23f2010-03-19 21:51:54 +00002836}
2837
Sebastian Redlc43b54c2010-08-18 23:56:43 +00002838void ASTReader::InitializeContext(ASTContext &Ctx) {
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00002839 Context = &Ctx;
2840 assert(Context && "Passed null context!");
2841
2842 assert(PP && "Forgot to set Preprocessor ?");
2843 PP->getIdentifierTable().setExternalIdentifierLookup(this);
Douglas Gregor88a35862010-01-04 19:18:44 +00002844 PP->setExternalSource(this);
Douglas Gregorcfbf1c72011-02-10 17:09:37 +00002845
Douglas Gregor3747ee72010-10-01 01:18:02 +00002846 // If we have an update block for the TU waiting, we have to add it before
2847 // deserializing the decl.
2848 DeclContextOffsetsMap::iterator DCU = DeclContextOffsets.find(0);
2849 if (DCU != DeclContextOffsets.end()) {
2850 // Insertion could invalidate map, so grab vector.
2851 DeclContextInfos T;
2852 T.swap(DCU->second);
2853 DeclContextOffsets.erase(DCU);
2854 DeclContextOffsets[Ctx.getTranslationUnitDecl()].swap(T);
2855 }
2856
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00002857 // Load the translation unit declaration
Argyrios Kyrtzidis8871a442010-07-08 17:13:02 +00002858 GetTranslationUnitDecl();
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00002859
2860 // Load the special types.
2861 Context->setBuiltinVaListType(
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002862 GetType(SpecialTypes[SPECIAL_TYPE_BUILTIN_VA_LIST]));
2863 if (unsigned Id = SpecialTypes[SPECIAL_TYPE_OBJC_ID])
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00002864 Context->setObjCIdType(GetType(Id));
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002865 if (unsigned Sel = SpecialTypes[SPECIAL_TYPE_OBJC_SELECTOR])
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00002866 Context->setObjCSelType(GetType(Sel));
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002867 if (unsigned Proto = SpecialTypes[SPECIAL_TYPE_OBJC_PROTOCOL])
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00002868 Context->setObjCProtoType(GetType(Proto));
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002869 if (unsigned Class = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS])
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00002870 Context->setObjCClassType(GetType(Class));
Steve Naroff14108da2009-07-10 23:34:53 +00002871
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002872 if (unsigned String = SpecialTypes[SPECIAL_TYPE_CF_CONSTANT_STRING])
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00002873 Context->setCFConstantStringType(GetType(String));
Mike Stump1eb44332009-09-09 15:08:12 +00002874 if (unsigned FastEnum
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002875 = SpecialTypes[SPECIAL_TYPE_OBJC_FAST_ENUMERATION_STATE])
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00002876 Context->setObjCFastEnumerationStateType(GetType(FastEnum));
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002877 if (unsigned File = SpecialTypes[SPECIAL_TYPE_FILE]) {
Douglas Gregorc29f77b2009-07-07 16:35:42 +00002878 QualType FileType = GetType(File);
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00002879 if (FileType.isNull()) {
2880 Error("FILE type is NULL");
2881 return;
2882 }
John McCall183700f2009-09-21 23:43:11 +00002883 if (const TypedefType *Typedef = FileType->getAs<TypedefType>())
Douglas Gregorc29f77b2009-07-07 16:35:42 +00002884 Context->setFILEDecl(Typedef->getDecl());
2885 else {
Ted Kremenek6217b802009-07-29 21:53:49 +00002886 const TagType *Tag = FileType->getAs<TagType>();
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00002887 if (!Tag) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002888 Error("Invalid FILE type in AST file");
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00002889 return;
2890 }
Douglas Gregorc29f77b2009-07-07 16:35:42 +00002891 Context->setFILEDecl(Tag->getDecl());
2892 }
2893 }
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002894 if (unsigned Jmp_buf = SpecialTypes[SPECIAL_TYPE_jmp_buf]) {
Mike Stump782fa302009-07-28 02:25:19 +00002895 QualType Jmp_bufType = GetType(Jmp_buf);
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00002896 if (Jmp_bufType.isNull()) {
2897 Error("jmp_bug type is NULL");
2898 return;
2899 }
John McCall183700f2009-09-21 23:43:11 +00002900 if (const TypedefType *Typedef = Jmp_bufType->getAs<TypedefType>())
Mike Stump782fa302009-07-28 02:25:19 +00002901 Context->setjmp_bufDecl(Typedef->getDecl());
2902 else {
Ted Kremenek6217b802009-07-29 21:53:49 +00002903 const TagType *Tag = Jmp_bufType->getAs<TagType>();
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00002904 if (!Tag) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002905 Error("Invalid jmp_buf type in AST file");
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00002906 return;
2907 }
Mike Stump782fa302009-07-28 02:25:19 +00002908 Context->setjmp_bufDecl(Tag->getDecl());
2909 }
2910 }
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002911 if (unsigned Sigjmp_buf = SpecialTypes[SPECIAL_TYPE_sigjmp_buf]) {
Mike Stump782fa302009-07-28 02:25:19 +00002912 QualType Sigjmp_bufType = GetType(Sigjmp_buf);
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00002913 if (Sigjmp_bufType.isNull()) {
2914 Error("sigjmp_buf type is NULL");
2915 return;
2916 }
John McCall183700f2009-09-21 23:43:11 +00002917 if (const TypedefType *Typedef = Sigjmp_bufType->getAs<TypedefType>())
Mike Stump782fa302009-07-28 02:25:19 +00002918 Context->setsigjmp_bufDecl(Typedef->getDecl());
2919 else {
Ted Kremenek6217b802009-07-29 21:53:49 +00002920 const TagType *Tag = Sigjmp_bufType->getAs<TagType>();
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002921 assert(Tag && "Invalid sigjmp_buf type in AST file");
Mike Stump782fa302009-07-28 02:25:19 +00002922 Context->setsigjmp_bufDecl(Tag->getDecl());
2923 }
2924 }
Mike Stump1eb44332009-09-09 15:08:12 +00002925 if (unsigned ObjCIdRedef
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002926 = SpecialTypes[SPECIAL_TYPE_OBJC_ID_REDEFINITION])
Douglas Gregord1571ac2009-08-21 00:27:50 +00002927 Context->ObjCIdRedefinitionType = GetType(ObjCIdRedef);
Mike Stump1eb44332009-09-09 15:08:12 +00002928 if (unsigned ObjCClassRedef
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002929 = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS_REDEFINITION])
Douglas Gregord1571ac2009-08-21 00:27:50 +00002930 Context->ObjCClassRedefinitionType = GetType(ObjCClassRedef);
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002931 if (unsigned String = SpecialTypes[SPECIAL_TYPE_BLOCK_DESCRIPTOR])
Mike Stumpadaaad32009-10-20 02:12:22 +00002932 Context->setBlockDescriptorType(GetType(String));
Mike Stump083c25e2009-10-22 00:49:09 +00002933 if (unsigned String
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002934 = SpecialTypes[SPECIAL_TYPE_BLOCK_EXTENDED_DESCRIPTOR])
Mike Stump083c25e2009-10-22 00:49:09 +00002935 Context->setBlockDescriptorExtendedType(GetType(String));
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00002936 if (unsigned ObjCSelRedef
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002937 = SpecialTypes[SPECIAL_TYPE_OBJC_SEL_REDEFINITION])
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00002938 Context->ObjCSelRedefinitionType = GetType(ObjCSelRedef);
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002939 if (unsigned String = SpecialTypes[SPECIAL_TYPE_NS_CONSTANT_STRING])
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00002940 Context->setNSConstantStringType(GetType(String));
Argyrios Kyrtzidis00611382010-07-04 21:44:19 +00002941
Sebastian Redl8538e8d2010-08-18 23:57:32 +00002942 if (SpecialTypes[SPECIAL_TYPE_INT128_INSTALLED])
Argyrios Kyrtzidis00611382010-07-04 21:44:19 +00002943 Context->setInt128Installed();
Argyrios Kyrtzidisf41d3be2010-11-05 22:10:18 +00002944
Richard Smithad762fc2011-04-14 22:09:26 +00002945 if (unsigned AutoDeduct = SpecialTypes[SPECIAL_TYPE_AUTO_DEDUCT])
2946 Context->AutoDeductTy = GetType(AutoDeduct);
2947 if (unsigned AutoRRefDeduct = SpecialTypes[SPECIAL_TYPE_AUTO_RREF_DEDUCT])
2948 Context->AutoRRefDeductTy = GetType(AutoRRefDeduct);
2949
Argyrios Kyrtzidis3efd52c2011-01-14 20:54:07 +00002950 ReadPragmaDiagnosticMappings(Context->getDiagnostics());
Peter Collingbourne14b6ba72011-02-09 21:04:32 +00002951
2952 // If there were any CUDA special declarations, deserialize them.
2953 if (!CUDASpecialDeclRefs.empty()) {
2954 assert(CUDASpecialDeclRefs.size() == 1 && "More decl refs than expected!");
2955 Context->setcudaConfigureCallDecl(
2956 cast<FunctionDecl>(GetDecl(CUDASpecialDeclRefs[0])));
2957 }
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00002958}
2959
Douglas Gregorb64c1932009-05-12 01:31:05 +00002960/// \brief Retrieve the name of the original source file name
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002961/// directly from the AST file, without actually loading the AST
Douglas Gregorb64c1932009-05-12 01:31:05 +00002962/// file.
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002963std::string ASTReader::getOriginalSourceFile(const std::string &ASTFileName,
Argyrios Kyrtzidis389db162010-11-03 22:45:23 +00002964 FileManager &FileMgr,
Daniel Dunbar93ebb1b2009-12-03 09:13:06 +00002965 Diagnostic &Diags) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002966 // Open the AST file.
Douglas Gregorb64c1932009-05-12 01:31:05 +00002967 std::string ErrStr;
2968 llvm::OwningPtr<llvm::MemoryBuffer> Buffer;
Chris Lattner39b49bc2010-11-23 08:35:12 +00002969 Buffer.reset(FileMgr.getBufferForFile(ASTFileName, &ErrStr));
Douglas Gregorb64c1932009-05-12 01:31:05 +00002970 if (!Buffer) {
Daniel Dunbar93ebb1b2009-12-03 09:13:06 +00002971 Diags.Report(diag::err_fe_unable_to_read_pch_file) << ErrStr;
Douglas Gregorb64c1932009-05-12 01:31:05 +00002972 return std::string();
2973 }
2974
2975 // Initialize the stream
2976 llvm::BitstreamReader StreamFile;
2977 llvm::BitstreamCursor Stream;
Mike Stump1eb44332009-09-09 15:08:12 +00002978 StreamFile.init((const unsigned char *)Buffer->getBufferStart(),
Douglas Gregorb64c1932009-05-12 01:31:05 +00002979 (const unsigned char *)Buffer->getBufferEnd());
2980 Stream.init(StreamFile);
2981
2982 // Sniff for the signature.
2983 if (Stream.Read(8) != 'C' ||
2984 Stream.Read(8) != 'P' ||
2985 Stream.Read(8) != 'C' ||
2986 Stream.Read(8) != 'H') {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002987 Diags.Report(diag::err_fe_not_a_pch_file) << ASTFileName;
Douglas Gregorb64c1932009-05-12 01:31:05 +00002988 return std::string();
2989 }
2990
2991 RecordData Record;
2992 while (!Stream.AtEndOfStream()) {
2993 unsigned Code = Stream.ReadCode();
Mike Stump1eb44332009-09-09 15:08:12 +00002994
Douglas Gregorb64c1932009-05-12 01:31:05 +00002995 if (Code == llvm::bitc::ENTER_SUBBLOCK) {
2996 unsigned BlockID = Stream.ReadSubBlockID();
Mike Stump1eb44332009-09-09 15:08:12 +00002997
Sebastian Redl3c7f4132010-08-18 23:57:06 +00002998 // We only know the AST subblock ID.
Douglas Gregorb64c1932009-05-12 01:31:05 +00002999 switch (BlockID) {
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003000 case AST_BLOCK_ID:
3001 if (Stream.EnterSubBlock(AST_BLOCK_ID)) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00003002 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
Douglas Gregorb64c1932009-05-12 01:31:05 +00003003 return std::string();
3004 }
3005 break;
Mike Stump1eb44332009-09-09 15:08:12 +00003006
Douglas Gregorb64c1932009-05-12 01:31:05 +00003007 default:
3008 if (Stream.SkipBlock()) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00003009 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
Douglas Gregorb64c1932009-05-12 01:31:05 +00003010 return std::string();
3011 }
3012 break;
3013 }
3014 continue;
3015 }
3016
3017 if (Code == llvm::bitc::END_BLOCK) {
3018 if (Stream.ReadBlockEnd()) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00003019 Diags.Report(diag::err_fe_pch_error_at_end_block) << ASTFileName;
Douglas Gregorb64c1932009-05-12 01:31:05 +00003020 return std::string();
3021 }
3022 continue;
3023 }
3024
3025 if (Code == llvm::bitc::DEFINE_ABBREV) {
3026 Stream.ReadAbbrevRecord();
3027 continue;
3028 }
3029
3030 Record.clear();
3031 const char *BlobStart = 0;
3032 unsigned BlobLen = 0;
Mike Stump1eb44332009-09-09 15:08:12 +00003033 if (Stream.ReadRecord(Code, Record, &BlobStart, &BlobLen)
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003034 == ORIGINAL_FILE_NAME)
Douglas Gregorb64c1932009-05-12 01:31:05 +00003035 return std::string(BlobStart, BlobLen);
Mike Stump1eb44332009-09-09 15:08:12 +00003036 }
Douglas Gregorb64c1932009-05-12 01:31:05 +00003037
3038 return std::string();
3039}
3040
Douglas Gregor0a0428e2009-04-10 20:39:37 +00003041/// \brief Parse the record that corresponds to a LangOptions data
3042/// structure.
3043///
Sebastian Redl3c7f4132010-08-18 23:57:06 +00003044/// This routine parses the language options from the AST file and then gives
3045/// them to the AST listener if one is set.
Douglas Gregor0a0428e2009-04-10 20:39:37 +00003046///
Sebastian Redl3c7f4132010-08-18 23:57:06 +00003047/// \returns true if the listener deems the file unacceptable, false otherwise.
Sebastian Redlc43b54c2010-08-18 23:56:43 +00003048bool ASTReader::ParseLanguageOptions(
Chris Lattner5f9e2722011-07-23 10:55:15 +00003049 const SmallVectorImpl<uint64_t> &Record) {
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00003050 if (Listener) {
3051 LangOptions LangOpts;
Mike Stump1eb44332009-09-09 15:08:12 +00003052
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00003053 #define PARSE_LANGOPT(Option) \
3054 LangOpts.Option = Record[Idx]; \
3055 ++Idx
Mike Stump1eb44332009-09-09 15:08:12 +00003056
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00003057 unsigned Idx = 0;
3058 PARSE_LANGOPT(Trigraphs);
3059 PARSE_LANGOPT(BCPLComment);
3060 PARSE_LANGOPT(DollarIdents);
3061 PARSE_LANGOPT(AsmPreprocessor);
3062 PARSE_LANGOPT(GNUMode);
Chandler Carrutheb5d7b72010-04-17 20:17:31 +00003063 PARSE_LANGOPT(GNUKeywords);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00003064 PARSE_LANGOPT(ImplicitInt);
3065 PARSE_LANGOPT(Digraphs);
3066 PARSE_LANGOPT(HexFloats);
3067 PARSE_LANGOPT(C99);
Peter Collingbourne7e7fbd02011-04-15 00:35:23 +00003068 PARSE_LANGOPT(C1X);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00003069 PARSE_LANGOPT(Microsoft);
3070 PARSE_LANGOPT(CPlusPlus);
3071 PARSE_LANGOPT(CPlusPlus0x);
3072 PARSE_LANGOPT(CXXOperatorNames);
3073 PARSE_LANGOPT(ObjC1);
3074 PARSE_LANGOPT(ObjC2);
3075 PARSE_LANGOPT(ObjCNonFragileABI);
Fariborz Jahanian412e7982010-02-09 19:31:38 +00003076 PARSE_LANGOPT(ObjCNonFragileABI2);
Fariborz Jahanianf84109e2011-01-07 18:59:25 +00003077 PARSE_LANGOPT(AppleKext);
Ted Kremenekc32647d2010-12-23 21:35:43 +00003078 PARSE_LANGOPT(ObjCDefaultSynthProperties);
Douglas Gregor74da19f2011-06-14 23:20:43 +00003079 PARSE_LANGOPT(ObjCInferRelatedResultType);
Fariborz Jahanian4c9d8d02010-04-22 21:01:59 +00003080 PARSE_LANGOPT(NoConstantCFStrings);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00003081 PARSE_LANGOPT(PascalStrings);
3082 PARSE_LANGOPT(WritableStrings);
3083 PARSE_LANGOPT(LaxVectorConversions);
Nate Begemanb9e7e632009-06-25 23:01:11 +00003084 PARSE_LANGOPT(AltiVec);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00003085 PARSE_LANGOPT(Exceptions);
Anders Carlssonda4b7cf2011-02-19 23:53:54 +00003086 PARSE_LANGOPT(ObjCExceptions);
Anders Carlsson7da99b02011-02-23 03:04:54 +00003087 PARSE_LANGOPT(CXXExceptions);
3088 PARSE_LANGOPT(SjLjExceptions);
Douglas Gregor6f755502011-02-01 15:15:22 +00003089 PARSE_LANGOPT(MSBitfields);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00003090 PARSE_LANGOPT(NeXTRuntime);
3091 PARSE_LANGOPT(Freestanding);
3092 PARSE_LANGOPT(NoBuiltin);
3093 PARSE_LANGOPT(ThreadsafeStatics);
Douglas Gregor972d9542009-09-03 14:36:33 +00003094 PARSE_LANGOPT(POSIXThreads);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00003095 PARSE_LANGOPT(Blocks);
3096 PARSE_LANGOPT(EmitAllDecls);
3097 PARSE_LANGOPT(MathErrno);
Chris Lattnera4d71452010-06-26 21:25:03 +00003098 LangOpts.setSignedOverflowBehavior((LangOptions::SignedOverflowBehaviorTy)
3099 Record[Idx++]);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00003100 PARSE_LANGOPT(HeinousExtensions);
3101 PARSE_LANGOPT(Optimize);
3102 PARSE_LANGOPT(OptimizeSize);
3103 PARSE_LANGOPT(Static);
3104 PARSE_LANGOPT(PICLevel);
3105 PARSE_LANGOPT(GNUInline);
3106 PARSE_LANGOPT(NoInline);
Chandler Carruth0d2d1bc2011-04-23 20:05:38 +00003107 PARSE_LANGOPT(Deprecated);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00003108 PARSE_LANGOPT(AccessControl);
3109 PARSE_LANGOPT(CharIsSigned);
John Thompsona6fda122009-11-05 20:14:16 +00003110 PARSE_LANGOPT(ShortWChar);
Argyrios Kyrtzidisb1bdced2011-01-15 02:56:16 +00003111 PARSE_LANGOPT(ShortEnums);
Chris Lattnera4d71452010-06-26 21:25:03 +00003112 LangOpts.setGCMode((LangOptions::GCMode)Record[Idx++]);
John McCall1fb0caa2010-10-22 21:05:15 +00003113 LangOpts.setVisibilityMode((Visibility)Record[Idx++]);
Daniel Dunbarab8e2812009-09-21 04:16:19 +00003114 LangOpts.setStackProtectorMode((LangOptions::StackProtectorMode)
Chris Lattnera4d71452010-06-26 21:25:03 +00003115 Record[Idx++]);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00003116 PARSE_LANGOPT(InstantiationDepth);
Nate Begemanb9e7e632009-06-25 23:01:11 +00003117 PARSE_LANGOPT(OpenCL);
Peter Collingbourne08a53262010-12-01 19:14:57 +00003118 PARSE_LANGOPT(CUDA);
Mike Stump9c276ae2009-12-12 01:27:46 +00003119 PARSE_LANGOPT(CatchUndefined);
Peter Collingbourne84bccea2011-02-15 19:46:30 +00003120 PARSE_LANGOPT(DefaultFPContract);
Roman Divacky1c51b1c2011-03-01 17:36:40 +00003121 PARSE_LANGOPT(ElideConstructors);
3122 PARSE_LANGOPT(SpellChecking);
Roman Divackycfe9af22011-03-01 17:40:53 +00003123 PARSE_LANGOPT(MRTD);
John McCallf85e1932011-06-15 23:02:42 +00003124 PARSE_LANGOPT(ObjCAutoRefCount);
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00003125 #undef PARSE_LANGOPT
Douglas Gregor0a0428e2009-04-10 20:39:37 +00003126
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00003127 return Listener->ReadLanguageOptions(LangOpts);
Douglas Gregor0a0428e2009-04-10 20:39:37 +00003128 }
Douglas Gregor0a0428e2009-04-10 20:39:37 +00003129
3130 return false;
3131}
3132
Sebastian Redlc43b54c2010-08-18 23:56:43 +00003133void ASTReader::ReadPreprocessedEntities() {
Jonathan D. Turner5d6d89f2011-07-25 20:32:21 +00003134 for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) {
3135 Module &F = *(*I);
Douglas Gregor4800a5c2011-02-08 21:58:10 +00003136 if (!F.PreprocessorDetailCursor.getBitStreamReader())
3137 continue;
3138
Jonathan D. Turner5d6d89f2011-07-25 20:32:21 +00003139 SavedStreamPosition SavedPosition(F.PreprocessorDetailCursor);
Douglas Gregor4800a5c2011-02-08 21:58:10 +00003140 F.PreprocessorDetailCursor.JumpToBit(F.PreprocessorDetailStartOffset);
3141 while (LoadPreprocessedEntity(F)) { }
3142 }
Douglas Gregor6a5a23f2010-03-19 21:51:54 +00003143}
3144
Douglas Gregor0a480292011-02-11 19:46:30 +00003145PreprocessedEntity *ASTReader::ReadPreprocessedEntityAtOffset(uint64_t Offset) {
Douglas Gregor8f1231b2011-07-22 06:10:01 +00003146 RecordLocation Loc = getLocalBitOffset(Offset);
Douglas Gregor89d99802010-11-30 06:16:57 +00003147
Douglas Gregor4800a5c2011-02-08 21:58:10 +00003148 // Keep track of where we are in the stream, then jump back there
3149 // after reading this entity.
Douglas Gregor8f1231b2011-07-22 06:10:01 +00003150 SavedStreamPosition SavedPosition(Loc.F->PreprocessorDetailCursor);
3151 Loc.F->PreprocessorDetailCursor.JumpToBit(Loc.Offset);
3152 return LoadPreprocessedEntity(*Loc.F);
Douglas Gregor89d99802010-11-30 06:16:57 +00003153}
3154
Douglas Gregorcfbf1c72011-02-10 17:09:37 +00003155HeaderFileInfo ASTReader::GetHeaderFileInfo(const FileEntry *FE) {
Jonathan D. Turner5d6d89f2011-07-25 20:32:21 +00003156 for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) {
3157 Module &F = *(*I);
Douglas Gregorb4dc4852011-07-28 04:50:02 +00003158
Douglas Gregor95eab172011-07-28 20:55:49 +00003159 HeaderFileInfoTrait Trait(*this, F, &PP->getHeaderSearchInfo(),
Douglas Gregorb4dc4852011-07-28 04:50:02 +00003160 F.HeaderFileFrameworkStrings,
3161 FE->getName());
3162
Douglas Gregorcfbf1c72011-02-10 17:09:37 +00003163 HeaderFileInfoLookupTable *Table
3164 = static_cast<HeaderFileInfoLookupTable *>(F.HeaderFileInfoTable);
3165 if (!Table)
3166 continue;
3167
3168 // Look in the on-disk hash table for an entry for this file name.
3169 HeaderFileInfoLookupTable::iterator Pos = Table->find(FE->getName(),
3170 &Trait);
3171 if (Pos == Table->end())
3172 continue;
3173
3174 HeaderFileInfo HFI = *Pos;
3175 if (Listener)
3176 Listener->ReadHeaderFileInfo(HFI, FE->getUID());
3177
3178 return HFI;
3179 }
3180
3181 return HeaderFileInfo();
3182}
3183
Argyrios Kyrtzidis3efd52c2011-01-14 20:54:07 +00003184void ASTReader::ReadPragmaDiagnosticMappings(Diagnostic &Diag) {
Jonathan D. Turner5d6d89f2011-07-25 20:32:21 +00003185 for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) {
3186 Module &F = *(*I);
Douglas Gregorf62d43d2011-07-19 16:10:42 +00003187 unsigned Idx = 0;
3188 while (Idx < F.PragmaDiagMappings.size()) {
3189 SourceLocation Loc = ReadSourceLocation(F, F.PragmaDiagMappings[Idx++]);
3190 while (1) {
3191 assert(Idx < F.PragmaDiagMappings.size() &&
3192 "Invalid data, didn't find '-1' marking end of diag/map pairs");
3193 if (Idx >= F.PragmaDiagMappings.size()) {
3194 break; // Something is messed up but at least avoid infinite loop in
3195 // release build.
3196 }
3197 unsigned DiagID = F.PragmaDiagMappings[Idx++];
3198 if (DiagID == (unsigned)-1) {
3199 break; // no more diag/map pairs for this location.
3200 }
3201 diag::Mapping Map = (diag::Mapping)F.PragmaDiagMappings[Idx++];
3202 Diag.setDiagnosticMapping(DiagID, Map, Loc);
3203 }
Argyrios Kyrtzidis3efd52c2011-01-14 20:54:07 +00003204 }
Argyrios Kyrtzidisf41d3be2010-11-05 22:10:18 +00003205 }
3206}
3207
Sebastian Redlaaec0aa2010-07-20 22:37:49 +00003208/// \brief Get the correct cursor and offset for loading a type.
Sebastian Redlc43b54c2010-08-18 23:56:43 +00003209ASTReader::RecordLocation ASTReader::TypeCursorForIndex(unsigned Index) {
Jonathan D. Turnere9b76c12011-07-20 21:31:32 +00003210 GlobalTypeMapType::iterator I = GlobalTypeMap.find(Index+1);
3211 assert(I != GlobalTypeMap.end() && "Corrupted global type map");
Douglas Gregor1e849b62011-07-29 00:21:44 +00003212 Module *M = I->second;
3213 return RecordLocation(M, M->TypeOffsets[Index - M->BaseTypeID]);
Sebastian Redlaaec0aa2010-07-20 22:37:49 +00003214}
3215
3216/// \brief Read and return the type with the given index..
Douglas Gregor2cf26342009-04-09 22:27:44 +00003217///
Sebastian Redlaaec0aa2010-07-20 22:37:49 +00003218/// The index is the type ID, shifted and minus the number of predefs. This
3219/// routine actually reads the record corresponding to the type at the given
3220/// location. It is a helper routine for GetType, which deals with reading type
3221/// IDs.
Douglas Gregor393f2492011-07-22 00:38:23 +00003222QualType ASTReader::readTypeRecord(unsigned Index) {
Sebastian Redlaaec0aa2010-07-20 22:37:49 +00003223 RecordLocation Loc = TypeCursorForIndex(Index);
Sebastian Redlc3632732010-10-05 15:59:54 +00003224 llvm::BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;
Sebastian Redl9137a522010-07-16 17:50:48 +00003225
Douglas Gregor0b748912009-04-14 21:18:50 +00003226 // Keep track of where we are in the stream, then jump back there
3227 // after reading this type.
Douglas Gregor61d60ee2009-10-17 00:13:19 +00003228 SavedStreamPosition SavedPosition(DeclsCursor);
Douglas Gregor0b748912009-04-14 21:18:50 +00003229
Argyrios Kyrtzidis919e6932010-06-28 22:28:35 +00003230 ReadingKindTracker ReadingKind(Read_Type, *this);
Sebastian Redl27372b42010-08-11 18:52:41 +00003231
Douglas Gregord89275b2009-07-06 18:54:52 +00003232 // Note that we are loading a type record.
Argyrios Kyrtzidis29ee3a22010-07-30 10:03:16 +00003233 Deserializing AType(this);
Mike Stump1eb44332009-09-09 15:08:12 +00003234
Douglas Gregor393f2492011-07-22 00:38:23 +00003235 unsigned Idx = 0;
Sebastian Redlc3632732010-10-05 15:59:54 +00003236 DeclsCursor.JumpToBit(Loc.Offset);
Douglas Gregor2cf26342009-04-09 22:27:44 +00003237 RecordData Record;
Douglas Gregor61d60ee2009-10-17 00:13:19 +00003238 unsigned Code = DeclsCursor.ReadCode();
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003239 switch ((TypeCode)DeclsCursor.ReadRecord(Code, Record)) {
3240 case TYPE_EXT_QUAL: {
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00003241 if (Record.size() != 2) {
3242 Error("Incorrect encoding of extended qualifier type");
3243 return QualType();
3244 }
Douglas Gregor393f2492011-07-22 00:38:23 +00003245 QualType Base = readType(*Loc.F, Record, Idx);
3246 Qualifiers Quals = Qualifiers::fromOpaqueValue(Record[Idx++]);
John McCall0953e762009-09-24 19:53:00 +00003247 return Context->getQualifiedType(Base, Quals);
Douglas Gregor6d473962009-04-15 22:00:08 +00003248 }
Douglas Gregorb4e715b2009-04-13 20:46:52 +00003249
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003250 case TYPE_COMPLEX: {
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00003251 if (Record.size() != 1) {
3252 Error("Incorrect encoding of complex type");
3253 return QualType();
3254 }
Douglas Gregor393f2492011-07-22 00:38:23 +00003255 QualType ElemType = readType(*Loc.F, Record, Idx);
Chris Lattnerd1d64a02009-04-27 21:45:14 +00003256 return Context->getComplexType(ElemType);
Douglas Gregor2cf26342009-04-09 22:27:44 +00003257 }
3258
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003259 case TYPE_POINTER: {
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00003260 if (Record.size() != 1) {
3261 Error("Incorrect encoding of pointer type");
3262 return QualType();
3263 }
Douglas Gregor393f2492011-07-22 00:38:23 +00003264 QualType PointeeType = readType(*Loc.F, Record, Idx);
Chris Lattnerd1d64a02009-04-27 21:45:14 +00003265 return Context->getPointerType(PointeeType);
Douglas Gregor2cf26342009-04-09 22:27:44 +00003266 }
3267
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003268 case TYPE_BLOCK_POINTER: {
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00003269 if (Record.size() != 1) {
3270 Error("Incorrect encoding of block pointer type");
3271 return QualType();
3272 }
Douglas Gregor393f2492011-07-22 00:38:23 +00003273 QualType PointeeType = readType(*Loc.F, Record, Idx);
Chris Lattnerd1d64a02009-04-27 21:45:14 +00003274 return Context->getBlockPointerType(PointeeType);
Douglas Gregor2cf26342009-04-09 22:27:44 +00003275 }
3276
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003277 case TYPE_LVALUE_REFERENCE: {
Richard Smithdf1550f2011-04-12 10:38:03 +00003278 if (Record.size() != 2) {
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00003279 Error("Incorrect encoding of lvalue reference type");
3280 return QualType();
3281 }
Douglas Gregor393f2492011-07-22 00:38:23 +00003282 QualType PointeeType = readType(*Loc.F, Record, Idx);
Richard Smithdf1550f2011-04-12 10:38:03 +00003283 return Context->getLValueReferenceType(PointeeType, Record[1]);
Douglas Gregor2cf26342009-04-09 22:27:44 +00003284 }
3285
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003286 case TYPE_RVALUE_REFERENCE: {
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00003287 if (Record.size() != 1) {
3288 Error("Incorrect encoding of rvalue reference type");
3289 return QualType();
3290 }
Douglas Gregor393f2492011-07-22 00:38:23 +00003291 QualType PointeeType = readType(*Loc.F, Record, Idx);
Chris Lattnerd1d64a02009-04-27 21:45:14 +00003292 return Context->getRValueReferenceType(PointeeType);
Douglas Gregor2cf26342009-04-09 22:27:44 +00003293 }
3294
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003295 case TYPE_MEMBER_POINTER: {
Argyrios Kyrtzidis240437b2010-07-02 11:55:15 +00003296 if (Record.size() != 2) {
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00003297 Error("Incorrect encoding of member pointer type");
3298 return QualType();
3299 }
Douglas Gregor393f2492011-07-22 00:38:23 +00003300 QualType PointeeType = readType(*Loc.F, Record, Idx);
3301 QualType ClassType = readType(*Loc.F, Record, Idx);
Douglas Gregor1ab55e92010-12-10 17:03:06 +00003302 if (PointeeType.isNull() || ClassType.isNull())
3303 return QualType();
3304
Chris Lattnerd1d64a02009-04-27 21:45:14 +00003305 return Context->getMemberPointerType(PointeeType, ClassType.getTypePtr());
Douglas Gregor2cf26342009-04-09 22:27:44 +00003306 }
3307
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003308 case TYPE_CONSTANT_ARRAY: {
Douglas Gregor393f2492011-07-22 00:38:23 +00003309 QualType ElementType = readType(*Loc.F, Record, Idx);
Douglas Gregorb4e715b2009-04-13 20:46:52 +00003310 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
3311 unsigned IndexTypeQuals = Record[2];
3312 unsigned Idx = 3;
3313 llvm::APInt Size = ReadAPInt(Record, Idx);
Douglas Gregor7e7eb3d2009-07-06 15:59:29 +00003314 return Context->getConstantArrayType(ElementType, Size,
3315 ASM, IndexTypeQuals);
3316 }
3317
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003318 case TYPE_INCOMPLETE_ARRAY: {
Douglas Gregor393f2492011-07-22 00:38:23 +00003319 QualType ElementType = readType(*Loc.F, Record, Idx);
Douglas Gregorb4e715b2009-04-13 20:46:52 +00003320 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
3321 unsigned IndexTypeQuals = Record[2];
Chris Lattnerd1d64a02009-04-27 21:45:14 +00003322 return Context->getIncompleteArrayType(ElementType, ASM, IndexTypeQuals);
Douglas Gregorb4e715b2009-04-13 20:46:52 +00003323 }
3324
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003325 case TYPE_VARIABLE_ARRAY: {
Douglas Gregor393f2492011-07-22 00:38:23 +00003326 QualType ElementType = readType(*Loc.F, Record, Idx);
Douglas Gregor0b748912009-04-14 21:18:50 +00003327 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
3328 unsigned IndexTypeQuals = Record[2];
Sebastian Redlc3632732010-10-05 15:59:54 +00003329 SourceLocation LBLoc = ReadSourceLocation(*Loc.F, Record[3]);
3330 SourceLocation RBLoc = ReadSourceLocation(*Loc.F, Record[4]);
3331 return Context->getVariableArrayType(ElementType, ReadExpr(*Loc.F),
Douglas Gregor7e7eb3d2009-07-06 15:59:29 +00003332 ASM, IndexTypeQuals,
3333 SourceRange(LBLoc, RBLoc));
Douglas Gregorb4e715b2009-04-13 20:46:52 +00003334 }
3335
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003336 case TYPE_VECTOR: {
Chris Lattner788b0fd2010-06-23 06:00:24 +00003337 if (Record.size() != 3) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00003338 Error("incorrect encoding of vector type in AST file");
Douglas Gregorb4e715b2009-04-13 20:46:52 +00003339 return QualType();
3340 }
3341
Douglas Gregor393f2492011-07-22 00:38:23 +00003342 QualType ElementType = readType(*Loc.F, Record, Idx);
Douglas Gregorb4e715b2009-04-13 20:46:52 +00003343 unsigned NumElements = Record[1];
Bob Wilsone86d78c2010-11-10 21:56:12 +00003344 unsigned VecKind = Record[2];
Chris Lattner788b0fd2010-06-23 06:00:24 +00003345 return Context->getVectorType(ElementType, NumElements,
Bob Wilsone86d78c2010-11-10 21:56:12 +00003346 (VectorType::VectorKind)VecKind);
Douglas Gregorb4e715b2009-04-13 20:46:52 +00003347 }
3348
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003349 case TYPE_EXT_VECTOR: {
Chris Lattner788b0fd2010-06-23 06:00:24 +00003350 if (Record.size() != 3) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00003351 Error("incorrect encoding of extended vector type in AST file");
Douglas Gregorb4e715b2009-04-13 20:46:52 +00003352 return QualType();
3353 }
3354
Douglas Gregor393f2492011-07-22 00:38:23 +00003355 QualType ElementType = readType(*Loc.F, Record, Idx);
Douglas Gregorb4e715b2009-04-13 20:46:52 +00003356 unsigned NumElements = Record[1];
Chris Lattnerd1d64a02009-04-27 21:45:14 +00003357 return Context->getExtVectorType(ElementType, NumElements);
Douglas Gregorb4e715b2009-04-13 20:46:52 +00003358 }
3359
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003360 case TYPE_FUNCTION_NO_PROTO: {
John McCallf85e1932011-06-15 23:02:42 +00003361 if (Record.size() != 6) {
Douglas Gregora02b1472009-04-28 21:53:25 +00003362 Error("incorrect encoding of no-proto function type");
Douglas Gregorb4e715b2009-04-13 20:46:52 +00003363 return QualType();
3364 }
Douglas Gregor393f2492011-07-22 00:38:23 +00003365 QualType ResultType = readType(*Loc.F, Record, Idx);
John McCallf85e1932011-06-15 23:02:42 +00003366 FunctionType::ExtInfo Info(Record[1], Record[2], Record[3],
3367 (CallingConv)Record[4], Record[5]);
Rafael Espindola264ba482010-03-30 20:24:48 +00003368 return Context->getFunctionNoProtoType(ResultType, Info);
Douglas Gregorb4e715b2009-04-13 20:46:52 +00003369 }
3370
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003371 case TYPE_FUNCTION_PROTO: {
Douglas Gregor393f2492011-07-22 00:38:23 +00003372 QualType ResultType = readType(*Loc.F, Record, Idx);
John McCalle23cf432010-12-14 08:05:40 +00003373
3374 FunctionProtoType::ExtProtoInfo EPI;
3375 EPI.ExtInfo = FunctionType::ExtInfo(/*noreturn*/ Record[1],
Eli Friedmana49218e2011-04-09 08:18:08 +00003376 /*hasregparm*/ Record[2],
3377 /*regparm*/ Record[3],
John McCallf85e1932011-06-15 23:02:42 +00003378 static_cast<CallingConv>(Record[4]),
3379 /*produces*/ Record[5]);
John McCalle23cf432010-12-14 08:05:40 +00003380
John McCallf85e1932011-06-15 23:02:42 +00003381 unsigned Idx = 6;
Douglas Gregorb4e715b2009-04-13 20:46:52 +00003382 unsigned NumParams = Record[Idx++];
Chris Lattner5f9e2722011-07-23 10:55:15 +00003383 SmallVector<QualType, 16> ParamTypes;
Douglas Gregorb4e715b2009-04-13 20:46:52 +00003384 for (unsigned I = 0; I != NumParams; ++I)
Douglas Gregor393f2492011-07-22 00:38:23 +00003385 ParamTypes.push_back(readType(*Loc.F, Record, Idx));
John McCalle23cf432010-12-14 08:05:40 +00003386
3387 EPI.Variadic = Record[Idx++];
3388 EPI.TypeQuals = Record[Idx++];
Douglas Gregorc938c162011-01-26 05:01:58 +00003389 EPI.RefQualifier = static_cast<RefQualifierKind>(Record[Idx++]);
Sebastian Redl60618fa2011-03-12 11:50:43 +00003390 ExceptionSpecificationType EST =
3391 static_cast<ExceptionSpecificationType>(Record[Idx++]);
3392 EPI.ExceptionSpecType = EST;
3393 if (EST == EST_Dynamic) {
3394 EPI.NumExceptions = Record[Idx++];
Chris Lattner5f9e2722011-07-23 10:55:15 +00003395 SmallVector<QualType, 2> Exceptions;
Sebastian Redl60618fa2011-03-12 11:50:43 +00003396 for (unsigned I = 0; I != EPI.NumExceptions; ++I)
Douglas Gregor393f2492011-07-22 00:38:23 +00003397 Exceptions.push_back(readType(*Loc.F, Record, Idx));
Sebastian Redl60618fa2011-03-12 11:50:43 +00003398 EPI.Exceptions = Exceptions.data();
3399 } else if (EST == EST_ComputedNoexcept) {
3400 EPI.NoexceptExpr = ReadExpr(*Loc.F);
3401 }
Jay Foadbeaaccd2009-05-21 09:52:38 +00003402 return Context->getFunctionType(ResultType, ParamTypes.data(), NumParams,
John McCalle23cf432010-12-14 08:05:40 +00003403 EPI);
Douglas Gregorb4e715b2009-04-13 20:46:52 +00003404 }
3405
Douglas Gregor409448c2011-07-21 22:35:25 +00003406 case TYPE_UNRESOLVED_USING: {
3407 unsigned Idx = 0;
John McCalled976492009-12-04 22:46:56 +00003408 return Context->getTypeDeclType(
Douglas Gregor409448c2011-07-21 22:35:25 +00003409 ReadDeclAs<UnresolvedUsingTypenameDecl>(*Loc.F, Record, Idx));
3410 }
3411
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003412 case TYPE_TYPEDEF: {
Argyrios Kyrtzidis9763e222010-07-02 11:55:11 +00003413 if (Record.size() != 2) {
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00003414 Error("incorrect encoding of typedef type");
3415 return QualType();
3416 }
Douglas Gregor409448c2011-07-21 22:35:25 +00003417 unsigned Idx = 0;
3418 TypedefNameDecl *Decl = ReadDeclAs<TypedefNameDecl>(*Loc.F, Record, Idx);
Douglas Gregor393f2492011-07-22 00:38:23 +00003419 QualType Canonical = readType(*Loc.F, Record, Idx);
Douglas Gregor32adc8b2010-10-26 00:51:02 +00003420 if (!Canonical.isNull())
3421 Canonical = Context->getCanonicalType(Canonical);
Argyrios Kyrtzidis9763e222010-07-02 11:55:11 +00003422 return Context->getTypedefType(Decl, Canonical);
3423 }
Douglas Gregorb4e715b2009-04-13 20:46:52 +00003424
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003425 case TYPE_TYPEOF_EXPR:
Sebastian Redlc3632732010-10-05 15:59:54 +00003426 return Context->getTypeOfExprType(ReadExpr(*Loc.F));
Douglas Gregorb4e715b2009-04-13 20:46:52 +00003427
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003428 case TYPE_TYPEOF: {
Douglas Gregorb4e715b2009-04-13 20:46:52 +00003429 if (Record.size() != 1) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00003430 Error("incorrect encoding of typeof(type) in AST file");
Douglas Gregorb4e715b2009-04-13 20:46:52 +00003431 return QualType();
3432 }
Douglas Gregor393f2492011-07-22 00:38:23 +00003433 QualType UnderlyingType = readType(*Loc.F, Record, Idx);
Chris Lattnerd1d64a02009-04-27 21:45:14 +00003434 return Context->getTypeOfType(UnderlyingType);
Douglas Gregorb4e715b2009-04-13 20:46:52 +00003435 }
Mike Stump1eb44332009-09-09 15:08:12 +00003436
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003437 case TYPE_DECLTYPE:
Sebastian Redlc3632732010-10-05 15:59:54 +00003438 return Context->getDecltypeType(ReadExpr(*Loc.F));
Anders Carlsson395b4752009-06-24 19:06:50 +00003439
Sean Huntca63c202011-05-24 22:41:36 +00003440 case TYPE_UNARY_TRANSFORM: {
Douglas Gregor393f2492011-07-22 00:38:23 +00003441 QualType BaseType = readType(*Loc.F, Record, Idx);
3442 QualType UnderlyingType = readType(*Loc.F, Record, Idx);
Sean Huntca63c202011-05-24 22:41:36 +00003443 UnaryTransformType::UTTKind UKind = (UnaryTransformType::UTTKind)Record[2];
3444 return Context->getUnaryTransformType(BaseType, UnderlyingType, UKind);
3445 }
3446
Richard Smith34b41d92011-02-20 03:19:35 +00003447 case TYPE_AUTO:
Douglas Gregor393f2492011-07-22 00:38:23 +00003448 return Context->getAutoType(readType(*Loc.F, Record, Idx));
Richard Smith34b41d92011-02-20 03:19:35 +00003449
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003450 case TYPE_RECORD: {
Argyrios Kyrtzidisbe191102010-07-08 13:09:53 +00003451 if (Record.size() != 2) {
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00003452 Error("incorrect encoding of record type");
3453 return QualType();
3454 }
Douglas Gregor409448c2011-07-21 22:35:25 +00003455 unsigned Idx = 0;
3456 bool IsDependent = Record[Idx++];
3457 QualType T
3458 = Context->getRecordType(ReadDeclAs<RecordDecl>(*Loc.F, Record, Idx));
John McCallf4c73712011-01-19 06:33:43 +00003459 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
Argyrios Kyrtzidisbe191102010-07-08 13:09:53 +00003460 return T;
3461 }
Douglas Gregorb4e715b2009-04-13 20:46:52 +00003462
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003463 case TYPE_ENUM: {
Argyrios Kyrtzidisbe191102010-07-08 13:09:53 +00003464 if (Record.size() != 2) {
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00003465 Error("incorrect encoding of enum type");
3466 return QualType();
3467 }
Douglas Gregor409448c2011-07-21 22:35:25 +00003468 unsigned Idx = 0;
3469 bool IsDependent = Record[Idx++];
3470 QualType T
3471 = Context->getEnumType(ReadDeclAs<EnumDecl>(*Loc.F, Record, Idx));
John McCallf4c73712011-01-19 06:33:43 +00003472 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
Argyrios Kyrtzidisbe191102010-07-08 13:09:53 +00003473 return T;
3474 }
Douglas Gregor0a2b45e2009-04-13 18:14:40 +00003475
John McCall9d156a72011-01-06 01:58:22 +00003476 case TYPE_ATTRIBUTED: {
3477 if (Record.size() != 3) {
3478 Error("incorrect encoding of attributed type");
3479 return QualType();
3480 }
Douglas Gregor393f2492011-07-22 00:38:23 +00003481 QualType modifiedType = readType(*Loc.F, Record, Idx);
3482 QualType equivalentType = readType(*Loc.F, Record, Idx);
John McCall9d156a72011-01-06 01:58:22 +00003483 AttributedType::Kind kind = static_cast<AttributedType::Kind>(Record[2]);
3484 return Context->getAttributedType(kind, modifiedType, equivalentType);
3485 }
3486
Abramo Bagnara075f8f12010-12-10 16:29:40 +00003487 case TYPE_PAREN: {
3488 if (Record.size() != 1) {
3489 Error("incorrect encoding of paren type");
3490 return QualType();
3491 }
Douglas Gregor393f2492011-07-22 00:38:23 +00003492 QualType InnerType = readType(*Loc.F, Record, Idx);
Abramo Bagnara075f8f12010-12-10 16:29:40 +00003493 return Context->getParenType(InnerType);
3494 }
3495
Douglas Gregor7536dd52010-12-20 02:24:11 +00003496 case TYPE_PACK_EXPANSION: {
Douglas Gregorf9997a02011-02-01 15:24:58 +00003497 if (Record.size() != 2) {
Douglas Gregor7536dd52010-12-20 02:24:11 +00003498 Error("incorrect encoding of pack expansion type");
3499 return QualType();
3500 }
Douglas Gregor393f2492011-07-22 00:38:23 +00003501 QualType Pattern = readType(*Loc.F, Record, Idx);
Douglas Gregor7536dd52010-12-20 02:24:11 +00003502 if (Pattern.isNull())
3503 return QualType();
Douglas Gregorcded4f62011-01-14 17:04:44 +00003504 llvm::Optional<unsigned> NumExpansions;
3505 if (Record[1])
3506 NumExpansions = Record[1] - 1;
3507 return Context->getPackExpansionType(Pattern, NumExpansions);
Douglas Gregor7536dd52010-12-20 02:24:11 +00003508 }
3509
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003510 case TYPE_ELABORATED: {
Argyrios Kyrtzidis3acad622010-06-25 16:24:58 +00003511 unsigned Idx = 0;
3512 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
Douglas Gregor409448c2011-07-21 22:35:25 +00003513 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
Douglas Gregor393f2492011-07-22 00:38:23 +00003514 QualType NamedType = readType(*Loc.F, Record, Idx);
Argyrios Kyrtzidis3acad622010-06-25 16:24:58 +00003515 return Context->getElaboratedType(Keyword, NNS, NamedType);
John McCall7da24312009-09-05 00:15:47 +00003516 }
3517
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003518 case TYPE_OBJC_INTERFACE: {
Chris Lattnerc6fa4452009-04-22 06:45:28 +00003519 unsigned Idx = 0;
Douglas Gregor409448c2011-07-21 22:35:25 +00003520 ObjCInterfaceDecl *ItfD
3521 = ReadDeclAs<ObjCInterfaceDecl>(*Loc.F, Record, Idx);
John McCallc12c5bb2010-05-15 11:32:37 +00003522 return Context->getObjCInterfaceType(ItfD);
3523 }
3524
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003525 case TYPE_OBJC_OBJECT: {
John McCallc12c5bb2010-05-15 11:32:37 +00003526 unsigned Idx = 0;
Douglas Gregor393f2492011-07-22 00:38:23 +00003527 QualType Base = readType(*Loc.F, Record, Idx);
Chris Lattnerc6fa4452009-04-22 06:45:28 +00003528 unsigned NumProtos = Record[Idx++];
Chris Lattner5f9e2722011-07-23 10:55:15 +00003529 SmallVector<ObjCProtocolDecl*, 4> Protos;
Chris Lattnerc6fa4452009-04-22 06:45:28 +00003530 for (unsigned I = 0; I != NumProtos; ++I)
Douglas Gregor409448c2011-07-21 22:35:25 +00003531 Protos.push_back(ReadDeclAs<ObjCProtocolDecl>(*Loc.F, Record, Idx));
Michael J. Spencer20249a12010-10-21 03:16:25 +00003532 return Context->getObjCObjectType(Base, Protos.data(), NumProtos);
Chris Lattnerc6fa4452009-04-22 06:45:28 +00003533 }
Douglas Gregorb4e715b2009-04-13 20:46:52 +00003534
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003535 case TYPE_OBJC_OBJECT_POINTER: {
Chris Lattnerd7a3fcd2009-04-22 06:40:03 +00003536 unsigned Idx = 0;
Douglas Gregor393f2492011-07-22 00:38:23 +00003537 QualType Pointee = readType(*Loc.F, Record, Idx);
John McCallc12c5bb2010-05-15 11:32:37 +00003538 return Context->getObjCObjectPointerType(Pointee);
Chris Lattnerd7a3fcd2009-04-22 06:40:03 +00003539 }
Argyrios Kyrtzidis24fab412009-09-29 19:42:55 +00003540
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003541 case TYPE_SUBST_TEMPLATE_TYPE_PARM: {
John McCall49a832b2009-10-18 09:09:24 +00003542 unsigned Idx = 0;
Douglas Gregor393f2492011-07-22 00:38:23 +00003543 QualType Parm = readType(*Loc.F, Record, Idx);
3544 QualType Replacement = readType(*Loc.F, Record, Idx);
John McCall49a832b2009-10-18 09:09:24 +00003545 return
3546 Context->getSubstTemplateTypeParmType(cast<TemplateTypeParmType>(Parm),
3547 Replacement);
3548 }
John McCall3cb0ebd2010-03-10 03:28:59 +00003549
Douglas Gregorc3069d62011-01-14 02:55:32 +00003550 case TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK: {
3551 unsigned Idx = 0;
Douglas Gregor393f2492011-07-22 00:38:23 +00003552 QualType Parm = readType(*Loc.F, Record, Idx);
Douglas Gregorc3069d62011-01-14 02:55:32 +00003553 TemplateArgument ArgPack = ReadTemplateArgument(*Loc.F, Record, Idx);
3554 return Context->getSubstTemplateTypeParmPackType(
3555 cast<TemplateTypeParmType>(Parm),
3556 ArgPack);
3557 }
3558
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003559 case TYPE_INJECTED_CLASS_NAME: {
Douglas Gregor409448c2011-07-21 22:35:25 +00003560 CXXRecordDecl *D = ReadDeclAs<CXXRecordDecl>(*Loc.F, Record, Idx);
Douglas Gregor393f2492011-07-22 00:38:23 +00003561 QualType TST = readType(*Loc.F, Record, Idx); // probably derivable
Argyrios Kyrtzidis43921b52010-07-02 11:55:20 +00003562 // FIXME: ASTContext::getInjectedClassNameType is not currently suitable
Sebastian Redl3c7f4132010-08-18 23:57:06 +00003563 // for AST reading, too much interdependencies.
Argyrios Kyrtzidis43921b52010-07-02 11:55:20 +00003564 return
3565 QualType(new (*Context, TypeAlignment) InjectedClassNameType(D, TST), 0);
John McCall3cb0ebd2010-03-10 03:28:59 +00003566 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00003567
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003568 case TYPE_TEMPLATE_TYPE_PARM: {
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00003569 unsigned Idx = 0;
3570 unsigned Depth = Record[Idx++];
3571 unsigned Index = Record[Idx++];
3572 bool Pack = Record[Idx++];
Douglas Gregor409448c2011-07-21 22:35:25 +00003573 TemplateTypeParmDecl *D
3574 = ReadDeclAs<TemplateTypeParmDecl>(*Loc.F, Record, Idx);
Chandler Carruth4fb86f82011-05-01 00:51:33 +00003575 return Context->getTemplateTypeParmType(Depth, Index, Pack, D);
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00003576 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00003577
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003578 case TYPE_DEPENDENT_NAME: {
Argyrios Kyrtzidis8dfbd8b2010-06-24 08:57:31 +00003579 unsigned Idx = 0;
3580 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
Douglas Gregor409448c2011-07-21 22:35:25 +00003581 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
Douglas Gregor95eab172011-07-28 20:55:49 +00003582 const IdentifierInfo *Name = this->GetIdentifierInfo(*Loc.F, Record, Idx);
Douglas Gregor393f2492011-07-22 00:38:23 +00003583 QualType Canon = readType(*Loc.F, Record, Idx);
Douglas Gregor32adc8b2010-10-26 00:51:02 +00003584 if (!Canon.isNull())
3585 Canon = Context->getCanonicalType(Canon);
Argyrios Kyrtzidisf48d45e2010-07-02 11:55:24 +00003586 return Context->getDependentNameType(Keyword, NNS, Name, Canon);
Argyrios Kyrtzidis8dfbd8b2010-06-24 08:57:31 +00003587 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00003588
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003589 case TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION: {
Argyrios Kyrtzidis3acad622010-06-25 16:24:58 +00003590 unsigned Idx = 0;
3591 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
Douglas Gregor409448c2011-07-21 22:35:25 +00003592 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
Douglas Gregor95eab172011-07-28 20:55:49 +00003593 const IdentifierInfo *Name = this->GetIdentifierInfo(*Loc.F, Record, Idx);
Argyrios Kyrtzidis3acad622010-06-25 16:24:58 +00003594 unsigned NumArgs = Record[Idx++];
Chris Lattner5f9e2722011-07-23 10:55:15 +00003595 SmallVector<TemplateArgument, 8> Args;
Argyrios Kyrtzidis3acad622010-06-25 16:24:58 +00003596 Args.reserve(NumArgs);
3597 while (NumArgs--)
Sebastian Redlc3632732010-10-05 15:59:54 +00003598 Args.push_back(ReadTemplateArgument(*Loc.F, Record, Idx));
Argyrios Kyrtzidis3acad622010-06-25 16:24:58 +00003599 return Context->getDependentTemplateSpecializationType(Keyword, NNS, Name,
3600 Args.size(), Args.data());
3601 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00003602
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003603 case TYPE_DEPENDENT_SIZED_ARRAY: {
Argyrios Kyrtzidisae8b17f2010-06-30 08:49:25 +00003604 unsigned Idx = 0;
3605
3606 // ArrayType
Douglas Gregor393f2492011-07-22 00:38:23 +00003607 QualType ElementType = readType(*Loc.F, Record, Idx);
Argyrios Kyrtzidisae8b17f2010-06-30 08:49:25 +00003608 ArrayType::ArraySizeModifier ASM
3609 = (ArrayType::ArraySizeModifier)Record[Idx++];
3610 unsigned IndexTypeQuals = Record[Idx++];
3611
3612 // DependentSizedArrayType
Sebastian Redlc3632732010-10-05 15:59:54 +00003613 Expr *NumElts = ReadExpr(*Loc.F);
3614 SourceRange Brackets = ReadSourceRange(*Loc.F, Record, Idx);
Argyrios Kyrtzidisae8b17f2010-06-30 08:49:25 +00003615
3616 return Context->getDependentSizedArrayType(ElementType, NumElts, ASM,
3617 IndexTypeQuals, Brackets);
3618 }
Argyrios Kyrtzidis90b715e2010-06-19 19:28:53 +00003619
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003620 case TYPE_TEMPLATE_SPECIALIZATION: {
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00003621 unsigned Idx = 0;
Argyrios Kyrtzidisbe191102010-07-08 13:09:53 +00003622 bool IsDependent = Record[Idx++];
Douglas Gregor1aee05d2011-01-15 06:45:20 +00003623 TemplateName Name = ReadTemplateName(*Loc.F, Record, Idx);
Chris Lattner5f9e2722011-07-23 10:55:15 +00003624 SmallVector<TemplateArgument, 8> Args;
Sebastian Redlc3632732010-10-05 15:59:54 +00003625 ReadTemplateArgumentList(Args, *Loc.F, Record, Idx);
Douglas Gregor393f2492011-07-22 00:38:23 +00003626 QualType Underlying = readType(*Loc.F, Record, Idx);
Argyrios Kyrtzidisbe191102010-07-08 13:09:53 +00003627 QualType T;
Richard Smith3e4c6c42011-05-05 21:57:07 +00003628 if (Underlying.isNull())
Argyrios Kyrtzidisbe191102010-07-08 13:09:53 +00003629 T = Context->getCanonicalTemplateSpecializationType(Name, Args.data(),
3630 Args.size());
Argyrios Kyrtzidis9763e222010-07-02 11:55:11 +00003631 else
Argyrios Kyrtzidisbe191102010-07-08 13:09:53 +00003632 T = Context->getTemplateSpecializationType(Name, Args.data(),
Richard Smith3e4c6c42011-05-05 21:57:07 +00003633 Args.size(), Underlying);
John McCallf4c73712011-01-19 06:33:43 +00003634 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
Argyrios Kyrtzidisbe191102010-07-08 13:09:53 +00003635 return T;
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00003636 }
Douglas Gregor2cf26342009-04-09 22:27:44 +00003637 }
Douglas Gregor2cf26342009-04-09 22:27:44 +00003638 // Suppress a GCC warning
3639 return QualType();
3640}
3641
Sebastian Redlc3632732010-10-05 15:59:54 +00003642class clang::TypeLocReader : public TypeLocVisitor<TypeLocReader> {
Sebastian Redlc43b54c2010-08-18 23:56:43 +00003643 ASTReader &Reader;
Douglas Gregor72a9ae12011-07-22 16:00:58 +00003644 Module &F;
Sebastian Redl577d4792010-07-22 22:43:28 +00003645 llvm::BitstreamCursor &DeclsCursor;
Sebastian Redlc43b54c2010-08-18 23:56:43 +00003646 const ASTReader::RecordData &Record;
John McCalla1ee0c52009-10-16 21:56:05 +00003647 unsigned &Idx;
3648
Sebastian Redlc3632732010-10-05 15:59:54 +00003649 SourceLocation ReadSourceLocation(const ASTReader::RecordData &R,
3650 unsigned &I) {
3651 return Reader.ReadSourceLocation(F, R, I);
3652 }
3653
Douglas Gregor409448c2011-07-21 22:35:25 +00003654 template<typename T>
3655 T *ReadDeclAs(const ASTReader::RecordData &Record, unsigned &Idx) {
3656 return Reader.ReadDeclAs<T>(F, Record, Idx);
3657 }
3658
John McCalla1ee0c52009-10-16 21:56:05 +00003659public:
Douglas Gregor72a9ae12011-07-22 16:00:58 +00003660 TypeLocReader(ASTReader &Reader, Module &F,
Sebastian Redlc43b54c2010-08-18 23:56:43 +00003661 const ASTReader::RecordData &Record, unsigned &Idx)
Sebastian Redlc3632732010-10-05 15:59:54 +00003662 : Reader(Reader), F(F), DeclsCursor(F.DeclsCursor), Record(Record), Idx(Idx)
3663 { }
John McCalla1ee0c52009-10-16 21:56:05 +00003664
John McCall51bd8032009-10-18 01:05:36 +00003665 // We want compile-time assurance that we've enumerated all of
3666 // these, so unfortunately we have to declare them first, then
3667 // define them out-of-line.
3668#define ABSTRACT_TYPELOC(CLASS, PARENT)
John McCalla1ee0c52009-10-16 21:56:05 +00003669#define TYPELOC(CLASS, PARENT) \
John McCall51bd8032009-10-18 01:05:36 +00003670 void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc);
John McCalla1ee0c52009-10-16 21:56:05 +00003671#include "clang/AST/TypeLocNodes.def"
3672
John McCall51bd8032009-10-18 01:05:36 +00003673 void VisitFunctionTypeLoc(FunctionTypeLoc);
3674 void VisitArrayTypeLoc(ArrayTypeLoc);
John McCalla1ee0c52009-10-16 21:56:05 +00003675};
3676
John McCall51bd8032009-10-18 01:05:36 +00003677void TypeLocReader::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
John McCalla1ee0c52009-10-16 21:56:05 +00003678 // nothing to do
3679}
John McCall51bd8032009-10-18 01:05:36 +00003680void TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003681 TL.setBuiltinLoc(ReadSourceLocation(Record, Idx));
Douglas Gregorddf889a2010-01-18 18:04:31 +00003682 if (TL.needsExtraLocalData()) {
3683 TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Record[Idx++]));
3684 TL.setWrittenSignSpec(static_cast<DeclSpec::TSS>(Record[Idx++]));
3685 TL.setWrittenWidthSpec(static_cast<DeclSpec::TSW>(Record[Idx++]));
3686 TL.setModeAttr(Record[Idx++]);
3687 }
John McCalla1ee0c52009-10-16 21:56:05 +00003688}
John McCall51bd8032009-10-18 01:05:36 +00003689void TypeLocReader::VisitComplexTypeLoc(ComplexTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003690 TL.setNameLoc(ReadSourceLocation(Record, Idx));
John McCalla1ee0c52009-10-16 21:56:05 +00003691}
John McCall51bd8032009-10-18 01:05:36 +00003692void TypeLocReader::VisitPointerTypeLoc(PointerTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003693 TL.setStarLoc(ReadSourceLocation(Record, Idx));
John McCalla1ee0c52009-10-16 21:56:05 +00003694}
John McCall51bd8032009-10-18 01:05:36 +00003695void TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003696 TL.setCaretLoc(ReadSourceLocation(Record, Idx));
John McCalla1ee0c52009-10-16 21:56:05 +00003697}
John McCall51bd8032009-10-18 01:05:36 +00003698void TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003699 TL.setAmpLoc(ReadSourceLocation(Record, Idx));
John McCalla1ee0c52009-10-16 21:56:05 +00003700}
John McCall51bd8032009-10-18 01:05:36 +00003701void TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003702 TL.setAmpAmpLoc(ReadSourceLocation(Record, Idx));
John McCalla1ee0c52009-10-16 21:56:05 +00003703}
John McCall51bd8032009-10-18 01:05:36 +00003704void TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003705 TL.setStarLoc(ReadSourceLocation(Record, Idx));
Abramo Bagnarab6ab6c12011-03-05 14:42:21 +00003706 TL.setClassTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
John McCalla1ee0c52009-10-16 21:56:05 +00003707}
John McCall51bd8032009-10-18 01:05:36 +00003708void TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003709 TL.setLBracketLoc(ReadSourceLocation(Record, Idx));
3710 TL.setRBracketLoc(ReadSourceLocation(Record, Idx));
John McCalla1ee0c52009-10-16 21:56:05 +00003711 if (Record[Idx++])
Sebastian Redlc3632732010-10-05 15:59:54 +00003712 TL.setSizeExpr(Reader.ReadExpr(F));
Douglas Gregor61d60ee2009-10-17 00:13:19 +00003713 else
John McCall51bd8032009-10-18 01:05:36 +00003714 TL.setSizeExpr(0);
3715}
3716void TypeLocReader::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) {
3717 VisitArrayTypeLoc(TL);
3718}
3719void TypeLocReader::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) {
3720 VisitArrayTypeLoc(TL);
3721}
3722void TypeLocReader::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) {
3723 VisitArrayTypeLoc(TL);
3724}
3725void TypeLocReader::VisitDependentSizedArrayTypeLoc(
3726 DependentSizedArrayTypeLoc TL) {
3727 VisitArrayTypeLoc(TL);
3728}
3729void TypeLocReader::VisitDependentSizedExtVectorTypeLoc(
3730 DependentSizedExtVectorTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003731 TL.setNameLoc(ReadSourceLocation(Record, Idx));
John McCall51bd8032009-10-18 01:05:36 +00003732}
3733void TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003734 TL.setNameLoc(ReadSourceLocation(Record, Idx));
John McCall51bd8032009-10-18 01:05:36 +00003735}
3736void TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003737 TL.setNameLoc(ReadSourceLocation(Record, Idx));
John McCall51bd8032009-10-18 01:05:36 +00003738}
3739void TypeLocReader::VisitFunctionTypeLoc(FunctionTypeLoc TL) {
Abramo Bagnara796aa442011-03-12 11:17:06 +00003740 TL.setLocalRangeBegin(ReadSourceLocation(Record, Idx));
3741 TL.setLocalRangeEnd(ReadSourceLocation(Record, Idx));
Douglas Gregordab60ad2010-10-01 18:44:50 +00003742 TL.setTrailingReturn(Record[Idx++]);
John McCall51bd8032009-10-18 01:05:36 +00003743 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) {
Douglas Gregor409448c2011-07-21 22:35:25 +00003744 TL.setArg(i, ReadDeclAs<ParmVarDecl>(Record, Idx));
John McCall51bd8032009-10-18 01:05:36 +00003745 }
3746}
3747void TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) {
3748 VisitFunctionTypeLoc(TL);
3749}
3750void TypeLocReader::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) {
3751 VisitFunctionTypeLoc(TL);
3752}
John McCalled976492009-12-04 22:46:56 +00003753void TypeLocReader::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003754 TL.setNameLoc(ReadSourceLocation(Record, Idx));
John McCalled976492009-12-04 22:46:56 +00003755}
John McCall51bd8032009-10-18 01:05:36 +00003756void TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003757 TL.setNameLoc(ReadSourceLocation(Record, Idx));
John McCall51bd8032009-10-18 01:05:36 +00003758}
3759void TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003760 TL.setTypeofLoc(ReadSourceLocation(Record, Idx));
3761 TL.setLParenLoc(ReadSourceLocation(Record, Idx));
3762 TL.setRParenLoc(ReadSourceLocation(Record, Idx));
John McCall51bd8032009-10-18 01:05:36 +00003763}
3764void TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003765 TL.setTypeofLoc(ReadSourceLocation(Record, Idx));
3766 TL.setLParenLoc(ReadSourceLocation(Record, Idx));
3767 TL.setRParenLoc(ReadSourceLocation(Record, Idx));
3768 TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
John McCall51bd8032009-10-18 01:05:36 +00003769}
3770void TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003771 TL.setNameLoc(ReadSourceLocation(Record, Idx));
John McCall51bd8032009-10-18 01:05:36 +00003772}
Sean Huntca63c202011-05-24 22:41:36 +00003773void TypeLocReader::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
3774 TL.setKWLoc(ReadSourceLocation(Record, Idx));
3775 TL.setLParenLoc(ReadSourceLocation(Record, Idx));
3776 TL.setRParenLoc(ReadSourceLocation(Record, Idx));
3777 TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
3778}
Richard Smith34b41d92011-02-20 03:19:35 +00003779void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) {
3780 TL.setNameLoc(ReadSourceLocation(Record, Idx));
3781}
John McCall51bd8032009-10-18 01:05:36 +00003782void TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003783 TL.setNameLoc(ReadSourceLocation(Record, Idx));
John McCall51bd8032009-10-18 01:05:36 +00003784}
3785void TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003786 TL.setNameLoc(ReadSourceLocation(Record, Idx));
John McCall51bd8032009-10-18 01:05:36 +00003787}
John McCall9d156a72011-01-06 01:58:22 +00003788void TypeLocReader::VisitAttributedTypeLoc(AttributedTypeLoc TL) {
3789 TL.setAttrNameLoc(ReadSourceLocation(Record, Idx));
3790 if (TL.hasAttrOperand()) {
3791 SourceRange range;
3792 range.setBegin(ReadSourceLocation(Record, Idx));
3793 range.setEnd(ReadSourceLocation(Record, Idx));
3794 TL.setAttrOperandParensRange(range);
3795 }
3796 if (TL.hasAttrExprOperand()) {
3797 if (Record[Idx++])
3798 TL.setAttrExprOperand(Reader.ReadExpr(F));
3799 else
3800 TL.setAttrExprOperand(0);
3801 } else if (TL.hasAttrEnumOperand())
3802 TL.setAttrEnumOperandLoc(ReadSourceLocation(Record, Idx));
3803}
John McCall51bd8032009-10-18 01:05:36 +00003804void TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003805 TL.setNameLoc(ReadSourceLocation(Record, Idx));
John McCall51bd8032009-10-18 01:05:36 +00003806}
John McCall49a832b2009-10-18 09:09:24 +00003807void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc(
3808 SubstTemplateTypeParmTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003809 TL.setNameLoc(ReadSourceLocation(Record, Idx));
John McCall49a832b2009-10-18 09:09:24 +00003810}
Douglas Gregorc3069d62011-01-14 02:55:32 +00003811void TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc(
3812 SubstTemplateTypeParmPackTypeLoc TL) {
3813 TL.setNameLoc(ReadSourceLocation(Record, Idx));
3814}
John McCall51bd8032009-10-18 01:05:36 +00003815void TypeLocReader::VisitTemplateSpecializationTypeLoc(
3816 TemplateSpecializationTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003817 TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx));
3818 TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
3819 TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
John McCall833ca992009-10-29 08:12:44 +00003820 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
3821 TL.setArgLocInfo(i,
Sebastian Redlc3632732010-10-05 15:59:54 +00003822 Reader.GetTemplateArgumentLocInfo(F,
3823 TL.getTypePtr()->getArg(i).getKind(),
3824 Record, Idx));
John McCall51bd8032009-10-18 01:05:36 +00003825}
Abramo Bagnara075f8f12010-12-10 16:29:40 +00003826void TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) {
3827 TL.setLParenLoc(ReadSourceLocation(Record, Idx));
3828 TL.setRParenLoc(ReadSourceLocation(Record, Idx));
3829}
Abramo Bagnara465d41b2010-05-11 21:36:43 +00003830void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003831 TL.setKeywordLoc(ReadSourceLocation(Record, Idx));
Douglas Gregor9e876872011-03-01 18:12:44 +00003832 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
John McCall51bd8032009-10-18 01:05:36 +00003833}
John McCall3cb0ebd2010-03-10 03:28:59 +00003834void TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003835 TL.setNameLoc(ReadSourceLocation(Record, Idx));
John McCall3cb0ebd2010-03-10 03:28:59 +00003836}
Douglas Gregor4714c122010-03-31 17:34:00 +00003837void TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003838 TL.setKeywordLoc(ReadSourceLocation(Record, Idx));
Douglas Gregor2494dd02011-03-01 01:34:45 +00003839 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
Sebastian Redlc3632732010-10-05 15:59:54 +00003840 TL.setNameLoc(ReadSourceLocation(Record, Idx));
John McCall51bd8032009-10-18 01:05:36 +00003841}
John McCall33500952010-06-11 00:33:02 +00003842void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc(
3843 DependentTemplateSpecializationTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003844 TL.setKeywordLoc(ReadSourceLocation(Record, Idx));
Douglas Gregor94fdffa2011-03-01 20:11:18 +00003845 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
Sebastian Redlc3632732010-10-05 15:59:54 +00003846 TL.setNameLoc(ReadSourceLocation(Record, Idx));
3847 TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
3848 TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
John McCall33500952010-06-11 00:33:02 +00003849 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I)
3850 TL.setArgLocInfo(I,
Sebastian Redlc3632732010-10-05 15:59:54 +00003851 Reader.GetTemplateArgumentLocInfo(F,
3852 TL.getTypePtr()->getArg(I).getKind(),
3853 Record, Idx));
John McCall33500952010-06-11 00:33:02 +00003854}
Douglas Gregor7536dd52010-12-20 02:24:11 +00003855void TypeLocReader::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
3856 TL.setEllipsisLoc(ReadSourceLocation(Record, Idx));
3857}
John McCall51bd8032009-10-18 01:05:36 +00003858void TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003859 TL.setNameLoc(ReadSourceLocation(Record, Idx));
John McCallc12c5bb2010-05-15 11:32:37 +00003860}
3861void TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
3862 TL.setHasBaseTypeAsWritten(Record[Idx++]);
Sebastian Redlc3632732010-10-05 15:59:54 +00003863 TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
3864 TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
John McCall51bd8032009-10-18 01:05:36 +00003865 for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
Sebastian Redlc3632732010-10-05 15:59:54 +00003866 TL.setProtocolLoc(i, ReadSourceLocation(Record, Idx));
John McCalla1ee0c52009-10-16 21:56:05 +00003867}
John McCall54e14c42009-10-22 22:37:11 +00003868void TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
Sebastian Redlc3632732010-10-05 15:59:54 +00003869 TL.setStarLoc(ReadSourceLocation(Record, Idx));
John McCall54e14c42009-10-22 22:37:11 +00003870}
John McCalla1ee0c52009-10-16 21:56:05 +00003871
Douglas Gregor72a9ae12011-07-22 16:00:58 +00003872TypeSourceInfo *ASTReader::GetTypeSourceInfo(Module &F,
Sebastian Redl577d4792010-07-22 22:43:28 +00003873 const RecordData &Record,
John McCalla1ee0c52009-10-16 21:56:05 +00003874 unsigned &Idx) {
Douglas Gregor393f2492011-07-22 00:38:23 +00003875 QualType InfoTy = readType(F, Record, Idx);
John McCalla1ee0c52009-10-16 21:56:05 +00003876 if (InfoTy.isNull())
3877 return 0;
3878
John McCalla93c9342009-12-07 02:54:59 +00003879 TypeSourceInfo *TInfo = getContext()->CreateTypeSourceInfo(InfoTy);
Sebastian Redlc3632732010-10-05 15:59:54 +00003880 TypeLocReader TLR(*this, F, Record, Idx);
John McCalla93c9342009-12-07 02:54:59 +00003881 for (TypeLoc TL = TInfo->getTypeLoc(); !TL.isNull(); TL = TL.getNextTypeLoc())
John McCalla1ee0c52009-10-16 21:56:05 +00003882 TLR.Visit(TL);
John McCalla93c9342009-12-07 02:54:59 +00003883 return TInfo;
John McCalla1ee0c52009-10-16 21:56:05 +00003884}
Douglas Gregor2cf26342009-04-09 22:27:44 +00003885
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003886QualType ASTReader::GetType(TypeID ID) {
John McCall0953e762009-09-24 19:53:00 +00003887 unsigned FastQuals = ID & Qualifiers::FastMask;
3888 unsigned Index = ID >> Qualifiers::FastWidth;
Douglas Gregor2cf26342009-04-09 22:27:44 +00003889
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003890 if (Index < NUM_PREDEF_TYPE_IDS) {
Douglas Gregor2cf26342009-04-09 22:27:44 +00003891 QualType T;
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003892 switch ((PredefinedTypeIDs)Index) {
3893 case PREDEF_TYPE_NULL_ID: return QualType();
3894 case PREDEF_TYPE_VOID_ID: T = Context->VoidTy; break;
3895 case PREDEF_TYPE_BOOL_ID: T = Context->BoolTy; break;
Douglas Gregor2cf26342009-04-09 22:27:44 +00003896
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003897 case PREDEF_TYPE_CHAR_U_ID:
3898 case PREDEF_TYPE_CHAR_S_ID:
Douglas Gregor2cf26342009-04-09 22:27:44 +00003899 // FIXME: Check that the signedness of CharTy is correct!
Chris Lattnerd1d64a02009-04-27 21:45:14 +00003900 T = Context->CharTy;
Douglas Gregor2cf26342009-04-09 22:27:44 +00003901 break;
3902
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003903 case PREDEF_TYPE_UCHAR_ID: T = Context->UnsignedCharTy; break;
3904 case PREDEF_TYPE_USHORT_ID: T = Context->UnsignedShortTy; break;
3905 case PREDEF_TYPE_UINT_ID: T = Context->UnsignedIntTy; break;
3906 case PREDEF_TYPE_ULONG_ID: T = Context->UnsignedLongTy; break;
3907 case PREDEF_TYPE_ULONGLONG_ID: T = Context->UnsignedLongLongTy; break;
3908 case PREDEF_TYPE_UINT128_ID: T = Context->UnsignedInt128Ty; break;
3909 case PREDEF_TYPE_SCHAR_ID: T = Context->SignedCharTy; break;
3910 case PREDEF_TYPE_WCHAR_ID: T = Context->WCharTy; break;
3911 case PREDEF_TYPE_SHORT_ID: T = Context->ShortTy; break;
3912 case PREDEF_TYPE_INT_ID: T = Context->IntTy; break;
3913 case PREDEF_TYPE_LONG_ID: T = Context->LongTy; break;
3914 case PREDEF_TYPE_LONGLONG_ID: T = Context->LongLongTy; break;
3915 case PREDEF_TYPE_INT128_ID: T = Context->Int128Ty; break;
3916 case PREDEF_TYPE_FLOAT_ID: T = Context->FloatTy; break;
3917 case PREDEF_TYPE_DOUBLE_ID: T = Context->DoubleTy; break;
3918 case PREDEF_TYPE_LONGDOUBLE_ID: T = Context->LongDoubleTy; break;
3919 case PREDEF_TYPE_OVERLOAD_ID: T = Context->OverloadTy; break;
John McCall864c0412011-04-26 20:42:42 +00003920 case PREDEF_TYPE_BOUND_MEMBER: T = Context->BoundMemberTy; break;
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003921 case PREDEF_TYPE_DEPENDENT_ID: T = Context->DependentTy; break;
John McCall1de4d4e2011-04-07 08:22:57 +00003922 case PREDEF_TYPE_UNKNOWN_ANY: T = Context->UnknownAnyTy; break;
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003923 case PREDEF_TYPE_NULLPTR_ID: T = Context->NullPtrTy; break;
3924 case PREDEF_TYPE_CHAR16_ID: T = Context->Char16Ty; break;
3925 case PREDEF_TYPE_CHAR32_ID: T = Context->Char32Ty; break;
3926 case PREDEF_TYPE_OBJC_ID: T = Context->ObjCBuiltinIdTy; break;
3927 case PREDEF_TYPE_OBJC_CLASS: T = Context->ObjCBuiltinClassTy; break;
3928 case PREDEF_TYPE_OBJC_SEL: T = Context->ObjCBuiltinSelTy; break;
Douglas Gregor2cf26342009-04-09 22:27:44 +00003929 }
3930
3931 assert(!T.isNull() && "Unknown predefined type");
John McCall0953e762009-09-24 19:53:00 +00003932 return T.withFastQualifiers(FastQuals);
Douglas Gregor2cf26342009-04-09 22:27:44 +00003933 }
3934
Sebastian Redl8538e8d2010-08-18 23:57:32 +00003935 Index -= NUM_PREDEF_TYPE_IDS;
Sebastian Redlaaec0aa2010-07-20 22:37:49 +00003936 assert(Index < TypesLoaded.size() && "Type index out-of-range");
Sebastian Redl07a353c2010-07-14 20:26:45 +00003937 if (TypesLoaded[Index].isNull()) {
Douglas Gregor393f2492011-07-22 00:38:23 +00003938 TypesLoaded[Index] = readTypeRecord(Index);
Douglas Gregor97475832010-10-05 18:37:06 +00003939 if (TypesLoaded[Index].isNull())
3940 return QualType();
3941
Sebastian Redl3c7f4132010-08-18 23:57:06 +00003942 TypesLoaded[Index]->setFromAST();
Argyrios Kyrtzidis5d267682010-08-20 16:04:27 +00003943 TypeIdxs[TypesLoaded[Index]] = TypeIdx::fromTypeID(ID);
Sebastian Redl30c514c2010-07-14 23:45:08 +00003944 if (DeserializationListener)
Argyrios Kyrtzidisc8e5d512010-08-20 16:03:59 +00003945 DeserializationListener->TypeRead(TypeIdx::fromTypeID(ID),
Sebastian Redl1476ed42010-07-16 16:36:56 +00003946 TypesLoaded[Index]);
Sebastian Redl07a353c2010-07-14 20:26:45 +00003947 }
Mike Stump1eb44332009-09-09 15:08:12 +00003948
John McCall0953e762009-09-24 19:53:00 +00003949 return TypesLoaded[Index].withFastQualifiers(FastQuals);
Douglas Gregor2cf26342009-04-09 22:27:44 +00003950}
3951
Douglas Gregor72a9ae12011-07-22 16:00:58 +00003952QualType ASTReader::getLocalType(Module &F, unsigned LocalID) {
Douglas Gregor393f2492011-07-22 00:38:23 +00003953 return GetType(getGlobalTypeID(F, LocalID));
3954}
3955
3956serialization::TypeID
Douglas Gregor72a9ae12011-07-22 16:00:58 +00003957ASTReader::getGlobalTypeID(Module &F, unsigned LocalID) const {
Douglas Gregor393f2492011-07-22 00:38:23 +00003958 // FIXME: Map from local type ID to global type ID.
3959 return LocalID;
3960}
3961
Argyrios Kyrtzidis5d267682010-08-20 16:04:27 +00003962TypeID ASTReader::GetTypeID(QualType T) const {
3963 return MakeTypeID(T,
3964 std::bind1st(std::mem_fun(&ASTReader::GetTypeIdx), this));
3965}
3966
3967TypeIdx ASTReader::GetTypeIdx(QualType T) const {
3968 if (T.isNull())
3969 return TypeIdx();
3970 assert(!T.getLocalFastQualifiers());
3971
3972 TypeIdxMap::const_iterator I = TypeIdxs.find(T);
3973 // GetTypeIdx is mostly used for computing the hash of DeclarationNames and
3974 // comparing keys of ASTDeclContextNameLookupTable.
3975 // If the type didn't come from the AST file use a specially marked index
3976 // so that any hash/key comparison fail since no such index is stored
3977 // in a AST file.
3978 if (I == TypeIdxs.end())
3979 return TypeIdx(-1);
3980 return I->second;
3981}
3982
John McCall833ca992009-10-29 08:12:44 +00003983TemplateArgumentLocInfo
Douglas Gregor72a9ae12011-07-22 16:00:58 +00003984ASTReader::GetTemplateArgumentLocInfo(Module &F,
Sebastian Redlc3632732010-10-05 15:59:54 +00003985 TemplateArgument::ArgKind Kind,
John McCall833ca992009-10-29 08:12:44 +00003986 const RecordData &Record,
Argyrios Kyrtzidis919e6932010-06-28 22:28:35 +00003987 unsigned &Index) {
John McCall833ca992009-10-29 08:12:44 +00003988 switch (Kind) {
3989 case TemplateArgument::Expression:
Sebastian Redlc3632732010-10-05 15:59:54 +00003990 return ReadExpr(F);
John McCall833ca992009-10-29 08:12:44 +00003991 case TemplateArgument::Type:
Sebastian Redlc3632732010-10-05 15:59:54 +00003992 return GetTypeSourceInfo(F, Record, Index);
Douglas Gregor788cd062009-11-11 01:00:40 +00003993 case TemplateArgument::Template: {
Douglas Gregorb6744ef2011-03-02 17:09:35 +00003994 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
3995 Index);
Sebastian Redlc3632732010-10-05 15:59:54 +00003996 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
Douglas Gregorb6744ef2011-03-02 17:09:35 +00003997 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
Douglas Gregora7fc9012011-01-05 18:58:31 +00003998 SourceLocation());
3999 }
4000 case TemplateArgument::TemplateExpansion: {
Douglas Gregorb6744ef2011-03-02 17:09:35 +00004001 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
4002 Index);
Douglas Gregora7fc9012011-01-05 18:58:31 +00004003 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
Douglas Gregorba68eca2011-01-05 17:40:24 +00004004 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Index);
Douglas Gregorb6744ef2011-03-02 17:09:35 +00004005 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
Douglas Gregorba68eca2011-01-05 17:40:24 +00004006 EllipsisLoc);
Douglas Gregor788cd062009-11-11 01:00:40 +00004007 }
John McCall833ca992009-10-29 08:12:44 +00004008 case TemplateArgument::Null:
4009 case TemplateArgument::Integral:
4010 case TemplateArgument::Declaration:
4011 case TemplateArgument::Pack:
4012 return TemplateArgumentLocInfo();
4013 }
Jeffrey Yasskin9f61aa92009-12-12 05:05:38 +00004014 llvm_unreachable("unexpected template argument loc");
John McCall833ca992009-10-29 08:12:44 +00004015 return TemplateArgumentLocInfo();
4016}
4017
Argyrios Kyrtzidis17cfded2010-06-28 09:31:42 +00004018TemplateArgumentLoc
Douglas Gregor72a9ae12011-07-22 16:00:58 +00004019ASTReader::ReadTemplateArgumentLoc(Module &F,
Sebastian Redl577d4792010-07-22 22:43:28 +00004020 const RecordData &Record, unsigned &Index) {
Sebastian Redlc3632732010-10-05 15:59:54 +00004021 TemplateArgument Arg = ReadTemplateArgument(F, Record, Index);
Argyrios Kyrtzidis17cfded2010-06-28 09:31:42 +00004022
4023 if (Arg.getKind() == TemplateArgument::Expression) {
4024 if (Record[Index++]) // bool InfoHasSameExpr.
4025 return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo(Arg.getAsExpr()));
4026 }
Sebastian Redlc3632732010-10-05 15:59:54 +00004027 return TemplateArgumentLoc(Arg, GetTemplateArgumentLocInfo(F, Arg.getKind(),
Argyrios Kyrtzidis919e6932010-06-28 22:28:35 +00004028 Record, Index));
Argyrios Kyrtzidis44f8c372010-06-22 09:54:59 +00004029}
4030
Sebastian Redlc43b54c2010-08-18 23:56:43 +00004031Decl *ASTReader::GetExternalDecl(uint32_t ID) {
John McCall76bd1f32010-06-01 09:23:16 +00004032 return GetDecl(ID);
4033}
4034
Douglas Gregor7c789c12010-10-29 22:39:52 +00004035uint64_t
4036ASTReader::GetCXXBaseSpecifiersOffset(serialization::CXXBaseSpecifiersID ID) {
4037 if (ID == 0)
4038 return 0;
Anders Carlssonf25330b2011-03-09 05:09:32 +00004039
Jonathan D. Turner1da90142011-07-21 21:15:19 +00004040 GlobalCXXBaseSpecifiersMapType::iterator I =
4041 GlobalCXXBaseSpecifiersMap.find(ID);
4042
4043 assert (I != GlobalCXXBaseSpecifiersMap.end() &&
4044 "Corrupted global CXX base specifiers map");
Douglas Gregor7c789c12010-10-29 22:39:52 +00004045
Douglas Gregor9827a802011-07-29 00:56:45 +00004046 Module *M = I->second;
4047 return M->CXXBaseSpecifiersOffsets[ID - 1 - M->BaseCXXBaseSpecifiersID] +
4048 M->GlobalBitOffset;
Douglas Gregor7c789c12010-10-29 22:39:52 +00004049}
4050
4051CXXBaseSpecifier *ASTReader::GetExternalCXXBaseSpecifiers(uint64_t Offset) {
Douglas Gregor8f1231b2011-07-22 06:10:01 +00004052 RecordLocation Loc = getLocalBitOffset(Offset);
4053 llvm::BitstreamCursor &Cursor = Loc.F->DeclsCursor;
Douglas Gregor7c789c12010-10-29 22:39:52 +00004054 SavedStreamPosition SavedPosition(Cursor);
Douglas Gregor8f1231b2011-07-22 06:10:01 +00004055 Cursor.JumpToBit(Loc.Offset);
Douglas Gregor7c789c12010-10-29 22:39:52 +00004056 ReadingKindTracker ReadingKind(Read_Decl, *this);
4057 RecordData Record;
4058 unsigned Code = Cursor.ReadCode();
4059 unsigned RecCode = Cursor.ReadRecord(Code, Record);
4060 if (RecCode != DECL_CXX_BASE_SPECIFIERS) {
4061 Error("Malformed AST file: missing C++ base specifiers");
4062 return 0;
4063 }
4064
4065 unsigned Idx = 0;
4066 unsigned NumBases = Record[Idx++];
4067 void *Mem = Context->Allocate(sizeof(CXXBaseSpecifier) * NumBases);
4068 CXXBaseSpecifier *Bases = new (Mem) CXXBaseSpecifier [NumBases];
4069 for (unsigned I = 0; I != NumBases; ++I)
Douglas Gregor8f1231b2011-07-22 06:10:01 +00004070 Bases[I] = ReadCXXBaseSpecifier(*Loc.F, Record, Idx);
Douglas Gregor7c789c12010-10-29 22:39:52 +00004071 return Bases;
4072}
4073
Sebastian Redlc43b54c2010-08-18 23:56:43 +00004074TranslationUnitDecl *ASTReader::GetTranslationUnitDecl() {
Sebastian Redl30c514c2010-07-14 23:45:08 +00004075 if (!DeclsLoaded[0]) {
Sebastian Redle1dde812010-08-24 00:50:04 +00004076 ReadDeclRecord(0, 1);
Sebastian Redl30c514c2010-07-14 23:45:08 +00004077 if (DeserializationListener)
Sebastian Redl1476ed42010-07-16 16:36:56 +00004078 DeserializationListener->DeclRead(1, DeclsLoaded[0]);
Sebastian Redl30c514c2010-07-14 23:45:08 +00004079 }
Argyrios Kyrtzidis8871a442010-07-08 17:13:02 +00004080
4081 return cast<TranslationUnitDecl>(DeclsLoaded[0]);
4082}
4083
Douglas Gregor409448c2011-07-21 22:35:25 +00004084serialization::DeclID
Douglas Gregor72a9ae12011-07-22 16:00:58 +00004085ASTReader::getGlobalDeclID(Module &F, unsigned LocalID) const {
Douglas Gregor409448c2011-07-21 22:35:25 +00004086 // FIXME: Perform local -> global remapping for declarations.
4087 return LocalID;
4088}
4089
Sebastian Redl8538e8d2010-08-18 23:57:32 +00004090Decl *ASTReader::GetDecl(DeclID ID) {
Douglas Gregor2cf26342009-04-09 22:27:44 +00004091 if (ID == 0)
4092 return 0;
4093
Douglas Gregor8f5dc7f2009-04-25 18:35:21 +00004094 if (ID > DeclsLoaded.size()) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00004095 Error("declaration ID out-of-range for AST file");
Douglas Gregor8f5dc7f2009-04-25 18:35:21 +00004096 return 0;
4097 }
Douglas Gregor2cf26342009-04-09 22:27:44 +00004098
Douglas Gregor8f5dc7f2009-04-25 18:35:21 +00004099 unsigned Index = ID - 1;
Sebastian Redl30c514c2010-07-14 23:45:08 +00004100 if (!DeclsLoaded[Index]) {
Argyrios Kyrtzidisa8650052010-08-03 17:30:10 +00004101 ReadDeclRecord(Index, ID);
Sebastian Redl30c514c2010-07-14 23:45:08 +00004102 if (DeserializationListener)
4103 DeserializationListener->DeclRead(ID, DeclsLoaded[Index]);
4104 }
Douglas Gregor8f5dc7f2009-04-25 18:35:21 +00004105
4106 return DeclsLoaded[Index];
Douglas Gregor2cf26342009-04-09 22:27:44 +00004107}
4108
Douglas Gregor72a9ae12011-07-22 16:00:58 +00004109serialization::DeclID ASTReader::ReadDeclID(Module &F,
Douglas Gregor409448c2011-07-21 22:35:25 +00004110 const RecordData &Record,
4111 unsigned &Idx) {
4112 if (Idx >= Record.size()) {
4113 Error("Corrupted AST file");
4114 return 0;
4115 }
4116
4117 return getGlobalDeclID(F, Record[Idx++]);
4118}
4119
Chris Lattner887e2b32009-04-27 05:46:25 +00004120/// \brief Resolve the offset of a statement into a statement.
4121///
4122/// This operation will read a new statement from the external
4123/// source each time it is called, and is meant to be used via a
4124/// LazyOffsetPtr (which is used by Decls for the body of functions, etc).
Sebastian Redlc43b54c2010-08-18 23:56:43 +00004125Stmt *ASTReader::GetExternalDeclStmt(uint64_t Offset) {
Argyrios Kyrtzidise09a2752010-10-28 09:29:32 +00004126 // Switch case IDs are per Decl.
4127 ClearSwitchCaseIDs();
4128
Sebastian Redl0fa7d0b2010-07-22 17:01:13 +00004129 // Offset here is a global offset across the entire chain.
Douglas Gregor8f1231b2011-07-22 06:10:01 +00004130 RecordLocation Loc = getLocalBitOffset(Offset);
4131 Loc.F->DeclsCursor.JumpToBit(Loc.Offset);
4132 return ReadStmtFromStream(*Loc.F);
Douglas Gregor250fc9c2009-04-18 00:07:54 +00004133}
4134
Douglas Gregorba6ffaf2011-07-15 21:46:17 +00004135ExternalLoadResult ASTReader::FindExternalLexicalDecls(const DeclContext *DC,
Argyrios Kyrtzidiseb5e9982010-10-14 20:14:34 +00004136 bool (*isKindWeWant)(Decl::Kind),
Chris Lattner5f9e2722011-07-23 10:55:15 +00004137 SmallVectorImpl<Decl*> &Decls) {
Sebastian Redl0fa7d0b2010-07-22 17:01:13 +00004138 // There might be lexical decls in multiple parts of the chain, for the TU
4139 // at least.
Sebastian Redl4a9eb262010-09-28 02:24:44 +00004140 // DeclContextOffsets might reallocate as we load additional decls below,
4141 // so make a copy of the vector.
4142 DeclContextInfos Infos = DeclContextOffsets[DC];
Sebastian Redl0fa7d0b2010-07-22 17:01:13 +00004143 for (DeclContextInfos::iterator I = Infos.begin(), E = Infos.end();
4144 I != E; ++I) {
Sebastian Redl681d7232010-07-27 00:17:23 +00004145 // IDs can be 0 if this context doesn't contain declarations.
4146 if (!I->LexicalDecls)
Sebastian Redl0fa7d0b2010-07-22 17:01:13 +00004147 continue;
Sebastian Redl0fa7d0b2010-07-22 17:01:13 +00004148
4149 // Load all of the declaration IDs
Argyrios Kyrtzidiseb5e9982010-10-14 20:14:34 +00004150 for (const KindDeclIDPair *ID = I->LexicalDecls,
4151 *IDE = ID + I->NumLexicalDecls; ID != IDE; ++ID) {
4152 if (isKindWeWant && !isKindWeWant((Decl::Kind)ID->first))
4153 continue;
Douglas Gregor409448c2011-07-21 22:35:25 +00004154
Douglas Gregorf5bb9ae2011-07-21 23:29:11 +00004155 Decl *D = GetLocalDecl(*I->F, ID->second);
Sebastian Redl4a9eb262010-09-28 02:24:44 +00004156 assert(D && "Null decl in lexical decls");
4157 Decls.push_back(D);
4158 }
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00004159 }
Douglas Gregor2cf26342009-04-09 22:27:44 +00004160
Douglas Gregor25123082009-04-22 22:34:57 +00004161 ++NumLexicalDeclContextsRead;
Douglas Gregorba6ffaf2011-07-15 21:46:17 +00004162 return ELR_Success;
Douglas Gregor2cf26342009-04-09 22:27:44 +00004163}
4164
John McCall76bd1f32010-06-01 09:23:16 +00004165DeclContext::lookup_result
Sebastian Redlc43b54c2010-08-18 23:56:43 +00004166ASTReader::FindExternalVisibleDeclsByName(const DeclContext *DC,
John McCall76bd1f32010-06-01 09:23:16 +00004167 DeclarationName Name) {
Mike Stump1eb44332009-09-09 15:08:12 +00004168 assert(DC->hasExternalVisibleStorage() &&
Douglas Gregor2cf26342009-04-09 22:27:44 +00004169 "DeclContext has no visible decls in storage");
Argyrios Kyrtzidis074dcc82010-08-20 16:04:35 +00004170 if (!Name)
4171 return DeclContext::lookup_result(DeclContext::lookup_iterator(0),
4172 DeclContext::lookup_iterator(0));
Ted Kremenekd5d7b3f2010-03-18 00:56:54 +00004173
Chris Lattner5f9e2722011-07-23 10:55:15 +00004174 SmallVector<NamedDecl *, 64> Decls;
Sebastian Redl8b122732010-08-24 00:49:55 +00004175 // There might be visible decls in multiple parts of the chain, for the TU
Sebastian Redl5967d622010-08-24 00:50:16 +00004176 // and namespaces. For any given name, the last available results replace
4177 // all earlier ones. For this reason, we walk in reverse.
Sebastian Redl0fa7d0b2010-07-22 17:01:13 +00004178 DeclContextInfos &Infos = DeclContextOffsets[DC];
Sebastian Redl5967d622010-08-24 00:50:16 +00004179 for (DeclContextInfos::reverse_iterator I = Infos.rbegin(), E = Infos.rend();
Sebastian Redl0fa7d0b2010-07-22 17:01:13 +00004180 I != E; ++I) {
Argyrios Kyrtzidis074dcc82010-08-20 16:04:35 +00004181 if (!I->NameLookupTableData)
Sebastian Redl0fa7d0b2010-07-22 17:01:13 +00004182 continue;
Douglas Gregor2cf26342009-04-09 22:27:44 +00004183
Argyrios Kyrtzidis074dcc82010-08-20 16:04:35 +00004184 ASTDeclContextNameLookupTable *LookupTable =
4185 (ASTDeclContextNameLookupTable*)I->NameLookupTableData;
4186 ASTDeclContextNameLookupTable::iterator Pos = LookupTable->find(Name);
4187 if (Pos == LookupTable->end())
Sebastian Redl0fa7d0b2010-07-22 17:01:13 +00004188 continue;
4189
Argyrios Kyrtzidis074dcc82010-08-20 16:04:35 +00004190 ASTDeclContextNameLookupTrait::data_type Data = *Pos;
4191 for (; Data.first != Data.second; ++Data.first)
Douglas Gregorf5bb9ae2011-07-21 23:29:11 +00004192 Decls.push_back(GetLocalDeclAs<NamedDecl>(*I->F, *Data.first));
Sebastian Redl5967d622010-08-24 00:50:16 +00004193 break;
Douglas Gregor2cf26342009-04-09 22:27:44 +00004194 }
4195
Douglas Gregor25123082009-04-22 22:34:57 +00004196 ++NumVisibleDeclContextsRead;
John McCall76bd1f32010-06-01 09:23:16 +00004197
Argyrios Kyrtzidis074dcc82010-08-20 16:04:35 +00004198 SetExternalVisibleDeclsForName(DC, Name, Decls);
John McCall76bd1f32010-06-01 09:23:16 +00004199 return const_cast<DeclContext*>(DC)->lookup(Name);
Douglas Gregor2cf26342009-04-09 22:27:44 +00004200}
4201
Argyrios Kyrtzidisa60786b2010-08-20 23:35:55 +00004202void ASTReader::MaterializeVisibleDecls(const DeclContext *DC) {
4203 assert(DC->hasExternalVisibleStorage() &&
4204 "DeclContext has no visible decls in storage");
4205
Chris Lattner5f9e2722011-07-23 10:55:15 +00004206 SmallVector<NamedDecl *, 64> Decls;
Argyrios Kyrtzidisa60786b2010-08-20 23:35:55 +00004207 // There might be visible decls in multiple parts of the chain, for the TU
4208 // and namespaces.
4209 DeclContextInfos &Infos = DeclContextOffsets[DC];
4210 for (DeclContextInfos::iterator I = Infos.begin(), E = Infos.end();
4211 I != E; ++I) {
4212 if (!I->NameLookupTableData)
4213 continue;
4214
4215 ASTDeclContextNameLookupTable *LookupTable =
4216 (ASTDeclContextNameLookupTable*)I->NameLookupTableData;
4217 for (ASTDeclContextNameLookupTable::item_iterator
4218 ItemI = LookupTable->item_begin(),
4219 ItemEnd = LookupTable->item_end() ; ItemI != ItemEnd; ++ItemI) {
4220 ASTDeclContextNameLookupTable::item_iterator::value_type Val
4221 = *ItemI;
4222 ASTDeclContextNameLookupTrait::data_type Data = Val.second;
4223 Decls.clear();
4224 for (; Data.first != Data.second; ++Data.first)
Douglas Gregorf5bb9ae2011-07-21 23:29:11 +00004225 Decls.push_back(GetLocalDeclAs<NamedDecl>(*I->F, *Data.first));
Argyrios Kyrtzidisa60786b2010-08-20 23:35:55 +00004226 MaterializeVisibleDeclsForName(DC, Val.first, Decls);
4227 }
4228 }
4229}
4230
Sebastian Redlc43b54c2010-08-18 23:56:43 +00004231void ASTReader::PassInterestingDeclsToConsumer() {
Argyrios Kyrtzidisbb80a8e2010-07-07 15:46:26 +00004232 assert(Consumer);
4233 while (!InterestingDecls.empty()) {
4234 DeclGroupRef DG(InterestingDecls.front());
4235 InterestingDecls.pop_front();
Sebastian Redl27372b42010-08-11 18:52:41 +00004236 Consumer->HandleInterestingDecl(DG);
Argyrios Kyrtzidisbb80a8e2010-07-07 15:46:26 +00004237 }
4238}
4239
Sebastian Redlc43b54c2010-08-18 23:56:43 +00004240void ASTReader::StartTranslationUnit(ASTConsumer *Consumer) {
Douglas Gregor0af2ca42009-04-22 19:09:20 +00004241 this->Consumer = Consumer;
4242
Douglas Gregorfdd01722009-04-14 00:24:19 +00004243 if (!Consumer)
4244 return;
4245
4246 for (unsigned I = 0, N = ExternalDefinitions.size(); I != N; ++I) {
Argyrios Kyrtzidisbb80a8e2010-07-07 15:46:26 +00004247 // Force deserialization of this decl, which will cause it to be queued for
4248 // passing to the consumer.
Daniel Dunbar04a0b502009-09-17 03:06:44 +00004249 GetDecl(ExternalDefinitions[I]);
Douglas Gregorfdd01722009-04-14 00:24:19 +00004250 }
Douglas Gregorc62a2fe2009-04-25 00:41:30 +00004251
Argyrios Kyrtzidisbb80a8e2010-07-07 15:46:26 +00004252 PassInterestingDeclsToConsumer();
Douglas Gregorfdd01722009-04-14 00:24:19 +00004253}
4254
Sebastian Redlc43b54c2010-08-18 23:56:43 +00004255void ASTReader::PrintStats() {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00004256 std::fprintf(stderr, "*** AST File Statistics:\n");
Douglas Gregor2cf26342009-04-09 22:27:44 +00004257
Mike Stump1eb44332009-09-09 15:08:12 +00004258 unsigned NumTypesLoaded
Douglas Gregor2b3a5a82009-04-25 19:10:14 +00004259 = TypesLoaded.size() - std::count(TypesLoaded.begin(), TypesLoaded.end(),
John McCall0953e762009-09-24 19:53:00 +00004260 QualType());
Douglas Gregor2b3a5a82009-04-25 19:10:14 +00004261 unsigned NumDeclsLoaded
4262 = DeclsLoaded.size() - std::count(DeclsLoaded.begin(), DeclsLoaded.end(),
4263 (Decl *)0);
4264 unsigned NumIdentifiersLoaded
4265 = IdentifiersLoaded.size() - std::count(IdentifiersLoaded.begin(),
4266 IdentifiersLoaded.end(),
4267 (IdentifierInfo *)0);
Mike Stump1eb44332009-09-09 15:08:12 +00004268 unsigned NumSelectorsLoaded
Douglas Gregor2b3a5a82009-04-25 19:10:14 +00004269 = SelectorsLoaded.size() - std::count(SelectorsLoaded.begin(),
4270 SelectorsLoaded.end(),
4271 Selector());
Douglas Gregor2d41cc12009-04-13 20:50:16 +00004272
Douglas Gregor4fed3f42009-04-27 18:38:38 +00004273 std::fprintf(stderr, " %u stat cache hits\n", NumStatHits);
4274 std::fprintf(stderr, " %u stat cache misses\n", NumStatMisses);
Douglas Gregor0cdd7982011-07-21 18:46:38 +00004275 if (unsigned TotalNumSLocEntries = getTotalNumSLocs())
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00004276 std::fprintf(stderr, " %u/%u source location entries read (%f%%)\n",
4277 NumSLocEntriesRead, TotalNumSLocEntries,
4278 ((float)NumSLocEntriesRead/TotalNumSLocEntries * 100));
Douglas Gregor8f5dc7f2009-04-25 18:35:21 +00004279 if (!TypesLoaded.empty())
Douglas Gregor83941df2009-04-25 17:48:32 +00004280 std::fprintf(stderr, " %u/%u types read (%f%%)\n",
Douglas Gregor8f5dc7f2009-04-25 18:35:21 +00004281 NumTypesLoaded, (unsigned)TypesLoaded.size(),
4282 ((float)NumTypesLoaded/TypesLoaded.size() * 100));
4283 if (!DeclsLoaded.empty())
Douglas Gregor83941df2009-04-25 17:48:32 +00004284 std::fprintf(stderr, " %u/%u declarations read (%f%%)\n",
Douglas Gregor8f5dc7f2009-04-25 18:35:21 +00004285 NumDeclsLoaded, (unsigned)DeclsLoaded.size(),
4286 ((float)NumDeclsLoaded/DeclsLoaded.size() * 100));
Douglas Gregor2b3a5a82009-04-25 19:10:14 +00004287 if (!IdentifiersLoaded.empty())
Douglas Gregor83941df2009-04-25 17:48:32 +00004288 std::fprintf(stderr, " %u/%u identifiers read (%f%%)\n",
Douglas Gregor2b3a5a82009-04-25 19:10:14 +00004289 NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(),
4290 ((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100));
Sebastian Redl725cd962010-08-04 20:40:17 +00004291 if (!SelectorsLoaded.empty())
Douglas Gregor83941df2009-04-25 17:48:32 +00004292 std::fprintf(stderr, " %u/%u selectors read (%f%%)\n",
Sebastian Redl725cd962010-08-04 20:40:17 +00004293 NumSelectorsLoaded, (unsigned)SelectorsLoaded.size(),
4294 ((float)NumSelectorsLoaded/SelectorsLoaded.size() * 100));
Douglas Gregor83941df2009-04-25 17:48:32 +00004295 if (TotalNumStatements)
4296 std::fprintf(stderr, " %u/%u statements read (%f%%)\n",
4297 NumStatementsRead, TotalNumStatements,
4298 ((float)NumStatementsRead/TotalNumStatements * 100));
4299 if (TotalNumMacros)
4300 std::fprintf(stderr, " %u/%u macros read (%f%%)\n",
4301 NumMacrosRead, TotalNumMacros,
4302 ((float)NumMacrosRead/TotalNumMacros * 100));
4303 if (TotalLexicalDeclContexts)
4304 std::fprintf(stderr, " %u/%u lexical declcontexts read (%f%%)\n",
4305 NumLexicalDeclContextsRead, TotalLexicalDeclContexts,
4306 ((float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts
4307 * 100));
4308 if (TotalVisibleDeclContexts)
4309 std::fprintf(stderr, " %u/%u visible declcontexts read (%f%%)\n",
4310 NumVisibleDeclContextsRead, TotalVisibleDeclContexts,
4311 ((float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts
4312 * 100));
Sebastian Redlfa78dec2010-08-04 21:22:45 +00004313 if (TotalNumMethodPoolEntries) {
Douglas Gregor83941df2009-04-25 17:48:32 +00004314 std::fprintf(stderr, " %u/%u method pool entries read (%f%%)\n",
Sebastian Redlfa78dec2010-08-04 21:22:45 +00004315 NumMethodPoolEntriesRead, TotalNumMethodPoolEntries,
4316 ((float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries
Douglas Gregor83941df2009-04-25 17:48:32 +00004317 * 100));
Sebastian Redlfa78dec2010-08-04 21:22:45 +00004318 std::fprintf(stderr, " %u method pool misses\n", NumMethodPoolMisses);
Douglas Gregor83941df2009-04-25 17:48:32 +00004319 }
Douglas Gregor2cf26342009-04-09 22:27:44 +00004320 std::fprintf(stderr, "\n");
Douglas Gregor23d7df52011-07-21 19:50:14 +00004321 dump();
4322 std::fprintf(stderr, "\n");
4323}
4324
Douglas Gregor72a9ae12011-07-22 16:00:58 +00004325template<typename Key, typename Module, unsigned InitialCapacity>
Douglas Gregor23d7df52011-07-21 19:50:14 +00004326static void
Chris Lattner5f9e2722011-07-23 10:55:15 +00004327dumpModuleIDMap(StringRef Name,
Douglas Gregor72a9ae12011-07-22 16:00:58 +00004328 const ContinuousRangeMap<Key, Module *,
Douglas Gregor23d7df52011-07-21 19:50:14 +00004329 InitialCapacity> &Map) {
4330 if (Map.begin() == Map.end())
4331 return;
4332
Douglas Gregor72a9ae12011-07-22 16:00:58 +00004333 typedef ContinuousRangeMap<Key, Module *, InitialCapacity> MapType;
Douglas Gregor23d7df52011-07-21 19:50:14 +00004334 llvm::errs() << Name << ":\n";
4335 for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end();
4336 I != IEnd; ++I) {
4337 llvm::errs() << " " << I->first << " -> " << I->second->FileName
4338 << "\n";
4339 }
4340}
4341
Douglas Gregor72a9ae12011-07-22 16:00:58 +00004342template<typename Key, typename Module, typename Adjustment,
Douglas Gregor23d7df52011-07-21 19:50:14 +00004343 unsigned InitialCapacity>
4344static void
Chris Lattner5f9e2722011-07-23 10:55:15 +00004345dumpModuleIDOffsetMap(StringRef Name,
Douglas Gregor23d7df52011-07-21 19:50:14 +00004346 const ContinuousRangeMap<Key,
Douglas Gregor72a9ae12011-07-22 16:00:58 +00004347 std::pair<Module *,
Douglas Gregor23d7df52011-07-21 19:50:14 +00004348 Adjustment>,
4349 InitialCapacity> &Map) {
4350 if (Map.begin() == Map.end())
4351 return;
4352
Douglas Gregor72a9ae12011-07-22 16:00:58 +00004353 typedef ContinuousRangeMap<Key, std::pair<Module *, Adjustment>,
Douglas Gregor23d7df52011-07-21 19:50:14 +00004354 InitialCapacity> MapType;
4355 llvm::errs() << Name << ":\n";
4356 for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end();
4357 I != IEnd; ++I) {
4358 llvm::errs() << " " << I->first << " -> (" << I->second.first->FileName
4359 << ", " << I->second.second << ")\n";
4360 }
4361}
4362
4363void ASTReader::dump() {
4364 llvm::errs() << "*** AST File Remapping:\n";
Douglas Gregor8f1231b2011-07-22 06:10:01 +00004365 dumpModuleIDMap("Global bit offset map", GlobalBitOffsetsMap);
Douglas Gregor23d7df52011-07-21 19:50:14 +00004366 dumpModuleIDMap("Global source location entry map", GlobalSLocEntryMap);
Douglas Gregor1e849b62011-07-29 00:21:44 +00004367 dumpModuleIDMap("Global type map", GlobalTypeMap);
Douglas Gregor9827a802011-07-29 00:56:45 +00004368 dumpModuleIDMap("Global declaration map", GlobalDeclMap);
4369 dumpModuleIDMap("Global C++ base specifiers map", GlobalCXXBaseSpecifiersMap);
4370 dumpModuleIDMap("Global identifier map", GlobalIdentifierMap);
4371 dumpModuleIDMap("Global selector map", GlobalSelectorMap);
4372 dumpModuleIDMap("Global macro definition map", GlobalMacroDefinitionMap);
4373 dumpModuleIDMap("Global preprocessed entity map",
4374 GlobalPreprocessedEntityMap);
Douglas Gregor2cf26342009-04-09 22:27:44 +00004375}
4376
Ted Kremeneke9b5f3d2011-04-28 23:46:20 +00004377/// Return the amount of memory used by memory buffers, breaking down
4378/// by heap-backed versus mmap'ed memory.
4379void ASTReader::getMemoryBufferSizes(MemoryBufferSizes &sizes) const {
Jonathan D. Turner5d6d89f2011-07-25 20:32:21 +00004380 for (ModuleConstIterator I = ModuleMgr.begin(),
4381 E = ModuleMgr.end(); I != E; ++I) {
4382 if (llvm::MemoryBuffer *buf = (*I)->Buffer.get()) {
Ted Kremeneke9b5f3d2011-04-28 23:46:20 +00004383 size_t bytes = buf->getBufferSize();
4384 switch (buf->getBufferKind()) {
4385 case llvm::MemoryBuffer::MemoryBuffer_Malloc:
4386 sizes.malloc_bytes += bytes;
4387 break;
4388 case llvm::MemoryBuffer::MemoryBuffer_MMap:
4389 sizes.mmap_bytes += bytes;
4390 break;
4391 }
4392 }
Jonathan D. Turner5d6d89f2011-07-25 20:32:21 +00004393 }
Ted Kremeneke9b5f3d2011-04-28 23:46:20 +00004394}
4395
Sebastian Redlc43b54c2010-08-18 23:56:43 +00004396void ASTReader::InitializeSema(Sema &S) {
Douglas Gregor668c1a42009-04-21 22:25:48 +00004397 SemaObj = &S;
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +00004398 S.ExternalSource = this;
4399
Douglas Gregor6cfc1a82009-04-22 21:15:06 +00004400 // Makes sure any declarations that were deserialized "too early"
4401 // still get added to the identifier's declaration chains.
Douglas Gregor76dc8892010-09-24 23:29:12 +00004402 for (unsigned I = 0, N = PreloadedDecls.size(); I != N; ++I) {
4403 if (SemaObj->TUScope)
John McCalld226f652010-08-21 09:40:31 +00004404 SemaObj->TUScope->AddDecl(PreloadedDecls[I]);
Douglas Gregor76dc8892010-09-24 23:29:12 +00004405
4406 SemaObj->IdResolver.AddDecl(PreloadedDecls[I]);
Douglas Gregor668c1a42009-04-21 22:25:48 +00004407 }
Douglas Gregor6cfc1a82009-04-22 21:15:06 +00004408 PreloadedDecls.clear();
Douglas Gregor4c0e86b2009-04-22 22:02:47 +00004409
Argyrios Kyrtzidis76c38d32010-08-02 07:14:54 +00004410 // Load the offsets of the declarations that Sema references.
4411 // They will be lazily deserialized when needed.
4412 if (!SemaDeclRefs.empty()) {
4413 assert(SemaDeclRefs.size() == 2 && "More decl refs than expected!");
Douglas Gregor1e5b6f62011-07-28 00:57:24 +00004414 if (!SemaObj->StdNamespace)
4415 SemaObj->StdNamespace = SemaDeclRefs[0];
4416 if (!SemaObj->StdBadAlloc)
4417 SemaObj->StdBadAlloc = SemaDeclRefs[1];
Argyrios Kyrtzidis76c38d32010-08-02 07:14:54 +00004418 }
4419
Peter Collingbourne84bccea2011-02-15 19:46:30 +00004420 if (!FPPragmaOptions.empty()) {
4421 assert(FPPragmaOptions.size() == 1 && "Wrong number of FP_PRAGMA_OPTIONS");
4422 SemaObj->FPFeatures.fp_contract = FPPragmaOptions[0];
4423 }
4424
4425 if (!OpenCLExtensions.empty()) {
4426 unsigned I = 0;
4427#define OPENCLEXT(nm) SemaObj->OpenCLFeatures.nm = OpenCLExtensions[I++];
4428#include "clang/Basic/OpenCLExtensions.def"
4429
4430 assert(OpenCLExtensions.size() == I && "Wrong number of OPENCL_EXTENSIONS");
4431 }
Douglas Gregor668c1a42009-04-21 22:25:48 +00004432}
4433
Sebastian Redlc43b54c2010-08-18 23:56:43 +00004434IdentifierInfo* ASTReader::get(const char *NameStart, const char *NameEnd) {
Sebastian Redld8c5abb2010-08-02 18:30:12 +00004435 // Try to find this name within our on-disk hash tables. We start with the
4436 // most recent one, since that one contains the most up-to-date info.
Jonathan D. Turner5d6d89f2011-07-25 20:32:21 +00004437 for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00004438 ASTIdentifierLookupTable *IdTable
Jonathan D. Turner5d6d89f2011-07-25 20:32:21 +00004439 = (ASTIdentifierLookupTable *)(*I)->IdentifierLookupTable;
Sebastian Redl0fa7d0b2010-07-22 17:01:13 +00004440 if (!IdTable)
4441 continue;
Sebastian Redld27d3fc2010-07-21 22:31:37 +00004442 std::pair<const char*, unsigned> Key(NameStart, NameEnd - NameStart);
Sebastian Redl3c7f4132010-08-18 23:57:06 +00004443 ASTIdentifierLookupTable::iterator Pos = IdTable->find(Key);
Sebastian Redld27d3fc2010-07-21 22:31:37 +00004444 if (Pos == IdTable->end())
4445 continue;
Douglas Gregor668c1a42009-04-21 22:25:48 +00004446
Sebastian Redld27d3fc2010-07-21 22:31:37 +00004447 // Dereferencing the iterator has the effect of building the
4448 // IdentifierInfo node and populating it with the various
4449 // declarations it needs.
Sebastian Redld8c5abb2010-08-02 18:30:12 +00004450 return *Pos;
Sebastian Redld27d3fc2010-07-21 22:31:37 +00004451 }
Sebastian Redld8c5abb2010-08-02 18:30:12 +00004452 return 0;
Douglas Gregor668c1a42009-04-21 22:25:48 +00004453}
4454
Douglas Gregor95f42922010-10-14 22:11:03 +00004455namespace clang {
4456 /// \brief An identifier-lookup iterator that enumerates all of the
4457 /// identifiers stored within a set of AST files.
4458 class ASTIdentifierIterator : public IdentifierIterator {
4459 /// \brief The AST reader whose identifiers are being enumerated.
4460 const ASTReader &Reader;
4461
4462 /// \brief The current index into the chain of AST files stored in
4463 /// the AST reader.
4464 unsigned Index;
4465
4466 /// \brief The current position within the identifier lookup table
4467 /// of the current AST file.
4468 ASTIdentifierLookupTable::key_iterator Current;
4469
4470 /// \brief The end position within the identifier lookup table of
4471 /// the current AST file.
4472 ASTIdentifierLookupTable::key_iterator End;
4473
4474 public:
4475 explicit ASTIdentifierIterator(const ASTReader &Reader);
4476
Chris Lattner5f9e2722011-07-23 10:55:15 +00004477 virtual StringRef Next();
Douglas Gregor95f42922010-10-14 22:11:03 +00004478 };
4479}
4480
4481ASTIdentifierIterator::ASTIdentifierIterator(const ASTReader &Reader)
Jonathan D. Turner5d6d89f2011-07-25 20:32:21 +00004482 : Reader(Reader), Index(Reader.ModuleMgr.size() - 1) {
Douglas Gregor95f42922010-10-14 22:11:03 +00004483 ASTIdentifierLookupTable *IdTable
Jonathan D. Turner5d6d89f2011-07-25 20:32:21 +00004484 = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index].IdentifierLookupTable;
Douglas Gregor95f42922010-10-14 22:11:03 +00004485 Current = IdTable->key_begin();
4486 End = IdTable->key_end();
4487}
4488
Chris Lattner5f9e2722011-07-23 10:55:15 +00004489StringRef ASTIdentifierIterator::Next() {
Douglas Gregor95f42922010-10-14 22:11:03 +00004490 while (Current == End) {
4491 // If we have exhausted all of our AST files, we're done.
4492 if (Index == 0)
Chris Lattner5f9e2722011-07-23 10:55:15 +00004493 return StringRef();
Douglas Gregor95f42922010-10-14 22:11:03 +00004494
4495 --Index;
4496 ASTIdentifierLookupTable *IdTable
Jonathan D. Turner5d6d89f2011-07-25 20:32:21 +00004497 = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index].
4498 IdentifierLookupTable;
Douglas Gregor95f42922010-10-14 22:11:03 +00004499 Current = IdTable->key_begin();
4500 End = IdTable->key_end();
4501 }
4502
4503 // We have any identifiers remaining in the current AST file; return
4504 // the next one.
4505 std::pair<const char*, unsigned> Key = *Current;
4506 ++Current;
Chris Lattner5f9e2722011-07-23 10:55:15 +00004507 return StringRef(Key.first, Key.second);
Douglas Gregor95f42922010-10-14 22:11:03 +00004508}
4509
4510IdentifierIterator *ASTReader::getIdentifiers() const {
4511 return new ASTIdentifierIterator(*this);
4512}
4513
Mike Stump1eb44332009-09-09 15:08:12 +00004514std::pair<ObjCMethodList, ObjCMethodList>
Sebastian Redlc43b54c2010-08-18 23:56:43 +00004515ASTReader::ReadMethodPool(Selector Sel) {
Sebastian Redl725cd962010-08-04 20:40:17 +00004516 // Find this selector in a hash table. We want to find the most recent entry.
Jonathan D. Turner5d6d89f2011-07-25 20:32:21 +00004517 for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) {
4518 Module &F = *(*I);
Sebastian Redl725cd962010-08-04 20:40:17 +00004519 if (!F.SelectorLookupTable)
4520 continue;
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +00004521
Sebastian Redl3c7f4132010-08-18 23:57:06 +00004522 ASTSelectorLookupTable *PoolTable
4523 = (ASTSelectorLookupTable*)F.SelectorLookupTable;
4524 ASTSelectorLookupTable::iterator Pos = PoolTable->find(Sel);
Sebastian Redl725cd962010-08-04 20:40:17 +00004525 if (Pos != PoolTable->end()) {
4526 ++NumSelectorsRead;
Sebastian Redlfa78dec2010-08-04 21:22:45 +00004527 // FIXME: Not quite happy with the statistics here. We probably should
4528 // disable this tracking when called via LoadSelector.
4529 // Also, should entries without methods count as misses?
4530 ++NumMethodPoolEntriesRead;
Sebastian Redl3c7f4132010-08-18 23:57:06 +00004531 ASTSelectorLookupTrait::data_type Data = *Pos;
Sebastian Redl725cd962010-08-04 20:40:17 +00004532 if (DeserializationListener)
4533 DeserializationListener->SelectorRead(Data.ID, Sel);
4534 return std::make_pair(Data.Instance, Data.Factory);
4535 }
Douglas Gregor83941df2009-04-25 17:48:32 +00004536 }
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +00004537
Sebastian Redlfa78dec2010-08-04 21:22:45 +00004538 ++NumMethodPoolMisses;
Sebastian Redl725cd962010-08-04 20:40:17 +00004539 return std::pair<ObjCMethodList, ObjCMethodList>();
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +00004540}
4541
Douglas Gregord8bba9c2011-06-28 16:20:02 +00004542void ASTReader::ReadKnownNamespaces(
Chris Lattner5f9e2722011-07-23 10:55:15 +00004543 SmallVectorImpl<NamespaceDecl *> &Namespaces) {
Douglas Gregord8bba9c2011-06-28 16:20:02 +00004544 Namespaces.clear();
4545
4546 for (unsigned I = 0, N = KnownNamespaces.size(); I != N; ++I) {
4547 if (NamespaceDecl *Namespace
4548 = dyn_cast_or_null<NamespaceDecl>(GetDecl(KnownNamespaces[I])))
4549 Namespaces.push_back(Namespace);
4550 }
4551}
4552
Douglas Gregora8623202011-07-27 20:58:46 +00004553void ASTReader::ReadTentativeDefinitions(
4554 SmallVectorImpl<VarDecl *> &TentativeDefs) {
4555 for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) {
4556 VarDecl *Var = dyn_cast_or_null<VarDecl>(GetDecl(TentativeDefinitions[I]));
4557 if (Var)
4558 TentativeDefs.push_back(Var);
4559 }
4560 TentativeDefinitions.clear();
4561}
4562
Douglas Gregora2ee20a2011-07-27 21:45:57 +00004563void ASTReader::ReadUnusedFileScopedDecls(
4564 SmallVectorImpl<const DeclaratorDecl *> &Decls) {
4565 for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) {
4566 DeclaratorDecl *D
4567 = dyn_cast_or_null<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I]));
4568 if (D)
4569 Decls.push_back(D);
4570 }
4571 UnusedFileScopedDecls.clear();
4572}
4573
Douglas Gregor0129b562011-07-27 21:57:17 +00004574void ASTReader::ReadDelegatingConstructors(
4575 SmallVectorImpl<CXXConstructorDecl *> &Decls) {
4576 for (unsigned I = 0, N = DelegatingCtorDecls.size(); I != N; ++I) {
4577 CXXConstructorDecl *D
4578 = dyn_cast_or_null<CXXConstructorDecl>(GetDecl(DelegatingCtorDecls[I]));
4579 if (D)
4580 Decls.push_back(D);
4581 }
4582 DelegatingCtorDecls.clear();
4583}
4584
Douglas Gregord58a0a52011-07-28 00:39:29 +00004585void ASTReader::ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl *> &Decls) {
4586 for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) {
4587 TypedefNameDecl *D
4588 = dyn_cast_or_null<TypedefNameDecl>(GetDecl(ExtVectorDecls[I]));
4589 if (D)
4590 Decls.push_back(D);
4591 }
4592 ExtVectorDecls.clear();
4593}
4594
Douglas Gregora126f172011-07-28 00:53:40 +00004595void ASTReader::ReadDynamicClasses(SmallVectorImpl<CXXRecordDecl *> &Decls) {
4596 for (unsigned I = 0, N = DynamicClasses.size(); I != N; ++I) {
4597 CXXRecordDecl *D
4598 = dyn_cast_or_null<CXXRecordDecl>(GetDecl(DynamicClasses[I]));
4599 if (D)
4600 Decls.push_back(D);
4601 }
4602 DynamicClasses.clear();
4603}
4604
Douglas Gregorec12ce22011-07-28 14:20:37 +00004605void
4606ASTReader::ReadLocallyScopedExternalDecls(SmallVectorImpl<NamedDecl *> &Decls) {
4607 for (unsigned I = 0, N = LocallyScopedExternalDecls.size(); I != N; ++I) {
4608 NamedDecl *D
4609 = dyn_cast_or_null<NamedDecl>(GetDecl(LocallyScopedExternalDecls[I]));
4610 if (D)
4611 Decls.push_back(D);
4612 }
4613 LocallyScopedExternalDecls.clear();
4614}
4615
Douglas Gregor5b9dc7c2011-07-28 14:54:22 +00004616void ASTReader::ReadReferencedSelectors(
4617 SmallVectorImpl<std::pair<Selector, SourceLocation> > &Sels) {
4618 if (ReferencedSelectorsData.empty())
4619 return;
4620
4621 // If there are @selector references added them to its pool. This is for
4622 // implementation of -Wselector.
4623 unsigned int DataSize = ReferencedSelectorsData.size()-1;
4624 unsigned I = 0;
4625 while (I < DataSize) {
4626 Selector Sel = DecodeSelector(ReferencedSelectorsData[I++]);
4627 SourceLocation SelLoc
4628 = SourceLocation::getFromRawEncoding(ReferencedSelectorsData[I++]);
4629 Sels.push_back(std::make_pair(Sel, SelLoc));
4630 }
4631 ReferencedSelectorsData.clear();
4632}
4633
Douglas Gregor31e37b22011-07-28 18:09:57 +00004634void ASTReader::ReadWeakUndeclaredIdentifiers(
4635 SmallVectorImpl<std::pair<IdentifierInfo *, WeakInfo> > &WeakIDs) {
4636 if (WeakUndeclaredIdentifiers.empty())
4637 return;
4638
4639 for (unsigned I = 0, N = WeakUndeclaredIdentifiers.size(); I < N; /*none*/) {
4640 IdentifierInfo *WeakId
4641 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
4642 IdentifierInfo *AliasId
4643 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
4644 SourceLocation Loc
4645 = SourceLocation::getFromRawEncoding(WeakUndeclaredIdentifiers[I++]);
4646 bool Used = WeakUndeclaredIdentifiers[I++];
4647 WeakInfo WI(AliasId, Loc);
4648 WI.setUsed(Used);
4649 WeakIDs.push_back(std::make_pair(WeakId, WI));
4650 }
4651 WeakUndeclaredIdentifiers.clear();
4652}
4653
Douglas Gregordfe65432011-07-28 19:11:31 +00004654void ASTReader::ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) {
4655 for (unsigned Idx = 0, N = VTableUses.size(); Idx < N; /* In loop */) {
4656 ExternalVTableUse VT;
4657 VT.Record = dyn_cast_or_null<CXXRecordDecl>(GetDecl(VTableUses[Idx++]));
4658 VT.Location = SourceLocation::getFromRawEncoding(VTableUses[Idx++]);
4659 VT.DefinitionRequired = VTableUses[Idx++];
4660 VTables.push_back(VT);
4661 }
4662
4663 VTableUses.clear();
4664}
4665
Douglas Gregor6e4a3f52011-07-28 19:49:54 +00004666void ASTReader::ReadPendingInstantiations(
4667 SmallVectorImpl<std::pair<ValueDecl *, SourceLocation> > &Pending) {
4668 for (unsigned Idx = 0, N = PendingInstantiations.size(); Idx < N;) {
4669 ValueDecl *D = cast<ValueDecl>(GetDecl(PendingInstantiations[Idx++]));
4670 SourceLocation Loc
4671 = SourceLocation::getFromRawEncoding(PendingInstantiations[Idx++]);
4672 Pending.push_back(std::make_pair(D, Loc));
4673 }
4674 PendingInstantiations.clear();
4675}
4676
Sebastian Redlc43b54c2010-08-18 23:56:43 +00004677void ASTReader::LoadSelector(Selector Sel) {
Sebastian Redle58aa892010-08-04 18:21:41 +00004678 // It would be complicated to avoid reading the methods anyway. So don't.
4679 ReadMethodPool(Sel);
4680}
4681
Douglas Gregor95eab172011-07-28 20:55:49 +00004682void ASTReader::SetIdentifierInfo(IdentifierID ID, IdentifierInfo *II) {
Douglas Gregor668c1a42009-04-21 22:25:48 +00004683 assert(ID && "Non-zero identifier ID required");
Douglas Gregora02b1472009-04-28 21:53:25 +00004684 assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range");
Douglas Gregor2b3a5a82009-04-25 19:10:14 +00004685 IdentifiersLoaded[ID - 1] = II;
Sebastian Redlf2f0f032010-07-23 23:49:55 +00004686 if (DeserializationListener)
4687 DeserializationListener->IdentifierRead(ID, II);
Douglas Gregor668c1a42009-04-21 22:25:48 +00004688}
4689
Douglas Gregord89275b2009-07-06 18:54:52 +00004690/// \brief Set the globally-visible declarations associated with the given
4691/// identifier.
4692///
Sebastian Redl3c7f4132010-08-18 23:57:06 +00004693/// If the AST reader is currently in a state where the given declaration IDs
Mike Stump1eb44332009-09-09 15:08:12 +00004694/// cannot safely be resolved, they are queued until it is safe to resolve
Douglas Gregord89275b2009-07-06 18:54:52 +00004695/// them.
4696///
4697/// \param II an IdentifierInfo that refers to one or more globally-visible
4698/// declarations.
4699///
4700/// \param DeclIDs the set of declaration IDs with the name @p II that are
4701/// visible at global scope.
4702///
4703/// \param Nonrecursive should be true to indicate that the caller knows that
4704/// this call is non-recursive, and therefore the globally-visible declarations
4705/// will not be placed onto the pending queue.
Mike Stump1eb44332009-09-09 15:08:12 +00004706void
Sebastian Redlc43b54c2010-08-18 23:56:43 +00004707ASTReader::SetGloballyVisibleDecls(IdentifierInfo *II,
Chris Lattner5f9e2722011-07-23 10:55:15 +00004708 const SmallVectorImpl<uint32_t> &DeclIDs,
Douglas Gregord89275b2009-07-06 18:54:52 +00004709 bool Nonrecursive) {
Argyrios Kyrtzidis29ee3a22010-07-30 10:03:16 +00004710 if (NumCurrentElementsDeserializing && !Nonrecursive) {
Douglas Gregord89275b2009-07-06 18:54:52 +00004711 PendingIdentifierInfos.push_back(PendingIdentifierInfo());
4712 PendingIdentifierInfo &PII = PendingIdentifierInfos.back();
4713 PII.II = II;
Benjamin Kramer4ea884b2010-09-06 23:43:28 +00004714 PII.DeclIDs.append(DeclIDs.begin(), DeclIDs.end());
Douglas Gregord89275b2009-07-06 18:54:52 +00004715 return;
4716 }
Mike Stump1eb44332009-09-09 15:08:12 +00004717
Douglas Gregord89275b2009-07-06 18:54:52 +00004718 for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) {
4719 NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I]));
4720 if (SemaObj) {
Douglas Gregor914ed9d2010-08-13 03:15:25 +00004721 if (SemaObj->TUScope) {
4722 // Introduce this declaration into the translation-unit scope
4723 // and add it to the declaration chain for this identifier, so
4724 // that (unqualified) name lookup will find it.
John McCalld226f652010-08-21 09:40:31 +00004725 SemaObj->TUScope->AddDecl(D);
Douglas Gregor914ed9d2010-08-13 03:15:25 +00004726 }
Douglas Gregor76dc8892010-09-24 23:29:12 +00004727 SemaObj->IdResolver.AddDeclToIdentifierChain(II, D);
Douglas Gregord89275b2009-07-06 18:54:52 +00004728 } else {
4729 // Queue this declaration so that it will be added to the
4730 // translation unit scope and identifier's declaration chain
4731 // once a Sema object is known.
4732 PreloadedDecls.push_back(D);
4733 }
4734 }
4735}
4736
Douglas Gregor95eab172011-07-28 20:55:49 +00004737IdentifierInfo *ASTReader::DecodeIdentifierInfo(IdentifierID ID) {
Douglas Gregorafaf3082009-04-11 00:14:32 +00004738 if (ID == 0)
4739 return 0;
Mike Stump1eb44332009-09-09 15:08:12 +00004740
Sebastian Redl11f5ccf2010-07-21 00:46:22 +00004741 if (IdentifiersLoaded.empty()) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00004742 Error("no identifier table in AST file");
Douglas Gregorafaf3082009-04-11 00:14:32 +00004743 return 0;
4744 }
Mike Stump1eb44332009-09-09 15:08:12 +00004745
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00004746 assert(PP && "Forgot to set Preprocessor ?");
Sebastian Redl11f5ccf2010-07-21 00:46:22 +00004747 ID -= 1;
4748 if (!IdentifiersLoaded[ID]) {
Douglas Gregor67268d02011-07-20 00:59:32 +00004749 GlobalIdentifierMapType::iterator I = GlobalIdentifierMap.find(ID + 1);
4750 assert(I != GlobalIdentifierMap.end() && "Corrupted global identifier map");
Douglas Gregor9827a802011-07-29 00:56:45 +00004751 Module *M = I->second;
4752 unsigned Index = ID - M->BaseIdentifierID;
4753 const char *Str = M->IdentifierTableData + M->IdentifierOffsets[Index];
Douglas Gregord6595a42009-04-25 21:04:17 +00004754
Sebastian Redl3c7f4132010-08-18 23:57:06 +00004755 // All of the strings in the AST file are preceded by a 16-bit length.
4756 // Extract that 16-bit length to avoid having to execute strlen().
Ted Kremenek231bc0b2009-10-23 04:45:31 +00004757 // NOTE: 'StrLenPtr' is an 'unsigned char*' so that we load bytes as
4758 // unsigned integers. This is important to avoid integer overflow when
4759 // we cast them to 'unsigned'.
Ted Kremenekff1ea462009-10-23 03:57:22 +00004760 const unsigned char *StrLenPtr = (const unsigned char*) Str - 2;
Douglas Gregor02fc7512009-04-28 20:01:51 +00004761 unsigned StrLen = (((unsigned) StrLenPtr[0])
4762 | (((unsigned) StrLenPtr[1]) << 8)) - 1;
Sebastian Redl11f5ccf2010-07-21 00:46:22 +00004763 IdentifiersLoaded[ID]
Chris Lattner5f9e2722011-07-23 10:55:15 +00004764 = &PP->getIdentifierTable().get(StringRef(Str, StrLen));
Sebastian Redlf2f0f032010-07-23 23:49:55 +00004765 if (DeserializationListener)
4766 DeserializationListener->IdentifierRead(ID + 1, IdentifiersLoaded[ID]);
Douglas Gregorafaf3082009-04-11 00:14:32 +00004767 }
Mike Stump1eb44332009-09-09 15:08:12 +00004768
Sebastian Redl11f5ccf2010-07-21 00:46:22 +00004769 return IdentifiersLoaded[ID];
Douglas Gregor2cf26342009-04-09 22:27:44 +00004770}
4771
Douglas Gregor95eab172011-07-28 20:55:49 +00004772IdentifierInfo *ASTReader::getLocalIdentifier(Module &M, unsigned LocalID) {
4773 return DecodeIdentifierInfo(getGlobalIdentifierID(M, LocalID));
4774}
4775
4776IdentifierID ASTReader::getGlobalIdentifierID(Module &M, unsigned LocalID) {
4777 // FIXME: Perform local-to-global remapping
4778 return LocalID;
4779}
4780
Douglas Gregorf62d43d2011-07-19 16:10:42 +00004781bool ASTReader::ReadSLocEntry(int ID) {
Douglas Gregore23ac652011-04-20 00:21:03 +00004782 return ReadSLocEntryRecord(ID) != Success;
Douglas Gregor7f94b0b2009-04-27 06:38:32 +00004783}
4784
Douglas Gregor2d2689a2011-07-28 21:16:51 +00004785Selector ASTReader::getLocalSelector(Module &M, unsigned LocalID) {
4786 return DecodeSelector(getGlobalSelectorID(M, LocalID));
4787}
4788
4789Selector ASTReader::DecodeSelector(serialization::SelectorID ID) {
Steve Naroff90cd1bb2009-04-23 10:39:46 +00004790 if (ID == 0)
4791 return Selector();
Mike Stump1eb44332009-09-09 15:08:12 +00004792
Sebastian Redl725cd962010-08-04 20:40:17 +00004793 if (ID > SelectorsLoaded.size()) {
Sebastian Redl3c7f4132010-08-18 23:57:06 +00004794 Error("selector ID out of range in AST file");
Steve Naroff90cd1bb2009-04-23 10:39:46 +00004795 return Selector();
4796 }
Douglas Gregor83941df2009-04-25 17:48:32 +00004797
Sebastian Redl725cd962010-08-04 20:40:17 +00004798 if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == 0) {
Douglas Gregor83941df2009-04-25 17:48:32 +00004799 // Load this selector from the selector table.
Douglas Gregor96958cb2011-07-20 01:10:58 +00004800 GlobalSelectorMapType::iterator I = GlobalSelectorMap.find(ID);
4801 assert(I != GlobalSelectorMap.end() && "Corrupted global selector map");
Douglas Gregor9827a802011-07-29 00:56:45 +00004802 Module &M = *I->second;
4803 ASTSelectorLookupTrait Trait(*this, M);
4804 unsigned Idx = ID - 1 - M.BaseSelectorID;
Douglas Gregor96958cb2011-07-20 01:10:58 +00004805 SelectorsLoaded[ID - 1] =
Douglas Gregor9827a802011-07-29 00:56:45 +00004806 Trait.ReadKey(M.SelectorLookupTableData + M.SelectorOffsets[Idx], 0);
Douglas Gregor96958cb2011-07-20 01:10:58 +00004807 if (DeserializationListener)
4808 DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]);
Douglas Gregor83941df2009-04-25 17:48:32 +00004809 }
4810
Sebastian Redl725cd962010-08-04 20:40:17 +00004811 return SelectorsLoaded[ID - 1];
Steve Naroff90cd1bb2009-04-23 10:39:46 +00004812}
4813
Douglas Gregor8451ec72011-07-28 14:41:43 +00004814Selector ASTReader::GetExternalSelector(serialization::SelectorID ID) {
Douglas Gregor719770d2010-04-06 17:30:22 +00004815 return DecodeSelector(ID);
4816}
4817
Sebastian Redlc43b54c2010-08-18 23:56:43 +00004818uint32_t ASTReader::GetNumExternalSelectors() {
Sebastian Redl725cd962010-08-04 20:40:17 +00004819 // ID 0 (the null selector) is considered an external selector.
4820 return getTotalNumSelectors() + 1;
Douglas Gregor719770d2010-04-06 17:30:22 +00004821}
4822
Douglas Gregor8451ec72011-07-28 14:41:43 +00004823serialization::SelectorID
4824ASTReader::getGlobalSelectorID(Module &F, unsigned LocalID) const {
4825 // FIXME: Perform local -> global remapping
4826 return LocalID;
4827}
4828
Mike Stump1eb44332009-09-09 15:08:12 +00004829DeclarationName
Douglas Gregor72a9ae12011-07-22 16:00:58 +00004830ASTReader::ReadDeclarationName(Module &F,
Douglas Gregor393f2492011-07-22 00:38:23 +00004831 const RecordData &Record, unsigned &Idx) {
Douglas Gregor2cf26342009-04-09 22:27:44 +00004832 DeclarationName::NameKind Kind = (DeclarationName::NameKind)Record[Idx++];
4833 switch (Kind) {
4834 case DeclarationName::Identifier:
Douglas Gregor95eab172011-07-28 20:55:49 +00004835 return DeclarationName(GetIdentifierInfo(F, Record, Idx));
Douglas Gregor2cf26342009-04-09 22:27:44 +00004836
4837 case DeclarationName::ObjCZeroArgSelector:
4838 case DeclarationName::ObjCOneArgSelector:
4839 case DeclarationName::ObjCMultiArgSelector:
Douglas Gregor2d2689a2011-07-28 21:16:51 +00004840 return DeclarationName(ReadSelector(F, Record, Idx));
Douglas Gregor2cf26342009-04-09 22:27:44 +00004841
4842 case DeclarationName::CXXConstructorName:
Chris Lattnerd1d64a02009-04-27 21:45:14 +00004843 return Context->DeclarationNames.getCXXConstructorName(
Douglas Gregor393f2492011-07-22 00:38:23 +00004844 Context->getCanonicalType(readType(F, Record, Idx)));
Douglas Gregor2cf26342009-04-09 22:27:44 +00004845
4846 case DeclarationName::CXXDestructorName:
Chris Lattnerd1d64a02009-04-27 21:45:14 +00004847 return Context->DeclarationNames.getCXXDestructorName(
Douglas Gregor393f2492011-07-22 00:38:23 +00004848 Context->getCanonicalType(readType(F, Record, Idx)));
Douglas Gregor2cf26342009-04-09 22:27:44 +00004849
4850 case DeclarationName::CXXConversionFunctionName:
Chris Lattnerd1d64a02009-04-27 21:45:14 +00004851 return Context->DeclarationNames.getCXXConversionFunctionName(
Douglas Gregor393f2492011-07-22 00:38:23 +00004852 Context->getCanonicalType(readType(F, Record, Idx)));
Douglas Gregor2cf26342009-04-09 22:27:44 +00004853
4854 case DeclarationName::CXXOperatorName:
Chris Lattnerd1d64a02009-04-27 21:45:14 +00004855 return Context->DeclarationNames.getCXXOperatorName(
Douglas Gregor2cf26342009-04-09 22:27:44 +00004856 (OverloadedOperatorKind)Record[Idx++]);
4857
Sean Hunt3e518bd2009-11-29 07:34:05 +00004858 case DeclarationName::CXXLiteralOperatorName:
4859 return Context->DeclarationNames.getCXXLiteralOperatorName(
Douglas Gregor95eab172011-07-28 20:55:49 +00004860 GetIdentifierInfo(F, Record, Idx));
Sean Hunt3e518bd2009-11-29 07:34:05 +00004861
Douglas Gregor2cf26342009-04-09 22:27:44 +00004862 case DeclarationName::CXXUsingDirective:
4863 return DeclarationName::getUsingDirectiveName();
4864 }
4865
4866 // Required to silence GCC warning
4867 return DeclarationName();
4868}
Douglas Gregor0a0428e2009-04-10 20:39:37 +00004869
Douglas Gregor72a9ae12011-07-22 16:00:58 +00004870void ASTReader::ReadDeclarationNameLoc(Module &F,
Argyrios Kyrtzidis40451072010-10-15 18:21:24 +00004871 DeclarationNameLoc &DNLoc,
4872 DeclarationName Name,
4873 const RecordData &Record, unsigned &Idx) {
4874 switch (Name.getNameKind()) {
4875 case DeclarationName::CXXConstructorName:
4876 case DeclarationName::CXXDestructorName:
4877 case DeclarationName::CXXConversionFunctionName:
4878 DNLoc.NamedType.TInfo = GetTypeSourceInfo(F, Record, Idx);
4879 break;
4880
4881 case DeclarationName::CXXOperatorName:
4882 DNLoc.CXXOperatorName.BeginOpNameLoc
4883 = ReadSourceLocation(F, Record, Idx).getRawEncoding();
4884 DNLoc.CXXOperatorName.EndOpNameLoc
4885 = ReadSourceLocation(F, Record, Idx).getRawEncoding();
4886 break;
4887
4888 case DeclarationName::CXXLiteralOperatorName:
4889 DNLoc.CXXLiteralOperatorName.OpNameLoc
4890 = ReadSourceLocation(F, Record, Idx).getRawEncoding();
4891 break;
4892
4893 case DeclarationName::Identifier:
4894 case DeclarationName::ObjCZeroArgSelector:
4895 case DeclarationName::ObjCOneArgSelector:
4896 case DeclarationName::ObjCMultiArgSelector:
4897 case DeclarationName::CXXUsingDirective:
4898 break;
4899 }
4900}
4901
Douglas Gregor72a9ae12011-07-22 16:00:58 +00004902void ASTReader::ReadDeclarationNameInfo(Module &F,
Argyrios Kyrtzidis40451072010-10-15 18:21:24 +00004903 DeclarationNameInfo &NameInfo,
4904 const RecordData &Record, unsigned &Idx) {
Douglas Gregor393f2492011-07-22 00:38:23 +00004905 NameInfo.setName(ReadDeclarationName(F, Record, Idx));
Argyrios Kyrtzidis40451072010-10-15 18:21:24 +00004906 NameInfo.setLoc(ReadSourceLocation(F, Record, Idx));
4907 DeclarationNameLoc DNLoc;
4908 ReadDeclarationNameLoc(F, DNLoc, NameInfo.getName(), Record, Idx);
4909 NameInfo.setInfo(DNLoc);
4910}
4911
Douglas Gregor72a9ae12011-07-22 16:00:58 +00004912void ASTReader::ReadQualifierInfo(Module &F, QualifierInfo &Info,
Argyrios Kyrtzidis40451072010-10-15 18:21:24 +00004913 const RecordData &Record, unsigned &Idx) {
Douglas Gregorc22b5ff2011-02-25 02:25:35 +00004914 Info.QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx);
Argyrios Kyrtzidis40451072010-10-15 18:21:24 +00004915 unsigned NumTPLists = Record[Idx++];
4916 Info.NumTemplParamLists = NumTPLists;
4917 if (NumTPLists) {
4918 Info.TemplParamLists = new (*Context) TemplateParameterList*[NumTPLists];
4919 for (unsigned i=0; i != NumTPLists; ++i)
4920 Info.TemplParamLists[i] = ReadTemplateParameterList(F, Record, Idx);
4921 }
4922}
4923
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00004924TemplateName
Douglas Gregor72a9ae12011-07-22 16:00:58 +00004925ASTReader::ReadTemplateName(Module &F, const RecordData &Record,
Douglas Gregor1aee05d2011-01-15 06:45:20 +00004926 unsigned &Idx) {
Michael J. Spencer20249a12010-10-21 03:16:25 +00004927 TemplateName::NameKind Kind = (TemplateName::NameKind)Record[Idx++];
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00004928 switch (Kind) {
4929 case TemplateName::Template:
Douglas Gregor409448c2011-07-21 22:35:25 +00004930 return TemplateName(ReadDeclAs<TemplateDecl>(F, Record, Idx));
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00004931
4932 case TemplateName::OverloadedTemplate: {
4933 unsigned size = Record[Idx++];
4934 UnresolvedSet<8> Decls;
4935 while (size--)
Douglas Gregor409448c2011-07-21 22:35:25 +00004936 Decls.addDecl(ReadDeclAs<NamedDecl>(F, Record, Idx));
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00004937
4938 return Context->getOverloadedTemplateName(Decls.begin(), Decls.end());
4939 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00004940
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00004941 case TemplateName::QualifiedTemplate: {
Douglas Gregor409448c2011-07-21 22:35:25 +00004942 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00004943 bool hasTemplKeyword = Record[Idx++];
Douglas Gregor409448c2011-07-21 22:35:25 +00004944 TemplateDecl *Template = ReadDeclAs<TemplateDecl>(F, Record, Idx);
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00004945 return Context->getQualifiedTemplateName(NNS, hasTemplKeyword, Template);
4946 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00004947
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00004948 case TemplateName::DependentTemplate: {
Douglas Gregor409448c2011-07-21 22:35:25 +00004949 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00004950 if (Record[Idx++]) // isIdentifier
4951 return Context->getDependentTemplateName(NNS,
Douglas Gregor95eab172011-07-28 20:55:49 +00004952 GetIdentifierInfo(F, Record,
4953 Idx));
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00004954 return Context->getDependentTemplateName(NNS,
Argyrios Kyrtzidis17cfded2010-06-28 09:31:42 +00004955 (OverloadedOperatorKind)Record[Idx++]);
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00004956 }
John McCall14606042011-06-30 08:33:18 +00004957
4958 case TemplateName::SubstTemplateTemplateParm: {
4959 TemplateTemplateParmDecl *param
Douglas Gregor409448c2011-07-21 22:35:25 +00004960 = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
John McCall14606042011-06-30 08:33:18 +00004961 if (!param) return TemplateName();
4962 TemplateName replacement = ReadTemplateName(F, Record, Idx);
4963 return Context->getSubstTemplateTemplateParm(param, replacement);
4964 }
Douglas Gregor1aee05d2011-01-15 06:45:20 +00004965
4966 case TemplateName::SubstTemplateTemplateParmPack: {
4967 TemplateTemplateParmDecl *Param
Douglas Gregor409448c2011-07-21 22:35:25 +00004968 = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
Douglas Gregor1aee05d2011-01-15 06:45:20 +00004969 if (!Param)
4970 return TemplateName();
4971
4972 TemplateArgument ArgPack = ReadTemplateArgument(F, Record, Idx);
4973 if (ArgPack.getKind() != TemplateArgument::Pack)
4974 return TemplateName();
4975
4976 return Context->getSubstTemplateTemplateParmPack(Param, ArgPack);
4977 }
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00004978 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00004979
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00004980 assert(0 && "Unhandled template name kind!");
4981 return TemplateName();
4982}
4983
4984TemplateArgument
Douglas Gregor72a9ae12011-07-22 16:00:58 +00004985ASTReader::ReadTemplateArgument(Module &F,
Sebastian Redl577d4792010-07-22 22:43:28 +00004986 const RecordData &Record, unsigned &Idx) {
Douglas Gregora7fc9012011-01-05 18:58:31 +00004987 TemplateArgument::ArgKind Kind = (TemplateArgument::ArgKind)Record[Idx++];
4988 switch (Kind) {
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00004989 case TemplateArgument::Null:
4990 return TemplateArgument();
4991 case TemplateArgument::Type:
Douglas Gregor393f2492011-07-22 00:38:23 +00004992 return TemplateArgument(readType(F, Record, Idx));
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00004993 case TemplateArgument::Declaration:
Douglas Gregor409448c2011-07-21 22:35:25 +00004994 return TemplateArgument(ReadDecl(F, Record, Idx));
Argyrios Kyrtzidisdc767e32010-06-28 09:31:34 +00004995 case TemplateArgument::Integral: {
4996 llvm::APSInt Value = ReadAPSInt(Record, Idx);
Douglas Gregor393f2492011-07-22 00:38:23 +00004997 QualType T = readType(F, Record, Idx);
Argyrios Kyrtzidisdc767e32010-06-28 09:31:34 +00004998 return TemplateArgument(Value, T);
4999 }
Douglas Gregora7fc9012011-01-05 18:58:31 +00005000 case TemplateArgument::Template:
Douglas Gregor1aee05d2011-01-15 06:45:20 +00005001 return TemplateArgument(ReadTemplateName(F, Record, Idx));
Douglas Gregora7fc9012011-01-05 18:58:31 +00005002 case TemplateArgument::TemplateExpansion: {
Douglas Gregor1aee05d2011-01-15 06:45:20 +00005003 TemplateName Name = ReadTemplateName(F, Record, Idx);
Douglas Gregor2be29f42011-01-14 23:41:42 +00005004 llvm::Optional<unsigned> NumTemplateExpansions;
5005 if (unsigned NumExpansions = Record[Idx++])
5006 NumTemplateExpansions = NumExpansions - 1;
5007 return TemplateArgument(Name, NumTemplateExpansions);
Douglas Gregorba68eca2011-01-05 17:40:24 +00005008 }
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00005009 case TemplateArgument::Expression:
Sebastian Redlc3632732010-10-05 15:59:54 +00005010 return TemplateArgument(ReadExpr(F));
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00005011 case TemplateArgument::Pack: {
5012 unsigned NumArgs = Record[Idx++];
Douglas Gregor910f8002010-11-07 23:05:16 +00005013 TemplateArgument *Args = new (*Context) TemplateArgument[NumArgs];
5014 for (unsigned I = 0; I != NumArgs; ++I)
5015 Args[I] = ReadTemplateArgument(F, Record, Idx);
5016 return TemplateArgument(Args, NumArgs);
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00005017 }
5018 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00005019
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +00005020 assert(0 && "Unhandled template argument kind!");
5021 return TemplateArgument();
5022}
5023
Argyrios Kyrtzidisdd41c142010-06-23 13:48:30 +00005024TemplateParameterList *
Douglas Gregor72a9ae12011-07-22 16:00:58 +00005025ASTReader::ReadTemplateParameterList(Module &F,
Sebastian Redlc3632732010-10-05 15:59:54 +00005026 const RecordData &Record, unsigned &Idx) {
5027 SourceLocation TemplateLoc = ReadSourceLocation(F, Record, Idx);
5028 SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Idx);
5029 SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Idx);
Argyrios Kyrtzidisdd41c142010-06-23 13:48:30 +00005030
5031 unsigned NumParams = Record[Idx++];
Chris Lattner5f9e2722011-07-23 10:55:15 +00005032 SmallVector<NamedDecl *, 16> Params;
Argyrios Kyrtzidisdd41c142010-06-23 13:48:30 +00005033 Params.reserve(NumParams);
5034 while (NumParams--)
Douglas Gregor409448c2011-07-21 22:35:25 +00005035 Params.push_back(ReadDeclAs<NamedDecl>(F, Record, Idx));
Michael J. Spencer20249a12010-10-21 03:16:25 +00005036
5037 TemplateParameterList* TemplateParams =
Argyrios Kyrtzidisdd41c142010-06-23 13:48:30 +00005038 TemplateParameterList::Create(*Context, TemplateLoc, LAngleLoc,
5039 Params.data(), Params.size(), RAngleLoc);
5040 return TemplateParams;
5041}
5042
5043void
Sebastian Redlc43b54c2010-08-18 23:56:43 +00005044ASTReader::
Chris Lattner5f9e2722011-07-23 10:55:15 +00005045ReadTemplateArgumentList(SmallVector<TemplateArgument, 8> &TemplArgs,
Douglas Gregor72a9ae12011-07-22 16:00:58 +00005046 Module &F, const RecordData &Record,
Sebastian Redlc3632732010-10-05 15:59:54 +00005047 unsigned &Idx) {
Argyrios Kyrtzidisdd41c142010-06-23 13:48:30 +00005048 unsigned NumTemplateArgs = Record[Idx++];
5049 TemplArgs.reserve(NumTemplateArgs);
5050 while (NumTemplateArgs--)
Sebastian Redlc3632732010-10-05 15:59:54 +00005051 TemplArgs.push_back(ReadTemplateArgument(F, Record, Idx));
Argyrios Kyrtzidisdd41c142010-06-23 13:48:30 +00005052}
5053
Argyrios Kyrtzidis37ffed32010-07-02 11:55:32 +00005054/// \brief Read a UnresolvedSet structure.
Douglas Gregor72a9ae12011-07-22 16:00:58 +00005055void ASTReader::ReadUnresolvedSet(Module &F, UnresolvedSetImpl &Set,
Argyrios Kyrtzidis37ffed32010-07-02 11:55:32 +00005056 const RecordData &Record, unsigned &Idx) {
5057 unsigned NumDecls = Record[Idx++];
5058 while (NumDecls--) {
Douglas Gregor409448c2011-07-21 22:35:25 +00005059 NamedDecl *D = ReadDeclAs<NamedDecl>(F, Record, Idx);
Argyrios Kyrtzidis37ffed32010-07-02 11:55:32 +00005060 AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
5061 Set.addDecl(D, AS);
5062 }
5063}
5064
Argyrios Kyrtzidis0745d0a2010-07-02 23:30:27 +00005065CXXBaseSpecifier
Douglas Gregor72a9ae12011-07-22 16:00:58 +00005066ASTReader::ReadCXXBaseSpecifier(Module &F,
Nick Lewycky56062202010-07-26 16:56:01 +00005067 const RecordData &Record, unsigned &Idx) {
Argyrios Kyrtzidis0745d0a2010-07-02 23:30:27 +00005068 bool isVirtual = static_cast<bool>(Record[Idx++]);
5069 bool isBaseOfClass = static_cast<bool>(Record[Idx++]);
5070 AccessSpecifier AS = static_cast<AccessSpecifier>(Record[Idx++]);
Sebastian Redlf677ea32011-02-05 19:23:19 +00005071 bool inheritConstructors = static_cast<bool>(Record[Idx++]);
Sebastian Redlc3632732010-10-05 15:59:54 +00005072 TypeSourceInfo *TInfo = GetTypeSourceInfo(F, Record, Idx);
5073 SourceRange Range = ReadSourceRange(F, Record, Idx);
Douglas Gregorf90b27a2011-01-03 22:36:02 +00005074 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Idx);
Sebastian Redlf677ea32011-02-05 19:23:19 +00005075 CXXBaseSpecifier Result(Range, isVirtual, isBaseOfClass, AS, TInfo,
Douglas Gregorf90b27a2011-01-03 22:36:02 +00005076 EllipsisLoc);
Sebastian Redlf677ea32011-02-05 19:23:19 +00005077 Result.setInheritConstructors(inheritConstructors);
5078 return Result;
Argyrios Kyrtzidis0745d0a2010-07-02 23:30:27 +00005079}
5080
Sean Huntcbb67482011-01-08 20:30:50 +00005081std::pair<CXXCtorInitializer **, unsigned>
Douglas Gregor72a9ae12011-07-22 16:00:58 +00005082ASTReader::ReadCXXCtorInitializers(Module &F, const RecordData &Record,
Sean Huntcbb67482011-01-08 20:30:50 +00005083 unsigned &Idx) {
5084 CXXCtorInitializer **CtorInitializers = 0;
Argyrios Kyrtzidis8e706f42010-08-09 10:54:12 +00005085 unsigned NumInitializers = Record[Idx++];
5086 if (NumInitializers) {
5087 ASTContext &C = *getContext();
5088
Sean Huntcbb67482011-01-08 20:30:50 +00005089 CtorInitializers
5090 = new (C) CXXCtorInitializer*[NumInitializers];
Argyrios Kyrtzidis8e706f42010-08-09 10:54:12 +00005091 for (unsigned i=0; i != NumInitializers; ++i) {
5092 TypeSourceInfo *BaseClassInfo = 0;
5093 bool IsBaseVirtual = false;
5094 FieldDecl *Member = 0;
Francois Pichet00eb3f92010-12-04 09:14:42 +00005095 IndirectFieldDecl *IndirectMember = 0;
Sean Hunt156b6402011-05-04 01:19:08 +00005096 CXXConstructorDecl *Target = 0;
Michael J. Spencer20249a12010-10-21 03:16:25 +00005097
Sean Hunt156b6402011-05-04 01:19:08 +00005098 CtorInitializerType Type = (CtorInitializerType)Record[Idx++];
5099 switch (Type) {
5100 case CTOR_INITIALIZER_BASE:
Sebastian Redlc3632732010-10-05 15:59:54 +00005101 BaseClassInfo = GetTypeSourceInfo(F, Record, Idx);
Argyrios Kyrtzidis8e706f42010-08-09 10:54:12 +00005102 IsBaseVirtual = Record[Idx++];
Sean Hunt156b6402011-05-04 01:19:08 +00005103 break;
5104
5105 case CTOR_INITIALIZER_DELEGATING:
Douglas Gregor409448c2011-07-21 22:35:25 +00005106 Target = ReadDeclAs<CXXConstructorDecl>(F, Record, Idx);
Sean Hunt156b6402011-05-04 01:19:08 +00005107 break;
5108
5109 case CTOR_INITIALIZER_MEMBER:
Douglas Gregor409448c2011-07-21 22:35:25 +00005110 Member = ReadDeclAs<FieldDecl>(F, Record, Idx);
Sean Hunt156b6402011-05-04 01:19:08 +00005111 break;
5112
5113 case CTOR_INITIALIZER_INDIRECT_MEMBER:
Douglas Gregor409448c2011-07-21 22:35:25 +00005114 IndirectMember = ReadDeclAs<IndirectFieldDecl>(F, Record, Idx);
Sean Hunt156b6402011-05-04 01:19:08 +00005115 break;
Argyrios Kyrtzidis8e706f42010-08-09 10:54:12 +00005116 }
Sean Hunt156b6402011-05-04 01:19:08 +00005117
Douglas Gregor3fb9e4b2011-01-04 00:32:56 +00005118 SourceLocation MemberOrEllipsisLoc = ReadSourceLocation(F, Record, Idx);
Sebastian Redlc3632732010-10-05 15:59:54 +00005119 Expr *Init = ReadExpr(F);
Sebastian Redlc3632732010-10-05 15:59:54 +00005120 SourceLocation LParenLoc = ReadSourceLocation(F, Record, Idx);
5121 SourceLocation RParenLoc = ReadSourceLocation(F, Record, Idx);
Argyrios Kyrtzidis8e706f42010-08-09 10:54:12 +00005122 bool IsWritten = Record[Idx++];
5123 unsigned SourceOrderOrNumArrayIndices;
Chris Lattner5f9e2722011-07-23 10:55:15 +00005124 SmallVector<VarDecl *, 8> Indices;
Argyrios Kyrtzidis8e706f42010-08-09 10:54:12 +00005125 if (IsWritten) {
5126 SourceOrderOrNumArrayIndices = Record[Idx++];
5127 } else {
5128 SourceOrderOrNumArrayIndices = Record[Idx++];
5129 Indices.reserve(SourceOrderOrNumArrayIndices);
5130 for (unsigned i=0; i != SourceOrderOrNumArrayIndices; ++i)
Douglas Gregor409448c2011-07-21 22:35:25 +00005131 Indices.push_back(ReadDeclAs<VarDecl>(F, Record, Idx));
Argyrios Kyrtzidis8e706f42010-08-09 10:54:12 +00005132 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00005133
Sean Huntcbb67482011-01-08 20:30:50 +00005134 CXXCtorInitializer *BOMInit;
Sean Hunt156b6402011-05-04 01:19:08 +00005135 if (Type == CTOR_INITIALIZER_BASE) {
Sean Huntcbb67482011-01-08 20:30:50 +00005136 BOMInit = new (C) CXXCtorInitializer(C, BaseClassInfo, IsBaseVirtual,
5137 LParenLoc, Init, RParenLoc,
5138 MemberOrEllipsisLoc);
Sean Hunt156b6402011-05-04 01:19:08 +00005139 } else if (Type == CTOR_INITIALIZER_DELEGATING) {
5140 BOMInit = new (C) CXXCtorInitializer(C, MemberOrEllipsisLoc, LParenLoc,
5141 Target, Init, RParenLoc);
Argyrios Kyrtzidis8e706f42010-08-09 10:54:12 +00005142 } else if (IsWritten) {
Francois Pichet00eb3f92010-12-04 09:14:42 +00005143 if (Member)
Sean Huntcbb67482011-01-08 20:30:50 +00005144 BOMInit = new (C) CXXCtorInitializer(C, Member, MemberOrEllipsisLoc,
5145 LParenLoc, Init, RParenLoc);
Francois Pichet00eb3f92010-12-04 09:14:42 +00005146 else
Sean Huntcbb67482011-01-08 20:30:50 +00005147 BOMInit = new (C) CXXCtorInitializer(C, IndirectMember,
5148 MemberOrEllipsisLoc, LParenLoc,
5149 Init, RParenLoc);
Argyrios Kyrtzidis8e706f42010-08-09 10:54:12 +00005150 } else {
Sean Huntcbb67482011-01-08 20:30:50 +00005151 BOMInit = CXXCtorInitializer::Create(C, Member, MemberOrEllipsisLoc,
5152 LParenLoc, Init, RParenLoc,
5153 Indices.data(), Indices.size());
Argyrios Kyrtzidis8e706f42010-08-09 10:54:12 +00005154 }
5155
Argyrios Kyrtzidisf84cde12010-09-06 19:04:27 +00005156 if (IsWritten)
5157 BOMInit->setSourceOrder(SourceOrderOrNumArrayIndices);
Sean Huntcbb67482011-01-08 20:30:50 +00005158 CtorInitializers[i] = BOMInit;
Argyrios Kyrtzidis8e706f42010-08-09 10:54:12 +00005159 }
5160 }
5161
Sean Huntcbb67482011-01-08 20:30:50 +00005162 return std::make_pair(CtorInitializers, NumInitializers);
Argyrios Kyrtzidis8e706f42010-08-09 10:54:12 +00005163}
5164
Chris Lattner6ad9ac02010-05-07 21:43:38 +00005165NestedNameSpecifier *
Douglas Gregor72a9ae12011-07-22 16:00:58 +00005166ASTReader::ReadNestedNameSpecifier(Module &F,
Douglas Gregor409448c2011-07-21 22:35:25 +00005167 const RecordData &Record, unsigned &Idx) {
Chris Lattner6ad9ac02010-05-07 21:43:38 +00005168 unsigned N = Record[Idx++];
5169 NestedNameSpecifier *NNS = 0, *Prev = 0;
5170 for (unsigned I = 0; I != N; ++I) {
5171 NestedNameSpecifier::SpecifierKind Kind
5172 = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
5173 switch (Kind) {
5174 case NestedNameSpecifier::Identifier: {
Douglas Gregor95eab172011-07-28 20:55:49 +00005175 IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx);
Chris Lattner6ad9ac02010-05-07 21:43:38 +00005176 NNS = NestedNameSpecifier::Create(*Context, Prev, II);
5177 break;
5178 }
5179
5180 case NestedNameSpecifier::Namespace: {
Douglas Gregor409448c2011-07-21 22:35:25 +00005181 NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
Chris Lattner6ad9ac02010-05-07 21:43:38 +00005182 NNS = NestedNameSpecifier::Create(*Context, Prev, NS);
5183 break;
5184 }
5185
Douglas Gregor14aba762011-02-24 02:36:08 +00005186 case NestedNameSpecifier::NamespaceAlias: {
Douglas Gregor409448c2011-07-21 22:35:25 +00005187 NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
Douglas Gregor14aba762011-02-24 02:36:08 +00005188 NNS = NestedNameSpecifier::Create(*Context, Prev, Alias);
5189 break;
5190 }
5191
Chris Lattner6ad9ac02010-05-07 21:43:38 +00005192 case NestedNameSpecifier::TypeSpec:
5193 case NestedNameSpecifier::TypeSpecWithTemplate: {
Douglas Gregor393f2492011-07-22 00:38:23 +00005194 const Type *T = readType(F, Record, Idx).getTypePtrOrNull();
Douglas Gregor1ab55e92010-12-10 17:03:06 +00005195 if (!T)
5196 return 0;
5197
Chris Lattner6ad9ac02010-05-07 21:43:38 +00005198 bool Template = Record[Idx++];
5199 NNS = NestedNameSpecifier::Create(*Context, Prev, Template, T);
5200 break;
5201 }
5202
5203 case NestedNameSpecifier::Global: {
5204 NNS = NestedNameSpecifier::GlobalSpecifier(*Context);
5205 // No associated value, and there can't be a prefix.
5206 break;
5207 }
Chris Lattner6ad9ac02010-05-07 21:43:38 +00005208 }
Argyrios Kyrtzidisd2bb2c02010-07-07 15:46:30 +00005209 Prev = NNS;
Chris Lattner6ad9ac02010-05-07 21:43:38 +00005210 }
5211 return NNS;
5212}
5213
Douglas Gregordc355712011-02-25 00:36:19 +00005214NestedNameSpecifierLoc
Douglas Gregor72a9ae12011-07-22 16:00:58 +00005215ASTReader::ReadNestedNameSpecifierLoc(Module &F, const RecordData &Record,
Douglas Gregordc355712011-02-25 00:36:19 +00005216 unsigned &Idx) {
5217 unsigned N = Record[Idx++];
Douglas Gregor5f791bb2011-02-28 23:58:31 +00005218 NestedNameSpecifierLocBuilder Builder;
Douglas Gregordc355712011-02-25 00:36:19 +00005219 for (unsigned I = 0; I != N; ++I) {
5220 NestedNameSpecifier::SpecifierKind Kind
5221 = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
5222 switch (Kind) {
5223 case NestedNameSpecifier::Identifier: {
Douglas Gregor95eab172011-07-28 20:55:49 +00005224 IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx);
Douglas Gregordc355712011-02-25 00:36:19 +00005225 SourceRange Range = ReadSourceRange(F, Record, Idx);
Douglas Gregor5f791bb2011-02-28 23:58:31 +00005226 Builder.Extend(*Context, II, Range.getBegin(), Range.getEnd());
Douglas Gregordc355712011-02-25 00:36:19 +00005227 break;
5228 }
5229
5230 case NestedNameSpecifier::Namespace: {
Douglas Gregor409448c2011-07-21 22:35:25 +00005231 NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
Douglas Gregordc355712011-02-25 00:36:19 +00005232 SourceRange Range = ReadSourceRange(F, Record, Idx);
Douglas Gregor5f791bb2011-02-28 23:58:31 +00005233 Builder.Extend(*Context, NS, Range.getBegin(), Range.getEnd());
Douglas Gregordc355712011-02-25 00:36:19 +00005234 break;
5235 }
5236
5237 case NestedNameSpecifier::NamespaceAlias: {
Douglas Gregor409448c2011-07-21 22:35:25 +00005238 NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
Douglas Gregordc355712011-02-25 00:36:19 +00005239 SourceRange Range = ReadSourceRange(F, Record, Idx);
Douglas Gregor5f791bb2011-02-28 23:58:31 +00005240 Builder.Extend(*Context, Alias, Range.getBegin(), Range.getEnd());
Douglas Gregordc355712011-02-25 00:36:19 +00005241 break;
5242 }
5243
5244 case NestedNameSpecifier::TypeSpec:
5245 case NestedNameSpecifier::TypeSpecWithTemplate: {
Douglas Gregordc355712011-02-25 00:36:19 +00005246 bool Template = Record[Idx++];
5247 TypeSourceInfo *T = GetTypeSourceInfo(F, Record, Idx);
5248 if (!T)
5249 return NestedNameSpecifierLoc();
Douglas Gregordc355712011-02-25 00:36:19 +00005250 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
Douglas Gregor5f791bb2011-02-28 23:58:31 +00005251
5252 // FIXME: 'template' keyword location not saved anywhere, so we fake it.
5253 Builder.Extend(*Context,
5254 Template? T->getTypeLoc().getBeginLoc() : SourceLocation(),
5255 T->getTypeLoc(), ColonColonLoc);
Douglas Gregordc355712011-02-25 00:36:19 +00005256 break;
5257 }
5258
5259 case NestedNameSpecifier::Global: {
Douglas Gregordc355712011-02-25 00:36:19 +00005260 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
Douglas Gregor5f791bb2011-02-28 23:58:31 +00005261 Builder.MakeGlobal(*Context, ColonColonLoc);
Douglas Gregordc355712011-02-25 00:36:19 +00005262 break;
5263 }
5264 }
Douglas Gregordc355712011-02-25 00:36:19 +00005265 }
5266
Douglas Gregor5f791bb2011-02-28 23:58:31 +00005267 return Builder.getWithLocInContext(*Context);
Douglas Gregordc355712011-02-25 00:36:19 +00005268}
5269
Chris Lattner6ad9ac02010-05-07 21:43:38 +00005270SourceRange
Douglas Gregor72a9ae12011-07-22 16:00:58 +00005271ASTReader::ReadSourceRange(Module &F, const RecordData &Record,
Sebastian Redlc3632732010-10-05 15:59:54 +00005272 unsigned &Idx) {
5273 SourceLocation beg = ReadSourceLocation(F, Record, Idx);
5274 SourceLocation end = ReadSourceLocation(F, Record, Idx);
Daniel Dunbar8ee59392010-06-02 15:47:10 +00005275 return SourceRange(beg, end);
Chris Lattner6ad9ac02010-05-07 21:43:38 +00005276}
5277
Douglas Gregor0a2b45e2009-04-13 18:14:40 +00005278/// \brief Read an integral value
Sebastian Redlc43b54c2010-08-18 23:56:43 +00005279llvm::APInt ASTReader::ReadAPInt(const RecordData &Record, unsigned &Idx) {
Douglas Gregor0a2b45e2009-04-13 18:14:40 +00005280 unsigned BitWidth = Record[Idx++];
5281 unsigned NumWords = llvm::APInt::getNumWords(BitWidth);
5282 llvm::APInt Result(BitWidth, NumWords, &Record[Idx]);
5283 Idx += NumWords;
5284 return Result;
5285}
5286
5287/// \brief Read a signed integral value
Sebastian Redlc43b54c2010-08-18 23:56:43 +00005288llvm::APSInt ASTReader::ReadAPSInt(const RecordData &Record, unsigned &Idx) {
Douglas Gregor0a2b45e2009-04-13 18:14:40 +00005289 bool isUnsigned = Record[Idx++];
5290 return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned);
5291}
5292
Douglas Gregor17fc2232009-04-14 21:55:33 +00005293/// \brief Read a floating-point value
Sebastian Redlc43b54c2010-08-18 23:56:43 +00005294llvm::APFloat ASTReader::ReadAPFloat(const RecordData &Record, unsigned &Idx) {
Douglas Gregor17fc2232009-04-14 21:55:33 +00005295 return llvm::APFloat(ReadAPInt(Record, Idx));
5296}
5297
Douglas Gregor68a2eb02009-04-15 21:30:51 +00005298// \brief Read a string
Sebastian Redlc43b54c2010-08-18 23:56:43 +00005299std::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) {
Douglas Gregor68a2eb02009-04-15 21:30:51 +00005300 unsigned Len = Record[Idx++];
Jay Foadbeaaccd2009-05-21 09:52:38 +00005301 std::string Result(Record.data() + Idx, Record.data() + Idx + Len);
Douglas Gregor68a2eb02009-04-15 21:30:51 +00005302 Idx += Len;
5303 return Result;
5304}
5305
Douglas Gregor0a0d2b12011-03-23 00:50:03 +00005306VersionTuple ASTReader::ReadVersionTuple(const RecordData &Record,
5307 unsigned &Idx) {
5308 unsigned Major = Record[Idx++];
5309 unsigned Minor = Record[Idx++];
5310 unsigned Subminor = Record[Idx++];
5311 if (Minor == 0)
5312 return VersionTuple(Major);
5313 if (Subminor == 0)
5314 return VersionTuple(Major, Minor - 1);
5315 return VersionTuple(Major, Minor - 1, Subminor - 1);
5316}
5317
Douglas Gregor72a9ae12011-07-22 16:00:58 +00005318CXXTemporary *ASTReader::ReadCXXTemporary(Module &F,
Douglas Gregor409448c2011-07-21 22:35:25 +00005319 const RecordData &Record,
Chris Lattnerd2598362010-05-10 00:25:06 +00005320 unsigned &Idx) {
Douglas Gregor409448c2011-07-21 22:35:25 +00005321 CXXDestructorDecl *Decl = ReadDeclAs<CXXDestructorDecl>(F, Record, Idx);
Chris Lattnerd2598362010-05-10 00:25:06 +00005322 return CXXTemporary::Create(*Context, Decl);
5323}
5324
Sebastian Redlc43b54c2010-08-18 23:56:43 +00005325DiagnosticBuilder ASTReader::Diag(unsigned DiagID) {
Douglas Gregore1d918e2009-04-10 23:10:45 +00005326 return Diag(SourceLocation(), DiagID);
5327}
5328
Sebastian Redlc43b54c2010-08-18 23:56:43 +00005329DiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) {
Argyrios Kyrtzidis33e4e702010-11-18 20:06:41 +00005330 return Diags.Report(Loc, DiagID);
Douglas Gregor0a0428e2009-04-10 20:39:37 +00005331}
Douglas Gregor025452f2009-04-17 00:04:06 +00005332
Douglas Gregor668c1a42009-04-21 22:25:48 +00005333/// \brief Retrieve the identifier table associated with the
5334/// preprocessor.
Sebastian Redlc43b54c2010-08-18 23:56:43 +00005335IdentifierTable &ASTReader::getIdentifierTable() {
Argyrios Kyrtzidis11e51102009-06-19 00:03:23 +00005336 assert(PP && "Forgot to set Preprocessor ?");
5337 return PP->getIdentifierTable();
Douglas Gregor668c1a42009-04-21 22:25:48 +00005338}
5339
Douglas Gregor025452f2009-04-17 00:04:06 +00005340/// \brief Record that the given ID maps to the given switch-case
5341/// statement.
Sebastian Redlc43b54c2010-08-18 23:56:43 +00005342void ASTReader::RecordSwitchCaseID(SwitchCase *SC, unsigned ID) {
Douglas Gregor025452f2009-04-17 00:04:06 +00005343 assert(SwitchCaseStmts[ID] == 0 && "Already have a SwitchCase with this ID");
5344 SwitchCaseStmts[ID] = SC;
5345}
5346
5347/// \brief Retrieve the switch-case statement with the given ID.
Sebastian Redlc43b54c2010-08-18 23:56:43 +00005348SwitchCase *ASTReader::getSwitchCaseWithID(unsigned ID) {
Douglas Gregor025452f2009-04-17 00:04:06 +00005349 assert(SwitchCaseStmts[ID] != 0 && "No SwitchCase with this ID");
5350 return SwitchCaseStmts[ID];
5351}
Douglas Gregor1de05fe2009-04-17 18:18:49 +00005352
Argyrios Kyrtzidise09a2752010-10-28 09:29:32 +00005353void ASTReader::ClearSwitchCaseIDs() {
5354 SwitchCaseStmts.clear();
5355}
5356
Sebastian Redlc43b54c2010-08-18 23:56:43 +00005357void ASTReader::FinishedDeserializing() {
Argyrios Kyrtzidis29ee3a22010-07-30 10:03:16 +00005358 assert(NumCurrentElementsDeserializing &&
5359 "FinishedDeserializing not paired with StartedDeserializing");
5360 if (NumCurrentElementsDeserializing == 1) {
Douglas Gregord89275b2009-07-06 18:54:52 +00005361 // If any identifiers with corresponding top-level declarations have
5362 // been loaded, load those declarations now.
Argyrios Kyrtzidis29ee3a22010-07-30 10:03:16 +00005363 while (!PendingIdentifierInfos.empty()) {
5364 SetGloballyVisibleDecls(PendingIdentifierInfos.front().II,
5365 PendingIdentifierInfos.front().DeclIDs, true);
5366 PendingIdentifierInfos.pop_front();
Douglas Gregord89275b2009-07-06 18:54:52 +00005367 }
Argyrios Kyrtzidisbb80a8e2010-07-07 15:46:26 +00005368
Argyrios Kyrtzidis0895d152011-02-12 07:50:47 +00005369 // Ready to load previous declarations of Decls that were delayed.
5370 while (!PendingPreviousDecls.empty()) {
5371 loadAndAttachPreviousDecl(PendingPreviousDecls.front().first,
5372 PendingPreviousDecls.front().second);
5373 PendingPreviousDecls.pop_front();
5374 }
5375
Argyrios Kyrtzidisbb80a8e2010-07-07 15:46:26 +00005376 // We are not in recursive loading, so it's safe to pass the "interesting"
5377 // decls to the consumer.
Argyrios Kyrtzidis29ee3a22010-07-30 10:03:16 +00005378 if (Consumer)
5379 PassInterestingDeclsToConsumer();
Argyrios Kyrtzidis134db1f2010-10-24 17:26:31 +00005380
5381 assert(PendingForwardRefs.size() == 0 &&
5382 "Some forward refs did not get linked to the definition!");
Douglas Gregord89275b2009-07-06 18:54:52 +00005383 }
Argyrios Kyrtzidis29ee3a22010-07-30 10:03:16 +00005384 --NumCurrentElementsDeserializing;
Douglas Gregord89275b2009-07-06 18:54:52 +00005385}
Douglas Gregor501c1032010-08-19 00:28:17 +00005386
Sebastian Redle1dde812010-08-24 00:50:04 +00005387ASTReader::ASTReader(Preprocessor &PP, ASTContext *Context,
Douglas Gregor832d6202011-07-22 16:35:34 +00005388 StringRef isysroot, bool DisableValidation,
Douglas Gregor8ef6c8c2011-02-05 19:42:43 +00005389 bool DisableStatCache)
Sebastian Redle1dde812010-08-24 00:50:04 +00005390 : Listener(new PCHValidator(PP, *this)), DeserializationListener(0),
5391 SourceMgr(PP.getSourceManager()), FileMgr(PP.getFileManager()),
5392 Diags(PP.getDiagnostics()), SemaObj(0), PP(&PP), Context(Context),
Jonathan D. Turner1afb6612011-07-28 17:20:23 +00005393 Consumer(0), ModuleMgr(FileMgr.getFileSystemOptions()),
5394 RelocatablePCH(false), isysroot(isysroot),
Douglas Gregorf62d43d2011-07-19 16:10:42 +00005395 DisableValidation(DisableValidation),
Douglas Gregor8ef6c8c2011-02-05 19:42:43 +00005396 DisableStatCache(DisableStatCache), NumStatHits(0), NumStatMisses(0),
Douglas Gregorf62d43d2011-07-19 16:10:42 +00005397 NumSLocEntriesRead(0), TotalNumSLocEntries(0),
Douglas Gregor8ef6c8c2011-02-05 19:42:43 +00005398 NumStatementsRead(0), TotalNumStatements(0), NumMacrosRead(0),
5399 TotalNumMacros(0), NumSelectorsRead(0), NumMethodPoolEntriesRead(0),
5400 NumMethodPoolMisses(0), TotalNumMethodPoolEntries(0),
5401 NumLexicalDeclContextsRead(0), TotalLexicalDeclContexts(0),
Jonathan D. Turner1da90142011-07-21 21:15:19 +00005402 NumVisibleDeclContextsRead(0), TotalVisibleDeclContexts(0),
5403 TotalModulesSizeInBits(0), NumCurrentElementsDeserializing(0),
5404 NumCXXBaseSpecifiersLoaded(0)
Douglas Gregor8ef6c8c2011-02-05 19:42:43 +00005405{
Douglas Gregorf62d43d2011-07-19 16:10:42 +00005406 SourceMgr.setExternalSLocEntrySource(this);
Sebastian Redle1dde812010-08-24 00:50:04 +00005407}
5408
5409ASTReader::ASTReader(SourceManager &SourceMgr, FileManager &FileMgr,
Douglas Gregor832d6202011-07-22 16:35:34 +00005410 Diagnostic &Diags, StringRef isysroot,
Douglas Gregor8ef6c8c2011-02-05 19:42:43 +00005411 bool DisableValidation, bool DisableStatCache)
Sebastian Redle1dde812010-08-24 00:50:04 +00005412 : DeserializationListener(0), SourceMgr(SourceMgr), FileMgr(FileMgr),
Jonathan D. Turner1afb6612011-07-28 17:20:23 +00005413 Diags(Diags), SemaObj(0), PP(0), Context(0),
5414 Consumer(0), ModuleMgr(FileMgr.getFileSystemOptions()),
Douglas Gregorf62d43d2011-07-19 16:10:42 +00005415 RelocatablePCH(false), isysroot(isysroot),
5416 DisableValidation(DisableValidation), DisableStatCache(DisableStatCache),
5417 NumStatHits(0), NumStatMisses(0), NumSLocEntriesRead(0),
5418 TotalNumSLocEntries(0), NumStatementsRead(0),
5419 TotalNumStatements(0), NumMacrosRead(0), TotalNumMacros(0),
5420 NumSelectorsRead(0), NumMethodPoolEntriesRead(0), NumMethodPoolMisses(0),
Sebastian Redl8db9fae2010-09-22 20:19:08 +00005421 TotalNumMethodPoolEntries(0), NumLexicalDeclContextsRead(0),
5422 TotalLexicalDeclContexts(0), NumVisibleDeclContextsRead(0),
Jonathan D. Turner1da90142011-07-21 21:15:19 +00005423 TotalVisibleDeclContexts(0), TotalModulesSizeInBits(0),
5424 NumCurrentElementsDeserializing(0), NumCXXBaseSpecifiersLoaded(0)
Douglas Gregorf62d43d2011-07-19 16:10:42 +00005425{
5426 SourceMgr.setExternalSLocEntrySource(this);
Sebastian Redle1dde812010-08-24 00:50:04 +00005427}
5428
5429ASTReader::~ASTReader() {
Sebastian Redle1dde812010-08-24 00:50:04 +00005430 // Delete all visible decl lookup tables
5431 for (DeclContextOffsetsMap::iterator I = DeclContextOffsets.begin(),
5432 E = DeclContextOffsets.end();
5433 I != E; ++I) {
5434 for (DeclContextInfos::iterator J = I->second.begin(), F = I->second.end();
5435 J != F; ++J) {
5436 if (J->NameLookupTableData)
5437 delete static_cast<ASTDeclContextNameLookupTable*>(
5438 J->NameLookupTableData);
5439 }
5440 }
5441 for (DeclContextVisibleUpdatesPending::iterator
5442 I = PendingVisibleUpdates.begin(),
5443 E = PendingVisibleUpdates.end();
5444 I != E; ++I) {
5445 for (DeclContextVisibleUpdates::iterator J = I->second.begin(),
5446 F = I->second.end();
5447 J != F; ++J)
5448 delete static_cast<ASTDeclContextNameLookupTable*>(*J);
5449 }
5450}
5451
Douglas Gregor72a9ae12011-07-22 16:00:58 +00005452Module::Module(ModuleKind Kind)
5453 : Kind(Kind), SizeInBits(0), LocalNumSLocEntries(0), SLocEntryBaseID(0),
Douglas Gregorf62d43d2011-07-19 16:10:42 +00005454 SLocEntryBaseOffset(0), SLocEntryOffsets(0),
5455 SLocFileOffsets(0), LocalNumIdentifiers(0),
5456 IdentifierOffsets(0), IdentifierTableData(0),
Sebastian Redl301c9b02010-09-22 00:42:27 +00005457 IdentifierLookupTable(0), LocalNumMacroDefinitions(0),
Douglas Gregorf62d43d2011-07-19 16:10:42 +00005458 MacroDefinitionOffsets(0), LocalNumHeaderFileInfos(0),
5459 HeaderFileInfoTableData(0), HeaderFileInfoTable(0),
Douglas Gregorb4dc4852011-07-28 04:50:02 +00005460 HeaderFileFrameworkStrings(0),
Douglas Gregorcfbf1c72011-02-10 17:09:37 +00005461 LocalNumSelectors(0), SelectorOffsets(0),
Sebastian Redl301c9b02010-09-22 00:42:27 +00005462 SelectorLookupTableData(0), SelectorLookupTable(0), LocalNumDecls(0),
Douglas Gregor7c789c12010-10-29 22:39:52 +00005463 DeclOffsets(0), LocalNumCXXBaseSpecifiers(0), CXXBaseSpecifiersOffsets(0),
5464 LocalNumTypes(0), TypeOffsets(0), StatCache(0),
Jonathan D. Turnerb4ae29c2011-07-28 23:15:22 +00005465 NumPreallocatedPreprocessingEntities(0)
Douglas Gregor501c1032010-08-19 00:28:17 +00005466{}
5467
Douglas Gregor72a9ae12011-07-22 16:00:58 +00005468Module::~Module() {
Douglas Gregor501c1032010-08-19 00:28:17 +00005469 delete static_cast<ASTIdentifierLookupTable *>(IdentifierLookupTable);
Douglas Gregorcfbf1c72011-02-10 17:09:37 +00005470 delete static_cast<HeaderFileInfoLookupTable *>(HeaderFileInfoTable);
Douglas Gregor501c1032010-08-19 00:28:17 +00005471 delete static_cast<ASTSelectorLookupTable *>(SelectorLookupTable);
5472}
Jonathan D. Turner48d2c3f2011-07-26 18:21:30 +00005473
Jonathan D. Turner1afb6612011-07-28 17:20:23 +00005474Module *ModuleManager::lookup(StringRef Name) {
5475 const FileEntry *Entry = FileMgr.getFile(Name);
5476 return Modules[Entry];
5477}
5478
Jonathan D. Turner48d2c3f2011-07-26 18:21:30 +00005479/// \brief Creates a new module and adds it to the list of known modules
5480Module &ModuleManager::addModule(StringRef FileName, ModuleKind Type) {
5481 Module *Prev = !size() ? 0 : &getLastModule();
5482 Module *Current = new Module(Type);
5483
5484 Current->FileName = FileName.str();
5485
5486 Chain.push_back(Current);
Jonathan D. Turner1afb6612011-07-28 17:20:23 +00005487 const FileEntry *Entry = FileMgr.getFile(FileName);
5488 Modules[Entry] = Current;
Jonathan D. Turner48d2c3f2011-07-26 18:21:30 +00005489
Jonathan D. Turner48d2c3f2011-07-26 18:21:30 +00005490 Current->Loaders.push_back(Prev);
5491
5492 return *Current;
5493}
5494
5495/// \brief Exports the list of loaded modules with their corresponding names
5496void ModuleManager::exportLookup(SmallVector<ModuleOffset, 16> &Target) {
5497 Target.reserve(size());
Jonathan D. Turner1afb6612011-07-28 17:20:23 +00005498 for (ModuleConstIterator I = Chain.begin(), E = Chain.end();
Jonathan D. Turner48d2c3f2011-07-26 18:21:30 +00005499 I != E; ++I) {
Jonathan D. Turner1afb6612011-07-28 17:20:23 +00005500 Target.push_back(ModuleOffset((*I)->SLocEntryBaseOffset,
5501 (*I)->FileName));
Jonathan D. Turner48d2c3f2011-07-26 18:21:30 +00005502 }
5503 std::sort(Target.begin(), Target.end());
5504}
5505
Jonathan D. Turner1afb6612011-07-28 17:20:23 +00005506ModuleManager::ModuleManager(const FileSystemOptions &FSO) : FileMgr(FSO) { }
5507
Jonathan D. Turner48d2c3f2011-07-26 18:21:30 +00005508ModuleManager::~ModuleManager() {
5509 for (unsigned i = 0, e = Chain.size(); i != e; ++i)
5510 delete Chain[e - i - 1];
5511}