我可以将现有方法绑定到 LLVM Function* 并从 JIT 编译的代码中使用它吗？

Question

我正在研究 LLVM C++ API。我想 JIT 编译代码并运行它。

但是，我需要从所述 JIT 编译的代码中调用 C++ 方法。通常，LLVM 将方法调用视为函数调用，并将对象指针作为第一个参数传递，因此调用应该不成问题。真正的问题是将该函数放入 LLVM 中。

据我所知，可以使用函数的外部链接并通过其名称获取它。问题是，由于它是一个 C++ 方法，它的名称将会被破坏，所以我认为这样做不是一个好主意。

制作 FunctionType 对象非常简单。但从那里，我如何通知 LLVM 我的方法并为其获取一个 Function 对象？

Answer 1

LLVM 邮件列表中的家伙足够有帮助，可以提供更好的解决方案。他们没有说如何获取从方法到函数的指针，但我已经弄清楚了这部分，所以没关系。

编辑 一种干净的方法是将您的方法包装到一个函数中：

int Foo_Bar(Foo* foo)
{
    return foo->bar();
}

然后使用 Foo_Bar 的地址而不是尝试获取 Foo::bar< /代码> 的。使用 llvm::ExecutionEngine::addGlobalMapping 添加映射，如下所示。

像往常一样，最简单的解决方案有一些有趣的好处。例如，它可以毫无问题地使用虚拟函数。 （但它的娱乐性要低得多。答案的其余部分保留用于历史目的，主要是因为我在研究 C++ 运行时的内部时获得了很多乐趣。另请注意，它是不可移植的。）

---

您需要一些东西沿着这些线来计算方法的地址（请注意，这是一个肮脏的黑客，可能只与 Itanium ABI 兼容）：

template<typename T>
const void* void_cast(const T& object)
{
    union Retyper
    {
        const T object;
        void* pointer;
        Retyper(T obj) : object(obj) { }
    };

    return Retyper(object).pointer;
}

template<typename T, typename M>
const void* getMethodPointer(const T* object, M method) // will work for virtual methods
{
    union MethodEntry
    {
        intptr_t offset;
        void* function;
    };

    const MethodEntry* entry = static_cast<const MethodEntry*>(void_cast(&method));

    if (entry->offset % sizeof(intptr_t) == 0) // looks like that's how the runtime guesses virtual from static
        return getMethodPointer(method);

    const void* const* const vtable = *reinterpret_cast<const void* const* const* const>(object);
    return vtable[(entry->offset - 1) / sizeof(void*)];
}

template<typename M>
const void* getMethodPointer(M method) // will only work with non-virtual methods
{
    union MethodEntry
    {
        intptr_t offset;
        void* function;
    };

    return static_cast<const MethodEntry*>(void_cast(&method))->function;
}

然后使用 llvm::ExecutionEngine::addGlobalMapping 来映射函数到您获得的地址。要调用它，请将您的对象作为第一个参数传递给它，其余部分照常进行。这是一个简单的例子。

class Foo
{
    void Bar();
    virtual void Baz();
};

class FooFoo : public Foo
{
    virtual void Baz();
};

Foo* foo = new FooFoo;

const void* barMethodPointer = getMethodPointer(&Foo::Bar);
const void* bazMethodPointer = getMethodPointer(foo, &Foo::Baz); // will get FooFoo::Baz

llvm::ExecutionEngine* engine = llvm::EngineBuilder(module).Create();

llvm::Function* bar = llvm::Function::Create(/* function type */, Function::ExternalLinkage, "foo", module);
llvm::Function* baz = llvm::Function::Create(/* function type */, Function::ExternalLinkage, "baz", module);
engine->addGlobalMapping(bar, const_cast<void*>(barMethodPointer)); // LLVM always takes non-const pointers
engine->addGlobalMapping(baz, const_cast<void*>(bazMethodPointer));

Answer 2

一种方法是对所需方法进行 C 包装，即

extern "C" {
  void wrapped_foo(bar *b, int arg1, int arg2) {
    b->foo(arg1, arg2);
  }
}

extern "C" 位使函数使用 C 调用约定并防止任何名称修改。请参阅http://www.parashift。 com/c++-faq-lite/mixing-c-and-cpp.html#faq-32.6 有关 C/C++ 互操作的详细信息，包括 extern "C"

您也应该能够获取 C++ 代码中函数的地址，然后将该地址存储在 LLVM 已知的全局中。

Answer 3

呵呵，使用非标准的 dladdr 和一种极其复杂且不安全的方法将方法指针转换为 void 指针，似乎有一种方法可以从方法的指针获取方法的名称。

这肯定比枪支更危险。不要在家里（或在工作中）这样做。

即使使用全能的 C 强制转换，C++ 也禁止将方法指针强制转换为 void*（这是 dladdr 工作所必需的），但您可以欺骗这一点。

#include <string>
#include <dlfcn.h>

template<typename T>
static void* voidify(T method)
{
    asm ("movq %rdi, %rax"); // should work on x86_64 ABI compliant platforms
}

template<typename T>
const char* getMethodName(T method)
{
    Dl_info info;
    if (dladdr(voidify(method), &info))
        return info.dli_sname;
    return "";
}

从那里：

int main()
{
    std::cout << getMethodName(&Foo::bar) << std::endl;
    // prints something like "_ZN3Foo3barEv"
}

...aaa并且您应该能够在 LLVM 中使用该符号名称。但它不适用于虚拟方法（不使用它的另一个很好的理由）。

编辑 深入研究虚拟方法指针的处理方式，我整理了一个更复杂的函数，也适用于它们。只有最勇敢的人才应该关注此链接。