cloudsmith-api 0.21.4 → 0.30.7

data/vendor/bundle/ruby/2.3.0/gems/ffi-1.9.18/ext/ffi_c/libffi/src/sh/ffitarget.h

@@ -1,49 +0,0 @@
-/* -----------------------------------------------------------------*-C-*-
-   ffitarget.h - Copyright (c) 1996-2003  Red Hat, Inc.
-   Target configuration macros for SuperH.
-
-   Permission is hereby granted, free of charge, to any person obtaining
-   a copy of this software and associated documentation files (the
-   ``Software''), to deal in the Software without restriction, including
-   without limitation the rights to use, copy, modify, merge, publish,
-   distribute, sublicense, and/or sell copies of the Software, and to
-   permit persons to whom the Software is furnished to do so, subject to
-   the following conditions:
-
-   The above copyright notice and this permission notice shall be included
-   in all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,
-   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-   NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-   HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-   WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-   DEALINGS IN THE SOFTWARE.
-
-   ----------------------------------------------------------------------- */
-
-#ifndef LIBFFI_TARGET_H
-#define LIBFFI_TARGET_H
-
-/* ---- Generic type definitions ----------------------------------------- */
-
-#ifndef LIBFFI_ASM
-typedef unsigned long          ffi_arg;
-typedef signed long            ffi_sarg;
-
-typedef enum ffi_abi {
-  FFI_FIRST_ABI = 0,
-  FFI_SYSV,
-  FFI_LAST_ABI,
-  FFI_DEFAULT_ABI = FFI_SYSV
-} ffi_abi;
-#endif
-
-#define FFI_CLOSURES 1
-#define FFI_TRAMPOLINE_SIZE 16
-#define FFI_NATIVE_RAW_API 0
-
-#endif
-

data/vendor/bundle/ruby/2.3.0/gems/ffi-1.9.18/ext/ffi_c/libffi/src/sh64/ffi.c

@@ -1,468 +0,0 @@
-/* -----------------------------------------------------------------------
-   ffi.c - Copyright (c) 2003, 2004, 2006, 2007 Kaz Kojima
-           Copyright (c) 2008 Anthony Green
-   
-   SuperH SHmedia Foreign Function Interface 
-
-   Permission is hereby granted, free of charge, to any person obtaining
-   a copy of this software and associated documentation files (the
-   ``Software''), to deal in the Software without restriction, including
-   without limitation the rights to use, copy, modify, merge, publish,
-   distribute, sublicense, and/or sell copies of the Software, and to
-   permit persons to whom the Software is furnished to do so, subject to
-   the following conditions:
-
-   The above copyright notice and this permission notice shall be included
-   in all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,
-   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-   NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-   HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-   WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-   DEALINGS IN THE SOFTWARE.
-   ----------------------------------------------------------------------- */
-
-#include <ffi.h>
-#include <ffi_common.h>
-
-#include <stdlib.h>
-
-#define NGREGARG 8
-#define NFREGARG 12
-
-static int
-return_type (ffi_type *arg)
-{
-
-  if (arg->type != FFI_TYPE_STRUCT)
-    return arg->type;
-
-  /* gcc uses r2 if the result can be packed in on register.  */
-  if (arg->size <= sizeof (UINT8))
-    return FFI_TYPE_UINT8;
-  else if (arg->size <= sizeof (UINT16))
-    return FFI_TYPE_UINT16;
-  else if (arg->size <= sizeof (UINT32))
-    return FFI_TYPE_UINT32;
-  else if (arg->size <= sizeof (UINT64))
-    return FFI_TYPE_UINT64;
-
-  return FFI_TYPE_STRUCT;
-}
-
-/* ffi_prep_args is called by the assembly routine once stack space
-   has been allocated for the function's arguments */
-
-void ffi_prep_args(char *stack, extended_cif *ecif)
-{
-  register unsigned int i;
-  register unsigned int avn;
-  register void **p_argv;
-  register char *argp;
-  register ffi_type **p_arg;
-
-  argp = stack;
-
-  if (return_type (ecif->cif->rtype) == FFI_TYPE_STRUCT)
-    {
-      *(void **) argp = ecif->rvalue;
-      argp += sizeof (UINT64);
-    }
-
-  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;
-      int align;
-
-      z = (*p_arg)->size;
-      align = (*p_arg)->alignment;
-      if (z < sizeof (UINT32))
-	{
-	  switch ((*p_arg)->type)
-	    {
-	    case FFI_TYPE_SINT8:
-	      *(SINT64 *) argp = (SINT64) *(SINT8 *)(*p_argv);
-	      break;
-  
-	    case FFI_TYPE_UINT8:
-	      *(UINT64 *) argp = (UINT64) *(UINT8 *)(*p_argv);
-	      break;
-  
-	    case FFI_TYPE_SINT16:
-	      *(SINT64 *) argp = (SINT64) *(SINT16 *)(*p_argv);
-	      break;
-  
-	    case FFI_TYPE_UINT16:
-	      *(UINT64 *) argp = (UINT64) *(UINT16 *)(*p_argv);
-	      break;
-  
-	    case FFI_TYPE_STRUCT:
-	      memcpy (argp, *p_argv, z);
-	      break;
-
-	    default:
-	      FFI_ASSERT(0);
-	    }
-	  argp += sizeof (UINT64);
-	}
-      else if (z == sizeof (UINT32) && align == sizeof (UINT32))
-	{
-	  switch ((*p_arg)->type)
-	    {
-	    case FFI_TYPE_INT:
-	    case FFI_TYPE_SINT32:
-	      *(SINT64 *) argp = (SINT64) *(SINT32 *) (*p_argv);
-	      break;
-
-	    case FFI_TYPE_FLOAT:
-	    case FFI_TYPE_POINTER:
-	    case FFI_TYPE_UINT32:
-	    case FFI_TYPE_STRUCT:
-	      *(UINT64 *) argp = (UINT64) *(UINT32 *) (*p_argv);
-	      break;
-
-	    default:
-	      FFI_ASSERT(0);
-	      break;
-	    }
-	  argp += sizeof (UINT64);
-	}
-      else if (z == sizeof (UINT64)
-	       && align == sizeof (UINT64)
-	       && ((int) *p_argv & (sizeof (UINT64) - 1)) == 0)
-	{
-	  *(UINT64 *) argp = *(UINT64 *) (*p_argv);
-	  argp += sizeof (UINT64);
-	}
-      else
-	{
-	  int n = (z + sizeof (UINT64) - 1) / sizeof (UINT64);
-
-	  memcpy (argp, *p_argv, z);
-	  argp += n * sizeof (UINT64);
-	}
-    }
-
-  return;
-}
-
-/* Perform machine dependent cif processing */
-ffi_status ffi_prep_cif_machdep(ffi_cif *cif)
-{
-  int i, j;
-  int size, type;
-  int n, m;
-  int greg;
-  int freg;
-  int fpair = -1;
-
-  greg = (return_type (cif->rtype) == FFI_TYPE_STRUCT ? 1 : 0);
-  freg = 0;
-  cif->flags2 = 0;
-
-  for (i = j = 0; i < cif->nargs; i++)
-    {
-      type = (cif->arg_types)[i]->type;
-      switch (type)
-	{
-	case FFI_TYPE_FLOAT:
-	  greg++;
-	  cif->bytes += sizeof (UINT64) - sizeof (float);
-	  if (freg >= NFREGARG - 1)
-	    continue;
-	  if (fpair < 0)
-	    {
-	      fpair = freg;
-	      freg += 2;
-	    }
-	  else
-	    fpair = -1;
-	  cif->flags2 += ((cif->arg_types)[i]->type) << (2 * j++);
-	  break;
-
-	case FFI_TYPE_DOUBLE:
-	  if (greg++ >= NGREGARG && (freg + 1) >= NFREGARG)
-	    continue;
-	  if ((freg + 1) < NFREGARG)
-	    {
-	      freg += 2;
-	      cif->flags2 += ((cif->arg_types)[i]->type) << (2 * j++);
-	    }
-	  else
-	    cif->flags2 += FFI_TYPE_INT << (2 * j++);
-	  break;
-	      
-	default:
-	  size = (cif->arg_types)[i]->size;
-	  if (size < sizeof (UINT64))
-	    cif->bytes += sizeof (UINT64) - size;
-	  n = (size + sizeof (UINT64) - 1) / sizeof (UINT64);
-	  if (greg >= NGREGARG)
-	    continue;
-	  else if (greg + n - 1 >= NGREGARG)
-	    greg = NGREGARG;
-	  else
-	    greg += n;
-	  for (m = 0; m < n; m++)
-	    cif->flags2 += FFI_TYPE_INT << (2 * j++);
-	  break;
-	}
-    }
-
-  /* Set the return type flag */
-  switch (cif->rtype->type)
-    {
-    case FFI_TYPE_STRUCT:
-      cif->flags = return_type (cif->rtype);
-      break;
-
-    case FFI_TYPE_VOID:
-    case FFI_TYPE_FLOAT:
-    case FFI_TYPE_DOUBLE:
-    case FFI_TYPE_SINT64:
-    case FFI_TYPE_UINT64:
-      cif->flags = cif->rtype->type;
-      break;
-
-    default:
-      cif->flags = FFI_TYPE_INT;
-      break;
-    }
-
-  return FFI_OK;
-}
-
-/*@-declundef@*/
-/*@-exportheader@*/
-extern void ffi_call_SYSV(void (*)(char *, extended_cif *), 
-			  /*@out@*/ extended_cif *, 
-			  unsigned, unsigned, long long,
-			  /*@out@*/ unsigned *, 
-			  void (*fn)(void));
-/*@=declundef@*/
-/*@=exportheader@*/
-
-void ffi_call(/*@dependent@*/ ffi_cif *cif, 
-	      void (*fn)(void), 
-	      /*@out@*/ void *rvalue, 
-	      /*@dependent@*/ void **avalue)
-{
-  extended_cif ecif;
-  UINT64 trvalue;
-
-  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 (cif->rtype->type == FFI_TYPE_STRUCT
-      && return_type (cif->rtype) != FFI_TYPE_STRUCT)
-    ecif.rvalue = &trvalue;
-  else 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, cif->flags2,
-		    ecif.rvalue, fn);
-      break;
-    default:
-      FFI_ASSERT(0);
-      break;
-    }
-
-  if (rvalue
-      && cif->rtype->type == FFI_TYPE_STRUCT
-      && return_type (cif->rtype) != FFI_TYPE_STRUCT)
-    memcpy (rvalue, &trvalue, cif->rtype->size);
-}
-
-extern void ffi_closure_SYSV (void);
-extern void __ic_invalidate (void *line);
-
-ffi_status
-ffi_prep_closure_loc (ffi_closure *closure,
-		      ffi_cif *cif,
-		      void (*fun)(ffi_cif*, void*, void**, void*),
-		      void *user_data,
-		      void *codeloc)
-{
-  unsigned int *tramp;
-
-  FFI_ASSERT (cif->abi == FFI_GCC_SYSV);
-
-  tramp = (unsigned int *) &closure->tramp[0];
-  /* Since ffi_closure is an aligned object, the ffi trampoline is
-     called as an SHcompact code.  Sigh.
-     SHcompact part:
-     mova @(1,pc),r0; add #1,r0; jmp @r0; nop;
-     SHmedia part:
-     movi fnaddr >> 16,r1; shori fnaddr,r1; ptabs/l r1,tr0
-     movi cxt >> 16,r1; shori cxt,r1; blink tr0,r63  */
-#ifdef __LITTLE_ENDIAN__
-  tramp[0] = 0x7001c701;
-  tramp[1] = 0x0009402b;
-#else
-  tramp[0] = 0xc7017001;
-  tramp[1] = 0x402b0009;
-#endif
-  tramp[2] = 0xcc000010 | (((UINT32) ffi_closure_SYSV) >> 16) << 10;
-  tramp[3] = 0xc8000010 | (((UINT32) ffi_closure_SYSV) & 0xffff) << 10;
-  tramp[4] = 0x6bf10600;
-  tramp[5] = 0xcc000010 | (((UINT32) codeloc) >> 16) << 10;
-  tramp[6] = 0xc8000010 | (((UINT32) codeloc) & 0xffff) << 10;
-  tramp[7] = 0x4401fff0;
-
-  closure->cif = cif;
-  closure->fun = fun;
-  closure->user_data = user_data;
-
-  /* Flush the icache.  */
-  asm volatile ("ocbwb %0,0; synco; icbi %1,0; synci" : : "r" (tramp),
-		"r"(codeloc));
-
-  return FFI_OK;
-}
-
-/* Basically the trampoline invokes ffi_closure_SYSV, and on 
- * entry, r3 holds the address of the closure.
- * After storing the registers that could possibly contain
- * parameters to be passed into the stack frame and setting
- * up space for a return value, ffi_closure_SYSV invokes the 
- * following helper function to do most of the work.
- */
-
-int
-ffi_closure_helper_SYSV (ffi_closure *closure, UINT64 *rvalue, 
-			 UINT64 *pgr, UINT64 *pfr, UINT64 *pst)
-{
-  void **avalue;
-  ffi_type **p_arg;
-  int i, avn;
-  int greg, freg;
-  ffi_cif *cif;
-  int fpair = -1;
-
-  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 (return_type (cif->rtype) == FFI_TYPE_STRUCT)
-    {
-      rvalue = (UINT64 *) *pgr;
-      greg = 1;
-    }
-  else
-    greg = 0;
-
-  freg = 0;
-  cif = closure->cif;
-  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;
-      void *p;
-
-      z = (*p_arg)->size;
-      if (z < sizeof (UINT32))
-	{
-	  p = pgr + greg++;
-
-	  switch ((*p_arg)->type)
-	    {
-	    case FFI_TYPE_SINT8:
-	    case FFI_TYPE_UINT8:
-	    case FFI_TYPE_SINT16:
-	    case FFI_TYPE_UINT16:
-	    case FFI_TYPE_STRUCT:
-#ifdef __LITTLE_ENDIAN__
-	      avalue[i] = p;
-#else
-	      avalue[i] = ((char *) p) + sizeof (UINT32) - z;
-#endif
-	      break;
-
-	    default:
-	      FFI_ASSERT(0);
-	    }
-	}
-      else if (z == sizeof (UINT32))
-	{
-	  if ((*p_arg)->type == FFI_TYPE_FLOAT)
-	    {
-	      if (freg < NFREGARG - 1)
-		{
-		  if (fpair >= 0)
-		    {
-		      avalue[i] = (UINT32 *) pfr + fpair;
-		      fpair = -1;
-		    }
-		  else
-		    {
-#ifdef __LITTLE_ENDIAN__
-		      fpair = freg;
-		      avalue[i] = (UINT32 *) pfr + (1 ^ freg);
-#else
-		      fpair = 1 ^ freg;
-		      avalue[i] = (UINT32 *) pfr + freg;
-#endif
-		      freg += 2;
-		    }
-		}
-	      else
-#ifdef __LITTLE_ENDIAN__
-		avalue[i] = pgr + greg;
-#else
-		avalue[i] = (UINT32 *) (pgr + greg) + 1;
-#endif
-	    }
-	  else
-#ifdef __LITTLE_ENDIAN__
-	    avalue[i] = pgr + greg;
-#else
-	    avalue[i] = (UINT32 *) (pgr + greg) + 1;
-#endif
-	  greg++;
-	}
-      else if ((*p_arg)->type == FFI_TYPE_DOUBLE)
-	{
-	  if (freg + 1 >= NFREGARG)
-	    avalue[i] = pgr + greg;
-	  else
-	    {
-	      avalue[i] = pfr + (freg >> 1);
-	      freg += 2;
-	    }
-	  greg++;
-	}
-      else
-	{
-	  int n = (z + sizeof (UINT64) - 1) / sizeof (UINT64);
-
-	  avalue[i] = pgr + greg;
-	  greg += n;
-	}
-    }
-
-  (closure->fun) (cif, rvalue, avalue, closure->user_data);
-
-  /* Tell ffi_closure_SYSV how to perform return type promotions.  */
-  return return_type (cif->rtype);
-}
-