packaging: pass '--enable-portable-binary' to configure

To fix SIGILL(crashing on vmovd) with AVX inst. enabled

Change-Id: Ie979daf9282984a0a5bc7a3a0bb52ccc5f1125d2
Signed-off-by: Dongkyun Son <dongkyun.s@samsung.com>

Blacklist ffi_call_int for ASan and HWASan build

See:
https://github.com/libffi/libffi/issues/255

Change-Id: Iaa3b738140cd02dd9b5ec1121396a1675ab4f4b3
Signed-off-by: Andrey Kazmin <a.kazmin@partner.samsung.com>

doc: disable info files

Fix "WARNING: 'makeinfo' is missing on your system."

Change-Id: I66492b0ece188f93a35d2f7ffe1a0fc322ecd680
Signed-off-by: Dongkyun Son <dongkyun.s@samsung.com>

Add packaging with v3.4.2

Change-Id: I95cbe89e71086b8b6e7e148dded6313b934310de
Signed-off-by: Dongkyun Son <dongkyun.s@samsung.com>

Update version to 3.4.2

Version 3.4.1

Update version to 3.4.0

Fix warnings

Add missing test cases to distribution

Add tests for single entry structs (#653)

Fix the assertions in cls-24byte (#652)

* Fix the assertions in cls-24byte

* Update print statement too

3.4.0 release candidate 2

Add missing FFI_HIDDEN to ffi_tramp_is_present declaration (#651)

Signed-off-by: Jeremy Huddleston Sequoia <jeremyhu@apple.com>

Print more information when an assertion fails in test suite (#649)

Fix signature of function pointer in cls_dbls_struct (#648)

configure.ac: add --disable-exec-static-tramp flag (#647)

Some projects like GHC (Glasgow Haskell Compiler) and
gobject-introspection use `ffi_closure_alloc()` as a way
to allocate executable memory. exec static tramp
interferes with it (unclear how exactly yet).

GHC symptom: ffi closure freeing cimplains about unexpected
trampoline (GHC manually fills one):

```
$ ghci
GHCi, version 8.10.5: https://www.haskell.org/ghc/  :? for help
ghc: freeHaskellFunctionPtr: not for me, guv! 0x7f0417a1efe8
ghc: freeHaskellFunctionPtr: not for me, guv! 0x7f0417a1efc8
```

gobject-introspection symptom:

```
$ meld
Segmentation fault (core dumped)

$ gdb --args /usr/bin/python3.9 /usr/bin/meld
(gdb) run
...
Thread 1 "python3.9" received signal SIGSEGV, Segmentation fault.
0x00007fffe9ac1ae8 in g_callable_info_free_closure (
  callable_info=0x555555d45990, closure=0x7fffe9e70c20)
    at ../gobject-introspection-1.68.0/girepository/girffi.c:428
428       g_free (wrapper->ffi_closure.cif->arg_types);
(gdb) bt
  callable_info=0x555555d45990, closure=0x7fffe9e70c20)
    at ../gobject-introspection-1.68.0/girepository/girffi.c:428
  data=0x555555d252d0)
    at ../pygobject-3.40.1/gi/pygi-closure.c:635
...
```

To ease downstreams narrowing down the actual problem let's
provide a knob to disable exec static trampolines.

The change for not affect current default.

Signed-off-by: Sergei Trofimovich <slyfox@gentoo.org>

Remove caveat about varargs support

Update contact info

configure.ac: allow user to specify READELF (#646)

Before the change with x86_64-pc-linux-gnu cross-compiler
installed the configure was not able to find cross-readelf:

```
$ ./configure --host=x86_64-pc-linux-gnu
...
checking whether .eh_frame section should be read-only... .././configure: line 19540: readelf: command not found
yes
...
```

The change uses AC_CHECK_TOOL to automatically seatch for ${host}-readelf,
readelf. And as a bonus it also allows user to override readelf with
something like READELF=llvm-readelf.

Signed-off-by: Sergei Trofimovich <slyfox@gentoo.org>

Make 3.4 release candidate 1

Add missing file from make dist.  Add missing license info.

Remove test case

This test includes a closure and must live in the closures test directory. (#645)

Co-authored-by: Matthew Green <squidhacks@users.noreply.github.com>

Make test methods static (#644)

Switch from travis-ci.org to travis-ci.com.

Avoid undefined behaviour

Remove libtool-ldflags file from .gitignore (#600)

This is correct.  Thank you!

2021-06-15  Jakub Jelinek  <jakub@redhat.com>

        * src/x86/ffi64.c (classify_argument): For FFI_TYPE_STRUCT set words
        to number of words needed for type->size + byte_offset bytes rather
        than just type->size bytes.  Compute pos before the loop and check
        total size of the structure.
        * testsuite/libffi.call/nested_struct12.c: New test.

Don't stop test on copy failure (#636)

* Don't stop test on copy failure

Static-library tests were failing only because there were
no DLLs to copy.  This change makes a copy failure not stop
the build; if a failed copy would otherwise be relevent, the
later tests would fail anyway.

While there are more clever ways to solve this, a brute force
fix is sufficient.

* [TEST] Try cygwin64; install more packages explicitly

* use correct cygwin64 directory name

appveyor has cygwin64 pre-installed in /cygwin64, and 32-bit cygwin
in /cygwin

* More testing - revert VS change, bump travis timeout

* Add -g to update the rest of perl

* Skip execution tests on non-native platforms

Special site.exp that skips the unix_load() command for arm platforms.

Unset TERM to avoid cruft in stdout

Try harder to find the libffi libraries

Fix build on OpenBSD/mips64 (#638)

The build fails on OpenBSD/mips64 because clang 11's integrated
assembler expects read-only .eh_frame:

../src/mips/n32.S:585:9: error: changed section flags for .eh_frame, expected: 0x2
        .section .eh_frame,"aw",@progbits
        ^

Use EH_FRAME_FLAGS to get matching flags for the section.

Add struct test to verify a nested float struct (#640)

The test aims to check a nested float struct
[float, [float,float]] to see whether it works good
with libffi.

Signed-off-by: Cheng Jin <jincheng@ca.ibm.com>

Remove reference to old test case

Revert appveyor changes

Update vs version

Upgrade to vs2019

Try updating automake

Bring in the latest version of perl

Fix building for arm windows with mingw toolchains (#631)

* arm: Check _WIN32 instead of _M_ARM or _MSC_VER for detecting windows

This matches what was done for ARM64 in
c06468fa6674d3783a0edb1d0fae9afc8bc28513.

* arm: Only use armasm source when building with MSVC

When building for windows/arm with clang, the normal gas style .S
source works fine (if fixed up to support thumb and other windows
specifics).

This matches what was done for ARM64 in
c06468fa6674d3783a0edb1d0fae9afc8bc28513.

* arm: Fix sysv.S to work in thumb mode

Align cases in jump tables (adding nop padding to make sure each
case starts where expected).

Rewrite instructions that add directly to the pc register.

For ffi_closure_ret, factor out a call_epilogue subroutine that
restores both sp and pc from the stack; the thumb version of ldm
can't load into the sp register. To avoid excessive ifdeffing, keep
using call_epilogue in arm mode, but keep the shorter "ldm sp, {sp, pc}"
epilogue in that case.

* arm: Add win32 version of trampoline to sysv.S

This matches the version of it in sysv_msvc_arm32.S. The calling
C code expects a specific form of the trampoline on windows; make
sure these work the same on windows regardless of the form of
assembly used.

* arm: Avoid optimizing out clearing the thumb bit of ffi_arm_trampoline

We clear the thumb bit of ffi_arm_trampoline with a bitmask before
memcpying its instructions into closure->tramp.

If the bit isn't cleared, the memcpy of the trampoline function
copies the wrong instructions.

If the ffi_arm_trampoline symbol is declared as an array of int,
the compiler can assume that it is aligned to a 4 byte boundary
and the bitmask operation is a no-op, and optimize it out.

See https://godbolt.org/z/dE3jE1WTz; both Clang and GCC optimize
out the bitmask as it is, while MSVC doesn't. By declaring the
trampoline as an array of unsigned char, the bitmask works as
intended.

Verbose brew update.

Move container images to quay.io.

testsuite: fix compiler vendor detection on dash as /bin/sh (#594)

In https://bugs.gentoo.org/753299 Paolo Pedroni reported
a single test failure out of all libffi. Here is the minimal
reproducer:

```
$ ./autogen
$ CONFIG_SHELL=/bin/dash ./configure --host=x86_64-pc-linux-gnu
$ make check RUNTESTFLAGS='complex.exp'
...
FAIL: libffi.complex/cls_align_complex_float.c (test for excess errors)
```

This happens because under 'dash' shell autoconf generates slightly
different style of string quotation in `config.log`:

- on bash: `ax_cv_c_compiler_vendor=gnu`
- on dash: `ax_cv_c_compiler_vendor='gnu'`

To avoid shell quotation parsing the change just embeds
`compiler_vendor` into `local.exp` at configure time.

Reported-by: Paolo Pedroni
Bug: https://bugs.gentoo.org/753299
Signed-off-by: Sergei Trofimovich <slyfox@gentoo.org>

arm64e: Pull in pointer authentication code from Apple's arm64e libffi port (#565)

NOTES: This changes the ptrauth support from #548 to match what Apple is
       shipping in its libffi-27 tag.

Signed-off-by: Jeremy Huddleston Sequoia <jeremyhu@apple.com>

fix windows tests (#595)

* Update .appveyor.yml

* add (debug+release)*(shared+static) CI

* fix libversion

x86: Fix thiscall and fastcall stack cleanup behavior (#611)

These are meant to use callee clean-up.

Mention MSVC runtime stack checking improvement

x86: Fix MSVC runtime checks interop (#612)

MSVC can add runtime code that checks if a stack frame is mismanaged,
however our custom assembly deliberately accesses and modifies the parent
stack frame.  Fortunately we can disable that specific check for the
function call so do that.

Co-authored-by: Matthew Waters <matthew@centricular.com>

Mention LIBFFI_TMPDIR

Search $LIBFFI_TMPDIR also (#605)

Most temp file directories need to be hardened against execution, but
libffi needs execute privileges.  Add a libffi-specific temp directory
that can be set up by sysadmins as needed with suitable permissions.
This both ensures that libffi will have a valid temp directory to use
as well as preventing attempts to access other directories.

aarch64: Fix closures for win64 (#606)

Update ax_cc_maxopt m4 macro (#617)

Keeps libffi's specific changes
(https://github.com/libffi/libffi/commit/cec3a3a201f17a7f018f25e1a0917bd5206e5a5a#diff-2396a1256ac4b1c6849c931ddb8018bdd984bb2383be21bb819a33b95d8d603f)
and updates to the latest ax_cc_maxopt.m4
(http://git.savannah.gnu.org/gitweb/?p=autoconf-archive.git;a=commit;h=73ee1b396c21062ee8eeb8721ba5323322110fb5):

ax_cc_maxopt.m4: retain setting of CFLAGS by configure

AX_CC_MAXOPT checks whether CFLAGS was set by the user; if so, the user’s
setting is respected. This behavior is retained, of course.

However, AX_CC_MAXOPT was then setting CFLAGS="". This overrode the default
setting by configure, which usually includes -g. Hence, if CFLAGS was not
set by the user, retain the default setting, to preserve the ability to
debug.

A typical default setting from configure is "-g -O2". This means that
AX_CC_MAXOPT might typically set CFLAGS to "-g -O2 -O3". This is fine,
because the later -O3 will override the earlier -O2. (The only assumption is
that all compilers that AX_CC_MAXOPT knows behave in this sane way.)

Fix formatting

Mention KVX

Bug #680.  Don't accept floats or small ints as var args. (#628)

* Bug #680.  Don't accept floats or small ints as var args.

* Bug #680.  Don't accept floats or small ints as var args.

* Bug #680.  Don't accept floats or small ints as var args.

Add some missing #if conditionals from Apple's code drop (#620)

* arm/aarch64: Add FFI_CLOSURES conditionals where appropriate

Signed-off-by: Jeremy Huddleston Sequoia <jeremyhu@apple.com>
* aarch64: Don't emit the do_closure label when building without FFI_GO_CLOSURES

Signed-off-by: Jeremy Huddleston Sequoia <jeremyhu@apple.com>

Add configuration generator for tvOS and watchOS. (#625)

Static tramp v5 (#624)

* Static Trampolines

Closure Trampoline Security Issue
=================================

Currently, the trampoline code used in libffi is not statically defined in
a source file (except for MACH). The trampoline is either pre-defined
machine code in a data buffer. Or, it is generated at runtime. In order to
execute a trampoline, it needs to be placed in a page with executable
permissions.

Executable data pages are attack surfaces for attackers who may try to
inject their own code into the page and contrive to have it executed. The
security settings in a system may prevent various tricks used in user land
to write code into a page and to have it executed somehow. On such systems,
libffi trampolines would not be able to run.

Static Trampoline
=================

To solve this problem, the trampoline code needs to be defined statically
in a source file, compiled and placed in the text segment so it can be
mapped and executed naturally without any tricks. However, the trampoline
needs to be able to access the closure pointer at runtime.

PC-relative data referencing
============================

The solution implemented in this patch set uses PC-relative data references.
The trampoline is mapped in a code page. Adjacent to the code page, a data
page is mapped that contains the parameters of the trampoline:

- the closure pointer
- pointer to the ABI handler to jump to

The trampoline code uses an offset relative to its current PC to access its
data.

Some architectures support PC-relative data references in the ISA itself.
E.g., X64 supports RIP-relative references. For others, the PC has to
somehow be loaded into a general purpose register to do PC-relative data
referencing. To do this, we need to define a get_pc() kind of function and
call it to load the PC in a desired register.

There are two cases:

1. The call instruction pushes the return address on the stack.

   In this case, get_pc() will extract the return address from the stack
   and load it in the desired register and return.

2. The call instruction stores the return address in a designated register.

   In this case, get_pc() will copy the return address to the desired
   register and return.

Either way, the PC next to the call instruction is obtained.

Scratch register
================

In order to do its job, the trampoline code would need to use a scratch
register. Depending on the ABI, there may not be a register available for
scratch. This problem needs to be solved so that all ABIs will work.

The trampoline will save two values on the stack:

- the closure pointer
- the original value of the scratch register

This is what the stack will look like:

sp before trampoline ------> --------------------
| closure pointer  |
--------------------
| scratch register |
sp after trampoline -------> --------------------

The ABI handler can do the following as needed by the ABI:

- the closure pointer can be loaded in a desired register

- the scratch register can be restored to its original value

- the stack pointer can be restored to its original value
  (the value when the trampoline was invoked)

To do this, I have defined prolog code for each ABI handler. The legacy
trampoline jumps to the ABI handler directly. But the static trampoline
defined in this patch jumps tp the prolog code which performs the above
actions before jumping to the ABI handler.

Trampoline Table
================

In order to reduce the trampoline memory footprint, the trampoline code
would be defined as a code array in the text segment. This array would be
mapped into the address space of the caller. The mapping would, therefore,
contain a trampoline table.

Adjacent to the trampoline table mapping, there will be a data mapping that
contains a parameter table, one parameter block for each trampoline. The
parameter block will contain:

- a pointer to the closure
- a pointer to the ABI handler

The static trampoline code would finally look like this:

- Make space on the stack for the closure and the scratch register
  by moving the stack pointer down
- Store the original value of the scratch register on the stack
- Using PC-relative reference, get the closure pointer
- Store the closure pointer on the stack
- Using PC-relative reference, get the ABI handler pointer
- Jump to the ABI handler

Mapping size
============

The size of the code mapping that contains the trampoline table needs to be
determined on a per architecture basis. If a particular architecture
supports multiple base page sizes, then the largest supported base page size
needs to be chosen. E.g., we choose 16K for ARM64.

Trampoline allocation and free
==============================

Static trampolines are allocated in ffi_closure_alloc() and freed in
ffi_closure_free().

Normally, applications use these functions. But there are some cases out
there where the user of libffi allocates and manages its own closure
memory. In such cases, static trampolines cannot be used. These will
fall back to using legacy trampolines. The user has to make sure that
the memory is executable.

ffi_closure structure
=====================

I did not want to make any changes to the size of the closure structure for
this feature to guarantee compatibility. But the opaque static trampoline
handle needs to be stored in the closure. I have defined it as follows:

-  char tramp[FFI_TRAMPOLINE_SIZE];
+  union {
+    char tramp[FFI_TRAMPOLINE_SIZE];
+    void *ftramp;
+  };

If static trampolines are used, then tramp[] is not needed to store a
dynamic trampoline. That space can be reused to store the handle. Hence,
the union.

Architecture Support
====================

Support has been added for x64, i386, aarch64 and arm. Support for other
architectures can be added very easily in the future.

OS Support
==========

Support has been added for Linux. Support for other OSes can be added very
easily.

Signed-off-by: Madhavan T. Venkataraman <madvenka@linux.microsoft.com>
* x86: Support for Static Trampolines

- Define the arch-specific initialization function ffi_tramp_arch ()
  that returns trampoline size information to common code.

- Define the trampoline code mapping and data mapping sizes.

- Define the trampoline code table statically. Define two tables,
  actually, one with CET and one without.

- Introduce a tiny prolog for each ABI handling function. The ABI
  handlers addressed are:

   - ffi_closure_unix64
- ffi_closure_unix64_sse
- ffi_closure_win64

  The prolog functions are called:

- ffi_closure_unix64_alt
- ffi_closure_unix64_sse_alt
- ffi_closure_win64_alt

  The legacy trampoline jumps to the ABI handler. The static
  trampoline jumps to the prolog function. The prolog function uses
  the information provided by the static trampoline, sets things up
  for the ABI handler and then jumps to the ABI handler.

- Call ffi_tramp_set_parms () in ffi_prep_closure_loc () to
  initialize static trampoline parameters.

Signed-off-by: Madhavan T. Venkataraman <madvenka@linux.microsoft.com>
* i386: Support for Static Trampolines

- Define the arch-specific initialization function ffi_tramp_arch ()
  that returns trampoline size information to common code.

- Define the trampoline code table statically. Define two tables,
  actually, one with CET and one without.

- Define the trampoline code table statically.

- Introduce a tiny prolog for each ABI handling function. The ABI
  handlers addressed are:

   - ffi_closure_i386
- ffi_closure_STDCALL
- ffi_closure_REGISTER

  The prolog functions are called:

   - ffi_closure_i386_alt
- ffi_closure_STDCALL_alt
- ffi_closure_REGISTER_alt

  The legacy trampoline jumps to the ABI handler. The static
  trampoline jumps to the prolog function. The prolog function uses
  the information provided by the static trampoline, sets things up
  for the ABI handler and then jumps to the ABI handler.

- Call ffi_tramp_set_parms () in ffi_prep_closure_loc () to
  initialize static trampoline parameters.

Signed-off-by: Madhavan T. Venkataraman <madvenka@linux.microsoft.com>
* arm64: Support for Static Trampolines

- Define the arch-specific initialization function ffi_tramp_arch ()
  that returns trampoline size information to common code.

- Define the trampoline code mapping and data mapping sizes.

- Define the trampoline code table statically.

- Introduce a tiny prolog for each ABI handling function. The ABI
  handlers addressed are:

   - ffi_closure_SYSV
- ffi_closure_SYSV_V

  The prolog functions are called:

   - ffi_closure_SYSV_alt
- ffi_closure_SYSV_V_alt

  The legacy trampoline jumps to the ABI handler. The static
  trampoline jumps to the prolog function. The prolog function uses
  the information provided by the static trampoline, sets things up
  for the ABI handler and then jumps to the ABI handler.

- Call ffi_tramp_set_parms () in ffi_prep_closure_loc () to
  initialize static trampoline parameters.

Signed-off-by: Madhavan T. Venkataraman <madvenka@linux.microsoft.com>
* arm: Support for Static Trampolines

- Define the arch-specific initialization function ffi_tramp_arch ()
  that returns trampoline size information to common code.

- Define the trampoline code mapping and data mapping sizes.

- Define the trampoline code table statically.

- Introduce a tiny prolog for each ABI handling function. The ABI
  handlers addressed are:

   - ffi_closure_SYSV
- ffi_closure_VFP

  The prolog functions are called:

   - ffi_closure_SYSV_alt
- ffi_closure_VFP_alt

  The legacy trampoline jumps to the ABI handler. The static
  trampoline jumps to the prolog function. The prolog function uses
  the information provided by the static trampoline, sets things up
  for the ABI handler and then jumps to the ABI handler.

- Call ffi_tramp_set_parms () in ffi_prep_closure_loc () to
  initialize static trampoline parameters.

Signed-off-by: Madhavan T. Venkataraman <madvenka@linux.microsoft.com>

Use memfd_create() (#604)

memfd_create creates a file in a memory-only filesystem that may
bypass strict security protocols in filesystem-based temporary
files.

libffi/x86: Always check __x86_64__ for x32 hosts (#601) (#602)

Since for x86_64-*x32 and x86_64-x32-* hosts, -m32 generates ia32 codes.
We should always check __x86_64__ for x32 hosts.

Properly quote and resolve msvcc.sh params (#596)

Allow to build with mingw-clang (#579)

For some reason, compiling sysv.S with mingw-clang fails with:
```
error: invalid variant 'ffi_closure_inner@8'
```

This can be fixed (worked around?) by quoting the symbol. This works
fine with mingw-gcc too.

Don't use FFI_TYPE_LONGDOUBLE in the jump table in win64*.S (#580)

It may have the same value as FFI_TYPE_DOUBLE per ffi.h, which
possibly can make things go wrong with .org/ORG.

For instance, GCC complains about "Error: attempt to move .org
backwards"

aarch64: Allow FFI_WIN64 for winelib (#593)

Add support for powerpc64le-*-freebsd*. (#581)

Tests pass with no additional changes needed, tested on hardware.

darwin powerpc: use go closures only if enabled (#583)

SHA: 0ff9419f2e75652426469e256cb7d0748064ad58 added go closures for darwin powerpc AIX, but
these have not yet been implemented for non-AIX systems

use the go closures only if enabled

Support building x86 and arm64 without FFI_GO_CLOSURES (#586)

* x86: Support building without FFI_GO_CLOSURES

Signed-off-by: Jeremy Huddleston Sequoia <jeremyhu@apple.com>
* arm: Support building without FFI_GO_CLOSURES

Signed-off-by: Jeremy Huddleston Sequoia <jeremyhu@apple.com>

testsuite: Add a missing include of <inttypes.h> to fix build failure in test suite (#587)

Signed-off-by: Jeremy Huddleston Sequoia <jeremyhu@apple.com>

Removing unnecessary instruction from ffi_call_unix64 (#588)

unix64.S's `ffi_call_unix64` looks like it used to take six parameters,
where the sixth said the number of SSE register arguments. However,
currently the function only takes five parameters, and the number of SSE
register arguments is encoded in the `struct register_args *` passed as
the first parameter to `ffi_call_unix64`. This change removes an
instruction that tries to use this missing sixth parameter as the number
of SSE arguments.

This fix should not change any behavior, nor fix any bugs, because a few
instructions later the value moved from %r9d into %eax is overwritten by
the correct value anyway. This change merely makes the code a tad less
confusing, because currently the assembly moves from a register (r9)
whose value is never set.

Fix read-only .eh_frame section test when CFLAGS contains -flto. (#590)

Power10 libffi fixes (#585)

Power10 pc-relative code doesn't use or preserve r2 as a TOC pointer.
That means calling between pc-relative and TOC using code can't be
done without intervening linker stubs, and a call from TOC code to
pc-relative code must have a nop after the bl in order to restore r2.

Now the PowerPC libffi assembly code doesn't use r2 except for the
implicit use when making calls back to C, ffi_closure_helper_LINUX64
and ffi_prep_args64.  So changing the assembly to interoperate with
pc-relative code without stubs is easily done.

* src/powerpc/linux64.S (ffi_call_LINUX64): Don't emit global
entry when __PCREL__.  Call using @notoc.  Add nops.
* src/powerpc/linux64_closure.S (ffi_closure_LINUX64): Likewise.
(ffi_go_closure_linux64): Likewise.

docs: fix simple typo, paramters -> parameters (#589)

There is a small typo in src/x86/ffi.c.

Should read `parameters` rather than `paramters`.

Re-enable s390x testing

Upstream local FreeBSD patches (#567)

* Add support for FreeBSD mips

Add support for FreeBSD mips, this has been a local patch in the FreeBSD
ports tree for quite some time.

Originally submitted by sson, and committed by sbruno AT FreeBSD DOT org
See https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=191909 for
background details.

Signed-off-by: Niclas Zeising <zeising@daemonic.se>
* Add support for FreeBSD powerpcspe

Add support for powerpcspe on FreeBSD
This has been in the FreeBSD ports tree for some time.
Originally submitted by jhibbits AT FreeBSD DOT org.

Signed-off-by: Niclas Zeising <zeising@daemonic.se>
* Fix abort() on FreeBSD arm related to __clear_cache()

This patch has been in the FreeBSD ports tree for a number of years.
Original commit by koobs AT FreeBSD DOT org

Original commit message:
> devel/libffi: Fix abort() on ARM related to __clear_cache()
>
> The current FreeBSD/ARM __clear_cache() implementation does nothing #if
> __i386__ || __x86_64__ #else abort();
>
> cognet@ advises this is an issue for anything !Apple that is using the
> libcompiler_rt provided by Clang on ARM, and requires upstreaming.

See https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=149167 for some
background details.

Signed-off-by: Niclas Zeising <zeising@daemonic.se>

Don't test s390.  Travis-ci is broken.

Add support for eabisim back.  This was removed upstream.

Merge pull request #576 from froydnj/config-updates

update config.{guess,sub}

update config.{guess,sub}

This change is primarily for aarch64 macOS support, since that configuration
is now properly supported upstream.

Merge pull request #570 from jwilk-forks/spelling

aarch64: Fix typo

aarch64: Fix typo

Add support for csky

Makefile: increase compatibility with bmake (#551)

Fixes macOS build on Python 3 (#563)

The error was:
```
Traceback (most recent call last):
  File "_generate-darwin-source-and-headers.py", line 209, in <module>
    generate_source_and_headers(generate_osx=not args.only_ios, generate_ios=not args.only_osx)
  File "_generate-darwin-source-and-headers.py", line 197, in generate_source_and_headers
    for header_name, tag_tuples in platform_headers.iteritems():
AttributeError: 'collections.defaultdict' object has no attribute 'iteritems'
```

Fix Free software foundation address (#564)

ref. https://www.fsf.org/about/contact/

Add gcc bug tests back

Add support for Kalray KVX architecture (#559)

ffi_powerpc.h: fix build failure with powerpc7 (#561)

This is a patch pulled down from the following:
https://github.com/buildroot/buildroot/blob/78926f610b1411b03464152472fd430012deb9ac/package/libffi/0004-ffi_powerpc.h-fix-build-failure-with-powerpc7.patch

This issue is being hit on OpenBMC code when pulling the latest
libffi tag and building on a P8 ppc64le machine. I verified this
patch fixes the issue we are seeing.

Below is the original commit message:

Sicne commit 73dd43afc8a447ba98ea02e9aad4c6898dc77fb0, build on powerpc7
fails on:

In file included from ../src/powerpc/ffi.c:33:0:
../src/powerpc/ffi_powerpc.h:61:9: error: '_Float128' is not supported on this target
 typedef _Float128 float128;
         ^~~~~~~~~

Fix this build failure by checking for __HAVE_FLOAT128 before using
_Float128, as _Float128 is enabled only on specific conditions, see
output/host/powerpc64-buildroot-linux-gnu/sysroot/usr/include/bits/floatn.h:

 /* Defined to 1 if the current compiler invocation provides a
    floating-point type with the IEEE 754 binary128 format, and this glibc
    includes corresponding *f128 interfaces for it.  */
 #if defined _ARCH_PWR8 && defined __LITTLE_ENDIAN__ && (_CALL_ELF == 2) \
     && defined __FLOAT128__ && !defined __NO_LONG_DOUBLE_MATH
 # define __HAVE_FLOAT128 1
 #else
 # define __HAVE_FLOAT128 0
 #endif

Fixes:
 - http://autobuild.buildroot.org/results/5c9dd8fb3b6a128882b6250f197c80232d8a3b53

Signed-off-by: Fabrice Fontaine <fontaine.fabrice@gmail.com>
Signed-off-by: Andrew Geissler <geissonator@yahoo.com>
Co-authored-by: Fabrice Fontaine <fontaine.fabrice@gmail.com>

arm: Fix the clang specific version of the assembly (#556)

Also fix the same error in the comment for the non-clang case.
That typo there seems to have existed since the code was written
in that form, in e7f15f60e86 - and when the clang specific codepath
was added in e3d2812ce43, the typo in the comment made it into the
actual code.

win64_armasm: Fix the spelling of ALIGN (#553)

Use __builtin_ffs instead of ffs (#554)

USE_BUILTIN_FFS is defined to 1 within __GNUC__, and the __builtin_ffs
function is available since GCC 3.x at least, while the ffs function
only exists on some OSes.

This fixes compilation for non-x86 mingw platforms. For x86,
USE_BUILTIN_FFS is explicitly disabled for windows targets - but
if USE_BUILTIN_FFS is enabled based on __GNUC__, it should also use
the builtin which actually is available correspondingly, not dependent
on the target OS.

Fix building for aarch64 windows with mingw toolchains (#555)

* aarch64: Check _WIN32 instead of _M_ARM64 for detecting windows

This fixes building for aarch64 with mingw toolchains. _M_ARM64 is
predefined by MSVC, while mingw compilers predefine __aarch64__.

In aarch64 specific code, change checks for _M_ARM64 into checks for
_WIN32.

In arch independent code, check for
(defined(_M_ARM64) || defined(__aarch64__)) && defined(_WIN32)
instead of just _M_ARM64.

In src/closures.c, coalesce checks like
defined(X86_WIN32) || defined(X86_WIN64) || defined(_M_ARM64)
into plain defined(_WIN32). Technically, this enables code for
ARM32 windows where it wasn't, but as far as I can see it, those
codepaths should be fine for that architecture variant as well.

* aarch64: Only use armasm source when building with MSVC

When building for windows/arm64 with clang, the normal gas style .S
source works fine. sysv.S and win64_armasm.S seem to be functionally
equivalent, with only differences being due to assembler syntax.

Improve read-write .eh_frame check (#546)

llvm-objdump -h does not print BFD SEC_* constants like "READONLY",
so the check will consider .eh_frame writable.
clang 11 (since https://reviews.llvm.org/D73999) will error for mismatching section flags.

Use readelf -S and check "WA" instead.

Mention ARM Pointer Authentication

Test on aarch64 Linux with clang

Port to iOS/arm64e (#548)

Try to fix RLGL_KEY nonsense (#547)

* Try to fix RLGL_KEY nonsense

* Hard code policy bound API key

Co-authored-by: Anthony Green <green@moxielogic.com>

Revamp PA_LINUX and PA_HPUX target closures to use function descriptors.

2020-02-23  John David Anglin  <danglin@gcc.gnu.org>

* include/ffi.h.in (FFI_CLOSURE_PTR, FFI_RESTORE_PTR): Define.
* src/closures.c (ffi_closure_alloc): Convert closure pointer
return by malloc to function pointer.
(ffi_closure_free): Convert function pointer back to malloc pointer.
* src/pa/ffi.c (ffi_closure_inner_pa32): Use union to double word
align return address on stack.  Adjust statements referencing return
address.  Convert closure argument from function pointer to standard
closure pointer.
(ffi_prep_closure_loc): Likewise convert closure argument back to
closure pointer.  Remove assembler trampolines.  Setup simulated
function descriptor as on ia64.
src/pa/ffitarget.h (FFI_TRAMPOLINE_SIZE): Reduce to 12.
src/pa/hpux32.S (ffi_closure_pa32): Retrieve closure pointer and real
gp from fake gp value in register %r19.
src/pa/linux.S (ffi_closure_pa32): Likewise.

Update the ABI version to LIBFFI_BASE_8.0 (#544)

Since x86 and x86-64 FFI_TRAMPOLINE_SIZE have been increased, we must
bump the ABI version.  This fixes:

https://github.com/libffi/libffi/issues/543

x86: Fix ffi_prep_closure_loc (#542)

Since FFI_TRAMPOLINE_SIZE is increased by 4 bytes to add ENDBR32, adjust
jump displacement by 4 bytes.

Merge branch 'master' of github.com:/libffi/libffi

Update for pending 3.4 release.

x86: Add indirect branch tracking support (#540)

Intel Control-flow Enforcement Technology (CET):

https://software.intel.com/en-us/articles/intel-sdm

contains shadow stack (SHSTK) and indirect branch tracking (IBT).  When
CET is enabled, ELF object files must be marked with .note.gnu.property
section.  When Intel CET is enabled, include <cet.h> in assembly codes
to mark Intel CET support.

Also when IBT is enabled, all indirect branch targets must start with
ENDBR instruction and notrack prefix can be used to disable IBT on
indirect branch.  <cet.h> defines _CET_ENDBR which can be used in
assembly codes for ENDBR instruction.  If <cet.h> isn't included,
define _CET_ENDBR as empty so that _CET_ENDBR can be used in assembly
codes.

Trampoline must be enlarged to add ENDBR instruction unconditionally,
which is NOP on non-CET processors.  This is required regardless if
libffi is enabled with CET since libffi.so will be marked in legacy
bitmap, but trampoline won't.  Update library version for larger
FFI_TRAMPOLINE_SIZE.

This fixed:

https://github.com/libffi/libffi/issues/474

Tested with

$ CC="gcc -Wl,-z,cet-report=error -fcf-protection" CXX="g++ -Wl,-z,cet-report=error -fcf-protection" .../configure

on Linux CET machines in i686, x32 and x86-64 modes.