cloudsmith-api 0.21.4 → 0.30.7

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

@@ -0,0 +1,58 @@
+/* -----------------------------------------------------------------*-C-*-
+   ffitarget.h - Copyright (c) 2012  Anthony Green
+                 Copyright (c) 1996-2003  Red Hat, Inc.
+   Target configuration macros for SuperH - SHmedia.
+
+   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
+
+#ifndef LIBFFI_H
+#error "Please do not include ffitarget.h directly into your source.  Use ffi.h instead."
+#endif
+
+/* ---- 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;
+
+#define FFI_EXTRA_CIF_FIELDS long long flags2
+#endif
+
+/* ---- Definitions for closures ----------------------------------------- */
+
+#define FFI_CLOSURES 1
+#define FFI_TRAMPOLINE_SIZE 32
+#define FFI_NATIVE_RAW_API 0
+
+#endif
+

data/vendor/bundle/ruby/2.3.0/gems/ffi-1.9.25/ext/ffi_c/libffi/src/sparc/ffi.c

@@ -0,0 +1,468 @@
+/* -----------------------------------------------------------------------
+   ffi.c - Copyright (c) 2011, 2013 Anthony Green
+           Copyright (c) 1996, 2003-2004, 2007-2008 Red Hat, Inc.
+   
+   SPARC 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>
+#include "internal.h"
+
+#ifndef SPARC64
+
+/* Force FFI_TYPE_LONGDOUBLE to be different than FFI_TYPE_DOUBLE;
+   all further uses in this file will refer to the 128-bit type.  */
+#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
+# if FFI_TYPE_LONGDOUBLE != 4
+#  error FFI_TYPE_LONGDOUBLE out of date
+# endif
+#else
+# undef FFI_TYPE_LONGDOUBLE
+# define FFI_TYPE_LONGDOUBLE 4
+#endif
+
+/* Perform machine dependent cif processing */
+ffi_status FFI_HIDDEN
+ffi_prep_cif_machdep(ffi_cif *cif)
+{
+  ffi_type *rtype = cif->rtype;
+  int rtt = rtype->type;
+  size_t bytes;
+  int i, n, flags;
+
+  /* Set the return type flag */
+  switch (rtt)
+    {
+    case FFI_TYPE_VOID:
+      flags = SPARC_RET_VOID;
+      break;
+    case FFI_TYPE_FLOAT:
+      flags = SPARC_RET_F_1;
+      break;
+    case FFI_TYPE_DOUBLE:
+      flags = SPARC_RET_F_2;
+      break;
+    case FFI_TYPE_LONGDOUBLE:
+    case FFI_TYPE_STRUCT:
+      flags = (rtype->size & 0xfff) << SPARC_SIZEMASK_SHIFT;
+      flags |= SPARC_RET_STRUCT;
+      break;
+    case FFI_TYPE_SINT8:
+      flags = SPARC_RET_SINT8;
+      break;
+    case FFI_TYPE_UINT8:
+      flags = SPARC_RET_UINT8;
+      break;
+    case FFI_TYPE_SINT16:
+      flags = SPARC_RET_SINT16;
+      break;
+    case FFI_TYPE_UINT16:
+      flags = SPARC_RET_UINT16;
+      break;
+    case FFI_TYPE_INT:
+    case FFI_TYPE_SINT32:
+    case FFI_TYPE_UINT32:
+    case FFI_TYPE_POINTER:
+      flags = SPARC_RET_UINT32;
+      break;
+    case FFI_TYPE_SINT64:
+    case FFI_TYPE_UINT64:
+      flags = SPARC_RET_INT64;
+      break;
+    case FFI_TYPE_COMPLEX:
+      rtt = rtype->elements[0]->type;
+      switch (rtt)
+	{
+	case FFI_TYPE_FLOAT:
+	  flags = SPARC_RET_F_2;
+	  break;
+	case FFI_TYPE_DOUBLE:
+	  flags = SPARC_RET_F_4;
+	  break;
+	case FFI_TYPE_LONGDOUBLE:
+	  flags = SPARC_RET_F_8;
+	  break;
+	case FFI_TYPE_SINT64:
+	case FFI_TYPE_UINT64:
+	  flags = SPARC_RET_INT128;
+	  break;
+	case FFI_TYPE_INT:
+	case FFI_TYPE_SINT32:
+	case FFI_TYPE_UINT32:
+	  flags = SPARC_RET_INT64;
+	  break;
+	case FFI_TYPE_SINT16:
+	case FFI_TYPE_UINT16:
+	  flags = SP_V8_RET_CPLX16;
+	  break;
+	case FFI_TYPE_SINT8:
+	case FFI_TYPE_UINT8:
+	  flags = SP_V8_RET_CPLX8;
+	  break;
+	default:
+	  abort();
+	}
+      break;
+    default:
+      abort();
+    }
+  cif->flags = flags;
+
+  bytes = 0;
+  for (i = 0, n = cif->nargs; i < n; ++i)
+    {
+      ffi_type *ty = cif->arg_types[i];
+      size_t z = ty->size;
+      int tt = ty->type;
+
+      switch (tt)
+	{
+	case FFI_TYPE_STRUCT:
+	case FFI_TYPE_LONGDOUBLE:
+	by_reference:
+	  /* Passed by reference.  */
+	  z = 4;
+	  break;
+
+	case FFI_TYPE_COMPLEX:
+	  tt = ty->elements[0]->type;
+	  if (tt == FFI_TYPE_FLOAT || z > 8)
+	    goto by_reference;
+	  /* FALLTHRU */
+
+	default:
+	  z = FFI_ALIGN(z, 4);
+	}
+      bytes += z;
+    }
+
+  /* Sparc call frames require that space is allocated for 6 args,
+     even if they aren't used. Make that space if necessary.  */
+  if (bytes < 6 * 4)
+    bytes = 6 * 4;
+
+  /* The ABI always requires space for the struct return pointer.  */
+  bytes += 4;
+
+  /* The stack must be 2 word aligned, so round bytes up appropriately. */
+  bytes = FFI_ALIGN(bytes, 2 * 4);
+
+  /* Include the call frame to prep_args.  */
+  bytes += 4*16 + 4*8;
+  cif->bytes = bytes;
+
+  return FFI_OK;
+}
+
+extern void ffi_call_v8(ffi_cif *cif, void (*fn)(void), void *rvalue,
+			void **avalue, size_t bytes, void *closure) FFI_HIDDEN;
+
+int FFI_HIDDEN
+ffi_prep_args_v8(ffi_cif *cif, unsigned long *argp, void *rvalue, void **avalue)
+{
+  ffi_type **p_arg;
+  int flags = cif->flags;
+  int i, nargs;
+
+  if (rvalue == NULL)
+    {
+      if ((flags & SPARC_FLAG_RET_MASK) == SPARC_RET_STRUCT)
+	{
+	  /* Since we pass the pointer to the callee, we need a value.
+	     We allowed for this space in ffi_call, before ffi_call_v8
+	     alloca'd the space.  */
+	  rvalue = (char *)argp + cif->bytes;
+	}
+      else
+	{
+	  /* Otherwise, we can ignore the return value.  */
+	  flags = SPARC_RET_VOID;
+	}
+    }
+
+  /* This could only really be done when we are returning a structure.
+     However, the space is reserved so we can do it unconditionally.  */
+  *argp++ = (unsigned long)rvalue;
+
+#ifdef USING_PURIFY
+  /* Purify will probably complain in our assembly routine,
+     unless we zero out this memory. */
+  memset(argp, 0, 6*4);
+#endif
+
+  p_arg = cif->arg_types;
+  for (i = 0, nargs = cif->nargs; i < nargs; i++)
+    {
+      ffi_type *ty = p_arg[i];
+      void *a = avalue[i];
+      int tt = ty->type;
+      size_t z;
+
+      switch (tt)
+	{
+	case FFI_TYPE_STRUCT:
+	case FFI_TYPE_LONGDOUBLE:
+	by_reference:
+	  *argp++ = (unsigned long)a;
+	  break;
+
+	case FFI_TYPE_DOUBLE:
+	case FFI_TYPE_UINT64:
+	case FFI_TYPE_SINT64:
+	  memcpy(argp, a, 8);
+	  argp += 2;
+	  break;
+
+	case FFI_TYPE_INT:
+	case FFI_TYPE_FLOAT:
+	case FFI_TYPE_UINT32:
+	case FFI_TYPE_SINT32:
+	case FFI_TYPE_POINTER:
+	  *argp++ = *(unsigned *)a;
+	  break;
+
+	case FFI_TYPE_UINT8:
+	  *argp++ = *(UINT8 *)a;
+	  break;
+	case FFI_TYPE_SINT8:
+	  *argp++ = *(SINT8 *)a;
+	  break;
+	case FFI_TYPE_UINT16:
+	  *argp++ = *(UINT16 *)a;
+	  break;
+	case FFI_TYPE_SINT16:
+	  *argp++ = *(SINT16 *)a;
+	  break;
+
+        case FFI_TYPE_COMPLEX:
+	  tt = ty->elements[0]->type;
+	  z = ty->size;
+	  if (tt == FFI_TYPE_FLOAT || z > 8)
+	    goto by_reference;
+	  if (z < 4)
+	    {
+	      memcpy((char *)argp + 4 - z, a, z);
+	      argp++;
+	    }
+	  else
+	    {
+	      memcpy(argp, a, z);
+	      argp += z / 4;
+	    }
+	  break;
+
+	default:
+	  abort();
+	}
+    }
+
+  return flags;
+}
+
+static void
+ffi_call_int (ffi_cif *cif, void (*fn)(void), void *rvalue,
+	      void **avalue, void *closure)
+{
+  size_t bytes = cif->bytes;
+
+  FFI_ASSERT (cif->abi == FFI_V8);
+
+  /* If we've not got a return value, we need to create one if we've
+     got to pass the return value to the callee.  Otherwise ignore it.  */
+  if (rvalue == NULL
+      && (cif->flags & SPARC_FLAG_RET_MASK) == SPARC_RET_STRUCT)
+    bytes += FFI_ALIGN (cif->rtype->size, 8);
+
+  ffi_call_v8(cif, fn, rvalue, avalue, -bytes, closure);
+}
+
+void
+ffi_call (ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue)
+{
+  ffi_call_int (cif, fn, rvalue, avalue, NULL);
+}
+
+void
+ffi_call_go (ffi_cif *cif, void (*fn)(void), void *rvalue,
+	     void **avalue, void *closure)
+{
+  ffi_call_int (cif, fn, rvalue, avalue, closure);
+}
+
+#ifdef __GNUC__
+static inline void
+ffi_flush_icache (void *p)
+{
+  /* SPARC v8 requires 5 instructions for flush to be visible */
+  asm volatile ("iflush	%0; iflush %0+8; nop; nop; nop; nop; nop"
+		: : "r" (p) : "memory");
+}
+#else
+extern void ffi_flush_icache (void *) FFI_HIDDEN;
+#endif
+
+extern void ffi_closure_v8(void) FFI_HIDDEN;
+extern void ffi_go_closure_v8(void) FFI_HIDDEN;
+
+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 = (unsigned int *) &closure->tramp[0];
+  unsigned long ctx = (unsigned long) closure;
+  unsigned long fn = (unsigned long) ffi_closure_v8;
+
+  if (cif->abi != FFI_V8)
+    return FFI_BAD_ABI;
+
+  tramp[0] = 0x03000000 | fn >> 10;	/* sethi %hi(fn), %g1	*/
+  tramp[1] = 0x05000000 | ctx >> 10;	/* sethi %hi(ctx), %g2	*/
+  tramp[2] = 0x81c06000 | (fn & 0x3ff);	/* jmp   %g1+%lo(fn)	*/
+  tramp[3] = 0x8410a000 | (ctx & 0x3ff);/* or    %g2, %lo(ctx)	*/
+
+  closure->cif = cif;
+  closure->fun = fun;
+  closure->user_data = user_data;
+
+  ffi_flush_icache (closure);
+
+  return FFI_OK;
+}
+
+ffi_status
+ffi_prep_go_closure (ffi_go_closure *closure, ffi_cif *cif,
+		     void (*fun)(ffi_cif*, void*, void**, void*))
+{
+  if (cif->abi != FFI_V8)
+    return FFI_BAD_ABI;
+
+  closure->tramp = ffi_go_closure_v8;
+  closure->cif = cif;
+  closure->fun = fun;
+
+  return FFI_OK;
+}
+
+int FFI_HIDDEN
+ffi_closure_sparc_inner_v8(ffi_cif *cif, 
+			   void (*fun)(ffi_cif*, void*, void**, void*),
+			   void *user_data, void *rvalue,
+			   unsigned long *argp)
+{
+  ffi_type **arg_types;
+  void **avalue;
+  int i, nargs, flags;
+
+  arg_types = cif->arg_types;
+  nargs = cif->nargs;
+  flags = cif->flags;
+  avalue = alloca(nargs * sizeof(void *));
+
+  /* Copy the caller's structure return address so that the closure
+     returns the data directly to the caller.  Also install it so we
+     can return the address in %o0.  */
+  if ((flags & SPARC_FLAG_RET_MASK) == SPARC_RET_STRUCT)
+    {
+      void *new_rvalue = (void *)*argp;
+      *(void **)rvalue = new_rvalue;
+      rvalue = new_rvalue;
+    }
+
+  /* Always skip the structure return address.  */
+  argp++;
+
+  /* Grab the addresses of the arguments from the stack frame.  */
+  for (i = 0; i < nargs; i++)
+    {
+      ffi_type *ty = arg_types[i];
+      int tt = ty->type;
+      void *a = argp;
+      size_t z;
+
+      switch (tt)
+	{
+	case FFI_TYPE_STRUCT:
+	case FFI_TYPE_LONGDOUBLE:
+	by_reference:
+	  /* Straight copy of invisible reference.  */
+	  a = (void *)*argp;
+	  break;
+
+	case FFI_TYPE_DOUBLE:
+	case FFI_TYPE_SINT64:
+	case FFI_TYPE_UINT64:
+	  if ((unsigned long)a & 7)
+	    {
+	      /* Align on a 8-byte boundary.  */
+	      UINT64 *tmp = alloca(8);
+	      *tmp = ((UINT64)argp[0] << 32) | argp[1];
+	      a = tmp;
+	    }
+	  argp++;
+	  break;
+
+	case FFI_TYPE_INT:
+	case FFI_TYPE_FLOAT:
+	case FFI_TYPE_UINT32:
+	case FFI_TYPE_SINT32:
+	case FFI_TYPE_POINTER:
+	  break;
+        case FFI_TYPE_UINT16:
+        case FFI_TYPE_SINT16:
+	  a += 2;
+	  break;
+        case FFI_TYPE_UINT8:
+        case FFI_TYPE_SINT8:
+	  a += 3;
+	  break;
+
+        case FFI_TYPE_COMPLEX:
+	  tt = ty->elements[0]->type;
+	  z = ty->size;
+	  if (tt == FFI_TYPE_FLOAT || z > 8)
+	    goto by_reference;
+	  if (z < 4)
+	    a += 4 - z;
+	  else if (z > 4)
+	    argp++;
+	  break;
+
+	default:
+	  abort();
+	}
+      argp++;
+      avalue[i] = a;
+    }
+
+  /* Invoke the closure.  */
+  fun (cif, rvalue, avalue, user_data);
+
+  /* Tell ffi_closure_sparc how to perform return type promotions.  */
+  return flags;
+}
+#endif /* !SPARC64 */