1 //===------ Interpreter.cpp - Incremental Compilation and Execution -------===// 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 // This file implements the component which performs incremental code 10 // compilation and execution. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "clang/Interpreter/Interpreter.h" 15 16 #include "IncrementalExecutor.h" 17 #include "IncrementalParser.h" 18 19 #include "clang/AST/ASTContext.h" 20 #include "clang/Basic/TargetInfo.h" 21 #include "clang/CodeGen/ModuleBuilder.h" 22 #include "clang/CodeGen/ObjectFilePCHContainerOperations.h" 23 #include "clang/Driver/Compilation.h" 24 #include "clang/Driver/Driver.h" 25 #include "clang/Driver/Job.h" 26 #include "clang/Driver/Options.h" 27 #include "clang/Driver/Tool.h" 28 #include "clang/Frontend/CompilerInstance.h" 29 #include "clang/Frontend/TextDiagnosticBuffer.h" 30 #include "clang/Lex/PreprocessorOptions.h" 31 32 #include "llvm/IR/Module.h" 33 #include "llvm/Support/Host.h" 34 35 using namespace clang; 36 37 // FIXME: Figure out how to unify with namespace init_convenience from 38 // tools/clang-import-test/clang-import-test.cpp and 39 // examples/clang-interpreter/main.cpp 40 namespace { 41 /// Retrieves the clang CC1 specific flags out of the compilation's jobs. 42 /// \returns NULL on error. 43 static llvm::Expected<const llvm::opt::ArgStringList *> 44 GetCC1Arguments(DiagnosticsEngine *Diagnostics, 45 driver::Compilation *Compilation) { 46 // We expect to get back exactly one Command job, if we didn't something 47 // failed. Extract that job from the Compilation. 48 const driver::JobList &Jobs = Compilation->getJobs(); 49 if (!Jobs.size() || !isa<driver::Command>(*Jobs.begin())) 50 return llvm::createStringError(std::errc::state_not_recoverable, 51 "Driver initialization failed. " 52 "Unable to create a driver job"); 53 54 // The one job we find should be to invoke clang again. 55 const driver::Command *Cmd = cast<driver::Command>(&(*Jobs.begin())); 56 if (llvm::StringRef(Cmd->getCreator().getName()) != "clang") 57 return llvm::createStringError(std::errc::state_not_recoverable, 58 "Driver initialization failed"); 59 60 return &Cmd->getArguments(); 61 } 62 63 static llvm::Expected<std::unique_ptr<CompilerInstance>> 64 CreateCI(const llvm::opt::ArgStringList &Argv) { 65 std::unique_ptr<CompilerInstance> Clang(new CompilerInstance()); 66 IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs()); 67 68 // Register the support for object-file-wrapped Clang modules. 69 // FIXME: Clang should register these container operations automatically. 70 auto PCHOps = Clang->getPCHContainerOperations(); 71 PCHOps->registerWriter(std::make_unique<ObjectFilePCHContainerWriter>()); 72 PCHOps->registerReader(std::make_unique<ObjectFilePCHContainerReader>()); 73 74 // Buffer diagnostics from argument parsing so that we can output them using 75 // a well formed diagnostic object. 76 IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions(); 77 TextDiagnosticBuffer *DiagsBuffer = new TextDiagnosticBuffer; 78 DiagnosticsEngine Diags(DiagID, &*DiagOpts, DiagsBuffer); 79 bool Success = CompilerInvocation::CreateFromArgs( 80 Clang->getInvocation(), llvm::makeArrayRef(Argv.begin(), Argv.size()), 81 Diags); 82 83 // Infer the builtin include path if unspecified. 84 if (Clang->getHeaderSearchOpts().UseBuiltinIncludes && 85 Clang->getHeaderSearchOpts().ResourceDir.empty()) 86 Clang->getHeaderSearchOpts().ResourceDir = 87 CompilerInvocation::GetResourcesPath(Argv[0], nullptr); 88 89 // Create the actual diagnostics engine. 90 Clang->createDiagnostics(); 91 if (!Clang->hasDiagnostics()) 92 return llvm::createStringError(std::errc::state_not_recoverable, 93 "Initialization failed. " 94 "Unable to create diagnostics engine"); 95 96 DiagsBuffer->FlushDiagnostics(Clang->getDiagnostics()); 97 if (!Success) 98 return llvm::createStringError(std::errc::state_not_recoverable, 99 "Initialization failed. " 100 "Unable to flush diagnostics"); 101 102 // FIXME: Merge with CompilerInstance::ExecuteAction. 103 llvm::MemoryBuffer *MB = llvm::MemoryBuffer::getMemBuffer("").release(); 104 Clang->getPreprocessorOpts().addRemappedFile("<<< inputs >>>", MB); 105 106 Clang->setTarget(TargetInfo::CreateTargetInfo( 107 Clang->getDiagnostics(), Clang->getInvocation().TargetOpts)); 108 if (!Clang->hasTarget()) 109 return llvm::createStringError(std::errc::state_not_recoverable, 110 "Initialization failed. " 111 "Target is missing"); 112 113 Clang->getTarget().adjust(Clang->getDiagnostics(), Clang->getLangOpts()); 114 115 return std::move(Clang); 116 } 117 118 } // anonymous namespace 119 120 llvm::Expected<std::unique_ptr<CompilerInstance>> 121 IncrementalCompilerBuilder::create(std::vector<const char *> &ClangArgv) { 122 123 // If we don't know ClangArgv0 or the address of main() at this point, try 124 // to guess it anyway (it's possible on some platforms). 125 std::string MainExecutableName = 126 llvm::sys::fs::getMainExecutable(nullptr, nullptr); 127 128 ClangArgv.insert(ClangArgv.begin(), MainExecutableName.c_str()); 129 130 // Prepending -c to force the driver to do something if no action was 131 // specified. By prepending we allow users to override the default 132 // action and use other actions in incremental mode. 133 // FIXME: Print proper driver diagnostics if the driver flags are wrong. 134 ClangArgv.insert(ClangArgv.begin() + 1, "-c"); 135 136 if (!llvm::is_contained(ClangArgv, " -x")) { 137 // We do C++ by default; append right after argv[0] if no "-x" given 138 ClangArgv.push_back("-x"); 139 ClangArgv.push_back("c++"); 140 } 141 142 // Put a dummy C++ file on to ensure there's at least one compile job for the 143 // driver to construct. 144 ClangArgv.push_back("<<< inputs >>>"); 145 146 CompilerInvocation Invocation; 147 // Buffer diagnostics from argument parsing so that we can output them using a 148 // well formed diagnostic object. 149 IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs()); 150 IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions(); 151 TextDiagnosticBuffer *DiagsBuffer = new TextDiagnosticBuffer; 152 DiagnosticsEngine Diags(DiagID, &*DiagOpts, DiagsBuffer); 153 unsigned MissingArgIndex, MissingArgCount; 154 const llvm::opt::OptTable &Opts = driver::getDriverOptTable(); 155 llvm::opt::InputArgList ParsedArgs = 156 Opts.ParseArgs(ArrayRef<const char *>(ClangArgv).slice(1), 157 MissingArgIndex, MissingArgCount); 158 ParseDiagnosticArgs(*DiagOpts, ParsedArgs, &Diags); 159 160 driver::Driver Driver(/*MainBinaryName=*/ClangArgv[0], 161 llvm::sys::getProcessTriple(), Diags); 162 Driver.setCheckInputsExist(false); // the input comes from mem buffers 163 llvm::ArrayRef<const char *> RF = llvm::makeArrayRef(ClangArgv); 164 std::unique_ptr<driver::Compilation> Compilation(Driver.BuildCompilation(RF)); 165 166 if (Compilation->getArgs().hasArg(driver::options::OPT_v)) 167 Compilation->getJobs().Print(llvm::errs(), "\n", /*Quote=*/false); 168 169 auto ErrOrCC1Args = GetCC1Arguments(&Diags, Compilation.get()); 170 if (auto Err = ErrOrCC1Args.takeError()) 171 return std::move(Err); 172 173 return CreateCI(**ErrOrCC1Args); 174 } 175 176 Interpreter::Interpreter(std::unique_ptr<CompilerInstance> CI, 177 llvm::Error &Err) { 178 llvm::ErrorAsOutParameter EAO(&Err); 179 auto LLVMCtx = std::make_unique<llvm::LLVMContext>(); 180 TSCtx = std::make_unique<llvm::orc::ThreadSafeContext>(std::move(LLVMCtx)); 181 IncrParser = std::make_unique<IncrementalParser>(std::move(CI), 182 *TSCtx->getContext(), Err); 183 } 184 185 Interpreter::~Interpreter() {} 186 187 llvm::Expected<std::unique_ptr<Interpreter>> 188 Interpreter::create(std::unique_ptr<CompilerInstance> CI) { 189 llvm::Error Err = llvm::Error::success(); 190 auto Interp = 191 std::unique_ptr<Interpreter>(new Interpreter(std::move(CI), Err)); 192 if (Err) 193 return std::move(Err); 194 return std::move(Interp); 195 } 196 197 const CompilerInstance *Interpreter::getCompilerInstance() const { 198 return IncrParser->getCI(); 199 } 200 201 llvm::Expected<PartialTranslationUnit &> 202 Interpreter::Parse(llvm::StringRef Code) { 203 return IncrParser->Parse(Code); 204 } 205 206 llvm::Error Interpreter::Execute(PartialTranslationUnit &T) { 207 assert(T.TheModule); 208 if (!IncrExecutor) { 209 const llvm::Triple &Triple = 210 getCompilerInstance()->getASTContext().getTargetInfo().getTriple(); 211 llvm::Error Err = llvm::Error::success(); 212 IncrExecutor = std::make_unique<IncrementalExecutor>(*TSCtx, Err, Triple); 213 214 if (Err) 215 return Err; 216 } 217 // FIXME: Add a callback to retain the llvm::Module once the JIT is done. 218 if (auto Err = IncrExecutor->addModule(std::move(T.TheModule))) 219 return Err; 220 221 if (auto Err = IncrExecutor->runCtors()) 222 return Err; 223 224 return llvm::Error::success(); 225 } 226