commit: 109f9a231cf497b2869191aa884c573da5816059 Author: Sam James <sam <AT> gentoo <DOT> org> AuthorDate: Mon Apr 3 06:38:46 2023 +0000 Commit: Sam James <sam <AT> gentoo <DOT> org> CommitDate: Mon Apr 3 06:39:51 2023 +0000 URL: https://gitweb.gentoo.org/repo/gentoo.git/commit/?id=109f9a23
dev-libs/libffi: backport HPPA improvements Signed-off-by: Sam James <sam <AT> gentoo.org> .../libffi-3.4.4-hppa-closure-function-ptrs.patch | 170 ++++++++++++ .../files/libffi-3.4.4-hppa-jump-table.patch | 289 +++++++++++++++++++++ .../files/libffi-3.4.4-hppa-large-struct.patch | 36 +++ dev-libs/libffi/libffi-3.4.4-r1.ebuild | 76 ++++++ 4 files changed, 571 insertions(+) diff --git a/dev-libs/libffi/files/libffi-3.4.4-hppa-closure-function-ptrs.patch b/dev-libs/libffi/files/libffi-3.4.4-hppa-closure-function-ptrs.patch new file mode 100644 index 000000000000..065f35e7c4c2 --- /dev/null +++ b/dev-libs/libffi/files/libffi-3.4.4-hppa-closure-function-ptrs.patch @@ -0,0 +1,170 @@ +https://github.com/libffi/libffi/commit/e58e22b22386ed0e0a95e97eb8eed016e3f01b02 + +From e58e22b22386ed0e0a95e97eb8eed016e3f01b02 Mon Sep 17 00:00:00 2001 +From: Anthony Green <gr...@moxielogic.com> +Date: Thu, 2 Feb 2023 07:02:53 -0500 +Subject: [PATCH] From Dave Anglin: + +A couple of years ago the 32-bit hppa targets were converted from using a trampoline executed on the stack to the function descriptor technique used by ia64. This is more efficient and avoids having to have an executable stack. However, function pointers on 32-bit need the PLABEL bit set in the pointer. It distinguishes between pointers that point directly to the executable code and pointer that point to a function descriptor. We need the later for libffi. But as a result, it is not possible to convert using casts data pointers to function pointers. + +The solution at the time was to set the PLABEL bit in hppa closure pointers using FFI_CLOSURE_PTR. However, I realized recently that this was a bad choice. Packages like python-cffi allocate their own closure pointers, so this isn't going to work well there. + +A better solution is to leave closure pointers unchanged and only set the PLABEL bit in pointers used to point to executable code. + +The attached patch drops the FFI_CLOSURE_PTR and FFI_RESTORE_PTR defines. This allows some cleanup in the hppa closure routines. The FFI_FN define is now used to set the PLABEL bit on hppa. ffi_closure_alloc is modified to set the PLABEL bit in the value set in *code. + +I also added a FFI_CL define to convert a function pointer to a closure pointer. It is only used in one test case. +--- a/include/ffi.h.in ++++ b/include/ffi.h.in +@@ -361,14 +361,6 @@ typedef struct { + FFI_API void *ffi_closure_alloc (size_t size, void **code); + FFI_API void ffi_closure_free (void *); + +-#if defined(PA_LINUX) || defined(PA_HPUX) +-#define FFI_CLOSURE_PTR(X) ((void *)((unsigned int)(X) | 2)) +-#define FFI_RESTORE_PTR(X) ((void *)((unsigned int)(X) & ~3)) +-#else +-#define FFI_CLOSURE_PTR(X) (X) +-#define FFI_RESTORE_PTR(X) (X) +-#endif +- + FFI_API ffi_status + ffi_prep_closure (ffi_closure*, + ffi_cif *, +@@ -515,8 +507,14 @@ FFI_API + ffi_status ffi_get_struct_offsets (ffi_abi abi, ffi_type *struct_type, + size_t *offsets); + +-/* Useful for eliminating compiler warnings. */ ++/* Convert between closure and function pointers. */ ++#if defined(PA_LINUX) || defined(PA_HPUX) ++#define FFI_FN(f) ((void (*)(void))((unsigned int)(f) | 2)) ++#define FFI_CL(f) ((void *)((unsigned int)(f) & ~3)) ++#else + #define FFI_FN(f) ((void (*)(void))f) ++#define FFI_CL(f) ((void *)(f)) ++#endif + + /* ---- Definitions shared with assembly code ---------------------------- */ + +--- a/src/closures.c ++++ b/src/closures.c +@@ -993,23 +993,23 @@ ffi_closure_alloc (size_t size, void **code) + if (!code) + return NULL; + +- ptr = FFI_CLOSURE_PTR (dlmalloc (size)); ++ ptr = dlmalloc (size); + + if (ptr) + { + msegmentptr seg = segment_holding (gm, ptr); + +- *code = add_segment_exec_offset (ptr, seg); ++ *code = FFI_FN (add_segment_exec_offset (ptr, seg)); + if (!ffi_tramp_is_supported ()) + return ptr; + + ftramp = ffi_tramp_alloc (0); + if (ftramp == NULL) + { +- dlfree (FFI_RESTORE_PTR (ptr)); ++ dlfree (ptr); + return NULL; + } +- *code = ffi_tramp_get_addr (ftramp); ++ *code = FFI_FN (ffi_tramp_get_addr (ftramp)); + ((ffi_closure *) ptr)->ftramp = ftramp; + } + +@@ -1050,7 +1050,7 @@ ffi_closure_free (void *ptr) + if (ffi_tramp_is_supported ()) + ffi_tramp_free (((ffi_closure *) ptr)->ftramp); + +- dlfree (FFI_RESTORE_PTR (ptr)); ++ dlfree (ptr); + } + + int +@@ -1070,16 +1070,20 @@ ffi_tramp_is_present (void *ptr) + void * + ffi_closure_alloc (size_t size, void **code) + { ++ void *c; ++ + if (!code) + return NULL; + +- return *code = FFI_CLOSURE_PTR (malloc (size)); ++ c = malloc (size); ++ *code = FFI_FN (c); ++ return c; + } + + void + ffi_closure_free (void *ptr) + { +- free (FFI_RESTORE_PTR (ptr)); ++ free (ptr); + } + + void * +--- a/src/pa/ffi.c ++++ b/src/pa/ffi.c +@@ -445,7 +445,6 @@ ffi_status ffi_closure_inner_pa32(ffi_closure *closure, UINT32 *stack) + int i, avn; + unsigned int slot = FIRST_ARG_SLOT; + register UINT32 r28 asm("r28"); +- ffi_closure *c = (ffi_closure *)FFI_RESTORE_PTR (closure); + + cif = closure->cif; + +@@ -548,7 +547,7 @@ ffi_status ffi_closure_inner_pa32(ffi_closure *closure, UINT32 *stack) + } + + /* Invoke the closure. */ +- (c->fun) (cif, rvalue, avalue, c->user_data); ++ (closure->fun) (cif, rvalue, avalue, closure->user_data); + + debug(3, "after calling function, ret[0] = %08x, ret[1] = %08x\n", u.ret[0], + u.ret[1]); +@@ -649,8 +648,6 @@ ffi_prep_closure_loc (ffi_closure* closure, + void *user_data, + void *codeloc) + { +- ffi_closure *c = (ffi_closure *)FFI_RESTORE_PTR (closure); +- + /* The layout of a function descriptor. A function pointer with the PLABEL + bit set points to a function descriptor. */ + struct pa32_fd +@@ -676,14 +673,14 @@ ffi_prep_closure_loc (ffi_closure* closure, + fd = (struct pa32_fd *)((UINT32)ffi_closure_pa32 & ~3); + + /* Setup trampoline. */ +- tramp = (struct ffi_pa32_trampoline_struct *)c->tramp; ++ tramp = (struct ffi_pa32_trampoline_struct *)closure->tramp; + tramp->code_pointer = fd->code_pointer; + tramp->fake_gp = (UINT32)codeloc & ~3; + tramp->real_gp = fd->gp; + +- c->cif = cif; +- c->user_data = user_data; +- c->fun = fun; ++ closure->cif = cif; ++ closure->user_data = user_data; ++ closure->fun = fun; + + return FFI_OK; + } +--- a/testsuite/libffi.closures/closure_loc_fn0.c ++++ b/testsuite/libffi.closures/closure_loc_fn0.c +@@ -85,7 +85,7 @@ int main (void) + + #ifndef FFI_EXEC_STATIC_TRAMP + /* With static trampolines, the codeloc does not point to closure */ +- CHECK(memcmp(pcl, codeloc, sizeof(*pcl)) == 0); ++ CHECK(memcmp(pcl, FFI_CL(codeloc), sizeof(*pcl)) == 0); + #endif + + res = (*((closure_loc_test_type0)codeloc)) + diff --git a/dev-libs/libffi/files/libffi-3.4.4-hppa-jump-table.patch b/dev-libs/libffi/files/libffi-3.4.4-hppa-jump-table.patch new file mode 100644 index 000000000000..822a7eb893ec --- /dev/null +++ b/dev-libs/libffi/files/libffi-3.4.4-hppa-jump-table.patch @@ -0,0 +1,289 @@ +https://github.com/libffi/libffi/commit/222abd0c65babe2174b21753217145f5031a8b91 + +From 222abd0c65babe2174b21753217145f5031a8b91 Mon Sep 17 00:00:00 2001 +From: Anthony Green <gr...@moxielogic.com> +Date: Thu, 2 Feb 2023 07:04:55 -0500 +Subject: [PATCH] From Dave Anglin: + +This patch is derived from the work done in implementing libffi for 64-bit hppa64-hpux target. Currently, the 32-bit hppa targets do a linear search for the return type of an ffi_call. This is slow and inefficient. A jump table can used to jump directly to the code used to process the return value. In most common cases, the return value can be processed in the jump table itself. + +The patch also fixes return handling for FFI_TYPE_UINT8, FFI_TYPE_SINT8, FFI_TYPE_UINT16 and FFI_TYPE_SINT16. +--- a/src/pa/ffi.c ++++ b/src/pa/ffi.c +@@ -56,27 +56,12 @@ static inline int ffi_struct_type(ffi_type *t) + size_t sz = t->size; + + /* Small structure results are passed in registers, +- larger ones are passed by pointer. Note that +- small structures of size 2, 4 and 8 differ from +- the corresponding integer types in that they have +- different alignment requirements. */ +- +- if (sz <= 1) +- return FFI_TYPE_UINT8; +- else if (sz == 2) +- return FFI_TYPE_SMALL_STRUCT2; +- else if (sz == 3) +- return FFI_TYPE_SMALL_STRUCT3; +- else if (sz == 4) +- return FFI_TYPE_SMALL_STRUCT4; +- else if (sz == 5) +- return FFI_TYPE_SMALL_STRUCT5; +- else if (sz == 6) +- return FFI_TYPE_SMALL_STRUCT6; +- else if (sz == 7) +- return FFI_TYPE_SMALL_STRUCT7; +- else if (sz <= 8) +- return FFI_TYPE_SMALL_STRUCT8; ++ larger ones are passed by pointer. Note that small ++ structures differ from the corresponding integer ++ types in that they have different alignment requirements. */ ++ ++ if (sz <= 8) ++ return -sz; + else + return FFI_TYPE_STRUCT; /* else, we pass it by pointer. */ + } +@@ -556,16 +541,16 @@ ffi_status ffi_closure_inner_pa32(ffi_closure *closure, UINT32 *stack) + switch (cif->flags) + { + case FFI_TYPE_UINT8: +- *(stack - FIRST_ARG_SLOT) = (UINT8)(u.ret[0] >> 24); ++ *(stack - FIRST_ARG_SLOT) = (UINT8)u.ret[0]; + break; + case FFI_TYPE_SINT8: +- *(stack - FIRST_ARG_SLOT) = (SINT8)(u.ret[0] >> 24); ++ *(stack - FIRST_ARG_SLOT) = (SINT8)u.ret[0]; + break; + case FFI_TYPE_UINT16: +- *(stack - FIRST_ARG_SLOT) = (UINT16)(u.ret[0] >> 16); ++ *(stack - FIRST_ARG_SLOT) = (UINT16)u.ret[0]; + break; + case FFI_TYPE_SINT16: +- *(stack - FIRST_ARG_SLOT) = (SINT16)(u.ret[0] >> 16); ++ *(stack - FIRST_ARG_SLOT) = (SINT16)u.ret[0]; + break; + case FFI_TYPE_INT: + case FFI_TYPE_SINT32: +@@ -590,6 +575,7 @@ ffi_status ffi_closure_inner_pa32(ffi_closure *closure, UINT32 *stack) + /* Don't need a return value, done by caller. */ + break; + ++ case FFI_TYPE_SMALL_STRUCT1: + case FFI_TYPE_SMALL_STRUCT2: + case FFI_TYPE_SMALL_STRUCT3: + case FFI_TYPE_SMALL_STRUCT4: +--- a/src/pa/ffitarget.h ++++ b/src/pa/ffitarget.h +@@ -73,11 +73,22 @@ typedef enum ffi_abi { + #define FFI_TRAMPOLINE_SIZE 12 + #endif + +-#define FFI_TYPE_SMALL_STRUCT2 -1 +-#define FFI_TYPE_SMALL_STRUCT3 -2 +-#define FFI_TYPE_SMALL_STRUCT4 -3 +-#define FFI_TYPE_SMALL_STRUCT5 -4 +-#define FFI_TYPE_SMALL_STRUCT6 -5 +-#define FFI_TYPE_SMALL_STRUCT7 -6 +-#define FFI_TYPE_SMALL_STRUCT8 -7 ++#define FFI_TYPE_SMALL_STRUCT1 -1 ++#define FFI_TYPE_SMALL_STRUCT2 -2 ++#define FFI_TYPE_SMALL_STRUCT3 -3 ++#define FFI_TYPE_SMALL_STRUCT4 -4 ++#define FFI_TYPE_SMALL_STRUCT5 -5 ++#define FFI_TYPE_SMALL_STRUCT6 -6 ++#define FFI_TYPE_SMALL_STRUCT7 -7 ++#define FFI_TYPE_SMALL_STRUCT8 -8 ++ ++/* linux.S and hpux32.S expect FFI_TYPE_COMPLEX is the last generic type. */ ++#define FFI_PA_TYPE_LAST FFI_TYPE_COMPLEX ++ ++/* If new generic types are added, the jump tables in linux.S and hpux32.S ++ likely need updating. */ ++#if FFI_TYPE_LAST != FFI_PA_TYPE_LAST ++# error "You likely have broken jump tables" ++#endif ++ + #endif + +--- a/src/pa/linux.S ++++ b/src/pa/linux.S +@@ -103,51 +103,103 @@ ffi_call_pa32: + + /* Prepare to store the result; we need to recover flags and rvalue. */ + ldw -48(%r3), %r21 /* r21 <- flags */ +- ldw -52(%r3), %r20 /* r20 <- rvalue */ + +- /* Store the result according to the return type. */ ++ /* Adjust flags range from [-8, 15] to [0, 23]. */ ++ addi 8, %r21, %r21 + +-.Lcheckint: +- comib,<>,n FFI_TYPE_INT, %r21, .Lcheckint8 +- b .Ldone +- stw %ret0, 0(%r20) ++ blr %r21, %r0 ++ ldw -52(%r3), %r20 /* r20 <- rvalue */ + +-.Lcheckint8: +- comib,<>,n FFI_TYPE_UINT8, %r21, .Lcheckint16 ++ /* Giant jump table */ ++ /* 8-byte small struct */ ++ b,n .Lsmst8 ++ nop ++ /* 7-byte small struct */ ++ b,n .Lsmst7 ++ nop ++ /* 6-byte small struct */ ++ b,n .Lsmst6 ++ nop ++ /* 5-byte small struct */ ++ b,n .Lsmst5 ++ nop ++ /* 4-byte small struct */ ++ b,n .Lsmst4 ++ nop ++ /* 3-byte small struct */ ++ b,n .Lsmst3 ++ nop ++ /* 2-byte small struct */ ++ b,n .Lsmst2 ++ nop ++ /* 1-byte small struct */ + b .Ldone + stb %ret0, 0(%r20) +- +-.Lcheckint16: +- comib,<>,n FFI_TYPE_UINT16, %r21, .Lcheckdbl ++ /* void */ ++ b,n .Ldone ++ nop ++ /* int */ + b .Ldone +- sth %ret0, 0(%r20) +- +-.Lcheckdbl: +- comib,<>,n FFI_TYPE_DOUBLE, %r21, .Lcheckfloat ++ stw %ret0, 0(%r20) ++ /* float */ ++ b .Ldone ++ fstw %fr4L,0(%r20) ++ /* double */ + b .Ldone + fstd %fr4,0(%r20) +- +-.Lcheckfloat: +- comib,<>,n FFI_TYPE_FLOAT, %r21, .Lcheckll ++ /* long double */ + b .Ldone +- fstw %fr4L,0(%r20) ++ fstd %fr4,0(%r20) ++ /* unsigned int8 */ ++ b .Ldone ++ stw %ret0, 0(%r20) ++ /* sint8 */ ++ b .Ldone ++ stw %ret0, 0(%r20) ++ /* unsigned int16 */ ++ b .Ldone ++ stw %ret0, 0(%r20) ++ /* sint16 */ ++ b .Ldone ++ stw %ret0, 0(%r20) ++ /* unsigned int32 */ ++ b .Ldone ++ stw %ret0, 0(%r20) ++ /* sint32 */ ++ b .Ldone ++ stw %ret0, 0(%r20) ++ /* unsigned int64 */ ++ b,n .Luint64 ++ nop ++ /* signed int64 */ ++ b,n .Lsint64 ++ nop ++ /* large struct */ ++ b,n .Ldone ++ nop ++ /* pointer */ ++ b .Ldone ++ stw %ret0, 0(%r20) ++ /* complex */ ++ b,n .Ldone ++ nop ++ ++ /* Store the result according to the return type. */ + +-.Lcheckll: +- comib,<>,n FFI_TYPE_UINT64, %r21, .Lchecksmst2 ++.Luint64: ++.Lsint64: + stw %ret0, 0(%r20) + b .Ldone + stw %ret1, 4(%r20) + +-.Lchecksmst2: +- comib,<>,n FFI_TYPE_SMALL_STRUCT2, %r21, .Lchecksmst3 ++.Lsmst2: + /* 2-byte structs are returned in ret0 as ????xxyy. */ + extru %ret0, 23, 8, %r22 + stbs,ma %r22, 1(%r20) + b .Ldone + stb %ret0, 0(%r20) + +-.Lchecksmst3: +- comib,<>,n FFI_TYPE_SMALL_STRUCT3, %r21, .Lchecksmst4 ++.Lsmst3: + /* 3-byte structs are returned in ret0 as ??xxyyzz. */ + extru %ret0, 15, 8, %r22 + stbs,ma %r22, 1(%r20) +@@ -156,8 +208,7 @@ ffi_call_pa32: + b .Ldone + stb %ret0, 0(%r20) + +-.Lchecksmst4: +- comib,<>,n FFI_TYPE_SMALL_STRUCT4, %r21, .Lchecksmst5 ++.Lsmst4: + /* 4-byte structs are returned in ret0 as wwxxyyzz. */ + extru %ret0, 7, 8, %r22 + stbs,ma %r22, 1(%r20) +@@ -168,8 +219,7 @@ ffi_call_pa32: + b .Ldone + stb %ret0, 0(%r20) + +-.Lchecksmst5: +- comib,<>,n FFI_TYPE_SMALL_STRUCT5, %r21, .Lchecksmst6 ++.Lsmst5: + /* 5 byte values are returned right justified: + ret0 ret1 + 5: ??????aa bbccddee */ +@@ -183,8 +233,7 @@ ffi_call_pa32: + b .Ldone + stb %ret1, 0(%r20) + +-.Lchecksmst6: +- comib,<>,n FFI_TYPE_SMALL_STRUCT6, %r21, .Lchecksmst7 ++.Lsmst6: + /* 6 byte values are returned right justified: + ret0 ret1 + 6: ????aabb ccddeeff */ +@@ -200,8 +249,7 @@ ffi_call_pa32: + b .Ldone + stb %ret1, 0(%r20) + +-.Lchecksmst7: +- comib,<>,n FFI_TYPE_SMALL_STRUCT7, %r21, .Lchecksmst8 ++.Lsmst7: + /* 7 byte values are returned right justified: + ret0 ret1 + 7: ??aabbcc ddeeffgg */ +@@ -219,8 +267,7 @@ ffi_call_pa32: + b .Ldone + stb %ret1, 0(%r20) + +-.Lchecksmst8: +- comib,<>,n FFI_TYPE_SMALL_STRUCT8, %r21, .Ldone ++.Lsmst8: + /* 8 byte values are returned right justified: + ret0 ret1 + 8: aabbccdd eeffgghh */ diff --git a/dev-libs/libffi/files/libffi-3.4.4-hppa-large-struct.patch b/dev-libs/libffi/files/libffi-3.4.4-hppa-large-struct.patch new file mode 100644 index 000000000000..aaf4af368432 --- /dev/null +++ b/dev-libs/libffi/files/libffi-3.4.4-hppa-large-struct.patch @@ -0,0 +1,36 @@ +https://github.com/libffi/libffi/commit/c50c16d0bcb58952840184aa83e62c6d912bf779 + +From c50c16d0bcb58952840184aa83e62c6d912bf779 Mon Sep 17 00:00:00 2001 +From: Anthony Green <gr...@moxielogic.com> +Date: Sun, 20 Nov 2022 12:20:40 -0500 +Subject: [PATCH] Fix large struct passing on PA-RISC + +--- a/src/pa/ffi.c ++++ b/src/pa/ffi.c +@@ -376,10 +376,26 @@ extern void ffi_call_pa32(void (*)(UINT32 *, extended_cif *, unsigned), + void ffi_call(ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue) + { + extended_cif ecif; ++ size_t i, nargs = cif->nargs; ++ ffi_type **arg_types = cif->arg_types; + + ecif.cif = cif; + ecif.avalue = avalue; + ++ /* If we have any large structure arguments, make a copy so we are passing ++ by value. */ ++ for (i = 0; i < nargs; i++) ++ { ++ ffi_type *at = arg_types[i]; ++ int size = at->size; ++ if (at->type == FFI_TYPE_STRUCT && size > 8) ++ { ++ char *argcopy = alloca (size); ++ memcpy (argcopy, avalue[i], size); ++ avalue[i] = argcopy; ++ } ++ } ++ + /* If the return value is a struct and we don't have a return + value address then we need to make one. */ + diff --git a/dev-libs/libffi/libffi-3.4.4-r1.ebuild b/dev-libs/libffi/libffi-3.4.4-r1.ebuild new file mode 100644 index 000000000000..8d8ab583df15 --- /dev/null +++ b/dev-libs/libffi/libffi-3.4.4-r1.ebuild @@ -0,0 +1,76 @@ +# Copyright 1999-2023 Gentoo Authors +# Distributed under the terms of the GNU General Public License v2 + +EAPI=7 + +inherit multilib-minimal preserve-libs + +MY_PV=${PV/_rc/-rc} +MY_P=${PN}-${MY_PV} + +DESCRIPTION="a portable, high level programming interface to various calling conventions" +HOMEPAGE="https://sourceware.org/libffi/"; +SRC_URI="https://github.com/libffi/libffi/releases/download/v${MY_PV}/${MY_P}.tar.gz"; +S="${WORKDIR}"/${MY_P} + +LICENSE="MIT" +# This is a core package which is depended on by e.g. Python +# Please use preserve-libs.eclass in pkg_{pre,post}inst to cover users +# with FEATURES="-preserved-libs" or another package manager if SONAME +# changes. +SLOT="0/8" # SONAME=libffi.so.8 +KEYWORDS="~alpha ~amd64 ~arm ~arm64 ~hppa ~ia64 ~loong ~m68k ~mips ~ppc ~ppc64 ~riscv ~s390 ~sparc ~x86 ~x64-cygwin ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris" +IUSE="debug exec-static-trampoline pax-kernel static-libs test" + +RESTRICT="!test? ( test )" +BDEPEND="test? ( dev-util/dejagnu )" + +PATCHES=( + "${FILESDIR}"/${P}-hppa-large-struct.patch + "${FILESDIR}"/${P}-hppa-closure-function-ptrs.patch + "${FILESDIR}"/${P}-hppa-jump-table.patch +) + +src_prepare() { + default + + if [[ ${CHOST} == arm64-*-darwin* ]] ; then + # ensure we use aarch64 asm, not x86 on arm64 + sed -i -e 's/aarch64\*-\*-\*/arm64*-*-*|&/' \ + configure configure.host || die + fi +} + +multilib_src_configure() { + # --includedir= path maintains a few properties: + # 1. have stable name across libffi versions: some packages like + # dev-lang/ghc or kde-frameworks/networkmanager-qt embed + # ${includedir} at build-time. Don't require those to be + # rebuilt unless SONAME changes. bug #695788 + # + # We use /usr/.../${PN} (instead of former /usr/.../${P}). + # + # 2. have ${ABI}-specific location as ffi.h is target-dependent. + # + # We use /usr/$(get_libdir)/... to have ABI identifier. + ECONF_SOURCE="${S}" econf \ + --includedir="${EPREFIX}"/usr/$(get_libdir)/${PN}/include \ + --disable-multi-os-directory \ + $(use_enable static-libs static) \ + $(use_enable exec-static-trampoline exec-static-tramp) \ + $(use_enable pax-kernel pax_emutramp) \ + $(use_enable debug) +} + +multilib_src_install_all() { + einstalldocs + find "${ED}" -name "*.la" -delete || die +} + +pkg_preinst() { + preserve_old_lib /usr/$(get_libdir)/libffi.so.7 +} + +pkg_postinst() { + preserve_old_lib_notify /usr/$(get_libdir)/libffi.so.7 +}
