kit

config_stubs.c (18021B)

---

 #include <kit/archive.h>
 #include <kit/config.h>
 #include <kit/dbg.h>
 #include <kit/disasm.h>
 #include <kit/dwarf.h>
 #include <kit/emu.h>
 #include <kit/jit.h>
 #include <kit/link.h>
 
 #include "core/core.h"
 #include "debug/debug.h"
 #include "link/link.h"
 
 #if !KIT_AR_ENABLED
 KitStatus kit_ar_write(KitWriter* out, const KitArInput* members,
                        uint32_t nmembers, const KitArWriteOptions* opts) {
   (void)out;
   (void)members;
   (void)nmembers;
   (void)opts;
   return KIT_UNSUPPORTED;
 }
 
 KitStatus kit_ar_list(const KitSlice* archive, KitWriter* out) {
   (void)archive;
   (void)out;
   return KIT_UNSUPPORTED;
 }
 
 KitStatus kit_ar_iter_new(const KitContext* ctx, const KitSlice* archive,
                           KitArIter** out) {
   (void)ctx;
   (void)archive;
   if (out) *out = NULL;
   return KIT_UNSUPPORTED;
 }
 
 KitIterResult kit_ar_iter_next(KitArIter* it, KitArMember* out) {
   (void)it;
   (void)out;
   return KIT_ITER_ERROR;
 }
 
 void kit_ar_iter_free(KitArIter* it) { (void)it; }
 #endif
 
 #if !KIT_DISASM_ENABLED
 KitStatus kit_disasm_iter_new(const KitDisasmContext* dctx,
                               const uint8_t* bytes, size_t len, uint64_t vaddr,
                               const KitObjFile* annotations,
                               KitDisasmIter** out) {
   (void)dctx;
   (void)bytes;
   (void)len;
   (void)vaddr;
   (void)annotations;
   if (out) *out = NULL;
   return KIT_UNSUPPORTED;
 }
 
 KitIterResult kit_disasm_iter_next(KitDisasmIter* it, KitInsn* out) {
   (void)it;
   (void)out;
   return KIT_ITER_ERROR;
 }
 
 void kit_disasm_iter_free(KitDisasmIter* it) { (void)it; }
 
 KitStatus kit_disasm_obj(const KitContext* ctx, const KitObjFile* obj,
                          KitWriter* out) {
   (void)ctx;
   (void)obj;
   (void)out;
   return KIT_UNSUPPORTED;
 }
 
 KitStatus kit_disasm_obj_bytes(const KitContext* ctx, const KitSlice* bytes,
                                KitWriter* out) {
   (void)ctx;
   (void)bytes;
   (void)out;
   return KIT_UNSUPPORTED;
 }
 #endif
 
 #if !KIT_DWARF_ENABLED
 Debug* debug_new(Compiler* c, ObjBuilder* ob) {
   (void)c;
   (void)ob;
   return NULL;
 }
 
 void debug_free(Debug* d) { (void)d; }
 u32 debug_file(Debug* d, u32 source_file_id) {
   (void)d;
   (void)source_file_id;
   return 0;
 }
 
 DebugTypeId debug_type_base(Debug* d, Sym name, DebugBaseEncoding enc,
                             u32 byte_size) {
   (void)d;
   (void)name;
   (void)enc;
   (void)byte_size;
   return DEBUG_TYPE_NONE;
 }
 
 DebugTypeId debug_type_void(Debug* d) {
   (void)d;
   return DEBUG_TYPE_NONE;
 }
 
 DebugTypeId debug_type_ptr(Debug* d, DebugTypeId pointee) {
   (void)d;
   (void)pointee;
   return DEBUG_TYPE_NONE;
 }
 
 DebugTypeId debug_type_array(Debug* d, DebugTypeId elem, u32 count) {
   (void)d;
   (void)elem;
   (void)count;
   return DEBUG_TYPE_NONE;
 }
 
 DebugTypeId debug_type_const(Debug* d, DebugTypeId base) {
   (void)d;
   (void)base;
   return DEBUG_TYPE_NONE;
 }
 
 DebugTypeId debug_type_volatile(Debug* d, DebugTypeId base) {
   (void)d;
   (void)base;
   return DEBUG_TYPE_NONE;
 }
 
 DebugTypeId debug_type_restrict(Debug* d, DebugTypeId base) {
   (void)d;
   (void)base;
   return DEBUG_TYPE_NONE;
 }
 
 DebugTypeId debug_type_typedef(Debug* d, Sym name, DebugTypeId base) {
   (void)d;
   (void)name;
   (void)base;
   return DEBUG_TYPE_NONE;
 }
 
 DebugTypeId debug_type_func(Debug* d, DebugTypeId ret,
                             const DebugTypeId* params, u32 nparams,
                             int variadic) {
   (void)d;
   (void)ret;
   (void)params;
   (void)nparams;
   (void)variadic;
   return DEBUG_TYPE_NONE;
 }
 
 DebugTypeBuilder* debug_type_record_begin(Debug* d, Sym tag, int is_union,
                                           u32 byte_size, u32 align) {
   (void)d;
   (void)tag;
   (void)is_union;
   (void)byte_size;
   (void)align;
   return NULL;
 }
 
 void debug_type_record_field(DebugTypeBuilder* b, Sym name, DebugTypeId type,
                              u32 byte_offset) {
   (void)b;
   (void)name;
   (void)type;
   (void)byte_offset;
 }
 
 void debug_type_record_bitfield(DebugTypeBuilder* b, Sym name, DebugTypeId type,
                                 u32 byte_offset, u16 bit_offset,
                                 u16 bit_width) {
   (void)b;
   (void)name;
   (void)type;
   (void)byte_offset;
   (void)bit_offset;
   (void)bit_width;
 }
 
 DebugTypeId debug_type_record_end(DebugTypeBuilder* b) {
   (void)b;
   return DEBUG_TYPE_NONE;
 }
 
 DebugEnumBuilder* debug_type_enum_begin(Debug* d, Sym tag, DebugTypeId base) {
   (void)d;
   (void)tag;
   (void)base;
   return NULL;
 }
 
 void debug_type_enum_value(DebugEnumBuilder* b, Sym name, i64 value) {
   (void)b;
   (void)name;
   (void)value;
 }
 
 DebugTypeId debug_type_enum_end(DebugEnumBuilder* b) {
   (void)b;
   return DEBUG_TYPE_NONE;
 }
 
 void debug_func_begin(Debug* d, ObjSymId sym, DebugTypeId fn_type,
                       SrcLoc decl) {
   (void)d;
   (void)sym;
   (void)fn_type;
   (void)decl;
 }
 
 void debug_func_select(Debug* d, ObjSymId sym) {
   (void)d;
   (void)sym;
 }
 
 void debug_func_pc_range(Debug* d, ObjSecId text_section_id, u32 begin_ofs,
                          u32 end_ofs) {
   (void)d;
   (void)text_section_id;
   (void)begin_ofs;
   (void)end_ofs;
 }
 
 void debug_func_end(Debug* d) { (void)d; }
 
 void debug_prune_removed_funcs(Debug* d) { (void)d; }
 
 void debug_scope_begin(Debug* d, SrcLoc loc) {
   (void)d;
   (void)loc;
 }
 void debug_scope_end(Debug* d, SrcLoc loc) {
   (void)d;
   (void)loc;
 }
 
 void debug_param(Debug* d, Sym name, DebugTypeId type, SrcLoc loc, u32 idx,
                  DebugVarLoc var_loc) {
   (void)d;
   (void)name;
   (void)type;
   (void)loc;
   (void)idx;
   (void)var_loc;
 }
 
 void debug_local(Debug* d, Sym name, DebugTypeId type, SrcLoc loc,
                  DebugVarLoc var_loc) {
   (void)d;
   (void)name;
   (void)type;
   (void)loc;
   (void)var_loc;
 }
 
 void debug_line(Debug* d, ObjSecId text_section_id, u32 text_offset, SrcLoc loc,
                 int is_stmt) {
   (void)d;
   (void)text_section_id;
   (void)text_offset;
   (void)loc;
   (void)is_stmt;
 }
 
 void debug_set_pending_loc(Debug* d, SrcLoc loc) {
   (void)d;
   (void)loc;
 }
 
 void debug_emit_row(Debug* d, ObjSecId text_section_id, u32 text_offset,
                     SrcLoc loc) {
   (void)d;
   (void)text_section_id;
   (void)text_offset;
   (void)loc;
 }
 
 u32 debug_loclist_new(Debug* d) {
   (void)d;
   return 0;
 }
 
 void debug_loclist_add(Debug* d, u32 id, u32 begin_pc, u32 end_pc,
                        DebugVarLoc loc) {
   (void)d;
   (void)id;
   (void)begin_pc;
   (void)end_pc;
   (void)loc;
 }
 
 void debug_emit(Debug* d) { (void)d; }
 
 KitStatus kit_dwarf_open(const KitContext* ctx, const KitObjFile* obj,
                          KitDebugInfo** out) {
   (void)ctx;
   (void)obj;
   if (out) *out = NULL;
   return KIT_UNSUPPORTED;
 }
 
 void kit_dwarf_free(KitDebugInfo* d) { (void)d; }
 
 KitStatus kit_dwarf_addr_to_line(KitDebugInfo* d, uint64_t pc,
                                  KitSlice* file_out, uint32_t* line_out,
                                  uint32_t* col_out) {
   (void)d;
   (void)pc;
   (void)file_out;
   (void)line_out;
   (void)col_out;
   return KIT_UNSUPPORTED;
 }
 
 KitStatus kit_dwarf_line_to_addr(KitDebugInfo* d, KitSlice file, uint32_t line,
                                  uint64_t* pc_out) {
   (void)d;
   (void)file;
   (void)line;
   (void)pc_out;
   return KIT_UNSUPPORTED;
 }
 
 KitStatus kit_dwarf_line_to_addr_all(KitDebugInfo* d, KitSlice file,
                                      uint32_t line, KitDwarfLineMatch* out,
                                      uint32_t cap, uint32_t* n_out) {
   (void)d;
   (void)file;
   (void)line;
   (void)out;
   (void)cap;
   if (n_out) *n_out = 0;
   return KIT_UNSUPPORTED;
 }
 
 KitStatus kit_dwarf_func_at(KitDebugInfo* d, uint64_t pc, KitSlice* name_out,
                             uint64_t* low_pc_out, uint64_t* high_pc_out) {
   (void)d;
   (void)pc;
   (void)name_out;
   (void)low_pc_out;
   (void)high_pc_out;
   return KIT_UNSUPPORTED;
 }
 
 KitStatus kit_dwarf_subprogram_at(KitDebugInfo* d, uint64_t pc,
                                   KitDwarfSubprogram* out) {
   (void)d;
   (void)pc;
   (void)out;
   return KIT_UNSUPPORTED;
 }
 
 KitStatus kit_dwarf_subprogram_named(KitDebugInfo* d, KitSlice name,
                                      KitDwarfSubprogram* out) {
   (void)d;
   (void)name;
   (void)out;
   return KIT_UNSUPPORTED;
 }
 
 KitStatus kit_dwarf_unwind_step(KitDebugInfo* d, KitUnwindFrame* frame) {
   (void)d;
   (void)frame;
   return KIT_UNSUPPORTED;
 }
 
 KitDwarfTypeInfo kit_dwarf_type_info(const KitDwarfType* t) {
   KitDwarfTypeInfo info;
   (void)t;
   info.kind = KIT_DT_VOID;
   info.byte_size = 0;
   info.name = KIT_SLICE_NULL;
   info.element_count = 0;
   info.inner = NULL;
   return info;
 }
 
 KitStatus kit_dwarf_field_iter_new(KitDebugInfo* d, const KitDwarfType* t,
                                    KitDwarfFieldIter** out) {
   (void)d;
   (void)t;
   if (out) *out = NULL;
   return KIT_UNSUPPORTED;
 }
 
 KitIterResult kit_dwarf_field_iter_next(KitDwarfFieldIter* it,
                                         KitDwarfField* out) {
   (void)it;
   (void)out;
   return KIT_ITER_ERROR;
 }
 
 void kit_dwarf_field_iter_free(KitDwarfFieldIter* it) { (void)it; }
 
 KitStatus kit_dwarf_enum_iter_new(KitDebugInfo* d, const KitDwarfType* t,
                                   KitDwarfEnumIter** out) {
   (void)d;
   (void)t;
   if (out) *out = NULL;
   return KIT_UNSUPPORTED;
 }
 
 KitIterResult kit_dwarf_enum_iter_next(KitDwarfEnumIter* it,
                                        KitDwarfEnumVal* out) {
   (void)it;
   (void)out;
   return KIT_ITER_ERROR;
 }
 
 void kit_dwarf_enum_iter_free(KitDwarfEnumIter* it) { (void)it; }
 
 KitStatus kit_dwarf_var_at(KitDebugInfo* d, uint64_t pc, KitSlice name,
                            KitDwarfVarLoc* out) {
   (void)d;
   (void)pc;
   (void)name;
   (void)out;
   return KIT_UNSUPPORTED;
 }
 
 KitStatus kit_dwarf_loc_read(KitDebugInfo* d, const KitDwarfVarLoc* loc,
                              const KitUnwindFrame* frame,
                              KitDwarfReadMemFn read_mem, void* read_user,
                              void* dst, size_t cap, size_t* read_out) {
   (void)d;
   (void)loc;
   (void)frame;
   (void)read_mem;
   (void)read_user;
   (void)dst;
   (void)cap;
   if (read_out) *read_out = 0;
   return KIT_UNSUPPORTED;
 }
 
 KitStatus kit_dwarf_vars_at_new(KitDebugInfo* d, uint64_t pc,
                                 uint32_t role_mask, KitDwarfVarIter** out) {
   (void)d;
   (void)pc;
   (void)role_mask;
   if (out) *out = NULL;
   return KIT_UNSUPPORTED;
 }
 
 KitIterResult kit_dwarf_vars_at_next(KitDwarfVarIter* it, KitDwarfVar* out) {
   (void)it;
   (void)out;
   return KIT_ITER_ERROR;
 }
 
 void kit_dwarf_vars_at_free(KitDwarfVarIter* it) { (void)it; }
 
 KitStatus kit_dwarf_param_iter_new(KitDebugInfo* d, uint64_t pc,
                                    KitDwarfParamIter** out) {
   (void)d;
   (void)pc;
   if (out) *out = NULL;
   return KIT_UNSUPPORTED;
 }
 
 KitStatus kit_dwarf_param_iter_new_named(KitDebugInfo* d, KitSlice name,
                                          KitDwarfParamIter** out) {
   (void)d;
   (void)name;
   if (out) *out = NULL;
   return KIT_UNSUPPORTED;
 }
 
 KitIterResult kit_dwarf_param_iter_next(KitDwarfParamIter* it,
                                         KitDwarfVar* out) {
   (void)it;
   (void)out;
   return KIT_ITER_ERROR;
 }
 
 void kit_dwarf_param_iter_free(KitDwarfParamIter* it) { (void)it; }
 #endif
 
 #if !KIT_LINK_ENABLED
 KitStatus kit_link_script_parse(const KitContext* ctx, KitSlice text,
                                 KitLinkScript** out) {
   (void)ctx;
   (void)text;
   if (out) *out = NULL;
   return KIT_UNSUPPORTED;
 }
 
 void kit_link_script_free(const KitContext* ctx, KitLinkScript* s) {
   (void)ctx;
   (void)s;
 }
 
 KitStatus kit_link_session_new(KitCompiler* c,
                                const KitLinkSessionOptions* opts,
                                KitLinkSession** out) {
   (void)c;
   (void)opts;
   if (out) *out = NULL;
   return KIT_UNSUPPORTED;
 }
 
 KitStatus kit_link_session_add_obj(KitLinkSession* s, KitObjBuilder* ob) {
   (void)s;
   (void)ob;
   return KIT_UNSUPPORTED;
 }
 
 KitStatus kit_link_session_add_obj_bytes(KitLinkSession* s, KitSlice name,
                                          const KitSlice* bytes) {
   (void)s;
   (void)name;
   (void)bytes;
   return KIT_UNSUPPORTED;
 }
 
 KitStatus kit_link_session_add_archive_bytes(
     KitLinkSession* s, const KitLinkArchiveInput* archive) {
   (void)s;
   (void)archive;
   return KIT_UNSUPPORTED;
 }
 
 KitStatus kit_link_session_add_dso_bytes(KitLinkSession* s, KitSlice name,
                                          const KitSlice* bytes) {
   (void)s;
   (void)name;
   (void)bytes;
   return KIT_UNSUPPORTED;
 }
 
 KitStatus kit_link_session_resolve(KitLinkSession* s) {
   (void)s;
   return KIT_UNSUPPORTED;
 }
 
 KitStatus kit_link_session_emit(KitLinkSession* s, KitWriter* out) {
   (void)s;
   (void)out;
   return KIT_UNSUPPORTED;
 }
 
 KitStatus kit_link_session_jit(KitLinkSession* s, KitJit** out_jit) {
   (void)s;
   if (out_jit) *out_jit = NULL;
   return KIT_UNSUPPORTED;
 }
 
 void kit_link_session_free(KitLinkSession* s) { (void)s; }
 #endif
 
 #if !KIT_JIT_ENABLED
 KitJit* kit_jit_from_image(LinkImage* img) {
   (void)img;
   return NULL;
 }
 
 const KitExecMem* kit_jit_image_execmem(KitJit* jit) {
   (void)jit;
   return NULL;
 }
 
 int kit_jit_image_contains(KitJit* jit, uint64_t runtime_addr) {
   (void)jit;
   (void)runtime_addr;
   return 0;
 }
 
 KitArchKind kit_jit_image_arch(KitJit* jit) {
   (void)jit;
   return KIT_ARCH_X86_64;
 }
 
 Compiler* kit_jit_compiler(KitJit* jit) {
   (void)jit;
   return NULL;
 }
 
 void kit_jit_free(KitJit* jit) { (void)jit; }
 
 void* kit_jit_lookup(KitJit* jit, KitSlice name) {
   (void)jit;
   (void)name;
   return NULL;
 }
 
 uint64_t kit_jit_generation(KitJit* jit) {
   (void)jit;
   return 0;
 }
 
 void kit_jit_run_dtors(KitJit* jit) { (void)jit; }
 
 KitStatus kit_jit_publish(KitJit* jit, const KitJitPublishOptions* opts,
                           KitJitPublishResult* result) {
   (void)jit;
   (void)opts;
   (void)result;
   return KIT_UNSUPPORTED;
 }
 
 const KitObjFile* kit_jit_view(KitJit* jit) {
   (void)jit;
   return NULL;
 }
 
 KitStatus kit_jit_addr_to_sym(KitJit* jit, uint64_t addr, KitSlice* name_out,
                               uint64_t* off_out) {
   (void)jit;
   (void)addr;
   (void)name_out;
   (void)off_out;
   return KIT_UNSUPPORTED;
 }
 
 uint64_t kit_jit_runtime_to_image(KitJit* jit, uint64_t runtime_pc) {
   (void)jit;
   (void)runtime_pc;
   return 0;
 }
 
 uint64_t kit_jit_image_to_runtime(KitJit* jit, uint64_t image_vaddr) {
   (void)jit;
   (void)image_vaddr;
   return 0;
 }
 
 KitStatus kit_jit_sym_iter_new(KitJit* jit, KitJitSymIter** out) {
   (void)jit;
   if (out) *out = NULL;
   return KIT_UNSUPPORTED;
 }
 
 KitIterResult kit_jit_sym_iter_next(KitJitSymIter* it, KitJitSym* out) {
   (void)it;
   (void)out;
   return KIT_ITER_ERROR;
 }
 
 void kit_jit_sym_iter_free(KitJitSymIter* it) { (void)it; }
 #endif
 
 #if !KIT_DBG_ENABLED
 KitStatus kit_jit_session_new(KitJit* jit, const KitDbgHost* host,
                               KitJitSession** out) {
   (void)jit;
   (void)host;
   if (out) *out = NULL;
   return KIT_UNSUPPORTED;
 }
 
 void kit_jit_session_free(KitJitSession* s) { (void)s; }
 
 KitStatus kit_jit_session_attach_dwarf(KitJitSession* s, KitDebugInfo* dwarf) {
   (void)s;
   (void)dwarf;
   return KIT_UNSUPPORTED;
 }
 
 KitStatus kit_jit_session_call(KitJitSession* s, void* entry, KitEntryKind kind,
                                int argc, char** argv, KitStopInfo* stop_out) {
   (void)s;
   (void)entry;
   (void)kind;
   (void)argc;
   (void)argv;
   (void)stop_out;
   return KIT_UNSUPPORTED;
 }
 
 KitStatus kit_jit_session_call_u64(KitJitSession* s, void* entry,
                                    const uint64_t* args, uint32_t nargs,
                                    uint64_t* ret_out, KitStopInfo* stop_out) {
   (void)s;
   (void)entry;
   (void)args;
   (void)nargs;
   (void)ret_out;
   (void)stop_out;
   return KIT_UNSUPPORTED;
 }
 
 KitStatus kit_jit_session_resume(KitJitSession* s, KitResumeMode mode,
                                  KitStopInfo* stop_out) {
   (void)s;
   (void)mode;
   (void)stop_out;
   return KIT_UNSUPPORTED;
 }
 
 KitStatus kit_jit_session_interrupt(KitJitSession* s) {
   (void)s;
   return KIT_UNSUPPORTED;
 }
 
 KitStatus kit_jit_session_read_mem(KitJitSession* s, uint64_t addr, void* dst,
                                    size_t n) {
   (void)s;
   (void)addr;
   (void)dst;
   (void)n;
   return KIT_UNSUPPORTED;
 }
 
 KitStatus kit_jit_session_write_mem(KitJitSession* s, uint64_t addr,
                                     const void* src, size_t n) {
   (void)s;
   (void)addr;
   (void)src;
   (void)n;
   return KIT_UNSUPPORTED;
 }
 
 KitStatus kit_jit_session_get_regs(KitJitSession* s, KitUnwindFrame* out) {
   (void)s;
   (void)out;
   return KIT_UNSUPPORTED;
 }
 
 KitStatus kit_jit_session_set_regs(KitJitSession* s, const KitUnwindFrame* in) {
   (void)s;
   (void)in;
   return KIT_UNSUPPORTED;
 }
 
 KitStatus kit_jit_session_breakpoint_set(KitJitSession* s, uint64_t addr,
                                          uint32_t* bp_id_out) {
   (void)s;
   (void)addr;
   (void)bp_id_out;
   return KIT_UNSUPPORTED;
 }
 
 KitStatus kit_jit_session_breakpoint_clear(KitJitSession* s, uint32_t bp_id) {
   (void)s;
   (void)bp_id;
   return KIT_UNSUPPORTED;
 }
 
 KitStatus kit_jit_session_breakpoint_set_spec(KitJitSession* s,
                                               const KitBreakpointSpec* spec,
                                               uint32_t* bp_id_out) {
   (void)s;
   (void)spec;
   (void)bp_id_out;
   return KIT_UNSUPPORTED;
 }
 #endif
 
 #if !KIT_EMU_ENABLED
 KitStatus kit_emu_run(KitCompiler* c, const KitEmuOptions* opts,
                       int* out_exit_code) {
   (void)c;
   (void)opts;
   (void)out_exit_code;
   return KIT_UNSUPPORTED;
 }
 
 KitStatus kit_emu_new(KitCompiler* c, const KitEmuOptions* opts, KitEmu** out) {
   (void)c;
   (void)opts;
   if (out) *out = NULL;
   return KIT_UNSUPPORTED;
 }
 
 KitStatus kit_emu_step(KitEmu* e, uint32_t nblocks) {
   (void)e;
   (void)nblocks;
   return KIT_UNSUPPORTED;
 }
 
 void* kit_emu_lookup(KitEmu* e, uint64_t guest_pc) {
   (void)e;
   (void)guest_pc;
   return NULL;
 }
 
 void kit_emu_free(KitEmu* e) { (void)e; }
 #endif