1 //===--- FrontendActions.cpp ----------------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "clang/Rewrite/Frontend/FrontendActions.h" 10 #include "clang/AST/ASTConsumer.h" 11 #include "clang/Basic/CharInfo.h" 12 #include "clang/Basic/LangStandard.h" 13 #include "clang/Config/config.h" 14 #include "clang/Frontend/CompilerInstance.h" 15 #include "clang/Frontend/FrontendActions.h" 16 #include "clang/Frontend/FrontendDiagnostic.h" 17 #include "clang/Frontend/Utils.h" 18 #include "clang/Lex/Preprocessor.h" 19 #include "clang/Lex/PreprocessorOptions.h" 20 #include "clang/Rewrite/Frontend/ASTConsumers.h" 21 #include "clang/Rewrite/Frontend/FixItRewriter.h" 22 #include "clang/Rewrite/Frontend/Rewriters.h" 23 #include "clang/Serialization/ASTReader.h" 24 #include "clang/Serialization/ModuleFile.h" 25 #include "clang/Serialization/ModuleManager.h" 26 #include "llvm/ADT/DenseSet.h" 27 #include "llvm/Support/CrashRecoveryContext.h" 28 #include "llvm/Support/FileSystem.h" 29 #include "llvm/Support/Path.h" 30 #include "llvm/Support/raw_ostream.h" 31 #include <memory> 32 #include <utility> 33 34 using namespace clang; 35 36 //===----------------------------------------------------------------------===// 37 // AST Consumer Actions 38 //===----------------------------------------------------------------------===// 39 40 std::unique_ptr<ASTConsumer> 41 HTMLPrintAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) { 42 if (std::unique_ptr<raw_ostream> OS = 43 CI.createDefaultOutputFile(false, InFile)) 44 return CreateHTMLPrinter(std::move(OS), CI.getPreprocessor()); 45 return nullptr; 46 } 47 48 FixItAction::FixItAction() {} 49 FixItAction::~FixItAction() {} 50 51 std::unique_ptr<ASTConsumer> 52 FixItAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) { 53 return std::make_unique<ASTConsumer>(); 54 } 55 56 namespace { 57 class FixItRewriteInPlace : public FixItOptions { 58 public: 59 FixItRewriteInPlace() { InPlace = true; } 60 61 std::string RewriteFilename(const std::string &Filename, int &fd) override { 62 llvm_unreachable("don't call RewriteFilename for inplace rewrites"); 63 } 64 }; 65 66 class FixItActionSuffixInserter : public FixItOptions { 67 std::string NewSuffix; 68 69 public: 70 FixItActionSuffixInserter(std::string NewSuffix, bool FixWhatYouCan) 71 : NewSuffix(std::move(NewSuffix)) { 72 this->FixWhatYouCan = FixWhatYouCan; 73 } 74 75 std::string RewriteFilename(const std::string &Filename, int &fd) override { 76 fd = -1; 77 SmallString<128> Path(Filename); 78 llvm::sys::path::replace_extension(Path, 79 NewSuffix + llvm::sys::path::extension(Path)); 80 return std::string(Path.str()); 81 } 82 }; 83 84 class FixItRewriteToTemp : public FixItOptions { 85 public: 86 std::string RewriteFilename(const std::string &Filename, int &fd) override { 87 SmallString<128> Path; 88 llvm::sys::fs::createTemporaryFile(llvm::sys::path::filename(Filename), 89 llvm::sys::path::extension(Filename).drop_front(), fd, 90 Path); 91 return std::string(Path.str()); 92 } 93 }; 94 } // end anonymous namespace 95 96 bool FixItAction::BeginSourceFileAction(CompilerInstance &CI) { 97 const FrontendOptions &FEOpts = getCompilerInstance().getFrontendOpts(); 98 if (!FEOpts.FixItSuffix.empty()) { 99 FixItOpts.reset(new FixItActionSuffixInserter(FEOpts.FixItSuffix, 100 FEOpts.FixWhatYouCan)); 101 } else { 102 FixItOpts.reset(new FixItRewriteInPlace); 103 FixItOpts->FixWhatYouCan = FEOpts.FixWhatYouCan; 104 } 105 Rewriter.reset(new FixItRewriter(CI.getDiagnostics(), CI.getSourceManager(), 106 CI.getLangOpts(), FixItOpts.get())); 107 return true; 108 } 109 110 void FixItAction::EndSourceFileAction() { 111 // Otherwise rewrite all files. 112 Rewriter->WriteFixedFiles(); 113 } 114 115 bool FixItRecompile::BeginInvocation(CompilerInstance &CI) { 116 117 std::vector<std::pair<std::string, std::string> > RewrittenFiles; 118 bool err = false; 119 { 120 const FrontendOptions &FEOpts = CI.getFrontendOpts(); 121 std::unique_ptr<FrontendAction> FixAction(new SyntaxOnlyAction()); 122 if (FixAction->BeginSourceFile(CI, FEOpts.Inputs[0])) { 123 std::unique_ptr<FixItOptions> FixItOpts; 124 if (FEOpts.FixToTemporaries) 125 FixItOpts.reset(new FixItRewriteToTemp()); 126 else 127 FixItOpts.reset(new FixItRewriteInPlace()); 128 FixItOpts->Silent = true; 129 FixItOpts->FixWhatYouCan = FEOpts.FixWhatYouCan; 130 FixItOpts->FixOnlyWarnings = FEOpts.FixOnlyWarnings; 131 FixItRewriter Rewriter(CI.getDiagnostics(), CI.getSourceManager(), 132 CI.getLangOpts(), FixItOpts.get()); 133 if (llvm::Error Err = FixAction->Execute()) { 134 // FIXME this drops the error on the floor. 135 consumeError(std::move(Err)); 136 return false; 137 } 138 139 err = Rewriter.WriteFixedFiles(&RewrittenFiles); 140 141 FixAction->EndSourceFile(); 142 CI.setSourceManager(nullptr); 143 CI.setFileManager(nullptr); 144 } else { 145 err = true; 146 } 147 } 148 if (err) 149 return false; 150 CI.getDiagnosticClient().clear(); 151 CI.getDiagnostics().Reset(); 152 153 PreprocessorOptions &PPOpts = CI.getPreprocessorOpts(); 154 PPOpts.RemappedFiles.insert(PPOpts.RemappedFiles.end(), 155 RewrittenFiles.begin(), RewrittenFiles.end()); 156 PPOpts.RemappedFilesKeepOriginalName = false; 157 158 return true; 159 } 160 161 #if CLANG_ENABLE_OBJC_REWRITER 162 163 std::unique_ptr<ASTConsumer> 164 RewriteObjCAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) { 165 if (std::unique_ptr<raw_ostream> OS = 166 CI.createDefaultOutputFile(false, InFile, "cpp")) { 167 if (CI.getLangOpts().ObjCRuntime.isNonFragile()) 168 return CreateModernObjCRewriter( 169 std::string(InFile), std::move(OS), CI.getDiagnostics(), 170 CI.getLangOpts(), CI.getDiagnosticOpts().NoRewriteMacros, 171 (CI.getCodeGenOpts().getDebugInfo() != codegenoptions::NoDebugInfo)); 172 return CreateObjCRewriter(std::string(InFile), std::move(OS), 173 CI.getDiagnostics(), CI.getLangOpts(), 174 CI.getDiagnosticOpts().NoRewriteMacros); 175 } 176 return nullptr; 177 } 178 179 #endif 180 181 //===----------------------------------------------------------------------===// 182 // Preprocessor Actions 183 //===----------------------------------------------------------------------===// 184 185 void RewriteMacrosAction::ExecuteAction() { 186 CompilerInstance &CI = getCompilerInstance(); 187 std::unique_ptr<raw_ostream> OS = 188 CI.createDefaultOutputFile(true, getCurrentFileOrBufferName()); 189 if (!OS) return; 190 191 RewriteMacrosInInput(CI.getPreprocessor(), OS.get()); 192 } 193 194 void RewriteTestAction::ExecuteAction() { 195 CompilerInstance &CI = getCompilerInstance(); 196 std::unique_ptr<raw_ostream> OS = 197 CI.createDefaultOutputFile(false, getCurrentFileOrBufferName()); 198 if (!OS) return; 199 200 DoRewriteTest(CI.getPreprocessor(), OS.get()); 201 } 202 203 class RewriteIncludesAction::RewriteImportsListener : public ASTReaderListener { 204 CompilerInstance &CI; 205 std::weak_ptr<raw_ostream> Out; 206 207 llvm::DenseSet<const FileEntry*> Rewritten; 208 209 public: 210 RewriteImportsListener(CompilerInstance &CI, std::shared_ptr<raw_ostream> Out) 211 : CI(CI), Out(Out) {} 212 213 void visitModuleFile(StringRef Filename, 214 serialization::ModuleKind Kind) override { 215 auto File = CI.getFileManager().getFile(Filename); 216 assert(File && "missing file for loaded module?"); 217 218 // Only rewrite each module file once. 219 if (!Rewritten.insert(*File).second) 220 return; 221 222 serialization::ModuleFile *MF = 223 CI.getASTReader()->getModuleManager().lookup(*File); 224 assert(MF && "missing module file for loaded module?"); 225 226 // Not interested in PCH / preambles. 227 if (!MF->isModule()) 228 return; 229 230 auto OS = Out.lock(); 231 assert(OS && "loaded module file after finishing rewrite action?"); 232 233 (*OS) << "#pragma clang module build "; 234 if (isValidIdentifier(MF->ModuleName)) 235 (*OS) << MF->ModuleName; 236 else { 237 (*OS) << '"'; 238 OS->write_escaped(MF->ModuleName); 239 (*OS) << '"'; 240 } 241 (*OS) << '\n'; 242 243 // Rewrite the contents of the module in a separate compiler instance. 244 CompilerInstance Instance(CI.getPCHContainerOperations(), 245 &CI.getModuleCache()); 246 Instance.setInvocation( 247 std::make_shared<CompilerInvocation>(CI.getInvocation())); 248 Instance.createDiagnostics( 249 new ForwardingDiagnosticConsumer(CI.getDiagnosticClient()), 250 /*ShouldOwnClient=*/true); 251 Instance.getFrontendOpts().DisableFree = false; 252 Instance.getFrontendOpts().Inputs.clear(); 253 Instance.getFrontendOpts().Inputs.emplace_back( 254 Filename, InputKind(Language::Unknown, InputKind::Precompiled)); 255 Instance.getFrontendOpts().ModuleFiles.clear(); 256 Instance.getFrontendOpts().ModuleMapFiles.clear(); 257 // Don't recursively rewrite imports. We handle them all at the top level. 258 Instance.getPreprocessorOutputOpts().RewriteImports = false; 259 260 llvm::CrashRecoveryContext().RunSafelyOnThread([&]() { 261 RewriteIncludesAction Action; 262 Action.OutputStream = OS; 263 Instance.ExecuteAction(Action); 264 }); 265 266 (*OS) << "#pragma clang module endbuild /*" << MF->ModuleName << "*/\n"; 267 } 268 }; 269 270 bool RewriteIncludesAction::BeginSourceFileAction(CompilerInstance &CI) { 271 if (!OutputStream) { 272 OutputStream = 273 CI.createDefaultOutputFile(true, getCurrentFileOrBufferName()); 274 if (!OutputStream) 275 return false; 276 } 277 278 auto &OS = *OutputStream; 279 280 // If we're preprocessing a module map, start by dumping the contents of the 281 // module itself before switching to the input buffer. 282 auto &Input = getCurrentInput(); 283 if (Input.getKind().getFormat() == InputKind::ModuleMap) { 284 if (Input.isFile()) { 285 OS << "# 1 \""; 286 OS.write_escaped(Input.getFile()); 287 OS << "\"\n"; 288 } 289 getCurrentModule()->print(OS); 290 OS << "#pragma clang module contents\n"; 291 } 292 293 // If we're rewriting imports, set up a listener to track when we import 294 // module files. 295 if (CI.getPreprocessorOutputOpts().RewriteImports) { 296 CI.createASTReader(); 297 CI.getASTReader()->addListener( 298 std::make_unique<RewriteImportsListener>(CI, OutputStream)); 299 } 300 301 return true; 302 } 303 304 void RewriteIncludesAction::ExecuteAction() { 305 CompilerInstance &CI = getCompilerInstance(); 306 307 // If we're rewriting imports, emit the module build output first rather 308 // than switching back and forth (potentially in the middle of a line). 309 if (CI.getPreprocessorOutputOpts().RewriteImports) { 310 std::string Buffer; 311 llvm::raw_string_ostream OS(Buffer); 312 313 RewriteIncludesInInput(CI.getPreprocessor(), &OS, 314 CI.getPreprocessorOutputOpts()); 315 316 (*OutputStream) << OS.str(); 317 } else { 318 RewriteIncludesInInput(CI.getPreprocessor(), OutputStream.get(), 319 CI.getPreprocessorOutputOpts()); 320 } 321 322 OutputStream.reset(); 323 } 324