void JitInstanceMemberFunction::setClosures()
{
    if(isVirtual())
    {
        m_pSubroutine->setClosure(jit_function_to_closure((jit_function_t)m_jit_virtual_indirection_function.function));
        Class* pClass = getInstanceMemberFunction()->getOwnerClass();
        for(auto it = pClass->beginVirtualMemberFunctionTables(); it != pClass->endVirtualMemberFunctionTables(); ++it)
        {
            size_t uiOffset = (*it)->getOffset();
            auto it = m_ThisAdjustmentThunks.find(uiOffset);
            if(it == m_ThisAdjustmentThunks.end())
            {
                // No thunk needed, use directly the function as the vtable pointer
                getInstanceMemberFunction()->setVTableClosure(uiOffset, jit_function_to_vtable_pointer((jit_function_t)m_jit_function.function));
            }
            else 
            {
                // Thunk needed
                getInstanceMemberFunction()->setVTableClosure(uiOffset, jit_function_to_vtable_pointer((jit_function_t)it->second.function));
            }
        }
    }
    else
    {
        m_pSubroutine->setClosure(jit_function_to_closure((jit_function_t)m_jit_function.function));
    }
}
phantom::generic_member_func_ptr JitInstanceMemberFunction::getGenericMemberFunctionPointer() const
{
    generic_member_func_ptr ptr;
    if(isVirtual())
    {
        ptr.setClosurePointer(jit_function_to_closure((jit_function_t)m_jit_virtual_indirection_function.function));
    }
    else
    {
        ptr.setClosurePointer(jit_function_to_closure((jit_function_t)m_jit_function.function));
    }
    return ptr;
}
Esempio n. 3
0
block_func_t compile_function(jit_function_t func) {
	//jit_dump_function(stdout, func, "block");
	jit_function_compile(func);
	jit_context_build_end(context);
	//jit_dump_function(stdout, func, "block");
	return (block_func_t) jit_function_to_closure(func);
}
Esempio n. 4
0
bool LibJITFormula::buildFunction ()
{
	// Create a context
	jit_context_t context;
	context = jit_context_create ();
	jit_context_build_start (context);

	// Create a signature for double (*func)();
	jit_type_t signature;
	signature = jit_type_create_signature (jit_abi_cdecl, jit_type_float64,
	                                       NULL, 0, 1);

	// Create a function
	function = jit_function_create (context, signature);

	// Return the result of compiling the whole mess
	jit_value_t val;
	val = (jit_value_t)parseTree->generate (this);
	if (!val)
		return false;

	jit_insn_return (function, val);
	jit_context_build_end (context);

	if (!jit_function_compile (function))
	{
		jit_function_abandon (function);
		return false;
	}

	func = (FunctionPointer)jit_function_to_closure (function);
	if (!func)
	{
		jit_function_abandon (function);
		return false;
	}

	return true;
}