1 //===--- FrontendActions.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/FrontendActions.h" 11 #include "clang/AST/ASTConsumer.h" 12 #include "clang/Lex/HeaderSearch.h" 13 #include "clang/Lex/Pragma.h" 14 #include "clang/Lex/Preprocessor.h" 15 #include "clang/Parse/Parser.h" 16 #include "clang/Basic/FileManager.h" 17 #include "clang/Frontend/ASTConsumers.h" 18 #include "clang/Frontend/ASTUnit.h" 19 #include "clang/Frontend/CompilerInstance.h" 20 #include "clang/Frontend/FrontendDiagnostic.h" 21 #include "clang/Frontend/Utils.h" 22 #include "clang/Serialization/ASTWriter.h" 23 #include "llvm/ADT/OwningPtr.h" 24 #include "llvm/Support/FileSystem.h" 25 #include "llvm/Support/MemoryBuffer.h" 26 #include "llvm/Support/raw_ostream.h" 27 #include "llvm/Support/system_error.h" 28 29 using namespace clang; 30 31 //===----------------------------------------------------------------------===// 32 // Custom Actions 33 //===----------------------------------------------------------------------===// 34 35 ASTConsumer *InitOnlyAction::CreateASTConsumer(CompilerInstance &CI, 36 StringRef InFile) { 37 return new ASTConsumer(); 38 } 39 40 void InitOnlyAction::ExecuteAction() { 41 } 42 43 //===----------------------------------------------------------------------===// 44 // AST Consumer Actions 45 //===----------------------------------------------------------------------===// 46 47 ASTConsumer *ASTPrintAction::CreateASTConsumer(CompilerInstance &CI, 48 StringRef InFile) { 49 if (raw_ostream *OS = CI.createDefaultOutputFile(false, InFile)) 50 return CreateASTPrinter(OS); 51 return 0; 52 } 53 54 ASTConsumer *ASTDumpAction::CreateASTConsumer(CompilerInstance &CI, 55 StringRef InFile) { 56 return CreateASTDumper(); 57 } 58 59 ASTConsumer *ASTDumpXMLAction::CreateASTConsumer(CompilerInstance &CI, 60 StringRef InFile) { 61 raw_ostream *OS; 62 if (CI.getFrontendOpts().OutputFile.empty()) 63 OS = &llvm::outs(); 64 else 65 OS = CI.createDefaultOutputFile(false, InFile); 66 if (!OS) return 0; 67 return CreateASTDumperXML(*OS); 68 } 69 70 ASTConsumer *ASTViewAction::CreateASTConsumer(CompilerInstance &CI, 71 StringRef InFile) { 72 return CreateASTViewer(); 73 } 74 75 ASTConsumer *DeclContextPrintAction::CreateASTConsumer(CompilerInstance &CI, 76 StringRef InFile) { 77 return CreateDeclContextPrinter(); 78 } 79 80 ASTConsumer *GeneratePCHAction::CreateASTConsumer(CompilerInstance &CI, 81 StringRef InFile) { 82 std::string Sysroot; 83 std::string OutputFile; 84 raw_ostream *OS = 0; 85 if (ComputeASTConsumerArguments(CI, InFile, Sysroot, OutputFile, OS)) 86 return 0; 87 88 if (!CI.getFrontendOpts().RelocatablePCH) 89 Sysroot.clear(); 90 return new PCHGenerator(CI.getPreprocessor(), OutputFile, 0, Sysroot, OS); 91 } 92 93 bool GeneratePCHAction::ComputeASTConsumerArguments(CompilerInstance &CI, 94 StringRef InFile, 95 std::string &Sysroot, 96 std::string &OutputFile, 97 raw_ostream *&OS) { 98 Sysroot = CI.getHeaderSearchOpts().Sysroot; 99 if (CI.getFrontendOpts().RelocatablePCH && Sysroot.empty()) { 100 CI.getDiagnostics().Report(diag::err_relocatable_without_isysroot); 101 return true; 102 } 103 104 // We use createOutputFile here because this is exposed via libclang, and we 105 // must disable the RemoveFileOnSignal behavior. 106 // We use a temporary to avoid race conditions. 107 OS = CI.createOutputFile(CI.getFrontendOpts().OutputFile, /*Binary=*/true, 108 /*RemoveFileOnSignal=*/false, InFile, 109 /*Extension=*/"", /*useTemporary=*/true); 110 if (!OS) 111 return true; 112 113 OutputFile = CI.getFrontendOpts().OutputFile; 114 return false; 115 } 116 117 ASTConsumer *GenerateModuleAction::CreateASTConsumer(CompilerInstance &CI, 118 StringRef InFile) { 119 std::string Sysroot; 120 std::string OutputFile; 121 raw_ostream *OS = 0; 122 if (ComputeASTConsumerArguments(CI, InFile, Sysroot, OutputFile, OS)) 123 return 0; 124 125 return new PCHGenerator(CI.getPreprocessor(), OutputFile, Module, 126 Sysroot, OS); 127 } 128 129 /// \brief Collect the set of header includes needed to construct the given 130 /// module. 131 /// 132 /// \param Module The module we're collecting includes from. 133 /// 134 /// \param Includes Will be augmented with the set of #includes or #imports 135 /// needed to load all of the named headers. 136 static void collectModuleHeaderIncludes(const LangOptions &LangOpts, 137 FileManager &FileMgr, 138 ModuleMap &ModMap, 139 clang::Module *Module, 140 SmallString<256> &Includes) { 141 // Don't collect any headers for unavailable modules. 142 if (!Module->isAvailable()) 143 return; 144 145 // Add includes for each of these headers. 146 for (unsigned I = 0, N = Module->Headers.size(); I != N; ++I) { 147 if (LangOpts.ObjC1) 148 Includes += "#import \""; 149 else 150 Includes += "#include \""; 151 Includes += Module->Headers[I]->getName(); 152 Includes += "\"\n"; 153 } 154 155 if (const FileEntry *UmbrellaHeader = Module->getUmbrellaHeader()) { 156 if (Module->Parent) { 157 // Include the umbrella header for submodules. 158 if (LangOpts.ObjC1) 159 Includes += "#import \""; 160 else 161 Includes += "#include \""; 162 Includes += UmbrellaHeader->getName(); 163 Includes += "\"\n"; 164 } 165 } else if (const DirectoryEntry *UmbrellaDir = Module->getUmbrellaDir()) { 166 // Add all of the headers we find in this subdirectory. 167 llvm::error_code EC; 168 SmallString<128> DirNative; 169 llvm::sys::path::native(UmbrellaDir->getName(), DirNative); 170 for (llvm::sys::fs::recursive_directory_iterator Dir(DirNative.str(), EC), 171 DirEnd; 172 Dir != DirEnd && !EC; Dir.increment(EC)) { 173 // Check whether this entry has an extension typically associated with 174 // headers. 175 if (!llvm::StringSwitch<bool>(llvm::sys::path::extension(Dir->path())) 176 .Cases(".h", ".H", ".hh", ".hpp", true) 177 .Default(false)) 178 continue; 179 180 // If this header is marked 'unavailable' in this module, don't include 181 // it. 182 if (const FileEntry *Header = FileMgr.getFile(Dir->path())) 183 if (ModMap.isHeaderInUnavailableModule(Header)) 184 continue; 185 186 // Include this header umbrella header for submodules. 187 if (LangOpts.ObjC1) 188 Includes += "#import \""; 189 else 190 Includes += "#include \""; 191 Includes += Dir->path(); 192 Includes += "\"\n"; 193 } 194 } 195 196 // Recurse into submodules. 197 for (clang::Module::submodule_iterator Sub = Module->submodule_begin(), 198 SubEnd = Module->submodule_end(); 199 Sub != SubEnd; ++Sub) 200 collectModuleHeaderIncludes(LangOpts, FileMgr, ModMap, *Sub, Includes); 201 } 202 203 bool GenerateModuleAction::BeginSourceFileAction(CompilerInstance &CI, 204 StringRef Filename) { 205 // Find the module map file. 206 const FileEntry *ModuleMap = CI.getFileManager().getFile(Filename); 207 if (!ModuleMap) { 208 CI.getDiagnostics().Report(diag::err_module_map_not_found) 209 << Filename; 210 return false; 211 } 212 213 // Parse the module map file. 214 HeaderSearch &HS = CI.getPreprocessor().getHeaderSearchInfo(); 215 if (HS.loadModuleMapFile(ModuleMap)) 216 return false; 217 218 if (CI.getLangOpts().CurrentModule.empty()) { 219 CI.getDiagnostics().Report(diag::err_missing_module_name); 220 221 // FIXME: Eventually, we could consider asking whether there was just 222 // a single module described in the module map, and use that as a 223 // default. Then it would be fairly trivial to just "compile" a module 224 // map with a single module (the common case). 225 return false; 226 } 227 228 // Dig out the module definition. 229 Module = HS.lookupModule(CI.getLangOpts().CurrentModule, 230 /*AllowSearch=*/false); 231 if (!Module) { 232 CI.getDiagnostics().Report(diag::err_missing_module) 233 << CI.getLangOpts().CurrentModule << Filename; 234 235 return false; 236 } 237 238 // Check whether we can build this module at all. 239 StringRef Feature; 240 if (!Module->isAvailable(CI.getLangOpts(), CI.getTarget(), Feature)) { 241 CI.getDiagnostics().Report(diag::err_module_unavailable) 242 << Module->getFullModuleName() 243 << Feature; 244 245 return false; 246 } 247 248 // Do we have an umbrella header for this module? 249 const FileEntry *UmbrellaHeader = Module->getUmbrellaHeader(); 250 251 // Collect the set of #includes we need to build the module. 252 SmallString<256> HeaderContents; 253 collectModuleHeaderIncludes(CI.getLangOpts(), CI.getFileManager(), 254 CI.getPreprocessor().getHeaderSearchInfo().getModuleMap(), 255 Module, HeaderContents); 256 if (UmbrellaHeader && HeaderContents.empty()) { 257 // Simple case: we have an umbrella header and there are no additional 258 // includes, we can just parse the umbrella header directly. 259 setCurrentInput(FrontendInputFile(UmbrellaHeader->getName(), 260 getCurrentFileKind(), 261 Module->IsSystem)); 262 return true; 263 } 264 265 FileManager &FileMgr = CI.getFileManager(); 266 SmallString<128> HeaderName; 267 time_t ModTime; 268 if (UmbrellaHeader) { 269 // Read in the umbrella header. 270 // FIXME: Go through the source manager; the umbrella header may have 271 // been overridden. 272 std::string ErrorStr; 273 llvm::MemoryBuffer *UmbrellaContents 274 = FileMgr.getBufferForFile(UmbrellaHeader, &ErrorStr); 275 if (!UmbrellaContents) { 276 CI.getDiagnostics().Report(diag::err_missing_umbrella_header) 277 << UmbrellaHeader->getName() << ErrorStr; 278 return false; 279 } 280 281 // Combine the contents of the umbrella header with the automatically- 282 // generated includes. 283 SmallString<256> OldContents = HeaderContents; 284 HeaderContents = UmbrellaContents->getBuffer(); 285 HeaderContents += "\n\n"; 286 HeaderContents += "/* Module includes */\n"; 287 HeaderContents += OldContents; 288 289 // Pretend that we're parsing the umbrella header. 290 HeaderName = UmbrellaHeader->getName(); 291 ModTime = UmbrellaHeader->getModificationTime(); 292 293 delete UmbrellaContents; 294 } else { 295 // Pick an innocuous-sounding name for the umbrella header. 296 HeaderName = Module->Name + ".h"; 297 if (FileMgr.getFile(HeaderName, /*OpenFile=*/false, 298 /*CacheFailure=*/false)) { 299 // Try again! 300 HeaderName = Module->Name + "-module.h"; 301 if (FileMgr.getFile(HeaderName, /*OpenFile=*/false, 302 /*CacheFailure=*/false)) { 303 // Pick something ridiculous and go with it. 304 HeaderName = Module->Name + "-module.hmod"; 305 } 306 } 307 ModTime = time(0); 308 } 309 310 // Remap the contents of the header name we're using to our synthesized 311 // buffer. 312 const FileEntry *HeaderFile = FileMgr.getVirtualFile(HeaderName, 313 HeaderContents.size(), 314 ModTime); 315 llvm::MemoryBuffer *HeaderContentsBuf 316 = llvm::MemoryBuffer::getMemBufferCopy(HeaderContents); 317 CI.getSourceManager().overrideFileContents(HeaderFile, HeaderContentsBuf); 318 setCurrentInput(FrontendInputFile(HeaderName, getCurrentFileKind(), 319 Module->IsSystem)); 320 return true; 321 } 322 323 bool GenerateModuleAction::ComputeASTConsumerArguments(CompilerInstance &CI, 324 StringRef InFile, 325 std::string &Sysroot, 326 std::string &OutputFile, 327 raw_ostream *&OS) { 328 // If no output file was provided, figure out where this module would go 329 // in the module cache. 330 if (CI.getFrontendOpts().OutputFile.empty()) { 331 HeaderSearch &HS = CI.getPreprocessor().getHeaderSearchInfo(); 332 SmallString<256> ModuleFileName(HS.getModuleCachePath()); 333 llvm::sys::path::append(ModuleFileName, 334 CI.getLangOpts().CurrentModule + ".pcm"); 335 CI.getFrontendOpts().OutputFile = ModuleFileName.str(); 336 } 337 338 // We use createOutputFile here because this is exposed via libclang, and we 339 // must disable the RemoveFileOnSignal behavior. 340 // We use a temporary to avoid race conditions. 341 OS = CI.createOutputFile(CI.getFrontendOpts().OutputFile, /*Binary=*/true, 342 /*RemoveFileOnSignal=*/false, InFile, 343 /*Extension=*/"", /*useTemporary=*/true, 344 /*CreateMissingDirectories=*/true); 345 if (!OS) 346 return true; 347 348 OutputFile = CI.getFrontendOpts().OutputFile; 349 return false; 350 } 351 352 ASTConsumer *SyntaxOnlyAction::CreateASTConsumer(CompilerInstance &CI, 353 StringRef InFile) { 354 return new ASTConsumer(); 355 } 356 357 //===----------------------------------------------------------------------===// 358 // Preprocessor Actions 359 //===----------------------------------------------------------------------===// 360 361 void DumpRawTokensAction::ExecuteAction() { 362 Preprocessor &PP = getCompilerInstance().getPreprocessor(); 363 SourceManager &SM = PP.getSourceManager(); 364 365 // Start lexing the specified input file. 366 const llvm::MemoryBuffer *FromFile = SM.getBuffer(SM.getMainFileID()); 367 Lexer RawLex(SM.getMainFileID(), FromFile, SM, PP.getLangOpts()); 368 RawLex.SetKeepWhitespaceMode(true); 369 370 Token RawTok; 371 RawLex.LexFromRawLexer(RawTok); 372 while (RawTok.isNot(tok::eof)) { 373 PP.DumpToken(RawTok, true); 374 llvm::errs() << "\n"; 375 RawLex.LexFromRawLexer(RawTok); 376 } 377 } 378 379 void DumpTokensAction::ExecuteAction() { 380 Preprocessor &PP = getCompilerInstance().getPreprocessor(); 381 // Start preprocessing the specified input file. 382 Token Tok; 383 PP.EnterMainSourceFile(); 384 do { 385 PP.Lex(Tok); 386 PP.DumpToken(Tok, true); 387 llvm::errs() << "\n"; 388 } while (Tok.isNot(tok::eof)); 389 } 390 391 void GeneratePTHAction::ExecuteAction() { 392 CompilerInstance &CI = getCompilerInstance(); 393 if (CI.getFrontendOpts().OutputFile.empty() || 394 CI.getFrontendOpts().OutputFile == "-") { 395 // FIXME: Don't fail this way. 396 // FIXME: Verify that we can actually seek in the given file. 397 llvm::report_fatal_error("PTH requires a seekable file for output!"); 398 } 399 llvm::raw_fd_ostream *OS = 400 CI.createDefaultOutputFile(true, getCurrentFile()); 401 if (!OS) return; 402 403 CacheTokens(CI.getPreprocessor(), OS); 404 } 405 406 void PreprocessOnlyAction::ExecuteAction() { 407 Preprocessor &PP = getCompilerInstance().getPreprocessor(); 408 409 // Ignore unknown pragmas. 410 PP.AddPragmaHandler(new EmptyPragmaHandler()); 411 412 Token Tok; 413 // Start parsing the specified input file. 414 PP.EnterMainSourceFile(); 415 do { 416 PP.Lex(Tok); 417 } while (Tok.isNot(tok::eof)); 418 } 419 420 void PrintPreprocessedAction::ExecuteAction() { 421 CompilerInstance &CI = getCompilerInstance(); 422 // Output file may need to be set to 'Binary', to avoid converting Unix style 423 // line feeds (<LF>) to Microsoft style line feeds (<CR><LF>). 424 // 425 // Look to see what type of line endings the file uses. If there's a 426 // CRLF, then we won't open the file up in binary mode. If there is 427 // just an LF or CR, then we will open the file up in binary mode. 428 // In this fashion, the output format should match the input format, unless 429 // the input format has inconsistent line endings. 430 // 431 // This should be a relatively fast operation since most files won't have 432 // all of their source code on a single line. However, that is still a 433 // concern, so if we scan for too long, we'll just assume the file should 434 // be opened in binary mode. 435 bool BinaryMode = true; 436 bool InvalidFile = false; 437 const SourceManager& SM = CI.getSourceManager(); 438 const llvm::MemoryBuffer *Buffer = SM.getBuffer(SM.getMainFileID(), 439 &InvalidFile); 440 if (!InvalidFile) { 441 const char *cur = Buffer->getBufferStart(); 442 const char *end = Buffer->getBufferEnd(); 443 const char *next = (cur != end) ? cur + 1 : end; 444 445 // Limit ourselves to only scanning 256 characters into the source 446 // file. This is mostly a sanity check in case the file has no 447 // newlines whatsoever. 448 if (end - cur > 256) end = cur + 256; 449 450 while (next < end) { 451 if (*cur == 0x0D) { // CR 452 if (*next == 0x0A) // CRLF 453 BinaryMode = false; 454 455 break; 456 } else if (*cur == 0x0A) // LF 457 break; 458 459 ++cur, ++next; 460 } 461 } 462 463 raw_ostream *OS = CI.createDefaultOutputFile(BinaryMode, getCurrentFile()); 464 if (!OS) return; 465 466 DoPrintPreprocessedInput(CI.getPreprocessor(), OS, 467 CI.getPreprocessorOutputOpts()); 468 } 469 470 void PrintPreambleAction::ExecuteAction() { 471 switch (getCurrentFileKind()) { 472 case IK_C: 473 case IK_CXX: 474 case IK_ObjC: 475 case IK_ObjCXX: 476 case IK_OpenCL: 477 case IK_CUDA: 478 break; 479 480 case IK_None: 481 case IK_Asm: 482 case IK_PreprocessedC: 483 case IK_PreprocessedCXX: 484 case IK_PreprocessedObjC: 485 case IK_PreprocessedObjCXX: 486 case IK_AST: 487 case IK_LLVM_IR: 488 // We can't do anything with these. 489 return; 490 } 491 492 CompilerInstance &CI = getCompilerInstance(); 493 llvm::MemoryBuffer *Buffer 494 = CI.getFileManager().getBufferForFile(getCurrentFile()); 495 if (Buffer) { 496 unsigned Preamble = Lexer::ComputePreamble(Buffer, CI.getLangOpts()).first; 497 llvm::outs().write(Buffer->getBufferStart(), Preamble); 498 delete Buffer; 499 } 500 } 501