One Level Up Top Level

runtime/kp_bcread.c - ktap

Data types defined

Functions defined

Macros defined

Source code

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

  26. #include "../include/ktap_types.h"
  27. #include "../include/ktap_bc.h"
  28. #include "../include/ktap_err.h"
  29. #include "ktap.h"
  30. #include "kp_obj.h"
  31. #include "kp_str.h"
  32. #include "kp_tab.h"


  35. /* Context for bytecode reader. */
  36. ‌typedef struct BCReadCtx {
  37.     ktap_state_t *ks;
  38.     int flags;
  39.     char *start;
  40.     char *p;
  41.     char *pe;
  42.     ktap_str_t *chunkname;
  43.     ktap_val_t *savetop;
  44. ‌} BCReadCtx;


  47. ‌#define bcread_flags(ctx)    (ctx)->flags
  48. ‌#define bcread_swap(ctx) \
  49.     ((bcread_flags(ctx) & BCDUMP_F_BE) != KP_BE*BCDUMP_F_BE)
  50. ‌#define bcread_oldtop(ctx)        (ctx)->savetop
  51. ‌#define bcread_savetop(ctx)    (ctx)->savetop = (ctx)->ks->top;

  53. ‌static inline uint32_t bswap(uint32_t x)
  54. {
  55.     return (uint32_t)__builtin_bswap32((int32_t)x);
  56. }

  58. /* -- Input buffer handling ----------------------------------------------- */

  60. /* Throw reader error. */
  61. ‌static void bcread_error(BCReadCtx *ctx, ErrMsg em)
  62. {
  63.     kp_error(ctx->ks, "%s\n", err2msg(em));
  64. }

  66. /* Return memory block from buffer. */
  67. ‌static inline uint8_t *bcread_mem(BCReadCtx *ctx, int len)
  68. {
  69.     uint8_t *p = (uint8_t *)ctx->p;
  70.     ctx->p += len;
  71.     kp_assert(ctx->p <= ctx->pe);
  72.     return p;
  73. }

  75. /* Copy memory block from buffer. */
  76. ‌static void bcread_block(BCReadCtx *ctx, void *q, int len)
  77. {
  78.     memcpy(q, bcread_mem(ctx, len), len);
  79. }

  81. /* Read byte from buffer. */
  82. ‌static inline uint32_t bcread_byte(BCReadCtx *ctx)
  83. {
  84.     kp_assert(ctx->p < ctx->pe);
  85.     return (uint32_t)(uint8_t)*ctx->p++;
  86. }

  88. /* Read ULEB128 value from buffer. */
  89. ‌static inline uint32_t bcread_uint32(BCReadCtx *ctx)
  90. {
  91.     uint32_t v;
  92.     bcread_block(ctx, &v, sizeof(uint32_t));
  93.     kp_assert(ctx->p <= ctx->pe);
  94.     return v;
  95. }

  97. /* -- Bytecode reader ----------------------------------------------------- */

  99. /* Read debug info of a prototype. */
  100. ‌static void bcread_dbg(BCReadCtx *ctx, ktap_proto_t *pt, int sizedbg)
  101. {
  102.     void *lineinfo = (void *)proto_lineinfo(pt);

  104.     bcread_block(ctx, lineinfo, sizedbg);
  105.     /* Swap lineinfo if the endianess differs. */
  106.     if (bcread_swap(ctx) && pt->numline >= 256) {
  107.         int i, n = pt->sizebc-1;
  108.         if (pt->numline < 65536) {
  109.             uint16_t *p = (uint16_t *)lineinfo;
  110.             for (i = 0; i < n; i++)
  111.                 p[i] = (uint16_t)((p[i] >> 8)|(p[i] << 8));
  112.         } else {
  113.             uint32_t *p = (uint32_t *)lineinfo;
  114.             for (i = 0; i < n; i++)
  115.                 p[i] = bswap(p[i]);
  116.         }
  117.     }
  118. }

  120. /* Find pointer to varinfo. */
  121. ‌static const void *bcread_varinfo(ktap_proto_t *pt)
  122. {
  123.     const uint8_t *p = proto_uvinfo(pt);
  124.     int n = pt->sizeuv;
  125.     if (n)
  126.         while (*p++ || --n) ;
  127.     return p;
  128. }

  130. /* Read a single constant key/value of a template table. */
  131. ‌static int bcread_ktabk(BCReadCtx *ctx, ktap_val_t *o)
  132. {
  133.     int tp = bcread_uint32(ctx);
  134.     if (tp >= BCDUMP_KTAB_STR) {
  135.         int len = tp - BCDUMP_KTAB_STR;
  136.         const char *p = (const char *)bcread_mem(ctx, len);
  137.         ktap_str_t *ts = kp_str_new(ctx->ks, p, len);
  138.         if (unlikely(!ts))
  139.             return -ENOMEM;

  141.         set_string(o, ts);
  142.     } else if (tp == BCDUMP_KTAB_NUM) {
  143.         set_number(o, *(ktap_number *)bcread_mem(ctx,
  144.                     sizeof(ktap_number)));
  145.     } else {
  146.          kp_assert(tp <= BCDUMP_KTAB_TRUE);
  147.         setitype(o, ~tp);
  148.     }
  149.     return 0;
  150. }

  152. /* Read a template table. */
  153. ‌static ktap_tab_t *bcread_ktab(BCReadCtx *ctx)
  154. {
  155.     int narray = bcread_uint32(ctx);
  156.     int nhash = bcread_uint32(ctx);

  158.     ktap_tab_t *t = kp_tab_new(ctx->ks, narray, hsize2hbits(nhash));
  159.     if (!t)
  160.         return NULL;

  162.     if (narray) {  /* Read array entries. */
  163.         int i;
  164.         ktap_val_t *o = t->array;
  165.         for (i = 0; i < narray; i++, o++)
  166.             if (bcread_ktabk(ctx, o))
  167.                 return NULL;
  168.     }
  169.     if (nhash) {  /* Read hash entries. */
  170.         int i;
  171.         for (i = 0; i < nhash; i++) {
  172.             ktap_val_t key;
  173.             ktap_val_t val;
  174.             if (bcread_ktabk(ctx, &key))
  175.                 return NULL;
  176.             kp_assert(!is_nil(&key));
  177.             if (bcread_ktabk(ctx, &val))
  178.                 return NULL;
  179.             kp_tab_set(ctx->ks, t, &key, &val);
  180.         }
  181.     }
  182.     return t;
  183. }

  185. /* Read GC constants(string, table, child proto) of a prototype. */
  186. ‌static int bcread_kgc(BCReadCtx *ctx, ktap_proto_t *pt, int sizekgc)
  187. {
  188.     ktap_obj_t **kr = (ktap_obj_t **)pt->k - (ptrdiff_t)sizekgc;
  189.     int i;

  191.     for (i = 0; i < sizekgc; i++, kr++) {
  192.         int tp = bcread_uint32(ctx);
  193.         if (tp >= BCDUMP_KGC_STR) {
  194.             int len = tp - BCDUMP_KGC_STR;
  195.             const char *p = (const char *)bcread_mem(ctx, len);
  196.             *kr =(ktap_obj_t *)kp_str_new(ctx->ks, p, len);
  197.             if (unlikely(!*kr))
  198.                 return -1;
  199.         } else if (tp == BCDUMP_KGC_TAB) {
  200.             *kr = (ktap_obj_t *)bcread_ktab(ctx);
  201.             if (unlikely(!*kr))
  202.                 return -1;
  203.         } else if (tp == BCDUMP_KGC_CHILD){
  204.             ktap_state_t *ks = ctx->ks;
  205.             if (ks->top <= bcread_oldtop(ctx)) {
  206.                 bcread_error(ctx, KP_ERR_BCBAD);
  207.                 return -1;
  208.             }
  209.             ks->top--;
  210.             *kr = (ktap_obj_t *)ptvalue(ks->top);
  211.         } else {
  212.             bcread_error(ctx, KP_ERR_BCBAD);
  213.             return -1;
  214.         }
  215.     }

  217.     return 0;
  218. }

  220. /* Read number constants of a prototype. */
  221. ‌static void bcread_knum(BCReadCtx *ctx, ktap_proto_t *pt, int sizekn)
  222. {
  223.     int i;
  224.     ktap_val_t *o = pt->k;

  226.     for (i = 0; i < sizekn; i++, o++) {
  227.         set_number(o, *(ktap_number *)bcread_mem(ctx,
  228.                     sizeof(ktap_number)));
  229.     }
  230. }

  232. /* Read bytecode instructions. */
  233. ‌static void bcread_bytecode(BCReadCtx *ctx, ktap_proto_t *pt, int sizebc)
  234. {
  235.     BCIns *bc = proto_bc(pt);
  236.     bc[0] = BCINS_AD((pt->flags & PROTO_VARARG) ? BC_FUNCV : BC_FUNCF,
  237.               pt->framesize, 0);
  238.     bcread_block(ctx, bc+1, (sizebc-1)*(int)sizeof(BCIns));
  239.     /* Swap bytecode instructions if the endianess differs. */
  240.     if (bcread_swap(ctx)) {
  241.         int i;
  242.         for (i = 1; i < sizebc; i++) bc[i] = bswap(bc[i]);
  243.     }
  244. }

  246. /* Read upvalue refs. */
  247. ‌static void bcread_uv(BCReadCtx *ctx, ktap_proto_t *pt, int sizeuv)
  248. {
  249.     if (sizeuv) {
  250.         uint16_t *uv = proto_uv(pt);
  251.         bcread_block(ctx, uv, sizeuv*2);
  252.         /* Swap upvalue refs if the endianess differs. */
  253.         if (bcread_swap(ctx)) {
  254.             int i;
  255.             for (i = 0; i < sizeuv; i++)
  256.                 uv[i] = (uint16_t)((uv[i] >> 8)|(uv[i] << 8));
  257.         }
  258.     }
  259. }

  261. /* Read a prototype. */
  262. ‌static ktap_proto_t *bcread_proto(BCReadCtx *ctx)
  263. {
  264.     ktap_proto_t *pt;
  265.     int framesize, numparams, flags;
  266.     int sizeuv, sizekgc, sizekn, sizebc, sizept;
  267.     int ofsk, ofsuv, ofsdbg;
  268.     int sizedbg = 0;
  269.     BCLine firstline = 0, numline = 0;

  271.     /* Read prototype header. */
  272.     flags = bcread_byte(ctx);
  273.     numparams = bcread_byte(ctx);
  274.     framesize = bcread_byte(ctx);
  275.     sizeuv = bcread_byte(ctx);
  276.     sizekgc = bcread_uint32(ctx);
  277.     sizekn = bcread_uint32(ctx);
  278.     sizebc = bcread_uint32(ctx) + 1;
  279.     if (!(bcread_flags(ctx) & BCDUMP_F_STRIP)) {
  280.         sizedbg = bcread_uint32(ctx);
  281.         if (sizedbg) {
  282.             firstline = bcread_uint32(ctx);
  283.             numline = bcread_uint32(ctx);
  284.         }
  285.     }

  287.     /* Calculate total size of prototype including all colocated arrays. */
  288.     sizept = (int)sizeof(ktap_proto_t) + sizebc * (int)sizeof(BCIns) +
  289.             sizekgc * (int)sizeof(ktap_obj_t *);
  290.     sizept = (sizept + (int)sizeof(ktap_val_t)-1) &
  291.             ~((int)sizeof(ktap_val_t)-1);
  292.     ofsk = sizept; sizept += sizekn*(int)sizeof(ktap_val_t);
  293.     ofsuv = sizept; sizept += ((sizeuv+1)&~1)*2;
  294.     ofsdbg = sizept; sizept += sizedbg;

  296.     /* Allocate prototype object and initialize its fields. */
  297.     pt = (ktap_proto_t *)kp_obj_new(ctx->ks, (int)sizept);
  298.     pt->gct = ~KTAP_TPROTO;
  299.     pt->numparams = (uint8_t)numparams;
  300.     pt->framesize = (uint8_t)framesize;
  301.     pt->sizebc = sizebc;
  302.     pt->k = (char *)pt + ofsk;
  303.     pt->uv = (char *)pt + ofsuv;
  304.     pt->sizekgc = 0;  /* Set to zero until fully initialized. */
  305.     pt->sizekn = sizekn;
  306.     pt->sizept = sizept;
  307.     pt->sizeuv = (uint8_t)sizeuv;
  308.     pt->flags = (uint8_t)flags;
  309.     pt->chunkname = ctx->chunkname;

  311.     /* Close potentially uninitialized gap between bc and kgc. */
  312.     *(uint32_t *)((char *)pt + ofsk - sizeof(ktap_obj_t *)*(sizekgc+1))
  313.                                     = 0;

  315.     /* Read bytecode instructions and upvalue refs. */
  316.     bcread_bytecode(ctx, pt, sizebc);
  317.     bcread_uv(ctx, pt, sizeuv);

  319.     /* Read constants. */
  320.     if (bcread_kgc(ctx, pt, sizekgc))
  321.         return NULL;
  322.     pt->sizekgc = sizekgc;
  323.     bcread_knum(ctx, pt, sizekn);

  325.     /* Read and initialize debug info. */
  326.     pt->firstline = firstline;
  327.     pt->numline = numline;
  328.     if (sizedbg) {
  329.         int sizeli = (sizebc-1) << (numline < 256 ? 0 :
  330.                     numline < 65536 ? 1 : 2);
  331.         pt->lineinfo = (char *)pt + ofsdbg;
  332.         pt->uvinfo = (char *)pt + ofsdbg + sizeli;
  333.         bcread_dbg(ctx, pt, sizedbg);
  334.         pt->varinfo = (void *)bcread_varinfo(pt);
  335.     } else {
  336.         pt->lineinfo = NULL;
  337.         pt->uvinfo = NULL;
  338.         pt->varinfo = NULL;
  339.     }
  340.     return pt;
  341. }

  343. /* Read and check header of bytecode dump. */
  344. ‌static int bcread_header(BCReadCtx *ctx)
  345. {
  346.     uint32_t flags;

  348.     if (bcread_byte(ctx) != BCDUMP_HEAD1 ||
  349.         bcread_byte(ctx) != BCDUMP_HEAD2 ||
  350.         bcread_byte(ctx) != BCDUMP_HEAD3 ||
  351.         bcread_byte(ctx) != BCDUMP_VERSION)
  352.         return -1;

  354.     bcread_flags(ctx) = flags = bcread_byte(ctx);

  356.     if ((flags & ~(BCDUMP_F_KNOWN)) != 0)
  357.         return -1;

  359.     if ((flags & BCDUMP_F_FFI)) {
  360.         return -1;
  361.     }

  363.     if ((flags & BCDUMP_F_STRIP)) {
  364.         ctx->chunkname = kp_str_newz(ctx->ks, "striped");
  365.     } else {
  366.         int len = bcread_uint32(ctx);
  367.         ctx->chunkname = kp_str_new(ctx->ks,
  368.                 (const char *)bcread_mem(ctx, len), len);
  369.     }

  371.     if (unlikely(!ctx->chunkname))
  372.         return -1;

  374.     return 0;
  375. }

  377. /* Read a bytecode dump. */
  378. ‌ktap_proto_t *kp_bcread(ktap_state_t *ks, unsigned char *buff, int len)
  379. {
  380.     BCReadCtx ctx;

  382.     ctx.ks = ks;
  383.     ctx.p = buff;
  384.     ctx.pe = buff + len;

  386.     ctx.start = buff;

  388.     bcread_savetop(&ctx);
  389.     /* Check for a valid bytecode dump header. */
  390.     if (bcread_header(&ctx)) {
  391.         bcread_error(&ctx, KP_ERR_BCFMT);
  392.         return NULL;
  393.     }

  395.     for (;;) {  /* Process all prototypes in the bytecode dump. */
  396.         ktap_proto_t *pt;
  397.         int len;
  398.         const char *startp;
  399.         /* Read length. */
  400.         if (ctx.p < ctx.pe && ctx.p[0] == 0) {  /* Shortcut EOF. */
  401.             ctx.p++;
  402.             break;
  403.         }
  404.         len = bcread_uint32(&ctx);
  405.         if (!len)
  406.             break;  /* EOF */
  407.         startp = ctx.p;
  408.         pt = bcread_proto(&ctx);
  409.         if (!pt)
  410.             return NULL;
  411.         if (ctx.p != startp + len) {
  412.             bcread_error(&ctx, KP_ERR_BCBAD);
  413.             return NULL;
  414.         }
  415.         set_proto(ks->top, pt);
  416.         incr_top(ks);
  417.     }
  418.     if ((int32_t)(2*(uint32_t)(ctx.pe - ctx.p)) > 0 ||
  419.             ks->top-1 != bcread_oldtop(&ctx)) {
  420.         bcread_error(&ctx, KP_ERR_BCBAD);
  421.         return NULL;
  422.     }

  424.     /* Pop off last prototype. */
  425.     ks->top--;
  426.     return ptvalue(ks->top);
  427. }

One Level Up Top Level