sig/ffi_type.cpp

   1 /* Cycript - Remove Execution Server and Disassembler
   2  * Copyright (C) 2009  Jay Freeman (saurik)
   3 */
   4
   5 /* Modified BSD License {{{ */
   6 /*
   7  *        Redistribution and use in source and binary
   8  * forms, with or without modification, are permitted
   9  * provided that the following conditions are met:
  10  *
  11  * 1. Redistributions of source code must retain the
  12  *    above copyright notice, this list of conditions
  13  *    and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the
  15  *    above copyright notice, this list of conditions
  16  *    and the following disclaimer in the documentation
  17  *    and/or other materials provided with the
  18  *    distribution.
  19  * 3. The name of the author may not be used to endorse
  20  *    or promote products derived from this software
  21  *    without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS''
  24  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
  25  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  26  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE
  28  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  29  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  30  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  31  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  32  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  33  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
  34  * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  35  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  36  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  37 */
  38 /* }}} */
  39
  40 #include "minimal/stdlib.h"
  41
  42 #include "sig/ffi_type.hpp"
  43 #include "sig/types.hpp"
  44
  45 #define ffi_type_slonglong ffi_type_sint64
  46 #define ffi_type_ulonglong ffi_type_uint64
  47
  48 namespace sig {
  49
  50 void sig_ffi_types(
  51     apr_pool_t *pool,
  52     ffi_type *(*sig_ffi_type)(apr_pool_t *, struct Type *),
  53     struct Signature *signature,
  54     ffi_type **types,
  55     size_t skip = 0,
  56     size_t offset = 0
  57 ) {
  58     _assert(signature->count >= skip);
  59     for (size_t index = skip; index != signature->count; ++index)
  60         types[index - skip + offset] = (*sig_ffi_type)(pool, signature->elements[index].type);
  61 }
  62
  63 ffi_type *ObjectiveC(apr_pool_t *pool, struct Type *type) {
  64     switch (type->primitive) {
  65         case typename_P: return &ffi_type_pointer;
  66
  67         case union_P:
  68             /* XXX: we can totally make this work */
  69             _assert(false);
  70         break;
  71
  72         case string_P: return &ffi_type_pointer;
  73         case selector_P: return &ffi_type_pointer;
  74         case object_P: return &ffi_type_pointer;
  75         case boolean_P: return &ffi_type_uchar;
  76         case uchar_P: return &ffi_type_uchar;
  77         case uint_P: return &ffi_type_uint;
  78         case ulong_P: return &ffi_type_ulong;
  79         case ulonglong_P: return &ffi_type_ulonglong;
  80         case ushort_P: return &ffi_type_ushort;
  81
  82         case array_P:
  83             /* XXX: implement */
  84             _assert(false);
  85         break;
  86
  87         case pointer_P: return &ffi_type_pointer;
  88
  89         case bit_P:
  90             /* XXX: we can totally make this work */
  91             _assert(false);
  92         break;
  93
  94         case char_P: return &ffi_type_schar;
  95         case double_P: return &ffi_type_double;
  96         case float_P: return &ffi_type_float;
  97         case int_P: return &ffi_type_sint;
  98         case long_P: return &ffi_type_slong;
  99         case longlong_P: return &ffi_type_slonglong;
 100         case short_P: return &ffi_type_sshort;
 101
 102         case void_P: return &ffi_type_void;
 103
 104         case struct_P: {
 105             ffi_type *aggregate = reinterpret_cast<ffi_type *>(apr_palloc(pool, sizeof(ffi_type)));
 106             aggregate->size = 0;
 107             aggregate->alignment = 0;
 108             aggregate->type = FFI_TYPE_STRUCT;
 109
 110             aggregate->elements = reinterpret_cast<ffi_type **>(apr_palloc(pool, (type->data.signature.count + 1) * sizeof(ffi_type *)));
 111             sig_ffi_types(pool, &ObjectiveC, &type->data.signature, aggregate->elements);
 112             aggregate->elements[type->data.signature.count] = NULL;
 113
 114             return aggregate;
 115         } break;
 116
 117         default:
 118             _assert(false);
 119         break;
 120     }
 121 }
 122
 123 ffi_type *Java(apr_pool_t *pool, struct Type *type) {
 124     switch (type->primitive) {
 125         case typename_P: return &ffi_type_pointer;
 126         case union_P: return &ffi_type_pointer;
 127         case string_P: return &ffi_type_pointer;
 128         case selector_P: return &ffi_type_pointer;
 129         case object_P: return &ffi_type_pointer;
 130         case boolean_P: return &ffi_type_uchar;
 131         case uchar_P: return &ffi_type_uchar;
 132         case uint_P: return &ffi_type_uint;
 133         case ulong_P: return &ffi_type_ulong;
 134         case ulonglong_P: return &ffi_type_ulonglong;
 135         case ushort_P: return &ffi_type_ushort;
 136         case array_P: return &ffi_type_pointer;
 137         case pointer_P: return &ffi_type_pointer;
 138
 139         /* XXX: bit type */
 140         case bit_P: return &ffi_type_uint;
 141
 142         case char_P: return &ffi_type_schar;
 143         case double_P: return &ffi_type_double;
 144         case float_P: return &ffi_type_double;
 145         case int_P: return &ffi_type_sint;
 146         case long_P: return &ffi_type_slong;
 147         case longlong_P: return &ffi_type_slonglong;
 148         case short_P: return &ffi_type_sshort;
 149         case void_P: return &ffi_type_void;
 150         case struct_P: return &ffi_type_pointer;
 151
 152         default:
 153             _assert(false);
 154         break;
 155     }
 156 }
 157
 158 void sig_ffi_cif(
 159     apr_pool_t *pool,
 160     ffi_type *(*sig_ffi_type)(apr_pool_t *, struct Type *),
 161     struct Signature *signature,
 162     ffi_cif *cif,
 163     size_t skip,
 164     ffi_type **types,
 165     size_t offset
 166 ) {
 167     if (types == NULL)
 168         types = reinterpret_cast<ffi_type **>(apr_palloc(pool, (signature->count - 1) * sizeof(ffi_type *)));
 169     ffi_type *type = (*sig_ffi_type)(pool, signature->elements[0].type);
 170     sig_ffi_types(pool, sig_ffi_type, signature, types, 1 + skip, offset);
 171     ffi_status status = ffi_prep_cif(cif, FFI_DEFAULT_ABI, signature->count - 1 - skip + offset, type, types);
 172     _assert(status == FFI_OK);
 173 }
 174
 175 }