Merge pull request #690 from glu-lang/feature/import-llvm

Snowy1803 · web-flow · commit b1839bf2c840 · 2025-10-27T19:17:35.000Z
Feature: Import LLVM files 🎉
diff --git a/include/Basic/SourceManager.hpp b/include/Basic/SourceManager.hpp
@@ -139,9 +139,6 @@ class SourceManager {
 
     ~SourceManager() = default;
 
-    ///
-    /// TODO: This function must be part of the FileManager class.
-    ///
     /// Load a file from the file system. The file is loaded using the virtual
     /// file system. The content of the file is stored in a ContentCache object
     /// and the file is assigned a FileID.
@@ -150,6 +147,7 @@ class SourceManager {
     /// @return A FileID object that represents the file that has been loaded.
     ///
     llvm::ErrorOr<FileID> loadFile(llvm::StringRef filePath);
+    llvm::ErrorOr<FileID> loadIRFile(llvm::StringRef filePath);
     llvm::MemoryBuffer *getBuffer(FileID fileId) const;
 
     void setMainFileID(FileID fid) { _mainFile = fid; }
diff --git a/include/IRDec/ModuleLifter.hpp b/include/IRDec/ModuleLifter.hpp
@@ -2,7 +2,7 @@
 #define GLU_IRDEC_MODULE_LIFTER_HPP
 
 #include "AST/Decls.hpp"
-#include "GIL/Module.hpp"
+
 #include <llvm/IR/Module.h>
 
 namespace glu::irdec {
diff --git a/include/Sema/ImportManager.hpp b/include/Sema/ImportManager.hpp
@@ -186,11 +186,31 @@ class ImportManager {
     LocalImportResult tryLoadingFile(
         SourceLocation importLoc, FileID fid, llvm::StringRef selector
     );
+    /// @brief Tries to select a module to import from a given LLVM IR file. The
+    /// file should contain LLVM bitcode or human-readable LLVM IR representing
+    /// a previously compiled module.
+    /// @param importLoc The source location of the import declaration, used for
+    /// diagnostics.
+    /// @param fid The file ID to load the module from.
+    /// @param selector The selector to import (or empty to import the namespace
+    /// itself, or "@all" to import all content).
+    /// @return Returns an import result if it was successfully loaded, or
+    /// std::nullopt if an error occurred.
+    LocalImportResult tryLoadingIRFile(
+        SourceLocation importLoc, FileID fid, llvm::StringRef selector
+    );
     /// @brief Loads a module from a file ID.
     /// @param fid The FileID of the module to load.
     /// @return Returns true if the module was loaded successfully, false
     /// otherwise.
     bool loadModuleFromFileID(FileID fid);
+    /// @brief Loads a module from an LLVM IR file.
+    /// @param importLoc The source location of the import declaration, used for
+    /// diagnostics.
+    /// @param fid The FileID of the module to load.
+    /// @return Returns true if the module was loaded successfully, false
+    /// otherwise.
+    bool loadModuleFromIRFile(SourceLocation importLoc, FileID fid);
     /// @brief Imports a module into a given scope.
     /// @param importedModule The module to import.
     /// @param selector The selector to import (or empty to import the namespace
diff --git a/lib/Basic/SourceManager.cpp b/lib/Basic/SourceManager.cpp
@@ -41,6 +41,33 @@ glu::SourceManager::loadFile(llvm::StringRef filePath)
     return llvm::ErrorOr<glu::FileID>(glu::FileID(_fileLocEntries.size() - 1));
 }
 
+llvm::ErrorOr<glu::FileID>
+glu::SourceManager::loadIRFile(llvm::StringRef filePath)
+{
+    llvm::SmallString<256> absPath(filePath);
+    _vfs->makeAbsolute(absPath);
+
+    // First check if the file is already loaded.
+    for (unsigned i = 0; i < _fileLocEntries.size(); ++i) {
+        if (_fileLocEntries[i]._fileName == absPath.str()) {
+            return glu::FileID(i);
+        }
+    }
+    llvm::ErrorOr<std::unique_ptr<llvm::vfs::File>> file
+        = _vfs->openFileForRead(filePath);
+    if (!file) {
+        return file.getError();
+    }
+
+    // Don't load it in a buffer
+
+    _fileLocEntries.emplace_back(
+        _nextOffset, nullptr, SourceLocation::invalid, absPath.str().str()
+    );
+
+    return llvm::ErrorOr<glu::FileID>(glu::FileID(_fileLocEntries.size() - 1));
+}
+
 llvm::MemoryBuffer *glu::SourceManager::getBuffer(FileID fileId) const
 {
     if (static_cast<size_t>(fileId._id) >= _fileLocEntries.size()) {
diff --git a/lib/IRDec/CMakeLists.txt b/lib/IRDec/CMakeLists.txt
@@ -7,8 +7,8 @@ target_include_directories(IRDec
 
 target_link_libraries(IRDec
     PUBLIC
-    GIL
-    GILGen
+    AST
+    LLVM
 )
 
 target_sources(IRDec
diff --git a/lib/IRDec/DITypeLifter.cpp b/lib/IRDec/DITypeLifter.cpp
@@ -1,4 +1,5 @@
 #include "DITypeLifter.hpp"
+
 #include <llvm/BinaryFormat/Dwarf.h>
 
 namespace glu::irdec {
diff --git a/lib/IRDec/ModuleLifter.cpp b/lib/IRDec/ModuleLifter.cpp
@@ -1,9 +1,9 @@
 #include "ModuleLifter.hpp"
 #include "AST/Exprs.hpp"
 #include "DITypeLifter.hpp"
-#include "GILGen/GILGen.hpp"
 #include "TypeLifter.hpp"
-#include "llvm/IR/Function.h"
+
+#include <llvm/IR/Function.h>
 
 namespace glu::irdec {
 
@@ -53,7 +53,10 @@ class ModuleLifter {
                 llvm::StringRef funcName = func.getName();
                 if (auto subprogram = func.getSubprogram()) {
                     type = diTypeLifter.lift(subprogram->getType());
-                    funcName = subprogram->getName();
+                    funcName = copyString(
+                        subprogram->getName(),
+                        _astContext.getASTMemoryArena().getAllocator()
+                    );
                 } else {
                     type = typeLifter.lift(func.getFunctionType());
                 }
@@ -63,11 +66,15 @@ class ModuleLifter {
                     continue;
                 llvm::SmallVector<ast::Attribute *, 4> attrs;
                 if (funcName != func.getName()) {
+                    auto linkageName = copyString(
+                        func.getName(),
+                        _astContext.getASTMemoryArena().getAllocator()
+                    );
                     auto *attr = astArena.create<ast::Attribute>(
                         ast::AttributeKind::LinkageNameKind,
                         SourceLocation::invalid,
                         astArena.create<ast::LiteralExpr>(
-                            func.getName(), nullptr, SourceLocation::invalid
+                            linkageName, nullptr, SourceLocation::invalid
                         )
                     );
                     attrs.push_back(attr);
diff --git a/lib/IRDec/TypeLifter.cpp b/lib/IRDec/TypeLifter.cpp
@@ -1,5 +1,6 @@
 #include "TypeLifter.hpp"
 #include "AST/Decls.hpp"
+
 #include <llvm/IR/DerivedTypes.h>
 
 namespace glu::irdec {
diff --git a/lib/Sema/CMakeLists.txt b/lib/Sema/CMakeLists.txt
@@ -12,6 +12,7 @@ target_link_libraries(Sema
         LLVM
         gluBasic
         Parser
+        IRDec
 )
 
 target_sources(Sema
diff --git a/lib/Sema/ImportManager.cpp b/lib/Sema/ImportManager.cpp
@@ -4,25 +4,39 @@
 #include "Lexer/Scanner.hpp"
 #include "Parser/Parser.hpp"
 
+#include "IRDec/ModuleLifter.hpp"
+
+#include <llvm/IR/LLVMContext.h>
+#include <llvm/IRReader/IRReader.h>
+
 namespace glu::sema {
 
 // Import Search Path Priority:
 // Example: import foo::bar::baz;
-// 1. ./foo/bar/baz.glu (no selector)
-// 2. ./foo/bar.glu (with selector baz)
-// 3. <import paths>/foo/bar/baz.glu
-// 4. <import paths>/foo/bar.glu (with selector baz)
-// 5. <system import paths>/foo/bar/baz.glu
-// 6. <system import paths>/foo/bar.glu (with selector baz)
-// Note that the system import paths are added to the import paths by the
-// compiler driver, so they are not explicitly handled here.
-// With wildcards, multiple files are not searched:
+// 1. ./foo/bar/baz.glu (no selector) (Glu source file)
+// 2. ./foo/bar/baz.bc (no selector) (decompiling LLVM bitcode)
+// 3. ./foo/bar/baz.ll (no selector) (human-readable LLVM IR)
+// 4. ./foo/bar.glu (with selector baz) (Glu source file)
+// 5. ./foo/bar.bc (with selector baz) (decompiling LLVM bitcode)
+// 6. ./foo/bar.ll (with selector baz) (human-readable LLVM IR)
+// 7. <import paths>/foo/bar/baz.glu (no selector) (Glu source file)
+// 8. <import paths>/foo/bar/baz.bc (no selector) (decompiling LLVM bitcode)
+// 9. <import paths>/foo/bar/baz.ll (no selector) (human-readable LLVM IR)
+// 10. <import paths>/foo/bar.glu (with selector baz) (Glu source file)
+// 11. <import paths>/foo/bar.bc (with selector baz) (decompiling LLVM bitcode)
+// 12. <import paths>/foo/bar.ll (with selector baz) (human-readable LLVM IR)
+// Note that the system import paths are added at the end of the import paths by
+// the compiler driver, so they are not explicitly handled here. With wildcards,
+// files are not wildcard-expanded, the wildcard is treated as a selector.
 // Example: import foo::bar::*;
 // 1. ./foo/bar.glu (with selector *)
 // 2. <import paths>/foo/bar.glu (with selector *)
 // 3. <system import paths>/foo/bar.glu (with selector *)
 // This may be changed in the future to support wildcard imports of multiple
-// files.
+// files. Decompiling bitcode or LLVM IR with wildcards is also supported with
+// wildcards, but not shown here for brevity.
+
+// MARK: - Import Resolution
 
 ImportManager::LocalImportResult ImportManager::findImport(
     SourceLocation importLoc, llvm::ArrayRef<llvm::StringRef> components,
@@ -99,13 +113,29 @@ bool ImportManager::trySelectPath(
     }
 
     // Try with .bc extension (binary LLVM bitcode).
-    // fullPath = path;
-    // fullPath.append(".bc");
+    fullPath = path;
+    fullPath.append(".bc");
+    if (auto fileOrErr = sm->loadIRFile(fullPath)) {
+        // Found
+        result = tryLoadingIRFile(importLoc, *fileOrErr, selector);
+        return true;
+    }
+
+    // Try with .ll extension (human-readable LLVM IR).
+    fullPath = path;
+    fullPath.append(".ll");
+    if (auto fileOrErr = sm->loadIRFile(fullPath)) {
+        // Found
+        result = tryLoadingIRFile(importLoc, *fileOrErr, selector);
+        return true;
+    }
 
     // No file found.
     return false;
 }
 
+// MARK: - Import File Loading
+
 ImportManager::LocalImportResult ImportManager::tryLoadingFile(
     SourceLocation importLoc, FileID fid, llvm::StringRef selector
 )
@@ -134,9 +164,27 @@ ImportManager::LocalImportResult ImportManager::tryLoadingFile(
     return std::tuple(_importedFiles[fid], selector);
 }
 
+ImportManager::LocalImportResult ImportManager::tryLoadingIRFile(
+    SourceLocation importLoc, FileID fid, llvm::StringRef selector
+)
+{
+    if (_failedImports.contains(fid)) {
+        // Previous import failed, do not try again. Do not generate new errors.
+        return std::nullopt;
+    }
+    if (!_importedFiles[fid]) {
+        // File has not been imported yet.
+        if (!loadModuleFromIRFile(importLoc, fid)) {
+            _failedImports.insert(fid);
+            return std::nullopt; // Import failed.
+        }
+    }
+    // File has already been imported.
+    return std::tuple(_importedFiles[fid], selector);
+}
+
 bool ImportManager::loadModuleFromFileID(FileID fid)
 {
-    _importStack.push_back(fid);
     auto *sm = _context.getSourceManager();
     glu::Scanner scanner(sm->getBuffer(fid));
     glu::Parser parser(scanner, _context, *sm, _diagManager);
@@ -147,12 +195,39 @@ bool ImportManager::loadModuleFromFileID(FileID fid)
     if (!ast) {
         return false;
     }
+    _importStack.push_back(fid);
     _importedFiles[fid] = sema::fastConstrainAST(ast, _diagManager, this);
     assert(_importStack.back() == fid);
     _importStack.pop_back();
     return _importedFiles[fid] != nullptr;
 }
 
+bool ImportManager::loadModuleFromIRFile(SourceLocation importLoc, FileID fid)
+{
+    llvm::SMDiagnostic err;
+    llvm::LLVMContext localContext;
+    auto *sm = _context.getSourceManager();
+    auto llvmModule
+        = llvm::parseIRFile(sm->getBufferName(fid), err, localContext);
+
+    if (!llvmModule) {
+        _diagManager.error(
+            importLoc, "Failed to parse LLVM module: " + err.getMessage()
+        );
+        return false;
+    }
+
+    auto *ast = glu::irdec::liftModule(_context, llvmModule.get());
+
+    _importStack.push_back(fid);
+    _importedFiles[fid] = sema::fastConstrainAST(ast, _diagManager, this);
+    assert(_importStack.back() == fid);
+    _importStack.pop_back();
+    return _importedFiles[fid] != nullptr;
+}
+
+// MARK: - Module Copying
+
 static llvm::StringRef isOperatorOverload(llvm::StringRef name)
 {
     return llvm::StringSwitch<bool>(name)
diff --git a/test/functional/IRDec/import-c.glu b/test/functional/IRDec/import-c.glu
@@ -0,0 +1,14 @@
+//
+// RUN: mkdir -p %t
+// RUN: clang -g -c -emit-llvm %S/simple.c -o %t/example.bc
+// RUN: gluc %s -I %t -o %t/import-c && %t/import-c | FileCheck -v %s
+//
+
+import example;
+
+@no_mangling @c_variadic func printf(s: *Char) -> Int;
+
+func main() {
+    // CHECK: Pizza count is 42, compiler is Clang
+    printf("Pizza count is %d, compiler is %s\n", example::getPizzaCount(), example::getCC());
+}
diff --git a/test/functional/IRDec/import-cpp.glu b/test/functional/IRDec/import-cpp.glu
@@ -0,0 +1,15 @@
+//
+// RUN: mkdir -p %t
+// RUN: clang++ -g -c -emit-llvm %S/simple.cpp -o %t/example.bc
+// RUN: gluc %s -I %t -o %t/import-cpp && %t/import-cpp | FileCheck -v %s
+//
+
+import example;
+
+@no_mangling @c_variadic func printf(s: *Char) -> Int;
+
+func main() {
+    // CHECK: Pizza count is 42, compiler is Clang++
+    let manager: example::PizzaManager = {};
+    printf("Pizza count is %d, compiler is %s\n", example::getPizzaCount(&manager), example::getCC());
+}
diff --git a/test/functional/IRDec/import-struct-cpp.glu b/test/functional/IRDec/import-struct-cpp.glu
@@ -0,0 +1,24 @@
+//
+// RUN: mkdir -p %t
+// RUN: clang++ -std=c++20 -g -c -emit-llvm %S/struct.cpp -o %t/person.bc
+// RUN: GLU_LINKER=clang++ gluc %s -I %t -o %t/import-cpp && %t/import-cpp | FileCheck -v %s
+//
+
+import person;
+
+@no_mangling @c_variadic func printf(s: *Char) -> Int;
+
+func main() {
+    let emil = person::getEmil();
+    // CHECK: Person name is Emil, born in 2003
+    printf("Person name is %s, born in %u\n", emil.name, emil.birthYear);
+    // CHECK: Emil's age in 2025 is 22
+    printf("Emil's age in 2025 is %u\n", person::getAgeInYear(&emil, 2025));
+    // CHECK: Emil's current age is {{.*}}
+    printf("Emil's current age is %u\n", person::getCurrentAge(&emil));
+    let marouan: person::Person = { "Marouan", 2000 };
+    // CHECK: Marouan's age in 2025 is 25
+    printf("Marouan's age in 2025 is %u\n", person::getAgeInYear(&marouan, 2025));
+    // CHECK: Marouan's current age is {{.*}}
+    printf("Marouan's current age is %u\n", person::getCurrentAge(&marouan));
+}
diff --git a/test/functional/IRDec/simple.cpp b/test/functional/IRDec/simple.cpp
@@ -16,3 +16,9 @@ size_t PizzaManager::getPizzaCount() const
 {
     return 42;
 }
+
+// CHECK: @linkage_name("{{.*}}") public func getCC() -> *Char;
+char const *getCC()
+{
+    return "Clang++";
+}
diff --git a/test/functional/IRDec/struct.cpp b/test/functional/IRDec/struct.cpp
diff --git a/tools/gluc/sources/CompilerDriver.cpp b/tools/gluc/sources/CompilerDriver.cpp

Original file line number	Diff line number	Diff line change
`@@ -7,8 +7,8 @@ target_include_directories(IRDec`
`7`	`7`
`8`	`8`	`target_link_libraries(IRDec`
`9`	`9`	`PUBLIC`
`10`		`- GIL`
`11`		`- GILGen`
	`10`	`+ AST`
	`11`	`+ LLVM`
`12`	`12`	`)`
`13`	`13`
`14`	`14`	`target_sources(IRDec`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`#include "DITypeLifter.hpp"`
	`2`	`+`
`2`	`3`	`#include <llvm/BinaryFormat/Dwarf.h>`
`3`	`4`
`4`	`5`	`namespace glu::irdec {`
Original file line number	Diff line number	Diff line change
`@@ -12,6 +12,7 @@ target_link_libraries(Sema`
`12`	`12`	`LLVM`
`13`	`13`	`gluBasic`
`14`	`14`	`Parser`
	`15`	`+ IRDec`
`15`	`16`	`)`
`16`	`17`
`17`	`18`	`target_sources(Sema`