ffi 1.15.5 → 1.16.0

Sign up to get free protection for your applications and to get access to all the features.
Files changed (308) hide show
  1. checksums.yaml +4 -4
  2. checksums.yaml.gz.sig +0 -0
  3. data/CHANGELOG.md +54 -0
  4. data/Gemfile +1 -1
  5. data/README.md +3 -2
  6. data/Rakefile +10 -7
  7. data/ext/ffi_c/AbstractMemory.c +56 -34
  8. data/ext/ffi_c/AbstractMemory.h +3 -2
  9. data/ext/ffi_c/ArrayType.c +49 -13
  10. data/ext/ffi_c/ArrayType.h +1 -0
  11. data/ext/ffi_c/Buffer.c +86 -29
  12. data/ext/ffi_c/Call.c +13 -5
  13. data/ext/ffi_c/DynamicLibrary.c +89 -26
  14. data/ext/ffi_c/Function.c +238 -98
  15. data/ext/ffi_c/Function.h +1 -0
  16. data/ext/ffi_c/FunctionInfo.c +78 -24
  17. data/ext/ffi_c/LastError.c +25 -7
  18. data/ext/ffi_c/MappedType.c +66 -23
  19. data/ext/ffi_c/MappedType.h +0 -2
  20. data/ext/ffi_c/MemoryPointer.c +34 -7
  21. data/ext/ffi_c/MethodHandle.c +3 -1
  22. data/ext/ffi_c/Pointer.c +68 -29
  23. data/ext/ffi_c/Pointer.h +1 -0
  24. data/ext/ffi_c/Struct.c +151 -80
  25. data/ext/ffi_c/Struct.h +7 -4
  26. data/ext/ffi_c/StructByValue.c +48 -16
  27. data/ext/ffi_c/StructLayout.c +117 -48
  28. data/ext/ffi_c/Type.c +104 -36
  29. data/ext/ffi_c/Type.h +3 -1
  30. data/ext/ffi_c/Types.c +1 -1
  31. data/ext/ffi_c/Variadic.c +65 -23
  32. data/ext/ffi_c/compat.h +22 -22
  33. data/ext/ffi_c/extconf.rb +19 -2
  34. data/ext/ffi_c/ffi.c +4 -0
  35. data/ext/ffi_c/libffi/.appveyor/site.exp +16 -0
  36. data/ext/ffi_c/libffi/.appveyor/unix-noexec.exp +7 -0
  37. data/ext/ffi_c/libffi/.appveyor.yml +27 -9
  38. data/ext/ffi_c/libffi/.ci/build-cross-in-container.sh +18 -0
  39. data/ext/ffi_c/libffi/{.travis → .ci}/build-in-container.sh +4 -6
  40. data/ext/ffi_c/libffi/.ci/build.sh +124 -0
  41. data/ext/ffi_c/libffi/{.travis → .ci}/install.sh +14 -7
  42. data/ext/ffi_c/libffi/.ci/msvs-detect +1103 -0
  43. data/ext/ffi_c/libffi/{.travis → .ci}/site.exp +5 -3
  44. data/ext/ffi_c/libffi/.circleci/config.yml +156 -0
  45. data/ext/ffi_c/libffi/.github/workflows/build.yml +460 -0
  46. data/ext/ffi_c/libffi/.github/workflows/emscripten.yml +171 -0
  47. data/ext/ffi_c/libffi/.gitignore +10 -2
  48. data/ext/ffi_c/libffi/LICENSE +1 -1
  49. data/ext/ffi_c/libffi/Makefile.am +12 -5
  50. data/ext/ffi_c/libffi/Makefile.in +118 -51
  51. data/ext/ffi_c/libffi/README.md +144 -104
  52. data/ext/ffi_c/libffi/acinclude.m4 +10 -112
  53. data/ext/ffi_c/libffi/config.guess +623 -556
  54. data/ext/ffi_c/libffi/config.sub +75 -34
  55. data/ext/ffi_c/libffi/configure +4571 -3830
  56. data/ext/ffi_c/libffi/configure.ac +64 -28
  57. data/ext/ffi_c/libffi/configure.host +25 -6
  58. data/ext/ffi_c/libffi/doc/Makefile.in +9 -6
  59. data/ext/ffi_c/libffi/doc/libffi.texi +82 -33
  60. data/ext/ffi_c/libffi/doc/version.texi +4 -4
  61. data/ext/ffi_c/libffi/fficonfig.h.in +12 -47
  62. data/ext/ffi_c/libffi/generate-darwin-source-and-headers.py +163 -52
  63. data/ext/ffi_c/libffi/include/Makefile.am +1 -1
  64. data/ext/ffi_c/libffi/include/Makefile.in +10 -9
  65. data/ext/ffi_c/libffi/include/ffi.h.in +54 -50
  66. data/ext/ffi_c/libffi/include/ffi_cfi.h +21 -0
  67. data/ext/ffi_c/libffi/include/ffi_common.h +29 -0
  68. data/ext/ffi_c/libffi/include/tramp.h +45 -0
  69. data/ext/ffi_c/libffi/install-sh +92 -69
  70. data/ext/ffi_c/libffi/libtool-version +2 -2
  71. data/ext/ffi_c/libffi/ltmain.sh +512 -315
  72. data/ext/ffi_c/libffi/m4/ax_cc_maxopt.m4 +18 -14
  73. data/ext/ffi_c/libffi/m4/ax_cflags_warn_all.m4 +108 -72
  74. data/ext/ffi_c/libffi/m4/ax_compiler_vendor.m4 +76 -45
  75. data/ext/ffi_c/libffi/m4/ax_prepend_flag.m4 +51 -0
  76. data/ext/ffi_c/libffi/man/Makefile.in +9 -6
  77. data/ext/ffi_c/libffi/missing +1 -1
  78. data/ext/ffi_c/libffi/msvc_build/aarch64/aarch64_include/ffi.h +1 -1
  79. data/ext/ffi_c/libffi/msvcc.sh +1 -1
  80. data/ext/ffi_c/libffi/src/aarch64/ffi.c +146 -42
  81. data/ext/ffi_c/libffi/src/aarch64/internal.h +32 -0
  82. data/ext/ffi_c/libffi/src/aarch64/sysv.S +134 -42
  83. data/ext/ffi_c/libffi/src/arc/arcompact.S +169 -94
  84. data/ext/ffi_c/libffi/src/arc/ffi.c +325 -148
  85. data/ext/ffi_c/libffi/src/arc/ffitarget.h +14 -0
  86. data/ext/ffi_c/libffi/src/arm/ffi.c +62 -17
  87. data/ext/ffi_c/libffi/src/arm/ffitarget.h +3 -3
  88. data/ext/ffi_c/libffi/src/arm/internal.h +10 -0
  89. data/ext/ffi_c/libffi/src/arm/sysv.S +113 -42
  90. data/ext/ffi_c/libffi/src/closures.c +133 -47
  91. data/ext/ffi_c/libffi/src/dlmalloc.c +5 -0
  92. data/ext/ffi_c/libffi/src/ia64/ffi.c +12 -0
  93. data/ext/ffi_c/libffi/src/ia64/unix.S +20 -2
  94. data/ext/ffi_c/libffi/src/loongarch64/ffi.c +621 -0
  95. data/ext/ffi_c/libffi/src/loongarch64/ffitarget.h +82 -0
  96. data/ext/ffi_c/libffi/src/loongarch64/sysv.S +327 -0
  97. data/ext/ffi_c/libffi/src/m32r/ffi.c +31 -14
  98. data/ext/ffi_c/libffi/src/mips/ffi.c +240 -65
  99. data/ext/ffi_c/libffi/src/mips/ffitarget.h +7 -0
  100. data/ext/ffi_c/libffi/src/mips/n32.S +137 -28
  101. data/ext/ffi_c/libffi/src/mips/o32.S +61 -4
  102. data/ext/ffi_c/libffi/src/moxie/ffi.c +47 -22
  103. data/ext/ffi_c/libffi/src/or1k/ffi.c +25 -12
  104. data/ext/ffi_c/libffi/src/pa/ffi.c +32 -33
  105. data/ext/ffi_c/libffi/src/pa/ffi64.c +614 -0
  106. data/ext/ffi_c/libffi/src/pa/ffitarget.h +22 -8
  107. data/ext/ffi_c/libffi/src/pa/hpux32.S +83 -36
  108. data/ext/ffi_c/libffi/src/pa/hpux64.S +681 -0
  109. data/ext/ffi_c/libffi/src/pa/linux.S +82 -35
  110. data/ext/ffi_c/libffi/src/powerpc/ffi_linux64.c +1 -1
  111. data/ext/ffi_c/libffi/src/powerpc/linux64.S +2 -0
  112. data/ext/ffi_c/libffi/src/powerpc/linux64_closure.S +2 -0
  113. data/ext/ffi_c/libffi/src/powerpc/t-aix +5 -0
  114. data/ext/ffi_c/libffi/src/prep_cif.c +22 -2
  115. data/ext/ffi_c/libffi/src/riscv/ffi.c +37 -4
  116. data/ext/ffi_c/libffi/src/sparc/ffi64.c +16 -0
  117. data/ext/ffi_c/libffi/src/tramp.c +716 -0
  118. data/ext/ffi_c/libffi/src/wasm32/ffi.c +934 -0
  119. data/ext/ffi_c/libffi/src/wasm32/ffitarget.h +62 -0
  120. data/ext/ffi_c/libffi/src/x86/ffi.c +99 -37
  121. data/ext/ffi_c/libffi/src/x86/ffi64.c +67 -12
  122. data/ext/ffi_c/libffi/src/x86/ffitarget.h +9 -5
  123. data/ext/ffi_c/libffi/src/x86/ffiw64.c +43 -0
  124. data/ext/ffi_c/libffi/src/x86/internal.h +14 -0
  125. data/ext/ffi_c/libffi/src/x86/internal64.h +14 -0
  126. data/ext/ffi_c/libffi/src/x86/sysv.S +172 -38
  127. data/ext/ffi_c/libffi/src/x86/sysv_intel.S +91 -88
  128. data/ext/ffi_c/libffi/src/x86/unix64.S +96 -6
  129. data/ext/ffi_c/libffi/src/x86/win64.S +20 -7
  130. data/ext/ffi_c/libffi/src/xtensa/ffi.c +16 -8
  131. data/ext/ffi_c/libffi/src/xtensa/ffitarget.h +4 -0
  132. data/ext/ffi_c/libffi/src/xtensa/sysv.S +26 -16
  133. data/ext/ffi_c/libffi/testsuite/Makefile.am +127 -114
  134. data/ext/ffi_c/libffi/testsuite/Makefile.in +137 -121
  135. data/ext/ffi_c/libffi/testsuite/emscripten/build-tests.sh +54 -0
  136. data/ext/ffi_c/libffi/testsuite/emscripten/build.sh +63 -0
  137. data/ext/ffi_c/libffi/testsuite/emscripten/conftest.py +80 -0
  138. data/ext/ffi_c/libffi/testsuite/emscripten/node-tests.sh +48 -0
  139. data/ext/ffi_c/libffi/testsuite/emscripten/test.html +7 -0
  140. data/ext/ffi_c/libffi/testsuite/emscripten/test_libffi.py +51 -0
  141. data/ext/ffi_c/libffi/testsuite/lib/libffi.exp +43 -21
  142. data/ext/ffi_c/libffi/testsuite/lib/target-libpath.exp +2 -2
  143. data/ext/ffi_c/libffi/testsuite/libffi.bhaible/test-call.c +1 -0
  144. data/ext/ffi_c/libffi/testsuite/libffi.bhaible/testcases.c +5 -1
  145. data/ext/ffi_c/libffi/testsuite/libffi.call/bpo_38748.c +41 -0
  146. data/ext/ffi_c/libffi/testsuite/libffi.call/ffitest.h +28 -3
  147. data/ext/ffi_c/libffi/testsuite/libffi.call/float_va.c +3 -0
  148. data/ext/ffi_c/libffi/testsuite/libffi.call/return_ll1.c +5 -0
  149. data/ext/ffi_c/libffi/testsuite/libffi.call/return_sl.c +4 -0
  150. data/ext/ffi_c/libffi/testsuite/libffi.call/return_ul.c +4 -0
  151. data/ext/ffi_c/libffi/testsuite/libffi.call/s55.c +60 -0
  152. data/ext/ffi_c/libffi/testsuite/libffi.call/strlen.c +8 -9
  153. data/ext/ffi_c/libffi/testsuite/libffi.call/strlen2.c +2 -2
  154. data/ext/ffi_c/libffi/testsuite/libffi.call/strlen3.c +2 -2
  155. data/ext/ffi_c/libffi/testsuite/libffi.call/strlen4.c +2 -2
  156. data/ext/ffi_c/libffi/testsuite/libffi.call/struct10.c +1 -1
  157. data/ext/ffi_c/libffi/testsuite/libffi.call/struct_by_value_2.c +63 -0
  158. data/ext/ffi_c/libffi/testsuite/libffi.call/struct_by_value_3.c +65 -0
  159. data/ext/ffi_c/libffi/testsuite/libffi.call/struct_by_value_3f.c +65 -0
  160. data/ext/ffi_c/libffi/testsuite/libffi.call/struct_by_value_4.c +67 -0
  161. data/ext/ffi_c/libffi/testsuite/libffi.call/struct_by_value_4f.c +67 -0
  162. data/ext/ffi_c/libffi/testsuite/libffi.call/struct_by_value_big.c +93 -0
  163. data/ext/ffi_c/libffi/testsuite/libffi.call/struct_by_value_small.c +61 -0
  164. data/ext/ffi_c/libffi/testsuite/libffi.call/struct_return_2H.c +63 -0
  165. data/ext/ffi_c/libffi/testsuite/libffi.call/struct_return_8H.c +90 -0
  166. data/ext/ffi_c/libffi/testsuite/libffi.call/va_1.c +1 -119
  167. data/ext/ffi_c/libffi/testsuite/libffi.call/va_2.c +220 -0
  168. data/ext/ffi_c/libffi/testsuite/libffi.call/va_3.c +154 -0
  169. data/ext/ffi_c/libffi/testsuite/libffi.call/va_struct1.c +13 -0
  170. data/ext/ffi_c/libffi/testsuite/libffi.call/va_struct2.c +11 -0
  171. data/ext/ffi_c/libffi/testsuite/libffi.call/va_struct3.c +15 -0
  172. data/ext/ffi_c/libffi/testsuite/libffi.closures/closure_fn0.c +3 -2
  173. data/ext/ffi_c/libffi/testsuite/libffi.closures/closure_fn1.c +2 -0
  174. data/ext/ffi_c/libffi/testsuite/libffi.closures/closure_fn2.c +2 -0
  175. data/ext/ffi_c/libffi/testsuite/libffi.closures/closure_fn3.c +21 -1
  176. data/ext/ffi_c/libffi/testsuite/libffi.closures/closure_fn4.c +2 -0
  177. data/ext/ffi_c/libffi/testsuite/libffi.closures/closure_fn5.c +2 -0
  178. data/ext/ffi_c/libffi/testsuite/libffi.closures/closure_fn6.c +2 -0
  179. data/ext/ffi_c/libffi/testsuite/libffi.closures/closure_loc_fn0.c +7 -6
  180. data/ext/ffi_c/libffi/testsuite/libffi.closures/closure_simple.c +6 -0
  181. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_12byte.c +18 -0
  182. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_16byte.c +22 -0
  183. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_18byte.c +24 -0
  184. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_19byte.c +29 -0
  185. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_1_1byte.c +4 -0
  186. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_20byte.c +19 -1
  187. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_20byte1.c +21 -1
  188. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_24byte.c +35 -3
  189. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_2byte.c +13 -0
  190. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_3_1byte.c +19 -0
  191. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_3byte1.c +13 -0
  192. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_3byte2.c +13 -0
  193. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_3float.c +18 -0
  194. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_4_1byte.c +22 -0
  195. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_4byte.c +13 -0
  196. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_5_1_byte.c +29 -1
  197. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_5byte.c +19 -1
  198. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_64byte.c +24 -0
  199. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_6_1_byte.c +28 -1
  200. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_6byte.c +24 -2
  201. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_7_1_byte.c +39 -1
  202. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_7byte.c +25 -1
  203. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_8byte.c +14 -0
  204. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_9byte1.c +14 -1
  205. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_9byte2.c +14 -2
  206. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_align_double.c +19 -1
  207. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_align_float.c +19 -1
  208. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_align_longdouble.c +20 -1
  209. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_align_longdouble_split.c +40 -25
  210. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_align_longdouble_split2.c +40 -3
  211. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_align_pointer.c +19 -1
  212. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_align_sint16.c +18 -1
  213. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_align_sint32.c +18 -3
  214. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_align_sint64.c +18 -1
  215. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_align_uint16.c +18 -1
  216. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_align_uint32.c +19 -1
  217. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_align_uint64.c +19 -1
  218. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_dbls_struct.c +3 -1
  219. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_double_va.c +9 -1
  220. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_float.c +4 -0
  221. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_longdouble.c +11 -1
  222. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_longdouble_va.c +22 -3
  223. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_multi_schar.c +5 -1
  224. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_multi_sshort.c +6 -1
  225. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_multi_sshortchar.c +9 -1
  226. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_multi_uchar.c +9 -1
  227. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_multi_ushort.c +6 -2
  228. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_multi_ushortchar.c +9 -1
  229. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_pointer.c +5 -0
  230. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_pointer_stack.c +10 -0
  231. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_schar.c +3 -0
  232. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_sint.c +2 -0
  233. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_sshort.c +3 -0
  234. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_struct_va1.c +11 -0
  235. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_uchar.c +3 -0
  236. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_uint.c +4 -0
  237. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_uint_va.c +4 -0
  238. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_ulong_va.c +4 -0
  239. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_ulonglong.c +2 -0
  240. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_ushort.c +3 -0
  241. data/ext/ffi_c/libffi/testsuite/libffi.closures/ffitest.h +1 -138
  242. data/ext/ffi_c/libffi/testsuite/libffi.closures/huge_struct.c +21 -21
  243. data/ext/ffi_c/libffi/testsuite/libffi.closures/nested_struct.c +32 -9
  244. data/ext/ffi_c/libffi/testsuite/libffi.closures/nested_struct1.c +1 -1
  245. data/ext/ffi_c/libffi/testsuite/libffi.closures/nested_struct10.c +12 -0
  246. data/ext/ffi_c/libffi/testsuite/libffi.closures/nested_struct11.c +21 -5
  247. data/ext/ffi_c/libffi/testsuite/libffi.closures/nested_struct12.c +86 -0
  248. data/ext/ffi_c/libffi/testsuite/libffi.closures/nested_struct13.c +115 -0
  249. data/ext/ffi_c/libffi/testsuite/libffi.closures/nested_struct2.c +10 -1
  250. data/ext/ffi_c/libffi/testsuite/libffi.closures/nested_struct3.c +10 -1
  251. data/ext/ffi_c/libffi/testsuite/libffi.closures/nested_struct4.c +9 -0
  252. data/ext/ffi_c/libffi/testsuite/libffi.closures/nested_struct5.c +9 -0
  253. data/ext/ffi_c/libffi/testsuite/libffi.closures/nested_struct6.c +11 -0
  254. data/ext/ffi_c/libffi/testsuite/libffi.closures/nested_struct7.c +9 -0
  255. data/ext/ffi_c/libffi/testsuite/libffi.closures/nested_struct8.c +11 -0
  256. data/ext/ffi_c/libffi/testsuite/libffi.closures/nested_struct9.c +11 -0
  257. data/ext/ffi_c/libffi/testsuite/libffi.closures/single_entry_structs1.c +86 -0
  258. data/ext/ffi_c/libffi/testsuite/libffi.closures/single_entry_structs2.c +102 -0
  259. data/ext/ffi_c/libffi/testsuite/libffi.closures/single_entry_structs3.c +101 -0
  260. data/ext/ffi_c/libffi/testsuite/libffi.closures/stret_medium.c +1 -1
  261. data/ext/ffi_c/libffi/testsuite/libffi.closures/stret_medium2.c +1 -1
  262. data/ext/ffi_c/libffi/testsuite/libffi.closures/testclosure.c +6 -1
  263. data/ext/ffi_c/libffi/testsuite/libffi.closures/unwindtest.cc +2 -1
  264. data/ext/ffi_c/libffi/testsuite/libffi.closures/unwindtest_ffi_call.cc +1 -0
  265. data/ext/ffi_c/libffi.bsd.mk +2 -2
  266. data/ext/ffi_c/libffi.gnu.mk +2 -2
  267. data/ext/ffi_c/rbffi.h +1 -1
  268. data/ffi.gemspec +2 -2
  269. data/lib/ffi/autopointer.rb +7 -22
  270. data/lib/ffi/compat.rb +43 -0
  271. data/lib/ffi/data_converter.rb +2 -2
  272. data/lib/ffi/dynamic_library.rb +89 -0
  273. data/lib/ffi/enum.rb +18 -11
  274. data/lib/ffi/ffi.rb +3 -0
  275. data/lib/ffi/function.rb +71 -0
  276. data/lib/ffi/library.rb +55 -71
  277. data/lib/ffi/library_path.rb +109 -0
  278. data/lib/ffi/managedstruct.rb +1 -1
  279. data/lib/ffi/platform/aarch64-windows/types.conf +52 -0
  280. data/lib/ffi/platform/hppa1.1-linux/types.conf +178 -0
  281. data/lib/ffi/platform/hppa2.0-linux/types.conf +178 -0
  282. data/lib/ffi/platform/loongarch64-linux/types.conf +141 -0
  283. data/lib/ffi/platform/sw_64-linux/types.conf +141 -0
  284. data/lib/ffi/platform.rb +15 -13
  285. data/lib/ffi/struct.rb +2 -1
  286. data/lib/ffi/struct_layout.rb +1 -1
  287. data/lib/ffi/struct_layout_builder.rb +1 -1
  288. data/lib/ffi/types.rb +30 -5
  289. data/lib/ffi/variadic.rb +19 -8
  290. data/lib/ffi/version.rb +1 -1
  291. data.tar.gz.sig +0 -0
  292. metadata +97 -25
  293. metadata.gz.sig +1 -0
  294. data/ext/ffi_c/libffi/.travis/build-cross-in-container.sh +0 -14
  295. data/ext/ffi_c/libffi/.travis/build.sh +0 -142
  296. data/ext/ffi_c/libffi/.travis.yml +0 -83
  297. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_uchar_va.c +0 -44
  298. data/ext/ffi_c/libffi/testsuite/libffi.closures/cls_ushort_va.c +0 -44
  299. /data/ext/ffi_c/libffi/{.travis → .ci}/ar-lib +0 -0
  300. /data/ext/ffi_c/libffi/{.travis → .ci}/bfin-sim.exp +0 -0
  301. /data/ext/ffi_c/libffi/{.travis → .ci}/compile +0 -0
  302. /data/ext/ffi_c/libffi/{.travis → .ci}/m32r-sim.exp +0 -0
  303. /data/ext/ffi_c/libffi/{.travis → .ci}/moxie-sim.exp +0 -0
  304. /data/ext/ffi_c/libffi/{.travis → .ci}/or1k-sim.exp +0 -0
  305. /data/ext/ffi_c/libffi/{.travis → .ci}/powerpc-eabisim.exp +0 -0
  306. /data/ext/ffi_c/libffi/{.travis → .ci}/wine-sim.exp +0 -0
  307. /data/ext/ffi_c/libffi/testsuite/libffi.call/{pyobjc-tc.c → pyobjc_tc.c} +0 -0
  308. /data/lib/ffi/platform/{sparc64-linux → sparcv9-linux}/types.conf +0 -0
@@ -0,0 +1,934 @@
1
+ /* -----------------------------------------------------------------------
2
+ ffi.c - Copyright (c) 2018-2023 Hood Chatham, Brion Vibber, Kleis Auke Wolthuizen, and others.
3
+
4
+ wasm32/emscripten Foreign Function Interface
5
+
6
+ Permission is hereby granted, free of charge, to any person obtaining
7
+ a copy of this software and associated documentation files (the
8
+ ``Software''), to deal in the Software without restriction, including
9
+ without limitation the rights to use, copy, modify, merge, publish,
10
+ distribute, sublicense, and/or sell copies of the Software, and to
11
+ permit persons to whom the Software is furnished to do so, subject to
12
+ the following conditions:
13
+
14
+ The above copyright notice and this permission notice shall be included
15
+ in all copies or substantial portions of the Software.
16
+
17
+ THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,
18
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
19
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
20
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
21
+ HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
22
+ WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
23
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
24
+ DEALINGS IN THE SOFTWARE.
25
+ ----------------------------------------------------------------------- */
26
+
27
+ #include <ffi.h>
28
+ #include <ffi_common.h>
29
+
30
+ #include <stdlib.h>
31
+ #include <stdint.h>
32
+
33
+ #include <emscripten/emscripten.h>
34
+
35
+ #ifdef DEBUG_F
36
+ #define LOG_DEBUG(args...) \
37
+ console.warn(`====LIBFFI(line __LINE__)`, args)
38
+ #else
39
+ #define LOG_DEBUG(args...) 0
40
+ #endif
41
+
42
+ #define EM_JS_MACROS(ret, name, args, body...) EM_JS(ret, name, args, body)
43
+
44
+ #if WASM_BIGINT
45
+ EM_JS_DEPS(libffi, "$getWasmTableEntry,$setWasmTableEntry,$getEmptyTableSlot,$convertJsFunctionToWasm");
46
+ #define CALL_FUNCTION_POINTER(ptr, args...) \
47
+ (LOG_DEBUG("CALL_FUNC_PTR", ptr, args), \
48
+ getWasmTableEntry(ptr).apply(null, args))
49
+
50
+ #define JS_FUNCTION_TO_WASM convertJsFunctionToWasm
51
+ #else
52
+ EM_JS_DEPS(libffi, "$getWasmTableEntry,$setWasmTableEntry,$getEmptyTableSlot,$convertJsFunctionToWasm,$dynCall,$generateFuncType,$uleb128Encode");
53
+ #define CALL_FUNCTION_POINTER(ptr, args...) \
54
+ (LOG_DEBUG("CALL_FUNC_PTR", sig, ptr, args), \
55
+ dynCall(sig, ptr, args))
56
+
57
+ #define JS_FUNCTION_TO_WASM createLegalizerWrapper
58
+ #endif
59
+
60
+ // Signature calculations are not needed if WASM_BIGINT is present.
61
+ #if WASM_BIGINT
62
+ #define SIG(sig)
63
+ #else
64
+ #define SIG(sig) sig
65
+ #endif
66
+
67
+ #define DEREF_U8(addr, offset) HEAPU8[addr + offset]
68
+ #define DEREF_S8(addr, offset) HEAP8[addr + offset]
69
+ #define DEREF_U16(addr, offset) HEAPU16[(addr >> 1) + offset]
70
+ #define DEREF_S16(addr, offset) HEAP16[(addr >> 1) + offset]
71
+ #define DEREF_U32(addr, offset) HEAPU32[(addr >> 2) + offset]
72
+ #define DEREF_S32(addr, offset) HEAP32[(addr >> 2) + offset]
73
+
74
+ #define DEREF_F32(addr, offset) HEAPF32[(addr >> 2) + offset]
75
+ #define DEREF_F64(addr, offset) HEAPF64[(addr >> 3) + offset]
76
+
77
+ #if WASM_BIGINT
78
+ // We have HEAPU64 in this case.
79
+ #define DEREF_U64(addr, offset) HEAPU64[(addr >> 3) + offset]
80
+ #endif
81
+
82
+
83
+ #define CHECK_FIELD_OFFSET(struct, field, offset) \
84
+ _Static_assert( \
85
+ offsetof(struct, field) == offset, \
86
+ "Memory layout of '" #struct "' has changed: '" #field "' is in an unexpected location");
87
+
88
+ CHECK_FIELD_OFFSET(ffi_cif, abi, 4*0);
89
+ CHECK_FIELD_OFFSET(ffi_cif, nargs, 4*1);
90
+ CHECK_FIELD_OFFSET(ffi_cif, arg_types, 4*2);
91
+ CHECK_FIELD_OFFSET(ffi_cif, rtype, 4*3);
92
+ CHECK_FIELD_OFFSET(ffi_cif, nfixedargs, 4*6);
93
+
94
+ #define CIF__ABI(addr) DEREF_U32(addr, 0)
95
+ #define CIF__NARGS(addr) DEREF_U32(addr, 1)
96
+ #define CIF__ARGTYPES(addr) DEREF_U32(addr, 2)
97
+ #define CIF__RTYPE(addr) DEREF_U32(addr, 3)
98
+ #define CIF__NFIXEDARGS(addr) DEREF_U32(addr, 6)
99
+
100
+ CHECK_FIELD_OFFSET(ffi_type, size, 0);
101
+ CHECK_FIELD_OFFSET(ffi_type, alignment, 4);
102
+ CHECK_FIELD_OFFSET(ffi_type, type, 6);
103
+ CHECK_FIELD_OFFSET(ffi_type, elements, 8);
104
+
105
+ #define FFI_TYPE__SIZE(addr) DEREF_U32(addr, 0)
106
+ #define FFI_TYPE__ALIGN(addr) DEREF_U16(addr + 4, 0)
107
+ #define FFI_TYPE__TYPEID(addr) DEREF_U16(addr + 6, 0)
108
+ #define FFI_TYPE__ELEMENTS(addr) DEREF_U32(addr + 8, 0)
109
+
110
+ #define ALIGN_ADDRESS(addr, align) (addr &= (~((align) - 1)))
111
+ #define STACK_ALLOC(stack, size, align) ((stack -= (size)), ALIGN_ADDRESS(stack, align))
112
+
113
+ // Most wasm runtimes support at most 1000 Js trampoline args.
114
+ #define MAX_ARGS 1000
115
+
116
+ #include <stddef.h>
117
+
118
+ #define VARARGS_FLAG 1
119
+
120
+ #define FFI_OK_MACRO 0
121
+ _Static_assert(FFI_OK_MACRO == FFI_OK, "FFI_OK must be 0");
122
+
123
+ #define FFI_BAD_TYPEDEF_MACRO 1
124
+ _Static_assert(FFI_BAD_TYPEDEF_MACRO == FFI_BAD_TYPEDEF, "FFI_BAD_TYPEDEF must be 1");
125
+
126
+ ffi_status FFI_HIDDEN
127
+ ffi_prep_cif_machdep(ffi_cif *cif)
128
+ {
129
+ if (cif->abi != FFI_WASM32_EMSCRIPTEN)
130
+ return FFI_BAD_ABI;
131
+ // This is called after ffi_prep_cif_machdep_var so we need to avoid
132
+ // overwriting cif->nfixedargs.
133
+ if (!(cif->flags & VARARGS_FLAG))
134
+ cif->nfixedargs = cif->nargs;
135
+ if (cif->nargs > MAX_ARGS)
136
+ return FFI_BAD_TYPEDEF;
137
+ if (cif->rtype->type == FFI_TYPE_COMPLEX)
138
+ return FFI_BAD_TYPEDEF;
139
+ // If they put the COMPLEX type into a struct we won't notice, but whatever.
140
+ for (int i = 0; i < cif->nargs; i++)
141
+ if (cif->arg_types[i]->type == FFI_TYPE_COMPLEX)
142
+ return FFI_BAD_TYPEDEF;
143
+ return FFI_OK;
144
+ }
145
+
146
+ ffi_status FFI_HIDDEN
147
+ ffi_prep_cif_machdep_var(ffi_cif *cif, unsigned nfixedargs, unsigned ntotalargs)
148
+ {
149
+ cif->flags |= VARARGS_FLAG;
150
+ cif->nfixedargs = nfixedargs;
151
+ // The varargs takes up one extra argument
152
+ if (cif->nfixedargs + 1 > MAX_ARGS)
153
+ return FFI_BAD_TYPEDEF;
154
+ return FFI_OK;
155
+ }
156
+
157
+ /**
158
+ * A Javascript helper function. This takes an argument typ which is a wasm
159
+ * pointer to an ffi_type object. It returns a pair a type and a type id.
160
+ *
161
+ * - If it is not a struct, return its type and its typeid field.
162
+ * - If it is a struct of size >= 2, return the type and its typeid (which
163
+ * will be FFI_TYPE_STRUCT)
164
+ * - If it is a struct of size 0, return FFI_TYPE_VOID (????? this is broken)
165
+ * - If it is a struct of size 1, replace it with the single field and apply
166
+ * the same logic again to that.
167
+ *
168
+ * By always unboxing structs up front, we can avoid messy casework later.
169
+ */
170
+ EM_JS_MACROS(
171
+ void,
172
+ unbox_small_structs, (ffi_type type_ptr), {
173
+ var type_id = FFI_TYPE__TYPEID(type_ptr);
174
+ while (type_id === FFI_TYPE_STRUCT) {
175
+ var elements = FFI_TYPE__ELEMENTS(type_ptr);
176
+ var first_element = DEREF_U32(elements, 0);
177
+ if (first_element === 0) {
178
+ type_id = FFI_TYPE_VOID;
179
+ break;
180
+ } else if (DEREF_U32(elements, 1) === 0) {
181
+ type_ptr = first_element;
182
+ type_id = FFI_TYPE__TYPEID(first_element);
183
+ } else {
184
+ break;
185
+ }
186
+ }
187
+ return [type_ptr, type_id];
188
+ })
189
+
190
+ EM_JS_MACROS(
191
+ void,
192
+ ffi_call_js, (ffi_cif *cif, ffi_fp fn, void *rvalue, void **avalue),
193
+ {
194
+ var abi = CIF__ABI(cif);
195
+ var nargs = CIF__NARGS(cif);
196
+ var nfixedargs = CIF__NFIXEDARGS(cif);
197
+ var arg_types_ptr = CIF__ARGTYPES(cif);
198
+ var rtype_unboxed = unbox_small_structs(CIF__RTYPE(cif));
199
+ var rtype_ptr = rtype_unboxed[0];
200
+ var rtype_id = rtype_unboxed[1];
201
+ var orig_stack_ptr = stackSave();
202
+ var cur_stack_ptr = orig_stack_ptr;
203
+
204
+ var args = [];
205
+ // Does our onwards call return by argument or normally? We return by argument
206
+ // no matter what.
207
+ var ret_by_arg = false;
208
+
209
+ if (rtype_id === FFI_TYPE_COMPLEX) {
210
+ throw new Error('complex ret marshalling nyi');
211
+ }
212
+ if (rtype_id < 0 || rtype_id > FFI_TYPE_LAST) {
213
+ throw new Error('Unexpected rtype ' + rtype_id);
214
+ }
215
+ // If the return type is a struct with multiple entries or a long double, the
216
+ // function takes an extra first argument which is a pointer to return value.
217
+ // Conveniently, we've already received a pointer to return value, so we can
218
+ // just use this. We also mark a flag that we don't need to convert the return
219
+ // value of the dynamic call back to C.
220
+ if (rtype_id === FFI_TYPE_LONGDOUBLE || rtype_id === FFI_TYPE_STRUCT) {
221
+ args.push(rvalue);
222
+ ret_by_arg = true;
223
+ }
224
+
225
+ SIG(var sig = "");
226
+
227
+ #if !WASM_BIGINT
228
+ switch(rtype_id) {
229
+ case FFI_TYPE_VOID:
230
+ SIG(sig = 'v');
231
+ break;
232
+ case FFI_TYPE_STRUCT:
233
+ case FFI_TYPE_LONGDOUBLE:
234
+ SIG(sig = 'vi');
235
+ break;
236
+ case FFI_TYPE_INT:
237
+ case FFI_TYPE_UINT8:
238
+ case FFI_TYPE_SINT8:
239
+ case FFI_TYPE_UINT16:
240
+ case FFI_TYPE_SINT16:
241
+ case FFI_TYPE_UINT32:
242
+ case FFI_TYPE_SINT32:
243
+ case FFI_TYPE_POINTER:
244
+ SIG(sig = 'i');
245
+ break;
246
+ case FFI_TYPE_FLOAT:
247
+ SIG(sig = 'f');
248
+ break;
249
+ case FFI_TYPE_DOUBLE:
250
+ SIG(sig = 'd');
251
+ break;
252
+ case FFI_TYPE_UINT64:
253
+ case FFI_TYPE_SINT64:
254
+ SIG(sig = 'j');
255
+ break;
256
+ }
257
+ #endif
258
+
259
+ // Accumulate a Javascript list of arguments for the Javascript wrapper for
260
+ // the wasm function. The Javascript wrapper does a type conversion from
261
+ // Javascript to C automatically, here we manually do the inverse conversion
262
+ // from C to Javascript.
263
+ for (var i = 0; i < nfixedargs; i++) {
264
+ var arg_ptr = DEREF_U32(avalue, i);
265
+ var arg_unboxed = unbox_small_structs(DEREF_U32(arg_types_ptr, i));
266
+ var arg_type_ptr = arg_unboxed[0];
267
+ var arg_type_id = arg_unboxed[1];
268
+
269
+ // It's okay here to always use unsigned integers as long as the size is 32
270
+ // or 64 bits. Smaller sizes get extended to 32 bits differently according
271
+ // to whether they are signed or unsigned.
272
+ switch (arg_type_id) {
273
+ case FFI_TYPE_INT:
274
+ case FFI_TYPE_SINT32:
275
+ case FFI_TYPE_UINT32:
276
+ case FFI_TYPE_POINTER:
277
+ args.push(DEREF_U32(arg_ptr, 0));
278
+ SIG(sig += 'i');
279
+ break;
280
+ case FFI_TYPE_FLOAT:
281
+ args.push(DEREF_F32(arg_ptr, 0));
282
+ SIG(sig += 'f');
283
+ break;
284
+ case FFI_TYPE_DOUBLE:
285
+ args.push(DEREF_F64(arg_ptr, 0));
286
+ SIG(sig += 'd');
287
+ break;
288
+ case FFI_TYPE_UINT8:
289
+ args.push(DEREF_U8(arg_ptr, 0));
290
+ SIG(sig += 'i');
291
+ break;
292
+ case FFI_TYPE_SINT8:
293
+ args.push(DEREF_S8(arg_ptr, 0));
294
+ SIG(sig += 'i');
295
+ break;
296
+ case FFI_TYPE_UINT16:
297
+ args.push(DEREF_U16(arg_ptr, 0));
298
+ SIG(sig += 'i');
299
+ break;
300
+ case FFI_TYPE_SINT16:
301
+ args.push(DEREF_S16(arg_ptr, 0));
302
+ SIG(sig += 'i');
303
+ break;
304
+ case FFI_TYPE_UINT64:
305
+ case FFI_TYPE_SINT64:
306
+ #if WASM_BIGINT
307
+ args.push(DEREF_U64(arg_ptr, 0));
308
+ #else
309
+ args.push(DEREF_U32(arg_ptr, 0));
310
+ args.push(DEREF_U32(arg_ptr, 1));
311
+ #endif
312
+ SIG(sig += 'j');
313
+ break;
314
+ case FFI_TYPE_LONGDOUBLE:
315
+ // long double is passed as a pair of BigInts.
316
+ #if WASM_BIGINT
317
+ args.push(DEREF_U64(arg_ptr, 0));
318
+ args.push(DEREF_U64(arg_ptr, 1));
319
+ #else
320
+ args.push(DEREF_U32(arg_ptr, 0));
321
+ args.push(DEREF_U32(arg_ptr, 1));
322
+ args.push(DEREF_U32(arg_ptr, 2));
323
+ args.push(DEREF_U32(arg_ptr, 3));
324
+ #endif
325
+ SIG(sig += "jj");
326
+ break;
327
+ case FFI_TYPE_STRUCT:
328
+ // Nontrivial structs are passed by pointer.
329
+ // Have to copy the struct onto the stack though because C ABI says it's
330
+ // call by value.
331
+ var size = FFI_TYPE__SIZE(arg_type_ptr);
332
+ var align = FFI_TYPE__ALIGN(arg_type_ptr);
333
+ STACK_ALLOC(cur_stack_ptr, size, align);
334
+ HEAP8.subarray(cur_stack_ptr, cur_stack_ptr+size).set(HEAP8.subarray(arg_ptr, arg_ptr + size));
335
+ args.push(cur_stack_ptr);
336
+ SIG(sig += 'i');
337
+ break;
338
+ case FFI_TYPE_COMPLEX:
339
+ throw new Error('complex marshalling nyi');
340
+ default:
341
+ throw new Error('Unexpected type ' + arg_type_id);
342
+ }
343
+ }
344
+
345
+ // Wasm functions can't directly manipulate the callstack, so varargs
346
+ // arguments have to go on a separate stack. A varags function takes one extra
347
+ // argument which is a pointer to where on the separate stack the args are
348
+ // located. Because stacks are allocated backwards, we have to loop over the
349
+ // varargs backwards.
350
+ //
351
+ // We don't have any way of knowing how many args were actually passed, so we
352
+ // just always copy extra nonsense past the end. The ownwards call will know
353
+ // not to look at it.
354
+ if (nfixedargs != nargs) {
355
+ SIG(sig += 'i');
356
+ var struct_arg_info = [];
357
+ for (var i = nargs - 1; i >= nfixedargs; i--) {
358
+ var arg_ptr = DEREF_U32(avalue, i);
359
+ var arg_unboxed = unbox_small_structs(DEREF_U32(arg_types_ptr, i));
360
+ var arg_type_ptr = arg_unboxed[0];
361
+ var arg_type_id = arg_unboxed[1];
362
+ switch (arg_type_id) {
363
+ case FFI_TYPE_UINT8:
364
+ case FFI_TYPE_SINT8:
365
+ STACK_ALLOC(cur_stack_ptr, 1, 1);
366
+ DEREF_U8(cur_stack_ptr, 0) = DEREF_U8(arg_ptr, 0);
367
+ break;
368
+ case FFI_TYPE_UINT16:
369
+ case FFI_TYPE_SINT16:
370
+ STACK_ALLOC(cur_stack_ptr, 2, 2);
371
+ DEREF_U16(cur_stack_ptr, 0) = DEREF_U16(arg_ptr, 0);
372
+ break;
373
+ case FFI_TYPE_INT:
374
+ case FFI_TYPE_UINT32:
375
+ case FFI_TYPE_SINT32:
376
+ case FFI_TYPE_POINTER:
377
+ case FFI_TYPE_FLOAT:
378
+ STACK_ALLOC(cur_stack_ptr, 4, 4);
379
+ DEREF_U32(cur_stack_ptr, 0) = DEREF_U32(arg_ptr, 0);
380
+ break;
381
+ case FFI_TYPE_DOUBLE:
382
+ case FFI_TYPE_UINT64:
383
+ case FFI_TYPE_SINT64:
384
+ STACK_ALLOC(cur_stack_ptr, 8, 8);
385
+ DEREF_U32(cur_stack_ptr, 0) = DEREF_U32(arg_ptr, 0);
386
+ DEREF_U32(cur_stack_ptr, 1) = DEREF_U32(arg_ptr, 1);
387
+ break;
388
+ case FFI_TYPE_LONGDOUBLE:
389
+ STACK_ALLOC(cur_stack_ptr, 16, 8);
390
+ DEREF_U32(cur_stack_ptr, 0) = DEREF_U32(arg_ptr, 0);
391
+ DEREF_U32(cur_stack_ptr, 1) = DEREF_U32(arg_ptr, 1);
392
+ DEREF_U32(cur_stack_ptr, 2) = DEREF_U32(arg_ptr, 2);
393
+ DEREF_U32(cur_stack_ptr, 3) = DEREF_U32(arg_ptr, 3);
394
+ break;
395
+ case FFI_TYPE_STRUCT:
396
+ // Again, struct must be passed by pointer.
397
+ // But ABI is by value, so have to copy struct onto stack.
398
+ // Currently arguments are going onto stack so we can't put it there now. Come back for this.
399
+ STACK_ALLOC(cur_stack_ptr, 4, 4);
400
+ struct_arg_info.push([cur_stack_ptr, arg_ptr, FFI_TYPE__SIZE(arg_type_ptr), FFI_TYPE__ALIGN(arg_type_ptr)]);
401
+ break;
402
+ case FFI_TYPE_COMPLEX:
403
+ throw new Error('complex arg marshalling nyi');
404
+ default:
405
+ throw new Error('Unexpected argtype ' + arg_type_id);
406
+ }
407
+ }
408
+ // extra normal argument which is the pointer to the varargs.
409
+ args.push(cur_stack_ptr);
410
+ // Now allocate variable struct args on stack too.
411
+ for (var i = 0; i < struct_arg_info.length; i++) {
412
+ var struct_info = struct_arg_info[i];
413
+ var arg_target = struct_info[0];
414
+ var arg_ptr = struct_info[1];
415
+ var size = struct_info[2];
416
+ var align = struct_info[3];
417
+ STACK_ALLOC(cur_stack_ptr, size, align);
418
+ HEAP8.subarray(cur_stack_ptr, cur_stack_ptr+size).set(HEAP8.subarray(arg_ptr, arg_ptr + size));
419
+ DEREF_U32(arg_target, 0) = cur_stack_ptr;
420
+ }
421
+ }
422
+ stackRestore(cur_stack_ptr);
423
+ stackAlloc(0); // stackAlloc enforces alignment invariants on the stack pointer
424
+ var result = CALL_FUNCTION_POINTER(fn, args);
425
+ // Put the stack pointer back (we moved it if there were any struct args or we
426
+ // made a varargs call)
427
+ stackRestore(orig_stack_ptr);
428
+
429
+ // We need to return by argument. If return value was a nontrivial struct or
430
+ // long double, the onwards call already put the return value in rvalue
431
+ if (ret_by_arg) {
432
+ return;
433
+ }
434
+
435
+ // Otherwise the result was automatically converted from C into Javascript and
436
+ // we need to manually convert it back to C.
437
+ switch (rtype_id) {
438
+ case FFI_TYPE_VOID:
439
+ break;
440
+ case FFI_TYPE_INT:
441
+ case FFI_TYPE_UINT32:
442
+ case FFI_TYPE_SINT32:
443
+ case FFI_TYPE_POINTER:
444
+ DEREF_U32(rvalue, 0) = result;
445
+ break;
446
+ case FFI_TYPE_FLOAT:
447
+ DEREF_F32(rvalue, 0) = result;
448
+ break;
449
+ case FFI_TYPE_DOUBLE:
450
+ DEREF_F64(rvalue, 0) = result;
451
+ break;
452
+ case FFI_TYPE_UINT8:
453
+ case FFI_TYPE_SINT8:
454
+ DEREF_U8(rvalue, 0) = result;
455
+ break;
456
+ case FFI_TYPE_UINT16:
457
+ case FFI_TYPE_SINT16:
458
+ DEREF_U16(rvalue, 0) = result;
459
+ break;
460
+ case FFI_TYPE_UINT64:
461
+ case FFI_TYPE_SINT64:
462
+ #if WASM_BIGINT
463
+ DEREF_U64(rvalue, 0) = result;
464
+ #else
465
+ DEREF_U32(rvalue, 0) = result;
466
+ DEREF_U32(rvalue, 1) = getTempRet0();
467
+ #endif
468
+ break;
469
+ case FFI_TYPE_COMPLEX:
470
+ throw new Error('complex ret marshalling nyi');
471
+ default:
472
+ throw new Error('Unexpected rtype ' + rtype_id);
473
+ }
474
+ });
475
+
476
+ void ffi_call(ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue) {
477
+ ffi_call_js(cif, fn, rvalue, avalue);
478
+ }
479
+
480
+ CHECK_FIELD_OFFSET(ffi_closure, ftramp, 4*0);
481
+ CHECK_FIELD_OFFSET(ffi_closure, cif, 4*1);
482
+ CHECK_FIELD_OFFSET(ffi_closure, fun, 4*2);
483
+ CHECK_FIELD_OFFSET(ffi_closure, user_data, 4*3);
484
+
485
+ #define CLOSURE__wrapper(addr) DEREF_U32(addr, 0)
486
+ #define CLOSURE__cif(addr) DEREF_U32(addr, 1)
487
+ #define CLOSURE__fun(addr) DEREF_U32(addr, 2)
488
+ #define CLOSURE__user_data(addr) DEREF_U32(addr, 3)
489
+
490
+ EM_JS_MACROS(void *, ffi_closure_alloc_js, (size_t size, void **code), {
491
+ var closure = _malloc(size);
492
+ var index = getEmptyTableSlot();
493
+ DEREF_U32(code, 0) = index;
494
+ CLOSURE__wrapper(closure) = index;
495
+ return closure;
496
+ })
497
+
498
+ void * __attribute__ ((visibility ("default")))
499
+ ffi_closure_alloc(size_t size, void **code) {
500
+ return ffi_closure_alloc_js(size, code);
501
+ }
502
+
503
+ EM_JS_MACROS(void, ffi_closure_free_js, (void *closure), {
504
+ var index = CLOSURE__wrapper(closure);
505
+ freeTableIndexes.push(index);
506
+ _free(closure);
507
+ })
508
+
509
+ void __attribute__ ((visibility ("default")))
510
+ ffi_closure_free(void *closure) {
511
+ return ffi_closure_free_js(closure);
512
+ }
513
+
514
+ #if !WASM_BIGINT
515
+
516
+ // When !WASM_BIGINT, we assume there is no JS bigint integration, so JavaScript
517
+ // functions cannot take 64 bit integer arguments.
518
+ //
519
+ // We need to make our own wasm legalizer adaptor that splits 64 bit integer
520
+ // arguments and then calls the JavaScript trampoline, then the JavaScript
521
+ // trampoline reassembles them, calls the closure, then splits the result (if
522
+ // it's a 64 bit integer) and the adaptor puts it back together.
523
+ //
524
+ // This is basically the reverse of the Emscripten function
525
+ // createDyncallWrapper.
526
+ EM_JS(void, createLegalizerWrapper, (int trampoline, int sig), {
527
+ if(!sig.includes("j")) {
528
+ return convertJsFunctionToWasm(trampoline, sig);
529
+ }
530
+ var sections = [];
531
+ var prelude = [
532
+ 0x00, 0x61, 0x73, 0x6d, // magic ("\0asm")
533
+ 0x01, 0x00, 0x00, 0x00, // version: 1
534
+ ];
535
+ sections.push(prelude);
536
+ var wrappersig = [
537
+ // if return type is j, we will put the upper 32 bits into tempRet0.
538
+ sig[0].replace("j", "i"),
539
+ // in the rest of the argument list, one 64 bit integer is legalized into
540
+ // two 32 bit integers.
541
+ sig.slice(1).replace(/j/g, "ii"),
542
+ ].join("");
543
+
544
+ var typeSectionBody = [
545
+ 0x03, // number of types = 3
546
+ ];
547
+ generateFuncType(wrappersig, typeSectionBody); // The signature of the wrapper we are generating
548
+ generateFuncType(sig, typeSectionBody); // the signature of the function pointer we will call
549
+ generateFuncType("i", typeSectionBody); // the signature of getTempRet0
550
+
551
+ var typeSection = [0x01 /* Type section code */];
552
+ uleb128Encode(typeSectionBody.length, typeSection); // length of section in bytes
553
+ typeSection.push.apply(typeSection, typeSectionBody);
554
+ sections.push(typeSection);
555
+
556
+ var importSection = [
557
+ 0x02, // import section code
558
+ 0x0d, // length of section in bytes
559
+ 0x02, // number of imports = 2
560
+ // Import the getTempRet0 function, which we will call "r"
561
+ 0x01, 0x65, // name "e"
562
+ 0x01, 0x72, // name "r"
563
+ 0x00, // importing a function
564
+ 0x02, // type 2 = () -> i32
565
+ // Import the wrapped function, which we will call "f"
566
+ 0x01, 0x65, // name "e"
567
+ 0x01, 0x66, // name "f"
568
+ 0x00, // importing a function
569
+ 0x00, // type 0 = wrappersig
570
+ ];
571
+ sections.push(importSection);
572
+
573
+ var functionSection = [
574
+ 0x03, // function section code
575
+ 0x02, // length of section in bytes
576
+ 0x01, // number of functions = 1
577
+ 0x01, // type 1 = sig
578
+ ];
579
+ sections.push(functionSection);
580
+
581
+ var exportSection = [
582
+ 0x07, // export section code
583
+ 0x05, // length of section in bytes
584
+ 0x01, // One export
585
+ 0x01, 0x66, // name "f"
586
+ 0x00, // type: function
587
+ 0x02, // function index 2 = the wrapper function
588
+ ];
589
+ sections.push(exportSection);
590
+
591
+ var convert_code = [];
592
+ convert_code.push(0x00); // no local variables (except the arguments)
593
+
594
+ function localGet(j) {
595
+ convert_code.push(0x20); // local.get
596
+ uleb128Encode(j, convert_code);
597
+ }
598
+
599
+ for (var i = 1; i < sig.length; i++) {
600
+ if (sig[i] == "j") {
601
+ localGet(i - 1);
602
+ convert_code.push(
603
+ 0xa7 // i32.wrap_i64
604
+ );
605
+ localGet(i - 1);
606
+ convert_code.push(
607
+ 0x42, 0x20, // i64.const 32
608
+ 0x88, // i64.shr_u
609
+ 0xa7 // i32.wrap_i64
610
+ );
611
+ } else {
612
+ localGet(i - 1);
613
+ }
614
+ }
615
+ convert_code.push(
616
+ 0x10, 0x01 // call f
617
+ );
618
+ if (sig[0] === "j") {
619
+ // Need to reassemble a 64 bit integer. Lower 32 bits is on stack. Upper 32
620
+ // bits we get from getTempRet0
621
+ convert_code.push(
622
+ 0xad, // i64.extend_i32_unsigned
623
+ 0x10, 0x00, // Call function 0 (r = getTempRet0)
624
+ // join lower 32 bits and upper 32 bits
625
+ 0xac, // i64.extend_i32_signed
626
+ 0x42, 0x20, // i64.const 32
627
+ 0x86, // i64.shl,
628
+ 0x84 // i64.or
629
+ );
630
+ }
631
+ convert_code.push(0x0b); // end
632
+
633
+ var codeBody = [0x01]; // one code
634
+ uleb128Encode(convert_code.length, codeBody);
635
+ codeBody.push.apply(codeBody, convert_code);
636
+ var codeSection = [0x0a /* Code section code */];
637
+ uleb128Encode(codeBody.length, codeSection);
638
+ codeSection.push.apply(codeSection, codeBody);
639
+ sections.push(codeSection);
640
+
641
+ var bytes = new Uint8Array([].concat.apply([], sections));
642
+ // We can compile this wasm module synchronously because it is small.
643
+ var module = new WebAssembly.Module(bytes);
644
+ var instance = new WebAssembly.Instance(module, {
645
+ e: {
646
+ r: getTempRet0,
647
+ f: trampoline,
648
+ },
649
+ });
650
+ return instance.exports.f;
651
+ });
652
+ #endif
653
+
654
+ EM_JS_MACROS(
655
+ ffi_status,
656
+ ffi_prep_closure_loc_js,
657
+ (ffi_closure *closure, ffi_cif *cif, void *fun, void *user_data, void *codeloc),
658
+ {
659
+ var abi = CIF__ABI(cif);
660
+ var nargs = CIF__NARGS(cif);
661
+ var nfixedargs = CIF__NFIXEDARGS(cif);
662
+ var arg_types_ptr = CIF__ARGTYPES(cif);
663
+ var rtype_unboxed = unbox_small_structs(CIF__RTYPE(cif));
664
+ var rtype_ptr = rtype_unboxed[0];
665
+ var rtype_id = rtype_unboxed[1];
666
+
667
+ // First construct the signature of the javascript trampoline we are going to create.
668
+ // Important: this is the signature for calling us, the onward call always has sig viiii.
669
+ var sig;
670
+ var ret_by_arg = false;
671
+ switch (rtype_id) {
672
+ case FFI_TYPE_VOID:
673
+ sig = 'v';
674
+ break;
675
+ case FFI_TYPE_STRUCT:
676
+ case FFI_TYPE_LONGDOUBLE:
677
+ // Return via a first pointer argument.
678
+ sig = 'vi';
679
+ ret_by_arg = true;
680
+ break;
681
+ case FFI_TYPE_INT:
682
+ case FFI_TYPE_UINT8:
683
+ case FFI_TYPE_SINT8:
684
+ case FFI_TYPE_UINT16:
685
+ case FFI_TYPE_SINT16:
686
+ case FFI_TYPE_UINT32:
687
+ case FFI_TYPE_SINT32:
688
+ case FFI_TYPE_POINTER:
689
+ sig = 'i';
690
+ break;
691
+ case FFI_TYPE_FLOAT:
692
+ sig = 'f';
693
+ break;
694
+ case FFI_TYPE_DOUBLE:
695
+ sig = 'd';
696
+ break;
697
+ case FFI_TYPE_UINT64:
698
+ case FFI_TYPE_SINT64:
699
+ sig = 'j';
700
+ break;
701
+ case FFI_TYPE_COMPLEX:
702
+ throw new Error('complex ret marshalling nyi');
703
+ default:
704
+ throw new Error('Unexpected rtype ' + rtype_id);
705
+ }
706
+ var unboxed_arg_type_id_list = [];
707
+ var unboxed_arg_type_info_list = [];
708
+ for (var i = 0; i < nargs; i++) {
709
+ var arg_unboxed = unbox_small_structs(DEREF_U32(arg_types_ptr, i));
710
+ var arg_type_ptr = arg_unboxed[0];
711
+ var arg_type_id = arg_unboxed[1];
712
+ unboxed_arg_type_id_list.push(arg_type_id);
713
+ unboxed_arg_type_info_list.push([FFI_TYPE__SIZE(arg_type_ptr), FFI_TYPE__ALIGN(arg_type_ptr)]);
714
+ }
715
+ for (var i = 0; i < nfixedargs; i++) {
716
+ switch (unboxed_arg_type_id_list[i]) {
717
+ case FFI_TYPE_INT:
718
+ case FFI_TYPE_UINT8:
719
+ case FFI_TYPE_SINT8:
720
+ case FFI_TYPE_UINT16:
721
+ case FFI_TYPE_SINT16:
722
+ case FFI_TYPE_UINT32:
723
+ case FFI_TYPE_SINT32:
724
+ case FFI_TYPE_POINTER:
725
+ case FFI_TYPE_STRUCT:
726
+ sig += 'i';
727
+ break;
728
+ case FFI_TYPE_FLOAT:
729
+ sig += 'f';
730
+ break;
731
+ case FFI_TYPE_DOUBLE:
732
+ sig += 'd';
733
+ break;
734
+ case FFI_TYPE_LONGDOUBLE:
735
+ sig += 'jj';
736
+ break;
737
+ case FFI_TYPE_UINT64:
738
+ case FFI_TYPE_SINT64:
739
+ sig += 'j';
740
+ break;
741
+ case FFI_TYPE_COMPLEX:
742
+ throw new Error('complex marshalling nyi');
743
+ default:
744
+ throw new Error('Unexpected argtype ' + arg_type_id);
745
+ }
746
+ }
747
+ if (nfixedargs < nargs) {
748
+ // extra pointer to varargs stack
749
+ sig += "i";
750
+ }
751
+ LOG_DEBUG("CREATE_CLOSURE", "sig:", sig);
752
+ function trampoline() {
753
+ var args = Array.prototype.slice.call(arguments);
754
+ var size = 0;
755
+ var orig_stack_ptr = stackSave();
756
+ var cur_ptr = orig_stack_ptr;
757
+ var ret_ptr;
758
+ var jsarg_idx = 0;
759
+ // Should we return by argument or not? The onwards call returns by argument
760
+ // no matter what. (Warning: ret_by_arg means the opposite in ffi_call)
761
+ if (ret_by_arg) {
762
+ ret_ptr = args[jsarg_idx++];
763
+ } else {
764
+ // We might return 4 bytes or 8 bytes, allocate 8 just in case.
765
+ STACK_ALLOC(cur_ptr, 8, 8);
766
+ ret_ptr = cur_ptr;
767
+ }
768
+ cur_ptr -= 4 * nargs;
769
+ var args_ptr = cur_ptr;
770
+ var carg_idx = 0;
771
+ // Here we either have the actual argument, or a pair of BigInts for long
772
+ // double, or a pointer to struct. We have to store into args_ptr[i] a
773
+ // pointer to the ith argument. If the argument is a struct, just store the
774
+ // pointer. Otherwise allocate stack space and copy the js argument onto the
775
+ // stack.
776
+ for (; carg_idx < nfixedargs; carg_idx++) {
777
+ // jsarg_idx might start out as 0 or 1 depending on ret_by_arg
778
+ // it advances an extra time for long double
779
+ var cur_arg = args[jsarg_idx++];
780
+ var arg_type_info = unboxed_arg_type_info_list[carg_idx];
781
+ var arg_size = arg_type_info[0];
782
+ var arg_align = arg_type_info[1];
783
+ var arg_type_id = unboxed_arg_type_id_list[carg_idx];
784
+ switch (arg_type_id) {
785
+ case FFI_TYPE_UINT8:
786
+ case FFI_TYPE_SINT8:
787
+ // Bad things happen if we don't align to 4 here
788
+ STACK_ALLOC(cur_ptr, 1, 4);
789
+ DEREF_U32(args_ptr, carg_idx) = cur_ptr;
790
+ DEREF_U8(cur_ptr, 0) = cur_arg;
791
+ break;
792
+ case FFI_TYPE_UINT16:
793
+ case FFI_TYPE_SINT16:
794
+ // Bad things happen if we don't align to 4 here
795
+ STACK_ALLOC(cur_ptr, 2, 4);
796
+ DEREF_U32(args_ptr, carg_idx) = cur_ptr;
797
+ DEREF_U16(cur_ptr, 0) = cur_arg;
798
+ break;
799
+ case FFI_TYPE_INT:
800
+ case FFI_TYPE_UINT32:
801
+ case FFI_TYPE_SINT32:
802
+ case FFI_TYPE_POINTER:
803
+ STACK_ALLOC(cur_ptr, 4, 4);
804
+ DEREF_U32(args_ptr, carg_idx) = cur_ptr;
805
+ DEREF_U32(cur_ptr, 0) = cur_arg;
806
+ break;
807
+ case FFI_TYPE_STRUCT:
808
+ // cur_arg is already a pointer to struct
809
+ // copy it onto stack to pass by value
810
+ STACK_ALLOC(cur_ptr, arg_size, arg_align);
811
+ HEAP8.subarray(cur_ptr, cur_ptr + arg_size).set(HEAP8.subarray(cur_arg, cur_arg + arg_size));
812
+ DEREF_U32(args_ptr, carg_idx) = cur_ptr;
813
+ break;
814
+ case FFI_TYPE_FLOAT:
815
+ STACK_ALLOC(cur_ptr, 4, 4);
816
+ DEREF_U32(args_ptr, carg_idx) = cur_ptr;
817
+ DEREF_F32(cur_ptr, 0) = cur_arg;
818
+ break;
819
+ case FFI_TYPE_DOUBLE:
820
+ STACK_ALLOC(cur_ptr, 8, 8);
821
+ DEREF_U32(args_ptr, carg_idx) = cur_ptr;
822
+ DEREF_F64(cur_ptr, 0) = cur_arg;
823
+ break;
824
+ case FFI_TYPE_UINT64:
825
+ case FFI_TYPE_SINT64:
826
+ STACK_ALLOC(cur_ptr, 8, 8);
827
+ DEREF_U32(args_ptr, carg_idx) = cur_ptr;
828
+ #if WASM_BIGINT
829
+ DEREF_U64(cur_ptr, 0) = cur_arg;
830
+ #else
831
+ // Bigint arg was split by legalizer adaptor
832
+ DEREF_U32(cur_ptr, 0) = cur_arg;
833
+ cur_arg = args[jsarg_idx++];
834
+ DEREF_U32(cur_ptr, 1) = cur_arg;
835
+ #endif
836
+ break;
837
+ case FFI_TYPE_LONGDOUBLE:
838
+ STACK_ALLOC(cur_ptr, 16, 8);
839
+ DEREF_U32(args_ptr, carg_idx) = cur_ptr;
840
+ #if WASM_BIGINT
841
+ DEREF_U64(cur_ptr, 0) = cur_arg;
842
+ cur_arg = args[jsarg_idx++];
843
+ DEREF_U64(cur_ptr, 1) = cur_arg;
844
+ #else
845
+ // Was split by legalizer adaptor
846
+ DEREF_U32(cur_ptr, 0) = cur_arg;
847
+ cur_arg = args[jsarg_idx++];
848
+ DEREF_U32(cur_ptr, 1) = cur_arg;
849
+ cur_arg = args[jsarg_idx++];
850
+ DEREF_U32(cur_ptr, 2) = cur_arg;
851
+ cur_arg = args[jsarg_idx++];
852
+ DEREF_U32(cur_ptr, 3) = cur_arg;
853
+ #endif
854
+ break;
855
+ }
856
+ }
857
+ // If its a varargs call, last js argument is a pointer to the varargs.
858
+ var varargs = args[args.length - 1];
859
+ // We have no way of knowing how many varargs were actually provided, this
860
+ // fills the rest of the stack space allocated with nonsense. The onward
861
+ // call will know to ignore the nonsense.
862
+
863
+ // We either have a pointer to the argument if the argument is not a struct
864
+ // or a pointer to pointer to struct. We need to store a pointer to the
865
+ // argument into args_ptr[i]
866
+ for (; carg_idx < nargs; carg_idx++) {
867
+ var arg_type_id = unboxed_arg_type_id_list[carg_idx];
868
+ var arg_type_info = unboxed_arg_type_info_list[carg_idx];
869
+ var arg_size = arg_type_info[0];
870
+ var arg_align = arg_type_info[1];
871
+ if (arg_type_id === FFI_TYPE_STRUCT) {
872
+ // In this case varargs is a pointer to pointer to struct so we need to
873
+ // deref once
874
+ var struct_ptr = DEREF_U32(varargs, 0);
875
+ STACK_ALLOC(cur_ptr, arg_size, arg_align);
876
+ HEAP8.subarray(cur_ptr, cur_ptr + arg_size).set(HEAP8.subarray(struct_ptr, struct_ptr + arg_size));
877
+ DEREF_U32(args_ptr, carg_idx) = cur_ptr;
878
+ } else {
879
+ DEREF_U32(args_ptr, carg_idx) = varargs;
880
+ }
881
+ varargs += 4;
882
+ }
883
+ stackRestore(cur_ptr);
884
+ stackAlloc(0); // stackAlloc enforces alignment invariants on the stack pointer
885
+ LOG_DEBUG("CALL_CLOSURE", "closure:", closure, "fptr", CLOSURE__fun(closure), "cif", CLOSURE__cif(closure));
886
+ getWasmTableEntry(CLOSURE__fun(closure))(
887
+ CLOSURE__cif(closure), ret_ptr, args_ptr,
888
+ CLOSURE__user_data(closure)
889
+ );
890
+ stackRestore(orig_stack_ptr);
891
+
892
+ // If we aren't supposed to return by argument, figure out what to return.
893
+ if (!ret_by_arg) {
894
+ switch (sig[0]) {
895
+ case "i":
896
+ return DEREF_U32(ret_ptr, 0);
897
+ case "j":
898
+ #if WASM_BIGINT
899
+ return DEREF_U64(ret_ptr, 0);
900
+ #else
901
+ // Split the return i64, set the upper 32 bits into tempRet0 and return
902
+ // the lower 32 bits.
903
+ setTempRet0(DEREF_U32(ret_ptr, 1));
904
+ return DEREF_U32(ret_ptr, 0);
905
+ #endif
906
+ case "d":
907
+ return DEREF_F64(ret_ptr, 0);
908
+ case "f":
909
+ return DEREF_F32(ret_ptr, 0);
910
+ }
911
+ }
912
+ }
913
+ try {
914
+ var wasm_trampoline = JS_FUNCTION_TO_WASM(trampoline, sig);
915
+ } catch(e) {
916
+ return FFI_BAD_TYPEDEF_MACRO;
917
+ }
918
+ setWasmTableEntry(codeloc, wasm_trampoline);
919
+ CLOSURE__cif(closure) = cif;
920
+ CLOSURE__fun(closure) = fun;
921
+ CLOSURE__user_data(closure) = user_data;
922
+ return FFI_OK_MACRO;
923
+ })
924
+
925
+ // EM_JS does not correctly handle function pointer arguments, so we need a
926
+ // helper
927
+ ffi_status ffi_prep_closure_loc(ffi_closure *closure, ffi_cif *cif,
928
+ void (*fun)(ffi_cif *, void *, void **, void *),
929
+ void *user_data, void *codeloc) {
930
+ if (cif->abi != FFI_WASM32_EMSCRIPTEN)
931
+ return FFI_BAD_ABI;
932
+ return ffi_prep_closure_loc_js(closure, cif, (void *)fun, user_data,
933
+ codeloc);
934
+ }