lib/Frontend/ASTUnit.cpp

   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
  81 ASTUnit *ASTUnit::LoadFromPCHFile(const std::string &Filename,
  82                                   FileManager &FileMgr,
  83                                   std::string *ErrMsg) {
  84
  85   llvm::OwningPtr<ASTUnit> AST(new ASTUnit());
  86
  87   AST->DiagClient.reset(new TextDiagnosticBuffer());
  88   AST->Diags.reset(new Diagnostic(AST->DiagClient.get()));
  89
  90   AST->HeaderInfo.reset(new HeaderSearch(FileMgr));
  91   AST->SourceMgr.reset(new SourceManager());
  92
  93   Diagnostic &Diags = *AST->Diags.get();
  94   SourceManager &SourceMgr = *AST->SourceMgr.get();
  95
  96   // Gather Info for preprocessor construction later on.
  97
  98   LangOptions LangInfo;
  99   HeaderSearch &HeaderInfo = *AST->HeaderInfo.get();
 100   std::string TargetTriple;
 101   std::string Predefines;
 102   unsigned Counter;
 103
 104   llvm::OwningPtr<PCHReader> Reader;
 105   llvm::OwningPtr<ExternalASTSource> Source;
 106
 107   Reader.reset(new PCHReader(SourceMgr, FileMgr, Diags));
 108   Reader->setListener(new PCHInfoCollector(LangInfo, HeaderInfo, TargetTriple,
 109                                            Predefines, Counter));
 110
 111   switch (Reader->ReadPCH(Filename)) {
 112   case PCHReader::Success:
 113     break;
 114
 115   case PCHReader::Failure:
 116     // Unrecoverable failure: don't even try to process the input
 117     // file.
 118     if (ErrMsg)
 119       *ErrMsg = "Could not load PCH file";
 120     return NULL;
 121
 122   case PCHReader::IgnorePCH:
 123     assert(0 && "Is there a validation that should not have happened ?");
 124   }
 125
 126   // PCH loaded successfully. Now create the preprocessor.
 127
 128   // Get information about the target being compiled for.
 129   AST->Target.reset(TargetInfo::CreateTargetInfo(TargetTriple));
 130   AST->PP.reset(new Preprocessor(Diags, LangInfo, *AST->Target.get(),
 131                                  SourceMgr, HeaderInfo));
 132   Preprocessor &PP = *AST->PP.get();
 133
 134   PP.setPredefines(Predefines);
 135   PP.setCounterValue(Counter);
 136   Reader->setPreprocessor(PP);
 137
 138   // Create and initialize the ASTContext.
 139
 140   AST->Ctx.reset(new ASTContext(LangInfo,
 141                                 SourceMgr,
 142                                 *AST->Target.get(),
 143                                 PP.getIdentifierTable(),
 144                                 PP.getSelectorTable(),
 145                                 PP.getBuiltinInfo(),
 146                                 /* FreeMemory = */ true,
 147                                 /* size_reserve = */0));
 148   ASTContext &Context = *AST->Ctx.get();
 149
 150   Reader->InitializeContext(Context);
 151
 152   // Attach the PCH reader to the AST context as an external AST
 153   // source, so that declarations will be deserialized from the
 154   // PCH file as needed.
 155   Source.reset(Reader.take());
 156   Context.setExternalSource(Source);
 157
 158   return AST.take();
 159 }