1 //===--- CompilerInstance.cpp ---------------------------------------------===// 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 #include "clang/Frontend/CompilerInstance.h" 11 #include "clang/AST/ASTConsumer.h" 12 #include "clang/AST/ASTContext.h" 13 #include "clang/Basic/Diagnostic.h" 14 #include "clang/Basic/FileManager.h" 15 #include "clang/Basic/SourceManager.h" 16 #include "clang/Basic/TargetInfo.h" 17 #include "clang/Basic/Version.h" 18 #include "clang/Lex/HeaderSearch.h" 19 #include "clang/Lex/Preprocessor.h" 20 #include "clang/Lex/PTHManager.h" 21 #include "clang/Frontend/ChainedDiagnosticClient.h" 22 #include "clang/Frontend/FrontendAction.h" 23 #include "clang/Frontend/PCHReader.h" 24 #include "clang/Frontend/FrontendDiagnostic.h" 25 #include "clang/Frontend/TextDiagnosticPrinter.h" 26 #include "clang/Frontend/VerifyDiagnosticsClient.h" 27 #include "clang/Frontend/Utils.h" 28 #include "clang/Sema/CodeCompleteConsumer.h" 29 #include "llvm/LLVMContext.h" 30 #include "llvm/Support/MemoryBuffer.h" 31 #include "llvm/Support/raw_ostream.h" 32 #include "llvm/ADT/Statistic.h" 33 #include "llvm/Support/Timer.h" 34 #include "llvm/System/Host.h" 35 #include "llvm/System/Path.h" 36 #include "llvm/System/Program.h" 37 using namespace clang; 38 39 CompilerInstance::CompilerInstance() 40 : Invocation(new CompilerInvocation()) { 41 } 42 43 CompilerInstance::~CompilerInstance() { 44 } 45 46 void CompilerInstance::setLLVMContext(llvm::LLVMContext *Value) { 47 LLVMContext.reset(Value); 48 } 49 50 void CompilerInstance::setInvocation(CompilerInvocation *Value) { 51 Invocation.reset(Value); 52 } 53 54 void CompilerInstance::setDiagnostics(Diagnostic *Value) { 55 Diagnostics = Value; 56 } 57 58 void CompilerInstance::setDiagnosticClient(DiagnosticClient *Value) { 59 DiagClient.reset(Value); 60 } 61 62 void CompilerInstance::setTarget(TargetInfo *Value) { 63 Target.reset(Value); 64 } 65 66 void CompilerInstance::setFileManager(FileManager *Value) { 67 FileMgr.reset(Value); 68 } 69 70 void CompilerInstance::setSourceManager(SourceManager *Value) { 71 SourceMgr.reset(Value); 72 } 73 74 void CompilerInstance::setPreprocessor(Preprocessor *Value) { 75 PP.reset(Value); 76 } 77 78 void CompilerInstance::setASTContext(ASTContext *Value) { 79 Context.reset(Value); 80 } 81 82 void CompilerInstance::setASTConsumer(ASTConsumer *Value) { 83 Consumer.reset(Value); 84 } 85 86 void CompilerInstance::setCodeCompletionConsumer(CodeCompleteConsumer *Value) { 87 CompletionConsumer.reset(Value); 88 } 89 90 // Diagnostics 91 namespace { 92 class BinaryDiagnosticSerializer : public DiagnosticClient { 93 llvm::raw_ostream &OS; 94 SourceManager *SourceMgr; 95 public: 96 explicit BinaryDiagnosticSerializer(llvm::raw_ostream &OS) 97 : OS(OS), SourceMgr(0) { } 98 99 virtual void HandleDiagnostic(Diagnostic::Level DiagLevel, 100 const DiagnosticInfo &Info); 101 }; 102 } 103 104 void BinaryDiagnosticSerializer::HandleDiagnostic(Diagnostic::Level DiagLevel, 105 const DiagnosticInfo &Info) { 106 StoredDiagnostic(DiagLevel, Info).Serialize(OS); 107 } 108 109 static void SetUpBuildDumpLog(const DiagnosticOptions &DiagOpts, 110 unsigned argc, char **argv, 111 Diagnostic &Diags) { 112 std::string ErrorInfo; 113 llvm::OwningPtr<llvm::raw_ostream> OS( 114 new llvm::raw_fd_ostream(DiagOpts.DumpBuildInformation.c_str(), ErrorInfo)); 115 if (!ErrorInfo.empty()) { 116 Diags.Report(diag::err_fe_unable_to_open_logfile) 117 << DiagOpts.DumpBuildInformation << ErrorInfo; 118 return; 119 } 120 121 (*OS) << "clang -cc1 command line arguments: "; 122 for (unsigned i = 0; i != argc; ++i) 123 (*OS) << argv[i] << ' '; 124 (*OS) << '\n'; 125 126 // Chain in a diagnostic client which will log the diagnostics. 127 DiagnosticClient *Logger = 128 new TextDiagnosticPrinter(*OS.take(), DiagOpts, /*OwnsOutputStream=*/true); 129 Diags.setClient(new ChainedDiagnosticClient(Diags.getClient(), Logger)); 130 } 131 132 void CompilerInstance::createDiagnostics(int Argc, char **Argv) { 133 Diagnostics = createDiagnostics(getDiagnosticOpts(), Argc, Argv); 134 135 if (Diagnostics) 136 DiagClient.reset(Diagnostics->getClient()); 137 } 138 139 llvm::IntrusiveRefCntPtr<Diagnostic> 140 CompilerInstance::createDiagnostics(const DiagnosticOptions &Opts, 141 int Argc, char **Argv) { 142 llvm::IntrusiveRefCntPtr<Diagnostic> Diags(new Diagnostic()); 143 144 // Create the diagnostic client for reporting errors or for 145 // implementing -verify. 146 llvm::OwningPtr<DiagnosticClient> DiagClient; 147 if (Opts.BinaryOutput) { 148 if (llvm::sys::Program::ChangeStderrToBinary()) { 149 // We weren't able to set standard error to binary, which is a 150 // bit of a problem. So, just create a text diagnostic printer 151 // to complain about this problem, and pretend that the user 152 // didn't try to use binary output. 153 DiagClient.reset(new TextDiagnosticPrinter(llvm::errs(), Opts)); 154 Diags->setClient(DiagClient.take()); 155 Diags->Report(diag::err_fe_stderr_binary); 156 return Diags; 157 } else { 158 DiagClient.reset(new BinaryDiagnosticSerializer(llvm::errs())); 159 } 160 } else { 161 DiagClient.reset(new TextDiagnosticPrinter(llvm::errs(), Opts)); 162 } 163 164 // Chain in -verify checker, if requested. 165 if (Opts.VerifyDiagnostics) 166 DiagClient.reset(new VerifyDiagnosticsClient(*Diags, DiagClient.take())); 167 168 Diags->setClient(DiagClient.take()); 169 if (!Opts.DumpBuildInformation.empty()) 170 SetUpBuildDumpLog(Opts, Argc, Argv, *Diags); 171 172 // Configure our handling of diagnostics. 173 ProcessWarningOptions(*Diags, Opts); 174 175 return Diags; 176 } 177 178 // File Manager 179 180 void CompilerInstance::createFileManager() { 181 FileMgr.reset(new FileManager()); 182 } 183 184 // Source Manager 185 186 void CompilerInstance::createSourceManager() { 187 SourceMgr.reset(new SourceManager(getDiagnostics())); 188 } 189 190 // Preprocessor 191 192 void CompilerInstance::createPreprocessor() { 193 PP.reset(createPreprocessor(getDiagnostics(), getLangOpts(), 194 getPreprocessorOpts(), getHeaderSearchOpts(), 195 getDependencyOutputOpts(), getTarget(), 196 getFrontendOpts(), getSourceManager(), 197 getFileManager())); 198 } 199 200 Preprocessor * 201 CompilerInstance::createPreprocessor(Diagnostic &Diags, 202 const LangOptions &LangInfo, 203 const PreprocessorOptions &PPOpts, 204 const HeaderSearchOptions &HSOpts, 205 const DependencyOutputOptions &DepOpts, 206 const TargetInfo &Target, 207 const FrontendOptions &FEOpts, 208 SourceManager &SourceMgr, 209 FileManager &FileMgr) { 210 // Create a PTH manager if we are using some form of a token cache. 211 PTHManager *PTHMgr = 0; 212 if (!PPOpts.TokenCache.empty()) 213 PTHMgr = PTHManager::Create(PPOpts.TokenCache, Diags); 214 215 // Create the Preprocessor. 216 HeaderSearch *HeaderInfo = new HeaderSearch(FileMgr); 217 Preprocessor *PP = new Preprocessor(Diags, LangInfo, Target, 218 SourceMgr, *HeaderInfo, PTHMgr, 219 /*OwnsHeaderSearch=*/true); 220 221 // Note that this is different then passing PTHMgr to Preprocessor's ctor. 222 // That argument is used as the IdentifierInfoLookup argument to 223 // IdentifierTable's ctor. 224 if (PTHMgr) { 225 PTHMgr->setPreprocessor(PP); 226 PP->setPTHManager(PTHMgr); 227 } 228 229 if (PPOpts.DetailedRecord) 230 PP->createPreprocessingRecord(); 231 232 InitializePreprocessor(*PP, PPOpts, HSOpts, FEOpts); 233 234 // Handle generating dependencies, if requested. 235 if (!DepOpts.OutputFile.empty()) 236 AttachDependencyFileGen(*PP, DepOpts); 237 238 return PP; 239 } 240 241 // ASTContext 242 243 void CompilerInstance::createASTContext() { 244 Preprocessor &PP = getPreprocessor(); 245 Context.reset(new ASTContext(getLangOpts(), PP.getSourceManager(), 246 getTarget(), PP.getIdentifierTable(), 247 PP.getSelectorTable(), PP.getBuiltinInfo(), 248 /*size_reserve=*/ 0)); 249 } 250 251 // ExternalASTSource 252 253 void CompilerInstance::createPCHExternalASTSource(llvm::StringRef Path, 254 bool DisablePCHValidation, 255 void *DeserializationListener){ 256 llvm::OwningPtr<ExternalASTSource> Source; 257 Source.reset(createPCHExternalASTSource(Path, getHeaderSearchOpts().Sysroot, 258 DisablePCHValidation, 259 getPreprocessor(), getASTContext(), 260 DeserializationListener)); 261 getASTContext().setExternalSource(Source); 262 } 263 264 ExternalASTSource * 265 CompilerInstance::createPCHExternalASTSource(llvm::StringRef Path, 266 const std::string &Sysroot, 267 bool DisablePCHValidation, 268 Preprocessor &PP, 269 ASTContext &Context, 270 void *DeserializationListener) { 271 llvm::OwningPtr<PCHReader> Reader; 272 Reader.reset(new PCHReader(PP, &Context, 273 Sysroot.empty() ? 0 : Sysroot.c_str(), 274 DisablePCHValidation)); 275 276 Reader->setDeserializationListener( 277 static_cast<PCHDeserializationListener *>(DeserializationListener)); 278 switch (Reader->ReadPCH(Path)) { 279 case PCHReader::Success: 280 // Set the predefines buffer as suggested by the PCH reader. Typically, the 281 // predefines buffer will be empty. 282 PP.setPredefines(Reader->getSuggestedPredefines()); 283 return Reader.take(); 284 285 case PCHReader::Failure: 286 // Unrecoverable failure: don't even try to process the input file. 287 break; 288 289 case PCHReader::IgnorePCH: 290 // No suitable PCH file could be found. Return an error. 291 break; 292 } 293 294 return 0; 295 } 296 297 // Code Completion 298 299 static bool EnableCodeCompletion(Preprocessor &PP, 300 const std::string &Filename, 301 unsigned Line, 302 unsigned Column) { 303 // Tell the source manager to chop off the given file at a specific 304 // line and column. 305 const FileEntry *Entry = PP.getFileManager().getFile(Filename); 306 if (!Entry) { 307 PP.getDiagnostics().Report(diag::err_fe_invalid_code_complete_file) 308 << Filename; 309 return true; 310 } 311 312 // Truncate the named file at the given line/column. 313 PP.SetCodeCompletionPoint(Entry, Line, Column); 314 return false; 315 } 316 317 void CompilerInstance::createCodeCompletionConsumer() { 318 const ParsedSourceLocation &Loc = getFrontendOpts().CodeCompletionAt; 319 if (!CompletionConsumer) { 320 CompletionConsumer.reset( 321 createCodeCompletionConsumer(getPreprocessor(), 322 Loc.FileName, Loc.Line, Loc.Column, 323 getFrontendOpts().DebugCodeCompletionPrinter, 324 getFrontendOpts().ShowMacrosInCodeCompletion, 325 getFrontendOpts().ShowCodePatternsInCodeCompletion, 326 llvm::outs())); 327 if (!CompletionConsumer) 328 return; 329 } else if (EnableCodeCompletion(getPreprocessor(), Loc.FileName, 330 Loc.Line, Loc.Column)) { 331 CompletionConsumer.reset(); 332 return; 333 } 334 335 if (CompletionConsumer->isOutputBinary() && 336 llvm::sys::Program::ChangeStdoutToBinary()) { 337 getPreprocessor().getDiagnostics().Report(diag::err_fe_stdout_binary); 338 CompletionConsumer.reset(); 339 } 340 } 341 342 void CompilerInstance::createFrontendTimer() { 343 FrontendTimer.reset(new llvm::Timer("Clang front-end timer")); 344 } 345 346 CodeCompleteConsumer * 347 CompilerInstance::createCodeCompletionConsumer(Preprocessor &PP, 348 const std::string &Filename, 349 unsigned Line, 350 unsigned Column, 351 bool UseDebugPrinter, 352 bool ShowMacros, 353 bool ShowCodePatterns, 354 llvm::raw_ostream &OS) { 355 if (EnableCodeCompletion(PP, Filename, Line, Column)) 356 return 0; 357 358 // Set up the creation routine for code-completion. 359 if (UseDebugPrinter) 360 return new PrintingCodeCompleteConsumer(ShowMacros, ShowCodePatterns, OS); 361 else 362 return new CIndexCodeCompleteConsumer(ShowMacros, ShowCodePatterns, OS); 363 } 364 365 // Output Files 366 367 void CompilerInstance::addOutputFile(llvm::StringRef Path, 368 llvm::raw_ostream *OS) { 369 assert(OS && "Attempt to add empty stream to output list!"); 370 OutputFiles.push_back(std::make_pair(Path, OS)); 371 } 372 373 void CompilerInstance::clearOutputFiles(bool EraseFiles) { 374 for (std::list< std::pair<std::string, llvm::raw_ostream*> >::iterator 375 it = OutputFiles.begin(), ie = OutputFiles.end(); it != ie; ++it) { 376 delete it->second; 377 if (EraseFiles && !it->first.empty()) 378 llvm::sys::Path(it->first).eraseFromDisk(); 379 } 380 OutputFiles.clear(); 381 } 382 383 llvm::raw_fd_ostream * 384 CompilerInstance::createDefaultOutputFile(bool Binary, 385 llvm::StringRef InFile, 386 llvm::StringRef Extension) { 387 return createOutputFile(getFrontendOpts().OutputFile, Binary, 388 InFile, Extension); 389 } 390 391 llvm::raw_fd_ostream * 392 CompilerInstance::createOutputFile(llvm::StringRef OutputPath, 393 bool Binary, 394 llvm::StringRef InFile, 395 llvm::StringRef Extension) { 396 std::string Error, OutputPathName; 397 llvm::raw_fd_ostream *OS = createOutputFile(OutputPath, Error, Binary, 398 InFile, Extension, 399 &OutputPathName); 400 if (!OS) { 401 getDiagnostics().Report(diag::err_fe_unable_to_open_output) 402 << OutputPath << Error; 403 return 0; 404 } 405 406 // Add the output file -- but don't try to remove "-", since this means we are 407 // using stdin. 408 addOutputFile((OutputPathName != "-") ? OutputPathName : "", OS); 409 410 return OS; 411 } 412 413 llvm::raw_fd_ostream * 414 CompilerInstance::createOutputFile(llvm::StringRef OutputPath, 415 std::string &Error, 416 bool Binary, 417 llvm::StringRef InFile, 418 llvm::StringRef Extension, 419 std::string *ResultPathName) { 420 std::string OutFile; 421 if (!OutputPath.empty()) { 422 OutFile = OutputPath; 423 } else if (InFile == "-") { 424 OutFile = "-"; 425 } else if (!Extension.empty()) { 426 llvm::sys::Path Path(InFile); 427 Path.eraseSuffix(); 428 Path.appendSuffix(Extension); 429 OutFile = Path.str(); 430 } else { 431 OutFile = "-"; 432 } 433 434 llvm::OwningPtr<llvm::raw_fd_ostream> OS( 435 new llvm::raw_fd_ostream(OutFile.c_str(), Error, 436 (Binary ? llvm::raw_fd_ostream::F_Binary : 0))); 437 if (!Error.empty()) 438 return 0; 439 440 if (ResultPathName) 441 *ResultPathName = OutFile; 442 443 return OS.take(); 444 } 445 446 // Initialization Utilities 447 448 bool CompilerInstance::InitializeSourceManager(llvm::StringRef InputFile) { 449 return InitializeSourceManager(InputFile, getDiagnostics(), getFileManager(), 450 getSourceManager(), getFrontendOpts()); 451 } 452 453 bool CompilerInstance::InitializeSourceManager(llvm::StringRef InputFile, 454 Diagnostic &Diags, 455 FileManager &FileMgr, 456 SourceManager &SourceMgr, 457 const FrontendOptions &Opts) { 458 // Figure out where to get and map in the main file. 459 if (InputFile != "-") { 460 const FileEntry *File = FileMgr.getFile(InputFile); 461 if (File) SourceMgr.createMainFileID(File, SourceLocation()); 462 if (SourceMgr.getMainFileID().isInvalid()) { 463 Diags.Report(diag::err_fe_error_reading) << InputFile; 464 return false; 465 } 466 } else { 467 llvm::MemoryBuffer *SB = llvm::MemoryBuffer::getSTDIN(); 468 if (SB) SourceMgr.createMainFileIDForMemBuffer(SB); 469 if (SourceMgr.getMainFileID().isInvalid()) { 470 Diags.Report(diag::err_fe_error_reading_stdin); 471 return false; 472 } 473 } 474 475 return true; 476 } 477 478 // High-Level Operations 479 480 bool CompilerInstance::ExecuteAction(FrontendAction &Act) { 481 assert(hasDiagnostics() && "Diagnostics engine is not initialized!"); 482 assert(!getFrontendOpts().ShowHelp && "Client must handle '-help'!"); 483 assert(!getFrontendOpts().ShowVersion && "Client must handle '-version'!"); 484 485 // FIXME: Take this as an argument, once all the APIs we used have moved to 486 // taking it as an input instead of hard-coding llvm::errs. 487 llvm::raw_ostream &OS = llvm::errs(); 488 489 // Create the target instance. 490 setTarget(TargetInfo::CreateTargetInfo(getDiagnostics(), getTargetOpts())); 491 if (!hasTarget()) 492 return false; 493 494 // Inform the target of the language options. 495 // 496 // FIXME: We shouldn't need to do this, the target should be immutable once 497 // created. This complexity should be lifted elsewhere. 498 getTarget().setForcedLangOptions(getLangOpts()); 499 500 // Validate/process some options. 501 if (getHeaderSearchOpts().Verbose) 502 OS << "clang -cc1 version " CLANG_VERSION_STRING 503 << " based upon " << PACKAGE_STRING 504 << " hosted on " << llvm::sys::getHostTriple() << "\n"; 505 506 if (getFrontendOpts().ShowTimers) 507 createFrontendTimer(); 508 509 if (getFrontendOpts().ShowStats) 510 llvm::EnableStatistics(); 511 512 for (unsigned i = 0, e = getFrontendOpts().Inputs.size(); i != e; ++i) { 513 const std::string &InFile = getFrontendOpts().Inputs[i].second; 514 515 // Reset the ID tables if we are reusing the SourceManager. 516 if (hasSourceManager()) 517 getSourceManager().clearIDTables(); 518 519 if (Act.BeginSourceFile(*this, InFile, getFrontendOpts().Inputs[i].first)) { 520 Act.Execute(); 521 Act.EndSourceFile(); 522 } 523 } 524 525 if (getDiagnosticOpts().ShowCarets) { 526 unsigned NumWarnings = getDiagnostics().getNumWarnings(); 527 unsigned NumErrors = getDiagnostics().getNumErrors() - 528 getDiagnostics().getNumErrorsSuppressed(); 529 530 if (NumWarnings) 531 OS << NumWarnings << " warning" << (NumWarnings == 1 ? "" : "s"); 532 if (NumWarnings && NumErrors) 533 OS << " and "; 534 if (NumErrors) 535 OS << NumErrors << " error" << (NumErrors == 1 ? "" : "s"); 536 if (NumWarnings || NumErrors) 537 OS << " generated.\n"; 538 } 539 540 if (getFrontendOpts().ShowStats && hasFileManager()) { 541 getFileManager().PrintStats(); 542 OS << "\n"; 543 } 544 545 // Return the appropriate status when verifying diagnostics. 546 // 547 // FIXME: If we could make getNumErrors() do the right thing, we wouldn't need 548 // this. 549 if (getDiagnosticOpts().VerifyDiagnostics) 550 return !static_cast<VerifyDiagnosticsClient&>( 551 getDiagnosticClient()).HadErrors(); 552 553 return !getDiagnostics().getNumErrors(); 554 } 555 556 557