One Level Up Top Level

runtime/ffi/ffi_util.c - ktap

Functions defined

Source code

  1. /*
  2. * ffi_util.c - utility function for ffi module
  3. *
  4. * This file is part of ktap by Jovi Zhangwei.
  5. *
  6. * Copyright (C) 2012-2013 Jovi Zhangwei <jovi.zhangwei@gmail.com>.
  7. *
  8. * ktap is free software; you can redistribute it and/or modify it
  9. * under the terms and conditions of the GNU General Public License,
  10. * version 2, as published by the Free Software Foundation.
  11. *
  12. * ktap is distributed in the hope it will be useful, but WITHOUT
  13. * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14. * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  15. * more details.
  16. *
  17. * You should have received a copy of the GNU General Public License along with
  18. * this program; if not, write to the Free Software Foundation, Inc.,
  19. * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
  20. */


  23. #include "../../include/ktap_types.h"
  24. #include "../../include/ktap_ffi.h"
  25. #include "../ktap.h"

  27. ‌static void init_csym_struct(ktap_state_t *ks, csymbol_struct *csst)
  28. {
  29.     int nr = csymst_mb_nr(csst);
  30.     size_t size = 0;
  31.     size_t align = 1;
  32.     int i, var_len;
  33.     size_t var_size, var_align;

  35.     if (csymst_mb_nr(csst) < 0) {
  36.         kp_error(ks, "Find size of undefined struct");
  37.         return;
  38.     }

  40.     for (i = 0; i < nr; i++) {
  41.         csymbol *var_cs = csymst_mb_csym(ks, csst, i);
  42.         var_len = csymst_mb_len(csst, i);
  43.         if (var_len < 0) {
  44.             var_len = 1;
  45.         } else {
  46.             var_cs = csym_ptr_deref(ks, var_cs);
  47.         }
  48.         var_size = csym_size(ks, var_cs) * var_len;
  49.         var_align = csym_align(ks, var_cs);
  50.         size = ALIGN(size, var_align);
  51.         size += var_size;
  52.         align = align > var_align ? align : var_align;
  53.     }
  54.     size = ALIGN(size, align);
  55.     csst->size = size;
  56.     csst->align = align;
  57. }

  59. ‌static void init_csym_union(ktap_state_t *ks, csymbol_struct *csst)
  60. {
  61.     int nr = csymst_mb_nr(csst);
  62.     size_t size = 0;
  63.     size_t align = 1;
  64.     int i, var_len;
  65.     size_t var_size, var_align;

  67.     if (csymst_mb_nr(csst) < 0) {
  68.         kp_error(ks, "Find size of undefined struct");
  69.         return;
  70.     }

  72.     for (i = 0; i < nr; i++) {
  73.         csymbol *var_cs = csymst_mb_csym(ks, csst, i);
  74.         var_len = csymst_mb_len(csst, i);
  75.         if (var_len < 0) {
  76.             var_len = 1;
  77.         } else {
  78.             var_cs = csym_ptr_deref(ks, var_cs);
  79.         }
  80.         var_size = csym_size(ks, var_cs) * var_len;
  81.         var_align = csym_align(ks, var_cs);
  82.         size = size > var_size ? size : var_size;
  83.         align = align > var_align ? align : var_align;
  84.     }
  85.     csst->size = size;
  86.     csst->align = align;
  87. }


  90. ‌size_t csym_size(ktap_state_t *ks, csymbol *cs)
  91. {
  92.     ffi_type type = csym_type(cs);
  93.     switch(type) {
  94.     case FFI_STRUCT:
  95.         if (csym_struct(cs)->align == 0)
  96.             init_csym_struct(ks, csym_struct(cs));
  97.         return csym_struct(cs)->size;
  98.     case FFI_UNION:
  99.         if (csym_struct(cs)->align == 0)
  100.             init_csym_union(ks, csym_struct(cs));
  101.         return csym_struct(cs)->size;
  102.     default:
  103.         return ffi_type_size(type);
  104.     }
  105. }

  107. ‌size_t csym_align(ktap_state_t *ks, csymbol *cs)
  108. {
  109.     ffi_type type = csym_type(cs);
  110.     switch(type) {
  111.     case FFI_STRUCT:
  112.         if (csym_struct(cs)->align == 0)
  113.             init_csym_struct(ks, csym_struct(cs));
  114.         return csym_struct(cs)->align;
  115.     case FFI_UNION:
  116.         if (csym_struct(cs)->align == 0)
  117.             init_csym_union(ks, csym_struct(cs));
  118.         return csym_struct(cs)->align;
  119.     default:
  120.         return ffi_type_align(type);
  121.     }
  122. }

  124. ‌size_t csym_record_mb_offset_by_name(ktap_state_t *ks,
  125.         csymbol *cs, const char *name)
  126. {
  127.     csymbol_struct *csst = csym_struct(cs);
  128.     int nr = csymst_mb_nr(csst);
  129.     size_t off = 0, sub_off;
  130.     size_t align = 1;
  131.     int i, var_len;
  132.     size_t var_size, var_align;

  134.     if (nr < 0) {
  135.         kp_error(ks, "Find size of undefined struct");
  136.         return 0;
  137.     }

  139.     for (i = 0; i < nr; i++) {
  140.         csymbol *var_cs = csymst_mb_csym(ks, csst, i);
  141.         var_len = csymst_mb_len(csst, i);
  142.         if (var_len < 0) {
  143.             var_len = 1;
  144.         } else {
  145.             var_cs = csym_ptr_deref(ks, var_cs);
  146.         }
  147.         var_size = csym_size(ks, var_cs) * var_len;
  148.         var_align = csym_align(ks, var_cs);
  149.         off = ALIGN(off, var_align);
  150.         if (!strcmp(name, csymst_mb_name(csst, i)))
  151.             return off;
  152.         if (!strcmp("", csymst_mb_name(csst, i))) {
  153.             if (csym_type(var_cs) != FFI_STRUCT &&
  154.                     csym_type(var_cs) != FFI_UNION) {
  155.                 kp_error(ks, "Parse error: non-record type without name");
  156.                 return -1;
  157.             }
  158.             sub_off = csym_record_mb_offset_by_name(ks,
  159.                     var_cs, name);
  160.             if (sub_off >= 0)
  161.                 return off + sub_off;
  162.         }
  163.         if (csym_type(cs) == FFI_STRUCT)
  164.             off += var_size;
  165.         else
  166.             off = 0;
  167.         align = align > var_align ? align : var_align;
  168.     }
  169.     return -1;
  170. }

  172. ‌struct_member *csymst_mb_by_name(ktap_state_t *ks,
  173.         csymbol_struct *csst, const char *name)
  174. {
  175.     int nr = csymst_mb_nr(csst);
  176.     int i;
  177.     struct_member *memb;
  178.     csymbol *cs = NULL;

  180.     if (nr < 0) {
  181.         kp_error(ks, "Find size of undefined struct");
  182.         return NULL;
  183.     }

  185.     for (i = 0; i < nr; i++) {
  186.         if (!strcmp(name, csymst_mb_name(csst, i)))
  187.             return csymst_mb(csst, i);
  188.         if (!strcmp("", csymst_mb_name(csst, i))) {
  189.             cs = csymst_mb_csym(ks, csst, i);
  190.             if (csym_type(cs) != FFI_STRUCT && csym_type(cs) != FFI_UNION) {
  191.                 kp_error(ks, "Parse error: non-record type without name");
  192.                 return NULL;
  193.             }
  194.             memb = csymst_mb_by_name(ks, csym_struct(cs), name);
  195.             if (memb != NULL)
  196.                 return memb;
  197.         }
  198.     }
  199.     return NULL;
  200. }

One Level Up Top Level