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