kit

registry.c (5272B)

---

 /* CGBackend / ArchImpl registry.
  *
  * This file is the *only* place in the codebase that checks
  * KIT_ARCH_*_ENABLED. Everything downstream operates on the registry's
  * outputs — `const CGBackend*` for session-level code emission, and
  * `const ArchImpl*` for arch-specific metadata (DWARF, debugger hooks,
  * register file, etc.).
  *
  * Conceptually:
  *   - A CGBackend is "something that can build a CgTarget from a Compiler +
  *     ObjBuilder + KitCodeOptions". Machine-code arches and c_target both
  *     qualify.
  *   - An ArchImpl is a CGBackend plus the machine-code metadata (its first
  *     field is a CGBackend, so `(const CGBackend*)&arch_impl_x` is valid).
  *   - c_target has no ArchImpl — it is a CGBackend and nothing more.
  */
 
 #include "arch/arch.h"
 #include "kit/config.h"
 
 #if KIT_ARCH_AA64_ENABLED
 extern const ArchImpl arch_impl_aa64;
 #endif
 #if KIT_ARCH_RV32_ENABLED
 extern const ArchImpl arch_impl_rv32;
 #endif
 #if KIT_ARCH_RV64_ENABLED
 extern const ArchImpl arch_impl_rv64;
 #endif
 #if KIT_ARCH_X64_ENABLED
 extern const ArchImpl arch_impl_x64;
 #endif
 #if KIT_ARCH_C_TARGET_ENABLED
 extern const CGBackend cg_backend_c_target;
 #endif
 extern const CGBackend cg_backend_check;
 #if KIT_ARCH_WASM_ENABLED
 extern const ArchImpl arch_impl_wasm;
 #endif
 
 /* Arch-metadata roster. The arch_lookup_* helpers iterate this list when a
  * caller needs machine-arch metadata — answers only come from backends that
  * have an ArchImpl, so c_target is intentionally absent.
  * cg_backend_for_session() picks the CGBackend (which is &impl->backend or
  * &cg_backend_c_target) without consulting this list. */
 static const ArchImpl* const arch_impls[] = {
 #if KIT_ARCH_AA64_ENABLED
     &arch_impl_aa64,
 #endif
 #if KIT_ARCH_X64_ENABLED
     &arch_impl_x64,
 #endif
 #if KIT_ARCH_RV32_ENABLED
     &arch_impl_rv32,
 #endif
 #if KIT_ARCH_RV64_ENABLED
     &arch_impl_rv64,
 #endif
 #if KIT_ARCH_WASM_ENABLED
     &arch_impl_wasm,
 #endif
 #if !KIT_ARCH_AA64_ENABLED && !KIT_ARCH_X64_ENABLED && \
     !KIT_ARCH_RV32_ENABLED && !KIT_ARCH_RV64_ENABLED && !KIT_ARCH_WASM_ENABLED
     NULL,
 #endif
 };
 
 static u32 arch_impls_count(void) {
   return (u32)(sizeof arch_impls / sizeof arch_impls[0]);
 }
 
 const char* arch_kind_name(KitArchKind arch) {
   switch (arch) {
     case KIT_ARCH_X86_32:
       return "x86_32";
     case KIT_ARCH_X86_64:
       return "x86_64";
     case KIT_ARCH_ARM_32:
       return "arm32";
     case KIT_ARCH_ARM_64:
       return "aarch64";
     case KIT_ARCH_RV32:
       return "riscv32";
     case KIT_ARCH_RV64:
       return "riscv64";
     case KIT_ARCH_WASM:
       return "wasm";
   }
   return "unknown";
 }
 
 const ArchImpl* arch_lookup(KitArchKind arch) {
   for (u32 i = 0; i < arch_impls_count(); ++i) {
     if (arch_impls[i] && arch_impls[i]->kind == arch) return arch_impls[i];
   }
   return NULL;
 }
 
 const ArchImpl* arch_for_compiler(const Compiler* c) {
   if (!c) return NULL;
   return arch_lookup(c->target.arch);
 }
 
 int arch_target_feature_index(const ArchImpl* a, KitSlice name, u32* idx_out) {
   u32 i;
   if (!a || !name.s) return 0;
   for (i = 0; i < a->ntarget_features; ++i) {
     if (kit_slice_eq_cstr(name, a->target_features[i].name)) {
       if (idx_out) *idx_out = i;
       return 1;
     }
   }
   return 0;
 }
 
 void arch_target_feature_defaults(const ArchImpl* a, const Target* target,
                                   u64* words, u32 nwords) {
   if (!a || !words || nwords == 0) return;
   if (a->target_feature_defaults) {
     a->target_feature_defaults(target, words, nwords);
   }
 }
 
 KitStatus arch_target_feature_apply_isa(const ArchImpl* a, const Target* target,
                                         KitSlice isa, u64* words, u32 nwords) {
   if (!a || !isa.s || isa.len == 0) return KIT_OK;
   if (!words && nwords != 0) return KIT_INVALID;
   if (!a->target_feature_apply_isa) return KIT_UNSUPPORTED;
   return a->target_feature_apply_isa(target, isa, words, nwords);
 }
 
 int arch_reloc_operand(const Compiler* c, u16 reloc_kind,
                        ArchRelocOperand* out) {
   const ArchImpl* a = arch_for_compiler(c);
   if (!a || !a->asm_ops || !a->asm_ops->reloc_operand) return 0;
   return a->asm_ops->reloc_operand(reloc_kind, c->target.obj, out);
 }
 
 int arch_is_local_branch(const Compiler* c, KitSlice mnemonic) {
   const ArchImpl* a = arch_for_compiler(c);
   if (!a || !a->asm_ops || !a->asm_ops->is_local_branch) return 0;
   return a->asm_ops->is_local_branch(mnemonic);
 }
 
 int arch_reloc_call_pair(const Compiler* c, u16 reloc_kind,
                          KitSlice pair_mnemonic, KitSlice pair_ops,
                          const char** mnemonic_out) {
   const ArchImpl* a = arch_for_compiler(c);
   if (!a || !a->asm_ops || !a->asm_ops->reloc_call_pair) return 0;
   return a->asm_ops->reloc_call_pair(reloc_kind, pair_mnemonic, pair_ops,
                                      mnemonic_out);
 }
 
 const CGBackend* cg_backend_for_session(const Compiler* c,
                                         const KitCodeOptions* opts) {
   if (opts && opts->check_only) {
     return &cg_backend_check;
   }
   if (opts && opts->emit_c_source) {
 #if KIT_ARCH_C_TARGET_ENABLED
     return &cg_backend_c_target;
 #else
     return NULL;
 #endif
   }
   {
     const ArchImpl* impl = arch_for_compiler(c);
     return impl ? &impl->backend : NULL;
   }
 }