自学教程：C++ FFI_ASSERT函数代码示例

ffi_statusffi_prep_cif_machdep(ffi_cif *cif){  size_t struct_size = 0;  int n_gpr = 0;  int n_fpr = 0;  int n_ov = 0;  ffi_type **ptr;  int i;  /* Determine return value handling.  */   switch (cif->rtype->type)    {      /* Void is easy.  */      case FFI_TYPE_VOID:	cif->flags = FFI390_RET_VOID;	break;      /* Structures are returned via a hidden pointer.  */      case FFI_TYPE_STRUCT:	cif->flags = FFI390_RET_STRUCT;	n_gpr++;  /* We need one GPR to pass the pointer.  */	break;       /* Floating point values are returned in fpr 0.  */      case FFI_TYPE_FLOAT:	cif->flags = FFI390_RET_FLOAT;	break;      case FFI_TYPE_DOUBLE:	cif->flags = FFI390_RET_DOUBLE;	break;#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE      case FFI_TYPE_LONGDOUBLE:	cif->flags = FFI390_RET_STRUCT;	n_gpr++;	break;#endif      /* Integer values are returned in gpr 2 (and gpr 3	 for 64-bit values on 31-bit machines).  */      case FFI_TYPE_UINT64:      case FFI_TYPE_SINT64:	cif->flags = FFI390_RET_INT64;	break;      case FFI_TYPE_POINTER:      case FFI_TYPE_INT:      case FFI_TYPE_UINT32:      case FFI_TYPE_SINT32:      case FFI_TYPE_UINT16:      case FFI_TYPE_SINT16:      case FFI_TYPE_UINT8:      case FFI_TYPE_SINT8:	/* These are to be extended to word size.  */#ifdef __s390x__	cif->flags = FFI390_RET_INT64;#else	cif->flags = FFI390_RET_INT32;#endif	break;       default:        FFI_ASSERT (0);        break;    }  /* Now for the arguments.  */   for (ptr = cif->arg_types, i = cif->nargs;       i > 0;       i--, ptr++)    {      int type = (*ptr)->type;#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE      /* 16-byte long double is passed like a struct.  */      if (type == FFI_TYPE_LONGDOUBLE)	type = FFI_TYPE_STRUCT;#endif      /* Check how a structure type is passed.  */      if (type == FFI_TYPE_STRUCT)	{	  type = ffi_check_struct_type (*ptr);	  /* If we pass the struct via pointer, we must reserve space	     to copy its data for proper call-by-value semantics.  */	  if (type == FFI_TYPE_POINTER)	    struct_size += ROUND_SIZE ((*ptr)->size);	}      /* Now handle all primitive int/float data types.  */      switch (type) 	{	  /* The first MAX_FPRARGS floating point arguments	     go in FPRs, the rest overflow to the stack.  *///.........这里部分代码省略.........

/* Classify the argument of type TYPE and mode MODE.   CLASSES will be filled by the register class used to pass each word   of the operand.  The number of words is returned.  In case the parameter   should be passed in memory, 0 is returned. As a special case for zero   sized containers, classes[0] will be NO_CLASS and 1 is returned.   See the x86-64 PS ABI for details.*/static intclassify_argument (ffi_type *type, enum x86_64_reg_class classes[],		   size_t byte_offset){  switch (type->type)    {    case FFI_TYPE_UINT8:    case FFI_TYPE_SINT8:    case FFI_TYPE_UINT16:    case FFI_TYPE_SINT16:    case FFI_TYPE_UINT32:    case FFI_TYPE_SINT32:    case FFI_TYPE_UINT64:    case FFI_TYPE_SINT64:    case FFI_TYPE_POINTER:      {	int size = byte_offset + type->size;	if (size <= 4)	  {	    classes[0] = X86_64_INTEGERSI_CLASS;	    return 1;	  }	else if (size <= 8)	  {	    classes[0] = X86_64_INTEGER_CLASS;	    return 1;	  }	else if (size <= 12)	  {	    classes[0] = X86_64_INTEGER_CLASS;	    classes[1] = X86_64_INTEGERSI_CLASS;	    return 2;	  }	else if (size <= 16)	  {	    classes[0] = classes[1] = X86_64_INTEGERSI_CLASS;	    return 2;	  }	else	  FFI_ASSERT (0);      }    case FFI_TYPE_FLOAT:      if (!(byte_offset % 8))	classes[0] = X86_64_SSESF_CLASS;      else	classes[0] = X86_64_SSE_CLASS;      return 1;    case FFI_TYPE_DOUBLE:      classes[0] = X86_64_SSEDF_CLASS;      return 1;    case FFI_TYPE_LONGDOUBLE:      classes[0] = X86_64_X87_CLASS;      classes[1] = X86_64_X87UP_CLASS;      return 2;    case FFI_TYPE_STRUCT:      {	const int UNITS_PER_WORD = 8;	int words = (type->size + UNITS_PER_WORD - 1) / UNITS_PER_WORD;	ffi_type **ptr; 	int i;	enum x86_64_reg_class subclasses[MAX_CLASSES];	/* If the struct is larger than 32 bytes, pass it on the stack.  */	if (type->size > 32)	  return 0;	for (i = 0; i < words; i++)	  classes[i] = X86_64_NO_CLASS;	/* Zero sized arrays or structures are NO_CLASS.  We return 0 to	   signalize memory class, so handle it as special case.  */	if (!words)	  {	    classes[0] = X86_64_NO_CLASS;	    return 1;	  }	/* Merge the fields of structure.  */	for (ptr = type->elements; *ptr != NULL; ptr++)	  {	    int num;	    byte_offset = ALIGN (byte_offset, (*ptr)->alignment);	    num = classify_argument (*ptr, subclasses, byte_offset % 8);	    if (num == 0)	      return 0;	    for (i = 0; i < num; i++)	      {		int pos = byte_offset / 8;		classes[i + pos] =//.........这里部分代码省略.........

void ffi_prep_args(char *stack, extended_cif *ecif){  register unsigned int i;  register void **p_argv;  register char *argp;  register ffi_type **p_arg;  argp = stack;  if (ecif->cif->flags == FFI_TYPE_STRUCT#ifdef X86_WIN64      && (ecif->cif->rtype->size != 1 && ecif->cif->rtype->size != 2          && ecif->cif->rtype->size != 4 && ecif->cif->rtype->size != 8)#endif      )    {      *(void **) argp = ecif->rvalue;      argp += sizeof(void*);    }  p_argv = ecif->avalue;  for (i = ecif->cif->nargs, p_arg = ecif->cif->arg_types;       i != 0;       i--, p_arg++)    {      size_t z;      /* Align if necessary */      if ((sizeof(void*) - 1) & (size_t) argp)        argp = (char *) ALIGN(argp, sizeof(void*));      z = (*p_arg)->size;#ifdef X86_WIN64      if (z > sizeof(ffi_arg)          || ((*p_arg)->type == FFI_TYPE_STRUCT              && (z != 1 && z != 2 && z != 4 && z != 8))#if FFI_TYPE_DOUBLE != FFI_TYPE_LONGDOUBLE          || ((*p_arg)->type == FFI_TYPE_LONGDOUBLE)#endif          )        {          z = sizeof(ffi_arg);          *(void **)argp = *p_argv;        }      else if ((*p_arg)->type == FFI_TYPE_FLOAT)        {          memcpy(argp, *p_argv, z);        }      else#endif      if (z < sizeof(ffi_arg))        {          z = sizeof(ffi_arg);          switch ((*p_arg)->type)            {            case FFI_TYPE_SINT8:              *(ffi_sarg *) argp = (ffi_sarg)*(SINT8 *)(* p_argv);              break;            case FFI_TYPE_UINT8:              *(ffi_arg *) argp = (ffi_arg)*(UINT8 *)(* p_argv);              break;            case FFI_TYPE_SINT16:              *(ffi_sarg *) argp = (ffi_sarg)*(SINT16 *)(* p_argv);              break;            case FFI_TYPE_UINT16:              *(ffi_arg *) argp = (ffi_arg)*(UINT16 *)(* p_argv);              break;            case FFI_TYPE_SINT32:              *(ffi_sarg *) argp = (ffi_sarg)*(SINT32 *)(* p_argv);              break;            case FFI_TYPE_UINT32:              *(ffi_arg *) argp = (ffi_arg)*(UINT32 *)(* p_argv);              break;            case FFI_TYPE_STRUCT:              *(ffi_arg *) argp = *(ffi_arg *)(* p_argv);              break;            default:              FFI_ASSERT(0);            }        }      else        {          memcpy(argp, *p_argv, z);        }      p_argv++;#ifdef X86_WIN64      argp += (z + sizeof(void*) - 1) & ~(sizeof(void*) - 1);#else      argp += z;#endif    }  //.........这里部分代码省略.........

static voidffi_call_int (ffi_cif *cif, void (*fn)(void), void *rvalue,	      void **avalue, void *closure){  int i, j, n, flags;  UINT64 *stack;  size_t rsize;  struct win64_call_frame *frame;  FFI_ASSERT(cif->abi == FFI_GNUW64 || cif->abi == FFI_WIN64);  flags = cif->flags;  rsize = 0;  /* If we have no return value for a structure, we need to create one.     Otherwise we can ignore the return type entirely.  */  if (rvalue == NULL)    {      if (flags == FFI_TYPE_STRUCT)	rsize = cif->rtype->size;      else	flags = FFI_TYPE_VOID;    }  stack = alloca(cif->bytes + sizeof(struct win64_call_frame) + rsize);  frame = (struct win64_call_frame *)((char *)stack + cif->bytes);  if (rsize)    rvalue = frame + 1;  frame->fn = (uintptr_t)fn;  frame->flags = flags;  frame->rvalue = (uintptr_t)rvalue;  j = 0;  if (flags == FFI_TYPE_STRUCT)    {      stack[0] = (uintptr_t)rvalue;      j = 1;    }  for (i = 0, n = cif->nargs; i < n; ++i, ++j)    {      switch (cif->arg_types[i]->size)	{	case 8:	  stack[j] = *(UINT64 *)avalue[i];	  break;	case 4:	  stack[j] = *(UINT32 *)avalue[i];	  break;	case 2:	  stack[j] = *(UINT16 *)avalue[i];	  break;	case 1:	  stack[j] = *(UINT8 *)avalue[i];	  break;	default:	  stack[j] = (uintptr_t)avalue[i];	  break;	}    }  ffi_call_win64 (stack, frame, closure);}

voidffi_raw_call(ffi_cif *cif, void (*fn)(void), void *rvalue, ffi_raw *fake_avalue){  extended_cif ecif;  void **avalue = (void **)fake_avalue;  ecif.cif = cif;  ecif.avalue = avalue;    /* If the return value is a struct and we don't have a return */  /* value address then we need to make one                     */  if (rvalue == NULL      && (cif->flags == FFI_TYPE_STRUCT          || cif->flags == FFI_TYPE_MS_STRUCT))    {      ecif.rvalue = alloca(cif->rtype->size);    }  else    ecif.rvalue = rvalue;        switch (cif->abi)     {#ifdef X86_WIN32    case FFI_SYSV:    case FFI_STDCALL:    case FFI_MS_CDECL:      ffi_call_win32(ffi_prep_args_raw, &ecif, cif->abi, cif->bytes, cif->flags,		     ecif.rvalue, fn);      break;    case FFI_THISCALL:    case FFI_FASTCALL:      {	unsigned int abi = cif->abi;	unsigned int i, passed_regs = 0;	if (cif->flags == FFI_TYPE_STRUCT)	  ++passed_regs;	for (i=0; i < cif->nargs && passed_regs < 2;i++)	  {	    size_t sz;	    if (cif->arg_types[i]->type == FFI_TYPE_FLOAT	        || cif->arg_types[i]->type == FFI_TYPE_STRUCT)	      continue;	    sz = (cif->arg_types[i]->size + 3) & ~3;	    if (sz == 0 || sz > 4)	      continue;	    ++passed_regs;	  }	if (passed_regs < 2 && abi == FFI_FASTCALL)	  cif->abi = abi = FFI_THISCALL;	if (passed_regs < 1 && abi == FFI_THISCALL)	  cif->abi = abi = FFI_STDCALL;        ffi_call_win32(ffi_prep_args_raw, &ecif, abi, cif->bytes, cif->flags,                       ecif.rvalue, fn);      }      break;#else    case FFI_SYSV:      ffi_call_SYSV(ffi_prep_args_raw, &ecif, cif->bytes, cif->flags,                    ecif.rvalue, fn);      break;#endif    default:      FFI_ASSERT(0);      break;    }}

void FFI_HIDDENffi_closure_SYSV_inner (ffi_closure *closure, struct call_context *context,			void *stack){  ffi_cif *cif = closure->cif;  void **avalue = (void**) alloca (cif->nargs * sizeof (void*));  void *rvalue = NULL;  int i;  struct arg_state state;  arg_init (&state, ALIGN(cif->bytes, 16));  for (i = 0; i < cif->nargs; i++)    {      ffi_type *ty = cif->arg_types[i];      switch (ty->type)	{	case FFI_TYPE_VOID:	  FFI_ASSERT (0);	  break;	case FFI_TYPE_UINT8:	case FFI_TYPE_SINT8:	case FFI_TYPE_UINT16:	case FFI_TYPE_SINT16:	case FFI_TYPE_UINT32:	case FFI_TYPE_SINT32:	case FFI_TYPE_INT:	case FFI_TYPE_POINTER:	case FFI_TYPE_UINT64:	case FFI_TYPE_SINT64:	case  FFI_TYPE_FLOAT:	case  FFI_TYPE_DOUBLE:#if FFI_TYPE_DOUBLE != FFI_TYPE_LONGDOUBLE	case  FFI_TYPE_LONGDOUBLE:	  avalue[i] = allocate_to_register_or_stack (context, stack,						     &state, ty->type);	  break;#endif	case FFI_TYPE_STRUCT:	  if (is_hfa (ty))	    {	      unsigned n = element_count (ty);	      if (available_v (&state) < n)		{		  state.nsrn = N_V_ARG_REG;		  avalue[i] = allocate_to_stack (&state, stack, ty->alignment,						 ty->size);		}	      else		{		  switch (get_homogeneous_type (ty))		    {		    case FFI_TYPE_FLOAT:		      {			/* Eeek! We need a pointer to the structure,			   however the homogeneous float elements are			   being passed in individual S registers,			   therefore the structure is not represented as			   a contiguous sequence of bytes in our saved			   register context. We need to fake up a copy			   of the structure laid out in memory			   correctly. The fake can be tossed once the			   closure function has returned hence alloca()			   is sufficient. */			int j;			UINT32 *p = avalue[i] = alloca (ty->size);			for (j = 0; j < element_count (ty); j++)			  memcpy (&p[j],				  allocate_to_s (context, &state),				  sizeof (*p));			break;		      }		    case FFI_TYPE_DOUBLE:		      {			/* Eeek! We need a pointer to the structure,			   however the homogeneous float elements are			   being passed in individual S registers,			   therefore the structure is not represented as			   a contiguous sequence of bytes in our saved			   register context. We need to fake up a copy			   of the structure laid out in memory			   correctly. The fake can be tossed once the			   closure function has returned hence alloca()			   is sufficient. */			int j;			UINT64 *p = avalue[i] = alloca (ty->size);			for (j = 0; j < element_count (ty); j++)			  memcpy (&p[j],				  allocate_to_d (context, &state),				  sizeof (*p));			break;		      }#if FFI_TYPE_DOUBLE != FFI_TYPE_LONGDOUBLE		    case FFI_TYPE_LONGDOUBLE:			  memcpy (&avalue[i],//.........这里部分代码省略.........

//.........这里部分代码省略.........   See the x86-64 PS ABI for details.*/static intclassify_argument (ffi_type *type, enum x86_64_reg_class classes[],		   int *byte_offset){  /* First, align to the right place.  */  *byte_offset = ALIGN(*byte_offset, type->alignment);  switch (type->type)    {    case FFI_TYPE_UINT8:    case FFI_TYPE_SINT8:    case FFI_TYPE_UINT16:    case FFI_TYPE_SINT16:    case FFI_TYPE_UINT32:    case FFI_TYPE_SINT32:    case FFI_TYPE_UINT64:    case FFI_TYPE_SINT64:    case FFI_TYPE_POINTER:      if (((*byte_offset) % 8 + type->size) <= 4)	classes[0] = X86_64_INTEGERSI_CLASS;      else	classes[0] = X86_64_INTEGER_CLASS;      return 1;    case FFI_TYPE_FLOAT:      if (((*byte_offset) % 8) == 0)	classes[0] = X86_64_SSESF_CLASS;      else	classes[0] = X86_64_SSE_CLASS;      return 1;    case FFI_TYPE_DOUBLE:      classes[0] = X86_64_SSEDF_CLASS;      return 1;    case FFI_TYPE_LONGDOUBLE:      classes[0] = X86_64_X87_CLASS;      classes[1] = X86_64_X87UP_CLASS;      return 2;    case FFI_TYPE_STRUCT:      {	const int UNITS_PER_WORD = 8;	int words = (type->size + UNITS_PER_WORD - 1) / UNITS_PER_WORD;	ffi_type **ptr; 	int i;	enum x86_64_reg_class subclasses[MAX_CLASSES];	/* If the struct is larger than 16 bytes, pass it on the stack.  */	if (type->size > 16)	  return 0;	for (i = 0; i < words; i++)	  classes[i] = X86_64_NO_CLASS;	/* Merge the fields of structure.  */	for (ptr=type->elements; (*ptr)!=NULL; ptr++)	  {	    int num;	    num = classify_argument (*ptr, subclasses, byte_offset);	    if (num == 0)	      return 0;	    for (i = 0; i < num; i++)	      {		int pos = *byte_offset / 8;		classes[i + pos] =		  merge_classes (subclasses[i], classes[i + pos]);	      }	    if ((*ptr)->type != FFI_TYPE_STRUCT)	      *byte_offset += (*ptr)->size;	  }	/* Final merger cleanup.  */	for (i = 0; i < words; i++)	  {	    /* If one class is MEMORY, everything should be passed in	       memory.  */	    if (classes[i] == X86_64_MEMORY_CLASS)	      return 0;	    /* The X86_64_SSEUP_CLASS should be always preceded by	       X86_64_SSE_CLASS.  */	    if (classes[i] == X86_64_SSEUP_CLASS		&& (i == 0 || classes[i - 1] != X86_64_SSE_CLASS))	      classes[i] = X86_64_SSE_CLASS;	    /*  X86_64_X87UP_CLASS should be preceded by X86_64_X87_CLASS.  */	    if (classes[i] == X86_64_X87UP_CLASS		&& (i == 0 || classes[i - 1] != X86_64_X87_CLASS))	      classes[i] = X86_64_SSE_CLASS;	  }	return words;      }    default:      FFI_ASSERT(0);    }  return 0; /* Never reached.  */}

void ffi_prep_args(char *stack, extended_cif *ecif){  register unsigned int i;  register int tmp;  register unsigned int avn;  register void **p_argv;  register char *argp;  register ffi_type **p_arg;  int greg, ireg;#if defined(__SH4__)  int freg = 0;#endif  tmp = 0;  argp = stack;  if (return_type (ecif->cif->rtype) == FFI_TYPE_STRUCT)    {      *(void **) argp = ecif->rvalue;      argp += 4;      ireg = STRUCT_VALUE_ADDRESS_WITH_ARG ? 1 : 0;    }  else    ireg = 0;  /* Set arguments for registers.  */  greg = ireg;  avn = ecif->cif->nargs;  p_argv = ecif->avalue;  for (i = 0, p_arg = ecif->cif->arg_types; i < avn; i++, p_arg++, p_argv++)    {      size_t z;      z = (*p_arg)->size;      if (z < sizeof(int))	{	  if (greg++ >= NGREGARG)	    continue;	  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;  	    case FFI_TYPE_STRUCT:	      *(unsigned int *) argp = (unsigned int)*(UINT32 *)(* p_argv);	      break;	    default:	      FFI_ASSERT(0);	    }	  argp += z;	}      else if (z == sizeof(int))	{#if defined(__SH4__)	  if ((*p_arg)->type == FFI_TYPE_FLOAT)	    {	      if (freg++ >= NFREGARG)		continue;	    }	  else#endif	    {	      if (greg++ >= NGREGARG)		continue;	    }	  *(unsigned int *) argp = (unsigned int)*(UINT32 *)(* p_argv);	  argp += z;	}#if defined(__SH4__)      else if ((*p_arg)->type == FFI_TYPE_DOUBLE)	{	  if (freg + 1 >= NFREGARG)	    continue;	  freg = (freg + 1) & ~1;	  freg += 2;	  memcpy (argp, *p_argv, z);	  argp += z;	}#endif      else	{	  int n = (z + sizeof (int) - 1) / sizeof (int);#if defined(__SH4__)//.........这里部分代码省略.........

intffi_closure_helper_SYSV (ffi_closure *closure, void *rvalue, 			 unsigned long *pgr, unsigned long *pfr, 			 unsigned long *pst){  void **avalue;  ffi_type **p_arg;  int i, avn;  int ireg, greg = 0;#if defined(__SH4__)  int freg = 0;#endif  ffi_cif *cif;   cif = closure->cif;  avalue = alloca(cif->nargs * sizeof(void *));  /* Copy the caller's structure return value address so that the closure     returns the data directly to the caller.  */  if (cif->rtype->type == FFI_TYPE_STRUCT && STRUCT_VALUE_ADDRESS_WITH_ARG)    {      rvalue = (void *) *pgr++;      ireg = 1;    }  else    ireg = 0;  cif = closure->cif;  greg = ireg;  avn = cif->nargs;  /* Grab the addresses of the arguments from the stack frame.  */  for (i = 0, p_arg = cif->arg_types; i < avn; i++, p_arg++)    {      size_t z;      z = (*p_arg)->size;      if (z < sizeof(int))	{	  if (greg++ >= NGREGARG)	    continue;	  z = sizeof(int);	  switch ((*p_arg)->type)	    {	    case FFI_TYPE_SINT8:	    case FFI_TYPE_UINT8:	      avalue[i] = (((char *)pgr) + OFS_INT8);	      break;  	    case FFI_TYPE_SINT16:	    case FFI_TYPE_UINT16:	      avalue[i] = (((char *)pgr) + OFS_INT16);	      break;  	    case FFI_TYPE_STRUCT:	      avalue[i] = pgr;	      break;	    default:	      FFI_ASSERT(0);	    }	  pgr++;	}      else if (z == sizeof(int))	{#if defined(__SH4__)	  if ((*p_arg)->type == FFI_TYPE_FLOAT)	    {	      if (freg++ >= NFREGARG)		continue;	      avalue[i] = pfr;	      pfr++;	    }	  else#endif	    {	      if (greg++ >= NGREGARG)		continue;	      avalue[i] = pgr;	      pgr++;	    }	}#if defined(__SH4__)      else if ((*p_arg)->type == FFI_TYPE_DOUBLE)	{	  if (freg + 1 >= NFREGARG)	    continue;	  if (freg & 1)	    pfr++;	  freg = (freg + 1) & ~1;	  freg += 2;	  avalue[i] = pfr;	  pfr += 2;	}#endif      else	{	  int n = (z + sizeof (int) - 1) / sizeof (int);#if defined(__SH4__)//.........这里部分代码省略.........

ffi_status ffi_prep_cif(/*@[email
C++ FFI_FN函数代码示例
C++ FFALIGN函数代码示例