cybrid_api_organization_ruby 0.94.31 → 0.94.33

data/vendor/bundle/ruby/3.2.0/gems/ffi-1.15.5/ext/ffi_c/libffi/src/x86/win64.S

@@ -1,241 +0,0 @@
-#ifdef __x86_64__
-#define LIBFFI_ASM
-#include <fficonfig.h>
-#include <ffi.h>
-#include <ffi_cfi.h>
-#include "asmnames.h"
-
-#if defined(HAVE_AS_CFI_PSEUDO_OP)
-        .cfi_sections   .debug_frame
-#endif
-
-#ifdef X86_WIN64
-#define SEH(...) __VA_ARGS__
-#define arg0	%rcx
-#define arg1	%rdx
-#define arg2	%r8
-#define arg3	%r9
-#else
-#define SEH(...)
-#define arg0	%rdi
-#define arg1	%rsi
-#define arg2	%rdx
-#define arg3	%rcx
-#endif
-
-/* This macro allows the safe creation of jump tables without an
-   actual table.  The entry points into the table are all 8 bytes.
-   The use of ORG asserts that we're at the correct location.  */
-/* ??? The clang assembler doesn't handle .org with symbolic expressions.  */
-#if defined(__clang__) || defined(__APPLE__) || (defined (__sun__) && defined(__svr4__))
-# define E(BASE, X)	.balign 8
-#else
-# define E(BASE, X)	.balign 8; .org BASE + (X) * 8
-#endif
-
-	.text
-
-/* ffi_call_win64 (void *stack, struct win64_call_frame *frame, void *r10)
-
-   Bit o trickiness here -- FRAME is the base of the stack frame
-   for this function.  This has been allocated by ffi_call.  We also
-   deallocate some of the stack that has been alloca'd.  */
-
-	.align	8
-	.globl	C(ffi_call_win64)
-	FFI_HIDDEN(C(ffi_call_win64))
-
-	SEH(.seh_proc ffi_call_win64)
-C(ffi_call_win64):
-	cfi_startproc
-	_CET_ENDBR
-	/* Set up the local stack frame and install it in rbp/rsp.  */
-	movq	(%rsp), %rax
-	movq	%rbp, (arg1)
-	movq	%rax, 8(arg1)
-	movq	arg1, %rbp
-	cfi_def_cfa(%rbp, 16)
-	cfi_rel_offset(%rbp, 0)
-	SEH(.seh_pushreg %rbp)
-	SEH(.seh_setframe %rbp, 0)
-	SEH(.seh_endprologue)
-	movq	arg0, %rsp
-
-	movq	arg2, %r10
-
-	/* Load all slots into both general and xmm registers.  */
-	movq	(%rsp), %rcx
-	movsd	(%rsp), %xmm0
-	movq	8(%rsp), %rdx
-	movsd	8(%rsp), %xmm1
-	movq	16(%rsp), %r8
-	movsd	16(%rsp), %xmm2
-	movq	24(%rsp), %r9
-	movsd	24(%rsp), %xmm3
-
-	call	*16(%rbp)
-
-	movl	24(%rbp), %ecx
-	movq	32(%rbp), %r8
-	leaq	0f(%rip), %r10
-	cmpl	$FFI_TYPE_SMALL_STRUCT_4B, %ecx
-	leaq	(%r10, %rcx, 8), %r10
-	ja	99f
-	_CET_NOTRACK jmp *%r10
-
-/* Below, we're space constrained most of the time.  Thus we eschew the
-   modern "mov, pop, ret" sequence (5 bytes) for "leave, ret" (2 bytes).  */
-.macro epilogue
-	leaveq
-	cfi_remember_state
-	cfi_def_cfa(%rsp, 8)
-	cfi_restore(%rbp)
-	ret
-	cfi_restore_state
-.endm
-
-	.align	8
-0:
-E(0b, FFI_TYPE_VOID)
-	epilogue
-E(0b, FFI_TYPE_INT)
-	movslq	%eax, %rax
-	movq	%rax, (%r8)
-	epilogue
-E(0b, FFI_TYPE_FLOAT)
-	movss	%xmm0, (%r8)
-	epilogue
-E(0b, FFI_TYPE_DOUBLE)
-	movsd	%xmm0, (%r8)
-	epilogue
-// FFI_TYPE_LONGDOUBLE may be FFI_TYPE_DOUBLE but we need a different value here.
-E(0b, FFI_TYPE_DOUBLE + 1)
-	call	PLT(C(abort))
-E(0b, FFI_TYPE_UINT8)
-	movzbl	%al, %eax
-	movq	%rax, (%r8)
-	epilogue
-E(0b, FFI_TYPE_SINT8)
-	movsbq	%al, %rax
-	jmp	98f
-E(0b, FFI_TYPE_UINT16)
-	movzwl	%ax, %eax
-	movq	%rax, (%r8)
-	epilogue
-E(0b, FFI_TYPE_SINT16)
-	movswq	%ax, %rax
-	jmp	98f
-E(0b, FFI_TYPE_UINT32)
-	movl	%eax, %eax
-	movq	%rax, (%r8)
-	epilogue
-E(0b, FFI_TYPE_SINT32)
-	movslq	%eax, %rax
-	movq	%rax, (%r8)
-	epilogue
-E(0b, FFI_TYPE_UINT64)
-98:	movq	%rax, (%r8)
-	epilogue
-E(0b, FFI_TYPE_SINT64)
-	movq	%rax, (%r8)
-	epilogue
-E(0b, FFI_TYPE_STRUCT)
-	epilogue
-E(0b, FFI_TYPE_POINTER)
-	movq	%rax, (%r8)
-	epilogue
-E(0b, FFI_TYPE_COMPLEX)
-	call	PLT(C(abort))
-E(0b, FFI_TYPE_SMALL_STRUCT_1B)
-	movb	%al, (%r8)
-	epilogue
-E(0b, FFI_TYPE_SMALL_STRUCT_2B)
-	movw	%ax, (%r8)
-	epilogue
-E(0b, FFI_TYPE_SMALL_STRUCT_4B)
-	movl	%eax, (%r8)
-	epilogue
-
-	.align	8
-99:	call	PLT(C(abort))
-
-	epilogue
-
-	cfi_endproc
-	SEH(.seh_endproc)
-
-
-/* 32 bytes of outgoing register stack space, 8 bytes of alignment,
-   16 bytes of result, 32 bytes of xmm registers.  */
-#define ffi_clo_FS	(32+8+16+32)
-#define ffi_clo_OFF_R	(32+8)
-#define ffi_clo_OFF_X	(32+8+16)
-
-	.align	8
-	.globl	C(ffi_go_closure_win64)
-	FFI_HIDDEN(C(ffi_go_closure_win64))
-
-	SEH(.seh_proc ffi_go_closure_win64)
-C(ffi_go_closure_win64):
-	cfi_startproc
-	_CET_ENDBR
-	/* Save all integer arguments into the incoming reg stack space.  */
-	movq	%rcx, 8(%rsp)
-	movq	%rdx, 16(%rsp)
-	movq	%r8, 24(%rsp)
-	movq	%r9, 32(%rsp)
-
-	movq	8(%r10), %rcx			/* load cif */
-	movq	16(%r10), %rdx			/* load fun */
-	movq	%r10, %r8			/* closure is user_data */
-	jmp	0f
-	cfi_endproc
-	SEH(.seh_endproc)
-
-	.align	8
-	.globl	C(ffi_closure_win64)
-	FFI_HIDDEN(C(ffi_closure_win64))
-
-	SEH(.seh_proc ffi_closure_win64)
-C(ffi_closure_win64):
-	cfi_startproc
-	_CET_ENDBR
-	/* Save all integer arguments into the incoming reg stack space.  */
-	movq	%rcx, 8(%rsp)
-	movq	%rdx, 16(%rsp)
-	movq	%r8, 24(%rsp)
-	movq	%r9, 32(%rsp)
-
-	movq	FFI_TRAMPOLINE_SIZE(%r10), %rcx		/* load cif */
-	movq	FFI_TRAMPOLINE_SIZE+8(%r10), %rdx	/* load fun */
-	movq	FFI_TRAMPOLINE_SIZE+16(%r10), %r8	/* load user_data */
-0:
-	subq	$ffi_clo_FS, %rsp
-	cfi_adjust_cfa_offset(ffi_clo_FS)
-	SEH(.seh_stackalloc ffi_clo_FS)
-	SEH(.seh_endprologue)
-
-	/* Save all sse arguments into the stack frame.  */
-	movsd	%xmm0, ffi_clo_OFF_X(%rsp)
-	movsd	%xmm1, ffi_clo_OFF_X+8(%rsp)
-	movsd	%xmm2, ffi_clo_OFF_X+16(%rsp)
-	movsd	%xmm3, ffi_clo_OFF_X+24(%rsp)
-
-	leaq	ffi_clo_OFF_R(%rsp), %r9
-	call	PLT(C(ffi_closure_win64_inner))
-
-	/* Load the result into both possible result registers.  */
-	movq    ffi_clo_OFF_R(%rsp), %rax
-	movsd   ffi_clo_OFF_R(%rsp), %xmm0
-
-	addq	$ffi_clo_FS, %rsp
-	cfi_adjust_cfa_offset(-ffi_clo_FS)
-	ret
-
-	cfi_endproc
-	SEH(.seh_endproc)
-#endif /* __x86_64__ */
-
-#if defined __ELF__ && defined __linux__
-	.section	.note.GNU-stack,"",@progbits
-#endif

data/vendor/bundle/ruby/3.2.0/gems/ffi-1.15.5/ext/ffi_c/libffi/src/xtensa/ffi.c

@@ -1,298 +0,0 @@
-/* -----------------------------------------------------------------------
-   ffi.c - Copyright (c) 2013 Tensilica, Inc.
-
-   XTENSA 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>
-
-/*
-                                 |----------------------------------------|
-                                 |                                        |
-    on entry to ffi_call ---->   |----------------------------------------|
-                                 | caller stack frame for registers a0-a3 |
-                                 |----------------------------------------|
-                                 |                                        |
-                                 |         additional arguments           |
-    entry of the function --->   |----------------------------------------|
-                                 |    copy of function arguments a2-a7    |
-                                 | -  -  -  -  -  -  -  -  -  -  -  -  -  |
-                                 |                                        |
-
-    The area below the entry line becomes the new stack frame for the function.
-
-*/
-
-
-#define FFI_TYPE_STRUCT_REGS FFI_TYPE_LAST
-
-
-extern void ffi_call_SYSV(void *rvalue, unsigned rsize, unsigned flags,
-			  void(*fn)(void), unsigned nbytes, extended_cif*);
-extern void ffi_closure_SYSV(void) FFI_HIDDEN;
-
-ffi_status ffi_prep_cif_machdep(ffi_cif *cif)
-{
-  switch(cif->rtype->type) {
-    case FFI_TYPE_SINT8:
-    case FFI_TYPE_UINT8:
-    case FFI_TYPE_SINT16:
-    case FFI_TYPE_UINT16:
-      cif->flags = cif->rtype->type;
-      break;
-    case FFI_TYPE_VOID:
-    case FFI_TYPE_FLOAT:
-      cif->flags = FFI_TYPE_UINT32;
-      break;
-    case FFI_TYPE_DOUBLE:
-    case FFI_TYPE_UINT64:
-    case FFI_TYPE_SINT64:
-      cif->flags = FFI_TYPE_UINT64; // cif->rtype->type;
-      break;
-    case FFI_TYPE_STRUCT:
-      cif->flags = FFI_TYPE_STRUCT; //_REGS;
-      /* Up to 16 bytes are returned in registers */
-      if (cif->rtype->size > 4 * 4) {
-        /* returned structure is referenced by a register; use 8 bytes
-           (including 4 bytes for potential additional alignment) */
-        cif->flags = FFI_TYPE_STRUCT;	
-        cif->bytes += 8;
-      }
-      break;
-
-    default:
-      cif->flags = FFI_TYPE_UINT32;
-      break;
-  }
-
-  /* Round the stack up to a full 4 register frame, just in case
-     (we use this size in movsp). This way, it's also a  multiple of
-     8 bytes for 64-bit arguments.  */
-  cif->bytes = FFI_ALIGN(cif->bytes, 16);
-
-  return FFI_OK;
-}
-
-void ffi_prep_args(extended_cif *ecif, unsigned char* stack)
-{
-  unsigned int i;
-  unsigned long *addr;
-  ffi_type **ptr;
-
-  union {
-    void **v;
-    char **c;
-    signed char **sc;
-    unsigned char **uc;
-    signed short **ss;
-    unsigned short **us;
-    unsigned int **i;
-    long long **ll;
-    float **f;
-    double **d;
-  } p_argv;
-
-  /* Verify that everything is aligned up properly */
-  FFI_ASSERT (((unsigned long) stack & 0x7) == 0);
-
-  p_argv.v = ecif->avalue;
-  addr = (unsigned long*)stack;
-
-  /* structures with a size greater than 16 bytes are passed in memory */
-  if (ecif->cif->rtype->type == FFI_TYPE_STRUCT && ecif->cif->rtype->size > 16)
-  {
-    *addr++ = (unsigned long)ecif->rvalue;
-  }
-
-  for (i = ecif->cif->nargs, ptr = ecif->cif->arg_types;
-       i > 0;
-       i--, ptr++, p_argv.v++)
-  {
-    switch ((*ptr)->type)
-    {
-      case FFI_TYPE_SINT8:
-        *addr++ = **p_argv.sc;
-        break;
-      case FFI_TYPE_UINT8:
-        *addr++ = **p_argv.uc;
-        break;
-      case FFI_TYPE_SINT16:
-        *addr++ = **p_argv.ss;
-        break;
-      case FFI_TYPE_UINT16:
-        *addr++ = **p_argv.us;
-        break;
-      case FFI_TYPE_FLOAT:
-      case FFI_TYPE_INT:
-      case FFI_TYPE_UINT32:
-      case FFI_TYPE_SINT32:
-      case FFI_TYPE_POINTER:
-        *addr++ = **p_argv.i;
-        break;
-      case FFI_TYPE_DOUBLE:
-      case FFI_TYPE_UINT64:
-      case FFI_TYPE_SINT64:
-        if (((unsigned long)addr & 4) != 0)
-          addr++;
-        *(unsigned long long*)addr = **p_argv.ll;
-	addr += sizeof(unsigned long long) / sizeof (addr);
-        break;
-
-      case FFI_TYPE_STRUCT:
-      {
-        unsigned long offs;
-        unsigned long size;
-
-        if (((unsigned long)addr & 4) != 0 && (*ptr)->alignment > 4)
-          addr++;
-
-        offs = (unsigned long) addr - (unsigned long) stack;
-        size = (*ptr)->size;
-
-        /* Entire structure must fit the argument registers or referenced */
-        if (offs < FFI_REGISTER_NARGS * 4
-            && offs + size > FFI_REGISTER_NARGS * 4)
-          addr = (unsigned long*) (stack + FFI_REGISTER_NARGS * 4);
-
-        memcpy((char*) addr, *p_argv.c, size);
-        addr += (size + 3) / 4;
-        break;
-      }
-
-      default:
-        FFI_ASSERT(0);
-    }
-  }
-}
-
-
-void ffi_call(ffi_cif* cif, void(*fn)(void), void *rvalue, void **avalue)
-{
-  extended_cif ecif;
-  unsigned long rsize = cif->rtype->size;
-  int flags = cif->flags;
-  void *alloc = NULL;
-
-  ecif.cif = cif;
-  ecif.avalue = avalue;
-
-  /* Note that for structures that are returned in registers (size <= 16 bytes)
-     we allocate a temporary buffer and use memcpy to copy it to the final 
-     destination. The reason is that the target address might be misaligned or
-     the length not a multiple of 4 bytes. Handling all those cases would be
-     very complex.  */
-
-  if (flags == FFI_TYPE_STRUCT && (rsize <= 16 || rvalue == NULL))
-  {
-    alloc = alloca(FFI_ALIGN(rsize, 4));
-    ecif.rvalue = alloc;
-  }
-  else
-  {
-    ecif.rvalue = rvalue;
-  }
-
-  if (cif->abi != FFI_SYSV)
-    FFI_ASSERT(0);
-
-  ffi_call_SYSV (ecif.rvalue, rsize, cif->flags, fn, cif->bytes, &ecif);
-
-  if (alloc != NULL && rvalue != NULL)
-    memcpy(rvalue, alloc, rsize);
-}
-
-extern void ffi_trampoline();
-extern void ffi_cacheflush(void* start, void* end);
-
-ffi_status
-ffi_prep_closure_loc (ffi_closure* closure,
-                      ffi_cif* cif,
-                      void (*fun)(ffi_cif*, void*, void**, void*),
-                      void *user_data,
-                      void *codeloc)
-{
-  /* copye trampoline to stack and patch 'ffi_closure_SYSV' pointer */
-  memcpy(closure->tramp, ffi_trampoline, FFI_TRAMPOLINE_SIZE);
-  *(unsigned int*)(&closure->tramp[8]) = (unsigned int)ffi_closure_SYSV;
-
-  // Do we have this function?
-  // __builtin___clear_cache(closer->tramp, closer->tramp + FFI_TRAMPOLINE_SIZE)
-  ffi_cacheflush(closure->tramp, closure->tramp + FFI_TRAMPOLINE_SIZE);
-
-  closure->cif = cif;
-  closure->fun = fun;
-  closure->user_data = user_data;
-  return FFI_OK; 
-}
-
-
-long FFI_HIDDEN
-ffi_closure_SYSV_inner(ffi_closure *closure, void **values, void *rvalue)
-{
-  ffi_cif *cif;
-  ffi_type **arg_types;
-  void **avalue;
-  int i, areg;
-
-  cif = closure->cif;
-  if (cif->abi != FFI_SYSV)
-    return FFI_BAD_ABI;
-
-  areg = 0;
-
-  int rtype = cif->rtype->type;
-  if (rtype == FFI_TYPE_STRUCT && cif->rtype->size > 4 * 4)
-  {
-    rvalue = *values;
-    areg++;
-  }
-
-  cif = closure->cif; 
-  arg_types = cif->arg_types;
-  avalue = alloca(cif->nargs * sizeof(void *));
-
-  for (i = 0; i < cif->nargs; i++)
-  {
-    if (arg_types[i]->alignment == 8 && (areg & 1) != 0)
-      areg++;
-
-    // skip the entry 16,a1 framework, add 16 bytes (4 registers)
-    if (areg == FFI_REGISTER_NARGS)
-      areg += 4;
-
-    if (arg_types[i]->type == FFI_TYPE_STRUCT)
-    {
-      int numregs = ((arg_types[i]->size + 3) & ~3) / 4;
-      if (areg < FFI_REGISTER_NARGS && areg + numregs > FFI_REGISTER_NARGS)
-        areg = FFI_REGISTER_NARGS + 4;
-    }
-
-    avalue[i] = &values[areg];
-    areg += (arg_types[i]->size + 3) / 4;
-  }
-
-  (closure->fun)(cif, rvalue, avalue, closure->user_data);
-
-  return rtype;
-}

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

@@ -1,53 +0,0 @@
-/* -----------------------------------------------------------------*-C-*-
-   ffitarget.h - Copyright (c) 2013 Tensilica, Inc.
-   Target configuration macros for XTENSA.
-
-   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
-
-#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_REGISTER_NARGS	6
-
-/* ---- Definitions for closures ----------------------------------------- */
-
-#define FFI_CLOSURES 1
-#define FFI_NATIVE_RAW_API 0
-#define FFI_TRAMPOLINE_SIZE 24
-
-#endif