1 //===--- ASTUnit.cpp - ASTUnit utility ------------------------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // ASTUnit Implementation.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "clang/Frontend/ASTUnit.h"
15 #include "clang/Frontend/PCHReader.h"
16 #include "clang/Frontend/TextDiagnosticBuffer.h"
17 #include "clang/AST/ASTContext.h"
18 #include "clang/AST/DeclVisitor.h"
19 #include "clang/AST/StmtVisitor.h"
20 #include "clang/Lex/HeaderSearch.h"
21 #include "clang/Lex/Preprocessor.h"
22 #include "clang/Basic/TargetInfo.h"
23 #include "clang/Basic/Diagnostic.h"
24 #include "llvm/Support/Compiler.h"
25 
26 using namespace clang;
27 
28 ASTUnit::ASTUnit() { }
29 ASTUnit::~ASTUnit() { }
30 
31 namespace {
32 
33 /// \brief Gathers information from PCHReader that will be used to initialize
34 /// a Preprocessor.
35 class VISIBILITY_HIDDEN PCHInfoCollector : public PCHReaderListener {
36   LangOptions &LangOpt;
37   HeaderSearch &HSI;
38   std::string &TargetTriple;
39   std::string &Predefines;
40   unsigned &Counter;
41 
42   unsigned NumHeaderInfos;
43 
44 public:
45   PCHInfoCollector(LangOptions &LangOpt, HeaderSearch &HSI,
46                    std::string &TargetTriple, std::string &Predefines,
47                    unsigned &Counter)
48     : LangOpt(LangOpt), HSI(HSI), TargetTriple(TargetTriple),
49       Predefines(Predefines), Counter(Counter), NumHeaderInfos(0) {}
50 
51   virtual bool ReadLanguageOptions(const LangOptions &LangOpts) {
52     LangOpt = LangOpts;
53     return false;
54   }
55 
56   virtual bool ReadTargetTriple(const std::string &Triple) {
57     TargetTriple = Triple;
58     return false;
59   }
60 
61   virtual bool ReadPredefinesBuffer(const char *PCHPredef,
62                                     unsigned PCHPredefLen,
63                                     FileID PCHBufferID,
64                                     std::string &SuggestedPredefines) {
65     Predefines = PCHPredef;
66     return false;
67   }
68 
69   virtual void ReadHeaderFileInfo(const HeaderFileInfo &HFI) {
70     HSI.setHeaderFileInfoForUID(HFI, NumHeaderInfos++);
71   }
72 
73   virtual void ReadCounter(unsigned Value) {
74     Counter = Value;
75   }
76 };
77 
78 } // anonymous namespace
79 
80 const std::string &ASTUnit::getOriginalSourceFileName() {
81   return dyn_cast<PCHReader>(Ctx->getExternalSource())->getOriginalSourceFile();
82 }
83 
84 FileManager &ASTUnit::getFileManager() {
85   return HeaderInfo->getFileMgr();
86 }
87 
88 ASTUnit *ASTUnit::LoadFromPCHFile(const std::string &Filename,
89                                   FileManager &FileMgr,
90                                   std::string *ErrMsg) {
91 
92   llvm::OwningPtr<ASTUnit> AST(new ASTUnit());
93 
94   AST->DiagClient.reset(new TextDiagnosticBuffer());
95   AST->Diags.reset(new Diagnostic(AST->DiagClient.get()));
96 
97   AST->HeaderInfo.reset(new HeaderSearch(FileMgr));
98   AST->SourceMgr.reset(new SourceManager());
99 
100   Diagnostic &Diags = *AST->Diags.get();
101   SourceManager &SourceMgr = *AST->SourceMgr.get();
102 
103   // Gather Info for preprocessor construction later on.
104 
105   LangOptions LangInfo;
106   HeaderSearch &HeaderInfo = *AST->HeaderInfo.get();
107   std::string TargetTriple;
108   std::string Predefines;
109   unsigned Counter;
110 
111   llvm::OwningPtr<PCHReader> Reader;
112   llvm::OwningPtr<ExternalASTSource> Source;
113 
114   Reader.reset(new PCHReader(SourceMgr, FileMgr, Diags));
115   Reader->setListener(new PCHInfoCollector(LangInfo, HeaderInfo, TargetTriple,
116                                            Predefines, Counter));
117 
118   switch (Reader->ReadPCH(Filename)) {
119   case PCHReader::Success:
120     break;
121 
122   case PCHReader::Failure:
123   case PCHReader::IgnorePCH:
124     if (ErrMsg)
125       *ErrMsg = "Could not load PCH file";
126     return NULL;
127   }
128 
129   // PCH loaded successfully. Now create the preprocessor.
130 
131   // Get information about the target being compiled for.
132   AST->Target.reset(TargetInfo::CreateTargetInfo(TargetTriple));
133   AST->PP.reset(new Preprocessor(Diags, LangInfo, *AST->Target.get(),
134                                  SourceMgr, HeaderInfo));
135   Preprocessor &PP = *AST->PP.get();
136 
137   PP.setPredefines(Predefines);
138   PP.setCounterValue(Counter);
139   Reader->setPreprocessor(PP);
140 
141   // Create and initialize the ASTContext.
142 
143   AST->Ctx.reset(new ASTContext(LangInfo,
144                                 SourceMgr,
145                                 *AST->Target.get(),
146                                 PP.getIdentifierTable(),
147                                 PP.getSelectorTable(),
148                                 PP.getBuiltinInfo(),
149                                 /* FreeMemory = */ true,
150                                 /* size_reserve = */0));
151   ASTContext &Context = *AST->Ctx.get();
152 
153   Reader->InitializeContext(Context);
154 
155   // Attach the PCH reader to the AST context as an external AST
156   // source, so that declarations will be deserialized from the
157   // PCH file as needed.
158   Source.reset(Reader.take());
159   Context.setExternalSource(Source);
160 
161   return AST.take();
162 }
163