Back to index

plt-scheme  4.2.1
Defines | Functions
ffi.c File Reference
#include <ffi.h>
#include <ffi_common.h>

Go to the source code of this file.

Defines

#define STACK_ARG_SIZE(x)   ALIGN(x, FFI_SIZEOF_ARG)

Functions

static ffi_status initialize_aggregate_packed_struct (ffi_type *arg)
int ffi_prep_args (char *stack, extended_cif *ecif)
ffi_status ffi_prep_cif (ffi_cif *cif, ffi_abi abi, unsigned int nargs, ffi_type *rtype, ffi_type **atypes)
ffi_status ffi_prep_cif_machdep (ffi_cif *cif)
void ffi_call_SYSV (int(*)(char *, extended_cif *), extended_cif *, unsigned, unsigned, unsigned *, void(*fn)()) __attribute__((__visibility__("hidden")))
void ffi_call (ffi_cif *cif, void(*fn)(), void *rvalue, void **avalue)
const char
ffi_cris_trampoline_template[] 
__attribute__ ((__visibility__("hidden")))
static unsigned long long ffi_prep_closure_inner (void **params, ffi_closure *closure)
ffi_status ffi_prep_closure_loc (ffi_closure *closure, ffi_cif *cif, void(*fun)(ffi_cif *, void *, void **, void *), void *user_data, void *codeloc)

Define Documentation

#define STACK_ARG_SIZE (   x)    ALIGN(x, FFI_SIZEOF_ARG)

Definition at line 32 of file ffi.c.


Function Documentation

const char ffi_cris_trampoline_template [] __attribute__ ( (__visibility__("hidden"))  )
void ffi_call ( ffi_cif *  cif,
void(*)()  fn,
void rvalue,
void **  avalue 
)

Definition at line 243 of file ffi.c.

{
  extended_cif ecif;

  ecif.cif = cif;
  ecif.avalue = avalue;

  if ((rvalue == NULL) && (cif->rtype->type == FFI_TYPE_STRUCT))
    {
      ecif.rvalue = alloca (cif->rtype->size);
    }
  else
    ecif.rvalue = rvalue;

  switch (cif->abi)
    {
    case FFI_SYSV:
      ffi_call_SYSV (ffi_prep_args, &ecif, cif->bytes,
                   cif->flags, ecif.rvalue, fn);
      break;
    default:
      FFI_ASSERT (0);
      break;
    }
}

Here is the call graph for this function:

void ffi_call_SYSV ( int(*)(char *, extended_cif *)  ,
extended_cif ,
unsigned  ,
unsigned  ,
unsigned *  ,
void(*)()  fn 
)
int ffi_prep_args ( char *  stack,
extended_cif ecif 
)

Definition at line 70 of file ffi.c.

{
  unsigned int i;
  unsigned int struct_count = 0;
  void **p_argv;
  char *argp;
  ffi_type **p_arg;

  argp = stack;

  p_argv = ecif->avalue;

  for (i = ecif->cif->nargs, p_arg = ecif->cif->arg_types;
       (i != 0); i--, p_arg++)
    {
      size_t z;

      switch ((*p_arg)->type)
       {
       case FFI_TYPE_STRUCT:
         {
           z = (*p_arg)->size;
           if (z <= 4)
             {
              memcpy (argp, *p_argv, z);
              z = 4;
             }
           else if (z <= 8)
             {
              memcpy (argp, *p_argv, z);
              z = 8;
             }
           else
             {
              unsigned int uiLocOnStack;
              z = sizeof (void *);
              uiLocOnStack = 4 * ecif->cif->nargs + struct_count;
              struct_count = struct_count + (*p_arg)->size;
              *(unsigned int *) argp =
                (unsigned int) (UINT32 *) (stack + uiLocOnStack);
              memcpy ((stack + uiLocOnStack), *p_argv, (*p_arg)->size);
             }
           break;
         }
       default:
         z = (*p_arg)->size;
         if (z < sizeof (int))
           {
             switch ((*p_arg)->type)
              {
              case FFI_TYPE_SINT8:
                *(signed int *) argp = (signed int) *(SINT8 *) (*p_argv);
                break;

              case FFI_TYPE_UINT8:
                *(unsigned int *) argp =
                  (unsigned int) *(UINT8 *) (*p_argv);
                break;

              case FFI_TYPE_SINT16:
                *(signed int *) argp = (signed int) *(SINT16 *) (*p_argv);
                break;

              case FFI_TYPE_UINT16:
                *(unsigned int *) argp =
                  (unsigned int) *(UINT16 *) (*p_argv);
                break;

              default:
                FFI_ASSERT (0);
              }
             z = sizeof (int);
           }
         else if (z == sizeof (int))
           *(unsigned int *) argp = (unsigned int) *(UINT32 *) (*p_argv);
         else
           memcpy (argp, *p_argv, z);
         break;
       }
      p_argv++;
      argp += z;
    }

  return (struct_count);
}
ffi_status ffi_prep_cif ( ffi_cif *  cif,
ffi_abi  abi,
unsigned int  nargs,
ffi_type *  rtype,
ffi_type **  atypes 
)

Definition at line 157 of file ffi.c.

{
  unsigned bytes = 0;
  unsigned int i;
  ffi_type **ptr;

  FFI_ASSERT (cif != NULL);
  FFI_ASSERT ((abi > FFI_FIRST_ABI) && (abi <= FFI_DEFAULT_ABI));

  cif->abi = abi;
  cif->arg_types = atypes;
  cif->nargs = nargs;
  cif->rtype = rtype;

  cif->flags = 0;

  if ((cif->rtype->size == 0)
      && (initialize_aggregate_packed_struct (cif->rtype) != FFI_OK))
    return FFI_BAD_TYPEDEF;

  FFI_ASSERT_VALID_TYPE (cif->rtype);

  for (ptr = cif->arg_types, i = cif->nargs; i > 0; i--, ptr++)
    {
      if (((*ptr)->size == 0)
         && (initialize_aggregate_packed_struct ((*ptr)) != FFI_OK))
       return FFI_BAD_TYPEDEF;

      FFI_ASSERT_VALID_TYPE (*ptr);

      if (((*ptr)->alignment - 1) & bytes)
       bytes = ALIGN (bytes, (*ptr)->alignment);
      if ((*ptr)->type == FFI_TYPE_STRUCT)
       {
         if ((*ptr)->size > 8)
           {
             bytes += (*ptr)->size;
             bytes += sizeof (void *);
           }
         else
           {
             if ((*ptr)->size > 4)
              bytes += 8;
             else
              bytes += 4;
           }
       }
      else
       bytes += STACK_ARG_SIZE ((*ptr)->size);
    }

  cif->bytes = bytes;

  return ffi_prep_cif_machdep (cif);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ffi_status ffi_prep_cif_machdep ( ffi_cif *  cif)

Definition at line 216 of file ffi.c.

{
  switch (cif->rtype->type)
    {
    case FFI_TYPE_VOID:
    case FFI_TYPE_STRUCT:
    case FFI_TYPE_FLOAT:
    case FFI_TYPE_DOUBLE:
    case FFI_TYPE_SINT64:
    case FFI_TYPE_UINT64:
      cif->flags = (unsigned) cif->rtype->type;
      break;

    default:
      cif->flags = FFI_TYPE_INT;
      break;
    }

  return FFI_OK;
}
static unsigned long long ffi_prep_closure_inner ( void **  params,
ffi_closure *  closure 
) [static]

Definition at line 294 of file ffi.c.

{
  char *register_args = (char *) params;
  void *struct_ret = params[5];
  char *stack_args = params[6];
  char *ptr = register_args;
  ffi_cif *cif = closure->cif;
  ffi_type **arg_types = cif->arg_types;

  /* Max room needed is number of arguments as 64-bit values.  */
  void **avalue = alloca (closure->cif->nargs * sizeof(void *));
  int i;
  int doing_regs;
  long long llret = 0;

  /* Find the address of each argument.  */
  for (i = 0, doing_regs = 1; i < cif->nargs; i++)
    {
      /* Types up to and including 8 bytes go by-value.  */
      if (arg_types[i]->size <= 4)
       {
         avalue[i] = ptr;
         ptr += 4;
       }
      else if (arg_types[i]->size <= 8)
       {
         avalue[i] = ptr;
         ptr += 8;
       }
      else
       {
         FFI_ASSERT (arg_types[i]->type == FFI_TYPE_STRUCT);

         /* Passed by-reference, so copy the pointer.  */
         avalue[i] = *(void **) ptr;
         ptr += 4;
       }

      /* If we've handled more arguments than fit in registers, start
        looking at the those passed on the stack.  Step over the
        first one if we had a straddling parameter.  */
      if (doing_regs && ptr >= register_args + 4*4)
       {
         ptr = stack_args + ((ptr > register_args + 4*4) ? 4 : 0);
         doing_regs = 0;
       }
    }

  /* Invoke the closure.  */
  (closure->fun) (cif,

                cif->rtype->type == FFI_TYPE_STRUCT
                /* The caller allocated space for the return
                   structure, and passed a pointer to this space in
                   R9.  */
                ? struct_ret

                /* We take advantage of being able to ignore that
                   the high part isn't set if the return value is
                   not in R10:R11, but in R10 only.  */
                : (void *) &llret,

                avalue, closure->user_data);

  return llret;
}

Here is the caller graph for this function:

ffi_status ffi_prep_closure_loc ( ffi_closure *  closure,
ffi_cif *  cif,
void(*)(ffi_cif *, void *, void **, void *)  fun,
void user_data,
void codeloc 
)

Definition at line 364 of file ffi.c.

{
  void *innerfn = ffi_prep_closure_inner;
  FFI_ASSERT (cif->abi == FFI_SYSV);
  closure->cif  = cif;
  closure->user_data = user_data;
  closure->fun  = fun;
  memcpy (closure->tramp, ffi_cris_trampoline_template,
         FFI_CRIS_TRAMPOLINE_CODE_PART_SIZE);
  memcpy (closure->tramp + ffi_cris_trampoline_fn_offset,
         &innerfn, sizeof (void *));
  memcpy (closure->tramp + ffi_cris_trampoline_closure_offset,
         &codeloc, sizeof (void *));

  return FFI_OK;
}

Here is the call graph for this function:

static ffi_status initialize_aggregate_packed_struct ( ffi_type *  arg) [static]

Definition at line 35 of file ffi.c.

{
  ffi_type **ptr;

  FFI_ASSERT (arg != NULL);

  FFI_ASSERT (arg->elements != NULL);
  FFI_ASSERT (arg->size == 0);
  FFI_ASSERT (arg->alignment == 0);

  ptr = &(arg->elements[0]);

  while ((*ptr) != NULL)
    {
      if (((*ptr)->size == 0)
         && (initialize_aggregate_packed_struct ((*ptr)) != FFI_OK))
       return FFI_BAD_TYPEDEF;

      FFI_ASSERT (ffi_type_test ((*ptr)));

      arg->size += (*ptr)->size;

      arg->alignment = (arg->alignment > (*ptr)->alignment) ?
       arg->alignment : (*ptr)->alignment;

      ptr++;
    }

  if (arg->size == 0)
    return FFI_BAD_TYPEDEF;
  else
    return FFI_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function: