approveapi 1.0.5 → 1.0.6

data/vendor/bundle/ruby/2.6.0/gems/ffi-1.10.0/ext/ffi_c/libffi/src/tile/ffitarget.h

@@ -1,65 +0,0 @@
-/* -----------------------------------------------------------------*-C-*-
-   ffitarget.h - Copyright (c) 2012 Tilera Corp.
-   Target configuration macros for TILE.
-
-   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
-
-#include <arch/abi.h>
-
-typedef uint_reg_t ffi_arg;
-typedef int_reg_t  ffi_sarg;
-
-typedef enum ffi_abi {
-  FFI_FIRST_ABI = 0,
-  FFI_UNIX,
-  FFI_LAST_ABI,
-  FFI_DEFAULT_ABI = FFI_UNIX
-} ffi_abi;
-#endif
-
-/* ---- Definitions for closures ----------------------------------------- */
-#define FFI_CLOSURES 1
-
-#ifdef __tilegx__
-/* We always pass 8-byte values, even in -m32 mode. */
-# define FFI_SIZEOF_ARG 8
-# ifdef __LP64__
-#  define FFI_TRAMPOLINE_SIZE (8 * 5)  /* 5 bundles */
-# else
-#  define FFI_TRAMPOLINE_SIZE (8 * 3)  /* 3 bundles */
-# endif
-#else
-# define FFI_SIZEOF_ARG 4
-# define FFI_TRAMPOLINE_SIZE 8 /* 1 bundle */
-#endif
-#define FFI_NATIVE_RAW_API 0
-
-#endif

data/vendor/bundle/ruby/2.6.0/gems/ffi-1.10.0/ext/ffi_c/libffi/src/tile/tile.S

@@ -1,360 +0,0 @@
-/* -----------------------------------------------------------------------
-   tile.S - Copyright (c) 2011 Tilera Corp.
-
-   Tilera TILEPro and TILE-Gx 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.
-   ----------------------------------------------------------------------- */
-
-#define LIBFFI_ASM
-#include <fficonfig.h>
-#include <ffi.h>
-
-/* Number of bytes in a register. */
-#define REG_SIZE FFI_SIZEOF_ARG
-
-/* Number of bytes in stack linkage area for backtracing.
-
-   A note about the ABI: on entry to a procedure, sp points to a stack
-   slot where it must spill the return address if it's not a leaf.
-   REG_SIZE bytes beyond that is a slot owned by the caller which
-   contains the sp value that the caller had when it was originally
-   entered (i.e. the caller's frame pointer). */
-#define LINKAGE_SIZE (2 * REG_SIZE)
-
-/* The first 10 registers are used to pass arguments and return values. */
-#define NUM_ARG_REGS 10
-
-#ifdef __tilegx__
-#define SW st
-#define LW ld
-#define BGZT bgtzt
-#else
-#define SW sw
-#define LW lw
-#define BGZT bgzt
-#endif
-
-
-/* void ffi_call_tile (int_reg_t reg_args[NUM_ARG_REGS],
-                       const int_reg_t *stack_args,
-                       unsigned long stack_args_bytes,
-                       void (*fnaddr)(void));
-
-        On entry, REG_ARGS contain the outgoing register values,
-        and STACK_ARGS contains STACK_ARG_BYTES of additional values
-        to be passed on the stack. If STACK_ARG_BYTES is zero, then
-        STACK_ARGS is ignored.
-
-        When the invoked function returns, the values of r0-r9 are
-        blindly stored back into REG_ARGS for the caller to examine. */
-
-        .section .text.ffi_call_tile, "ax", @progbits
-        .align  8
-        .globl  ffi_call_tile
-        FFI_HIDDEN(ffi_call_tile)
-ffi_call_tile:
-
-/* Incoming arguments. */
-#define REG_ARGS                r0
-#define INCOMING_STACK_ARGS     r1
-#define STACK_ARG_BYTES         r2
-#define ORIG_FNADDR             r3
-
-/* Temporary values. */
-#define FRAME_SIZE              r10
-#define TMP                     r11
-#define TMP2                    r12
-#define OUTGOING_STACK_ARGS     r13
-#define REG_ADDR_PTR            r14
-#define RETURN_REG_ADDR         r15
-#define FNADDR                  r16
-
-        .cfi_startproc
-        {
-         /* Save return address. */
-         SW     sp, lr
-         .cfi_offset lr, 0
-         /* Prepare to spill incoming r52. */
-         addi   TMP, sp, -REG_SIZE
-         /* Increase frame size to have room to spill r52 and REG_ARGS.
-            The +7 is to round up mod 8. */
-         addi   FRAME_SIZE, STACK_ARG_BYTES, \
-                REG_SIZE + REG_SIZE + LINKAGE_SIZE + 7
-        }
-        {
-         /* Round stack frame size to a multiple of 8 to satisfy ABI. */
-         andi   FRAME_SIZE, FRAME_SIZE, -8
-         /* Compute where to spill REG_ARGS value. */
-         addi   TMP2, sp, -(REG_SIZE * 2)
-        }
-        {
-         /* Spill incoming r52. */
-         SW     TMP, r52
-         .cfi_offset r52, -REG_SIZE
-         /* Set up our frame pointer. */
-         move   r52, sp
-         .cfi_def_cfa_register r52
-         /* Push stack frame. */
-         sub    sp, sp, FRAME_SIZE
-        }
-        {
-         /* Prepare to set up stack linkage. */
-         addi   TMP, sp, REG_SIZE
-         /* Prepare to memcpy stack args. */
-         addi   OUTGOING_STACK_ARGS, sp, LINKAGE_SIZE
-         /* Save REG_ARGS which we will need after we call the subroutine. */
-         SW     TMP2, REG_ARGS
-        }
-        {
-         /* Set up linkage info to hold incoming stack pointer. */
-         SW     TMP, r52
-        }
-        {
-         /* Skip stack args memcpy if we don't have any stack args (common). */
-         blezt  STACK_ARG_BYTES, .Ldone_stack_args_memcpy
-        }
-
-.Lmemcpy_stack_args:
-        {
-         /* Load incoming argument from stack_args. */
-         LW     TMP, INCOMING_STACK_ARGS
-         addi   INCOMING_STACK_ARGS, INCOMING_STACK_ARGS, REG_SIZE
-        }
-        {
-         /* Store stack argument into outgoing stack argument area. */
-         SW     OUTGOING_STACK_ARGS, TMP
-         addi   OUTGOING_STACK_ARGS, OUTGOING_STACK_ARGS, REG_SIZE
-         addi   STACK_ARG_BYTES, STACK_ARG_BYTES, -REG_SIZE
-        }
-        {
-         BGZT   STACK_ARG_BYTES, .Lmemcpy_stack_args
-        }
-.Ldone_stack_args_memcpy:
-
-        {
-         /* Copy aside ORIG_FNADDR so we can overwrite its register. */
-         move   FNADDR, ORIG_FNADDR
-         /* Prepare to load argument registers. */
-         addi   REG_ADDR_PTR, r0, REG_SIZE
-         /* Load outgoing r0. */
-         LW     r0, r0
-        }
-
-        /* Load up argument registers from the REG_ARGS array. */
-#define LOAD_REG(REG, PTR) \
-        { \
-         LW     REG, PTR ; \
-         addi   PTR, PTR, REG_SIZE \
-        }
-
-        LOAD_REG(r1, REG_ADDR_PTR)
-        LOAD_REG(r2, REG_ADDR_PTR)
-        LOAD_REG(r3, REG_ADDR_PTR)
-        LOAD_REG(r4, REG_ADDR_PTR)
-        LOAD_REG(r5, REG_ADDR_PTR)
-        LOAD_REG(r6, REG_ADDR_PTR)
-        LOAD_REG(r7, REG_ADDR_PTR)
-        LOAD_REG(r8, REG_ADDR_PTR)
-        LOAD_REG(r9, REG_ADDR_PTR)
-
-        {
-         /* Call the subroutine. */
-         jalr   FNADDR
-        }
-
-        {
-         /* Restore original lr. */
-         LW     lr, r52
-         /* Prepare to recover ARGS, which we spilled earlier. */
-         addi   TMP, r52, -(2 * REG_SIZE)
-        }
-        {
-         /* Restore ARGS, so we can fill it in with the return regs r0-r9. */
-         LW     RETURN_REG_ADDR, TMP
-         /* Prepare to restore original r52. */
-         addi   TMP, r52, -REG_SIZE
-        }
-
-        {
-         /* Pop stack frame. */
-         move   sp, r52
-         /* Restore original r52. */
-         LW     r52, TMP
-        }
-
-#define STORE_REG(REG, PTR) \
-        { \
-         SW     PTR, REG ; \
-         addi   PTR, PTR, REG_SIZE \
-        }
-
-        /* Return all register values by reference. */
-        STORE_REG(r0, RETURN_REG_ADDR)
-        STORE_REG(r1, RETURN_REG_ADDR)
-        STORE_REG(r2, RETURN_REG_ADDR)
-        STORE_REG(r3, RETURN_REG_ADDR)
-        STORE_REG(r4, RETURN_REG_ADDR)
-        STORE_REG(r5, RETURN_REG_ADDR)
-        STORE_REG(r6, RETURN_REG_ADDR)
-        STORE_REG(r7, RETURN_REG_ADDR)
-        STORE_REG(r8, RETURN_REG_ADDR)
-        STORE_REG(r9, RETURN_REG_ADDR)
-
-        {
-         jrp    lr
-        }
-
-        .cfi_endproc
-        .size ffi_call_tile, .-ffi_call_tile
-
-/* ffi_closure_tile(...)
-
-   On entry, lr points to the closure plus 8 bytes, and r10
-   contains the actual return address.
-
-   This function simply dumps all register parameters into a stack array
-   and passes the closure, the registers array, and the stack arguments
-   to C code that does all of the actual closure processing. */
-
-        .section .text.ffi_closure_tile, "ax", @progbits
-        .align  8
-        .globl  ffi_closure_tile
-        FFI_HIDDEN(ffi_closure_tile)
-
-        .cfi_startproc
-/* Room to spill all NUM_ARG_REGS incoming registers, plus frame linkage. */
-#define CLOSURE_FRAME_SIZE (((NUM_ARG_REGS * REG_SIZE * 2 + LINKAGE_SIZE) + 7) & -8)
-ffi_closure_tile:
-        {
-#ifdef __tilegx__
-         st     sp, lr
-         .cfi_offset lr, 0
-#else
-         /* Save return address (in r10 due to closure stub wrapper). */
-         SW     sp, r10
-         .cfi_return_column r10
-         .cfi_offset r10, 0
-#endif
-         /* Compute address for stack frame linkage. */
-         addli   r10, sp, -(CLOSURE_FRAME_SIZE - REG_SIZE)
-        }
-        {
-         /* Save incoming stack pointer in linkage area. */
-         SW     r10, sp
-         .cfi_offset sp, -(CLOSURE_FRAME_SIZE - REG_SIZE)
-         /* Push a new stack frame. */
-         addli   sp, sp, -CLOSURE_FRAME_SIZE
-         .cfi_adjust_cfa_offset CLOSURE_FRAME_SIZE
-        }
-
-        {
-         /* Create pointer to where to start spilling registers. */
-         addi   r10, sp, LINKAGE_SIZE
-        }
-
-        /* Spill all the incoming registers. */
-        STORE_REG(r0, r10)
-        STORE_REG(r1, r10)
-        STORE_REG(r2, r10)
-        STORE_REG(r3, r10)
-        STORE_REG(r4, r10)
-        STORE_REG(r5, r10)
-        STORE_REG(r6, r10)
-        STORE_REG(r7, r10)
-        STORE_REG(r8, r10)
-        {
-         /* Save r9. */
-         SW     r10, r9
-#ifdef __tilegx__
-         /* Pointer to closure is passed in r11. */
-         move  r0, r11
-#else
-         /* Compute pointer to the closure object. Because the closure
-            starts with a "jal ffi_closure_tile", we can just take the
-            value of lr (a phony return address pointing into the closure)
-            and subtract 8. */
-         addi   r0, lr, -8
-#endif
-         /* Compute a pointer to the register arguments we just spilled. */
-         addi   r1, sp, LINKAGE_SIZE
-        }
-        {
-         /* Compute a pointer to the extra stack arguments (if any). */
-         addli   r2, sp, CLOSURE_FRAME_SIZE + LINKAGE_SIZE
-         /* Call C code to deal with all of the grotty details. */
-         jal    ffi_closure_tile_inner
-        }
-        {
-         addli   r10, sp, CLOSURE_FRAME_SIZE
-        }
-        {
-         /* Restore the return address. */
-         LW     lr, r10
-         /* Compute pointer to registers array. */
-         addli   r10, sp, LINKAGE_SIZE + (NUM_ARG_REGS * REG_SIZE)
-        }
-        /* Return all the register values, which C code may have set. */
-        LOAD_REG(r0, r10)
-        LOAD_REG(r1, r10)
-        LOAD_REG(r2, r10)
-        LOAD_REG(r3, r10)
-        LOAD_REG(r4, r10)
-        LOAD_REG(r5, r10)
-        LOAD_REG(r6, r10)
-        LOAD_REG(r7, r10)
-        LOAD_REG(r8, r10)
-        LOAD_REG(r9, r10)
-        {
-         /* Pop the frame. */
-         addli   sp, sp, CLOSURE_FRAME_SIZE
-         jrp    lr
-        }
-
-        .cfi_endproc
-        .size   ffi_closure_tile, . - ffi_closure_tile
-
-
-/* What follows are code template instructions that get copied to the
-   closure trampoline by ffi_prep_closure_loc.  The zeroed operands
-   get replaced by their proper values at runtime. */
-
-        .section .text.ffi_template_tramp_tile, "ax", @progbits
-        .align  8
-        .globl  ffi_template_tramp_tile
-        FFI_HIDDEN(ffi_template_tramp_tile)
-ffi_template_tramp_tile:
-#ifdef __tilegx__
-        {
-          moveli r11, 0 /* backpatched to address of containing closure. */
-          moveli r10, 0 /* backpatched to ffi_closure_tile. */
-        }
-        /* Note: the following bundle gets generated multiple times
-           depending on the pointer value (esp. useful for -m32 mode). */
-        { shl16insli r11, r11, 0 ; shl16insli r10, r10, 0 }
-        { info 2+8 /* for backtracer: -> pc in lr, frame size 0 */ ; jr r10 }
-#else
-        /* 'jal .' yields a PC-relative offset of zero so we can OR in the
-           right offset at runtime. */
-        { move r10, lr ; jal . /* ffi_closure_tile */ }
-#endif
-
-        .size   ffi_template_tramp_tile, . - ffi_template_tramp_tile

data/vendor/bundle/ruby/2.6.0/gems/ffi-1.10.0/ext/ffi_c/libffi/src/types.c

@@ -1,108 +0,0 @@
-/* -----------------------------------------------------------------------
-   types.c - Copyright (c) 1996, 1998  Red Hat, Inc.
-   
-   Predefined ffi_types needed by libffi.
-
-   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.
-   ----------------------------------------------------------------------- */
-
-/* Hide the basic type definitions from the header file, so that we
-   can redefine them here as "const".  */
-#define LIBFFI_HIDE_BASIC_TYPES
-
-#include <ffi.h>
-#include <ffi_common.h>
-
-/* Type definitions */
-
-#define FFI_TYPEDEF(name, type, id, maybe_const)\
-struct struct_align_##name {			\
-  char c;					\
-  type x;					\
-};						\
-FFI_EXTERN					\
-maybe_const ffi_type ffi_type_##name = {	\
-  sizeof(type),					\
-  offsetof(struct struct_align_##name, x),	\
-  id, NULL					\
-}
-
-#define FFI_COMPLEX_TYPEDEF(name, type, maybe_const)	\
-static ffi_type *ffi_elements_complex_##name [2] = {	\
-	(ffi_type *)(&ffi_type_##name), NULL		\
-};							\
-struct struct_align_complex_##name {			\
-  char c;						\
-  _Complex type x;					\
-};							\
-FFI_EXTERN						\
-maybe_const ffi_type ffi_type_complex_##name = {	\
-  sizeof(_Complex type),				\
-  offsetof(struct struct_align_complex_##name, x),	\
-  FFI_TYPE_COMPLEX,					\
-  (ffi_type **)ffi_elements_complex_##name		\
-}
-
-/* Size and alignment are fake here. They must not be 0. */
-FFI_EXTERN const ffi_type ffi_type_void = {
-  1, 1, FFI_TYPE_VOID, NULL
-};
-
-FFI_TYPEDEF(uint8, UINT8, FFI_TYPE_UINT8, const);
-FFI_TYPEDEF(sint8, SINT8, FFI_TYPE_SINT8, const);
-FFI_TYPEDEF(uint16, UINT16, FFI_TYPE_UINT16, const);
-FFI_TYPEDEF(sint16, SINT16, FFI_TYPE_SINT16, const);
-FFI_TYPEDEF(uint32, UINT32, FFI_TYPE_UINT32, const);
-FFI_TYPEDEF(sint32, SINT32, FFI_TYPE_SINT32, const);
-FFI_TYPEDEF(uint64, UINT64, FFI_TYPE_UINT64, const);
-FFI_TYPEDEF(sint64, SINT64, FFI_TYPE_SINT64, const);
-
-FFI_TYPEDEF(pointer, void*, FFI_TYPE_POINTER, const);
-
-FFI_TYPEDEF(float, float, FFI_TYPE_FLOAT, const);
-FFI_TYPEDEF(double, double, FFI_TYPE_DOUBLE, const);
-
-#if !defined HAVE_LONG_DOUBLE_VARIANT || defined __alpha__
-#define FFI_LDBL_CONST const
-#else
-#define FFI_LDBL_CONST
-#endif
-
-#ifdef __alpha__
-/* Even if we're not configured to default to 128-bit long double, 
-   maintain binary compatibility, as -mlong-double-128 can be used
-   at any time.  */
-/* Validate the hard-coded number below.  */
-# if defined(__LONG_DOUBLE_128__) && FFI_TYPE_LONGDOUBLE != 4
-#  error FFI_TYPE_LONGDOUBLE out of date
-# endif
-const ffi_type ffi_type_longdouble = { 16, 16, 4, NULL };
-#elif FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
-FFI_TYPEDEF(longdouble, long double, FFI_TYPE_LONGDOUBLE, FFI_LDBL_CONST);
-#endif
-
-#ifdef FFI_TARGET_HAS_COMPLEX_TYPE
-FFI_COMPLEX_TYPEDEF(float, float, const);
-FFI_COMPLEX_TYPEDEF(double, double, const);
-#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
-FFI_COMPLEX_TYPEDEF(longdouble, long double, FFI_LDBL_CONST);
-#endif
-#endif