libffi/src/x86/ffiw64.c

   1 /* -----------------------------------------------------------------------
   2    ffiw64.c - Copyright (c) 2018 Anthony Green
   3               Copyright (c) 2014 Red Hat, Inc.
   4
   5    x86 win64 Foreign Function Interface
   6
   7    Permission is hereby granted, free of charge, to any person obtaining
   8    a copy of this software and associated documentation files (the
   9    ``Software''), to deal in the Software without restriction, including
  10    without limitation the rights to use, copy, modify, merge, publish,
  11    distribute, sublicense, and/or sell copies of the Software, and to
  12    permit persons to whom the Software is furnished to do so, subject to
  13    the following conditions:
  14
  15    The above copyright notice and this permission notice shall be included
  16    in all copies or substantial portions of the Software.
  17
  18    THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,
  19    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  21    NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  22    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  23    WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  24    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  25    DEALINGS IN THE SOFTWARE.
  26    ----------------------------------------------------------------------- */
  27
  28 #if defined(__x86_64__) || defined(_M_AMD64)
  29 #include <ffi.h>
  30 #include <ffi_common.h>
  31 #include <stdlib.h>
  32 #include <stdint.h>
  33 #include <tramp.h>
  34
  35 #ifdef X86_WIN64
  36 #define EFI64(name) name
  37 #else
  38 #define EFI64(name) FFI_HIDDEN name##_efi64
  39 #endif
  40
  41 struct win64_call_frame
  42 {
  43   UINT64 rbp;           /* 0 */
  44   UINT64 retaddr;       /* 8 */
  45   UINT64 fn;            /* 16 */
  46   UINT64 flags;         /* 24 */
  47   UINT64 rvalue;        /* 32 */
  48 };
  49
  50 extern void ffi_call_win64 (void *stack, struct win64_call_frame *,
  51                             void *closure) FFI_HIDDEN;
  52
  53 ffi_status FFI_HIDDEN
  54 EFI64(ffi_prep_cif_machdep)(ffi_cif *cif)
  55 {
  56   int flags, n;
  57
  58   switch (cif->abi)
  59     {
  60     case FFI_WIN64:
  61     case FFI_GNUW64:
  62       break;
  63     default:
  64       return FFI_BAD_ABI;
  65     }
  66
  67   flags = cif->rtype->type;
  68   switch (flags)
  69     {
  70     default:
  71       break;
  72     case FFI_TYPE_LONGDOUBLE:
  73       /* GCC returns long double values by reference, like a struct */
  74       if (cif->abi == FFI_GNUW64)
  75         flags = FFI_TYPE_STRUCT;
  76       break;
  77     case FFI_TYPE_COMPLEX:
  78       flags = FFI_TYPE_STRUCT;
  79       /* FALLTHRU */
  80     case FFI_TYPE_STRUCT:
  81       switch (cif->rtype->size)
  82         {
  83         case 8:
  84           flags = FFI_TYPE_UINT64;
  85           break;
  86         case 4:
  87           flags = FFI_TYPE_SMALL_STRUCT_4B;
  88           break;
  89         case 2:
  90           flags = FFI_TYPE_SMALL_STRUCT_2B;
  91           break;
  92         case 1:
  93           flags = FFI_TYPE_SMALL_STRUCT_1B;
  94           break;
  95         }
  96       break;
  97     }
  98   cif->flags = flags;
  99
 100   /* Each argument either fits in a register, an 8 byte slot, or is
 101      passed by reference with the pointer in the 8 byte slot.  */
 102   n = cif->nargs;
 103   n += (flags == FFI_TYPE_STRUCT);
 104   if (n < 4)
 105     n = 4;
 106   cif->bytes = n * 8;
 107
 108   return FFI_OK;
 109 }
 110
 111 /* We perform some black magic here to use some of the parent's stack frame in
 112  * ffi_call_win64() that breaks with the MSVC compiler with the /RTCs or /GZ
 113  * flags.  Disable the 'Stack frame run time error checking' for this function
 114  * so we don't hit weird exceptions in debug builds. */
 115 #if defined(_MSC_VER)
 116 #pragma runtime_checks("s", off)
 117 #endif
 118 static void
 119 ffi_call_int (ffi_cif *cif, void (*fn)(void), void *rvalue,
 120               void **avalue, void *closure)
 121 {
 122   int i, j, n, flags;
 123   UINT64 *stack;
 124   size_t rsize;
 125   struct win64_call_frame *frame;
 126
 127   FFI_ASSERT(cif->abi == FFI_GNUW64 || cif->abi == FFI_WIN64);
 128
 129   flags = cif->flags;
 130   rsize = 0;
 131
 132   /* If we have no return value for a structure, we need to create one.
 133      Otherwise we can ignore the return type entirely.  */
 134   if (rvalue == NULL)
 135     {
 136       if (flags == FFI_TYPE_STRUCT)
 137         rsize = cif->rtype->size;
 138       else
 139         flags = FFI_TYPE_VOID;
 140     }
 141
 142   stack = alloca(cif->bytes + sizeof(struct win64_call_frame) + rsize);
 143   frame = (struct win64_call_frame *)((char *)stack + cif->bytes);
 144   if (rsize)
 145     rvalue = frame + 1;
 146
 147   frame->fn = (uintptr_t)fn;
 148   frame->flags = flags;
 149   frame->rvalue = (uintptr_t)rvalue;
 150
 151   j = 0;
 152   if (flags == FFI_TYPE_STRUCT)
 153     {
 154       stack[0] = (uintptr_t)rvalue;
 155       j = 1;
 156     }
 157
 158   for (i = 0, n = cif->nargs; i < n; ++i, ++j)
 159     {
 160       switch (cif->arg_types[i]->size)
 161         {
 162         case 8:
 163           stack[j] = *(UINT64 *)avalue[i];
 164           break;
 165         case 4:
 166           stack[j] = *(UINT32 *)avalue[i];
 167           break;
 168         case 2:
 169           stack[j] = *(UINT16 *)avalue[i];
 170           break;
 171         case 1:
 172           stack[j] = *(UINT8 *)avalue[i];
 173           break;
 174         default:
 175           stack[j] = (uintptr_t)avalue[i];
 176           break;
 177         }
 178     }
 179
 180   ffi_call_win64 (stack, frame, closure);
 181 }
 182 #if defined(_MSC_VER)
 183 #pragma runtime_checks("s", restore)
 184 #endif
 185
 186 void
 187 EFI64(ffi_call)(ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue)
 188 {
 189   ffi_call_int (cif, fn, rvalue, avalue, NULL);
 190 }
 191
 192 void
 193 EFI64(ffi_call_go)(ffi_cif *cif, void (*fn)(void), void *rvalue,
 194              void **avalue, void *closure)
 195 {
 196   ffi_call_int (cif, fn, rvalue, avalue, closure);
 197 }
 198
 199
 200 extern void ffi_closure_win64(void) FFI_HIDDEN;
 201 #if defined(FFI_EXEC_STATIC_TRAMP)
 202 extern void ffi_closure_win64_alt(void) FFI_HIDDEN;
 203 #endif
 204
 205 #ifdef FFI_GO_CLOSURES
 206 extern void ffi_go_closure_win64(void) FFI_HIDDEN;
 207 #endif
 208
 209 ffi_status
 210 EFI64(ffi_prep_closure_loc)(ffi_closure* closure,
 211                       ffi_cif* cif,
 212                       void (*fun)(ffi_cif*, void*, void**, void*),
 213                       void *user_data,
 214                       void *codeloc)
 215 {
 216   static const unsigned char trampoline[FFI_TRAMPOLINE_SIZE - 8] = {
 217     /* endbr64 */
 218     0xf3, 0x0f, 0x1e, 0xfa,
 219     /* leaq  -0xb(%rip),%r10   # 0x0  */
 220     0x4c, 0x8d, 0x15, 0xf5, 0xff, 0xff, 0xff,
 221     /* jmpq  *0x7(%rip)        # 0x18 */
 222     0xff, 0x25, 0x07, 0x00, 0x00, 0x00,
 223     /* nopl  0(%rax) */
 224     0x0f, 0x1f, 0x80, 0x00, 0x00, 0x00, 0x00
 225   };
 226   char *tramp = closure->tramp;
 227
 228   switch (cif->abi)
 229     {
 230     case FFI_WIN64:
 231     case FFI_GNUW64:
 232       break;
 233     default:
 234       return FFI_BAD_ABI;
 235     }
 236
 237 #if defined(FFI_EXEC_STATIC_TRAMP)
 238   if (ffi_tramp_is_present(closure))
 239     {
 240       /* Initialize the static trampoline's parameters. */
 241       ffi_tramp_set_parms (closure->ftramp, ffi_closure_win64_alt, closure);
 242       goto out;
 243     }
 244 #endif
 245
 246   /* Initialize the dynamic trampoline. */
 247   memcpy (tramp, trampoline, sizeof(trampoline));
 248   *(UINT64 *)(tramp + sizeof (trampoline)) = (uintptr_t)ffi_closure_win64;
 249
 250 out:
 251   closure->cif = cif;
 252   closure->fun = fun;
 253   closure->user_data = user_data;
 254
 255   return FFI_OK;
 256 }
 257
 258 #ifdef FFI_GO_CLOSURES
 259 ffi_status
 260 EFI64(ffi_prep_go_closure)(ffi_go_closure* closure, ffi_cif* cif,
 261                      void (*fun)(ffi_cif*, void*, void**, void*))
 262 {
 263   switch (cif->abi)
 264     {
 265     case FFI_WIN64:
 266     case FFI_GNUW64:
 267       break;
 268     default:
 269       return FFI_BAD_ABI;
 270     }
 271
 272   closure->tramp = ffi_go_closure_win64;
 273   closure->cif = cif;
 274   closure->fun = fun;
 275
 276   return FFI_OK;
 277 }
 278 #endif
 279
 280 struct win64_closure_frame
 281 {
 282   UINT64 rvalue[2];
 283   UINT64 fargs[4];
 284   UINT64 retaddr;
 285   UINT64 args[];
 286 };
 287
 288 /* Force the inner function to use the MS ABI.  When compiling on win64
 289    this is a nop.  When compiling on unix, this simplifies the assembly,
 290    and places the burden of saving the extra call-saved registers on
 291    the compiler.  */
 292 int FFI_HIDDEN __attribute__((ms_abi))
 293 ffi_closure_win64_inner(ffi_cif *cif,
 294                         void (*fun)(ffi_cif*, void*, void**, void*),
 295                         void *user_data,
 296                         struct win64_closure_frame *frame)
 297 {
 298   void **avalue;
 299   void *rvalue;
 300   int i, n, nreg, flags;
 301
 302   avalue = alloca(cif->nargs * sizeof(void *));
 303   rvalue = frame->rvalue;
 304   nreg = 0;
 305
 306   /* When returning a structure, the address is in the first argument.
 307      We must also be prepared to return the same address in eax, so
 308      install that address in the frame and pretend we return a pointer.  */
 309   flags = cif->flags;
 310   if (flags == FFI_TYPE_STRUCT)
 311     {
 312       rvalue = (void *)(uintptr_t)frame->args[0];
 313       frame->rvalue[0] = frame->args[0];
 314       nreg = 1;
 315     }
 316
 317   for (i = 0, n = cif->nargs; i < n; ++i, ++nreg)
 318     {
 319       size_t size = cif->arg_types[i]->size;
 320       size_t type = cif->arg_types[i]->type;
 321       void *a;
 322
 323       if (type == FFI_TYPE_DOUBLE || type == FFI_TYPE_FLOAT)
 324         {
 325           if (nreg < 4)
 326             a = &frame->fargs[nreg];
 327           else
 328             a = &frame->args[nreg];
 329         }
 330       else if (size == 1 || size == 2 || size == 4 || size == 8)
 331         a = &frame->args[nreg];
 332       else
 333         a = (void *)(uintptr_t)frame->args[nreg];
 334
 335       avalue[i] = a;
 336     }
 337
 338   /* Invoke the closure.  */
 339   fun (cif, rvalue, avalue, user_data);
 340   return flags;
 341 }
 342
 343 #endif /* __x86_64__ */