Add support for importing symbols from static library

docs/source/user-guide/binding/execution-engine.rst

@@ -79,6 +79,13 @@ The ExecutionEngine class
             or a object file instance. Object file instance is not usable after this
             call.
 
+   * .. method:: add_archive(archive_file)
+
+        Add the symbols from the specified static archive file to the execution
+        engine. It is a fatal error in LLVM if the *archive_file* does not exist.
+
+        * *archive* str: a path to the static object file
+
    * .. method:: set_object_cache(notify_func=None, getbuffer_func=None)
 
         Set the object cache callbacks for this engine.

ffi/executionengine.cpp

@@ -10,7 +10,9 @@
 #include "llvm/Object/Binary.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/Memory.h"
-
+#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Object/Archive.h"
+#include "llvm/Support/Errc.h"
 #include <cstdio>
 #include <memory>
 
@@ -167,6 +169,40 @@ LLVMPY_MCJITAddObjectFile(LLVMExecutionEngineRef EE, LLVMObjectFileRef ObjF) {
         {std::move(binary_tuple.first), std::move(binary_tuple.second)});
 }
 
+API_EXPORT(int)
+LLVMPY_MCJITAddArchive(LLVMExecutionEngineRef EE, const char *ArchiveName,
+                       const char **OutError) {
+    using namespace llvm;
+    using namespace llvm::object;
+    auto engine = unwrap(EE);
+
+    ErrorOr<std::unique_ptr<MemoryBuffer>> ArBufOrErr = MemoryBuffer::getFile(ArchiveName);
+
+    std::error_code EC = ArBufOrErr.getError();
+    if (EC){
+        *OutError = LLVMPY_CreateString(EC.message().c_str());
+        return 1;
+    }
+
+    Expected<std::unique_ptr<object::Archive>> ArchiveOrError =
+        object::Archive::create(ArBufOrErr.get()->getMemBufferRef());
+
+    if (!ArchiveOrError) {
+        auto takeErr = ArchiveOrError.takeError();
+        std::string archiveErrStr = "Unable to load archive: " + std::string(ArchiveName);
+        *OutError = LLVMPY_CreateString(archiveErrStr.c_str());
+        return 1;
+    }
+
+    std::unique_ptr<MemoryBuffer> &ArBuf = ArBufOrErr.get();
+    std::unique_ptr<object::Archive> &Ar = ArchiveOrError.get();
+    object::OwningBinary<object::Archive> owningBinaryArchive(std::move(Ar),
+                                                              std::move(ArBuf));
+    engine->addArchive(std::move(owningBinaryArchive));
+    *OutError = LLVMPY_CreateString("");
+    return 0;
+}
+
 //
 // Object cache
 //

llvmlite/binding/executionengine.py

@@ -155,6 +155,18 @@ def add_object_file(self, obj_file):
 
         ffi.lib.LLVMPY_MCJITAddObjectFile(self, obj_file)
 
+    def add_archive(self, archive_file):
+        """
+        Add archive file to the jit. archive_file is a string
+        representing the file system path to the archive file.
+        """
+
+        with ffi.OutputString() as outerr:
+            res = ffi.lib.LLVMPY_MCJITAddArchive(self, archive_file.encode(),
+                                                 outerr)
+            if res:
+                raise RuntimeError(str(outerr))
+
     def set_object_cache(self, notify_func=None, getbuffer_func=None):
         """
         Set the object cache "notifyObjectCompiled" and "getBuffer"
@@ -286,6 +298,14 @@ def _dispose(self):
     ffi.LLVMObjectFileRef
 ]
 
+ffi.lib.LLVMPY_MCJITAddArchive.argtypes = [
+    ffi.LLVMExecutionEngineRef,
+    c_char_p,
+    POINTER(c_char_p)
+]
+
+ffi.lib.LLVMPY_MCJITAddArchive.restype = c_int
+
 
 class _ObjectCacheData(Structure):
     _fields_ = [

llvmlite/tests/a.c

@@ -0,0 +1,5 @@
+
+int __multiply_accumulate(int a, int b, int c)
+{
+  return (a * b) + c;
+}

llvmlite/tests/b.c

@@ -0,0 +1,4 @@
+int __multiply_subtract(int a, int b, int c)
+{
+  return (a * b) - c;
+}

llvmlite/tests/test_binding.py

@@ -16,6 +16,8 @@
 from llvmlite import binding as llvm
 from llvmlite.binding import ffi
 from llvmlite.tests import TestCase
+import llvmlite.tests
+from distutils.ccompiler import new_compiler
 
 
 # arvm7l needs extra ABI symbols to link successfully
@@ -1935,6 +1937,54 @@ def test_get_section_content(self):
                 self.assertEqual(s.data().hex(), issue_632_text)
 
 
+class TestArchiveFile(BaseTest):
+    mod_archive_asm = """
+        ;ModuleID = <string>
+        target triple = "{triple}"
+
+        declare i32 @__multiply_accumulate(i32 %0, i32 %1, i32 %2)
+        declare i32 @__multiply_subtract(i32 %0, i32 %1, i32 %2)
+    """
+
+    @unittest.skipUnless(sys.platform.startswith('linux'),
+                         "Linux-specific test")
+    def test_add_archive(self):
+        target_machine = self.target_machine(jit=False)
+
+        jit = llvm.create_mcjit_compiler(self.module(self.mod_archive_asm),
+                                         target_machine)
+
+        # Create compiler with default options
+        c = new_compiler()
+        workdir = os.path.dirname(llvmlite.tests.__file__) + "/"
+
+        # Compile into .o files
+        file1 = workdir + "a.c"
+        file2 = workdir + "b.c"
+
+        objects = c.compile([file1, file2])
+        library_name = "foo"
+        # Create static or shared library
+
+        c.create_static_lib(objects, library_name, output_dir=workdir)
+
+        static_library_name = workdir + "lib" + library_name + ".a"
+        jit.add_archive(static_library_name)
+
+        mac_func = CFUNCTYPE(c_int, c_int, c_int, c_int)(
+            jit.get_function_address("__multiply_accumulate"))
+
+        msub_func = CFUNCTYPE(c_int, c_int, c_int, c_int)(
+            jit.get_function_address("__multiply_subtract"))
+
+        self.assertEqual(mac_func(10, 10, 20), 120)
+        self.assertEqual(msub_func(10, 10, 20), 80)
+
+        os.unlink(objects[0])
+        os.unlink(objects[1])
+        os.unlink(static_library_name)
+
+
 class TestTimePasses(BaseTest):
     def test_reporting(self):
         mp = llvm.create_module_pass_manager()