ASTUnit.cpp revision 98b7c5c496dfccb39287b8f7d8f1444594936d10
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/AST/ASTContext.h" 17#include "clang/AST/ASTConsumer.h" 18#include "clang/AST/DeclVisitor.h" 19#include "clang/AST/StmtVisitor.h" 20#include "clang/Driver/Compilation.h" 21#include "clang/Driver/Driver.h" 22#include "clang/Driver/Job.h" 23#include "clang/Driver/Tool.h" 24#include "clang/Frontend/CompilerInstance.h" 25#include "clang/Frontend/FrontendActions.h" 26#include "clang/Frontend/FrontendDiagnostic.h" 27#include "clang/Frontend/FrontendOptions.h" 28#include "clang/Lex/HeaderSearch.h" 29#include "clang/Lex/Preprocessor.h" 30#include "clang/Basic/TargetOptions.h" 31#include "clang/Basic/TargetInfo.h" 32#include "clang/Basic/Diagnostic.h" 33#include "llvm/Support/MemoryBuffer.h" 34#include "llvm/System/Host.h" 35#include "llvm/System/Path.h" 36using namespace clang; 37 38ASTUnit::ASTUnit(bool _MainFileIsAST) 39 : MainFileIsAST(_MainFileIsAST), ConcurrencyCheckValue(CheckUnlocked) { } 40 41ASTUnit::~ASTUnit() { 42 ConcurrencyCheckValue = CheckLocked; 43 for (unsigned I = 0, N = TemporaryFiles.size(); I != N; ++I) 44 TemporaryFiles[I].eraseFromDisk(); 45} 46 47namespace { 48 49/// \brief Gathers information from PCHReader that will be used to initialize 50/// a Preprocessor. 51class PCHInfoCollector : public PCHReaderListener { 52 LangOptions &LangOpt; 53 HeaderSearch &HSI; 54 std::string &TargetTriple; 55 std::string &Predefines; 56 unsigned &Counter; 57 58 unsigned NumHeaderInfos; 59 60public: 61 PCHInfoCollector(LangOptions &LangOpt, HeaderSearch &HSI, 62 std::string &TargetTriple, std::string &Predefines, 63 unsigned &Counter) 64 : LangOpt(LangOpt), HSI(HSI), TargetTriple(TargetTriple), 65 Predefines(Predefines), Counter(Counter), NumHeaderInfos(0) {} 66 67 virtual bool ReadLanguageOptions(const LangOptions &LangOpts) { 68 LangOpt = LangOpts; 69 return false; 70 } 71 72 virtual bool ReadTargetTriple(llvm::StringRef Triple) { 73 TargetTriple = Triple; 74 return false; 75 } 76 77 virtual bool ReadPredefinesBuffer(llvm::StringRef PCHPredef, 78 FileID PCHBufferID, 79 llvm::StringRef OriginalFileName, 80 std::string &SuggestedPredefines) { 81 Predefines = PCHPredef; 82 return false; 83 } 84 85 virtual void ReadHeaderFileInfo(const HeaderFileInfo &HFI, unsigned ID) { 86 HSI.setHeaderFileInfoForUID(HFI, NumHeaderInfos++); 87 } 88 89 virtual void ReadCounter(unsigned Value) { 90 Counter = Value; 91 } 92}; 93 94class StoredDiagnosticClient : public DiagnosticClient { 95 llvm::SmallVectorImpl<StoredDiagnostic> &StoredDiags; 96 97public: 98 explicit StoredDiagnosticClient( 99 llvm::SmallVectorImpl<StoredDiagnostic> &StoredDiags) 100 : StoredDiags(StoredDiags) { } 101 102 virtual void HandleDiagnostic(Diagnostic::Level Level, 103 const DiagnosticInfo &Info); 104}; 105 106/// \brief RAII object that optionally captures diagnostics, if 107/// there is no diagnostic client to capture them already. 108class CaptureDroppedDiagnostics { 109 Diagnostic &Diags; 110 StoredDiagnosticClient Client; 111 DiagnosticClient *PreviousClient; 112 113public: 114 CaptureDroppedDiagnostics(bool RequestCapture, Diagnostic &Diags, 115 llvm::SmallVectorImpl<StoredDiagnostic> &StoredDiags) 116 : Diags(Diags), Client(StoredDiags), PreviousClient(Diags.getClient()) 117 { 118 if (RequestCapture || Diags.getClient() == 0) 119 Diags.setClient(&Client); 120 } 121 122 ~CaptureDroppedDiagnostics() { 123 Diags.setClient(PreviousClient); 124 } 125}; 126 127} // anonymous namespace 128 129void StoredDiagnosticClient::HandleDiagnostic(Diagnostic::Level Level, 130 const DiagnosticInfo &Info) { 131 StoredDiags.push_back(StoredDiagnostic(Level, Info)); 132} 133 134const std::string &ASTUnit::getOriginalSourceFileName() { 135 return OriginalSourceFile; 136} 137 138const std::string &ASTUnit::getPCHFileName() { 139 assert(isMainFileAST() && "Not an ASTUnit from a PCH file!"); 140 return static_cast<PCHReader *>(Ctx->getExternalSource())->getFileName(); 141} 142 143ASTUnit *ASTUnit::LoadFromPCHFile(const std::string &Filename, 144 llvm::IntrusiveRefCntPtr<Diagnostic> Diags, 145 bool OnlyLocalDecls, 146 RemappedFile *RemappedFiles, 147 unsigned NumRemappedFiles, 148 bool CaptureDiagnostics) { 149 llvm::OwningPtr<ASTUnit> AST(new ASTUnit(true)); 150 151 if (!Diags.getPtr()) { 152 // No diagnostics engine was provided, so create our own diagnostics object 153 // with the default options. 154 DiagnosticOptions DiagOpts; 155 Diags = CompilerInstance::createDiagnostics(DiagOpts, 0, 0); 156 } 157 158 AST->OnlyLocalDecls = OnlyLocalDecls; 159 AST->Diagnostics = Diags; 160 AST->FileMgr.reset(new FileManager); 161 AST->SourceMgr.reset(new SourceManager(AST->getDiagnostics())); 162 AST->HeaderInfo.reset(new HeaderSearch(AST->getFileManager())); 163 164 // If requested, capture diagnostics in the ASTUnit. 165 CaptureDroppedDiagnostics Capture(CaptureDiagnostics, AST->getDiagnostics(), 166 AST->StoredDiagnostics); 167 168 for (unsigned I = 0; I != NumRemappedFiles; ++I) { 169 // Create the file entry for the file that we're mapping from. 170 const FileEntry *FromFile 171 = AST->getFileManager().getVirtualFile(RemappedFiles[I].first, 172 RemappedFiles[I].second->getBufferSize(), 173 0); 174 if (!FromFile) { 175 AST->getDiagnostics().Report(diag::err_fe_remap_missing_from_file) 176 << RemappedFiles[I].first; 177 delete RemappedFiles[I].second; 178 continue; 179 } 180 181 // Override the contents of the "from" file with the contents of 182 // the "to" file. 183 AST->getSourceManager().overrideFileContents(FromFile, 184 RemappedFiles[I].second); 185 } 186 187 // Gather Info for preprocessor construction later on. 188 189 LangOptions LangInfo; 190 HeaderSearch &HeaderInfo = *AST->HeaderInfo.get(); 191 std::string TargetTriple; 192 std::string Predefines; 193 unsigned Counter; 194 195 llvm::OwningPtr<PCHReader> Reader; 196 llvm::OwningPtr<ExternalASTSource> Source; 197 198 Reader.reset(new PCHReader(AST->getSourceManager(), AST->getFileManager(), 199 AST->getDiagnostics())); 200 Reader->setListener(new PCHInfoCollector(LangInfo, HeaderInfo, TargetTriple, 201 Predefines, Counter)); 202 203 switch (Reader->ReadPCH(Filename)) { 204 case PCHReader::Success: 205 break; 206 207 case PCHReader::Failure: 208 case PCHReader::IgnorePCH: 209 AST->getDiagnostics().Report(diag::err_fe_unable_to_load_pch); 210 return NULL; 211 } 212 213 AST->OriginalSourceFile = Reader->getOriginalSourceFile(); 214 215 // PCH loaded successfully. Now create the preprocessor. 216 217 // Get information about the target being compiled for. 218 // 219 // FIXME: This is broken, we should store the TargetOptions in the PCH. 220 TargetOptions TargetOpts; 221 TargetOpts.ABI = ""; 222 TargetOpts.CXXABI = "itanium"; 223 TargetOpts.CPU = ""; 224 TargetOpts.Features.clear(); 225 TargetOpts.Triple = TargetTriple; 226 AST->Target.reset(TargetInfo::CreateTargetInfo(AST->getDiagnostics(), 227 TargetOpts)); 228 AST->PP.reset(new Preprocessor(AST->getDiagnostics(), LangInfo, 229 *AST->Target.get(), 230 AST->getSourceManager(), HeaderInfo)); 231 Preprocessor &PP = *AST->PP.get(); 232 233 PP.setPredefines(Reader->getSuggestedPredefines()); 234 PP.setCounterValue(Counter); 235 Reader->setPreprocessor(PP); 236 237 // Create and initialize the ASTContext. 238 239 AST->Ctx.reset(new ASTContext(LangInfo, 240 AST->getSourceManager(), 241 *AST->Target.get(), 242 PP.getIdentifierTable(), 243 PP.getSelectorTable(), 244 PP.getBuiltinInfo(), 245 /* FreeMemory = */ false, 246 /* size_reserve = */0)); 247 ASTContext &Context = *AST->Ctx.get(); 248 249 Reader->InitializeContext(Context); 250 251 // Attach the PCH reader to the AST context as an external AST 252 // source, so that declarations will be deserialized from the 253 // PCH file as needed. 254 Source.reset(Reader.take()); 255 Context.setExternalSource(Source); 256 257 return AST.take(); 258} 259 260namespace { 261 262class TopLevelDeclTrackerConsumer : public ASTConsumer { 263 ASTUnit &Unit; 264 265public: 266 TopLevelDeclTrackerConsumer(ASTUnit &_Unit) : Unit(_Unit) {} 267 268 void HandleTopLevelDecl(DeclGroupRef D) { 269 for (DeclGroupRef::iterator it = D.begin(), ie = D.end(); it != ie; ++it) { 270 Decl *D = *it; 271 // FIXME: Currently ObjC method declarations are incorrectly being 272 // reported as top-level declarations, even though their DeclContext 273 // is the containing ObjC @interface/@implementation. This is a 274 // fundamental problem in the parser right now. 275 if (isa<ObjCMethodDecl>(D)) 276 continue; 277 Unit.getTopLevelDecls().push_back(D); 278 } 279 } 280}; 281 282class TopLevelDeclTrackerAction : public ASTFrontendAction { 283public: 284 ASTUnit &Unit; 285 286 virtual ASTConsumer *CreateASTConsumer(CompilerInstance &CI, 287 llvm::StringRef InFile) { 288 return new TopLevelDeclTrackerConsumer(Unit); 289 } 290 291public: 292 TopLevelDeclTrackerAction(ASTUnit &_Unit) : Unit(_Unit) {} 293 294 virtual bool hasCodeCompletionSupport() const { return false; } 295}; 296 297} 298 299ASTUnit *ASTUnit::LoadFromCompilerInvocation(CompilerInvocation *CI, 300 llvm::IntrusiveRefCntPtr<Diagnostic> Diags, 301 bool OnlyLocalDecls, 302 bool CaptureDiagnostics) { 303 // Create the compiler instance to use for building the AST. 304 CompilerInstance Clang; 305 llvm::OwningPtr<ASTUnit> AST; 306 llvm::OwningPtr<TopLevelDeclTrackerAction> Act; 307 308 if (!Diags.getPtr()) { 309 // No diagnostics engine was provided, so create our own diagnostics object 310 // with the default options. 311 DiagnosticOptions DiagOpts; 312 Diags = CompilerInstance::createDiagnostics(DiagOpts, 0, 0); 313 } 314 315 Clang.setInvocation(CI); 316 317 Clang.setDiagnostics(Diags.getPtr()); 318 Clang.setDiagnosticClient(Diags->getClient()); 319 320 // Create the target instance. 321 Clang.setTarget(TargetInfo::CreateTargetInfo(Clang.getDiagnostics(), 322 Clang.getTargetOpts())); 323 if (!Clang.hasTarget()) { 324 Clang.takeDiagnosticClient(); 325 return 0; 326 } 327 328 // Inform the target of the language options. 329 // 330 // FIXME: We shouldn't need to do this, the target should be immutable once 331 // created. This complexity should be lifted elsewhere. 332 Clang.getTarget().setForcedLangOptions(Clang.getLangOpts()); 333 334 assert(Clang.getFrontendOpts().Inputs.size() == 1 && 335 "Invocation must have exactly one source file!"); 336 assert(Clang.getFrontendOpts().Inputs[0].first != IK_AST && 337 "FIXME: AST inputs not yet supported here!"); 338 assert(Clang.getFrontendOpts().Inputs[0].first != IK_LLVM_IR && 339 "IR inputs not support here!"); 340 341 // Create the AST unit. 342 AST.reset(new ASTUnit(false)); 343 AST->Diagnostics = Diags; 344 AST->FileMgr.reset(new FileManager); 345 AST->SourceMgr.reset(new SourceManager(AST->getDiagnostics())); 346 AST->OnlyLocalDecls = OnlyLocalDecls; 347 AST->OriginalSourceFile = Clang.getFrontendOpts().Inputs[0].second; 348 349 // Capture any diagnostics that would otherwise be dropped. 350 CaptureDroppedDiagnostics Capture(CaptureDiagnostics, 351 Clang.getDiagnostics(), 352 AST->StoredDiagnostics); 353 354 // Create a file manager object to provide access to and cache the filesystem. 355 Clang.setFileManager(&AST->getFileManager()); 356 357 // Create the source manager. 358 Clang.setSourceManager(&AST->getSourceManager()); 359 360 Act.reset(new TopLevelDeclTrackerAction(*AST)); 361 if (!Act->BeginSourceFile(Clang, Clang.getFrontendOpts().Inputs[0].second, 362 Clang.getFrontendOpts().Inputs[0].first)) 363 goto error; 364 365 Act->Execute(); 366 367 // Steal the created target, context, and preprocessor, and take back the 368 // source and file managers. 369 AST->Ctx.reset(Clang.takeASTContext()); 370 AST->PP.reset(Clang.takePreprocessor()); 371 Clang.takeSourceManager(); 372 Clang.takeFileManager(); 373 AST->Target.reset(Clang.takeTarget()); 374 375 Act->EndSourceFile(); 376 377 Clang.takeDiagnosticClient(); 378 Clang.takeInvocation(); 379 380 AST->Invocation.reset(Clang.takeInvocation()); 381 return AST.take(); 382 383error: 384 Clang.takeSourceManager(); 385 Clang.takeFileManager(); 386 Clang.takeDiagnosticClient(); 387 return 0; 388} 389 390ASTUnit *ASTUnit::LoadFromCommandLine(const char **ArgBegin, 391 const char **ArgEnd, 392 llvm::IntrusiveRefCntPtr<Diagnostic> Diags, 393 llvm::StringRef ResourceFilesPath, 394 bool OnlyLocalDecls, 395 RemappedFile *RemappedFiles, 396 unsigned NumRemappedFiles, 397 bool CaptureDiagnostics) { 398 if (!Diags.getPtr()) { 399 // No diagnostics engine was provided, so create our own diagnostics object 400 // with the default options. 401 DiagnosticOptions DiagOpts; 402 Diags = CompilerInstance::createDiagnostics(DiagOpts, 0, 0); 403 } 404 405 llvm::SmallVector<const char *, 16> Args; 406 Args.push_back("<clang>"); // FIXME: Remove dummy argument. 407 Args.insert(Args.end(), ArgBegin, ArgEnd); 408 409 // FIXME: Find a cleaner way to force the driver into restricted modes. We 410 // also want to force it to use clang. 411 Args.push_back("-fsyntax-only"); 412 413 // FIXME: We shouldn't have to pass in the path info. 414 driver::Driver TheDriver("clang", "/", llvm::sys::getHostTriple(), 415 "a.out", false, false, *Diags); 416 417 // Don't check that inputs exist, they have been remapped. 418 TheDriver.setCheckInputsExist(false); 419 420 llvm::OwningPtr<driver::Compilation> C( 421 TheDriver.BuildCompilation(Args.size(), Args.data())); 422 423 // We expect to get back exactly one command job, if we didn't something 424 // failed. 425 const driver::JobList &Jobs = C->getJobs(); 426 if (Jobs.size() != 1 || !isa<driver::Command>(Jobs.begin())) { 427 llvm::SmallString<256> Msg; 428 llvm::raw_svector_ostream OS(Msg); 429 C->PrintJob(OS, C->getJobs(), "; ", true); 430 Diags->Report(diag::err_fe_expected_compiler_job) << OS.str(); 431 return 0; 432 } 433 434 const driver::Command *Cmd = cast<driver::Command>(*Jobs.begin()); 435 if (llvm::StringRef(Cmd->getCreator().getName()) != "clang") { 436 Diags->Report(diag::err_fe_expected_clang_command); 437 return 0; 438 } 439 440 const driver::ArgStringList &CCArgs = Cmd->getArguments(); 441 llvm::OwningPtr<CompilerInvocation> CI(new CompilerInvocation); 442 CompilerInvocation::CreateFromArgs(*CI, 443 const_cast<const char **>(CCArgs.data()), 444 const_cast<const char **>(CCArgs.data()) + 445 CCArgs.size(), 446 *Diags); 447 448 // Override any files that need remapping 449 for (unsigned I = 0; I != NumRemappedFiles; ++I) 450 CI->getPreprocessorOpts().addRemappedFile(RemappedFiles[I].first, 451 RemappedFiles[I].second); 452 453 // Override the resources path. 454 CI->getHeaderSearchOpts().ResourceDir = ResourceFilesPath; 455 456 CI->getFrontendOpts().DisableFree = true; 457 return LoadFromCompilerInvocation(CI.take(), Diags, OnlyLocalDecls, 458 CaptureDiagnostics); 459} 460