You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314
  1. #include "vm/print.h"
  2. #include <stdio.h>
  3. #include <string.h>
  4. #include <stdint.h>
  5. static l2_word read_u4le(unsigned char *ops, size_t *ptr) {
  6. unsigned char *data = &ops[*ptr];
  7. l2_word ret =
  8. (l2_word)data[0] |
  9. (l2_word)data[1] << 8 |
  10. (l2_word)data[2] << 16 |
  11. (l2_word)data[3] << 24;
  12. *ptr += 4;
  13. return ret;
  14. }
  15. static l2_word read_u1le(unsigned char *ops, size_t *ptr) {
  16. return ops[(*ptr)++];
  17. }
  18. static double read_d8le(unsigned char *ops, size_t *ptr) {
  19. unsigned char *data = &ops[*ptr];
  20. uint64_t integer = 0 |
  21. (uint64_t)data[0] |
  22. (uint64_t)data[1] << 8 |
  23. (uint64_t)data[2] << 16 |
  24. (uint64_t)data[3] << 24 |
  25. (uint64_t)data[4] << 32 |
  26. (uint64_t)data[5] << 40 |
  27. (uint64_t)data[6] << 48 |
  28. (uint64_t)data[7] << 56;
  29. double num;
  30. memcpy(&num, &integer, 8);
  31. *ptr += 8;
  32. return num;
  33. }
  34. void l2_vm_print_val(struct l2_vm_value *val) {
  35. switch (l2_value_get_type(val)) {
  36. case L2_VAL_TYPE_NONE:
  37. printf("NONE\n");
  38. break;
  39. case L2_VAL_TYPE_ATOM:
  40. printf("ATOM %u\n", val->atom);
  41. break;
  42. case L2_VAL_TYPE_REAL:
  43. printf("REAL %f\n", val->real);
  44. break;
  45. case L2_VAL_TYPE_ARRAY:
  46. {
  47. printf("ARRAY, len %u\n", val->extra.arr_length);
  48. l2_word *data = val->flags & L2_VAL_SBO ? val->shortarray : val->array->data;
  49. for (size_t i = 0; i < val->extra.arr_length; ++i) {
  50. printf(" %zu: %u\n", i, data[i]);
  51. }
  52. }
  53. break;
  54. case L2_VAL_TYPE_BUFFER:
  55. {
  56. if (val->buffer == NULL) {
  57. printf("BUFFER, empty\n");
  58. return;
  59. }
  60. printf("BUFFER, len %u\n", val->extra.buf_length);
  61. for (size_t i = 0; i < val->extra.buf_length; ++i) {
  62. printf(" %zu: %c\n", i, val->buffer[i]);
  63. }
  64. }
  65. break;
  66. case L2_VAL_TYPE_NAMESPACE:
  67. {
  68. if (val->ns == NULL) {
  69. printf("NAMESPACE, empty, parent %u\n", val->extra.ns_parent);
  70. return;
  71. }
  72. printf("NAMESPACE, len %zu, parent %u\n", val->ns->len, val->extra.ns_parent);
  73. for (size_t i = 0; i < val->ns->size; ++i) {
  74. l2_word key = val->ns->data[i];
  75. l2_word v = val->ns->data[val->ns->size + i];
  76. if (key == 0 || key == ~(l2_word)0) continue;
  77. printf(" %u: %u\n", key, v);
  78. }
  79. }
  80. break;
  81. case L2_VAL_TYPE_FUNCTION:
  82. printf("FUNCTION, pos %u, ns %u\n", val->func.pos, val->func.ns);
  83. break;
  84. case L2_VAL_TYPE_CFUNCTION:
  85. // ISO C doesn't let you cast a function pointer to void*.
  86. printf("C FUNCTION, %8jx\n", (uintmax_t)val->cfunc);
  87. break;
  88. case L2_VAL_TYPE_ERROR:
  89. printf("ERROR, %s\n", val->error);
  90. break;
  91. case L2_VAL_TYPE_CONTINUATION:
  92. printf("CONTINUATION, call %u, cont %08jx\n",
  93. val->extra.cont_call, (uintmax_t)val->cont);
  94. break;
  95. }
  96. }
  97. void l2_vm_print_state(struct l2_vm *vm) {
  98. printf("Stack:\n");
  99. l2_vm_print_stack(vm);
  100. printf("Heap:\n");
  101. l2_vm_print_heap(vm);
  102. printf("Frame Stack:\n");
  103. l2_vm_print_fstack(vm);
  104. }
  105. void l2_vm_print_heap(struct l2_vm *vm) {
  106. printf(" Root: ");
  107. l2_vm_print_val(&vm->values[2]);
  108. printf(" 0-%u: (builtins)\n", vm->gc_start - 1);
  109. for (l2_word i = vm->gc_start; i < vm->valuessize; ++i) {
  110. if (l2_bitset_get(&vm->valueset, i)) {
  111. printf(" %u: ", i);
  112. l2_vm_print_val(&vm->values[i]);
  113. }
  114. }
  115. }
  116. void l2_vm_print_stack(struct l2_vm *vm) {
  117. for (l2_word i = 0; i < vm->sptr; ++i) {
  118. printf(" %i: %i\n", i, vm->stack[i]);
  119. }
  120. }
  121. void l2_vm_print_fstack(struct l2_vm *vm) {
  122. for (l2_word i = 0; i < vm->fsptr; ++i) {
  123. printf(" %i: %i, ret %i, stack base %i\n",
  124. i, vm->fstack[i].ns, vm->fstack[i].retptr, vm->fstack[i].sptr);
  125. }
  126. }
  127. void l2_vm_print_op(unsigned char *ops, size_t opcount, size_t *ptr) {
  128. enum l2_opcode opcode = (enum l2_opcode)ops[(*ptr)++];
  129. switch (opcode) {
  130. case L2_OP_NOP:
  131. printf("NOP\n");
  132. return;
  133. case L2_OP_DISCARD:
  134. printf("DISCARD\n");
  135. return;
  136. case L2_OP_SWAP_DISCARD:
  137. printf("SWAP_DISCARD\n");
  138. return;
  139. case L2_OP_DUP:
  140. printf("DUP\n");
  141. return;
  142. case L2_OP_ADD:
  143. printf("ADD\n");
  144. return;
  145. case L2_OP_FUNC_CALL_U4:
  146. printf("FUNC_CALL %u\n", read_u4le(ops, ptr));
  147. return;
  148. case L2_OP_FUNC_CALL_U1:
  149. printf("FUNC_CALL %u\n", read_u1le(ops, ptr));
  150. return;
  151. case L2_OP_FUNC_CALL_INFIX:
  152. printf("FUNC_CALL_INFIX\n");
  153. return;
  154. case L2_OP_RJMP_U4:
  155. printf("RJMP %u\n", read_u4le(ops, ptr));
  156. return;
  157. case L2_OP_RJMP_U1:
  158. printf("RJMP %u\n", read_u1le(ops, ptr));
  159. return;
  160. case L2_OP_STACK_FRAME_LOOKUP_U4:
  161. printf("STACK_FRAME_LOOKUP %u\n", read_u4le(ops, ptr));
  162. return;
  163. case L2_OP_STACK_FRAME_LOOKUP_U1:
  164. printf("STACK_FRAME_LOOKUP %u\n", read_u1le(ops, ptr));
  165. return;
  166. case L2_OP_STACK_FRAME_SET_U4:
  167. printf("STACK_FRAME_SET %u\n", read_u4le(ops, ptr));
  168. return;
  169. case L2_OP_STACK_FRAME_SET_U1:
  170. printf("STACK_FRAME_SET %u\n", read_u1le(ops, ptr));
  171. return;
  172. case L2_OP_STACK_FRAME_REPLACE_U4:
  173. printf("STACK_FRAME_REPLACE %u\n", read_u4le(ops, ptr));
  174. return;
  175. case L2_OP_STACK_FRAME_REPLACE_U1:
  176. printf("STACK_FRAME_REPLACE %u\n", read_u1le(ops, ptr));
  177. return;
  178. case L2_OP_RET:
  179. printf("RET\n");
  180. return;
  181. case L2_OP_ALLOC_NONE:
  182. printf("ALLOC_NONE\n");
  183. return;
  184. case L2_OP_ALLOC_ATOM_U4:
  185. printf("ALLOC_ATOM %u\n", read_u4le(ops, ptr));
  186. return;
  187. case L2_OP_ALLOC_ATOM_U1:
  188. printf("ALLOC_ATOM %u\n", read_u1le(ops, ptr));
  189. return;
  190. case L2_OP_ALLOC_REAL_D8:
  191. printf("ALLOC_REAL %f\n", read_d8le(ops, ptr));
  192. return;
  193. case L2_OP_ALLOC_BUFFER_STATIC_U4:
  194. {
  195. l2_word w1 = read_u4le(ops, ptr);
  196. l2_word w2 = read_u4le(ops, ptr);;
  197. printf("ALLOC_BUFFER_STATIC %u %u\n", w1, w2);
  198. }
  199. return;
  200. case L2_OP_ALLOC_BUFFER_STATIC_U1:
  201. {
  202. l2_word w1 = read_u1le(ops, ptr);
  203. l2_word w2 = read_u1le(ops, ptr);;
  204. printf("ALLOC_BUFFER_STATIC %u %u\n", w1, w2);
  205. }
  206. return;
  207. case L2_OP_ALLOC_ARRAY_U4:
  208. printf("ALLOC_ARRAY %u\n", read_u4le(ops, ptr));
  209. return;
  210. case L2_OP_ALLOC_ARRAY_U1:
  211. printf("ALLOC_ARRAY %u\n", read_u1le(ops, ptr));
  212. return;
  213. case L2_OP_ALLOC_NAMESPACE:
  214. printf("ALLOC_NAMESPACE\n");
  215. return;
  216. case L2_OP_ALLOC_FUNCTION_U4:
  217. printf("ALLOC_FUNCTION %u\n", read_u4le(ops, ptr));
  218. return;
  219. case L2_OP_ALLOC_FUNCTION_U1:
  220. printf("ALLOC_FUNCTION %u\n", read_u1le(ops, ptr));
  221. return;
  222. case L2_OP_NAMESPACE_SET_U4:
  223. printf("NAMESPACE_SET %u\n", read_u4le(ops, ptr));
  224. return;
  225. case L2_OP_NAMESPACE_SET_U1:
  226. printf("NAMESPACE_SET %u\n", read_u1le(ops, ptr));
  227. return;
  228. case L2_OP_NAMESPACE_LOOKUP_U4:
  229. printf("NAMESPACE_LOOKUP %u\n", read_u4le(ops, ptr));
  230. return;
  231. case L2_OP_NAMESPACE_LOOKUP_U1:
  232. printf("NAMESPACE_LOOKUP %u\n", read_u1le(ops, ptr));
  233. return;
  234. case L2_OP_ARRAY_LOOKUP_U4:
  235. printf("ARRAY_LOOKUP %u\n", read_u4le(ops, ptr));
  236. return;
  237. case L2_OP_ARRAY_LOOKUP_U1:
  238. printf("ARRAY_LOOKUP %u\n", read_u1le(ops, ptr));
  239. return;
  240. case L2_OP_ARRAY_SET_U4:
  241. printf("ARRAY_SET %u\n", read_u4le(ops, ptr));
  242. return;
  243. case L2_OP_ARRAY_SET_U1:
  244. printf("ARRAY_SET %u\n", read_u1le(ops, ptr));
  245. return;
  246. case L2_OP_DYNAMIC_LOOKUP:
  247. printf("DYNAMIC_LOOKUP\n");
  248. return;
  249. case L2_OP_DYNAMIC_SET:
  250. printf("DYNAMIC_SET\n");
  251. return;
  252. case L2_OP_HALT:
  253. printf("HALT\n");
  254. return;
  255. }
  256. printf("? 0x%02x\n", opcode);
  257. }
  258. void l2_vm_print_bytecode(unsigned char *ops, size_t opcount) {
  259. size_t ptr = 0;
  260. while (ptr < opcount) {
  261. printf("%04zu ", ptr);
  262. l2_vm_print_op(ops, opcount, &ptr);
  263. }
  264. }