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.

Update powerpc sysv assembly for ffi_powerpc.h changes (#541)

Some of the flag bits were moved when adding powerpc64 vector support.

Fixes #536

Update copyright year.

Fix script

Use rlgl API key on login

powerpc64: Use memcpy to help platforms with no __int128. (#534)

Signed-off-by: Khem Raj <raj.khem@gmail.com>

Remove 32-bit x86 file references to fix macosx builds

Fixed missed #ifndef for __mips_soft_float (#442)

Thank you!

Clean up macosx builds

Address platforms with no __int128.

Make build errors easier to debug

Add powerpc-eabi

Test on powerpc-eabisim

powerpc: fix build failure on power7 and older (#532)

Build failure looks as:
```
libtool: compile:  powerpc-unknown-linux-gnu-gcc \
    -O2 -mcpu=powerpc -mtune=powerpc -pipe ... -c src/powerpc/ffi.c ...
In file included from src/powerpc/ffi.c:33:
src/powerpc/ffi_powerpc.h:65:9: error: '__int128' is not supported on this target
   65 | typedef __int128 float128;
      |         ^~~~~~~~
```

The fix avoids using __int128 in favour of aligned char[16].

Closes: https://github.com/libffi/libffi/issues/531
Signed-off-by: Sergei Trofimovich <slyfox@gentoo.org>

Run aarch64-linux-gnu tests on travi-ci directly

Fixes for ppc64le and s390x travis testing

Force the use of docker

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

Try travis-ci's new ppc64le and s390x support

disable obsolete 32-bit targets in macOS (#511)

Minor clean-up

Move nested_struct3 test to closures directory

Add missing closing brace

Version 3.3

Remove junk file from dist

Account for moved test files

Add dejagnu directives accidentally removed

Move closure test to closure directory

More more closure tests to the closure test directory

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

Move closure tests so we can easily XFAIL them for some targets

Remove gccbug detection.  GCC is good now.

Capture x86-windows host like x86_64-windows (#529)

Manual clean-ups, and include the PDF in the source distribution.

Mention more major port contributors

Update autoconf-archive m4 macros

Fix formatting of README.

Fix or1k lack-of-g++ checking in testsuite

Add work-around for users who manage their own closure memory

As suggested by DJ

No C++ for or1k-unknown-elf

No C++ for or1k

Disable type warnings for or1k.

No c++ for or1k-elf

Fake TRAVIS_BUILD_DIR

Adapt for new old ChangeLog file

Fix DEJAGNU variable

Set vars

Remove verbosity

Pull before running

Fix cross builds for or1k

More cross build debugging

Set path to simulator. Add debugging output.

Be specific when building CI container images

Capture more or1k hosts

Add test support for or1k. Fix yaml typo.

Fix typo for m32r and bfin builds