contrib/llvm/tools/clang/lib/Frontend/FrontendActions.cpp

   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/Basic/FileManager.h"
  13 #include "clang/Frontend/ASTConsumers.h"
  14 #include "clang/Frontend/ASTUnit.h"
  15 #include "clang/Frontend/CompilerInstance.h"
  16 #include "clang/Frontend/FrontendDiagnostic.h"
  17 #include "clang/Frontend/MultiplexConsumer.h"
  18 #include "clang/Frontend/Utils.h"
  19 #include "clang/Lex/HeaderSearch.h"
  20 #include "clang/Lex/Pragma.h"
  21 #include "clang/Lex/Preprocessor.h"
  22 #include "clang/Parse/Parser.h"
  23 #include "clang/Serialization/ASTReader.h"
  24 #include "clang/Serialization/ASTWriter.h"
  25 #include "llvm/Support/FileSystem.h"
  26 #include "llvm/Support/MemoryBuffer.h"
  27 #include "llvm/Support/raw_ostream.h"
  28 #include <memory>
  29 #include <system_error>
  30
  31 using namespace clang;
  32
  33 //===----------------------------------------------------------------------===//
  34 // Custom Actions
  35 //===----------------------------------------------------------------------===//
  36
  37 std::unique_ptr<ASTConsumer>
  38 InitOnlyAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
  39   return llvm::make_unique<ASTConsumer>();
  40 }
  41
  42 void InitOnlyAction::ExecuteAction() {
  43 }
  44
  45 //===----------------------------------------------------------------------===//
  46 // AST Consumer Actions
  47 //===----------------------------------------------------------------------===//
  48
  49 std::unique_ptr<ASTConsumer>
  50 ASTPrintAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
  51   if (std::unique_ptr<raw_ostream> OS =
  52           CI.createDefaultOutputFile(false, InFile))
  53     return CreateASTPrinter(std::move(OS), CI.getFrontendOpts().ASTDumpFilter);
  54   return nullptr;
  55 }
  56
  57 std::unique_ptr<ASTConsumer>
  58 ASTDumpAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
  59   return CreateASTDumper(CI.getFrontendOpts().ASTDumpFilter,
  60                          CI.getFrontendOpts().ASTDumpDecls,
  61                          CI.getFrontendOpts().ASTDumpLookups);
  62 }
  63
  64 std::unique_ptr<ASTConsumer>
  65 ASTDeclListAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
  66   return CreateASTDeclNodeLister();
  67 }
  68
  69 std::unique_ptr<ASTConsumer>
  70 ASTViewAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
  71   return CreateASTViewer();
  72 }
  73
  74 std::unique_ptr<ASTConsumer>
  75 DeclContextPrintAction::CreateASTConsumer(CompilerInstance &CI,
  76                                           StringRef InFile) {
  77   return CreateDeclContextPrinter();
  78 }
  79
  80 std::unique_ptr<ASTConsumer>
  81 GeneratePCHAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
  82   std::string Sysroot;
  83   std::string OutputFile;
  84   std::unique_ptr<raw_pwrite_stream> OS =
  85       ComputeASTConsumerArguments(CI, InFile, Sysroot, OutputFile);
  86   if (!OS)
  87     return nullptr;
  88
  89   if (!CI.getFrontendOpts().RelocatablePCH)
  90     Sysroot.clear();
  91
  92   auto Buffer = std::make_shared<PCHBuffer>();
  93   std::vector<std::unique_ptr<ASTConsumer>> Consumers;
  94   Consumers.push_back(llvm::make_unique<PCHGenerator>(
  95                         CI.getPreprocessor(), OutputFile, nullptr, Sysroot,
  96                         Buffer, CI.getFrontendOpts().ModuleFileExtensions,
  97                         /*AllowASTWithErrors*/false,
  98                         /*IncludeTimestamps*/
  99                           +CI.getFrontendOpts().IncludeTimestamps));
 100   Consumers.push_back(CI.getPCHContainerWriter().CreatePCHContainerGenerator(
 101       CI, InFile, OutputFile, std::move(OS), Buffer));
 102
 103   return llvm::make_unique<MultiplexConsumer>(std::move(Consumers));
 104 }
 105
 106 std::unique_ptr<raw_pwrite_stream>
 107 GeneratePCHAction::ComputeASTConsumerArguments(CompilerInstance &CI,
 108                                                StringRef InFile,
 109                                                std::string &Sysroot,
 110                                                std::string &OutputFile) {
 111   Sysroot = CI.getHeaderSearchOpts().Sysroot;
 112   if (CI.getFrontendOpts().RelocatablePCH && Sysroot.empty()) {
 113     CI.getDiagnostics().Report(diag::err_relocatable_without_isysroot);
 114     return nullptr;
 115   }
 116
 117   // We use createOutputFile here because this is exposed via libclang, and we
 118   // must disable the RemoveFileOnSignal behavior.
 119   // We use a temporary to avoid race conditions.
 120   std::unique_ptr<raw_pwrite_stream> OS =
 121       CI.createOutputFile(CI.getFrontendOpts().OutputFile, /*Binary=*/true,
 122                           /*RemoveFileOnSignal=*/false, InFile,
 123                           /*Extension=*/"", /*useTemporary=*/true);
 124   if (!OS)
 125     return nullptr;
 126
 127   OutputFile = CI.getFrontendOpts().OutputFile;
 128   return OS;
 129 }
 130
 131 std::unique_ptr<ASTConsumer>
 132 GenerateModuleAction::CreateASTConsumer(CompilerInstance &CI,
 133                                         StringRef InFile) {
 134   std::string Sysroot;
 135   std::string OutputFile;
 136   std::unique_ptr<raw_pwrite_stream> OS =
 137       ComputeASTConsumerArguments(CI, InFile, Sysroot, OutputFile);
 138   if (!OS)
 139     return nullptr;
 140
 141   auto Buffer = std::make_shared<PCHBuffer>();
 142   std::vector<std::unique_ptr<ASTConsumer>> Consumers;
 143
 144   Consumers.push_back(llvm::make_unique<PCHGenerator>(
 145                         CI.getPreprocessor(), OutputFile, Module, Sysroot,
 146                         Buffer, CI.getFrontendOpts().ModuleFileExtensions,
 147                         /*AllowASTWithErrors=*/false,
 148                         /*IncludeTimestamps=*/
 149                           +CI.getFrontendOpts().BuildingImplicitModule));
 150   Consumers.push_back(CI.getPCHContainerWriter().CreatePCHContainerGenerator(
 151       CI, InFile, OutputFile, std::move(OS), Buffer));
 152   return llvm::make_unique<MultiplexConsumer>(std::move(Consumers));
 153 }
 154
 155 static SmallVectorImpl<char> &
 156 operator+=(SmallVectorImpl<char> &Includes, StringRef RHS) {
 157   Includes.append(RHS.begin(), RHS.end());
 158   return Includes;
 159 }
 160
 161 static void addHeaderInclude(StringRef HeaderName,
 162                              SmallVectorImpl<char> &Includes,
 163                              const LangOptions &LangOpts,
 164                              bool IsExternC) {
 165   if (IsExternC && LangOpts.CPlusPlus)
 166     Includes += "extern \"C\" {\n";
 167   if (LangOpts.ObjC1)
 168     Includes += "#import \"";
 169   else
 170     Includes += "#include \"";
 171
 172   Includes += HeaderName;
 173
 174   Includes += "\"\n";
 175   if (IsExternC && LangOpts.CPlusPlus)
 176     Includes += "}\n";
 177 }
 178
 179 /// \brief Collect the set of header includes needed to construct the given
 180 /// module and update the TopHeaders file set of the module.
 181 ///
 182 /// \param Module The module we're collecting includes from.
 183 ///
 184 /// \param Includes Will be augmented with the set of \#includes or \#imports
 185 /// needed to load all of the named headers.
 186 static std::error_code
 187 collectModuleHeaderIncludes(const LangOptions &LangOpts, FileManager &FileMgr,
 188                             ModuleMap &ModMap, clang::Module *Module,
 189                             SmallVectorImpl<char> &Includes) {
 190   // Don't collect any headers for unavailable modules.
 191   if (!Module->isAvailable())
 192     return std::error_code();
 193
 194   // Add includes for each of these headers.
 195   for (auto HK : {Module::HK_Normal, Module::HK_Private}) {
 196     for (Module::Header &H : Module->Headers[HK]) {
 197       Module->addTopHeader(H.Entry);
 198       // Use the path as specified in the module map file. We'll look for this
 199       // file relative to the module build directory (the directory containing
 200       // the module map file) so this will find the same file that we found
 201       // while parsing the module map.
 202       addHeaderInclude(H.NameAsWritten, Includes, LangOpts, Module->IsExternC);
 203     }
 204   }
 205   // Note that Module->PrivateHeaders will not be a TopHeader.
 206
 207   if (Module::Header UmbrellaHeader = Module->getUmbrellaHeader()) {
 208     Module->addTopHeader(UmbrellaHeader.Entry);
 209     if (Module->Parent)
 210       // Include the umbrella header for submodules.
 211       addHeaderInclude(UmbrellaHeader.NameAsWritten, Includes, LangOpts,
 212                        Module->IsExternC);
 213   } else if (Module::DirectoryName UmbrellaDir = Module->getUmbrellaDir()) {
 214     // Add all of the headers we find in this subdirectory.
 215     std::error_code EC;
 216     SmallString<128> DirNative;
 217     llvm::sys::path::native(UmbrellaDir.Entry->getName(), DirNative);
 218
 219     vfs::FileSystem &FS = *FileMgr.getVirtualFileSystem();
 220     for (vfs::recursive_directory_iterator Dir(FS, DirNative, EC), End;
 221          Dir != End && !EC; Dir.increment(EC)) {
 222       // Check whether this entry has an extension typically associated with
 223       // headers.
 224       if (!llvm::StringSwitch<bool>(llvm::sys::path::extension(Dir->getName()))
 225           .Cases(".h", ".H", ".hh", ".hpp", true)
 226           .Default(false))
 227         continue;
 228
 229       const FileEntry *Header = FileMgr.getFile(Dir->getName());
 230       // FIXME: This shouldn't happen unless there is a file system race. Is
 231       // that worth diagnosing?
 232       if (!Header)
 233         continue;
 234
 235       // If this header is marked 'unavailable' in this module, don't include
 236       // it.
 237       if (ModMap.isHeaderUnavailableInModule(Header, Module))
 238         continue;
 239
 240       // Compute the relative path from the directory to this file.
 241       SmallVector<StringRef, 16> Components;
 242       auto PathIt = llvm::sys::path::rbegin(Dir->getName());
 243       for (int I = 0; I != Dir.level() + 1; ++I, ++PathIt)
 244         Components.push_back(*PathIt);
 245       SmallString<128> RelativeHeader(UmbrellaDir.NameAsWritten);
 246       for (auto It = Components.rbegin(), End = Components.rend(); It != End;
 247            ++It)
 248         llvm::sys::path::append(RelativeHeader, *It);
 249
 250       // Include this header as part of the umbrella directory.
 251       Module->addTopHeader(Header);
 252       addHeaderInclude(RelativeHeader, Includes, LangOpts, Module->IsExternC);
 253     }
 254
 255     if (EC)
 256       return EC;
 257   }
 258
 259   // Recurse into submodules.
 260   for (clang::Module::submodule_iterator Sub = Module->submodule_begin(),
 261                                       SubEnd = Module->submodule_end();
 262        Sub != SubEnd; ++Sub)
 263     if (std::error_code Err = collectModuleHeaderIncludes(
 264             LangOpts, FileMgr, ModMap, *Sub, Includes))
 265       return Err;
 266
 267   return std::error_code();
 268 }
 269
 270 bool GenerateModuleAction::BeginSourceFileAction(CompilerInstance &CI,
 271                                                  StringRef Filename) {
 272   CI.getLangOpts().CompilingModule = true;
 273
 274   // Find the module map file.
 275   const FileEntry *ModuleMap =
 276       CI.getFileManager().getFile(Filename, /*openFile*/true);
 277   if (!ModuleMap)  {
 278     CI.getDiagnostics().Report(diag::err_module_map_not_found)
 279       << Filename;
 280     return false;
 281   }
 282
 283   // Set up embedding for any specified files. Do this before we load any
 284   // source files, including the primary module map for the compilation.
 285   for (const auto &F : CI.getFrontendOpts().ModulesEmbedFiles) {
 286     if (const auto *FE = CI.getFileManager().getFile(F, /*openFile*/true))
 287       CI.getSourceManager().setFileIsTransient(FE);
 288     else
 289       CI.getDiagnostics().Report(diag::err_modules_embed_file_not_found) << F;
 290   }
 291   if (CI.getFrontendOpts().ModulesEmbedAllFiles)
 292     CI.getSourceManager().setAllFilesAreTransient(true);
 293
 294   // Parse the module map file.
 295   HeaderSearch &HS = CI.getPreprocessor().getHeaderSearchInfo();
 296   if (HS.loadModuleMapFile(ModuleMap, IsSystem))
 297     return false;
 298
 299   if (CI.getLangOpts().CurrentModule.empty()) {
 300     CI.getDiagnostics().Report(diag::err_missing_module_name);
 301
 302     // FIXME: Eventually, we could consider asking whether there was just
 303     // a single module described in the module map, and use that as a
 304     // default. Then it would be fairly trivial to just "compile" a module
 305     // map with a single module (the common case).
 306     return false;
 307   }
 308
 309   // If we're being run from the command-line, the module build stack will not
 310   // have been filled in yet, so complete it now in order to allow us to detect
 311   // module cycles.
 312   SourceManager &SourceMgr = CI.getSourceManager();
 313   if (SourceMgr.getModuleBuildStack().empty())
 314     SourceMgr.pushModuleBuildStack(CI.getLangOpts().CurrentModule,
 315                                    FullSourceLoc(SourceLocation(), SourceMgr));
 316
 317   // Dig out the module definition.
 318   Module = HS.lookupModule(CI.getLangOpts().CurrentModule,
 319                            /*AllowSearch=*/false);
 320   if (!Module) {
 321     CI.getDiagnostics().Report(diag::err_missing_module)
 322       << CI.getLangOpts().CurrentModule << Filename;
 323
 324     return false;
 325   }
 326
 327   // Check whether we can build this module at all.
 328   clang::Module::Requirement Requirement;
 329   clang::Module::UnresolvedHeaderDirective MissingHeader;
 330   if (!Module->isAvailable(CI.getLangOpts(), CI.getTarget(), Requirement,
 331                            MissingHeader)) {
 332     if (MissingHeader.FileNameLoc.isValid()) {
 333       CI.getDiagnostics().Report(MissingHeader.FileNameLoc,
 334                                  diag::err_module_header_missing)
 335         << MissingHeader.IsUmbrella << MissingHeader.FileName;
 336     } else {
 337       CI.getDiagnostics().Report(diag::err_module_unavailable)
 338         << Module->getFullModuleName()
 339         << Requirement.second << Requirement.first;
 340     }
 341
 342     return false;
 343   }
 344
 345   if (ModuleMapForUniquing && ModuleMapForUniquing != ModuleMap) {
 346     Module->IsInferred = true;
 347     HS.getModuleMap().setInferredModuleAllowedBy(Module, ModuleMapForUniquing);
 348   } else {
 349     ModuleMapForUniquing = ModuleMap;
 350   }
 351
 352   FileManager &FileMgr = CI.getFileManager();
 353
 354   // Collect the set of #includes we need to build the module.
 355   SmallString<256> HeaderContents;
 356   std::error_code Err = std::error_code();
 357   if (Module::Header UmbrellaHeader = Module->getUmbrellaHeader())
 358     addHeaderInclude(UmbrellaHeader.NameAsWritten, HeaderContents,
 359                      CI.getLangOpts(), Module->IsExternC);
 360   Err = collectModuleHeaderIncludes(
 361         CI.getLangOpts(), FileMgr,
 362         CI.getPreprocessor().getHeaderSearchInfo().getModuleMap(), Module,
 363         HeaderContents);
 364
 365   if (Err) {
 366     CI.getDiagnostics().Report(diag::err_module_cannot_create_includes)
 367       << Module->getFullModuleName() << Err.message();
 368     return false;
 369   }
 370
 371   // Inform the preprocessor that includes from within the input buffer should
 372   // be resolved relative to the build directory of the module map file.
 373   CI.getPreprocessor().setMainFileDir(Module->Directory);
 374
 375   std::unique_ptr<llvm::MemoryBuffer> InputBuffer =
 376       llvm::MemoryBuffer::getMemBufferCopy(HeaderContents,
 377                                            Module::getModuleInputBufferName());
 378   // Ownership of InputBuffer will be transferred to the SourceManager.
 379   setCurrentInput(FrontendInputFile(InputBuffer.release(), getCurrentFileKind(),
 380                                     Module->IsSystem));
 381   return true;
 382 }
 383
 384 std::unique_ptr<raw_pwrite_stream>
 385 GenerateModuleAction::ComputeASTConsumerArguments(CompilerInstance &CI,
 386                                                   StringRef InFile,
 387                                                   std::string &Sysroot,
 388                                                   std::string &OutputFile) {
 389   // If no output file was provided, figure out where this module would go
 390   // in the module cache.
 391   if (CI.getFrontendOpts().OutputFile.empty()) {
 392     HeaderSearch &HS = CI.getPreprocessor().getHeaderSearchInfo();
 393     CI.getFrontendOpts().OutputFile =
 394         HS.getModuleFileName(CI.getLangOpts().CurrentModule,
 395                              ModuleMapForUniquing->getName());
 396   }
 397
 398   // We use createOutputFile here because this is exposed via libclang, and we
 399   // must disable the RemoveFileOnSignal behavior.
 400   // We use a temporary to avoid race conditions.
 401   std::unique_ptr<raw_pwrite_stream> OS =
 402       CI.createOutputFile(CI.getFrontendOpts().OutputFile, /*Binary=*/true,
 403                           /*RemoveFileOnSignal=*/false, InFile,
 404                           /*Extension=*/"", /*useTemporary=*/true,
 405                           /*CreateMissingDirectories=*/true);
 406   if (!OS)
 407     return nullptr;
 408
 409   OutputFile = CI.getFrontendOpts().OutputFile;
 410   return OS;
 411 }
 412
 413 SyntaxOnlyAction::~SyntaxOnlyAction() {
 414 }
 415
 416 std::unique_ptr<ASTConsumer>
 417 SyntaxOnlyAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
 418   return llvm::make_unique<ASTConsumer>();
 419 }
 420
 421 std::unique_ptr<ASTConsumer>
 422 DumpModuleInfoAction::CreateASTConsumer(CompilerInstance &CI,
 423                                         StringRef InFile) {
 424   return llvm::make_unique<ASTConsumer>();
 425 }
 426
 427 std::unique_ptr<ASTConsumer>
 428 VerifyPCHAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
 429   return llvm::make_unique<ASTConsumer>();
 430 }
 431
 432 void VerifyPCHAction::ExecuteAction() {
 433   CompilerInstance &CI = getCompilerInstance();
 434   bool Preamble = CI.getPreprocessorOpts().PrecompiledPreambleBytes.first != 0;
 435   const std::string &Sysroot = CI.getHeaderSearchOpts().Sysroot;
 436   std::unique_ptr<ASTReader> Reader(new ASTReader(
 437       CI.getPreprocessor(), CI.getASTContext(), CI.getPCHContainerReader(),
 438       CI.getFrontendOpts().ModuleFileExtensions,
 439       Sysroot.empty() ? "" : Sysroot.c_str(),
 440       /*DisableValidation*/ false,
 441       /*AllowPCHWithCompilerErrors*/ false,
 442       /*AllowConfigurationMismatch*/ true,
 443       /*ValidateSystemInputs*/ true));
 444
 445   Reader->ReadAST(getCurrentFile(),
 446                   Preamble ? serialization::MK_Preamble
 447                            : serialization::MK_PCH,
 448                   SourceLocation(),
 449                   ASTReader::ARR_ConfigurationMismatch);
 450 }
 451
 452 namespace {
 453   /// \brief AST reader listener that dumps module information for a module
 454   /// file.
 455   class DumpModuleInfoListener : public ASTReaderListener {
 456     llvm::raw_ostream &Out;
 457
 458   public:
 459     DumpModuleInfoListener(llvm::raw_ostream &Out) : Out(Out) { }
 460
 461 #define DUMP_BOOLEAN(Value, Text)                       \
 462     Out.indent(4) << Text << ": " << (Value? "Yes" : "No") << "\n"
 463
 464     bool ReadFullVersionInformation(StringRef FullVersion) override {
 465       Out.indent(2)
 466         << "Generated by "
 467         << (FullVersion == getClangFullRepositoryVersion()? "this"
 468                                                           : "a different")
 469         << " Clang: " << FullVersion << "\n";
 470       return ASTReaderListener::ReadFullVersionInformation(FullVersion);
 471     }
 472
 473     void ReadModuleName(StringRef ModuleName) override {
 474       Out.indent(2) << "Module name: " << ModuleName << "\n";
 475     }
 476     void ReadModuleMapFile(StringRef ModuleMapPath) override {
 477       Out.indent(2) << "Module map file: " << ModuleMapPath << "\n";
 478     }
 479
 480     bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain,
 481                              bool AllowCompatibleDifferences) override {
 482       Out.indent(2) << "Language options:\n";
 483 #define LANGOPT(Name, Bits, Default, Description) \
 484       DUMP_BOOLEAN(LangOpts.Name, Description);
 485 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
 486       Out.indent(4) << Description << ": "                   \
 487                     << static_cast<unsigned>(LangOpts.get##Name()) << "\n";
 488 #define VALUE_LANGOPT(Name, Bits, Default, Description) \
 489       Out.indent(4) << Description << ": " << LangOpts.Name << "\n";
 490 #define BENIGN_LANGOPT(Name, Bits, Default, Description)
 491 #define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
 492 #include "clang/Basic/LangOptions.def"
 493
 494       if (!LangOpts.ModuleFeatures.empty()) {
 495         Out.indent(4) << "Module features:\n";
 496         for (StringRef Feature : LangOpts.ModuleFeatures)
 497           Out.indent(6) << Feature << "\n";
 498       }
 499
 500       return false;
 501     }
 502
 503     bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain,
 504                            bool AllowCompatibleDifferences) override {
 505       Out.indent(2) << "Target options:\n";
 506       Out.indent(4) << "  Triple: " << TargetOpts.Triple << "\n";
 507       Out.indent(4) << "  CPU: " << TargetOpts.CPU << "\n";
 508       Out.indent(4) << "  ABI: " << TargetOpts.ABI << "\n";
 509
 510       if (!TargetOpts.FeaturesAsWritten.empty()) {
 511         Out.indent(4) << "Target features:\n";
 512         for (unsigned I = 0, N = TargetOpts.FeaturesAsWritten.size();
 513              I != N; ++I) {
 514           Out.indent(6) << TargetOpts.FeaturesAsWritten[I] << "\n";
 515         }
 516       }
 517
 518       return false;
 519     }
 520
 521     bool ReadDiagnosticOptions(IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts,
 522                                bool Complain) override {
 523       Out.indent(2) << "Diagnostic options:\n";
 524 #define DIAGOPT(Name, Bits, Default) DUMP_BOOLEAN(DiagOpts->Name, #Name);
 525 #define ENUM_DIAGOPT(Name, Type, Bits, Default) \
 526       Out.indent(4) << #Name << ": " << DiagOpts->get##Name() << "\n";
 527 #define VALUE_DIAGOPT(Name, Bits, Default) \
 528       Out.indent(4) << #Name << ": " << DiagOpts->Name << "\n";
 529 #include "clang/Basic/DiagnosticOptions.def"
 530
 531       Out.indent(4) << "Diagnostic flags:\n";
 532       for (const std::string &Warning : DiagOpts->Warnings)
 533         Out.indent(6) << "-W" << Warning << "\n";
 534       for (const std::string &Remark : DiagOpts->Remarks)
 535         Out.indent(6) << "-R" << Remark << "\n";
 536
 537       return false;
 538     }
 539
 540     bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
 541                                  StringRef SpecificModuleCachePath,
 542                                  bool Complain) override {
 543       Out.indent(2) << "Header search options:\n";
 544       Out.indent(4) << "System root [-isysroot=]: '" << HSOpts.Sysroot << "'\n";
 545       Out.indent(4) << "Module Cache: '" << SpecificModuleCachePath << "'\n";
 546       DUMP_BOOLEAN(HSOpts.UseBuiltinIncludes,
 547                    "Use builtin include directories [-nobuiltininc]");
 548       DUMP_BOOLEAN(HSOpts.UseStandardSystemIncludes,
 549                    "Use standard system include directories [-nostdinc]");
 550       DUMP_BOOLEAN(HSOpts.UseStandardCXXIncludes,
 551                    "Use standard C++ include directories [-nostdinc++]");
 552       DUMP_BOOLEAN(HSOpts.UseLibcxx,
 553                    "Use libc++ (rather than libstdc++) [-stdlib=]");
 554       return false;
 555     }
 556
 557     bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
 558                                  bool Complain,
 559                                  std::string &SuggestedPredefines) override {
 560       Out.indent(2) << "Preprocessor options:\n";
 561       DUMP_BOOLEAN(PPOpts.UsePredefines,
 562                    "Uses compiler/target-specific predefines [-undef]");
 563       DUMP_BOOLEAN(PPOpts.DetailedRecord,
 564                    "Uses detailed preprocessing record (for indexing)");
 565
 566       if (!PPOpts.Macros.empty()) {
 567         Out.indent(4) << "Predefined macros:\n";
 568       }
 569
 570       for (std::vector<std::pair<std::string, bool/*isUndef*/> >::const_iterator
 571              I = PPOpts.Macros.begin(), IEnd = PPOpts.Macros.end();
 572            I != IEnd; ++I) {
 573         Out.indent(6);
 574         if (I->second)
 575           Out << "-U";
 576         else
 577           Out << "-D";
 578         Out << I->first << "\n";
 579       }
 580       return false;
 581     }
 582
 583     /// Indicates that a particular module file extension has been read.
 584     void readModuleFileExtension(
 585            const ModuleFileExtensionMetadata &Metadata) override {
 586       Out.indent(2) << "Module file extension '"
 587                     << Metadata.BlockName << "' " << Metadata.MajorVersion
 588                     << "." << Metadata.MinorVersion;
 589       if (!Metadata.UserInfo.empty()) {
 590         Out << ": ";
 591         Out.write_escaped(Metadata.UserInfo);
 592       }
 593
 594       Out << "\n";
 595     }
 596 #undef DUMP_BOOLEAN
 597   };
 598 }
 599
 600 void DumpModuleInfoAction::ExecuteAction() {
 601   // Set up the output file.
 602   std::unique_ptr<llvm::raw_fd_ostream> OutFile;
 603   StringRef OutputFileName = getCompilerInstance().getFrontendOpts().OutputFile;
 604   if (!OutputFileName.empty() && OutputFileName != "-") {
 605     std::error_code EC;
 606     OutFile.reset(new llvm::raw_fd_ostream(OutputFileName.str(), EC,
 607                                            llvm::sys::fs::F_Text));
 608   }
 609   llvm::raw_ostream &Out = OutFile.get()? *OutFile.get() : llvm::outs();
 610
 611   Out << "Information for module file '" << getCurrentFile() << "':\n";
 612   DumpModuleInfoListener Listener(Out);
 613   ASTReader::readASTFileControlBlock(
 614       getCurrentFile(), getCompilerInstance().getFileManager(),
 615       getCompilerInstance().getPCHContainerReader(),
 616       /*FindModuleFileExtensions=*/true, Listener);
 617 }
 618
 619 //===----------------------------------------------------------------------===//
 620 // Preprocessor Actions
 621 //===----------------------------------------------------------------------===//
 622
 623 void DumpRawTokensAction::ExecuteAction() {
 624   Preprocessor &PP = getCompilerInstance().getPreprocessor();
 625   SourceManager &SM = PP.getSourceManager();
 626
 627   // Start lexing the specified input file.
 628   const llvm::MemoryBuffer *FromFile = SM.getBuffer(SM.getMainFileID());
 629   Lexer RawLex(SM.getMainFileID(), FromFile, SM, PP.getLangOpts());
 630   RawLex.SetKeepWhitespaceMode(true);
 631
 632   Token RawTok;
 633   RawLex.LexFromRawLexer(RawTok);
 634   while (RawTok.isNot(tok::eof)) {
 635     PP.DumpToken(RawTok, true);
 636     llvm::errs() << "\n";
 637     RawLex.LexFromRawLexer(RawTok);
 638   }
 639 }
 640
 641 void DumpTokensAction::ExecuteAction() {
 642   Preprocessor &PP = getCompilerInstance().getPreprocessor();
 643   // Start preprocessing the specified input file.
 644   Token Tok;
 645   PP.EnterMainSourceFile();
 646   do {
 647     PP.Lex(Tok);
 648     PP.DumpToken(Tok, true);
 649     llvm::errs() << "\n";
 650   } while (Tok.isNot(tok::eof));
 651 }
 652
 653 void GeneratePTHAction::ExecuteAction() {
 654   CompilerInstance &CI = getCompilerInstance();
 655   std::unique_ptr<raw_pwrite_stream> OS =
 656       CI.createDefaultOutputFile(true, getCurrentFile());
 657   if (!OS)
 658     return;
 659
 660   CacheTokens(CI.getPreprocessor(), OS.get());
 661 }
 662
 663 void PreprocessOnlyAction::ExecuteAction() {
 664   Preprocessor &PP = getCompilerInstance().getPreprocessor();
 665
 666   // Ignore unknown pragmas.
 667   PP.IgnorePragmas();
 668
 669   Token Tok;
 670   // Start parsing the specified input file.
 671   PP.EnterMainSourceFile();
 672   do {
 673     PP.Lex(Tok);
 674   } while (Tok.isNot(tok::eof));
 675 }
 676
 677 void PrintPreprocessedAction::ExecuteAction() {
 678   CompilerInstance &CI = getCompilerInstance();
 679   // Output file may need to be set to 'Binary', to avoid converting Unix style
 680   // line feeds (<LF>) to Microsoft style line feeds (<CR><LF>).
 681   //
 682   // Look to see what type of line endings the file uses. If there's a
 683   // CRLF, then we won't open the file up in binary mode. If there is
 684   // just an LF or CR, then we will open the file up in binary mode.
 685   // In this fashion, the output format should match the input format, unless
 686   // the input format has inconsistent line endings.
 687   //
 688   // This should be a relatively fast operation since most files won't have
 689   // all of their source code on a single line. However, that is still a
 690   // concern, so if we scan for too long, we'll just assume the file should
 691   // be opened in binary mode.
 692   bool BinaryMode = true;
 693   bool InvalidFile = false;
 694   const SourceManager& SM = CI.getSourceManager();
 695   const llvm::MemoryBuffer *Buffer = SM.getBuffer(SM.getMainFileID(),
 696                                                      &InvalidFile);
 697   if (!InvalidFile) {
 698     const char *cur = Buffer->getBufferStart();
 699     const char *end = Buffer->getBufferEnd();
 700     const char *next = (cur != end) ? cur + 1 : end;
 701
 702     // Limit ourselves to only scanning 256 characters into the source
 703     // file.  This is mostly a sanity check in case the file has no
 704     // newlines whatsoever.
 705     if (end - cur > 256) end = cur + 256;
 706
 707     while (next < end) {
 708       if (*cur == 0x0D) {  // CR
 709         if (*next == 0x0A)  // CRLF
 710           BinaryMode = false;
 711
 712         break;
 713       } else if (*cur == 0x0A)  // LF
 714         break;
 715
 716       ++cur;
 717       ++next;
 718     }
 719   }
 720
 721   std::unique_ptr<raw_ostream> OS =
 722       CI.createDefaultOutputFile(BinaryMode, getCurrentFile());
 723   if (!OS) return;
 724
 725   DoPrintPreprocessedInput(CI.getPreprocessor(), OS.get(),
 726                            CI.getPreprocessorOutputOpts());
 727 }
 728
 729 void PrintPreambleAction::ExecuteAction() {
 730   switch (getCurrentFileKind()) {
 731   case IK_C:
 732   case IK_CXX:
 733   case IK_ObjC:
 734   case IK_ObjCXX:
 735   case IK_OpenCL:
 736   case IK_CUDA:
 737     break;
 738
 739   case IK_None:
 740   case IK_Asm:
 741   case IK_PreprocessedC:
 742   case IK_PreprocessedCuda:
 743   case IK_PreprocessedCXX:
 744   case IK_PreprocessedObjC:
 745   case IK_PreprocessedObjCXX:
 746   case IK_AST:
 747   case IK_LLVM_IR:
 748   case IK_RenderScript:
 749     // We can't do anything with these.
 750     return;
 751   }
 752
 753   CompilerInstance &CI = getCompilerInstance();
 754   auto Buffer = CI.getFileManager().getBufferForFile(getCurrentFile());
 755   if (Buffer) {
 756     unsigned Preamble =
 757         Lexer::ComputePreamble((*Buffer)->getBuffer(), CI.getLangOpts()).first;
 758     llvm::outs().write((*Buffer)->getBufferStart(), Preamble);
 759   }
 760 }