kit

as.c (9623B)

---

 #include <kit/compile.h>
 #include <kit/core.h>
 #include <kit/preprocess.h>
 #include <stdint.h>
 #include <string.h>
 
 #include "cflags.h"
 #include "driver.h"
 
 /* `kit as` — standalone assembler. Reads a single text source, writes a
  * relocatable object via a KitCompileSession. `.S` inputs are
  * preprocessed first via kit_cpp_preprocess; `.s` inputs are not. The
  * accepted input is a GAS subset (AT&T syntax on x86). */
 
 #define AS_TOOL "as"
 
 typedef struct AsOptions {
   int debug_info;          /* -g                       */
   const char* output_path; /* -o                       */
   const char* source;      /* single positional input  */
   KitTargetSpec target;    /* -target TRIPLE; host default */
 } AsOptions;
 
 static void as_usage(void) {
   driver_errf(AS_TOOL, "%.*s",
               KIT_SLICE_ARG(KIT_SLICE_LIT(
                   "usage: kit as [-g] [-target TRIPLE] -o out.o input.{s,S}\n"
                   "       kit as --help    for full option reference")));
 }
 
 void driver_help_as(void) {
   driver_printf(
       "%.*s",
       KIT_SLICE_ARG(KIT_SLICE_LIT(
           "kit as — standalone assembler\n"
           "\n"
           "USAGE\n"
           "  kit as [options] -o OUT.o INPUT.s\n"
           "  kit as [options] -o OUT.o INPUT.S\n"
           "  kit as [options] -o OUT.o -       (read raw assembly from stdin)\n"
           "\n"
           "DESCRIPTION\n"
           "  Reads a single text source written in a GAS subset (AT&T syntax "
           "on\n"
           "  x86, standard mnemonics on aarch64/riscv64) and writes a "
           "relocatable\n"
           "  object via the same back-end the C compiler emits to. INPUT.S is "
           "run\n"
           "  through the C preprocessor first; INPUT.s is assembled directly.\n"
           "  Exactly one positional input is required; -o is required.\n"
           "\n"
           "OPTIONS\n"
           "  -o PATH           Output object path (required)\n"
           "  -g                Emit DWARF debug info from .file/.loc "
           "directives\n"
           "  -I DIR, -IDIR     Add a user include directory for INPUT.S\n"
           "  -isystem DIR      Add a system include directory for INPUT.S\n"
           "  -D NAME[=VALUE]   Define a preprocessor macro for INPUT.S\n"
           "  -U NAME           Undefine a preprocessor macro for INPUT.S\n"
           "  -target TRIPLE    Cross-assemble target (default: host)\n"
           "  -h, --help        Show this help and exit\n"
           "  --version         Show Kit version and exit\n"
           "\n"
           "TARGETS AND INPUT LIMITS\n"
           "  Canonical assembler examples are aarch64-none-elf,\n"
           "  x86_64-linux-gnu, and riscv64-none-elf. The release also accepts\n"
           "  the corresponding hosted/freestanding triples documented by\n"
           "  `kit cc --help`. A literal `-` reads raw (non-preprocessed)\n"
           "  assembly from stdin and uses <stdin> in diagnostics. Use --\n"
           "  before a leading-dash path.\n"
           "\n"
           "EXAMPLES\n"
           "  kit as -target aarch64-none-elf -g -o start.o start.s\n"
           "  kit as -target x86_64-linux-gnu -DDEBUG=1 -I include \\\n"
           "    -o entry.o entry.S\n"
           "\n"
           "  printf '.text\\n.globl entry\\nentry:\\n  ret\\n' | \\\n"
           "    kit as -target x86_64-linux-gnu -o entry.o -\n"
           "\n"
           "EXIT CODES\n"
           "  0   success           1   assemble error           2   bad "
           "usage\n")));
 }
 
 /* Returns 0 on success; non-zero on bad args (already reported). */
 static int as_parse(int argc, char** argv, AsOptions* o, DriverEnv* env,
                     DriverCflags* cf, DriverTargetFeatures* tf) {
   int i;
   int options = 1;
 
   o->target = driver_host_target();
 
   for (i = 1; i < argc; ++i) {
     const char* a = argv[i];
     int r;
 
     if (options && driver_streq(a, "--")) {
       options = 0;
       continue;
     }
     if (!options || driver_streq(a, "-")) {
       if (o->source) {
         driver_errf(AS_TOOL, "multiple inputs not supported");
         return 1;
       }
       o->source = a;
       continue;
     }
 
     r = driver_cflags_try_consume(cf, env, AS_TOOL, argc, argv, &i);
     if (r < 0) return 1;
     if (r > 0) continue;
 
     if (driver_streq(a, "-g")) {
       o->debug_info = 1;
       continue;
     }
 
     if (driver_streq(a, "-o")) {
       if (++i >= argc) {
         driver_errf(AS_TOOL, "-o requires an argument");
         return 1;
       }
       o->output_path = argv[i];
       continue;
     }
 
     if (driver_streq(a, "-target")) {
       if (++i >= argc) {
         driver_errf(AS_TOOL, "-target requires an argument");
         return 1;
       }
       if (driver_target_from_triple(argv[i], &o->target) != 0) {
         driver_err_unknown_target(AS_TOOL, argv[i]);
         return 1;
       }
       continue;
     }
 
     {
       int tr =
           driver_target_features_try_consume(tf, env, AS_TOOL, argc, argv, &i);
       if (tr < 0) return 1;
       if (tr > 0) continue;
     }
 
     if (a[0] == '-' && a[1] != '\0') {
       driver_errf(AS_TOOL, "unknown flag: %.*s",
                   KIT_SLICE_ARG(kit_slice_cstr(a)));
       return 1;
     }
 
     if (o->source) {
       driver_errf(AS_TOOL, "multiple inputs not supported");
       return 1;
     }
     o->source = a;
   }
 
   if (!o->source) {
     driver_errf(AS_TOOL, "no input file");
     as_usage();
     return 1;
   }
   if (!o->output_path) {
     driver_errf(AS_TOOL, "-o is required");
     return 1;
   }
   return 0;
 }
 
 int driver_as(int argc, char** argv) {
   DriverEnv env;
   AsOptions o = {0};
   DriverCflags cf = {0};
   DriverTargetFeatures tf = {0};
   KitContext ctx;
   KitPreprocessOptions pp;
   KitTarget* target = NULL;
   KitCompiler* compiler = NULL;
   KitWriter* writer = NULL;
   KitWriter* pp_writer = NULL;
   KitFileData src = {0};
   uint8_t* stdin_data = NULL;
   size_t stdin_len = 0;
   KitSlice input;
   KitSlice asm_input;
   KitAsmCompileOptions copts;
   KitAsmCompileOptions zero = {0};
   const uint8_t* pp_data;
   size_t pp_len;
   int rc = 1;
   int loaded = 0;
 
   if (argc < 2 || driver_argv_wants_help(argc, argv, 1)) {
     driver_help_as();
     return 0;
   }
 
   driver_env_init(&env);
 
   if (driver_cflags_init(&cf, &env, argc) != 0 ||
       driver_target_features_init(&tf, &env, argc) != 0) {
     driver_errf(AS_TOOL, "out of memory");
     driver_target_features_fini(&tf, &env);
     driver_cflags_fini(&cf, &env);
     driver_env_fini(&env);
     return 2;
   }
 
   if (as_parse(argc, argv, &o, &env, &cf, &tf) != 0) {
     driver_target_features_fini(&tf, &env);
     driver_cflags_fini(&cf, &env);
     driver_env_fini(&env);
     return 2;
   }
   driver_cflags_fill_pp(&cf, &pp);
 
   ctx = driver_env_to_context(&env);
 
   if (driver_streq(o.source, "-")) {
     if (!driver_read_stdin(&env, &stdin_data, &stdin_len)) {
       driver_errf(AS_TOOL, "failed to read stdin");
       goto out;
     }
     input.data = stdin_data;
     input.len = stdin_len;
   } else {
     if (ctx.file_io->read_all(ctx.file_io->user, o.source, &src) != KIT_OK) {
       driver_errf(AS_TOOL, "failed to read: %.*s",
                   KIT_SLICE_ARG(kit_slice_cstr(o.source)));
       goto out;
     }
     loaded = 1;
     input.data = src.data;
     input.len = src.size;
   }
 
   if (ctx.file_io->open_writer(ctx.file_io->user, o.output_path, &writer) !=
       KIT_OK) {
     driver_errf(AS_TOOL, "failed to open output: %.*s",
                 KIT_SLICE_ARG(kit_slice_cstr(o.output_path)));
     goto out;
   }
 
   if (driver_target_new(&ctx, o.target, &tf, AS_TOOL, &target) != KIT_OK ||
       driver_compiler_new(target, &ctx, &compiler) != KIT_OK) {
     driver_errf(AS_TOOL, "failed to initialize compiler");
     goto out;
   }
 
   copts = zero;
   copts.code.debug_info = o.debug_info;
 
   asm_input = input;
 
   if (driver_has_suffix(o.source, ".S")) {
     if (kit_writer_mem(ctx.heap, &pp_writer) != KIT_OK) {
       driver_errf(AS_TOOL, "out of memory");
       goto out;
     }
     if (kit_cpp_preprocess(compiler, &pp, kit_slice_cstr(o.source), &input,
                            pp_writer) != KIT_OK)
       goto out;
     if (kit_writer_status(pp_writer) != KIT_OK) {
       driver_errf(AS_TOOL, "failed to preprocess: %.*s",
                   KIT_SLICE_ARG(kit_slice_cstr(o.source)));
       goto out;
     }
     pp_data = kit_writer_mem_bytes(pp_writer, &pp_len);
     asm_input.data = pp_data;
     asm_input.len = pp_len;
   }
 
   {
     KitCompileSessionOptions sopts;
     KitCompileSession* session = NULL;
     KitSourceInput sin;
     KitObjBuilder* ob = NULL;
     KitStatus st;
     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_cstr(driver_streq(o.source, "-") ? "<stdin>" : o.source);
     sin.bytes = asm_input;
     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) st = kit_obj_builder_emit(ob, writer);
     kit_obj_builder_free(ob);
     kit_compile_session_free(session);
     rc = st == KIT_OK ? 0 : 1;
   }
 
 out:
   if (compiler) driver_compiler_free(compiler);
   kit_target_free(target);
   if (pp_writer) kit_writer_close(pp_writer);
   if (writer) kit_writer_close(writer);
   if (loaded) ctx.file_io->release(ctx.file_io->user, &src);
   if (stdin_data) driver_free(&env, stdin_data, stdin_len);
   driver_target_features_fini(&tf, &env);
   driver_cflags_fini(&cf, &env);
   driver_env_fini(&env);
   return rc;
 }