kit

mc.c (10904B)

---

 #include <kit/compile.h>
 #include <kit/core.h>
 #include <kit/disasm.h>
 #include <kit/object.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
 
 #include "driver.h"
 #include "env.h"
 
 /* `kit mc` — assemble one (or a few) GAS-subset instructions and show the
  * machine-code encoding, llvm-mc --show-encoding style. The text is assembled
  * through the same back-end as `kit as`, emitted to an in-memory object, and
  * the executable section is disassembled to attribute bytes to each
  * instruction. Any relocations the assembler emits (e.g. for a branch to an
  * undefined symbol) are listed beneath. -p prints just the raw .text hex. */
 
 #define MC_TOOL "mc"
 
 typedef struct McOpts {
   KitTargetSpec target;
   int plain; /* -p: raw .text hex only */
 } McOpts;
 
 void driver_help_mc(void) {
   driver_printf(
       "%.*s",
       KIT_SLICE_ARG(KIT_SLICE_LIT(
           "kit mc — assemble an instruction and show its encoding\n"
           "\n"
           "USAGE\n"
           "  kit mc [-target TRIPLE] [-p] \"INSN ...\"\n"
           "  kit mc [-target TRIPLE] [-p] -        (read instructions from "
           "stdin)\n"
           "\n"
           "DESCRIPTION\n"
           "  Assembles the given instruction text (GAS subset: AT&T on x86,\n"
           "  standard mnemonics on aarch64/riscv64) and prints each decoded\n"
           "  instruction with its bytes as `# encoding: [0x..,..]`. "
           "Relocations\n"
           "  emitted for undefined-symbol operands are listed beneath.\n"
           "\n"
           "OPTIONS\n"
           "  -target TRIPLE   architecture to assemble for. Audited spellings:\n"
           "                   aarch64, x86_64, riscv64 (host default)\n"
           "  -p               print only the raw .text bytes as hex\n"
           "  -h, --help       show this help\n"
           "\n"
           "INPUT AND OUTPUT\n"
           "  A quoted operand may contain one or more instructions. A positional\n"
           "  - reads instruction text from stdin. Normal output shows decoded\n"
           "  instructions and byte arrays; -p emits one continuous hex line.\n"
           "  References to undefined symbols retain relocation records and print\n"
           "  them below the instruction.\n"
           "\n"
           "EXAMPLES\n"
           "  kit mc -target x86_64 'movq %rax, %rbx'\n"
           "  kit mc -target aarch64 -p 'ret'\n"
           "  kit mc -target riscv64 -p 'ret'\n"
           "  kit mc -target x86_64 'call target_symbol'\n"
           "  printf 'nop\\n' | kit mc -target x86_64 -p -\n"
           "  bytes=$(kit mc -target riscv64 -p 'ret')\n"
           "  kit disas -target riscv64 -x \"$bytes\"\n"
           "\n"
           "EXIT CODES\n"
           "  0   success           1   assemble error       2   bad usage\n")));
 }
 
 /* Locate the executable section's bytes (format-agnostic: .text / __text). */
 static int mc_text_section(const KitObjFile* f, const uint8_t** data,
                            size_t* len) {
   uint32_t n = kit_obj_nsections(f);
   uint32_t i;
   for (i = 0; i < n; ++i) {
     KitObjSecInfo sec;
     if (kit_obj_section(f, i, &sec) != KIT_OK) continue;
     if (!(sec.flags & KIT_SF_EXEC)) continue;
     if (kit_obj_section_data(f, i, data, len) != KIT_OK) continue;
     if (*data && *len) return 0;
   }
   return 1;
 }
 
 static void mc_print_plain(const uint8_t* text, size_t len) {
   size_t i;
   for (i = 0; i < len; ++i) driver_printf("%02x", text[i]);
   driver_printf("\n");
 }
 
 /* Disassemble the assembled .text and print one `mnemonic ops # encoding: [..]`
  * line per instruction. */
 static void mc_print_encoding(const KitContext* ctx, const KitTarget* target,
                               const uint8_t* text, size_t len) {
   KitDisasmContext dctx;
   KitDisasmIter* it = NULL;
   KitInsn insn;
   memset(&dctx, 0, sizeof dctx);
   dctx.target = target;
   dctx.context = *ctx;
   if (kit_disasm_iter_new(&dctx, text, len, 0, NULL, &it) != KIT_OK) {
     /* No disassembler: fall back to a single raw-hex line. */
     mc_print_plain(text, len);
     return;
   }
   while (kit_disasm_iter_next(it, &insn) == KIT_ITER_ITEM) {
     uint32_t b;
     driver_printf("%.*s", KIT_SLICE_ARG(insn.mnemonic));
     if (insn.operands.len) driver_printf(" %.*s", KIT_SLICE_ARG(insn.operands));
     driver_printf("\t# encoding: [");
     for (b = 0; b < insn.nbytes; ++b)
       driver_printf("%s0x%02x", b ? "," : "", insn.bytes[b]);
     driver_printf("]\n");
   }
   kit_disasm_iter_free(it);
 }
 
 /* List any relocations the assembler emitted (undefined-symbol operands). */
 static void mc_print_relocs(KitObjFile* f) {
   KitObjRelocIter* it = NULL;
   KitObjReloc r;
   if (kit_obj_reliter_new(f, &it) != KIT_OK) return;
   while (kit_obj_reliter_next(it, &r) == KIT_ITER_ITEM) {
     driver_printf(
         "#  reloc %.*s %.*s",
         KIT_SLICE_ARG(r.kind_name.len ? r.kind_name : KIT_SLICE_LIT("?")),
         KIT_SLICE_ARG(r.sym_name.len ? r.sym_name : KIT_SLICE_LIT("*ABS*")));
     if (r.addend)
       driver_printf("%c0x%llx", r.addend < 0 ? '-' : '+',
                     (unsigned long long)(r.addend < 0 ? -r.addend : r.addend));
     driver_printf(" @ .text+0x%llx\n", (unsigned long long)r.offset);
   }
   kit_obj_reliter_free(it);
 }
 
 /* Join the instruction operands argv[first..argc) into a newline-terminated
  * source buffer. Returns NULL on OOM. */
 static char* mc_join_source(DriverEnv* env, int first, int argc, char** argv,
                             size_t* out_len) {
   size_t total = 0;
   int i;
   char* buf;
   size_t pos = 0;
   for (i = first; i < argc; ++i) total += driver_strlen(argv[i]) + 1;
   total += 1; /* trailing NUL */
   buf = (char*)driver_alloc(env, total);
   if (!buf) return NULL;
   for (i = first; i < argc; ++i) {
     size_t n = driver_strlen(argv[i]);
     driver_memcpy(buf + pos, argv[i], n);
     pos += n;
     buf[pos++] = (i + 1 < argc) ? ' ' : '\n';
   }
   if (pos == 0) buf[pos++] = '\n';
   *out_len = pos;
   return buf;
 }
 
 int driver_mc(int argc, char** argv) {
   DriverEnv env;
   KitContext ctx;
   McOpts o;
   DriverTargetFeatures tf = {0};
   KitTarget* target = NULL;
   KitCompiler* compiler = NULL;
   KitCompileSession* session = NULL;
   KitObjBuilder* ob = NULL;
   KitWriter* mem = NULL;
   KitObjFile* objf = NULL;
   char* src = NULL;
   size_t src_len = 0;
   uint8_t* stdin_buf = NULL;
   size_t stdin_len = 0;
   int first_pos = 0; /* argv index of the first instruction token, 0 = none */
   int read_stdin = 0;
   int i, rc = 2;
 
   if (argc < 2 || driver_argv_wants_help(argc, argv, 1)) {
     driver_help_mc();
     return argc < 2 ? 2 : 0;
   }
 
   memset(&o, 0, sizeof o);
   o.target = driver_host_target();
   driver_env_init(&env);
   if (driver_target_features_init(&tf, &env, argc) != 0) {
     driver_errf(MC_TOOL, "out of memory");
     driver_target_features_fini(&tf, &env);
     driver_env_fini(&env);
     return 1;
   }
 
   for (i = 1; i < argc; ++i) {
     const char* a = argv[i];
     if (driver_streq(a, "--")) {
       if (i + 1 < argc) first_pos = i + 1;
       break;
     }
     if (driver_streq(a, "-target")) {
       if (i + 1 >= argc) {
         driver_errf(MC_TOOL, "-target requires an argument");
         goto done;
       }
       if (driver_target_from_triple(argv[++i], &o.target) != 0) {
         driver_err_unknown_target(MC_TOOL, argv[i]);
         goto done;
       }
       continue;
     }
     if (driver_streq(a, "-p")) {
       o.plain = 1;
       continue;
     }
     {
       int tr = driver_target_features_try_consume(&tf, &env, MC_TOOL, argc,
                                                   argv, &i);
       if (tr < 0) goto done;
       if (tr > 0) continue;
     }
     if (driver_streq(a, "-")) {
       read_stdin = 1;
       first_pos = i; /* marks "have input"; stdin overrides token join */
       break;
     }
     if (a[0] == '-' && a[1] != '\0') {
       driver_errf(MC_TOOL, "unknown option: %s", a);
       goto done;
     }
     first_pos = i; /* first instruction token */
     break;
   }
 
   if (read_stdin) {
     if (!driver_read_stdin(&env, &stdin_buf, &stdin_len)) {
       driver_errf(MC_TOOL, "failed to read stdin");
       rc = 1;
       goto done;
     }
     src = (char*)stdin_buf;
     src_len = stdin_len;
   } else if (first_pos != 0) {
     src = mc_join_source(&env, first_pos, argc, argv, &src_len);
     if (!src) {
       driver_errf(MC_TOOL, "out of memory");
       rc = 1;
       goto done;
     }
   } else {
     driver_errf(MC_TOOL, "no instruction given");
     goto done;
   }
 
   ctx = driver_env_to_context(&env);
   if (driver_target_new(&ctx, o.target, &tf, MC_TOOL, &target) != KIT_OK ||
       driver_compiler_new(target, &ctx, &compiler) != KIT_OK) {
     driver_errf(MC_TOOL, "failed to initialize compiler");
     rc = 1;
     goto done;
   }
 
   {
     KitCompileSessionOptions sopts;
     KitAsmCompileOptions copts;
     KitSourceInput sin;
     KitStatus st;
     const uint8_t* mem_bytes;
     size_t mem_len;
     KitSlice objslice;
     const uint8_t* text = NULL;
     size_t text_len = 0;
 
     memset(&copts, 0, sizeof copts);
     memset(&sopts, 0, sizeof sopts);
     sopts.lang = KIT_LANG_ASM;
     sopts.compile.code = copts.code;
     sopts.compile.diagnostics = copts.diagnostics;
     sopts.compile.language_options = &copts;
     memset(&sin, 0, sizeof sin);
     sin.name = KIT_SLICE_LIT("<mc>");
     sin.bytes.data = (const uint8_t*)src;
     sin.bytes.len = src_len;
     sin.lang = KIT_LANG_ASM;
 
     st = kit_compile_session_new(compiler, &sopts, &session);
     if (st == KIT_OK) st = kit_compile_session_compile(session, &sin, &ob);
     if (st != KIT_OK) {
       /* diagnostics already went to stderr via the diag sink */
       rc = 1;
       goto done;
     }
     if (kit_writer_mem(ctx.heap, &mem) != KIT_OK) {
       driver_errf(MC_TOOL, "out of memory");
       rc = 1;
       goto done;
     }
     if (kit_obj_builder_emit(ob, mem) != KIT_OK) {
       driver_errf(MC_TOOL, "failed to emit object");
       rc = 1;
       goto done;
     }
     mem_bytes = kit_writer_mem_bytes(mem, &mem_len);
     objslice.data = mem_bytes;
     objslice.len = mem_len;
     if (kit_obj_open(&ctx, KIT_SLICE_LIT("<mc>"), &objslice, &objf) != KIT_OK) {
       driver_errf(MC_TOOL, "failed to read assembled object");
       rc = 1;
       goto done;
     }
     if (mc_text_section(objf, &text, &text_len) != 0) {
       driver_errf(MC_TOOL, "assembled object has no code");
       rc = 1;
       goto done;
     }
     if (o.plain)
       mc_print_plain(text, text_len);
     else
       mc_print_encoding(&ctx, target, text, text_len);
     mc_print_relocs(objf);
     rc = 0;
   }
 
 done:
   if (objf) kit_obj_free(objf);
   if (mem) kit_writer_close(mem);
   if (ob) kit_obj_builder_free(ob);
   if (session) kit_compile_session_free(session);
   if (compiler) driver_compiler_free(compiler);
   kit_target_free(target);
   if (stdin_buf) driver_free(&env, stdin_buf, stdin_len);
   if (src && !read_stdin) driver_free(&env, src, src_len);
   driver_target_features_fini(&tf, &env);
   driver_env_fini(&env);
   return rc;
 }