kit

targets.c (7552B)

---

 #include "driver.h"
 
 #include <kit/target.h>
 #include <stdint.h>
 
 enum TargetsFormat {
   TARGETS_FORMAT_HUMAN,
   TARGETS_FORMAT_TRIPLE,
   TARGETS_FORMAT_TSV_V1,
 };
 
 static void targets_print_capabilities(uint32_t caps, const char* separator) {
   struct CapabilityName {
     uint32_t bit;
     const char* name;
   };
   static const struct CapabilityName names[] = {
       {KIT_TARGET_CAP_COMPILE, "compile"},
       {KIT_TARGET_CAP_ASSEMBLE, "assemble"},
       {KIT_TARGET_CAP_LINK, "link"},
       {KIT_TARGET_CAP_SHARED, "shared"},
       {KIT_TARGET_CAP_EXECUTE, "execute"},
       {KIT_TARGET_CAP_SELFHOST, "selfhost"},
   };
   unsigned i;
   int first = 1;
   for (i = 0; i < (unsigned)(sizeof names / sizeof names[0]); ++i) {
     if (!(caps & names[i].bit)) continue;
     if (!first) driver_printf("%s", separator);
     driver_printf("%s", names[i].name);
     first = 0;
   }
   if (first) driver_printf("none");
 }
 
 void driver_help_targets(void) {
   driver_printf(
       "kit targets — inspect the compiled target-profile registry\n"
       "\n"
       "USAGE\n"
       "  kit targets [--format=human|triple|tsv|tsv-v1] [SELECTOR|TRIPLE]\n"
       "\n"
       "DESCRIPTION\n"
       "  With no target argument, list every profile compiled into libkit.\n"
       "  A detail argument accepts either the stable orchestration selector or\n"
       "  its canonical -target triple. Capability and provisioning are separate:\n"
       "  provisioning describes the required local sysroot/SDK/VM/QEMU lane,\n"
       "  not a claim that it is installed on this machine.\n"
       "\n"
       "FORMATS\n"
       "  human    Readable table or key/value detail (default)\n"
       "  triple   Canonical triples, one per line\n"
       "  tsv      Versioned kit-targets-v1 TSV records\n"
       "  tsv-v1   Explicit spelling for the same stable TSV schema\n"
       "\n"
       "EXAMPLES\n"
       "  kit targets\n"
       "  kit targets --format=triple\n"
       "  kit targets --format=tsv linux-musl-aa64\n"
       "  kit targets aarch64-linux-android21\n"
       "\n"
       "EXIT CODES\n"
       "  0  Registry/list/detail emitted\n"
       "  1  No profile matches the requested selector or triple\n"
       "  2  Invalid command-line usage\n");
 }
 
 static int targets_parse_format(const char* value, enum TargetsFormat* out) {
   if (driver_streq(value, "human")) {
     *out = TARGETS_FORMAT_HUMAN;
   } else if (driver_streq(value, "triple")) {
     *out = TARGETS_FORMAT_TRIPLE;
   } else if (driver_streq(value, "tsv") || driver_streq(value, "tsv-v1")) {
     *out = TARGETS_FORMAT_TSV_V1;
   } else {
     return 1;
   }
   return 0;
 }
 
 static void targets_unknown_format(const char* value) {
   const char* const formats[] = {"human", "triple", "tsv", "tsv-v1"};
   DriverSuggestion suggestions[3];
   size_t n = driver_suggest_values(value, formats,
                                    sizeof formats / sizeof formats[0],
                                    suggestions, 3);
   if (n)
     driver_errf("targets", "unknown format: %s; did you mean '%s'?", value,
                 suggestions[0].value);
   else
     driver_errf("targets", "unknown format: %s", value);
 }
 
 static void targets_print_tsv_header(void) {
   driver_printf("# kit-targets-v1\n");
   driver_printf("selector\ttriple\tarch\tos\tobject\thosted\tlibc\t"
                 "sysroot\tcapabilities\tprovisioning\n");
 }
 
 static void targets_print_tsv(const KitTargetProfile* p) {
   driver_printf("%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t", p->selector,
                 p->triple, kit_target_arch_name(p->spec.arch),
                 kit_target_os_name(p->spec.os),
                 kit_target_obj_name(p->spec.obj),
                 p->hosted ? "hosted" : "freestanding",
                 kit_target_libc_name(p->libc),
                 kit_target_sysroot_name(p->sysroot));
   targets_print_capabilities(p->capabilities, ",");
   driver_printf("\t%s\n",
                 kit_target_provisioning_name(p->provisioning));
 }
 
 static void targets_print_human_row(const KitTargetProfile* p) {
   driver_printf("%-22s %-29s %-8s %-13s %-6s %-15s ", p->selector,
                 p->triple, kit_target_arch_name(p->spec.arch),
                 kit_target_os_name(p->spec.os),
                 kit_target_obj_name(p->spec.obj),
                 kit_target_libc_name(p->libc));
   targets_print_capabilities(p->capabilities, ",");
   driver_printf("  [%s]\n",
                 kit_target_provisioning_name(p->provisioning));
 }
 
 static void targets_print_detail(const KitTargetProfile* p) {
   driver_printf("selector:      %s\n", p->selector);
   driver_printf("triple:        %s\n", p->triple);
   driver_printf("architecture:  %s\n", kit_target_arch_name(p->spec.arch));
   driver_printf("os:            %s\n", kit_target_os_name(p->spec.os));
   driver_printf("object-format: %s\n", kit_target_obj_name(p->spec.obj));
   driver_printf("pointer:       %u-bit %s-endian\n",
                 (unsigned)p->spec.ptr_size * 8u,
                 p->spec.big_endian ? "big" : "little");
   driver_printf("hosted-model:  %s\n",
                 p->hosted ? "hosted" : "freestanding");
   driver_printf("libc-model:    %s\n", kit_target_libc_name(p->libc));
   driver_printf("sysroot-model: %s\n", kit_target_sysroot_name(p->sysroot));
   driver_printf("capabilities:  ");
   targets_print_capabilities(p->capabilities, ", ");
   driver_printf("\nprovisioning:  %s (requirement, local state not inferred)\n",
                 kit_target_provisioning_name(p->provisioning));
 }
 
 int driver_targets(int argc, char** argv) {
   enum TargetsFormat format = TARGETS_FORMAT_HUMAN;
   const char* detail = NULL;
   const KitTargetProfile* profiles;
   size_t count = 0;
   size_t i;
 
   if (driver_argv_wants_help(argc, argv, 1)) {
     driver_help_targets();
     return 0;
   }
   for (i = 1; i < (size_t)argc; ++i) {
     const char* arg = argv[i];
     if (driver_strneq(arg, "--format=", 9)) {
       if (targets_parse_format(arg + 9, &format) != 0) {
         targets_unknown_format(arg + 9);
         return 2;
       }
     } else if (driver_streq(arg, "--format")) {
       if (++i >= (size_t)argc) {
         driver_errf("targets", "--format requires an argument");
         return 2;
       }
       if (targets_parse_format(argv[i], &format) != 0) {
         targets_unknown_format(argv[i]);
         return 2;
       }
     } else if (arg[0] == '-') {
       driver_errf("targets", "unknown option: %s", arg);
       return 2;
     } else if (detail) {
       driver_errf("targets", "expected at most one selector or triple");
       return 2;
     } else {
       detail = arg;
     }
   }
 
   profiles = kit_target_profiles(&count);
   if (detail) {
     const KitTargetProfile* p = kit_target_profile_lookup(detail);
     if (!p) {
       driver_err_unknown_target("targets", detail);
       return 1;
     }
     if (format == TARGETS_FORMAT_TRIPLE) {
       driver_printf("%s\n", p->triple);
     } else if (format == TARGETS_FORMAT_TSV_V1) {
       targets_print_tsv_header();
       targets_print_tsv(p);
     } else {
       targets_print_detail(p);
     }
     return 0;
   }
 
   if (format == TARGETS_FORMAT_TSV_V1) {
     targets_print_tsv_header();
     for (i = 0; i < count; ++i) targets_print_tsv(&profiles[i]);
   } else if (format == TARGETS_FORMAT_TRIPLE) {
     for (i = 0; i < count; ++i) driver_printf("%s\n", profiles[i].triple);
   } else {
     driver_printf("SELECTOR               TRIPLE                        ARCH     "
                   "OS            OBJECT LIBC            CAPABILITIES "
                   "[PROVISION]\n");
     for (i = 0; i < count; ++i) targets_print_human_row(&profiles[i]);
   }
   return 0;
 }