One Level Up Top Level

userspace/cparser.h - ktap

Data types defined

Functions defined

Macros defined

Source code

  1. #ifndef __KTAP_CPARSER_H__
  2. ‌#define __KTAP_CPARSER_H__

  4. /*
  5. * Copyright (c) 2011 James R. McKaskill
  6. *
  7. * This software is licensed under the stock MIT license:
  8. *
  9. * Permission is hereby granted, free of charge, to any person obtaining a
  10. * copy of this software and associated documentation files (the "Software"),
  11. * to deal in the Software without restriction, including without limitation
  12. * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  13. * and/or sell copies of the Software, and to permit persons to whom the
  14. * Software is furnished to do so, subject to the following conditions:
  15. *
  16. * The above copyright notice and this permission notice shall be included in
  17. * all copies or substantial portions of the Software.
  18. *
  19. * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  20. * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21. * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  22. * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  23. * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  24. * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  25. * DEALINGS IN THE SOFTWARE.
  26. *
  27. * ----------------------------------------------------------------------------
  28. */

  30. /*
  31. * Adapted from luaffi commit: abc638c9341025580099dcf77795c4b320ba0e63
  32. *
  33. * Copyright (c) 2013 Yicheng Qin, Qingping Hou
  34. */

  36. #ifdef CONFIG_KTAP_FFI

  38. #include <assert.h>
  39. #include <stdlib.h>
  40. #include <stdio.h>
  41. #include <stdint.h>
  42. #include <string.h>
  43. #include <stdbool.h>

  45. #include "../include/ktap_ffi.h"

  47. ‌#define PTR_ALIGN_MASK (sizeof(void*) - 1)
  48. ‌#define FUNCTION_ALIGN_MASK (sizeof(void (*)()) - 1)
  49. ‌#define DEFAULT_ALIGN_MASK 7

  51. ‌struct parser {
  52.     int line;
  53.     const char *next;
  54.     const char *prev;
  55.     unsigned align_mask;
  56. };

  58. enum {
  59.     C_CALL,
  60.     STD_CALL,
  61.     FAST_CALL,
  62. };


  65. ‌#define MAX_TYPE_NAME_LEN CSYM_NAME_MAX_LEN

  67. enum {
  68.     /* 0 - 4 */
  69.     INVALID_TYPE,
  70.     VOID_TYPE,
  71.     BOOL_TYPE,
  72.     INT8_TYPE,
  73.     INT16_TYPE,
  74.     /* 5 - 9 */
  75.     INT32_TYPE,
  76.     INT64_TYPE,
  77.     INTPTR_TYPE,
  78.     ENUM_TYPE,
  79.     UNION_TYPE,
  80.     /* 10 - 12 */
  81.     STRUCT_TYPE,
  82.     FUNCTION_TYPE,
  83.     FUNCTION_PTR_TYPE,
  84. };


  87. ‌#define IS_CHAR_UNSIGNED (((char) -1) > 0)

  89. ‌#define POINTER_BITS 2
  90. ‌#define POINTER_MAX ((1 << POINTER_BITS) - 1)

  92. ‌#define ALIGNOF(S) ((int) ((char*) &S.v - (char*) &S - 1))


  95. /* Note: if adding a new member that is associated with a struct/union
  96. * definition then it needs to be copied over in ctype.c:set_defined for when
  97. * we create types based off of the declaration alone.
  98. *
  99. * Since this is used as a header for every ctype and cdata, and we create a
  100. * ton of them on the stack, we try and minimise its size.
  101. */
  102. ‌struct cp_ctype {
  103.     size_t base_size; /* size of the base type in bytes */
  104.     int ffi_base_cs_id;
  105.     int ffi_cs_id; /* index for csymbol from ktap vm */
  106.     union {
  107.         /* valid if is_bitfield */
  108.         struct {
  109.             /* size of bitfield in bits */
  110.             unsigned bit_size : 7;
  111.             /* offset within the current byte between 0-63 */
  112.             unsigned bit_offset : 6;
  113.         };
  114.         /* Valid if is_array */
  115.         size_t array_size;
  116.         /* Valid for is_variable_struct or is_variable_array. If
  117.          * variable_size_known (only used for is_variable_struct)
  118.          * then this is the total increment otherwise this is the
  119.          * per element increment.
  120.          */
  121.         size_t variable_increment;
  122.     };
  123.     size_t offset;
  124.     /* as (align bytes - 1) eg 7 gives 8 byte alignment */
  125.     unsigned align_mask : 4;
  126.     /* number of dereferences to get to the base type
  127.      * including +1 for arrays */
  128.     unsigned pointers : POINTER_BITS;
  129.     /* const pointer mask, LSB is current pointer, +1 for the whether
  130.      * the base type is const */
  131.     unsigned const_mask : POINTER_MAX + 1;
  132.     unsigned type : 5; /* value given by type enum above */
  133.     unsigned is_reference : 1;
  134.     unsigned is_array : 1;
  135.     unsigned is_defined : 1;
  136.     unsigned is_null : 1;
  137.     unsigned has_member_name : 1;
  138.     unsigned calling_convention : 2;
  139.     unsigned has_var_arg : 1;
  140.     /* set for variable array types where we don't know
  141.      * the variable size yet */
  142.     unsigned is_variable_array : 1;
  143.     unsigned is_variable_struct : 1;
  144.     /* used for variable structs after we know the variable size */
  145.     unsigned variable_size_known : 1;
  146.     unsigned is_bitfield : 1;
  147.     unsigned has_bitfield : 1;
  148.     unsigned is_jitted : 1;
  149.     unsigned is_packed : 1;
  150.     unsigned is_unsigned : 1;
  151. };

  153. ‌#define ALIGNED_DEFAULT (__alignof__(void* __attribute__((aligned))) - 1)

  155. csymbol *cp_id_to_csym(int id);
  156. ‌#define ct_ffi_cs(ct) (cp_id_to_csym((ct)->ffi_cs_id))

  158. size_t ctype_size(const struct cp_ctype* ct);
  159. int ctype_stack_top();
  160. int cp_ctype_init();
  161. int cp_ctype_free();
  162. struct cp_ctype *ctype_lookup_type(char *name);
  163. void cp_ctype_dump_stack();
  164. void cp_error(const char *err_msg_fmt, ...);
  165. struct cp_ctype *cp_ctype_reg_type(char *name, struct cp_ctype *ct);

  167. void cp_update_csym_in_ctype(struct cp_ctype *ct);
  168. void cp_push_ctype_with_name(struct cp_ctype *ct, const char *name, int nlen);
  169. void cp_push_ctype(struct cp_ctype *ct);
  170. void cp_set_defined(struct cp_ctype *ct);

  172. int cp_symbol_build_func(struct cp_ctype *type, const char *fname, int fn_size);
  173. int cp_symbol_build_record(const char *stname, int type, int start_top);
  174. int cp_symbol_build_fake_record(const char *stname, int type);
  175. int cp_symbol_build_pointer(struct cp_ctype *ct);

  177. int ffi_parse_cdef(const char *s);
  178. void ffi_parse_new(const char *s, struct cp_ctype *ct);
  179. int ffi_lookup_csymbol_id_by_name(const char *s);

  181. void ffi_cparser_init(void);
  182. void ffi_cparser_free(void);


  185. ‌static inline csymbol *cp_csymf_ret(csymbol_func *csf)
  186. {
  187.     return cp_id_to_csym(csf->ret_id);
  188. }

  190. ‌static inline csymbol *cp_csymf_arg(csymbol_func *csf, int idx)
  191. {
  192.     return cp_id_to_csym(csf->arg_ids[idx]);
  193. }


  196. #else
  197. ‌static inline void ffi_cparser_init(void)
  198. {
  199.     return;
  200. }
  201. ‌static inline void ffi_cparser_free(void)
  202. {
  203.     return;
  204. }
  205. #endif /* CONFIG_KTAP_FFI */


  208. #endif /* __KTAP_CPARSER_H__ */

One Level Up Top Level