One Level Up Top Level

userspace/kp_bcwrite.c - ktap

Global variables defined

Data types defined

Functions defined

Macros defined

Source code

  1. /*
  2. * Bytecode writer
  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. * Copyright (C) 1994-2013 Lua.org, PUC-Rio.
  9. *  - The part of code in this file is copied from lua initially.
  10. *  - lua's MIT license is compatible with GPL.
  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 <stdio.h>
  27. #include <stdlib.h>
  28. #include <string.h>

  30. #include "../include/ktap_types.h"
  31. #include "cparser.h"
  32. #include "kp_util.h"

  34. /* Context for bytecode writer. */
  35. ‌typedef struct BCWriteCtx {
  36.     SBuf sb;        /* Output buffer. */
  37.     ktap_proto_t *pt;    /* Root prototype. */
  38.     ktap_writer wfunc;    /* Writer callback. */
  39.     void *wdata;        /* Writer callback data. */
  40.     int strip;        /* Strip debug info. */
  41.     int status;        /* Status from writer callback. */
  42. ‌} BCWriteCtx;


  45. ‌static char *bcwrite_uint32(char *p, uint32_t v)
  46. {
  47.     memcpy(p, &v, sizeof(uint32_t));
  48.     p += sizeof(uint32_t);
  49.     return p;
  50. }

  52. /* -- Bytecode writer ----------------------------------------------------- */

  54. /* Write a single constant key/value of a template table. */
  55. ‌static void bcwrite_ktabk(BCWriteCtx *ctx, const ktap_val_t *o, int narrow)
  56. {
  57.     char *p = kp_buf_more(&ctx->sb, 1+10);
  58.     if (is_string(o)) {
  59.         const ktap_str_t *str = rawtsvalue(o);
  60.         int len = str->len;
  61.         p = kp_buf_more(&ctx->sb, 5+len);
  62.         p = bcwrite_uint32(p, BCDUMP_KTAB_STR+len);
  63.         p = kp_buf_wmem(p, getstr(str), len);
  64.     } else if (is_number(o)) {
  65.         p = bcwrite_uint32(p, BCDUMP_KTAB_NUM);
  66.         p = kp_buf_wmem(p, &nvalue(o), sizeof(ktap_number));
  67.     } else {
  68.         kp_assert(tvispri(o));
  69.         p = bcwrite_uint32(p, BCDUMP_KTAB_NIL+~itype(o));
  70.     }
  71.     setsbufP(&ctx->sb, p);
  72. }

  74. /* Write a template table. */
  75. ‌static void bcwrite_ktab(BCWriteCtx *ctx, char *p, const ktap_tab_t *t)
  76. {
  77.     int narray = 0, nhash = 0;
  78.     if (t->asize > 0) {  /* Determine max. length of array part. */
  79.         ptrdiff_t i;
  80.         ktap_val_t *array = t->array;
  81.         for (i = (ptrdiff_t)t->asize-1; i >= 0; i--)
  82.             if (!is_nil(&array[i]))
  83.                 break;
  84.             narray = (int)(i+1);
  85.     }
  86.     if (t->hmask > 0) {  /* Count number of used hash slots. */
  87.         int i, hmask = t->hmask;
  88.         ktap_node_t *node = t->node;
  89.         for (i = 0; i <= hmask; i++)
  90.             nhash += !is_nil(&node[i].val);
  91.     }
  92.     /* Write number of array slots and hash slots. */
  93.     p = bcwrite_uint32(p, narray);
  94.     p = bcwrite_uint32(p, nhash);
  95.     setsbufP(&ctx->sb, p);
  96.     if (narray) {  /* Write array entries (may contain nil). */
  97.         int i;
  98.         ktap_val_t *o = t->array;
  99.         for (i = 0; i < narray; i++, o++)
  100.             bcwrite_ktabk(ctx, o, 1);
  101.     }
  102.     if (nhash) {  /* Write hash entries. */
  103.         int i = nhash;
  104.         ktap_node_t *node = t->node + t->hmask;
  105.         for (;; node--)
  106.             if (!is_nil(&node->val)) {
  107.                 bcwrite_ktabk(ctx, &node->key, 0);
  108.                 bcwrite_ktabk(ctx, &node->val, 1);
  109.                 if (--i == 0)
  110.                     break;
  111.             }
  112.     }
  113. }

  115. /* Write GC constants of a prototype. */
  116. ‌static void bcwrite_kgc(BCWriteCtx *ctx, ktap_proto_t *pt)
  117. {
  118.     int i, sizekgc = pt->sizekgc;
  119.     ktap_obj_t **kr = (ktap_obj_t **)pt->k - (ptrdiff_t)sizekgc;

  121.     for (i = 0; i < sizekgc; i++, kr++) {
  122.         ktap_obj_t *o = *kr;
  123.         int tp, need = 1;
  124.         char *p;

  126.         /* Determine constant type and needed size. */
  127.         if (o->gch.gct == ~KTAP_TSTR) {
  128.             tp = BCDUMP_KGC_STR + ((ktap_str_t *)o)->len;
  129.             need = 5 + ((ktap_str_t *)o)->len;
  130.         } else if (o->gch.gct == ~KTAP_TPROTO) {
  131.             kp_assert((pt->flags & PROTO_CHILD));
  132.             tp = BCDUMP_KGC_CHILD;
  133.         } else {
  134.             kp_assert(o->gch.gct == ~KTAP_TTAB);
  135.             tp = BCDUMP_KGC_TAB;
  136.             need = 1+2*5;
  137.         }

  139.         /* Write constant type. */
  140.         p = kp_buf_more(&ctx->sb, need);
  141.         p = bcwrite_uint32(p, tp);
  142.         /* Write constant data (if any). */
  143.         if (tp >= BCDUMP_KGC_STR) {
  144.             p = kp_buf_wmem(p, getstr((ktap_str_t *)o),
  145.                     ((ktap_str_t *)o)->len);
  146.         } else if (tp == BCDUMP_KGC_TAB) {
  147.             bcwrite_ktab(ctx, p, (ktap_tab_t *)o);
  148.             continue;
  149.         }
  150.         setsbufP(&ctx->sb, p);
  151.     }
  152. }

  154. /* Write number constants of a prototype. */
  155. ‌static void bcwrite_knum(BCWriteCtx *ctx, ktap_proto_t *pt)
  156. {
  157.     int i, sizekn = pt->sizekn;
  158.     const ktap_val_t *o = (ktap_val_t *)pt->k;
  159.     char *p = kp_buf_more(&ctx->sb, 10*sizekn);

  161.     for (i = 0; i < sizekn; i++, o++) {
  162.         if (is_number(o))
  163.             p = kp_buf_wmem(p, &nvalue(o), sizeof(ktap_number));
  164.     }
  165.     setsbufP(&ctx->sb, p);
  166. }

  168. /* Write bytecode instructions. */
  169. ‌static char *bcwrite_bytecode(BCWriteCtx *ctx, char *p, ktap_proto_t *pt)
  170. {
  171.     int nbc = pt->sizebc-1;  /* Omit the [JI]FUNC* header. */

  173.     p = kp_buf_wmem(p, proto_bc(pt)+1, nbc*(int)sizeof(BCIns));
  174.     return p;
  175. }

  177. /* Write prototype. */
  178. ‌static void bcwrite_proto(BCWriteCtx *ctx, ktap_proto_t *pt)
  179. {
  180.     int sizedbg = 0;
  181.     char *p;

  183.     /* Recursively write children of prototype. */
  184.     if (pt->flags & PROTO_CHILD) {
  185.         ptrdiff_t i, n = pt->sizekgc;
  186.         ktap_obj_t **kr = (ktap_obj_t **)pt->k - 1;
  187.         for (i = 0; i < n; i++, kr--) {
  188.             ktap_obj_t *o = *kr;
  189.             if (o->gch.gct == ~KTAP_TPROTO)
  190.                 bcwrite_proto(ctx, (ktap_proto_t *)o);
  191.         }
  192.     }

  194.     /* Start writing the prototype info to a buffer. */
  195.     p = kp_buf_need(&ctx->sb,
  196.         5+4+6*5+(pt->sizebc-1)*(int)sizeof(BCIns)+pt->sizeuv*2);
  197.     p += 4;  /* Leave room for final size. */

  199.     /* Write prototype header. */
  200.     *p++ = (pt->flags & (PROTO_CHILD|PROTO_VARARG|PROTO_FFI));
  201.     *p++ = pt->numparams;
  202.     *p++ = pt->framesize;
  203.     *p++ = pt->sizeuv;
  204.     p = bcwrite_uint32(p, pt->sizekgc);
  205.     p = bcwrite_uint32(p, pt->sizekn);
  206.     p = bcwrite_uint32(p, pt->sizebc-1);
  207.     if (!ctx->strip) {
  208.         if (proto_lineinfo(pt))
  209.             sizedbg = pt->sizept -
  210.                 (int)((char *)proto_lineinfo(pt) - (char *)pt);
  211.         p = bcwrite_uint32(p, sizedbg);
  212.         if (sizedbg) {
  213.             p = bcwrite_uint32(p, pt->firstline);
  214.             p = bcwrite_uint32(p, pt->numline);
  215.         }
  216.     }

  218.     /* Write bytecode instructions and upvalue refs. */
  219.     p = bcwrite_bytecode(ctx, p, pt);
  220.     p = kp_buf_wmem(p, proto_uv(pt), pt->sizeuv*2);
  221.     setsbufP(&ctx->sb, p);

  223.     /* Write constants. */
  224.     bcwrite_kgc(ctx, pt);
  225.     bcwrite_knum(ctx, pt);

  227.     /* Write debug info, if not stripped. */
  228.     if (sizedbg) {
  229.         p = kp_buf_more(&ctx->sb, sizedbg);
  230.         p = kp_buf_wmem(p, proto_lineinfo(pt), sizedbg);
  231.         setsbufP(&ctx->sb, p);
  232.     }

  234.     /* Pass buffer to writer function. */
  235.     if (ctx->status == 0) {
  236.         int n = sbuflen(&ctx->sb) - 4;
  237.         char *q = sbufB(&ctx->sb);
  238.         p = bcwrite_uint32(q, n);  /* Fill in final size. */
  239.         kp_assert(p == sbufB(&ctx->sb) + 4);
  240.         ctx->status = ctx->wfunc(q, n + 4, ctx->wdata);
  241.     }
  242. }

  244. /* Write header of bytecode dump. */
  245. ‌static void bcwrite_header(BCWriteCtx *ctx)
  246. {
  247.     ktap_str_t *chunkname = proto_chunkname(ctx->pt);
  248.     const char *name = getstr(chunkname);
  249.     int len = chunkname->len;
  250.     char *p = kp_buf_need(&ctx->sb, 5+5+len);
  251.     *p++ = BCDUMP_HEAD1;
  252.     *p++ = BCDUMP_HEAD2;
  253.     *p++ = BCDUMP_HEAD3;
  254.     *p++ = BCDUMP_VERSION;
  255.     *p++ = (ctx->strip ? BCDUMP_F_STRIP : 0) + (KP_BE ? BCDUMP_F_BE : 0);

  257.     if (!ctx->strip) {
  258.         p = bcwrite_uint32(p, len);
  259.         p = kp_buf_wmem(p, name, len);
  260.     }
  261.     ctx->status = ctx->wfunc(sbufB(&ctx->sb),
  262.         (int)(p - sbufB(&ctx->sb)), ctx->wdata);
  263. }

  265. /* Write footer of bytecode dump. */
  266. ‌static void bcwrite_footer(BCWriteCtx *ctx)
  267. {
  268.     if (ctx->status == 0) {
  269.         uint8_t zero = 0;
  270.         ctx->status = ctx->wfunc(&zero, 1, ctx->wdata);
  271.     }
  272. }

  274. /* Write bytecode for a prototype. */
  275. ‌int kp_bcwrite(ktap_proto_t *pt, ktap_writer writer, void *data, int strip)
  276. {
  277.     BCWriteCtx ctx;

  279.     ctx.pt = pt;
  280.     ctx.wfunc = writer;
  281.     ctx.wdata = data;
  282.     ctx.strip = strip;
  283.     ctx.status = 0;

  285.     kp_buf_init(&ctx.sb);
  286.     kp_buf_need(&ctx.sb, 1024);  /* Avoids resize for most prototypes. */
  287.     bcwrite_header(&ctx);
  288.     bcwrite_proto(&ctx, ctx.pt);
  289.     bcwrite_footer(&ctx);

  291.     kp_buf_free(&ctx.sb);
  292.     return ctx.status;
  293. }

  295. /* -- Bytecode dump ----------------------------------------------------- */

  297. ‌static const char * const bc_names[] = {
  298. ‌#define BCNAME(name, ma, mb, mc, mt)       #name,
  299.     BCDEF(BCNAME)
  300. ‌#undef BCNAME
  301.   NULL
  302. };

  304. ‌static const uint16_t bc_mode[] = {
  305.     BCDEF(BCMODE)
  306. };

  308. ‌static void dump_bytecode(ktap_proto_t *pt)
  309. {
  310.     int nbc = pt->sizebc - 1; /* Omit the FUNC* header. */
  311.     BCIns *ins = proto_bc(pt) + 1;
  312.     ktap_obj_t **kbase = pt->k;
  313.     int i;

  315.     printf("-- BYTECODE -- %s:%d-%d\n", getstr(pt->chunkname),
  316.         pt->firstline, pt->firstline + pt->numline);

  318.     for (i = 0; i < nbc; i++, ins++) {
  319.         int op = bc_op(*ins);

  321.         printf("%04d\t%s", i + 1, bc_names[op]);

  323.         printf("\t%d", bc_a(*ins));
  324.         if (bcmode_b(op) != BCMnone)
  325.             printf("\t%d", bc_b(*ins));

  327.         if (bcmode_hasd(op))
  328.             printf("\t%d", bc_d(*ins));
  329.         else
  330.             printf("\t%d", bc_c(*ins));

  332.         if (bcmode_b(op) == BCMstr || bcmode_c(op) == BCMstr) {
  333.             printf("\t  ; ");
  334.             if (bcmode_d(op) == BCMstr) {
  335.                 int idx = ~bc_d(*ins);
  336.                 printf("\"%s\"", getstr((ktap_str_t *)kbase[idx]));
  337.             }
  338.         }
  339.         printf("\n");
  340.     }
  341. }

  343. ‌static int function_nr = 0;

  345. ‌void kp_dump_proto(ktap_proto_t *pt)
  346. {
  347.     printf("\n----------------------------------------------------\n");
  348.     printf("function proto %d:\n", function_nr++);
  349.     printf("numparams: %d\n", pt->numparams);
  350.     printf("framesize: %d\n", pt->framesize);
  351.     printf("sizebc: %d\n", pt->sizebc);
  352.     printf("sizekgc: %d\n", pt->sizekgc);
  353.     printf("sizekn: %d\n", pt->sizekn);
  354.     printf("sizept: %d\n", pt->sizept);
  355.     printf("sizeuv: %d\n", pt->sizeuv);
  356.     printf("firstline: %d\n", pt->firstline);
  357.     printf("numline: %d\n", pt->numline);

  359.     printf("has child proto: %d\n", pt->flags & PROTO_CHILD);
  360.     printf("has vararg: %d\n", pt->flags & PROTO_VARARG);
  361.     printf("has ILOOP: %d\n", pt->flags & PROTO_ILOOP);

  363.     dump_bytecode(pt);

  365.     /* Recursively dump children of prototype. */
  366.     if (pt->flags & PROTO_CHILD) {
  367.         ptrdiff_t i, n = pt->sizekgc;
  368.         ktap_obj_t **kr = (ktap_obj_t **)pt->k - 1;
  369.         for (i = 0; i < n; i++, kr--) {
  370.             ktap_obj_t *o = *kr;
  371.             if (o->gch.gct == ~KTAP_TPROTO)
  372.                 kp_dump_proto((ktap_proto_t *)o);
  373.         }
  374.     }
  375. }

One Level Up Top Level