[clang-repl] Automatically inline CUDA device functions in interpreter

[argentite]

Summary

CUDA device code linking is currently not implemented. This is a
workaround by inlining all device functions

clang/lib/Interpreter/IncrementalParser.h

protected:
 
   /// Counts the number of direct user input lines that have been parsed.
   unsigned InputCount = 0;
 
   /// List containing every information about every incrementally parsed piece
   /// of code.
   std::list<PartialTranslationUnit> PTUs;
 
+  /// Callbacks executed with the parsed result of every incremntal input
+  std::vector<std::function<void(DeclGroupRef)>> ASTHandlers;
+
   IncrementalParser();
 
 public:
   IncrementalParser(std::unique_ptr<CompilerInstance> Instance,
                     llvm::LLVMContext &LLVMCtx, llvm::Error &Err);
   virtual ~IncrementalParser();
 
   const CompilerInstance *getCI() const { return CI.get(); }

clang/lib/Interpreter/IncrementalParser.cpp

if (P->getCurToken().is(tok::eof)) {
     P->EnterScope(Scope::DeclScope);
     S.ActOnTranslationUnitScope(P->getCurScope());
   }
 
   Parser::DeclGroupPtrTy ADecl;
   Sema::ModuleImportState ImportState;
   for (bool AtEOF = P->ParseFirstTopLevelDecl(ADecl, ImportState); !AtEOF;
        AtEOF = P->ParseTopLevelDecl(ADecl, ImportState)) {
-    if (ADecl && !Consumer->HandleTopLevelDecl(ADecl.get()))
-      return llvm::make_error<llvm::StringError>("Parsing failed. "
-                                                 "The consumer rejected a decl",
-                                                 std::error_code());
+    if (ADecl) {
+      auto DeclGroup = ADecl.get();
+      for (auto handler : ASTHandlers) {
+        handler(DeclGroup);
+      }
+      if (!Consumer->HandleTopLevelDecl(DeclGroup))
+        return llvm::make_error<llvm::StringError>(
+            "Parsing failed. The consumer rejected a decl", std::error_code());
+    }
   }
 
   DiagnosticsEngine &Diags = getCI()->getDiagnostics();
   if (Diags.hasErrorOccurred()) {
     PartialTranslationUnit MostRecentPTU = {C.getTranslationUnitDecl(),
                                             nullptr};
     CleanUpPTU(MostRecentPTU);
 

clang/lib/Interpreter/Offload.cpp

 #include "clang/Frontend/CompilerInstance.h"
 
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Target/TargetMachine.h"
 
 namespace clang {
 
+static void inlineCudaDeviceFunctions(DeclGroupRef DG) {
+  for (auto *Decl : DG) {
+    if (Decl->isFunctionOrFunctionTemplate()) {
+      auto *Func = Decl->getAsFunction();
+      if (Func->hasAttr<CUDADeviceAttr>()) {
+        Func->setInlineSpecified(true);
+      }
+    }
+  }
+}
+
 IncrementalCUDADeviceParser::IncrementalCUDADeviceParser(
     std::unique_ptr<CompilerInstance> Instance, llvm::LLVMContext &LLVMCtx,
     llvm::StringRef Arch, llvm::StringRef FatbinFile, llvm::Error &Err)
     : IncrementalParser(std::move(Instance), LLVMCtx, Err) {
   if (Err)
     return;
 
+  ASTHandlers.push_back(inlineCudaDeviceFunctions);
+
   if (!Arch.starts_with("sm_") || Arch.substr(3).getAsInteger(10, SMVersion)) {
     llvm::errs() << Arch.substr(3) << SMVersion << '\n';
 
     Err = llvm::joinErrors(std::move(Err), llvm::make_error<llvm::StringError>(
                                                "Invalid CUDA architecture",
                                                llvm::inconvertibleErrorCode()));
     return;
   }