cybrid_api_organization_ruby 0.117.26 → 0.117.28

data/vendor/bundle/ruby/3.2.0/gems/ffi-1.16.3/ext/ffi_c/libffi/src/m88k/ffi.c

@@ -1,400 +0,0 @@
-/*
- * Copyright (c) 2013 Miodrag Vallat.  <miod@openbsd.org>
- *
- * 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.
- */
-
-/*
- * m88k Foreign Function Interface
- *
- * This file attempts to provide all the FFI entry points which can reliably
- * be implemented in C.
- *
- * Only OpenBSD/m88k is currently supported; other platforms (such as
- * Motorola's SysV/m88k) could be supported with the following tweaks:
- *
- * - non-OpenBSD systems use an `outgoing parameter area' as part of the
- *   88BCS calling convention, which is not supported under OpenBSD from
- *   release 3.6 onwards.  Supporting it should be as easy as taking it
- *   into account when adjusting the stack, in the assembly code.
- *
- * - the logic deciding whether a function argument gets passed through
- *   registers, or on the stack, has changed several times in OpenBSD in
- *   edge cases (especially for structs larger than 32 bytes being passed
- *   by value). The code below attemps to match the logic used by the
- *   system compiler of OpenBSD 5.3, i.e. gcc 3.3.6 with many m88k backend
- *   fixes.
- */
-
-#include <ffi.h>
-#include <ffi_common.h>
-
-#include <stdlib.h>
-#include <unistd.h>
-
-void ffi_call_OBSD (unsigned int, extended_cif *, unsigned int, void *,
-		    void (*fn) ());
-void *ffi_prep_args (void *, extended_cif *);
-void ffi_closure_OBSD (ffi_closure *);
-void ffi_closure_struct_OBSD (ffi_closure *);
-unsigned int ffi_closure_OBSD_inner (ffi_closure *, void *, unsigned int *,
-				     char *);
-void ffi_cacheflush_OBSD (unsigned int, unsigned int);
-
-#define CIF_FLAGS_INT		(1 << 0)
-#define CIF_FLAGS_DINT		(1 << 1)
-
-/*
- * Foreign Function Interface API
- */
-
-/* ffi_prep_args is called by the assembly routine once stack space has
-   been allocated for the function's arguments.  */
-
-void *
-ffi_prep_args (void *stack, extended_cif *ecif)
-{
-  unsigned int i;
-  void **p_argv;
-  char *argp, *stackp;
-  unsigned int *regp;
-  unsigned int regused;
-  ffi_type **p_arg;
-  void *struct_value_ptr;
-
-  regp = (unsigned int *)stack;
-  stackp = (char *)(regp + 8);
-  regused = 0;
-
-  if (ecif->cif->rtype->type == FFI_TYPE_STRUCT
-      && !ecif->cif->flags)
-    struct_value_ptr = ecif->rvalue;
-  else
-    struct_value_ptr = NULL;
-
-  p_argv = ecif->avalue;
-
-  for (i = ecif->cif->nargs, p_arg = ecif->cif->arg_types; i != 0; i--, p_arg++)
-    {
-      size_t z;
-      unsigned short t, a;
-
-      z = (*p_arg)->size;
-      t = (*p_arg)->type;
-      a = (*p_arg)->alignment;
-
-      /*
-       * Figure out whether the argument can be passed through registers
-       * or on the stack.
-       * The rule is that registers can only receive simple types not larger
-       * than 64 bits, or structs the exact size of a register and aligned to
-       * the size of a register.
-       */
-      if (t == FFI_TYPE_STRUCT)
-	{
-	  if (z == sizeof (int) && a == sizeof (int) && regused < 8)
-	    argp = (char *)regp;
-	  else
-	    argp = stackp;
-	}
-      else
-	{
-	  if (z > sizeof (int) && regused < 8 - 1)
-	    {
-	      /* align to an even register pair */
-	      if (regused & 1)
-		{
-		  regp++;
-		  regused++;
-		}
-	    }
-	  if (regused < 8)
-	    argp = (char *)regp;
-	  else
-	    argp = stackp;
-	}
-
-      /* Enforce proper stack alignment of 64-bit types */
-      if (argp == stackp && a > sizeof (int))
-	{
-	  stackp = (char *) FFI_ALIGN(stackp, a);
-	  argp = stackp;
-	}
-
-      switch (t)
-	{
-	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_INT:
-	case FFI_TYPE_FLOAT:
-	case FFI_TYPE_UINT32:
-	case FFI_TYPE_SINT32:
-	case FFI_TYPE_POINTER:
-	  *(unsigned int *) argp = *(unsigned int *) *p_argv;
-	  break;
-
-	case FFI_TYPE_DOUBLE:
-	case FFI_TYPE_UINT64:
-	case FFI_TYPE_SINT64:
-	case FFI_TYPE_STRUCT:
-	  memcpy (argp, *p_argv, z);
-	  break;
-
-	default:
-	  FFI_ASSERT (0);
-	}
-
-      /* Align if necessary.  */
-      if ((sizeof (int) - 1) & z)
-	z = FFI_ALIGN(z, sizeof (int));
-
-      p_argv++;
-
-      /* Be careful, once all registers are filled, and about to continue
-         on stack, regp == stackp.  Therefore the check for regused as well. */
-      if (argp == (char *)regp && regused < 8)
-	{
-	  regp += z / sizeof (int);
-	  regused += z / sizeof (int);
-	}
-      else
-	stackp += z;
-    }
-
-  return struct_value_ptr;
-}
-
-/* Perform machine dependent cif processing */
-ffi_status
-ffi_prep_cif_machdep (ffi_cif *cif)
-{
-  /* Set the return type flag */
-  switch (cif->rtype->type)
-    {
-    case FFI_TYPE_VOID:
-      cif->flags = 0;
-      break;
-
-    case FFI_TYPE_STRUCT:
-      if (cif->rtype->size == sizeof (int) &&
-	  cif->rtype->alignment == sizeof (int))
-	cif->flags = CIF_FLAGS_INT;
-      else
-	cif->flags = 0;
-      break;
-
-    case FFI_TYPE_DOUBLE:
-    case FFI_TYPE_SINT64:
-    case FFI_TYPE_UINT64:
-      cif->flags = CIF_FLAGS_DINT;
-      break;
-
-    default:
-      cif->flags = CIF_FLAGS_INT;
-      break;
-    }
-
-  return FFI_OK;
-}
-
-void
-ffi_call (ffi_cif *cif, void (*fn) (), void *rvalue, void **avalue)
-{
-  extended_cif ecif;
-
-  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->rtype->type == FFI_TYPE_STRUCT
-      && (cif->rtype->size != sizeof (int)
-	  || cif->rtype->alignment != sizeof (int)))
-    ecif.rvalue = alloca (cif->rtype->size);
-  else
-    ecif.rvalue = rvalue;
-
-  switch (cif->abi)
-    {
-    case FFI_OBSD:
-      ffi_call_OBSD (cif->bytes, &ecif, cif->flags, ecif.rvalue, fn);
-      break;
-
-    default:
-      FFI_ASSERT (0);
-      break;
-    }
-}
-
-/*
- * Closure API
- */
-
-static void
-ffi_prep_closure_args_OBSD (ffi_cif *cif, void **avalue, unsigned int *regp,
-			    char *stackp)
-{
-  unsigned int i;
-  void **p_argv;
-  char *argp;
-  unsigned int regused;
-  ffi_type **p_arg;
-
-  regused = 0;
-
-  p_argv = avalue;
-
-  for (i = cif->nargs, p_arg = cif->arg_types; i != 0; i--, p_arg++)
-    {
-      size_t z;
-      unsigned short t, a;
-
-      z = (*p_arg)->size;
-      t = (*p_arg)->type;
-      a = (*p_arg)->alignment;
-
-      /*
-       * Figure out whether the argument has been passed through registers
-       * or on the stack.
-       * The rule is that registers can only receive simple types not larger
-       * than 64 bits, or structs the exact size of a register and aligned to
-       * the size of a register.
-       */
-      if (t == FFI_TYPE_STRUCT)
-	{
-	  if (z == sizeof (int) && a == sizeof (int) && regused < 8)
-	    argp = (char *)regp;
-	  else
-	    argp = stackp;
-	}
-      else
-	{
-	  if (z > sizeof (int) && regused < 8 - 1)
-	    {
-	      /* align to an even register pair */
-	      if (regused & 1)
-		{
-		  regp++;
-		  regused++;
-		}
-	    }
-	  if (regused < 8)
-	    argp = (char *)regp;
-	  else
-	    argp = stackp;
-	}
-
-      /* Enforce proper stack alignment of 64-bit types */
-      if (argp == stackp && a > sizeof (int))
-	{
-	  stackp = (char *) FFI_ALIGN(stackp, a);
-	  argp = stackp;
-	}
-
-      if (z < sizeof (int) && t != FFI_TYPE_STRUCT)
-	*p_argv = (void *) (argp + sizeof (int) - z);
-      else
-	*p_argv = (void *) argp;
-
-      /* Align if necessary */
-      if ((sizeof (int) - 1) & z)
-	z = FFI_ALIGN(z, sizeof (int));
-
-      p_argv++;
-
-      /* Be careful, once all registers are exhausted, and about to fetch from
-	 stack, regp == stackp.  Therefore the check for regused as well. */
-      if (argp == (char *)regp && regused < 8)
-	{
-	  regp += z / sizeof (int);
-	  regused += z / sizeof (int);
-	}
-      else
-	stackp += z;
-    }
-}
-
-unsigned int
-ffi_closure_OBSD_inner (ffi_closure *closure, void *resp, unsigned int *regp,
-			char *stackp)
-{
-  ffi_cif *cif;
-  void **arg_area;
-
-  cif = closure->cif;
-  arg_area = (void**) alloca (cif->nargs * sizeof (void *));
-
-  ffi_prep_closure_args_OBSD(cif, arg_area, regp, stackp);
-
-  (closure->fun) (cif, resp, arg_area, closure->user_data);
-
-  return cif->flags;
-}
-
-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 *) codeloc;
-  void *fn;
-
-  FFI_ASSERT (cif->abi == FFI_OBSD);
-
-  if (cif->rtype->type == FFI_TYPE_STRUCT && !cif->flags)
-    fn = &ffi_closure_struct_OBSD;
-  else
-    fn = &ffi_closure_OBSD;
-
-  /* or.u %r10, %r0, %hi16(fn) */
-  tramp[0] = 0x5d400000 | (((unsigned int)fn) >> 16);
-  /* or.u %r13, %r0, %hi16(closure) */
-  tramp[1] = 0x5da00000 | ((unsigned int)closure >> 16);
-  /* or %r10, %r10, %lo16(fn) */
-  tramp[2] = 0x594a0000 | (((unsigned int)fn) & 0xffff);
-  /* jmp.n %r10 */
-  tramp[3] = 0xf400c40a;
-  /* or %r13, %r13, %lo16(closure) */
-  tramp[4] = 0x59ad0000 | ((unsigned int)closure & 0xffff);
-
-  ffi_cacheflush_OBSD((unsigned int)codeloc, FFI_TRAMPOLINE_SIZE);
-
-  closure->cif  = cif;
-  closure->user_data = user_data;
-  closure->fun  = fun;
-
-  return FFI_OK;
-}

data/vendor/bundle/ruby/3.2.0/gems/ffi-1.16.3/ext/ffi_c/libffi/src/m88k/ffitarget.h

@@ -1,49 +0,0 @@
-/*
- * Copyright (c) 2013 Miodrag Vallat.  <miod@openbsd.org>
- *
- * 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.
- */
-
-/*
- * m88k Foreign Function Interface
- */
-
-#ifndef LIBFFI_TARGET_H
-#define LIBFFI_TARGET_H
-
-#ifndef LIBFFI_ASM
-typedef unsigned long ffi_arg;
-typedef signed long ffi_sarg;
-
-typedef enum ffi_abi {
-  FFI_FIRST_ABI = 0,
-  FFI_OBSD,
-  FFI_DEFAULT_ABI = FFI_OBSD,
-  FFI_LAST_ABI = FFI_DEFAULT_ABI + 1
-} ffi_abi;
-#endif
-
-/* ---- Definitions for closures ----------------------------------------- */
-
-#define FFI_CLOSURES 1
-#define FFI_TRAMPOLINE_SIZE 0x14
-#define FFI_NATIVE_RAW_API 0
-
-#endif

data/vendor/bundle/ruby/3.2.0/gems/ffi-1.16.3/ext/ffi_c/libffi/src/m88k/obsd.S

@@ -1,209 +0,0 @@
-/*
- * Copyright (c) 2013 Miodrag Vallat.  <miod@openbsd.org>
- *
- * 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.
- */
-
-/*
- * m88k Foreign Function Interface
- */
-
-#define LIBFFI_ASM	
-#include <fficonfig.h>
-#include <ffi.h>
-
-	.text
-
-/*
- * ffi_cacheflush_OBSD(unsigned int addr,	%r2
- *		       unsigned int size);	%r3
- */
-	.align	4
-	.globl	ffi_cacheflush_OBSD
-	.type	ffi_cacheflush_OBSD,@function
-ffi_cacheflush_OBSD:
-	tb0	0,   %r0, 451
-	or	%r0, %r0, %r0
-	jmp	%r1
-	.size	ffi_cacheflush_OBSD, . - ffi_cacheflush_OBSD
-
-/*
- * ffi_call_OBSD(unsigned bytes,		%r2
- *		 extended_cif *ecif,		%r3
- *		 unsigned flags,		%r4
- *		 void *rvalue,			%r5
- *		 void (*fn)());			%r6
- */
-	.align	4
-	.globl	ffi_call_OBSD
-	.type	ffi_call_OBSD,@function
-ffi_call_OBSD:
-	subu	%r31, %r31, 32
-	st	%r30, %r31, 4
-	st	%r1,  %r31, 0
-	addu	%r30, %r31, 32
-
-	| Save the few arguments we'll need after ffi_prep_args()
-	st.d	%r4, %r31, 8
-	st	%r6, %r31, 16
-
-	| Allocate room for the image of r2-r9, and the stack space for
-	| the args (rounded to a 16-byte boundary)
-	addu	%r2,  %r2,  (8 * 4) + 15
-	clr	%r2,  %r2,  4<0>
-	subu	%r31, %r31, %r2
-
-	| Fill register and stack image
-	or	%r2, %r31, %r0
-#ifdef PIC
-	bsr	ffi_prep_args#plt
-#else
-	bsr	ffi_prep_args
-#endif
-
-	| Save pointer to return struct address, if any
-	or	%r12, %r2, %r0
-
-	| Get function pointer
-	subu	%r4,  %r30, 32
-	ld	%r1,  %r4,  16
-
-	| Fetch the register arguments
-	ld.d	%r2, %r31, (0 * 4)
-	ld.d	%r4, %r31, (2 * 4)
-	ld.d	%r6, %r31, (4 * 4)
-	ld.d	%r8, %r31, (6 * 4)
-	addu	%r31, %r31, (8 * 4)
-
-	| Invoke the function
-	jsr	%r1
-
-	| Restore stack now that we don't need the args anymore
-	subu	%r31, %r30, 32
-
-	| Figure out what to return as the function's return value
-	ld	%r5, %r31, 12		| rvalue
-	ld	%r4, %r31, 8		| flags
-
-	bcnd	eq0, %r5, 9f
-
-	bb0	0, %r4, 1f		| CIF_FLAGS_INT
-	st	%r2, %r5, 0
-	br	9f
-
-1:
-	bb0	1, %r4, 1f		| CIF_FLAGS_DINT
-	st.d	%r2, %r5, 0
-	br	9f
-
-1:
-9:
-	ld	%r1,  %r31, 0
-	ld	%r30, %r31, 4
-	jmp.n	%r1
-	 addu	%r31, %r31, 32
-	.size	ffi_call_OBSD, . - ffi_call_OBSD
-
-/*
- * ffi_closure_OBSD(ffi_closure *closure);	%r13
- */
-	.align	4
-	.globl	ffi_closure_OBSD
-	.type	ffi_closure_OBSD, @function
-ffi_closure_OBSD:
-	subu	%r31, %r31, 16
-	st	%r30, %r31, 4
-	st	%r1,  %r31, 0
-	addu	%r30, %r31, 16
-
-	| Make room on the stack for saved register arguments and return
-	| value
-	subu	%r31, %r31, (8 * 4) + (2 * 4)
-	st.d	%r2,  %r31, (0 * 4)
-	st.d	%r4,  %r31, (2 * 4)
-	st.d	%r6,  %r31, (4 * 4)
-	st.d	%r8,  %r31, (6 * 4)
-
-	| Invoke the closure function
-	or	%r5,  %r30, 0			| calling stack
-	addu	%r4,  %r31, 0			| saved registers
-	addu	%r3,  %r31, (8 * 4)		| return value
-	or	%r2,  %r13, %r0			| closure
-#ifdef PIC
-	bsr	ffi_closure_OBSD_inner#plt
-#else
-	bsr	ffi_closure_OBSD_inner
-#endif
-
-	| Figure out what to return as the function's return value
-	bb0	0, %r2, 1f		| CIF_FLAGS_INT
-	ld	%r2, %r31, (8 * 4)
-	br	9f
-
-1:
-	bb0	1, %r2, 1f		| CIF_FLAGS_DINT
-	ld.d	%r2, %r31, (8 * 4)
-	br	9f
-
-1:
-9:
-	subu	%r31, %r30, 16
-	ld	%r1,  %r31, 0
-	ld	%r30, %r31, 4
-	jmp.n	%r1
-	 addu	%r31, %r31, 16
-	.size	ffi_closure_OBSD,.-ffi_closure_OBSD
-
-/*
- * ffi_closure_struct_OBSD(ffi_closure *closure);	%r13
- */
-	.align	4
-	.globl	ffi_closure_struct_OBSD
-	.type	ffi_closure_struct_OBSD, @function
-ffi_closure_struct_OBSD:
-	subu	%r31, %r31, 16
-	st	%r30, %r31, 4
-	st	%r1,  %r31, 0
-	addu	%r30, %r31, 16
-
-	| Make room on the stack for saved register arguments
-	subu	%r31, %r31, (8 * 4)
-	st.d	%r2,  %r31, (0 * 4)
-	st.d	%r4,  %r31, (2 * 4)
-	st.d	%r6,  %r31, (4 * 4)
-	st.d	%r8,  %r31, (6 * 4)
-
-	| Invoke the closure function
-	or	%r5,  %r30, 0			| calling stack
-	addu	%r4,  %r31, 0			| saved registers
-	or	%r3,  %r12, 0			| return value
-	or	%r2,  %r13, %r0			| closure
-#ifdef PIC
-	bsr	ffi_closure_OBSD_inner#plt
-#else
-	bsr	ffi_closure_OBSD_inner
-#endif
-
-	subu	%r31, %r30, 16
-	ld	%r1,  %r31, 0
-	ld	%r30, %r31, 4
-	jmp.n	%r1
-	 addu	%r31, %r31, 16
-	.size	ffi_closure_struct_OBSD,.-ffi_closure_struct_OBSD