Add support for importing C++ inline functions (#5427)

This requires:
* Making `FunctionDecl` mutable since generating code
(`HandleTopLevelDecl()`) requires a mutable declaration and since we
manually add `used` attribute to force code generation.
* Passing the file system to `Lower` since it's needed by Clang code
generation.
* Creating an internal Clang LLVM module and link it against the Carbon
LLVM module.

Demo:

```c++
// hello_world.h

extern int puts;
inline void hello_world() {
  ((int (*)(const char*))&puts)("hello world");
}
```

```carbon
// main.carbon

library "Main";

import Cpp library "hello_world.h";

fn Run() -> i32 {
  Cpp.hello_world();
  return 0;
}
```

```shell
$ bazel-bin/toolchain/carbon compile main.carbon
$ bazel-bin/toolchain/carbon link main.o --output=demo
$ ./demo
hello world
```

Based on #5406.

Part of #5405.

Author: bricknerb

toolchain/check/check.cpp

@@ -326,7 +326,8 @@ auto CheckParseTrees(
     llvm::MutableArrayRef<Unit> units,
     llvm::ArrayRef<Parse::GetTreeAndSubtreesFn> tree_and_subtrees_getters,
     bool prelude_import, llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> fs,
-    llvm::raw_ostream* vlog_stream, bool fuzzing) -> void {
+    llvm::StringRef target, llvm::raw_ostream* vlog_stream, bool fuzzing)
+    -> void {
   // UnitAndImports is big due to its SmallVectors, so we default to 0 on the
   // stack.
   llvm::SmallVector<UnitAndImports, 0> unit_infos(
@@ -380,7 +381,8 @@ auto CheckParseTrees(
   for (int check_index = 0;
        check_index < static_cast<int>(ready_to_check.size()); ++check_index) {
     auto* unit_info = ready_to_check[check_index];
-    CheckUnit(unit_info, tree_and_subtrees_getters, fs, vlog_stream).Run();
+    CheckUnit(unit_info, tree_and_subtrees_getters, fs, target, vlog_stream)
+        .Run();
     for (auto* incoming_import : unit_info->incoming_imports) {
       --incoming_import->imports_remaining;
       if (incoming_import->imports_remaining == 0) {
@@ -427,7 +429,9 @@ auto CheckParseTrees(
     // incomplete imports.
     for (auto& unit_info : unit_infos) {
       if (unit_info.imports_remaining > 0) {
-        CheckUnit(&unit_info, tree_and_subtrees_getters, fs, vlog_stream).Run();
+        CheckUnit(&unit_info, tree_and_subtrees_getters, fs, target,
+                  vlog_stream)
+            .Run();
       }
     }
   }

toolchain/check/check.h

@@ -35,7 +35,8 @@ auto CheckParseTrees(
     llvm::MutableArrayRef<Unit> units,
     llvm::ArrayRef<Parse::GetTreeAndSubtreesFn> tree_and_subtrees_getters,
     bool prelude_import, llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> fs,
-    llvm::raw_ostream* vlog_stream, bool fuzzing) -> void;
+    llvm::StringRef target, llvm::raw_ostream* vlog_stream, bool fuzzing)
+    -> void;
 
 }  // namespace Carbon::Check
 

toolchain/check/check_unit.cpp

@@ -53,14 +53,15 @@ static auto GetImportedIRCount(UnitAndImports* unit_and_imports) -> int {
 CheckUnit::CheckUnit(
     UnitAndImports* unit_and_imports,
     llvm::ArrayRef<Parse::GetTreeAndSubtreesFn> tree_and_subtrees_getters,
-    llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> fs,
+    llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> fs, llvm::StringRef target,
     llvm::raw_ostream* vlog_stream)
     : unit_and_imports_(unit_and_imports),
       tree_and_subtrees_getter_(
           tree_and_subtrees_getters
               [unit_and_imports->unit->sem_ir->check_ir_id().index]),
       total_ir_count_(tree_and_subtrees_getters.size()),
       fs_(std::move(fs)),
+      target_(target),
       vlog_stream_(vlog_stream),
       emitter_(&unit_and_imports_->err_tracker, tree_and_subtrees_getters,
                unit_and_imports_->unit->sem_ir),
@@ -154,7 +155,7 @@ auto CheckUnit::InitPackageScopeAndImports() -> void {
     CARBON_CHECK(!cpp_ast->get());
     *cpp_ast =
         ImportCppFiles(context_, unit_and_imports_->unit->sem_ir->filename(),
-                       cpp_import_names, fs_);
+                       cpp_import_names, fs_, target_);
   }
 }
 

toolchain/check/check_unit.h

@@ -124,7 +124,7 @@ class CheckUnit {
       UnitAndImports* unit_and_imports,
       llvm::ArrayRef<Parse::GetTreeAndSubtreesFn> tree_and_subtrees_getters,
       llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> fs,
-      llvm::raw_ostream* vlog_stream);
+      llvm::StringRef target, llvm::raw_ostream* vlog_stream);
 
   // Produces and checks the IR for the provided unit.
   auto Run() -> void;
@@ -191,6 +191,7 @@ class CheckUnit {
   // The number of IRs being checked in total.
   int total_ir_count_;
   llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> fs_;
+  llvm::StringRef target_;
   llvm::raw_ostream* vlog_stream_;
 
   DiagnosticEmitter emitter_;

toolchain/check/import_cpp.cpp

@@ -179,7 +179,8 @@ class CarbonClangDiagnosticConsumer : public clang::DiagnosticConsumer {
 // TODO: Consider to always have a (non-null) AST.
 static auto GenerateAst(Context& context, llvm::StringRef importing_file_path,
                         llvm::ArrayRef<Parse::Tree::PackagingNames> imports,
-                        llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> fs)
+                        llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> fs,
+                        llvm::StringRef target)
     -> std::pair<std::unique_ptr<clang::ASTUnit>, bool> {
   // TODO: Use all import locations by referring each Clang diagnostic to the
   // relevant import.
@@ -190,9 +191,12 @@ static auto GenerateAst(Context& context, llvm::StringRef importing_file_path,
   // TODO: Share compilation flags with ClangRunner.
   auto ast = clang::tooling::buildASTFromCodeWithArgs(
       GenerateCppIncludesHeaderCode(context, imports),
-      // Parse C++ (and not C)
-      {"-x", "c++"}, (importing_file_path + ".generated.cpp_imports.h").str(),
-      "clang-tool", std::make_shared<clang::PCHContainerOperations>(),
+      // Parse C++ (and not C).
+      {"-x", "c++",
+       // Propagate the target to Clang.
+       "-target", target.str()},
+      (importing_file_path + ".generated.cpp_imports.h").str(), "clang-tool",
+      std::make_shared<clang::PCHContainerOperations>(),
       clang::tooling::getClangStripDependencyFileAdjuster(),
       clang::tooling::FileContentMappings(), &diagnostics_consumer, fs);
   // Remove link to the diagnostics consumer before its deletion.
@@ -235,16 +239,16 @@ static auto AddNamespace(Context& context, PackageNameId cpp_package_id,
 
 auto ImportCppFiles(Context& context, llvm::StringRef importing_file_path,
                     llvm::ArrayRef<Parse::Tree::PackagingNames> imports,
-                    llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> fs)
-    -> std::unique_ptr<clang::ASTUnit> {
+                    llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> fs,
+                    llvm::StringRef target) -> std::unique_ptr<clang::ASTUnit> {
   if (imports.empty()) {
     return nullptr;
   }
 
   CARBON_CHECK(!context.sem_ir().cpp_ast());
 
   auto [generated_ast, ast_has_error] =
-      GenerateAst(context, importing_file_path, imports, fs);
+      GenerateAst(context, importing_file_path, imports, fs, target);
 
   PackageNameId package_id = imports.front().package_id;
   CARBON_CHECK(
@@ -422,7 +426,7 @@ static auto GetReturnType(Context& context, SemIR::LocId loc_id,
 static auto ImportFunctionDecl(Context& context, SemIR::LocId loc_id,
                                SemIR::NameScopeId scope_id,
                                SemIR::NameId name_id,
-                               const clang::FunctionDecl* clang_decl)
+                               clang::FunctionDecl* clang_decl)
     -> SemIR::InstId {
   if (clang_decl->isVariadic()) {
     context.TODO(loc_id, "Unsupported: Variadic function");
@@ -603,7 +607,7 @@ static auto ImportCXXRecordDecl(Context& context, SemIR::LocId loc_id,
 static auto ImportNameDecl(Context& context, SemIR::LocId loc_id,
                            SemIR::NameScopeId scope_id, SemIR::NameId name_id,
                            clang::NamedDecl* clang_decl) -> SemIR::InstId {
-  if (const auto* clang_function_decl =
+  if (auto* clang_function_decl =
           clang::dyn_cast<clang::FunctionDecl>(clang_decl)) {
     return ImportFunctionDecl(context, loc_id, scope_id, name_id,
                               clang_function_decl);

toolchain/check/import_cpp.h

@@ -16,8 +16,8 @@ namespace Carbon::Check {
 // and warnings. If successful, adds a `Cpp` namespace and returns the AST.
 auto ImportCppFiles(Context& context, llvm::StringRef importing_file_path,
                     llvm::ArrayRef<Parse::Tree::PackagingNames> imports,
-                    llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> fs)
-    -> std::unique_ptr<clang::ASTUnit>;
+                    llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> fs,
+                    llvm::StringRef target) -> std::unique_ptr<clang::ASTUnit>;
 
 // Looks up the given name in the Clang AST generated when importing C++ code.
 // If successful, generates the instruction and returns the new `InstId`.

toolchain/driver/compile_subcommand.cpp

@@ -712,9 +712,9 @@ auto CompilationUnit::RunLower() -> void {
     if (options_->include_debug_info) {
       subtrees = cache_->tree_and_subtrees_getters();
     }
-    module_ =
-        Lower::LowerToLLVM(*llvm_context_, subtrees, input_filename_, *sem_ir_,
-                           sem_ir_->cpp_ast(), &inst_namer, vlog_stream_);
+    module_ = Lower::LowerToLLVM(*llvm_context_, driver_env_->fs, subtrees,
+                                 input_filename_, *sem_ir_, sem_ir_->cpp_ast(),
+                                 &inst_namer, vlog_stream_);
   });
   if (vlog_stream_) {
     CARBON_VLOG("*** llvm::Module ***\n");
@@ -964,6 +964,7 @@ auto CompileSubcommand::Run(DriverEnv& driver_env) -> DriverResult {
   CARBON_VLOG_TO(driver_env.vlog_stream, "*** Check::CheckParseTrees ***\n");
   Check::CheckParseTrees(check_units, cache.tree_and_subtrees_getters(),
                          options_.prelude_import, driver_env.fs,
+                         options_.codegen_options.target,
                          driver_env.vlog_stream, driver_env.fuzzing);
   CARBON_VLOG_TO(driver_env.vlog_stream,
                  "*** Check::CheckParseTrees done ***\n");

toolchain/language_server/BUILD

@@ -45,6 +45,7 @@ cc_library(
         "//toolchain/sem_ir:file",
         "//toolchain/source:source_buffer",
         "@llvm-project//clang-tools-extra/clangd:ClangDaemon",
+        "@llvm-project//llvm:TargetParser",
     ],
 )
 

toolchain/language_server/context.cpp

@@ -10,6 +10,7 @@
 
 #include "common/check.h"
 #include "common/raw_string_ostream.h"
+#include "llvm/TargetParser/Host.h"
 #include "toolchain/base/shared_value_stores.h"
 #include "toolchain/check/check.h"
 #include "toolchain/diagnostics/diagnostic.h"
@@ -152,7 +153,8 @@ auto Context::File::SetText(Context& context, std::optional<int64_t> version,
   // TODO: Include the prelude.
   Check::CheckParseTrees(
       units, llvm::ArrayRef<Parse::GetTreeAndSubtreesFn>(getter),
-      /*prelude_import=*/false, fs, context.vlog_stream(), /*fuzzing=*/false);
+      /*prelude_import=*/false, fs, llvm::sys::getDefaultTargetTriple(),
+      context.vlog_stream(), /*fuzzing=*/false);
 
   // Note we need to publish diagnostics even when empty.
   // TODO: Consider caching previously published diagnostics and only publishing

toolchain/lower/BUILD

@@ -57,7 +57,11 @@ cc_library(
         "//toolchain/sem_ir:inst_namer",
         "//toolchain/sem_ir:typed_insts",
         "@llvm-project//clang:ast",
+        "@llvm-project//clang:basic",
+        "@llvm-project//clang:codegen",
+        "@llvm-project//clang:lex",
         "@llvm-project//llvm:Core",
+        "@llvm-project//llvm:Linker",
         "@llvm-project//llvm:Support",
         "@llvm-project//llvm:TransformUtils",
     ],

toolchain/lower/file_context.cpp

@@ -9,10 +9,12 @@
 #include <string>
 #include <utility>
 
+#include "clang/CodeGen/ModuleBuilder.h"
 #include "common/check.h"
 #include "common/vlog.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/Sequence.h"
+#include "llvm/Linker/Linker.h"
 #include "llvm/Transforms/Utils/ModuleUtils.h"
 #include "toolchain/base/kind_switch.h"
 #include "toolchain/lower/constant.h"
@@ -33,13 +35,15 @@ namespace Carbon::Lower {
 
 FileContext::FileContext(
     llvm::LLVMContext& llvm_context,
+    llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> fs,
     std::optional<llvm::ArrayRef<Parse::GetTreeAndSubtreesFn>>
         tree_and_subtrees_getters_for_debug_info,
     llvm::StringRef module_name, const SemIR::File& sem_ir,
     clang::ASTUnit* cpp_ast, const SemIR::InstNamer* inst_namer,
     llvm::raw_ostream* vlog_stream)
     : llvm_context_(&llvm_context),
       llvm_module_(std::make_unique<llvm::Module>(module_name, llvm_context)),
+      fs_(std::move(fs)),
       di_builder_(*llvm_module_),
       di_compile_unit_(
           tree_and_subtrees_getters_for_debug_info
@@ -51,6 +55,8 @@ FileContext::FileContext(
       cpp_ast_(cpp_ast),
       inst_namer_(inst_namer),
       vlog_stream_(vlog_stream) {
+  // Initialization that relies on invariants of the class.
+  cpp_code_generator_ = CreateCppCodeGenerator();
   CARBON_CHECK(!sem_ir.has_errors(),
                "Generating LLVM IR from invalid SemIR::File is unsupported.");
 }
@@ -59,6 +65,10 @@ FileContext::FileContext(
 auto FileContext::Run() -> std::unique_ptr<llvm::Module> {
   CARBON_CHECK(llvm_module_, "Run can only be called once.");
 
+  if (cpp_code_generator_) {
+    cpp_code_generator_->Initialize(cpp_ast()->getASTContext());
+  }
+
   // Lower all types that were required to be complete.
   types_.resize(sem_ir_->insts().size());
   for (auto type_id : sem_ir_->types().complete_types()) {
@@ -124,6 +134,15 @@ auto FileContext::Run() -> std::unique_ptr<llvm::Module> {
                               /*Priority=*/0);
   }
 
+  if (cpp_code_generator_) {
+    cpp_code_generator_->HandleTranslationUnit(cpp_ast()->getASTContext());
+    bool link_error = llvm::Linker::linkModules(
+        /*Dest=*/*llvm_module_,
+        /*Src=*/std::unique_ptr<llvm::Module>(
+            cpp_code_generator_->ReleaseModule()));
+    CARBON_CHECK(!link_error);
+  }
+
   return std::move(llvm_module_);
 }
 
@@ -146,6 +165,21 @@ auto FileContext::BuildDICompileUnit(llvm::StringRef module_name,
                                       /*RV=*/0);
 }
 
+auto FileContext::CreateCppCodeGenerator()
+    -> std::unique_ptr<clang::CodeGenerator> {
+  if (!cpp_ast()) {
+    return nullptr;
+  }
+
+  RawStringOstream clang_module_name_stream;
+  clang_module_name_stream << llvm_module_->getName() << ".clang";
+
+  return std::unique_ptr<clang::CodeGenerator>(clang::CreateLLVMCodeGen(
+      cpp_ast()->getASTContext().getDiagnostics(),
+      clang_module_name_stream.TakeStr(), fs_, cpp_header_search_options_,
+      cpp_preprocessor_options_, cpp_code_gen_options_, *llvm_context_));
+}
+
 auto FileContext::GetGlobal(SemIR::InstId inst_id,
                             SemIR::SpecificId specific_id) -> llvm::Value* {
   auto const_id = GetConstantValueInSpecific(sem_ir(), specific_id, inst_id);
@@ -367,7 +401,8 @@ auto FileContext::BuildFunctionDefinition(SemIR::FunctionId function_id,
     -> void {
   const auto& function = sem_ir().functions().Get(function_id);
   const auto& body_block_ids = function.body_block_ids;
-  if (body_block_ids.empty()) {
+  if (body_block_ids.empty() &&
+      (!function.cpp_decl || !function.cpp_decl->isDefined())) {
     // Function is probably defined in another file; not an error.
     return;
   }
@@ -396,6 +431,29 @@ auto FileContext::BuildFunctionBody(SemIR::FunctionId function_id,
                                     SemIR::SpecificId specific_id) -> void {
   const auto& body_block_ids = function.body_block_ids;
   CARBON_DCHECK(llvm_function, "LLVM Function not found when lowering body.");
+
+  if (function.cpp_decl) {
+    // TODO: To support recursive inline functions, collect all calls to
+    // `HandleTopLevelDecl()` in a custom `ASTConsumer` configured in the
+    // `ASTUnit`, and replay them in lowering in the `CodeGenerator`. See
+    // https://discord.com/channels/655572317891461132/768530752592805919/1370509111585935443
+    clang::FunctionDecl* cpp_def = function.cpp_decl->getDefinition();
+    CARBON_DCHECK(cpp_def, "No Clang function body found during lowering");
+
+    // Create the LLVM function (`CodeGenModule::GetOrCreateLLVMFunction()`) so
+    // that code generation (`CodeGenModule::EmitGlobal()`) would see this
+    // function name (`CodeGenModule::getMangledName()`), and will generate its
+    // definition.
+    llvm::Constant* function_address =
+        cpp_code_generator_->GetAddrOfGlobal(clang::GlobalDecl(cpp_def),
+                                             /*isForDefinition=*/false);
+    CARBON_DCHECK(function_address);
+
+    // Emit the function code.
+    cpp_code_generator_->HandleTopLevelDecl(clang::DeclGroupRef(cpp_def));
+    return;
+  }
+
   CARBON_DCHECK(!body_block_ids.empty(),
                 "No function body blocks found during lowering.");