import sys
from rpython.rtyper.lltypesystem import lltype, llmemory, rffi
from rpython.rtyper.lltypesystem.lloperation import llop
from rpython.rlib import clibffi, jit
from rpython.rlib.rarithmetic import r_longlong, r_singlefloat
from rpython.rlib.unroll import unrolling_iterable

FFI_CIF = clibffi.FFI_CIFP.TO
FFI_TYPE = clibffi.FFI_TYPE_P.TO
FFI_TYPE_P = clibffi.FFI_TYPE_P
FFI_TYPE_PP = clibffi.FFI_TYPE_PP
FFI_ABI = clibffi.FFI_ABI
FFI_TYPE_STRUCT = clibffi.FFI_TYPE_STRUCT
SIZE_OF_FFI_ARG = rffi.sizeof(clibffi.ffi_arg)
SIZE_OF_SIGNED = rffi.sizeof(lltype.Signed)
FFI_ARG_P = rffi.CArrayPtr(clibffi.ffi_arg)

# Usage: for each C function, make one CIF_DESCRIPTION block of raw
# memory.  Initialize it by filling all its fields apart from 'cif'.
# The 'atypes' points to an array of ffi_type pointers; a reasonable
# place to locate this array's memory is in the same block of raw
# memory, by allocating more than sizeof(CIF_DESCRIPTION).
#
# The four fields 'abi', 'nargs', 'rtype', 'atypes' are the same as
# the arguments to ffi_prep_cif().
#
# Following this, we find jit_libffi-specific information:
#
#  - 'exchange_size': an integer that tells how big a buffer we must
#    allocate to do the call; this buffer should have enough room at the
#    beginning for an array of NARGS pointers which is initialized
#    internally by jit_ffi_call().
#
#  - 'exchange_result': the offset in that buffer for the result of the call.
#    (this and the other offsets must be at least NARGS * sizeof(void*).)
#
#  - 'exchange_args[nargs]': the offset in that buffer for each argument.
#
# Each argument and the result should have enough room for at least
# SIZE_OF_FFI_ARG bytes, even if they may be smaller.  (Unlike ffi_call,
# we don't have any special rule about results that are integers smaller
# than SIZE_OF_FFI_ARG).

CIF_DESCRIPTION = lltype.Struct(
    'CIF_DESCRIPTION',
    ('cif', FFI_CIF),
    ('abi', lltype.Signed),    # these 4 fields could also be read directly
    ('nargs', lltype.Signed),  # from 'cif', but doing so adds a dependency
    ('rtype', FFI_TYPE_P),     # on the exact fields available from ffi_cif.
    ('atypes', FFI_TYPE_PP),   #
    ('exchange_size', lltype.Signed),
    ('exchange_result', lltype.Signed),
    ('exchange_args', lltype.Array(lltype.Signed,
                          hints={'nolength': True, 'immutable': True})),
    hints={'immutable': True})

CIF_DESCRIPTION_P = lltype.Ptr(CIF_DESCRIPTION)


def jit_ffi_prep_cif(cif_description):
    """Minimal wrapper around ffi_prep_cif().  Call this after
    cif_description is initialized, in order to fill the last field: 'cif'.
    """
    res = clibffi.c_ffi_prep_cif(cif_description.cif,
                                 cif_description.abi,
                                 cif_description.nargs,
                                 cif_description.rtype,
                                 cif_description.atypes)
    return rffi.cast(lltype.Signed, res)


# =============================
# jit_ffi_call and its helpers
# =============================

## Problem: jit_ffi_call is turned into call_release_gil by pyjitpl. Before
## the refactor-call_release_gil branch, the resulting code looked like this:
##
##     buffer = ...
##     i0 = call_release_gil(...)
##     guard_not_forced()
##     setarray_item_raw(buffer, ..., i0)
##
## The problem is that the result box i0 was generated freshly inside pyjitpl,
## and the codewriter did not know about its liveness: the result was that i0
## was not in the fail_args of guard_not_forced. See
## test_fficall::test_guard_not_forced_fails for a more detalied explanation
## of the problem.
##
## The solution is to create a new separate operation libffi_call.
## The result is that now the jitcode looks like this:
##
##     %i0 = direct_call(libffi_call, ...)
##     -live-
##     raw_store(exchange_result, %i0)
##
## the "-live-" is the key, because it make sure that the value is not lost if
## guard_not_forced fails.
##
## The value of %i0 is stored back in the exchange_buffer at the offset
## exchange_result, which is usually where functions like jit_ffi_call_impl_int
## have just read it from when called *in interpreter mode* only.


def jit_ffi_call(cif_description, func_addr, exchange_buffer):
    """Wrapper around ffi_call().  Must receive a CIF_DESCRIPTION_P that
    describes the layout of the 'exchange_buffer'.

    Note that this cannot be optimized if 'cif_description' is not
    a constant for the JIT, so if it is ever possible, consider promoting
    it.  The promotion of 'cif_description' must be done earlier, before
    the raw malloc of 'exchange_buffer'.
    """
    reskind = types.getkind(cif_description.rtype)
    if reskind == 'v':
        jit_ffi_call_impl_void(cif_description, func_addr, exchange_buffer)
    elif reskind == 'i':
        _do_ffi_call_sint(cif_description, func_addr, exchange_buffer)
    elif reskind == 'u':
        _do_ffi_call_uint(cif_description, func_addr, exchange_buffer)
    elif reskind == 'f':
        _do_ffi_call_float(cif_description, func_addr, exchange_buffer)
    elif reskind == 'L': # L is for longlongs, on 32bit
        _do_ffi_call_longlong(cif_description, func_addr, exchange_buffer)
    elif reskind == 'S': # SingleFloat
        _do_ffi_call_singlefloat(cif_description, func_addr, exchange_buffer)
    else:
        # the result kind is not supported: we disable the jit_ffi_call
        # optimization by calling directly jit_ffi_call_impl_any, so the JIT
        # does not see any libffi_call oopspec.
        #
        # Since call_release_gil is not generated, there is no need to
        # jit_ffi_save_result
        jit_ffi_call_impl_any(cif_description, func_addr, exchange_buffer)


_short_sint_types = unrolling_iterable([rffi.SIGNEDCHAR, rffi.SHORT, rffi.INT])
_short_uint_types = unrolling_iterable([rffi.UCHAR, rffi.USHORT, rffi.UINT])

def _do_ffi_call_sint(cif_description, func_addr, exchange_buffer):
    result = jit_ffi_call_impl_int(cif_description, func_addr,
                                   exchange_buffer)
    size = types.getsize(cif_description.rtype)
    for TP in _short_sint_types:     # short **signed** types
        if size == rffi.sizeof(TP):
            llop.raw_store(lltype.Void,
                           llmemory.cast_ptr_to_adr(exchange_buffer),
                           cif_description.exchange_result,
                           rffi.cast(TP, result))
            break
    else:
        # default case: expect a full signed number
        llop.raw_store(lltype.Void,
                       llmemory.cast_ptr_to_adr(exchange_buffer),
                       cif_description.exchange_result,
                       result)

def _do_ffi_call_uint(cif_description, func_addr, exchange_buffer):
    result = jit_ffi_call_impl_int(cif_description, func_addr,
                                   exchange_buffer)
    size = types.getsize(cif_description.rtype)
    for TP in _short_uint_types:     # short **unsigned** types
        if size == rffi.sizeof(TP):
            llop.raw_store(lltype.Void,
                           llmemory.cast_ptr_to_adr(exchange_buffer),
                           cif_description.exchange_result,
                           rffi.cast(TP, result))
            break
    else:
        # default case: expect a full unsigned number
        llop.raw_store(lltype.Void,
                       llmemory.cast_ptr_to_adr(exchange_buffer),
                       cif_description.exchange_result,
                       rffi.cast(lltype.Unsigned, result))

def _do_ffi_call_float(cif_description, func_addr, exchange_buffer):
    # a separate function in case the backend doesn't support floats
    result = jit_ffi_call_impl_float(cif_description, func_addr,
                                     exchange_buffer)
    llop.raw_store(lltype.Void,
                   llmemory.cast_ptr_to_adr(exchange_buffer),
                   cif_description.exchange_result,
                   result)

def _do_ffi_call_longlong(cif_description, func_addr, exchange_buffer):
    # a separate function in case the backend doesn't support longlongs
    result = jit_ffi_call_impl_longlong(cif_description, func_addr,
                                        exchange_buffer)
    llop.raw_store(lltype.Void,
                   llmemory.cast_ptr_to_adr(exchange_buffer),
                   cif_description.exchange_result,
                   result)

def _do_ffi_call_singlefloat(cif_description, func_addr, exchange_buffer):
    # a separate function in case the backend doesn't support singlefloats
    result = jit_ffi_call_impl_singlefloat(cif_description, func_addr,
                                           exchange_buffer)
    llop.raw_store(lltype.Void,
                   llmemory.cast_ptr_to_adr(exchange_buffer),
                   cif_description.exchange_result,
                   result)


@jit.oopspec("libffi_call(cif_description,func_addr,exchange_buffer)")
def jit_ffi_call_impl_int(cif_description, func_addr, exchange_buffer):
    jit_ffi_call_impl_any(cif_description, func_addr, exchange_buffer)
    # read a complete 'ffi_arg' word
    resultdata = rffi.ptradd(exchange_buffer, cif_description.exchange_result)
    return rffi.cast(lltype.Signed, rffi.cast(FFI_ARG_P, resultdata)[0])

@jit.oopspec("libffi_call(cif_description,func_addr,exchange_buffer)")
def jit_ffi_call_impl_float(cif_description, func_addr, exchange_buffer):
    jit_ffi_call_impl_any(cif_description, func_addr, exchange_buffer)
    resultdata = rffi.ptradd(exchange_buffer, cif_description.exchange_result)
    return rffi.cast(rffi.DOUBLEP, resultdata)[0]

@jit.oopspec("libffi_call(cif_description,func_addr,exchange_buffer)")
def jit_ffi_call_impl_longlong(cif_description, func_addr, exchange_buffer):
    jit_ffi_call_impl_any(cif_description, func_addr, exchange_buffer)
    resultdata = rffi.ptradd(exchange_buffer, cif_description.exchange_result)
    return rffi.cast(rffi.LONGLONGP, resultdata)[0]

@jit.oopspec("libffi_call(cif_description,func_addr,exchange_buffer)")
def jit_ffi_call_impl_singlefloat(cif_description, func_addr, exchange_buffer):
    jit_ffi_call_impl_any(cif_description, func_addr, exchange_buffer)
    resultdata = rffi.ptradd(exchange_buffer, cif_description.exchange_result)
    return rffi.cast(rffi.FLOATP, resultdata)[0]

@jit.oopspec("libffi_call(cif_description,func_addr,exchange_buffer)")
def jit_ffi_call_impl_void(cif_description, func_addr, exchange_buffer):
    jit_ffi_call_impl_any(cif_description, func_addr, exchange_buffer)
    return None

def jit_ffi_call_impl_any(cif_description, func_addr, exchange_buffer):
    """
    This is the function which actually calls libffi. All the rest is just
    infrastructure to convince the JIT to pass a typed result box to
    jit_ffi_save_result
    """
    buffer_array = rffi.cast(rffi.VOIDPP, exchange_buffer)
    for i in range(cif_description.nargs):
        data = rffi.ptradd(exchange_buffer, cif_description.exchange_args[i])
        buffer_array[i] = data
    resultdata = rffi.ptradd(exchange_buffer,
                             cif_description.exchange_result)
    clibffi.c_ffi_call(cif_description.cif, func_addr,
                       rffi.cast(rffi.VOIDP, resultdata),
                       buffer_array)


# ____________________________________________________________

class types(object):
    """
    This namespace contains the mapping the JIT needs from ffi types to
    a less strict "kind" character.
    """

    @classmethod
    def _import(cls):
        prefix = 'ffi_type_'
        for key, value in clibffi.__dict__.iteritems():
            if key.startswith(prefix):
                name = key[len(prefix):]
                setattr(cls, name, value)
        cls.slong = clibffi.cast_type_to_ffitype(rffi.LONG)
        cls.ulong = clibffi.cast_type_to_ffitype(rffi.ULONG)
        cls.slonglong = clibffi.cast_type_to_ffitype(rffi.LONGLONG)
        cls.ulonglong = clibffi.cast_type_to_ffitype(rffi.ULONGLONG)
        cls.signed = clibffi.cast_type_to_ffitype(rffi.SIGNED)
        cls.wchar_t = clibffi.cast_type_to_ffitype(lltype.UniChar)
        del cls._import

    @staticmethod
    @jit.elidable
    def getkind(ffi_type):
        """Returns 'v' for void, 'f' for float, 'i' for signed integer,
        'u' for unsigned integer, 'S' for singlefloat, 'L' for long long
        integer (signed or unsigned), '*' for struct, or '?' for others
        (e.g. long double).
        """
        if   ffi_type == types.void:    return 'v'
        elif ffi_type == types.double:  return 'f'
        elif ffi_type == types.float:   return 'S'
        elif ffi_type == types.pointer: return 'u'
        #
        elif ffi_type == types.schar:   return 'i'
        elif ffi_type == types.uchar:   return 'u'
        elif ffi_type == types.sshort:  return 'i'
        elif ffi_type == types.ushort:  return 'u'
        elif ffi_type == types.sint:    return 'i'
        elif ffi_type == types.uint:    return 'u'
        elif ffi_type == types.slong:   return 'i'
        elif ffi_type == types.ulong:   return 'u'
        #
        elif ffi_type == types.sint8:   return 'i'
        elif ffi_type == types.uint8:   return 'u'
        elif ffi_type == types.sint16:  return 'i'
        elif ffi_type == types.uint16:  return 'u'
        elif ffi_type == types.sint32:  return 'i'
        elif ffi_type == types.uint32:  return 'u'
        ## (note that on 64-bit platforms, types.sint64 == types.slong and the
        ## case == caught above)
        elif ffi_type == types.sint64:  return 'L'
        elif ffi_type == types.uint64:  return 'L'
        #
        elif types.is_struct(ffi_type): return '*'
        return '?'

    @staticmethod
    @jit.elidable
    def getsize(ffi_type):
        return rffi.getintfield(ffi_type, 'c_size')

    @staticmethod
    @jit.elidable
    def is_struct(ffi_type):
        return rffi.getintfield(ffi_type, 'c_type') == FFI_TYPE_STRUCT

types._import()