Могу ли я связать существующий метод с LLVM Function * и использовать его из JIT-скомпилированного кода? - PullRequest
Новая
       4

Могу ли я связать существующий метод с LLVM Function * и использовать его из JIT-скомпилированного кода?

19 голосов
/ 23 июня 2010

Я играю с LLVM C ++ API. Я хотел бы JIT скомпилировать код и запустить его.

Однако мне нужно вызвать метод C ++ из указанного JIT-скомпилированного кода. Обычно LLVM обрабатывает вызовы методов как вызовы функций с указателем объекта, переданным в качестве первого аргумента, поэтому вызов не должен быть проблемой. Настоящая проблема состоит в том, чтобы поместить эту функцию в LLVM.

Насколько я вижу, можно использовать внешнюю связь для функций и получить ее по имени. Проблема в том, что, поскольку это метод C ++, его имя будет искажено, поэтому я не думаю, что это хорошая идея - идти таким путем.

Создание объекта FunctionType достаточно просто. Но откуда я могу сообщить LLVM о моем методе и получить для него объект Function?

Ответы [ 3 ]

15 голосов
/ 04 июля 2010

Парни из списка рассылки 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));
8 голосов
/ 23 июня 2010

Одним из способов является обертка 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.

4 голосов
/ 23 июня 2010

Да, используя нестандартный dladdr и невероятно извилистый и небезопасный способ приведения указателей метода к аннулирующим указателям, кажется, есть способ получить имя метода из его указателя.

Это, безусловно, более опасно, чем огнестрельное оружие. Не делайте этого дома (или на работе, если на то пошло).

C ++ запрещает приводить указатели методов к аннулированию * (что требуется dladdr для работы) даже со всемогущим приведением C, но вы можете обмануть это. 

#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"
}

... ааа, и вы сможете использовать это имя символа с LLVM. Но он не будет работать с виртуальными методами (еще одна веская причина не использовать его).

РЕДАКТИРОВАТЬ Зная о том, как обрабатываются указатели виртуальных методов, гораздо глубже, я собрал более сложную функцию, которая работает и для них. Перейдите по этой ссылке .

Только самые смелые из вас
...