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