ed/perfaware
1
0
Fork 0
mirror of https://github.com/Ed94/perfaware.git synced 2026-09-17 21:23:48 +00:00
Code Issues Packages Projects Releases Wiki Activity

Compare commits

base: ed/perfaware:28e6e38c9299537009ccfb35f593180a9c5989d0
Branches Tags
ed/perfaware:main ed/perfaware:decoder
ed/perfaware:pre-company-license
...
compare: ed/perfaware:decoder
Branches Tags
ed/perfaware:main ed/perfaware:decoder
ed/perfaware:pre-company-license
6 Commits
28e6e38c92 ... decoder
Author SHA1 Message Date
ed d3fd791537 working on serializer 2026-09-09 12:09:12 -04:00
ed 6cca3fbe8b decoder seems to be working, need to make a serializer next. 2026-09-09 01:50:20 -04:00
ed 5e6e139cc0 x8616_decode_gen_emit now easier to read... 2026-09-08 23:46:35 -04:00
ed b9b1ed460a Better str8_fmt_ktl_buf (using simd) 2026-09-08 20:45:57 -04:00
ed 749a712ceb update comment 2026-09-08 15:32:40 -04:00
ed 7e533cbfb2 fixes, convering x8616_decode_gen_emit_plan to use formatting template. 2026-09-08 13:42:59 -04:00
17 changed files with 1300 additions and 467 deletions
Expand all files Collapse all files
code/8086/decoder.c
+34 -16
View File
@@ -24,7 +24,7 @@ RO_ global U1 x8616_decode_payload_bytes[] = {
};
typedef Struct_(X8616_DecodePlex) {
U1 const* source;
U1* source;
U4 source_size;
U4 source_offset;
@@ -33,7 +33,7 @@ typedef Struct_(X8616_DecodePlex) {
U2 dispatch;
U1 plan_idx;
X8616_DecodePlan const* plan;
X8616_DecodePlan* plan;
U1 opcode;
U1 post_opcode;
@@ -80,6 +80,23 @@ typedef Struct_(X8616_DecodePlex) {
FI_ U2 x8616_decode_u2(U1_R bytes) { return C_(U2, bytes[0] | u2_(bytes[1] << 8)); }
internal X8616_OpcodePrefix
x8616_decode_opcode(X8616_DecodePlan const* plan, U1 opcode)
{
U1 field_mask = 0;
if (plan->flags & x8616_plan_has_d) field_mask |= u1_(1u << plan->d_shift);
if (plan->flags & x8616_plan_has_w) field_mask |= u1_(1u << plan->w_shift);
if (plan->flags & x8616_plan_has_s) field_mask |= u1_(1u << plan->s_shift);
if (plan->flags & x8616_plan_has_v) field_mask |= u1_(1u << plan->v_shift);
if (plan->flags & x8616_plan_has_z) field_mask |= u1_(1u << plan->z_shift);
if (plan->flags & x8616_plan_has_reg) field_mask |= u1_(0b111u << plan->reg_shift);
if (plan->flags & x8616_plan_has_sr) field_mask |= u1_(0b11u << plan->sr_shift);
if (field_mask == 0) return 0;
U1 stem_mask = u1_(~field_mask);
if (stem_mask == 0) return 0;
return C_(X8616_OpcodePrefix, (opcode & stem_mask) >> count_trailing_zeros_u4(stem_mask));
}
internal void
x8616_decode_apply_prefix(X8616_DecodePlex_R plex, X8616_DecodePlan_R plan, U1 opcode) {
plex->prefixes.count += 1;
@@ -107,7 +124,7 @@ x8616_decode_one_plex(X8616_DecodePlex* plex)
U2 prefix_dispatch = x8616_decode_dispatch[prefix_opcode];
if (prefix_dispatch == false || (prefix_dispatch & X8616_DECODE_AUX_BIT)) break;
X8616_DecodePlan const* prefix_plan = x8616_decode_plans + prefix_dispatch;
X8616_DecodePlan_R prefix_plan = x8616_decode_plans + prefix_dispatch;
if ((prefix_plan->flags & x8616_plan_is_prefix) == false) break;
x8616_decode_apply_prefix(plex, prefix_plan, prefix_opcode);
@@ -228,7 +245,6 @@ x8616_decode_one_plex(X8616_DecodePlex* plex)
plex->instruction.prefixes = plex->prefixes;
plex->instruction.op = x8616_op_invalid;
plex->instruction.decode_flags = (plex->encoding_invalid ? x8616_decode_invalid : 0) | (plex->classification_truncated ? x8616_decode_truncated : 0);
plex->instruction.opcode = plex->opcode;
plex->instruction.size = u1_(prefix_at + invalid_body_size);
plex->instruction.size_required = plex->instruction.size;
return plex->instruction.size;
@@ -305,37 +321,37 @@ x8616_decode_one_plex(X8616_DecodePlex* plex)
source[x8616_operand_reg_modrm].flags = x8616_decoded_operand_register;
source[x8616_operand_reg_modrm].width = plex->width;
source[x8616_operand_reg_modrm].reg = plex->reg;
source[x8616_operand_reg_modrm].reg.r16 = C_(X8616_Reg16, plex->reg);
source[x8616_operand_reg_opcode].flags = x8616_decoded_operand_register;
source[x8616_operand_reg_opcode].width = plex->width;
source[x8616_operand_reg_opcode].reg = plex->reg_opcode;
source[x8616_operand_reg_opcode].reg.r16 = C_(X8616_Reg16, plex->reg_opcode);
source[x8616_operand_segment_modrm].flags = x8616_decoded_operand_segment;
source[x8616_operand_segment_modrm].width = x8616_width_word;
source[x8616_operand_segment_modrm].segment = plex->sr_modrm;
source[x8616_operand_segment_modrm].segment = C_(X8616_Segment, plex->sr_modrm);
source[x8616_operand_segment_opcode].flags = x8616_decoded_operand_segment;
source[x8616_operand_segment_opcode].width = x8616_width_word;
source[x8616_operand_segment_opcode].segment = plex->sr_opcode;
source[x8616_operand_segment_opcode].segment = C_(X8616_Segment, plex->sr_opcode);
source[x8616_operand_acc].flags = x8616_decoded_operand_register | x8616_decoded_operand_implicit;
source[x8616_operand_acc].width = plex->width;
source[x8616_operand_acc].reg = 0;
source[x8616_operand_acc].reg.r16 = x8616_ax;
source[x8616_operand_dx].flags = x8616_decoded_operand_register | x8616_decoded_operand_implicit;
source[x8616_operand_dx].width = x8616_width_word;
source[x8616_operand_dx].reg = x8616_dx;
source[x8616_operand_dx].reg.r16 = x8616_dx;
source[x8616_operand_rm].width = plex->width;
if (plex->mod == x8616_mod_reg) {
source[x8616_operand_rm].flags = x8616_decoded_operand_register;
source[x8616_operand_rm].reg = plex->rm;
source[x8616_operand_rm].reg.r16 = C_(X8616_Reg16, plex->rm);
}
else {
source[x8616_operand_rm].flags = x8616_decoded_operand_memory;
source[x8616_operand_rm].mod = plex->mod;
source[x8616_operand_rm].ea = plex->rm;
source[x8616_operand_rm].mod = C_(X8616_Mod, plex->mod);
source[x8616_operand_rm].ea = C_(X8616_EA, plex->rm);
source[x8616_operand_rm].displacement = plex->displacement;
source[x8616_operand_rm].displacement_bytes = plex->displacement_bytes;
if (plex->direct_memory) {
@@ -382,7 +398,7 @@ x8616_decode_one_plex(X8616_DecodePlex* plex)
source[x8616_operand_shift_count].width = x8616_width_byte;
if (plex->v == x8616_v_cl) {
source[x8616_operand_shift_count].flags |= x8616_decoded_operand_register;
source[x8616_operand_shift_count].reg = x8616_cl;
source[x8616_operand_shift_count].reg.r8 = x8616_cl;
}
else {
source[x8616_operand_shift_count].flags |= x8616_decoded_operand_immediate;
@@ -401,8 +417,9 @@ x8616_decode_one_plex(X8616_DecodePlex* plex)
plex->instruction.width = plex->width;
plex->instruction.prefixes = plex->prefixes;
plex->instruction.operand_count = plan->operand_count;
plex->instruction.opcode = plex->opcode;
plex->instruction.mod_rm = plex->mod_rm;
plex->instruction.opcode = x8616_decode_opcode(plan, plex->opcode);
plex->instruction.d = C_(X8616_Direction, (plan->flags & x8616_plan_has_d) ? plex->d : 0);
plex->instruction.w = C_(X8616_Width, (plan->flags & x8616_plan_has_w) ? plex->w : 0);
plex->instruction.has_mod_rm = (plan->flags & x8616_plan_has_modrm) != 0;
U4 total_required = prefix_at + plex->body_required;
@@ -414,6 +431,7 @@ x8616_decode_one_plex(X8616_DecodePlex* plex)
return total_consumed;
}
#define x8616_decode_(...) x8616_decode((X8616_DecodeRequest){__VA_ARGS__})
X8616_DecodeInfo x8616_decode(X8616_DecodeRequest request)
{
X8616_DecodeInfo result = {0};
code/8086/decoder.h
+35 -29
View File
@@ -12,25 +12,30 @@ enum {
};
typedef Enum_(U2, X8616_DecodedOperandFlags) {
x8616_decoded_operand_none = 0b0000000000000000,
x8616_decoded_operand_register = 0b0000000000000001,
x8616_decoded_operand_segment = 0b0000000000000010,
x8616_decoded_operand_memory = 0b0000000000000100,
x8616_decoded_operand_immediate = 0b0000000000001000,
x8616_decoded_operand_relative = 0b0000000000010000,
x8616_decoded_operand_far_ptr = 0b0000000000100000,
x8616_decoded_operand_direct = 0b0000000001000000,
x8616_decoded_operand_sign_extended = 0b0000000010000000,
x8616_decoded_operand_implicit = 0b0000000100000000,
Bit_(x8616_decoded_operand_none, 0),
Bit_(x8616_decoded_operand_register, 1),
Bit_(x8616_decoded_operand_segment, 2),
Bit_(x8616_decoded_operand_memory, 3),
Bit_(x8616_decoded_operand_immediate, 4),
Bit_(x8616_decoded_operand_relative, 5),
Bit_(x8616_decoded_operand_far_ptr, 6),
Bit_(x8616_decoded_operand_direct, 7),
Bit_(x8616_decoded_operand_sign_extended, 8),
Bit_(x8616_decoded_operand_implicit, 9),
};
typedef Union_(X8616_DecodedReg) {
X8616_Reg8 r8;
X8616_Reg16 r16;
};
typedef Struct_(X8616_DecodedOperand) {
X8616_DecodedOperandFlags flags;
X8616_WidthMode width;
U1 reg;
U1 segment;
U1 mod;
U1 ea;
X8616_DecodedReg reg;
X8616_Segment segment;
X8616_Mod mod;
X8616_EA ea;
S2 displacement;
U2 address;
U2 immediate;
@@ -64,26 +69,27 @@ typedef Struct_(X8616_DecodedInstruction) {
X8616_DecodedPrefixes prefixes;
X8616_DecodedOperand operands[2];
U1 operand_count;
U1 opcode;
U1 mod_rm;
X8616_OpcodePrefix opcode;
X8616_Direction d;
X8616_Width w;
B1 has_mod_rm;
U1 size;
U1 size_required;
};
typedef Enum_(U2, X8616_DecodePlanFlags) {
x8616_plan_none = 0b0000000000000000,
x8616_plan_has_modrm = 0b0000000000000001,
x8616_plan_has_post_opcode = 0b0000000000000010,
x8616_plan_has_d = 0b0000000000000100,
x8616_plan_has_w = 0b0000000000001000,
x8616_plan_has_s = 0b0000000000010000,
x8616_plan_has_v = 0b0000000000100000,
x8616_plan_has_z = 0b0000000001000000,
x8616_plan_has_reg = 0b0000000010000000,
x8616_plan_has_sr = 0b0000000100000000,
x8616_plan_uses_rm = 0b0000001000000000,
x8616_plan_is_prefix = 0b0000010000000000,
Bit_(x8616_plan_none, 0),
Bit_(x8616_plan_has_modrm, 1),
Bit_(x8616_plan_has_post_opcode, 2),
Bit_(x8616_plan_has_d, 3),
Bit_(x8616_plan_has_w, 4),
Bit_(x8616_plan_has_s, 5),
Bit_(x8616_plan_has_v, 6),
Bit_(x8616_plan_has_z, 7),
Bit_(x8616_plan_has_reg, 8),
Bit_(x8616_plan_has_sr, 9),
Bit_(x8616_plan_uses_rm, 10),
Bit_(x8616_plan_is_prefix, 11),
};
typedef Enum_(U1, X8616_DecodePayload) {
@@ -136,7 +142,7 @@ enum {
};
typedef Struct_(X8616_DecodeRequest) {
U1 const* source;
U1* source;
U4 source_size;
X8616_DecodedInstruction* instructions;
code/8086/decoder.test.c
-36
View File
@@ -1,36 +0,0 @@
#ifdef INTELLISENSE_DIRECTIVES
# include "duffle/dsl.h"
# include "encoder.h"
# include "decoder.h"
# include "info.h"
#endif
internal void
x8616_decoder_smoke_test(void)
{
U1 bytes[] = {
x8616_mov_r16_i (x8616_ax, 0x1234),
x8616_add_r16_i8s(x8616_ax, -2),
x8616_nop(),
};
X8616_DecodedInstruction instructions[3] = {0};
U1 info_memory[1024] = {0};
FArena info_scratch = farena_make(slice_ut_arr(info_memory));
X8616_DecodeInfo info = x8616_decode((X8616_DecodeRequest){
.source = bytes,
.source_size = S_(bytes),
.instructions = instructions,
.instruction_capacity = Array_len(instructions),
.info_arena = & info_scratch,
});
assert(info.source_consumed == S_(bytes));
assert(info.instruction_count == 3);
assert(info.msgs.error_count == 0);
assert(instructions[0].op == x8616_op_mov);
assert(instructions[1].op == x8616_op_add);
assert(instructions[2].op == x8616_op_xchg); /* 0x90 in the Part 1 table */
}
code/8086/decoder_table_generator.meta.c
+193 -94
View File
@@ -1,4 +1,5 @@
#include "duffle/dsl.h"
#include "duffle/asm.h"
#include "duffle/analysis.h"
#include "duffle/math.h"
#include "duffle/encoding.h"
@@ -40,15 +41,14 @@ typedef Struct_(X8616_DecodeGenInfo) {
X8616_InfoList msgs;
};
FI_ B1 x8616_decode_gen_operand_uses_modrm(X8616_Operand operand) {
FI_ B4 x8616_decode_gen_operand_uses_modrm(X8616_Operand operand) {
return operand == x8616_operand_rm || operand == x8616_operand_reg_modrm || operand == x8616_operand_segment_modrm;
}
FI_ B1 x8616_decode_gen_operand_uses_rm(X8616_Operand operand) { return operand == x8616_operand_rm; }
FI_ B4 x8616_decode_gen_operand_uses_rm(X8616_Operand operand) { return operand == x8616_operand_rm; }
internal X8616_DecodePayload
x8616_decode_gen_payload_from_operand(X8616_Operand operand) {
switch (operand) {
x8616_decode_gen_payload_from_operand(X8616_Operand operand) { switch (operand) {
case x8616_operand_imm: return x8616_payload_imm;
case x8616_operand_imm8: return x8616_payload_imm8;
case x8616_operand_imm16: return x8616_payload_imm16;
@@ -57,8 +57,7 @@ x8616_decode_gen_payload_from_operand(X8616_Operand operand) {
case x8616_operand_rel16: return x8616_payload_rel16;
case x8616_operand_far_ptr: return x8616_payload_far_ptr;
default: return x8616_payload_none;
}
}
}}
internal X8616_DecodePrefixKind
x8616_decode_gen_prefix_kind(X8616_Encoding const* encoding) {
@@ -72,7 +71,7 @@ x8616_decode_gen_prefix_kind(X8616_Encoding const* encoding) {
}
internal X8616_DecodePlan
x8616_decode_gen_plan(X8616_Encoding const* encoding, U4 encoding_idx, X8616_InfoList* msgs, FArena_R info_scratch)
x8616_decode_gen_plan(X8616_Encoding_R encoding, U4 encoding_idx, X8616_InfoList_R msgs, FArena_R info_scratch)
{
X8616_DecodePlan plan = {0};
plan.op = encoding->op;
@@ -141,11 +140,11 @@ x8616_decode_gen_plan(X8616_Encoding const* encoding, U4 encoding_idx, X8616_Inf
return plan;
}
FI_ B1 x8616_decode_gen_encoding_matches_opcode(X8616_Encoding const* encoding, U1 opcode) {
FI_ B4 x8616_decode_gen_encoding_matches_opcode(X8616_Encoding_R encoding, U1 opcode) {
return (opcode & encoding->opcode.mask) == encoding->opcode.bits;
}
FI_ B1 x8616_decode_gen_plan_matches_second(X8616_DecodePlan const* plan, U1 byte) {
FI_ B4 x8616_decode_gen_plan_matches_second(X8616_DecodePlan_R plan, U1 byte) {
if (plan->mod_rm.mask && ((byte & plan->mod_rm.mask) != plan->mod_rm.bits)) return false;
if (plan->post_opcode.mask && ((byte & plan->post_opcode.mask) != plan->post_opcode.bits)) return false;
return true;
@@ -212,7 +211,7 @@ x8616_decode_gen_pass_dispatch(X8616_DecodeGen* gen, FArena_R info_scratch)
}
internal void
x8616_decode_gen_pass_validate(X8616_DecodeGen* gen, FArena_R info_scratch)
x8616_decode_gen_pass_validate(X8616_DecodeGen_R gen, FArena_R info_scratch)
{
for (U4 opcode = 0; opcode < 256; ++ opcode)
for (U4 second = 0; second < 256; ++ second)
@@ -220,11 +219,11 @@ x8616_decode_gen_pass_validate(X8616_DecodeGen* gen, FArena_R info_scratch)
U1 expected = 0;
for (U4 encoding_idx = 0; encoding_idx < X8616_ENCODING_COUNT; ++ encoding_idx)
{
X8616_Encoding const* encoding = x8616_encodings + encoding_idx;
if (! x8616_decode_gen_encoding_matches_opcode(encoding, C_(U1, opcode))) continue;
X8616_Encoding_R encoding = x8616_encodings + encoding_idx;
if (x8616_decode_gen_encoding_matches_opcode(encoding, C_(U1, opcode)) == false) continue;
X8616_DecodePlan const* plan = gen->plans + encoding_idx + 1;
if (! x8616_decode_gen_plan_matches_second(plan, C_(U1, second))) continue;
X8616_DecodePlan_R plan = gen->plans + encoding_idx + 1;
if (x8616_decode_gen_plan_matches_second(plan, C_(U1, second)) == false) continue;
if (expected) x8616_info_push(info_scratch, & gen->msgs, x8616_info_error
, x8616_info_gen_ambiguous_decode
@@ -274,114 +273,214 @@ x8616_decode_table_generate(X8616_DecodeGen* gen, FArena_R info_scratch) {
}
#ifndef X8616_DECODE_TABLE_OUTPUT
# define X8616_DECODE_TABLE_OUTPUT "./code/8086/gen/decoder_table.h"
#endif
#define X8616_DECODE_TABLE_OUTPUT "./code/8086/gen/decoder_table.h"
enum {
X8616_DECODE_GEN_INFO_MEMORY = kilo(64),
X8616_DECODE_GEN_TEXT_MEMORY = kilo(128),
X8616_DECODE_GEN_FILE_MEMORY = kilo(4),
INFO_MEMORY_SIZE = kilo(64),
TEXT_MEMORY_SIZE = kilo(128),
FILE_MEMORY_SIZE = kilo(4),
};
typedef Struct_(X8616_DecodeGenMemory) {
U1 info[X8616_DECODE_GEN_INFO_MEMORY];
U1 text[X8616_DECODE_GEN_TEXT_MEMORY];
U1 file[X8616_DECODE_GEN_FILE_MEMORY];
typedef FStack_(FStack_64k, U1, kilo(64));
typedef Struct_(SMemory) {
U1 info[INFO_MEMORY_SIZE];
U1 text[TEXT_MEMORY_SIZE];
U1 file[FILE_MEMORY_SIZE];
FStack_64k scratch;
X8616_DecodeGen gen;
};
global SMemory smem;
global X8616_DecodeGen x8616_decode_gen;
global X8616_DecodeGenMemory x8616_decode_gen_memory;
I_ void
x8616_decode_gen_append_u4(Str8Gen_R out, U4 value, U4 radix, U4 min_digits) {
UTF8 buffer[64];
Info_str8_from_u4 info = str8_from_u4_info(value, radix, min_digits, 0);
I_ void str8gen_append_u4(Str8Gen_R out, U4 value, U4 radix, U4 min_digits) {
UTF8 buffer[64]; Info_str8_from_u4 info = str8_from_u4_info(value, radix, min_digits, 0);
Str8 text = str8_from_u4_buf(slice_ut_arr(buffer), value, radix, min_digits, 0, info);
str8gen_append_str8(out, text);
}
I_ void x8616_decode_gen_append_hex_u1(Str8Gen_R out, U1 value) { x8616_decode_gen_append_u4(out, value, 16, 2); }
I_ void x8616_decode_gen_append_hex_u2(Str8Gen_R out, U2 value) { x8616_decode_gen_append_u4(out, value, 16, 4); }
I_ void x8616_decode_gen_append_dec (Str8Gen_R out, U4 value) { x8616_decode_gen_append_u4(out, value, 10, 1); }
I_ void str8gen_append_hex_u1(Str8Gen_R out, U1 value) { str8gen_append_u4(out, value, 16, 2); }
I_ void str8gen_append_hex_u2(Str8Gen_R out, U2 value) { str8gen_append_u4(out, value, 16, 4); }
I_ void str8gen_append_dec (Str8Gen_R out, U4 value) { str8gen_append_u4(out, value, 10, 1); }
FI_ Slice scratch_push(U8 len) { return fstack_push_(smem.scratch, len); }
typedef Opt_(str8_from_u4) { U4 radix, min_digits, digit_group_separator; };
I_ Str8 str8_from_u4_opt(U4 num, Opt_str8_from_u4 o) { if (o.radix == 0) {o.radix = 10;}
/*gather info*/Info_str8_from_u4 info = str8_from_u4_info(num, o.radix, o.min_digits, o.digit_group_separator);
/*write buf */return str8_from_u4_buf(scratch_push(128), num, o.radix, o.min_digits, o.digit_group_separator, info);
}
#define str8_from_u4(num, ...) str8_from_u4_opt(num, opt_(str8_from_u4, __VA_ARGS__))
#define code_str8(...) slit8(stringify(__VA_ARGS__))
#define dec(v) str8_from_u4(v, .radix = 10, .min_digits = 1)
#define hex_u1(v) str8_from_u4(v, .radix = 16, .min_digits = 2)
#define hex_u2(v) str8_from_u4(v, .radix = 16, .min_digits = 4)
#define entry(k,v) { ktl_str8_key(k), v }
internal void
x8616_decode_gen_emit_plan(Str8Gen_R out, X8616_DecodePlan const* plan) {
str8gen_append_str8(out, slit8("\t{ "));
x8616_decode_gen_append_hex_u2(out, plan->flags); str8gen_append_str8(out, slit8(", "));
x8616_decode_gen_append_hex_u1(out, plan->op); str8gen_append_str8(out, slit8(", "));
x8616_decode_gen_append_hex_u1(out, plan->encoding_flags); str8gen_append_str8(out, slit8(", "));
x8616_decode_gen_append_hex_u1(out, plan->width); str8gen_append_str8(out, slit8(", {"));
x8616_decode_gen_append_hex_u1(out, plan->operands[0]); str8gen_append_str8(out, slit8(","));
x8616_decode_gen_append_hex_u1(out, plan->operands[1]); str8gen_append_str8(out, slit8("}, "));
x8616_decode_gen_append_dec(out, plan->operand_count); str8gen_append_str8(out, slit8(", "));
x8616_decode_gen_append_dec(out, plan->payload); str8gen_append_str8(out, slit8(", "));
x8616_decode_gen_append_dec(out, plan->prefix_kind); str8gen_append_str8(out, slit8(", "));
x8616_decode_gen_append_dec(out, plan->d_shift); str8gen_append_str8(out, slit8(","));
x8616_decode_gen_append_dec(out, plan->w_shift); str8gen_append_str8(out, slit8(","));
x8616_decode_gen_append_dec(out, plan->s_shift); str8gen_append_str8(out, slit8(","));
x8616_decode_gen_append_dec(out, plan->v_shift); str8gen_append_str8(out, slit8(","));
x8616_decode_gen_append_dec(out, plan->z_shift); str8gen_append_str8(out, slit8(","));
x8616_decode_gen_append_dec(out, plan->reg_shift); str8gen_append_str8(out, slit8(","));
x8616_decode_gen_append_dec(out, plan->sr_shift); str8gen_append_str8(out, slit8(", {"));
x8616_decode_gen_append_hex_u1(out, plan->mod_rm.bits); str8gen_append_str8(out, slit8(","));
x8616_decode_gen_append_hex_u1(out, plan->mod_rm.mask); str8gen_append_str8(out, slit8("}, {"));
x8616_decode_gen_append_hex_u1(out, plan->post_opcode.bits); str8gen_append_str8(out, slit8(","));
x8616_decode_gen_append_hex_u1(out, plan->post_opcode.mask); str8gen_append_str8(out, slit8("} },\n"));
}
x8616_decode_gen_emit_plan(Str8Gen_R out, X8616_DecodePlan_R plan) { defer_rewind(smem.scratch.top) {
Str8 template = code_str8(
\t{
<flags>, <op>, <encoding_flags>, <width>,
{<operands[0]>, <operands[1]>}, <operand_count>,
<payload>, <prefix_kind>,
<d_shift>, <w_shift>, <s_shift>, <v_shift>, <z_shift>, <reg_shift>, <sr_shift>,
{<mod_rm.bits>, <mod_rm.mask>},
{<post_opcode.bits>, <post_opcode.mask>},
},\n
);
KTL_Slot_Str8 tbl[] = {
entry("flags", hex_u2(plan->flags)),
entry("op", hex_u1(plan->op)),
entry("encoding_flags", hex_u1(plan->encoding_flags)),
entry("width", hex_u1(plan->width)),
entry("operands[0]", hex_u1(plan->operands[0])),
entry("operands[1]", hex_u1(plan->operands[1])),
entry("operand_count", dec(plan->operand_count)),
entry("payload", dec(plan->payload)),
entry("prefix_kind", dec(plan->prefix_kind)),
entry("d_shift", dec(plan->d_shift)),
entry("w_shift", dec(plan->w_shift)),
entry("s_shift", dec(plan->s_shift)),
entry("v_shift", dec(plan->v_shift)),
entry("z_shift", dec(plan->z_shift)),
entry("reg_shift", dec(plan->reg_shift)),
entry("sr_shift", dec(plan->sr_shift)),
entry("mod_rm.bits", hex_u1(plan->mod_rm.bits)),
entry("mod_rm.mask", hex_u1(plan->mod_rm.mask)),
entry("post_opcode.bits", hex_u1(plan->post_opcode.bits)),
entry("post_opcode.mask", hex_u1(plan->post_opcode.mask)),
};
str8gen_append_fmt(out, template, ktl_str8_from_arr(tbl));
}}
#define gen_fmt(out, tmpl, ...) str8gen_append_fmt((out), (tmpl), ktl_str8_from_arr(((KTL_Slot_Str8[]){ __VA_ARGS__ })))
internal Str8
x8616_decode_gen_emit(Str8Gen_R out, X8616_DecodeGen const* gen) {
x8616_decode_gen_emit(Str8Gen_R out, X8616_DecodeGen_R gen)
{
#pragma push_macro("RO_")
#pragma push_macro("global")
#undef RO_
#undef global
defer_rewind(smem.scratch.top)
{
str8gen_append_str8(out, slit8(
"// Generated from encoder_table.h. Do not hand-edit.\n"
"// Plan 0 is the all-zero nil/invalid plan.\n\n"
"RO_ global X8616_DecodePlan x8616_decode_plans["));
x8616_decode_gen_append_dec(out, X8616_ENCODING_COUNT + 1);
str8gen_append_str8(out, slit8("] =\n{\n"));
for (U4 idx = 0; idx < X8616_ENCODING_COUNT + 1; ++ idx) x8616_decode_gen_emit_plan(out, gen->plans + idx);
"// Plan 0 is a nil/invalid entry.\n"
"#ifdef INTELLISENSE_DIRECTIVES\n"
"#\tinclude \"dsl.h\"\n"
"#endif\n\n"
));
gen_fmt(out, code_str8(RO_ global X8616_DecodePlan x8616_decode_plans[<plan_count>] =\n{\n)
, entry("plan_count", dec(X8616_ENCODING_COUNT + 1))
);
str8gen_append_str8(out, slit8("};\n\nRO_ global U2 x8616_decode_dispatch[256] =\n{\n"));
for (U4 idx = 0; idx < 256; ++ idx) {
if ((idx & 15) == 0) str8gen_append_str8(out, slit8("\t"));
x8616_decode_gen_append_hex_u2(out, gen->dispatch[idx]);
str8gen_append_str8(out, (idx & 15) == 15 ? slit8(",\n") : slit8(", "));
}
for (U4 idx = 0; idx < X8616_ENCODING_COUNT + 1; ++ idx) { x8616_decode_gen_emit_plan(out, gen->plans + idx); }
str8gen_append_str8(out, slit8("};\n\nRO_ global U1 x8616_decode_aux["));
x8616_decode_gen_append_dec(out, gen->aux_count);
str8gen_append_str8(out, slit8("] =\n{\n"));
for (U4 idx = 0; idx < gen->aux_count; ++ idx) {
if ((idx & 15) == 0) str8gen_append_str8(out, slit8("\t"));
x8616_decode_gen_append_hex_u1(out, gen->aux[idx]);
str8gen_append_str8(out, (idx & 15) == 15 ? slit8(",\n") : slit8(", "));
str8gen_append_str8(out, code_str8(
};\n\n
));
str8gen_append_str8(out, code_str8(RO_ global U2 x8616_decode_dispatch[256] =\n{\n));
{
Str8 line = code_str8(\t<e0>, <e1>, <e2>, <e3>, <e4>, <e5>, <e6>, <e7>, <e8>, <e9>, <e10>, <e11>, <e12>, <e13>, <e14>, <e15>,\n);
for (U4 idx = 0; idx < 256; idx += 16) defer_rewind(smem.scratch.top) {
U2_R d = gen->dispatch + idx;
gen_fmt(out, line,
entry("e0", hex_u2(d[0])),
entry("e1", hex_u2(d[1])),
entry("e2", hex_u2(d[2])),
entry("e3", hex_u2(d[3])),
entry("e4", hex_u2(d[4])),
entry("e5", hex_u2(d[5])),
entry("e6", hex_u2(d[6])),
entry("e7", hex_u2(d[7])),
entry("e8", hex_u2(d[8])),
entry("e9", hex_u2(d[9])),
entry("e10", hex_u2(d[10])),
entry("e11", hex_u2(d[11])),
entry("e12", hex_u2(d[12])),
entry("e13", hex_u2(d[13])),
entry("e14", hex_u2(d[14])),
entry("e15", hex_u2(d[15]))
);
}
}
str8gen_append_str8(out, code_str8(};\n\n));
gen_fmt(out, code_str8(RO_ global U1 x8616_decode_aux[<aux_count>] =\n{\n)
, entry("aux_count", dec(gen->aux_count))
);
{
Str8 line = code_str8(\t<a0>, <a1>, <a2>, <a3>, <a4>, <a5>, <a6>, <a7>, <a8>, <a9>, <a10>, <a11>, <a12>, <a13>, <a14>, <a15>,\n);
U4 idx = 0;
for (; idx + 16 <= gen->aux_count; idx += 16) defer_rewind(smem.scratch.top) {
U1_R a = gen->aux + idx;
gen_fmt(out, line,
entry("a0", hex_u1(a[0])),
entry("a1", hex_u1(a[1])),
entry("a2", hex_u1(a[2])),
entry("a3", hex_u1(a[3])),
entry("a4", hex_u1(a[4])),
entry("a5", hex_u1(a[5])),
entry("a6", hex_u1(a[6])),
entry("a7", hex_u1(a[7])),
entry("a8", hex_u1(a[8])),
entry("a9", hex_u1(a[9])),
entry("a10", hex_u1(a[10])),
entry("a11", hex_u1(a[11])),
entry("a12", hex_u1(a[12])),
entry("a13", hex_u1(a[13])),
entry("a14", hex_u1(a[14])),
entry("a15", hex_u1(a[15]))
);
}
if (idx < gen->aux_count) {
str8gen_append_str8(out, slit8("\t"));
for (; idx < gen->aux_count; ++ idx) {
str8gen_append_hex_u1(out, gen->aux[idx]); str8gen_append_str8(out, slit8(", "));
}
str8gen_append_str8(out, slit8("\n"));
}
}
str8gen_append_str8(out, code_str8(};\n\n));
gen_fmt(out, code_str8(enum {\n
\tX8616_DECODE_PLAN_COUNT = <plan_count>,\n
\tX8616_DECODE_AUX_COUNT = <aux_count>,
\n};\n
),
entry("plan_count", dec(X8616_ENCODING_COUNT + 1)),
entry("aux_count", dec(gen->aux_count))
);
}
str8gen_append_str8(out, slit8("};\n\nenum {\n\tX8616_DECODE_PLAN_COUNT = "));
x8616_decode_gen_append_dec(out, X8616_ENCODING_COUNT + 1);
str8gen_append_str8(out, slit8(",\n\tX8616_DECODE_AUX_COUNT = "));
x8616_decode_gen_append_dec(out, gen->aux_count);
str8gen_append_str8(out, slit8(",\n};\n"));
return str8(out->ptr, out->len);
#pragma pop_macro("RO_")
#pragma pop_macro("global")
}
CLANG_OPTIMIZE_DISABLE
int
main(void) {
FArena info_scratch = farena_make(slice_ut_arr(x8616_decode_gen_memory.info));
X8616_DecodeGenInfo gen_info = x8616_decode_table_generate(& x8616_decode_gen, & info_scratch);
#undef gen_fmt
#undef entry
#undef hex_u2
#undef hex_u1
#undef dec
int main(void) {
FArena info_scratch = farena_make(slice_ut_arr(smem.info));
X8616_DecodeGenInfo gen_info = x8616_decode_table_generate(& smem.gen, & info_scratch);
if (gen_info.msgs.error_count) { ms_exit_process(1); return 1; }
Str8Gen output = {
.ptr = C_(UTF8*, x8616_decode_gen_memory.text),
.cap = S_(x8616_decode_gen_memory.text),
};
Str8 generated = x8616_decode_gen_emit(& output, & x8616_decode_gen);
Str8Gen output = str8gen_make(slice_ut_arr(smem.text));
Str8 generated = x8616_decode_gen_emit(& output, & smem.gen);
FArena file_scratch = farena_make(slice_ut_arr(x8616_decode_gen_memory.file));
FArena file_scratch = farena_make(slice_ut_arr(smem.file));
B4 wrote = write_data_to_file_path(slit8(X8616_DECODE_TABLE_OUTPUT), generated, & file_scratch);
if (! wrote) { ms_exit_process(2); return 2; }
if (wrote == false) { ms_exit_process(2); return 2; }
if (gen_info.verified_count != 256 * 256) { ms_exit_process(3); return 3; }
ms_exit_process(0);
return 0;
}
CLANG_OPTIMIZE_ENABLE
code/8086/gen/decoder_table.h
+136 -133
View File
@@ -1,140 +1,143 @@
// Generated from encoder_table.h. Do not hand-edit.
// Plan 0 is the all-zero nil/invalid plan.
// Plan 0 is a nil/invalid entry.
#ifdef INTELLISENSE_DIRECTIVES
# include "dsl.h"
#endif
RO_ global X8616_DecodePlan x8616_decode_plans[132] =
{
{ 0x0000, 0x00, 0x00, 0x00, {0x00,0x00}, 0, 0, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x020d, 0x02, 0x00, 0x00, {0x01,0x02}, 2, 0, 0, 1,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0209, 0x02, 0x00, 0x00, {0x01,0x07}, 2, 1, 0, 0,0,0,0,0,0,0, {0x00,0x38}, {0x00,0x00} },
{ 0x0088, 0x02, 0x00, 0x00, {0x03,0x07}, 2, 1, 0, 0,3,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x000c, 0x02, 0x00, 0x00, {0x06,0x0a}, 2, 4, 0, 1,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0205, 0x02, 0x00, 0x02, {0x01,0x04}, 2, 0, 0, 1,0,0,0,0,0,0, {0x00,0x20}, {0x00,0x00} },
{ 0x0201, 0x0b, 0x00, 0x02, {0x01,0x00}, 1, 0, 0, 0,0,0,0,0,0,0, {0x30,0x38}, {0x00,0x00} },
{ 0x0080, 0x0b, 0x00, 0x02, {0x03,0x00}, 1, 0, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0100, 0x0b, 0x00, 0x02, {0x05,0x00}, 1, 0, 0, 0,0,0,0,0,0,3, {0x00,0x00}, {0x00,0x00} },
{ 0x0201, 0x0c, 0x00, 0x02, {0x01,0x00}, 1, 0, 0, 0,0,0,0,0,0,0, {0x00,0x38}, {0x00,0x00} },
{ 0x0080, 0x0c, 0x00, 0x02, {0x03,0x00}, 1, 0, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0100, 0x0c, 0x00, 0x02, {0x05,0x00}, 1, 0, 0, 0,0,0,0,0,0,3, {0x00,0x00}, {0x00,0x00} },
{ 0x0209, 0x0d, 0x00, 0x00, {0x02,0x01}, 2, 0, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0080, 0x0d, 0x00, 0x02, {0x06,0x03}, 2, 0, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0008, 0x0e, 0x00, 0x00, {0x06,0x08}, 2, 2, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0008, 0x0e, 0x00, 0x00, {0x06,0x0e}, 2, 0, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0008, 0x0f, 0x00, 0x00, {0x08,0x06}, 2, 2, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0008, 0x0f, 0x00, 0x00, {0x0e,0x06}, 2, 0, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0000, 0x10, 0x00, 0x00, {0x00,0x00}, 0, 0, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0201, 0x11, 0x00, 0x02, {0x02,0x01}, 2, 0, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0201, 0x12, 0x00, 0x02, {0x02,0x01}, 2, 0, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0201, 0x13, 0x00, 0x02, {0x02,0x01}, 2, 0, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0000, 0x14, 0x00, 0x00, {0x00,0x00}, 0, 0, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0000, 0x15, 0x00, 0x00, {0x00,0x00}, 0, 0, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0000, 0x16, 0x00, 0x00, {0x00,0x00}, 0, 0, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0000, 0x17, 0x00, 0x00, {0x00,0x00}, 0, 0, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x020d, 0x03, 0x00, 0x00, {0x01,0x02}, 2, 0, 0, 1,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0219, 0x03, 0x00, 0x00, {0x01,0x07}, 2, 1, 0, 0,0,1,0,0,0,0, {0x00,0x38}, {0x00,0x00} },
{ 0x0008, 0x03, 0x00, 0x00, {0x06,0x07}, 2, 1, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x020d, 0x04, 0x00, 0x00, {0x01,0x02}, 2, 0, 0, 1,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0209, 0x04, 0x00, 0x00, {0x01,0x07}, 2, 1, 0, 0,0,0,0,0,0,0, {0x08,0x38}, {0x00,0x00} },
{ 0x0008, 0x04, 0x00, 0x00, {0x06,0x07}, 2, 1, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x020d, 0x05, 0x00, 0x00, {0x01,0x02}, 2, 0, 0, 1,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0219, 0x05, 0x00, 0x00, {0x01,0x07}, 2, 1, 0, 0,0,1,0,0,0,0, {0x10,0x38}, {0x00,0x00} },
{ 0x0008, 0x05, 0x00, 0x00, {0x06,0x07}, 2, 1, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x020d, 0x06, 0x00, 0x00, {0x01,0x02}, 2, 0, 0, 1,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0219, 0x06, 0x00, 0x00, {0x01,0x07}, 2, 1, 0, 0,0,1,0,0,0,0, {0x18,0x38}, {0x00,0x00} },
{ 0x0008, 0x06, 0x00, 0x00, {0x06,0x07}, 2, 1, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x020d, 0x07, 0x00, 0x00, {0x01,0x02}, 2, 0, 0, 1,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0209, 0x07, 0x00, 0x00, {0x01,0x07}, 2, 1, 0, 0,0,0,0,0,0,0, {0x20,0x38}, {0x00,0x00} },
{ 0x0008, 0x07, 0x00, 0x00, {0x06,0x07}, 2, 1, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x020d, 0x08, 0x00, 0x00, {0x01,0x02}, 2, 0, 0, 1,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0219, 0x08, 0x00, 0x00, {0x01,0x07}, 2, 1, 0, 0,0,1,0,0,0,0, {0x28,0x38}, {0x00,0x00} },
{ 0x0008, 0x08, 0x00, 0x00, {0x06,0x07}, 2, 1, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x020d, 0x09, 0x00, 0x00, {0x01,0x02}, 2, 0, 0, 1,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0209, 0x09, 0x00, 0x00, {0x01,0x07}, 2, 1, 0, 0,0,0,0,0,0,0, {0x30,0x38}, {0x00,0x00} },
{ 0x0008, 0x09, 0x00, 0x00, {0x06,0x07}, 2, 1, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x020d, 0x0a, 0x00, 0x00, {0x01,0x02}, 2, 0, 0, 1,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0219, 0x0a, 0x00, 0x00, {0x01,0x07}, 2, 1, 0, 0,0,1,0,0,0,0, {0x38,0x38}, {0x00,0x00} },
{ 0x0008, 0x0a, 0x00, 0x00, {0x06,0x07}, 2, 1, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0209, 0x18, 0x00, 0x00, {0x01,0x00}, 1, 0, 0, 0,0,0,0,0,0,0, {0x00,0x38}, {0x00,0x00} },
{ 0x0080, 0x18, 0x00, 0x02, {0x03,0x00}, 1, 0, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0000, 0x19, 0x00, 0x00, {0x00,0x00}, 0, 0, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0000, 0x1a, 0x00, 0x00, {0x00,0x00}, 0, 0, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0209, 0x1b, 0x00, 0x00, {0x01,0x00}, 1, 0, 0, 0,0,0,0,0,0,0, {0x08,0x38}, {0x00,0x00} },
{ 0x0080, 0x1b, 0x00, 0x02, {0x03,0x00}, 1, 0, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0209, 0x1c, 0x00, 0x00, {0x01,0x00}, 1, 0, 0, 0,0,0,0,0,0,0, {0x18,0x38}, {0x00,0x00} },
{ 0x0209, 0x1f, 0x00, 0x00, {0x01,0x00}, 1, 0, 0, 0,0,0,0,0,0,0, {0x20,0x38}, {0x00,0x00} },
{ 0x0209, 0x20, 0x00, 0x00, {0x01,0x00}, 1, 0, 0, 0,0,0,0,0,0,0, {0x28,0x38}, {0x00,0x00} },
{ 0x0209, 0x22, 0x00, 0x00, {0x01,0x00}, 1, 0, 0, 0,0,0,0,0,0,0, {0x30,0x38}, {0x00,0x00} },
{ 0x0209, 0x23, 0x00, 0x00, {0x01,0x00}, 1, 0, 0, 0,0,0,0,0,0,0, {0x38,0x38}, {0x00,0x00} },
{ 0x0209, 0x27, 0x00, 0x00, {0x01,0x00}, 1, 0, 0, 0,0,0,0,0,0,0, {0x10,0x38}, {0x00,0x00} },
{ 0x0000, 0x1d, 0x00, 0x00, {0x00,0x00}, 0, 0, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0000, 0x1e, 0x00, 0x00, {0x00,0x00}, 0, 0, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0002, 0x21, 0x00, 0x00, {0x00,0x00}, 0, 0, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x0a,0xff} },
{ 0x0002, 0x24, 0x00, 0x00, {0x00,0x00}, 0, 0, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x0a,0xff} },
{ 0x0000, 0x25, 0x00, 0x00, {0x00,0x00}, 0, 0, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0000, 0x26, 0x00, 0x00, {0x00,0x00}, 0, 0, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0229, 0x2b, 0x00, 0x00, {0x01,0x0f}, 2, 0, 0, 0,0,0,1,0,0,0, {0x00,0x38}, {0x00,0x00} },
{ 0x0229, 0x2c, 0x00, 0x00, {0x01,0x0f}, 2, 0, 0, 0,0,0,1,0,0,0, {0x08,0x38}, {0x00,0x00} },
{ 0x0229, 0x2d, 0x00, 0x00, {0x01,0x0f}, 2, 0, 0, 0,0,0,1,0,0,0, {0x10,0x38}, {0x00,0x00} },
{ 0x0229, 0x2e, 0x00, 0x00, {0x01,0x0f}, 2, 0, 0, 0,0,0,1,0,0,0, {0x18,0x38}, {0x00,0x00} },
{ 0x0229, 0x28, 0x00, 0x00, {0x01,0x0f}, 2, 0, 0, 0,0,0,1,0,0,0, {0x20,0x38}, {0x00,0x00} },
{ 0x0229, 0x29, 0x00, 0x00, {0x01,0x0f}, 2, 0, 0, 0,0,0,1,0,0,0, {0x28,0x38}, {0x00,0x00} },
{ 0x0229, 0x2a, 0x00, 0x00, {0x01,0x0f}, 2, 0, 0, 0,0,0,1,0,0,0, {0x38,0x38}, {0x00,0x00} },
{ 0x0209, 0x2f, 0x00, 0x00, {0x01,0x02}, 2, 0, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0209, 0x2f, 0x00, 0x00, {0x01,0x07}, 2, 1, 0, 0,0,0,0,0,0,0, {0x00,0x38}, {0x00,0x00} },
{ 0x0008, 0x2f, 0x00, 0x00, {0x06,0x07}, 2, 1, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0440, 0x30, 0x02, 0x00, {0x00,0x00}, 0, 0, 2, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0008, 0x31, 0x00, 0x00, {0x00,0x00}, 0, 0, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0008, 0x32, 0x00, 0x00, {0x00,0x00}, 0, 0, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0008, 0x33, 0x00, 0x00, {0x00,0x00}, 0, 0, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0008, 0x34, 0x00, 0x00, {0x00,0x00}, 0, 0, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0008, 0x35, 0x00, 0x00, {0x00,0x00}, 0, 0, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0400, 0x5b, 0x02, 0x00, {0x00,0x00}, 0, 0, 1, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0500, 0x5c, 0x02, 0x00, {0x00,0x00}, 0, 0, 3, 0,0,0,0,0,0,3, {0x00,0x00}, {0x00,0x00} },
{ 0x0000, 0x36, 0x00, 0x00, {0x0c,0x00}, 1, 6, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0201, 0x36, 0x00, 0x02, {0x01,0x00}, 1, 0, 0, 0,0,0,0,0,0,0, {0x10,0x38}, {0x00,0x00} },
{ 0x0000, 0x36, 0x01, 0x00, {0x0d,0x00}, 1, 7, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0201, 0x36, 0x01, 0x02, {0x01,0x00}, 1, 0, 0, 0,0,0,0,0,0,0, {0x18,0x38}, {0x00,0x00} },
{ 0x0000, 0x37, 0x00, 0x00, {0x0c,0x00}, 1, 6, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0000, 0x37, 0x00, 0x00, {0x0b,0x00}, 1, 5, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0201, 0x37, 0x00, 0x02, {0x01,0x00}, 1, 0, 0, 0,0,0,0,0,0,0, {0x20,0x38}, {0x00,0x00} },
{ 0x0000, 0x37, 0x01, 0x00, {0x0d,0x00}, 1, 7, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0201, 0x37, 0x01, 0x02, {0x01,0x00}, 1, 0, 0, 0,0,0,0,0,0,0, {0x28,0x38}, {0x00,0x00} },
{ 0x0000, 0x38, 0x00, 0x00, {0x00,0x00}, 0, 0, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0000, 0x38, 0x00, 0x00, {0x09,0x00}, 1, 3, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0000, 0x39, 0x00, 0x00, {0x00,0x00}, 0, 0, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0000, 0x39, 0x00, 0x00, {0x09,0x00}, 1, 3, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0000, 0x40, 0x00, 0x00, {0x0b,0x00}, 1, 5, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0000, 0x48, 0x00, 0x00, {0x0b,0x00}, 1, 5, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0000, 0x3d, 0x00, 0x00, {0x0b,0x00}, 1, 5, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0000, 0x45, 0x00, 0x00, {0x0b,0x00}, 1, 5, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0000, 0x3a, 0x00, 0x00, {0x0b,0x00}, 1, 5, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0000, 0x42, 0x00, 0x00, {0x0b,0x00}, 1, 5, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0000, 0x3e, 0x00, 0x00, {0x0b,0x00}, 1, 5, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0000, 0x46, 0x00, 0x00, {0x0b,0x00}, 1, 5, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0000, 0x41, 0x00, 0x00, {0x0b,0x00}, 1, 5, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0000, 0x49, 0x00, 0x00, {0x0b,0x00}, 1, 5, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0000, 0x3f, 0x00, 0x00, {0x0b,0x00}, 1, 5, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0000, 0x47, 0x00, 0x00, {0x0b,0x00}, 1, 5, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0000, 0x3b, 0x00, 0x00, {0x0b,0x00}, 1, 5, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0000, 0x43, 0x00, 0x00, {0x0b,0x00}, 1, 5, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0000, 0x3c, 0x00, 0x00, {0x0b,0x00}, 1, 5, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0000, 0x44, 0x00, 0x00, {0x0b,0x00}, 1, 5, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0000, 0x4c, 0x00, 0x00, {0x0b,0x00}, 1, 5, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0000, 0x4b, 0x00, 0x00, {0x0b,0x00}, 1, 5, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0000, 0x4a, 0x00, 0x00, {0x0b,0x00}, 1, 5, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0000, 0x4d, 0x00, 0x00, {0x0b,0x00}, 1, 5, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0000, 0x4e, 0x00, 0x00, {0x08,0x00}, 1, 2, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0000, 0x4f, 0x00, 0x00, {0x00,0x00}, 0, 0, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0000, 0x50, 0x00, 0x00, {0x00,0x00}, 0, 0, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0000, 0x51, 0x00, 0x00, {0x00,0x00}, 0, 0, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0000, 0x52, 0x00, 0x00, {0x00,0x00}, 0, 0, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0000, 0x53, 0x00, 0x00, {0x00,0x00}, 0, 0, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0000, 0x54, 0x00, 0x00, {0x00,0x00}, 0, 0, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0000, 0x55, 0x00, 0x00, {0x00,0x00}, 0, 0, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0000, 0x56, 0x00, 0x00, {0x00,0x00}, 0, 0, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0000, 0x57, 0x00, 0x00, {0x00,0x00}, 0, 0, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0000, 0x58, 0x00, 0x00, {0x00,0x00}, 0, 0, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0000, 0x59, 0x00, 0x00, {0x00,0x00}, 0, 0, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0000, 0x5a, 0x00, 0x00, {0x00,0x00}, 0, 0, 0, 0,0,0,0,0,0,0, {0x00,0x00}, {0x00,0x00} },
{ 0x0000, 0x00, 0x00, 0x00, {0x00, 0x00}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x041a, 0x02, 0x00, 0x00, {0x01, 0x02}, 2, 0, 0, 1, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0412, 0x02, 0x00, 0x00, {0x01, 0x07}, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x38}, {0x00, 0x00}, },
{ 0x0110, 0x02, 0x00, 0x00, {0x03, 0x07}, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0018, 0x02, 0x00, 0x00, {0x06, 0x0a}, 2, 4, 0, 1, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x040a, 0x02, 0x00, 0x02, {0x01, 0x04}, 2, 0, 0, 1, 0, 0, 0, 0, 0, 0, {0x00, 0x20}, {0x00, 0x00}, },
{ 0x0402, 0x0b, 0x00, 0x02, {0x01, 0x00}, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x30, 0x38}, {0x00, 0x00}, },
{ 0x0100, 0x0b, 0x00, 0x02, {0x03, 0x00}, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0200, 0x0b, 0x00, 0x02, {0x05, 0x00}, 1, 0, 0, 0, 0, 0, 0, 0, 0, 3, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0402, 0x0c, 0x00, 0x02, {0x01, 0x00}, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x38}, {0x00, 0x00}, },
{ 0x0100, 0x0c, 0x00, 0x02, {0x03, 0x00}, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0200, 0x0c, 0x00, 0x02, {0x05, 0x00}, 1, 0, 0, 0, 0, 0, 0, 0, 0, 3, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0412, 0x0d, 0x00, 0x00, {0x02, 0x01}, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0100, 0x0d, 0x00, 0x02, {0x06, 0x03}, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0010, 0x0e, 0x00, 0x00, {0x06, 0x08}, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0010, 0x0e, 0x00, 0x00, {0x06, 0x0e}, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0010, 0x0f, 0x00, 0x00, {0x08, 0x06}, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0010, 0x0f, 0x00, 0x00, {0x0e, 0x06}, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0000, 0x10, 0x00, 0x00, {0x00, 0x00}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0402, 0x11, 0x00, 0x02, {0x02, 0x01}, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0402, 0x12, 0x00, 0x02, {0x02, 0x01}, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0402, 0x13, 0x00, 0x02, {0x02, 0x01}, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0000, 0x14, 0x00, 0x00, {0x00, 0x00}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0000, 0x15, 0x00, 0x00, {0x00, 0x00}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0000, 0x16, 0x00, 0x00, {0x00, 0x00}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0000, 0x17, 0x00, 0x00, {0x00, 0x00}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x041a, 0x03, 0x00, 0x00, {0x01, 0x02}, 2, 0, 0, 1, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0432, 0x03, 0x00, 0x00, {0x01, 0x07}, 2, 1, 0, 0, 0, 1, 0, 0, 0, 0, {0x00, 0x38}, {0x00, 0x00}, },
{ 0x0010, 0x03, 0x00, 0x00, {0x06, 0x07}, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x041a, 0x04, 0x00, 0x00, {0x01, 0x02}, 2, 0, 0, 1, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0412, 0x04, 0x00, 0x00, {0x01, 0x07}, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, {0x08, 0x38}, {0x00, 0x00}, },
{ 0x0010, 0x04, 0x00, 0x00, {0x06, 0x07}, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x041a, 0x05, 0x00, 0x00, {0x01, 0x02}, 2, 0, 0, 1, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0432, 0x05, 0x00, 0x00, {0x01, 0x07}, 2, 1, 0, 0, 0, 1, 0, 0, 0, 0, {0x10, 0x38}, {0x00, 0x00}, },
{ 0x0010, 0x05, 0x00, 0x00, {0x06, 0x07}, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x041a, 0x06, 0x00, 0x00, {0x01, 0x02}, 2, 0, 0, 1, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0432, 0x06, 0x00, 0x00, {0x01, 0x07}, 2, 1, 0, 0, 0, 1, 0, 0, 0, 0, {0x18, 0x38}, {0x00, 0x00}, },
{ 0x0010, 0x06, 0x00, 0x00, {0x06, 0x07}, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x041a, 0x07, 0x00, 0x00, {0x01, 0x02}, 2, 0, 0, 1, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0412, 0x07, 0x00, 0x00, {0x01, 0x07}, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, {0x20, 0x38}, {0x00, 0x00}, },
{ 0x0010, 0x07, 0x00, 0x00, {0x06, 0x07}, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x041a, 0x08, 0x00, 0x00, {0x01, 0x02}, 2, 0, 0, 1, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0432, 0x08, 0x00, 0x00, {0x01, 0x07}, 2, 1, 0, 0, 0, 1, 0, 0, 0, 0, {0x28, 0x38}, {0x00, 0x00}, },
{ 0x0010, 0x08, 0x00, 0x00, {0x06, 0x07}, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x041a, 0x09, 0x00, 0x00, {0x01, 0x02}, 2, 0, 0, 1, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0412, 0x09, 0x00, 0x00, {0x01, 0x07}, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, {0x30, 0x38}, {0x00, 0x00}, },
{ 0x0010, 0x09, 0x00, 0x00, {0x06, 0x07}, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x041a, 0x0a, 0x00, 0x00, {0x01, 0x02}, 2, 0, 0, 1, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0432, 0x0a, 0x00, 0x00, {0x01, 0x07}, 2, 1, 0, 0, 0, 1, 0, 0, 0, 0, {0x38, 0x38}, {0x00, 0x00}, },
{ 0x0010, 0x0a, 0x00, 0x00, {0x06, 0x07}, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0412, 0x18, 0x00, 0x00, {0x01, 0x00}, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x38}, {0x00, 0x00}, },
{ 0x0100, 0x18, 0x00, 0x02, {0x03, 0x00}, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0000, 0x19, 0x00, 0x00, {0x00, 0x00}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0000, 0x1a, 0x00, 0x00, {0x00, 0x00}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0412, 0x1b, 0x00, 0x00, {0x01, 0x00}, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x08, 0x38}, {0x00, 0x00}, },
{ 0x0100, 0x1b, 0x00, 0x02, {0x03, 0x00}, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0412, 0x1c, 0x00, 0x00, {0x01, 0x00}, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x18, 0x38}, {0x00, 0x00}, },
{ 0x0412, 0x1f, 0x00, 0x00, {0x01, 0x00}, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x20, 0x38}, {0x00, 0x00}, },
{ 0x0412, 0x20, 0x00, 0x00, {0x01, 0x00}, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x28, 0x38}, {0x00, 0x00}, },
{ 0x0412, 0x22, 0x00, 0x00, {0x01, 0x00}, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x30, 0x38}, {0x00, 0x00}, },
{ 0x0412, 0x23, 0x00, 0x00, {0x01, 0x00}, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x38, 0x38}, {0x00, 0x00}, },
{ 0x0412, 0x27, 0x00, 0x00, {0x01, 0x00}, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x10, 0x38}, {0x00, 0x00}, },
{ 0x0000, 0x1d, 0x00, 0x00, {0x00, 0x00}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0000, 0x1e, 0x00, 0x00, {0x00, 0x00}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0004, 0x21, 0x00, 0x00, {0x00, 0x00}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x0a, 0xff}, },
{ 0x0004, 0x24, 0x00, 0x00, {0x00, 0x00}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x0a, 0xff}, },
{ 0x0000, 0x25, 0x00, 0x00, {0x00, 0x00}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0000, 0x26, 0x00, 0x00, {0x00, 0x00}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0452, 0x2b, 0x00, 0x00, {0x01, 0x0f}, 2, 0, 0, 0, 0, 0, 1, 0, 0, 0, {0x00, 0x38}, {0x00, 0x00}, },
{ 0x0452, 0x2c, 0x00, 0x00, {0x01, 0x0f}, 2, 0, 0, 0, 0, 0, 1, 0, 0, 0, {0x08, 0x38}, {0x00, 0x00}, },
{ 0x0452, 0x2d, 0x00, 0x00, {0x01, 0x0f}, 2, 0, 0, 0, 0, 0, 1, 0, 0, 0, {0x10, 0x38}, {0x00, 0x00}, },
{ 0x0452, 0x2e, 0x00, 0x00, {0x01, 0x0f}, 2, 0, 0, 0, 0, 0, 1, 0, 0, 0, {0x18, 0x38}, {0x00, 0x00}, },
{ 0x0452, 0x28, 0x00, 0x00, {0x01, 0x0f}, 2, 0, 0, 0, 0, 0, 1, 0, 0, 0, {0x20, 0x38}, {0x00, 0x00}, },
{ 0x0452, 0x29, 0x00, 0x00, {0x01, 0x0f}, 2, 0, 0, 0, 0, 0, 1, 0, 0, 0, {0x28, 0x38}, {0x00, 0x00}, },
{ 0x0452, 0x2a, 0x00, 0x00, {0x01, 0x0f}, 2, 0, 0, 0, 0, 0, 1, 0, 0, 0, {0x38, 0x38}, {0x00, 0x00}, },
{ 0x0412, 0x2f, 0x00, 0x00, {0x01, 0x02}, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0412, 0x2f, 0x00, 0x00, {0x01, 0x07}, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x38}, {0x00, 0x00}, },
{ 0x0010, 0x2f, 0x00, 0x00, {0x06, 0x07}, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0880, 0x30, 0x02, 0x00, {0x00, 0x00}, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0010, 0x31, 0x00, 0x00, {0x00, 0x00}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0010, 0x32, 0x00, 0x00, {0x00, 0x00}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0010, 0x33, 0x00, 0x00, {0x00, 0x00}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0010, 0x34, 0x00, 0x00, {0x00, 0x00}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0010, 0x35, 0x00, 0x00, {0x00, 0x00}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0800, 0x5b, 0x02, 0x00, {0x00, 0x00}, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0a00, 0x5c, 0x02, 0x00, {0x00, 0x00}, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0000, 0x36, 0x00, 0x00, {0x0c, 0x00}, 1, 6, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0402, 0x36, 0x00, 0x02, {0x01, 0x00}, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x10, 0x38}, {0x00, 0x00}, },
{ 0x0000, 0x36, 0x01, 0x00, {0x0d, 0x00}, 1, 7, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0402, 0x36, 0x01, 0x02, {0x01, 0x00}, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x18, 0x38}, {0x00, 0x00}, },
{ 0x0000, 0x37, 0x00, 0x00, {0x0c, 0x00}, 1, 6, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0000, 0x37, 0x00, 0x00, {0x0b, 0x00}, 1, 5, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0402, 0x37, 0x00, 0x02, {0x01, 0x00}, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x20, 0x38}, {0x00, 0x00}, },
{ 0x0000, 0x37, 0x01, 0x00, {0x0d, 0x00}, 1, 7, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0402, 0x37, 0x01, 0x02, {0x01, 0x00}, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x28, 0x38}, {0x00, 0x00}, },
{ 0x0000, 0x38, 0x00, 0x00, {0x00, 0x00}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0000, 0x38, 0x00, 0x00, {0x09, 0x00}, 1, 3, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0000, 0x39, 0x00, 0x00, {0x00, 0x00}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0000, 0x39, 0x00, 0x00, {0x09, 0x00}, 1, 3, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0000, 0x40, 0x00, 0x00, {0x0b, 0x00}, 1, 5, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0000, 0x48, 0x00, 0x00, {0x0b, 0x00}, 1, 5, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0000, 0x3d, 0x00, 0x00, {0x0b, 0x00}, 1, 5, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0000, 0x45, 0x00, 0x00, {0x0b, 0x00}, 1, 5, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0000, 0x3a, 0x00, 0x00, {0x0b, 0x00}, 1, 5, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0000, 0x42, 0x00, 0x00, {0x0b, 0x00}, 1, 5, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0000, 0x3e, 0x00, 0x00, {0x0b, 0x00}, 1, 5, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0000, 0x46, 0x00, 0x00, {0x0b, 0x00}, 1, 5, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0000, 0x41, 0x00, 0x00, {0x0b, 0x00}, 1, 5, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0000, 0x49, 0x00, 0x00, {0x0b, 0x00}, 1, 5, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0000, 0x3f, 0x00, 0x00, {0x0b, 0x00}, 1, 5, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0000, 0x47, 0x00, 0x00, {0x0b, 0x00}, 1, 5, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0000, 0x3b, 0x00, 0x00, {0x0b, 0x00}, 1, 5, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0000, 0x43, 0x00, 0x00, {0x0b, 0x00}, 1, 5, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0000, 0x3c, 0x00, 0x00, {0x0b, 0x00}, 1, 5, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0000, 0x44, 0x00, 0x00, {0x0b, 0x00}, 1, 5, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0000, 0x4c, 0x00, 0x00, {0x0b, 0x00}, 1, 5, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0000, 0x4b, 0x00, 0x00, {0x0b, 0x00}, 1, 5, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0000, 0x4a, 0x00, 0x00, {0x0b, 0x00}, 1, 5, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0000, 0x4d, 0x00, 0x00, {0x0b, 0x00}, 1, 5, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0000, 0x4e, 0x00, 0x00, {0x08, 0x00}, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0000, 0x4f, 0x00, 0x00, {0x00, 0x00}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0000, 0x50, 0x00, 0x00, {0x00, 0x00}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0000, 0x51, 0x00, 0x00, {0x00, 0x00}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0000, 0x52, 0x00, 0x00, {0x00, 0x00}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0000, 0x53, 0x00, 0x00, {0x00, 0x00}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0000, 0x54, 0x00, 0x00, {0x00, 0x00}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0000, 0x55, 0x00, 0x00, {0x00, 0x00}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0000, 0x56, 0x00, 0x00, {0x00, 0x00}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0000, 0x57, 0x00, 0x00, {0x00, 0x00}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0000, 0x58, 0x00, 0x00, {0x00, 0x00}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0000, 0x59, 0x00, 0x00, {0x00, 0x00}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
{ 0x0000, 0x5a, 0x00, 0x00, {0x00, 0x00}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0x00, 0x00}, {0x00, 0x00}, },
};
RO_ global U2 x8616_decode_dispatch[256] =
code/8086/info.h
+6 -6
View File
@@ -70,7 +70,7 @@ typedef Struct_(X8616_InfoList) {
I_ Str8 x8616_info_template(X8616_InfoCode code) { return code < x8616_info_count ? x8616_info_templates[code] : x8616_info_templates[x8616_info_none]; }
FI_ void x8616_info_push(FArena_R scratch
, X8616_InfoList_R list
, X8616_InfoList_R msgs
, X8616_InfoKind kind
, X8616_InfoCode code
, U4 source_offset
@@ -79,13 +79,13 @@ FI_ void x8616_info_push(FArena_R scratch
, U4 actual
){
assert(scratch != nullptr);
list->count += 1;
list->error_count += kind == x8616_info_error;
list->warning_count += kind == x8616_info_warning;
msgs->count += 1;
msgs->error_count += kind == x8616_info_error;
msgs->warning_count += kind == x8616_info_warning;
U4 allocation_size = align_pow2(S_(X8616_InfoMsg), MEM_ALIGNMENT_DEFAULT);
U4 left = scratch->capacity - scratch->used;
if (allocation_size > left) { ++ list->dropped_count; return; }
if (allocation_size > left) { ++ msgs->dropped_count; return; }
X8616_InfoMsg_R msg = farena_push_type(scratch, X8616_InfoMsg);
// msg[0] = (X8616_InfoMsg){0};
@@ -96,5 +96,5 @@ FI_ void x8616_info_push(FArena_R scratch
msg->expected = expected;
msg->actual = actual;
msg->text = x8616_info_template(code);
sll_queue_push_n(list->first, list->last, msg, next);
sll_queue_push_n(msgs->first, msgs->last, msg, next);
}
code/8086/serializer.c
+522
View File
@@ -0,0 +1,522 @@
#ifdef INTELLISENSE_DIRECTIVES
# include "serializer.h"
#endif
enum {
X8616_SERIALIZE_HEADER_LEN = 9,
};
RO_ global Str8 x8616_serialize_header = slit8("bits 16\n\n");
RO_ global Str8 x8616_serialize_mnemonic[] = {
[x8616_op_invalid] = slit8(""),
[x8616_op_nop] = slit8("nop"),
[x8616_op_mov] = slit8("mov"),
[x8616_op_add] = slit8("add"),
[x8616_op_or] = slit8("or"),
[x8616_op_adc] = slit8("adc"),
[x8616_op_sbb] = slit8("sbb"),
[x8616_op_and] = slit8("and"),
[x8616_op_sub] = slit8("sub"),
[x8616_op_xor] = slit8("xor"),
[x8616_op_cmp] = slit8("cmp"),
[x8616_op_push] = slit8("push"),
[x8616_op_pop] = slit8("pop"),
[x8616_op_xchg] = slit8("xchg"),
[x8616_op_in] = slit8("in"),
[x8616_op_out] = slit8("out"),
[x8616_op_xlat] = slit8("xlat"),
[x8616_op_lea] = slit8("lea"),
[x8616_op_lds] = slit8("lds"),
[x8616_op_les] = slit8("les"),
[x8616_op_lahf] = slit8("lahf"),
[x8616_op_sahf] = slit8("sahf"),
[x8616_op_pushf] = slit8("pushf"),
[x8616_op_popf] = slit8("popf"),
[x8616_op_inc] = slit8("inc"),
[x8616_op_aaa] = slit8("aaa"),
[x8616_op_daa] = slit8("daa"),
[x8616_op_dec] = slit8("dec"),
[x8616_op_neg] = slit8("neg"),
[x8616_op_aas] = slit8("aas"),
[x8616_op_das] = slit8("das"),
[x8616_op_mul] = slit8("mul"),
[x8616_op_imul] = slit8("imul"),
[x8616_op_aam] = slit8("aam"),
[x8616_op_div] = slit8("div"),
[x8616_op_idiv] = slit8("idiv"),
[x8616_op_aad] = slit8("aad"),
[x8616_op_cbw] = slit8("cbw"),
[x8616_op_cwd] = slit8("cwd"),
[x8616_op_not] = slit8("not"),
[x8616_op_shl] = slit8("shl"),
[x8616_op_shr] = slit8("shr"),
[x8616_op_sar] = slit8("sar"),
[x8616_op_rol] = slit8("rol"),
[x8616_op_ror] = slit8("ror"),
[x8616_op_rcl] = slit8("rcl"),
[x8616_op_rcr] = slit8("rcr"),
[x8616_op_test] = slit8("test"),
[x8616_op_rep] = slit8(""),
[x8616_op_movs] = slit8("movs"),
[x8616_op_cmps] = slit8("cmps"),
[x8616_op_scas] = slit8("scas"),
[x8616_op_lods] = slit8("lods"),
[x8616_op_stos] = slit8("stos"),
[x8616_op_call] = slit8("call"),
[x8616_op_jmp] = slit8("jmp"),
[x8616_op_ret] = slit8("ret"),
[x8616_op_retf] = slit8("retf"),
[x8616_op_je] = slit8("je"),
[x8616_op_jl] = slit8("jl"),
[x8616_op_jle] = slit8("jle"),
[x8616_op_jb] = slit8("jb"),
[x8616_op_jbe] = slit8("jbe"),
[x8616_op_jp] = slit8("jp"),
[x8616_op_jo] = slit8("jo"),
[x8616_op_js] = slit8("js"),
[x8616_op_jne] = slit8("jne"),
[x8616_op_jnl] = slit8("jnl"),
[x8616_op_jg] = slit8("jg"),
[x8616_op_jnb] = slit8("jnb"),
[x8616_op_ja] = slit8("ja"),
[x8616_op_jnp] = slit8("jnp"),
[x8616_op_jno] = slit8("jno"),
[x8616_op_jns] = slit8("jns"),
[x8616_op_loop] = slit8("loop"),
[x8616_op_loopz] = slit8("loopz"),
[x8616_op_loopnz] = slit8("loopnz"),
[x8616_op_jcxz] = slit8("jcxz"),
[x8616_op_int] = slit8("int"),
[x8616_op_int3] = slit8("int3"),
[x8616_op_into] = slit8("into"),
[x8616_op_iret] = slit8("iret"),
[x8616_op_clc] = slit8("clc"),
[x8616_op_cmc] = slit8("cmc"),
[x8616_op_stc] = slit8("stc"),
[x8616_op_cld] = slit8("cld"),
[x8616_op_std] = slit8("std"),
[x8616_op_cli] = slit8("cli"),
[x8616_op_sti] = slit8("sti"),
[x8616_op_hlt] = slit8("hlt"),
[x8616_op_wait] = slit8("wait"),
[x8616_op_lock] = slit8(""),
[x8616_op_segment] = slit8(""),
};
RO_ global Str8 x8616_serialize_reg8[] = {
[x8616_al] = slit8("al"),
[x8616_cl] = slit8("cl"),
[x8616_dl] = slit8("dl"),
[x8616_bl] = slit8("bl"),
[x8616_ah] = slit8("ah"),
[x8616_ch] = slit8("ch"),
[x8616_dh] = slit8("dh"),
[x8616_bh] = slit8("bh"),
};
RO_ global Str8 x8616_serialize_reg16[] = {
[x8616_ax] = slit8("ax"),
[x8616_cx] = slit8("cx"),
[x8616_dx] = slit8("dx"),
[x8616_bx] = slit8("bx"),
[x8616_sp] = slit8("sp"),
[x8616_bp] = slit8("bp"),
[x8616_si] = slit8("si"),
[x8616_di] = slit8("di"),
};
RO_ global Str8 x8616_serialize_seg[] = {
[x8616_es] = slit8("es"),
[x8616_cs] = slit8("cs"),
[x8616_ss] = slit8("ss"),
[x8616_ds] = slit8("ds"),
};
RO_ global Str8 x8616_serialize_ea[] = {
[x8616_ea_bx_si] = slit8("bx + si"),
[x8616_ea_bx_di] = slit8("bx + di"),
[x8616_ea_bp_si] = slit8("bp + si"),
[x8616_ea_bp_di] = slit8("bp + di"),
[x8616_ea_si] = slit8("si"),
[x8616_ea_di] = slit8("di"),
[x8616_ea_bp] = slit8("bp"),
[x8616_ea_bx] = slit8("bx"),
};
typedef Enum_(U1, X8616_SerializeSizeWhere) {
x8616_serialize_size_none = 0x00,
x8616_serialize_size_before_mem = 0x01,
x8616_serialize_size_before_imm = 0x02,
};
FI_ B4 x8616_serialize_put(Str8Gen_R gen, Str8 piece) {
if (piece.len > gen->cap - gen->len) return false;
str8gen_append_str8(gen, piece); return true;
}
FI_ X8616_SerializeStatus x8616_serialize_put_or_full(Str8Gen_R gen, Str8 piece) {
X8616_SerializeStatus status = x8616_serialize_ok;
if (x8616_serialize_put(gen, piece) == 0) status = x8616_serialize_output_full;
return status;
}
internal B4 x8616_serialize_put_u4(Str8Gen_R gen, U4 value) {
Info_str8_from_u4 info = str8_from_u4_info(value, 10, 0, 0);
UTF8 digits[16];
B4 ok = info.size_required != 0 && info.size_required <= Array_len(digits) && info.size_required <= gen->cap - gen->len;
if (ok) {
Str8 text = str8_from_u4_buf(slice_ut(digits, info.size_required), value, 10, 0, 0, info);
ok = x8616_serialize_put(gen, text);
}
return ok;
}
internal B4 x8616_serialize_put_s4(Str8Gen_R gen, S4 value) {
B4 ok = true;
if (value < 0) {
ok = x8616_serialize_put(gen, slit8("-"));
if (ok) ok = x8616_serialize_put_u4(gen, C_(U4, -value));
}
else {
ok = x8616_serialize_put_u4(gen, C_(U4, value));
}
return ok;
}
internal S4 x8616_serialize_s4_from_bits(U2 bits, U1 byte_count) {
if (byte_count <= 1) {
U4 value = bits & 0xFF;
if (value & 0x80) return C_(S4, value) - 256;
return C_(S4, value);
}
U4 value = bits;
if (value & 0x8000) return C_(S4, value) - 65536;
return C_(S4, value);
}
FI_ B4 x8616_serialize_imm_is_signed(X8616_Op op) { switch (op) {
case x8616_op_mov:
case x8616_op_add:
case x8616_op_adc:
case x8616_op_sub:
case x8616_op_sbb:
case x8616_op_cmp:
case x8616_op_ret:
case x8616_op_retf:
return 1;
default:
return 0;
}}
FI_ U1 x8616_serialize_imm_bytes(X8616_DecodedOperandFlags flags, U1 immediate_bytes, X8616_WidthMode width) {
if (immediate_bytes) return immediate_bytes;
if (flags & x8616_decoded_operand_sign_extended) return 1;
if (width == x8616_width_word) return 2;
return 1;
}
internal B4
x8616_serialize_put_imm(Str8Gen_R gen, X8616_DecodedInstruction_R inst, X8616_DecodedOperand_R operand) {
U1 bytes = x8616_serialize_imm_bytes(operand->flags, operand->immediate_bytes, operand->width);
if (x8616_serialize_imm_is_signed(inst->op)) {
return x8616_serialize_put_s4(gen, x8616_serialize_s4_from_bits(operand->immediate, bytes));
}
U4 value = operand->immediate;
if (bytes <= 1) value &= 0xFF;
return x8616_serialize_put_u4(gen, value);
}
internal X8616_WidthMode
x8616_serialize_mem_width(X8616_DecodedInstruction_R inst) {
for (U1 id = 0; id < inst->operand_count; ++id) {
if (inst->operands[id].flags & x8616_decoded_operand_memory) return inst->operands[id].width;
}
return inst->width;
}
internal X8616_SerializeSizeWhere
x8616_serialize_size_where(X8616_Op op, U1 operand_count, X8616_DecodedOperand operands[static 2])
{
B4 has_mem = 0;
B4 has_imm = 0;
for (U1 id = 0; id < operand_count; ++id) {
X8616_DecodedOperandFlags flags = operands[id].flags;
if (flags & x8616_decoded_operand_memory) has_mem = 1;
if ((flags & x8616_decoded_operand_immediate) && ((flags & x8616_decoded_operand_register) == 0)) has_imm = 1;
}
switch (op) {
case x8616_op_mov:
if (has_mem && has_imm) return x8616_serialize_size_before_imm;
return x8616_serialize_size_none;
case x8616_op_add:
case x8616_op_adc:
case x8616_op_sub:
case x8616_op_sbb:
case x8616_op_cmp:
case x8616_op_and:
case x8616_op_or:
case x8616_op_xor:
case x8616_op_test:
if (has_mem && has_imm) return x8616_serialize_size_before_mem;
return x8616_serialize_size_none;
case x8616_op_not:
case x8616_op_neg:
case x8616_op_inc:
case x8616_op_dec:
case x8616_op_mul:
case x8616_op_imul:
case x8616_op_div:
case x8616_op_idiv:
case x8616_op_push:
case x8616_op_pop:
case x8616_op_shl:
case x8616_op_shr:
case x8616_op_sar:
case x8616_op_rol:
case x8616_op_ror:
case x8616_op_rcl:
case x8616_op_rcr:
if (has_mem) return x8616_serialize_size_before_mem;
return x8616_serialize_size_none;
default:
return x8616_serialize_size_none;
}
}
internal B4 x8616_serialize_put_size(Str8Gen_R gen, X8616_WidthMode width) {
Str8 name = slit8("");
if (width == x8616_width_byte) name = slit8("byte");
if (width == x8616_width_word) name = slit8("word");
B4 ok = name.len != 0;
if (ok) ok = x8616_serialize_put(gen, name);
if (ok) ok = x8616_serialize_put(gen, slit8(" "));
return ok;
}
internal B4
x8616_serialize_put_memory(Str8Gen_R gen, X8616_DecodedInstruction_R inst, X8616_DecodedOperand_R operand)
{
B4 ok = true;
if (inst->prefixes.has_segment) {
ok = x8616_serialize_put(gen, x8616_serialize_seg[inst->prefixes.segment]);
if (ok) ok = x8616_serialize_put(gen, slit8(":"));
}
if (ok) ok = x8616_serialize_put(gen, slit8("["));
if (ok && (operand->flags & x8616_decoded_operand_direct)) {
ok = x8616_serialize_put_u4(gen, operand->address);
}
else if (ok) {
ok = x8616_serialize_put(gen, x8616_serialize_ea[operand->ea]);
S4 disp = operand->displacement;
if (ok && disp > 0) {
ok = x8616_serialize_put(gen, slit8(" + "));
if (ok) ok = x8616_serialize_put_u4(gen, C_(U4, disp));
}
else if (ok && disp < 0) {
ok = x8616_serialize_put(gen, slit8(" - "));
if (ok) ok = x8616_serialize_put_u4(gen, C_(U4, -disp));
}
}
if (ok) ok = x8616_serialize_put(gen, slit8("]"));
return ok;
}
FI_ B4 x8616_serialize_is_string(X8616_Op op) { switch (op) {
case x8616_op_movs:
case x8616_op_cmps:
case x8616_op_scas:
case x8616_op_lods:
case x8616_op_stos:
return 1;
default:
return 0;
}}
FI_ B4 x8616_serialize_has_memory(X8616_DecodedInstruction* inst) {
for (U1 id = 0; id < inst->operand_count; ++id) { if (inst->operands[id].flags & x8616_decoded_operand_memory) return 1; }
return 0;
}
internal X8616_SerializeStatus
x8616_serialize_put_operand(Str8Gen_R gen, X8616_DecodedInstruction* inst, X8616_DecodedOperand* operand)
{
X8616_SerializeStatus status = x8616_serialize_ok;
X8616_SerializeSizeWhere where = x8616_serialize_size_where(inst->op, inst->operand_count, inst->operands);
X8616_WidthMode width = x8616_serialize_mem_width(inst);
B4 is_mem = (operand->flags & x8616_decoded_operand_memory) != 0;
B4 is_imm = ((operand->flags & x8616_decoded_operand_immediate) != 0) && ((operand->flags & x8616_decoded_operand_register) == 0);
B4 is_reg = (operand->flags & x8616_decoded_operand_register) != 0;
B4 is_seg = (operand->flags & x8616_decoded_operand_segment) != 0;
B4 is_rel = (operand->flags & x8616_decoded_operand_relative) != 0;
B4 is_far = (operand->flags & x8616_decoded_operand_far_ptr) != 0;
if (status == x8616_serialize_ok && where == x8616_serialize_size_before_mem && is_mem) {
if (x8616_serialize_put_size(gen, width) == 0) status = x8616_serialize_output_full;
}
if (status == x8616_serialize_ok && where == x8616_serialize_size_before_imm && is_imm) {
if (x8616_serialize_put_size(gen, width) == 0) status = x8616_serialize_output_full;
}
if (status == x8616_serialize_ok && (inst->flags & x8616_encoding_far) && is_mem) {
status = x8616_serialize_put_or_full(gen, slit8("far "));
}
if (status == x8616_serialize_ok) {
if (is_reg) {
U1 index = C_(U1, operand->reg.r16);
if (operand->width == x8616_width_byte) status = x8616_serialize_put_or_full(gen, x8616_serialize_reg8 [index]);
else if (operand->width == x8616_width_word) status = x8616_serialize_put_or_full(gen, x8616_serialize_reg16[index]);
else status = x8616_serialize_unsupported_form;
}
else if (is_seg) {
status = x8616_serialize_put_or_full(gen, x8616_serialize_seg[operand->segment]);
}
else if (is_mem) {
if (x8616_serialize_put_memory(gen, inst, operand) == 0) status = x8616_serialize_output_full;
}
else if (is_imm) {
if (x8616_serialize_put_imm(gen, inst, operand) == 0) status = x8616_serialize_output_full;
}
else if (is_rel) {
S4 rel = C_(S4, inst->size) + operand->displacement;
status = x8616_serialize_put_or_full(gen, slit8("$"));
if (status == x8616_serialize_ok && rel >= 0) status = x8616_serialize_put_or_full(gen, slit8("+"));
if (status == x8616_serialize_ok && x8616_serialize_put_s4(gen, rel) == 0) status = x8616_serialize_output_full;
}
else if (is_far) {
if (x8616_serialize_put_u4(gen, operand->far_segment) == 0) status = x8616_serialize_output_full;
if (status == x8616_serialize_ok) status = x8616_serialize_put_or_full(gen, slit8(":"));
if (status == x8616_serialize_ok && x8616_serialize_put_u4(gen, operand->far_offset) == 0) status = x8616_serialize_output_full;
}
else {
status = x8616_serialize_unsupported_form;
}
}
return status;
}
FI_ X8616_DecodedOperandFlags x8616_serialize_base_flags(X8616_DecodedOperandFlags flags) {
return flags & (
x8616_decoded_operand_register
| x8616_decoded_operand_segment
| x8616_decoded_operand_memory
| x8616_decoded_operand_immediate
| x8616_decoded_operand_relative
| x8616_decoded_operand_far_ptr
);
}
FI_ B4 x8616_serialize_one_flag(X8616_DecodedOperandFlags flags) { U2 bits = C_(U2, flags); return (bits != 0) && ((bits & (bits - 1)) == 0); }
internal X8616_SerializeStatus
x8616_serialize_validate(X8616_DecodedInstruction_R inst)
{
X8616_SerializeStatus status = x8616_serialize_ok;
B4 bad_decode = inst->decode_flags & (x8616_decode_invalid | x8616_decode_truncated);
B4 invalid_sig = inst->size == 0 || inst->operand_count > 2;
B4 invalid_mnemonic = u4_(inst->op) >= Array_len(x8616_serialize_mnemonic) || inst->op == x8616_op_invalid;
B4 invalid_prefix_with_seg = inst->prefixes.has_segment && u1_(inst->prefixes.segment) >= Array_len(x8616_serialize_seg);
if (bad_decode || invalid_sig || invalid_mnemonic || invalid_prefix_with_seg) {
status = x8616_serialize_invalid_record; goto status_failed;
}
B4 bad_prefix_segement = inst->prefixes.has_segment && (x8616_serialize_has_memory(inst) == 0);
B4 bad_prefix_repeat = inst->prefixes.has_repeat && (x8616_serialize_is_string(inst->op) == 0);
if (bad_prefix_segement || bad_prefix_repeat) {
status = x8616_serialize_unsupported_form; goto status_failed;
}
for (U1 id = 0; id < inst->operand_count; ++id)
{
X8616_DecodedOperand_R operand = & inst->operands[id];
X8616_DecodedOperandFlags base = x8616_serialize_base_flags(operand->flags);
B4 invalid_flag = x8616_serialize_one_flag(base) == 0;
B4 has_operand_register = base & x8616_decoded_operand_register;
B4 has_operand_segment = base & x8616_decoded_operand_segment;
B4 has_operand_memory = base & x8616_decoded_operand_memory;
B4 invalid_reg_r16 = u1_(operand->reg.r16) >= Array_len(x8616_serialize_reg16);
B4 invalid_width = operand->width != x8616_width_byte && operand->width != x8616_width_word;
B4 invalid_operand_seg = u1_(operand->segment) >= Array_len(x8616_serialize_seg);
B4 invalid_operand_ea = u1_(operand->ea) >= Array_len(x8616_serialize_ea);
B4 invalid_direct_ea = has_operand_memory && ((operand->flags & x8616_decoded_operand_direct) == 0) && invalid_operand_ea;
B4 invalid_operand = invalid_flag
|| (has_operand_register && (invalid_reg_r16 || invalid_width))
|| (has_operand_segment && invalid_operand_seg)
|| invalid_direct_ea;
if (invalid_operand) {
status = x8616_serialize_invalid_record; goto status_failed;
}
}
status_failed:
return status;
}
internal X8616_SerializeStatus
x8616_serialize_instruction_line(Str8Gen_R line, X8616_DecodedInstruction* inst)
{
X8616_SerializeStatus st = x8616_serialize_ok;
Str8 mnemonic = x8616_serialize_mnemonic[inst->op];
if (mnemonic.len == 0) st = x8616_serialize_unsupported_form;
if (st == x8616_serialize_ok && inst->prefixes.lock) {
st = x8616_serialize_put_or_full(line, slit8("lock "));
}
if (st == x8616_serialize_ok && inst->prefixes.has_repeat) {
if (inst->prefixes.repeat == x8616_rep) st = x8616_serialize_put_or_full(line, slit8("rep "));
else st = x8616_serialize_put_or_full(line, slit8("repne "));
}
if (st == x8616_serialize_ok) st = x8616_serialize_put_or_full(line, mnemonic);
if (st == x8616_serialize_ok && x8616_serialize_is_string(inst->op)) {
if (inst->width == x8616_width_byte) st = x8616_serialize_put_or_full(line, slit8("b"));
else if (inst->width == x8616_width_word) st = x8616_serialize_put_or_full(line, slit8("w"));
else st = x8616_serialize_unsupported_form;
}
if (st == x8616_serialize_ok && inst->operand_count) {
st = x8616_serialize_put_or_full(line, slit8(" "));
for (U1 id = 0; st == x8616_serialize_ok && id < inst->operand_count; ++id) {
if (id) st = x8616_serialize_put_or_full(line, slit8(", "));
if (st == x8616_serialize_ok) st = x8616_serialize_put_operand(line, inst, & inst->operands[id]);
}
}
if (st == x8616_serialize_ok) st = x8616_serialize_put_or_full(line, slit8("\n"));
return st;
}
X8616_SerializeInfo
x8616_serialize_instructions(X8616_SerializeRequest request)
{
X8616_SerializeInfo result = {0}; result.text.ptr = C_(UTF8*, request.output.ptr);
B4 invalid_record =
(request.instruction_count && request.instructions == 0)
|| (request.output.len && request.output.ptr == 0)
|| (request.scratch.len && request.scratch.ptr == 0);
if (invalid_record) { result.status = x8616_serialize_invalid_record; goto exit; }
if (request.output.len < X8616_SERIALIZE_HEADER_LEN) { result.status = x8616_serialize_output_full; goto exit; }
Str8Gen gen = str8gen_make(request.output);
if (x8616_serialize_header.len > gen.cap - gen.len) { result.status = x8616_serialize_output_full; goto exit; }
str8gen_append_str8(& gen, x8616_serialize_header);
result.text.len = gen.len;
for (U4 id = 0; id < request.instruction_count; ++id) {
X8616_SerializeStatus line_status = x8616_serialize_validate(& request.instructions[id]);
if (line_status != x8616_serialize_ok) { result.status = line_status; goto exit; }
Str8Gen line = str8gen_make(request.scratch);
line_status = x8616_serialize_instruction_line(& line, & request.instructions[id]);
if (line_status != x8616_serialize_ok) { result.status = line_status; goto exit; }
Str8 text = str8(line.ptr, line.len);
if (text.len > gen.cap - gen.len) { result.status = x8616_serialize_output_full; goto exit; }
str8gen_append_str8(& gen, text);
result.text.len = gen.len;
result.instructions_written += 1;
}
result.status = x8616_serialize_ok;
exit:
return result;
}
code/8086/serializer.h
+26
View File
@@ -0,0 +1,26 @@
#ifdef INTELLISENSE_DIRECTIVES
# pragma once
# include "decoder.h"
#endif
typedef Enum_(U1, X8616_SerializeStatus) {
x8616_serialize_ok = 0x00,
x8616_serialize_output_full = 0x01,
x8616_serialize_invalid_record = 0x02,
x8616_serialize_unsupported_form = 0x03,
};
typedef Struct_(X8616_SerializeRequest) {
X8616_DecodedInstruction* instructions;
U4 instruction_count;
Slice output;
Slice scratch;
};
typedef Struct_(X8616_SerializeInfo) {
Str8 text;
U4 instructions_written;
X8616_SerializeStatus status;
};
X8616_SerializeInfo x8616_serialize_instructions(X8616_SerializeRequest request);
code/duffle/asm.h
+127
View File
@@ -0,0 +1,127 @@
#ifdef INTELLISENSE_DIRECTIVES
# pragma once
# include "dsl.h"
#endif
#define asm_out /* outputs */
#define asm_in /* inputs */
#define asm_clobber /* clobbers */
#define asm_out_r(name) [name] "=r"(name)
#define asm_in_r(name) [name] "r"(name)
#define asm_out_x(name) [name] "=&x"(name) /* XMM, earlyclobber */
#define asm_out_x0(name) [name] "=x"(name) /* XMM, no earlyclobber */
#define asm_in_x(name) [name] "x"(name)
#define x64_r(name) "%[" #name "]"
#define x64_m(name) "(%[" #name "])"
#define x64_xmm(name) "%x[" #name "]"
typedef U8 U8x2 attribute(vector_size(16));
typedef U8 U8x4 attribute(vector_size(32));
typedef U1 U1x16 attribute(vector_size(16));
#define x64_u4_from_byte_hits(dst, src) "pmovmskb " x64_r(src) ", " x64_r(dst) "\n"
#define x64_u4_count_trailing_zeros(dst, src) "tzcntl " x64_r(src) ", " x64_r(dst) "\n"
#define x64_u1x16_repeat_dwords(dst, src, n) "pshufd $" #n ", " x64_r(src) ", " x64_r(dst) "\n"
#define x64_u1x16_load_mem4(dst, src) "movd " x64_r(src) ", " x64_r(dst) "\n"
#define x64_u1x16_load_mem8(dst, src) "movq " x64_m(src) ", " x64_r(dst) "\n"
#define x64_u1x16_load_mem16(dst, src) "movdqu " x64_m(src) ", " x64_r(dst) "\n"
#define x64_u1x16_match_bytes(dst, src) "pcmpeqb " x64_r(src) ", " x64_r(dst) "\n"
#define x64_u8x2_load_u8(dst, src) "vmovq " x64_m(src) ", " x64_r(dst) "\n"
#define x64_u8x2_insert_u8(dst, src, n) "vpinsrq $" #n ", " x64_m(src) ", " x64_r(dst) ", " x64_r(dst) "\n"
#define x64_u8x4_insert_xmm(dst, src, n) "vinserti128 $" #n ", " x64_r(src) ", " x64_r(dst) ", " x64_r(dst) "\n"
#define x64_u8x4_broadcast(dst, src) "vpbroadcastq " x64_r(src) ", " x64_r(dst) "\n"
#define x64_u8x4_match(dst, a, b) "vpcmpeqq " x64_r(b) ", " x64_r(a) ", " x64_r(dst) "\n"
#define x64_u4_from_qword_hits(dst, src) "vmovmskpd " x64_r(src) ", " x64_r(dst) "\n"
FI_ U4 count_trailing_zeros_u4(U4 mask) {
U4 n;
asm volatile(
x64_u4_count_trailing_zeros(n, mask)
asm_out : asm_out_r(n)
asm_in : asm_in_r(mask)
);
return n;
}
FI_ U1x16 splat_u4_u1x16(U4 b4) {
U1x16 v;
asm volatile(
x64_u1x16_load_mem4 (v, b4)
x64_u1x16_repeat_dwords(v, v, 0)
asm_out : asm_out_x0(v)
asm_in : asm_in_r(b4)
);
return v;
}
FI_ U4 mask_eq8_u1x16(U1_R p, U1x16 needle) {
U1x16 chunk;
U4 mask;
asm volatile(
x64_u1x16_load_mem8 (chunk, p)
x64_u1x16_match_bytes(chunk, needle)
x64_u4_from_byte_hits(mask, chunk)
asm_out : asm_out_x(chunk), asm_out_r(mask)
asm_in : asm_in_r(p), asm_in_x(needle)
asm_clobber : "memory"
);
return mask; /* movq zero-fills the high 8 bytes; bits 8–15 stay 0 */
}
FI_ U4 mask_eq16_u1x16(U1_R p, U1x16 needle) {
U1x16 chunk;
U4 mask;
asm volatile(
x64_u1x16_load_mem16 (chunk, p)
x64_u1x16_match_bytes(chunk, needle)
x64_u4_from_byte_hits(mask, chunk)
asm_out : asm_out_x(chunk), asm_out_r(mask)
asm_in : asm_in_r(p), asm_in_x(needle)
asm_clobber : "memory"
);
return mask;
}
I_ U8 find_u1_via_u1x16(U1_R p, U8 len, U1 ch, U1x16 needle) {
U8 i = 0;
while (len - i >= 16) {
U4 mask = mask_eq16_u1x16(p + i, needle);
if (mask) return i + C_(U8, count_trailing_zeros_u4(mask));
i += 16;
}
while (len - i >= 8) {
U4 mask = mask_eq8_u1x16(p + i, needle);
if (mask) return i + C_(U8, count_trailing_zeros_u4(mask));
i += 8;
}
while (i < len) {
if (p[i] == ch) return i;
++ i;
}
return len; /* not found */
}
FI_ U4 find_aos_keys_mask_u8x4(U8_R p0, U8_R p1, U8_R p2, U8_R p3, U8 key) {
U8x2 lo, hi;
U8x4 keys, splat, eq;
U4 mask;
asm volatile(
x64_u8x2_load_u8 (lo, p0)
x64_u8x2_insert_u8(lo, p1, 1)
x64_u8x2_load_u8 (hi, p2)
x64_u8x2_insert_u8(hi, p3, 1)
x64_u8x4_insert_xmm(keys, lo, 0)
x64_u8x4_insert_xmm(keys, hi, 1)
x64_u8x4_broadcast(splat, key)
x64_u8x4_match(eq, keys, splat)
x64_u4_from_qword_hits(mask, eq)
asm_out : asm_out_x(lo), asm_out_x(hi), asm_out_x(keys), asm_out_x(splat), asm_out_x(eq), asm_out_r(mask)
asm_in : asm_in_r(p0), asm_in_r(p1), asm_in_r(p2), asm_in_r(p3), asm_in_r(key)
asm_clobber : "memory"
);
return mask;
}
code/duffle/dsl.h
+21 -33
View File
@@ -10,6 +10,7 @@ Standard: c23
#pragma clang diagnostic ignored "-Wswitch"
#pragma clang diagnostic ignored "-Wuninitialized"
#pragma clang diagnostic ignored "-Wmicrosoft-enum-forward-reference"
#pragma clang diagnostic ignored "-Wmicrosoft-fixed-enum"
// #pragma comment(lib, "Advapi32.lib")
// #pragma comment(lib, "gdi32.lib")
// #pragma comment(lib, "Kernel32.lib")
@@ -41,8 +42,8 @@ Standard: c23
#define glue(A, B) glue_impl(A, B)
#define tmpl(prefix, type) prefix ## _ ## type
#define stringify_impl(S) #S
#define stringify(S) stringify_impl(S)
#define stringify_impl(...) #__VA_ARGS__
#define stringify(...) stringify_impl(__VA_ARGS__)
#define VA_Sel_1( _1, ... ) _1 // <-- Of all th args passed pick _1.
#define VA_Sel_2( _1, _2, ... ) _2 // <-- Of all the args passed pick _2.
@@ -54,16 +55,19 @@ Standard: c23
#define LP_ static // static data within procedure scope
#define internal static // internal
#define attribute(directive) __attribute__((directive))
#define asm __asm__
#define align_(value) __attribute__((aligned (value))) // for easy alignment
#define align_(value) attribute(aligned(value)) // for easy alignment
#define C_(type,data) ((type)(data)) // for enforced precedence
#define expect_(x, y) __builtin_expect(x, y) // so compiler knows the common path
#define cexpr_ __builtin_constant_p
#define I_ internal inline
#define FI_ inline __attribute__((always_inline)) // inline always
#define NI_ internal __attribute__((noinline)) // inline never
#define RO_ __attribute__((section(".rodata"))) // Read only data allocation
#define FI_ inline attribute(always_inline) // inline always
#define NI_ internal attribute(noinline) // inline never
#define RO_ attribute(section(".rodata")) // Read only data allocation
#define T_ typeof //
#define T_same(a,b) _Generic((a), typeof((b)): 1, default: 0)
@@ -119,7 +123,7 @@ Standard: c23
#define Array_expand(type,len) type Array_sym(type, len)[len]; typedef PtrSet_(Array_sym(type, len))
#define Array_(type,len) Array_expand(type,len)
#define Bit_(id,b) id = (1 << b), tmpl(id,pos) = b
#define Enum_(underlying_type, symbol) underlying_type TSet_(symbol); enum symbol
#define Enum_(underlying_type, symbol) enum symbol : underlying_type TSet_(symbol); enum symbol : underlying_type
#define Proc_(symbol) symbol
#define Relative_(symbol) // Does nothing but annotate that a symbol is associated with another.
#define Struct_(symbol) struct symbol TSet_(symbol); struct symbol
@@ -218,6 +222,10 @@ def_signed_ops(le, <=)
#define dbg_args(...) __VA_ARGS__
#pragma region Control Flow & Iteration
#define jump_ne(a,b,label) if (a != b) goto label
#define jump_gt(a,b,label) if (a > b) goto label
#define jump_lt(a,b,label) if (a < b) goto label
#define unreachable() __builtin_unreachable()
#define each_iter(type, iter, end) (type iter = 0; iter < end; ++ iter)
@@ -262,6 +270,10 @@ FI_ U8 atm_swap_u8(U8_R addr, U8 value){asm volatile("lock xchgq %0,%1":"=r"(val
#pragma endregion Thread Coherence
#pragma region Misc
#define byte_pos(pos) (pos * 8)
#define byte_shift(value,pos) (value << byte_pos(pos))
#define u4_byte_fill(value) byte_shift(value,0) | byte_shift(value,1) | byte_shift(value,2) | byte_shift(value,3)
enum {
Bitmask_3 = 0x00000007,
Bitmask_4 = 0x0000000f,
@@ -270,32 +282,8 @@ enum {
Bitmask_10 = 0x000003ff,
};
typedef Enum_(U4, WeekDay) {
WeekDay_Sun,
WeekDay_Mon,
WeekDay_Tue,
WeekDay_Wed,
WeekDay_Thu,
WeekDay_Fri,
WeekDay_Sat,
WeekDay_Num,
};
typedef Enum_(U4, Month) {
Month_Jan,
Month_Feb,
Month_Mar,
Month_Apr,
Month_May,
Month_Jun,
Month_Jul,
Month_Aug,
Month_Sep,
Month_Oct,
Month_Nov,
Month_Dec,
Month_Num,
};
typedef Enum_(U4, WeekDay) { WeekDay_Sun, WeekDay_Mon, WeekDay_Tue, WeekDay_Wed, WeekDay_Thu, WeekDay_Fri, WeekDay_Sat, WeekDay_Num, };
typedef Enum_(U4, Month) { Month_Jan, Month_Feb, Month_Mar, Month_Apr, Month_May, Month_Jun, Month_Jul, Month_Aug, Month_Sep, Month_Oct, Month_Nov, Month_Dec, Month_Num, };
typedef U8 DenseTime;
code/duffle/files.h
+1 -1
View File
@@ -13,7 +13,7 @@
CLANG_OPTIMIZE_DISABLE
// Most of this referenced from the RAD Debugger codebase.
typedef Enum_(U4,AccessFlags) {
typedef Enum_(U4, AccessFlags) {
Bit_(AccessFlag_Read, 0),
Bit_(AccessFlag_Write, 1),
Bit_(AccessFlag_Execute, 2),
code/duffle/memory.h
+38 -19
View File
@@ -5,7 +5,7 @@
#define MEM_ALIGNMENT_DEFAULT 4
#define assert_bounds(point, start, end) for(;0;){ \
#define assert_bounds(point, start, end) do{ \
assert((start) <= (point)); \
assert((point) <= (end)); \
} while(0)
@@ -39,8 +39,17 @@ FI_ B4 mem_match (U8 a, U8 b, U8 z) { return mem_compare(a, b, z) == 0; }
#define mem_match_struct(a,b) mem_match(C_(U8,a), C_(U8,b), S_((a)[0]))
#define mem_zero_struct(s) mem_zero(u8_(& s), S_(s))
#pragma region DAG
I_ void mem_push_aligned_typed(U8 start, U8 capacity, U8_R used, U8 amount, U4 alignment, U4 type_width, U8_R out_ptr, U8_R out_len) {
if (amount == 0) { out_ptr[0] = 0; out_len[0] = 0; return; }
U8 desired = amount * (type_width == 0 ? 1 : type_width);
U8 to_commit = align_pow2(desired, alignment ? alignment : MEM_ALIGNMENT_DEFAULT);
U8 ptr = start + used[0];
mem_bump_u8(start, capacity, used, to_commit);
out_ptr[0] = ptr;
out_len[0] = to_commit;
}
#pragma region DAG
#define check_nil(nil, p) ((p) == 0 || (p) == nil)
#define set_nil(nil, p) ((p) = nil)
@@ -59,15 +68,13 @@ FI_ B4 mem_match (U8 a, U8 b, U8 z) { return mem_compare(a, b, z) == 0; }
) \
)
#define sll_queue_push_n(f, l, n, next) sll_queue_push_nz(0, f, l, n, next)
#pragma endregion DAG
#pragma region Slice
typedef unsigned char TSet_(UTF8);
typedef Struct_(Str8) { UTF8* ptr; U8 len; }; typedef Str8 Slice_UTF8;
typedef Struct_(Slice_Str8) { Str8* ptr; U8 len; };
#define slit8(string_literal) (Str8){ (UTF8*) string_literal, S_(string_literal) - 1 }
#define slit8(string_literal) ((Str8){ (UTF8*) string_literal, S_(string_literal) - 1 })
#define str8(p,l) (Str8){p,l}
typedef Struct_(Slice) { U8 ptr; U8 len; }; // Untyped Slice
@@ -81,7 +88,6 @@ FI_ Slice slice_ut_(U8 ptr, U8 len) { return (Slice){ptr, len}; }
#define slice_ut(ptr,len) slice_ut_(u8_(ptr), u8_(len))
#define slice_ut_arr(a) slice_ut_(u8_(a), S_(a))
#define slice_to_ut(s) slice_ut_(u8_((s).ptr), S_slice(s))
#define slice_iter(container, iter) (T_((container).ptr) iter = (container).ptr; iter != slice_end(container); ++ iter)
#define slice_arg_from_array(type, ...) & (tmpl(Slice,type)) { .ptr = Array_decl(type,__VA_ARGS__), .len = Array_len( Array_decl(type,__VA_ARGS__)) }
#define slice_from_array(type, array) (tmpl(Slice,type)) { .ptr = array, .len = S_(array) }
@@ -105,11 +111,9 @@ typedef Slice_(U1);
typedef Slice_(U2);
typedef Slice_(U4);
typedef Slice_(U8);
#pragma endregion Slice
#pragma region FArena
typedef Opt_(farena) { U8 alignment, type_width; };
typedef Struct_(FArena) { U8 start, capacity, used; };
FI_ void farena_init(FArena_R arena, Slice mem) { assert(arena != nullptr);
@@ -118,13 +122,10 @@ FI_ void farena_init(FArena_R arena, Slice mem) { assert(arena != nullptr);
arena->used = 0;
}
FI_ FArena farena_make(Slice mem) { FArena a; farena_init(& a, mem); return a; }
I_ Slice farena_push(FArena_R arena, U8 amount, Opt_farena o) {
if (amount == 0) { return (Slice){}; }
U8 desired = amount * (o.type_width == 0 ? 1 : o.type_width);
U8 to_commit = align_pow2(desired, o.alignment ? o.alignment : MEM_ALIGNMENT_DEFAULT);
U8 ptr = arena->start + arena->used;
mem_bump_u8(arena->start, arena->capacity, & arena->used, to_commit);
return (Slice){ ptr, to_commit };
FI_ Slice farena_push(FArena_R arena, U8 amount, Opt_farena o) { Slice res;
mem_push_aligned_typed(arena->start, arena->capacity, & arena->used, amount, o.alignment, o.type_width
, & res.ptr, & res.len);
return res;
}
FI_ void farena_reset (FArena_R arena) { arena->used = 0; }
FI_ void farena_rewind(FArena_R arena, U8 save_point) {
@@ -132,8 +133,26 @@ FI_ void farena_rewind(FArena_R arena, U8 save_point) {
arena->used = save_point;
}
FI_ U8 farena_save(FArena arena) { return arena.used; }
#define farena_push_(arena, amount, ...) farena_push((arena), (amount), opt_(farena, __VA_ARGS__))
#define farena_push_type(arena, type, ...) C_(type*, farena_push((arena), 1, opt_(farena, .type_width=S_(type), __VA_ARGS__)).ptr)
#define farena_push_array(arena, type, amount, ...) (tmpl(Slice,type)){ C_(type*, farena_push((arena), (amount), opt_(farena, .type_width=S_(type), __VA_ARGS__)).ptr), (amount) }
#define farena_push_(arena, amount, ...) farena_push((arena),(amount),opt_(farena,__VA_ARGS__))
#define farena_push_type(arena, type, ...) C_(type*,farena_push((arena),1, opt_(farena,.type_width=S_(type),__VA_ARGS__)).ptr)
#define farena_push_array(arena, type, amount, ...) (tmpl(Slice,type)){ C_(type*,farena_push((arena),(amount),opt_(farena,.type_width=S_(type),__VA_ARGS__)).ptr),(amount) }
#pragma endregion FArena
#pragma region FStack
#define FStack_(name, type, width) Struct_(name) { U8 top; type arr[width]; }
FI_ Slice fstack_push(Slice mem, U8_R top, U8 amount, Opt_farena o) { Slice res;
mem_push_aligned_typed(mem.ptr, mem.len, top, amount, o.alignment, o.type_width
, & res.ptr, & res.len);
return res;
};
// This is here more for annotation than anything else.
#define fstack_save(stack) stack.top
#define fstack_rewind(stack, sp) do{stack.top = sp;}while(0)
#define fstack_reset(stack) do{stack.top = 0; }while(0)
#define fstack_slice(stack) slice_ut_arr((stack).arr)
#define fstack_push_(stk, amount, ...) fstack_push(fstack_slice(stk),&(stk).top,(amount),opt_(farena,__VA_ARGS__))
#define fstack_push_array(stk, type, amount, ...) (tmpl(Slice,type)){ C_(type*,fstack_push(fstack_slice(stk),&(stk).top,(amount),opt_(farena,.type_width=S_(type),__VA_ARGS__)).ptr),(amount) }
#pragma endregion FStack
code/duffle/tables.h
+19 -4
View File
@@ -1,14 +1,14 @@
#ifdef INTELLISENSE_DIRECTIVES
# pragma once
# include "dsl.h"
# include "asm.h"
# include "memory.h"
# include "hashing.h"
# include "analysis.h"
#endif
#pragma region Key Table Linear (KTL)
enum { KT_SLot_value = S_(U8), };
enum { KT_Slot_value = S_(U8), };
#define KTL_Slot_(type) Struct_(tmpl(KTL_Slot,type)) { \
U8 key; \
type value; \
@@ -34,7 +34,22 @@ FI_ void ktl_populate_slice_a2_str8(KTL_Str8* kt, Slice_A2_Str8 values) {
mem_copy(u8_(& kt->ptr[id].value), u8_(& values.ptr[id][1]), S_(Str8));
}
}
#define ktl_str8_key(str) hash64_fnv1a_ret(slice_to_ut(str8(str)), 0)
#define ktl_str8_from_arr(arr) (KTL_Str8){arr, array_len(arr)}
#define ktl_str8_key(str) hash64_fnv1a_ret(slice_to_ut(slit8(str)), 0)
#define ktl_str8_from_arr(arr) (KTL_Str8){arr, Array_len(arr)}
FI_ Str8_R ktl_str8_find(KTL_Str8 table, U8 key) {
U8 i = 0;
while (table.len - i >= 4) {
KTL_Slot_Str8_R p = table.ptr + i;
U4 mask = find_aos_keys_mask_u8x4(& p[0].key, & p[1].key, & p[2].key, & p[3].key, key);
if (mask) return & table.ptr[i + C_(U8, count_trailing_zeros_u4(mask))].value;
i += 4;
}
while (i < table.len) {
if (table.ptr[i].key == key) return & table.ptr[i].value;
++ i;
}
assert(false);
return nullptr;
}
#pragma endregion KTL
code/duffle/text.h
+50 -56
View File
@@ -6,6 +6,7 @@
# include "hashing.h"
# include "tables.h"
# include "analysis.h"
# include "asm.h"
#endif
// NOTE(rjf): Includes reverses for uppercase and lowercase hex.
@@ -122,8 +123,8 @@ I_ Str8 str8_from_u4_buf(Slice buf, U4 num, U4 radix, U4 min_digits, U4 digit_gr
/*Fill Prefix*/ if (info.prefix.len > 0) { slice_copy(result, info.prefix); }
return result;
}
I_ Str8 str8_fmt_ktl_buf(Slice buffer, KTL_Str8 table, Str8 fmt_template)
{
I_ Str8 str8_fmt_ktl_buf(Slice buffer, KTL_Str8 table, Str8 fmt_template){
slice_assert(buffer);
slice_assert(table);
slice_assert(fmt_template);
@@ -131,68 +132,41 @@ I_ Str8 str8_fmt_ktl_buf(Slice buffer, KTL_Str8 table, Str8 fmt_template)
U8 buffer_remaining = buffer.len;
UTF8_R cursor_fmt = fmt_template.ptr;
U8 left_fmt = fmt_template.len;
U1x16 needle_lt = splat_u4_u1x16(u4_byte_fill('<'));
U1x16 needle_gt = splat_u4_u1x16(u4_byte_fill('>'));
while (left_fmt && buffer_remaining)
{
// Forward until we hit the delimiter '<' or the template's contents are exhausted.
U8 copy_offset = 0;
if (cursor_fmt[0] == '<')
{
UTF8_R potential_token_cursor = cursor_fmt + 1; // Skip '<'
U8 potential_token_len = 0;
B4 fmt_overflow = false;
while(true) {
UTF8_R cursor = potential_token_cursor + potential_token_len;
fmt_overflow = cursor >= slice_end(fmt_template);
B4 found_terminator = potential_token_cursor[potential_token_len] == '>';
if (fmt_overflow || found_terminator) { break; }
++ potential_token_len;
}
if (fmt_overflow) {
// Failed to find a subst and we're at end of fmt, just copy segment.
copy_offset = 1 + potential_token_len; // '<' + token
goto write_to_buffer;
}
// Hashing the potential token and cross checking it with our token table
U8 key = hash64_fnv1a_ret(slice_ut(u8_(potential_token_cursor), potential_token_len), 0);
Str8_R value = nullptr; for slice_iter(table, token) {
// We do a linear iteration instead of a hash table lookup because the user should never subst with more than 100 unqiue tokens..
if (token->key == key) { value = & token->value; break; }
}
if (value)
{
// We're going to appending the string, make sure we have enough space in our buffer.
// NOTE(Ed): this version doesn't support growing the buffer (No Allocator Interface)
assert((buffer_remaining - potential_token_len) > 0);
copy_offset = min(buffer_remaining, value->len); // Prevent Buffer overflow.
mem_copy(u8_(cursor_buffer), u8_(value->ptr), buffer_remaining);
// Sync cursor format to after the processed token
cursor_buffer += copy_offset;
buffer_remaining -= copy_offset;
cursor_fmt = potential_token_cursor + 1 + potential_token_len; // '<' + token
left_fmt -= potential_token_len + 2; // The 2 here are the '<' & '>' delimiters being omitted.
if (cursor_fmt[0] == '<') {
UTF8_R sig = cursor_fmt + 1;
U8 sig_max = slice_end(fmt_template) - sig;
U8 sig_len = find_u1_via_u1x16(sig, sig_max, '>', needle_gt);
assert(sig_len < sig_max);
Str8_R value = ktl_str8_find(table, hash64_fnv1a_ret(slice_ut(sig, sig_len), 0));
U8 n = min(buffer_remaining, value->len);
assert((buffer_remaining - n) > 0); mem_copy(u8_(cursor_buffer), u8_(value->ptr), n);
cursor_buffer += n;
buffer_remaining -= n;
cursor_fmt = sig + sig_len + 1;
left_fmt -= sig_len + 2;
continue;
}
// If not a subsitution, we copy the segment and continue.
copy_offset = 1 + potential_token_len; // '<' + token
goto write_to_buffer;
U8 n = find_u1_via_u1x16(cursor_fmt, min(left_fmt, buffer_remaining), '<', needle_lt);
assert((buffer_remaining - 1) > 0); n = min(buffer_remaining, n);
mem_copy(u8_(cursor_buffer), u8_(cursor_fmt), n);
cursor_buffer += n;
cursor_fmt += n;
buffer_remaining -= n;
left_fmt -= n;
}
else do {
++ copy_offset;
}
while ( (cursor_fmt[copy_offset] != '<' && (cursor_fmt + copy_offset) < slice_end(fmt_template)) );
write_to_buffer:
assert((buffer_remaining - copy_offset) > 0);
copy_offset = min(buffer_remaining, copy_offset); // Prevent buffer overflow.
mem_copy(u8_(cursor_buffer), u8_(cursor_fmt), copy_offset);
buffer_remaining -= copy_offset;
left_fmt -= copy_offset;
cursor_buffer += copy_offset;
cursor_fmt += copy_offset;
}
return (Str8){C_(UTF8*, buffer.ptr), buffer.len - buffer_remaining};
return str8(C_(UTF8*,buffer.ptr), buffer.len - buffer_remaining);
}
typedef Struct_(Str8Gen) { UTF8* ptr; U8 cap, len; };
FI_ Str8Gen str8gen_make(Slice s) { return (Str8Gen){C_(UTF8*,s.ptr), s.len, 0}; }
FI_ Slice str8gen_buf(Str8Gen_R gen) { return (Slice){u8_(gen->ptr) + gen->len, gen->cap - gen->len}; }
FI_ void str8gen_append_str8(Str8Gen_R gen, Str8 str) { assert(gen != nullptr);
@@ -223,8 +197,7 @@ str16_from_8(FArena* arena, Str8 in) {
U1* opl = ptr + in.len;
U8 size = 0;
UnicodeDecode consume;
for(;ptr < opl; ptr += consume.inc)
{
for(;ptr < opl; ptr += consume.inc) {
consume = utf8_decode(ptr, opl - ptr);
size += utf16_encode(str.ptr + size, consume.codepoint);
}
@@ -235,3 +208,24 @@ str16_from_8(FArena* arena, Str8 in) {
}
return result;
}
// Formatter where serial operation is done on-demand per-entry.
// enum {
// KTL_Str8FmtEntry_InlaidSize = (S_(Str8) * 2) - S_(Str8Fmt_TokenKind),
// };
// typedef Enum_(U4, Str8Fmt_SerialOpKind) {
// Str8Fmt_TKind_Str8,
// Str8Fmt_Base16_U1,
// Str8Fmt_Base16_U2,
// Str8Fmt_Base10_U4,
// };
// typedef Struct_(KTL_Str8Fmt_SerialOp_Entry) {
// union {
// U1 InlaidData[KTL_Str8FmtEntry_InlaidSize];
// Str8 str;
// void* Ptr;
// };
// Str8Fmt_SerialOpKind kind;
// };
// typedef KTL_Slot_(KTL_Str8Fmt_SerialOp_Entry);
code/part_1/sim_8086.c
+46 -6
View File
@@ -1,4 +1,5 @@
#include "duffle/dsl.h"
#include "duffle/asm.h"
#include "duffle/analysis.h"
#include "duffle/math.h"
#include "duffle/memory.h"
@@ -10,6 +11,17 @@
#include "duffle/win32.h"
#include "8086/encoder.h"
#include "8086/encoder_table.h"
#include "8086/info.h"
#include "8086/info_render.h"
#include "8086/decoder.h"
#include "8086/serializer.h"
#include "8086/gen/decoder_table.h"
#include "8086/decoder.c"
#include "8086/serializer.c"
// #include "8086/decoder.h"
typedef Struct_(U2_HL) { U1 Low; U1 High; };
@@ -47,7 +59,6 @@ FI_ void a8utf8_from_u1_be(UTF8 out[8], U1 value) {
I_ U4 binary_as_str8_eval_len(Slice_U1 data) { return data.len * 8; }
#define jump_lt(a,b,label) if (a < b) goto label
I_ Str8 binary_as_str8(Slice_U1 data, FArena* str8_mem) { Str8 result = {0};
U4 req_len = data.len * 8; jump_lt(str8_mem->capacity,req_len, jret);
@@ -56,22 +67,24 @@ I_ Str8 binary_as_str8(Slice_U1 data, FArena* str8_mem) { Str8 result = {0};
jret: return result;
}
enum {
Scratchpad_Len = kilo(1),
Scratchpad_Len = kilo(16),
FileRam_Len = kilo(16),
};
typedef Struct_(SMemory) {
U1 Scratchpad [Scratchpad_Len];
U1 FileRam [FileRam_Len];
U1 decode_mem[kilo(64)];
UTF8 text_mem [kilo(16)];
};
global SMemory smem;
#define path_course_content "./course_content/perfaware/"
#define path_part1 path_course_content "part1/"
CLANG_OPTIMIZE_DISABLE
typedef Slice_(X8616_DecodedInstruction);
int main()
{
FArena scratch = farena_make(slice_ut_arr(smem.Scratchpad));
@@ -80,8 +93,35 @@ int main()
Str8 path_listing_0037_single_register_mov = slit8(path_part1 "listing_0037_single_register_mov");
Str8 path_listing_0037_single_register_mov_asm = slit8(path_part1 "listing_0037_single_register_mov.asm");
Slice_U1 data = data_from_file_path(& file_arena, path_listing_0037_single_register_mov, & scratch);
farena_reset(& scratch);
FArena decode_arena = farena_make(slice_ut_arr(smem.decode_mem));
Slice_X8616_DecodedInstruction decoded = farena_push_array(& decode_arena, X8616_DecodedInstruction, data.len);
X8616_DecodeInfo info = x8616_decode_(
.source = data.ptr,
.source_size = data.len,
.instructions = decoded.ptr,
.instruction_capacity = decoded.len,
.info_arena = & decode_arena,
);
if (info.source_consumed != data.len || info.instruction_count == 0 || info.msgs.error_count || info.msgs.dropped_count) {
ms_exit_process(10);
return 10;
}
X8616_SerializeInfo text = x8616_serialize_instructions((X8616_SerializeRequest){
.instructions = decoded.ptr,
.instruction_count = info.instruction_count,
.output = slice_ut_arr(smem.text_mem),
.scratch = slice_ut_arr(smem.Scratchpad),
});
if (text.status != x8616_serialize_ok || text.instructions_written != info.instruction_count) {
ms_exit_process(13);
return 13;
}
Str8 listing_text = text.text;
(void)listing_text;
ms_exit_process(0);
return 0;
}
CLANG_OPTIMIZE_ENABLE
perfaware.proj
+7 -2
View File
@@ -3,7 +3,12 @@
target:
{
executable: "build/sim_8086.exe"
working_directory: ""
enabled: 1
working_directory: "../perfaware"
label: "Sim 8086"
enabled: 1
}
target:
{
executable: "build/decoder_table_generator.meta.exe"
working_directory: "../perfaware"
}
scripts/build.ps1
+9 -2
View File
@@ -128,6 +128,7 @@ $f_ms_extensions = '-fms-extensions' # Allow MSVC language extension
$f_ms_compatibility = '-fms-compatibility'
$f_ms_runtime_lib_none = '-fno-ms-runtime'
$f_preprocess_non_integrated = '-no-integrated-cpp'
$f_stack_probes_disabled = '-mno-stack-arg-probe' # Requires the fully committed stack in link-modules
$f_stack_protector = '-fstack-protector'
$f_stack_protector_strong = '-fstack-protector-strong'
$f_stack_protector_all = '-fstack-protector-all'
@@ -144,6 +145,9 @@ $f_sanitize_hwaddress = '-fsanitize=hwaddress'
$f_sanitize_address_safe = '-fsanitize=address,safe-stack'
$f_sanitize_cfi = '-fsanitize=cfi'
# --- Compiler Flags: Hardware Architecture ---
$f_arch_haswell = '-march=haswell'
# --- Compiler Flags: Environment / Target ---
$f_no_stdlib = '-nostdlib'
$f_freestanding = '-ffreestanding'
@@ -285,10 +289,12 @@ function compile-unit { param(
$compile_args = @()
$compile_args += $f_std_c11
$compile_args += $f_all_c
$compile_args += $f_arch_haswell
$compile_args += $f_ms_ex
$compile_args += $f_wall
$compile_args += $f_wno_attributes
$compile_args += $f_exceptions_disabled
$compile_args += $f_stack_probes_disabled
$compile_args += $f_diagnostics_absolute
$compile_args += $f_debug
foreach ($p in $include_paths) {
@@ -321,6 +327,7 @@ function link-modules { param(
$link_args += $f_link_win_no_incremental
$link_args += ($f_link_win_path_output + $module)
$link_args += $f_link_win_subsystem_console
$link_args += ($f_link_win_stack + '262144,262144') # 256 KiB reserved
$link_args += $f_link_win_debug
$link_args += ($f_link_win_entry + 'main')
$link_args += ($f_link_win_pdb + $pdb)
@@ -384,7 +391,7 @@ function build-8086_decoder_table {
dump-disassembly $module_c $exe
}
build-8086_decoder_table
# build-8086_decoder_table
function build-part_1 {
# The base lib uses subdir-prefixed includes (e.g. "duffle/dsl.h"),
@@ -411,4 +418,4 @@ function build-part_1 {
dump-disassembly $module_c $exe
}
# build-part_1
build-part_1