config_stubs.c (36390B)
1 #include <kit/archive.h> 2 #include <kit/build_coord.h> 3 #include <kit/config.h> 4 #include <kit/dbg.h> 5 #include <kit/disasm.h> 6 #include <kit/dwarf.h> 7 #include <kit/emu.h> 8 #include <kit/gram.h> 9 #include <kit/gram_unicode.h> 10 #include <kit/image.h> 11 #include <kit/jit.h> 12 #include <kit/link.h> 13 14 #include "core/core.h" 15 #include "debug/debug.h" 16 #include "link/link.h" 17 18 #if !KIT_BUILD_ENABLED 19 KitStatus kit_build_coordinator_open(const KitContext* ctx, 20 const KitBuildHost* host, 21 KitSlice store_root, 22 const KitBuildOptions* opts, 23 KitBuildCoordinator** out) { 24 (void)ctx; 25 (void)host; 26 (void)store_root; 27 (void)opts; 28 if (out) *out = NULL; 29 return KIT_UNSUPPORTED; 30 } 31 32 void kit_build_coordinator_close(KitBuildCoordinator* c) { (void)c; } 33 34 KitStatus kit_build(KitBuildCoordinator* c, const KitBuildRequest* req, 35 KitBuildResult* out) { 36 (void)c; 37 (void)req; 38 (void)out; 39 return KIT_UNSUPPORTED; 40 } 41 42 KitStatus kit_build_test(KitBuildCoordinator* c, const KitBuildRequest* req, 43 KitBuildTestResult* out) { 44 (void)c; 45 (void)req; 46 (void)out; 47 return KIT_UNSUPPORTED; 48 } 49 50 void kit_build_stats(const KitBuildCoordinator* c, KitBuildStats* out) { 51 (void)c; 52 if (out) { 53 out->deep_hits = 0; 54 out->shallow_hits = 0; 55 out->recipes_run = 0; 56 out->materialize_misses = 0; 57 out->object_fetches = 0; 58 out->trace_pulls = 0; 59 out->test_runs = 0; 60 out->test_cache_hits = 0; 61 out->test_failures = 0; 62 } 63 } 64 65 KitStatus kit_build_traces_export(KitBuildCoordinator* c, 66 const KitBuildExportOptions* opts) { 67 (void)c; 68 (void)opts; 69 return KIT_UNSUPPORTED; 70 } 71 72 KitStatus kit_build_traces_import(KitBuildCoordinator* c, 73 const KitBuildImportOptions* opts, 74 KitBuildImportResult* result) { 75 (void)c; 76 (void)opts; 77 (void)result; 78 return KIT_UNSUPPORTED; 79 } 80 81 KitStatus kit_build_client_open(const KitContext* ctx, 82 const KitBuildTransport* transport, 83 KitBuildClient** out) { 84 (void)ctx; 85 (void)transport; 86 if (out) *out = NULL; 87 return KIT_UNSUPPORTED; 88 } 89 90 void kit_build_client_close(KitBuildClient* c) { (void)c; } 91 92 KitStatus kit_build_client_config_get(KitBuildClient* c, KitSlice key, 93 KitSlice default_value, int has_default, 94 KitSlice* value, int* present) { 95 (void)c; 96 (void)key; 97 (void)default_value; 98 (void)has_default; 99 if (value) *value = KIT_SLICE_NULL; 100 if (present) *present = 0; 101 return KIT_UNSUPPORTED; 102 } 103 104 KitStatus kit_build_client_source(KitBuildClient* c, KitSlice path, 105 uint8_t blob[KIT_BUILD_HASH_LEN], 106 KitSlice* realpath) { 107 (void)c; 108 (void)path; 109 if (blob) { 110 size_t i; 111 for (i = 0; i < KIT_BUILD_HASH_LEN; ++i) blob[i] = 0; 112 } 113 if (realpath) *realpath = KIT_SLICE_NULL; 114 return KIT_UNSUPPORTED; 115 } 116 117 KitStatus kit_build_client_glob(KitBuildClient* c, KitSlice pattern, 118 KitBuildGlobFn cb, void* cb_user) { 119 (void)c; 120 (void)pattern; 121 (void)cb; 122 (void)cb_user; 123 return KIT_UNSUPPORTED; 124 } 125 126 KitStatus kit_build_client_need(KitBuildClient* c, 127 const KitBuildRequest* req, 128 KitBuildResult* out) { 129 (void)c; 130 (void)req; 131 (void)out; 132 return KIT_UNSUPPORTED; 133 } 134 135 KitStatus kit_build_client_need_submit(KitBuildClient* c, 136 const KitBuildRequest* req, 137 KitBuildNeedToken* out_token) { 138 (void)c; 139 (void)req; 140 if (out_token) out_token->id = 0; 141 return KIT_UNSUPPORTED; 142 } 143 144 KitStatus kit_build_client_need_await(KitBuildClient* c, 145 KitBuildNeedToken token, 146 KitBuildResult* out) { 147 (void)c; 148 (void)token; 149 (void)out; 150 return KIT_UNSUPPORTED; 151 } 152 #endif 153 154 #if !KIT_AR_ENABLED 155 KitStatus kit_ar_write(KitWriter* out, const KitArInput* members, 156 uint32_t nmembers, const KitArWriteOptions* opts) { 157 (void)out; 158 (void)members; 159 (void)nmembers; 160 (void)opts; 161 return KIT_UNSUPPORTED; 162 } 163 164 KitStatus kit_ar_list(const KitSlice* archive, KitWriter* out) { 165 (void)archive; 166 (void)out; 167 return KIT_UNSUPPORTED; 168 } 169 170 KitStatus kit_ar_iter_new(const KitContext* ctx, const KitSlice* archive, 171 KitArIter** out) { 172 (void)ctx; 173 (void)archive; 174 if (out) *out = NULL; 175 return KIT_UNSUPPORTED; 176 } 177 178 KitIterResult kit_ar_iter_next(KitArIter* it, KitArMember* out) { 179 (void)it; 180 (void)out; 181 return KIT_ITER_ERROR; 182 } 183 184 void kit_ar_iter_free(KitArIter* it) { (void)it; } 185 #endif 186 187 #if !KIT_DISASM_ENABLED 188 KitStatus kit_disasm_iter_new(const KitDisasmContext* dctx, 189 const uint8_t* bytes, size_t len, uint64_t vaddr, 190 const KitObjFile* annotations, 191 KitDisasmIter** out) { 192 (void)dctx; 193 (void)bytes; 194 (void)len; 195 (void)vaddr; 196 (void)annotations; 197 if (out) *out = NULL; 198 return KIT_UNSUPPORTED; 199 } 200 201 KitIterResult kit_disasm_iter_next(KitDisasmIter* it, KitInsn* out) { 202 (void)it; 203 (void)out; 204 return KIT_ITER_ERROR; 205 } 206 207 void kit_disasm_iter_free(KitDisasmIter* it) { (void)it; } 208 209 KitStatus kit_disasm_obj(const KitContext* ctx, const KitObjFile* obj, 210 KitWriter* out) { 211 (void)ctx; 212 (void)obj; 213 (void)out; 214 return KIT_UNSUPPORTED; 215 } 216 217 KitStatus kit_disasm_obj_bytes(const KitContext* ctx, const KitSlice* bytes, 218 KitWriter* out) { 219 (void)ctx; 220 (void)bytes; 221 (void)out; 222 return KIT_UNSUPPORTED; 223 } 224 #endif 225 226 #if !KIT_IMAGE_ENABLED 227 KitStatus kit_image_emit(const KitContext* ctx, KitObjFile* obj, 228 const KitSlice* object_bytes, 229 const KitImageOptions* opts, KitWriter* out, 230 KitImageReport* report_out) { 231 (void)ctx; 232 (void)obj; 233 (void)object_bytes; 234 (void)opts; 235 (void)out; 236 (void)report_out; 237 return KIT_UNSUPPORTED; 238 } 239 240 KitStatus kit_image_emit_bytes(const KitContext* ctx, KitSlice name, 241 const KitSlice* object_bytes, 242 const KitImageOptions* opts, KitWriter* out, 243 KitImageReport* report_out) { 244 (void)ctx; 245 (void)name; 246 (void)object_bytes; 247 (void)opts; 248 (void)out; 249 (void)report_out; 250 return KIT_UNSUPPORTED; 251 } 252 253 bool kit_image_segment_selected(KitObjFmt fmt, const KitObjSegInfo* seg, 254 const KitImageOptions* opts) { 255 (void)fmt; 256 (void)seg; 257 (void)opts; 258 return false; 259 } 260 #endif 261 262 #if !KIT_DWARF_ENABLED 263 Debug* debug_new(Compiler* c, ObjBuilder* ob) { 264 (void)c; 265 (void)ob; 266 return NULL; 267 } 268 269 void debug_free(Debug* d) { (void)d; } 270 u32 debug_file(Debug* d, u32 source_file_id) { 271 (void)d; 272 (void)source_file_id; 273 return 0; 274 } 275 276 DebugTypeId debug_type_base(Debug* d, Sym name, DebugBaseEncoding enc, 277 u32 byte_size) { 278 (void)d; 279 (void)name; 280 (void)enc; 281 (void)byte_size; 282 return DEBUG_TYPE_NONE; 283 } 284 285 DebugTypeId debug_type_void(Debug* d) { 286 (void)d; 287 return DEBUG_TYPE_NONE; 288 } 289 290 DebugTypeId debug_type_ptr(Debug* d, DebugTypeId pointee) { 291 (void)d; 292 (void)pointee; 293 return DEBUG_TYPE_NONE; 294 } 295 296 DebugTypeId debug_type_array(Debug* d, DebugTypeId elem, u32 count) { 297 (void)d; 298 (void)elem; 299 (void)count; 300 return DEBUG_TYPE_NONE; 301 } 302 303 DebugTypeId debug_type_const(Debug* d, DebugTypeId base) { 304 (void)d; 305 (void)base; 306 return DEBUG_TYPE_NONE; 307 } 308 309 DebugTypeId debug_type_volatile(Debug* d, DebugTypeId base) { 310 (void)d; 311 (void)base; 312 return DEBUG_TYPE_NONE; 313 } 314 315 DebugTypeId debug_type_restrict(Debug* d, DebugTypeId base) { 316 (void)d; 317 (void)base; 318 return DEBUG_TYPE_NONE; 319 } 320 321 DebugTypeId debug_type_typedef(Debug* d, Sym name, DebugTypeId base) { 322 (void)d; 323 (void)name; 324 (void)base; 325 return DEBUG_TYPE_NONE; 326 } 327 328 DebugTypeId debug_type_func(Debug* d, DebugTypeId ret, 329 const DebugTypeId* params, u32 nparams, 330 int variadic) { 331 (void)d; 332 (void)ret; 333 (void)params; 334 (void)nparams; 335 (void)variadic; 336 return DEBUG_TYPE_NONE; 337 } 338 339 DebugTypeBuilder* debug_type_record_begin(Debug* d, Sym tag, int is_union, 340 u32 byte_size, u32 align) { 341 (void)d; 342 (void)tag; 343 (void)is_union; 344 (void)byte_size; 345 (void)align; 346 return NULL; 347 } 348 349 DebugTypeId debug_type_record_id(DebugTypeBuilder* b) { 350 (void)b; 351 return DEBUG_TYPE_NONE; 352 } 353 354 void debug_type_record_field(DebugTypeBuilder* b, Sym name, DebugTypeId type, 355 u32 byte_offset) { 356 (void)b; 357 (void)name; 358 (void)type; 359 (void)byte_offset; 360 } 361 362 void debug_type_record_bitfield(DebugTypeBuilder* b, Sym name, DebugTypeId type, 363 u32 byte_offset, u16 bit_offset, 364 u16 bit_width) { 365 (void)b; 366 (void)name; 367 (void)type; 368 (void)byte_offset; 369 (void)bit_offset; 370 (void)bit_width; 371 } 372 373 DebugTypeId debug_type_record_end(DebugTypeBuilder* b) { 374 (void)b; 375 return DEBUG_TYPE_NONE; 376 } 377 378 DebugEnumBuilder* debug_type_enum_begin(Debug* d, Sym tag, DebugTypeId base) { 379 (void)d; 380 (void)tag; 381 (void)base; 382 return NULL; 383 } 384 385 void debug_type_enum_value(DebugEnumBuilder* b, Sym name, i64 value) { 386 (void)b; 387 (void)name; 388 (void)value; 389 } 390 391 DebugTypeId debug_type_enum_end(DebugEnumBuilder* b) { 392 (void)b; 393 return DEBUG_TYPE_NONE; 394 } 395 396 void debug_func_begin(Debug* d, ObjSymId sym, DebugTypeId fn_type, 397 SrcLoc decl) { 398 (void)d; 399 (void)sym; 400 (void)fn_type; 401 (void)decl; 402 } 403 404 void debug_func_select(Debug* d, ObjSymId sym) { 405 (void)d; 406 (void)sym; 407 } 408 409 void debug_func_pc_range(Debug* d, ObjSecId text_section_id, u32 begin_ofs, 410 u32 end_ofs) { 411 (void)d; 412 (void)text_section_id; 413 (void)begin_ofs; 414 (void)end_ofs; 415 } 416 417 void debug_func_end(Debug* d) { (void)d; } 418 419 void debug_prune_removed_funcs(Debug* d) { (void)d; } 420 421 void debug_scope_begin(Debug* d, SrcLoc loc) { 422 (void)d; 423 (void)loc; 424 } 425 void debug_scope_end(Debug* d, SrcLoc loc) { 426 (void)d; 427 (void)loc; 428 } 429 430 void debug_param(Debug* d, Sym name, DebugTypeId type, SrcLoc loc, u32 idx, 431 DebugVarLoc var_loc) { 432 (void)d; 433 (void)name; 434 (void)type; 435 (void)loc; 436 (void)idx; 437 (void)var_loc; 438 } 439 440 void debug_local(Debug* d, Sym name, DebugTypeId type, SrcLoc loc, 441 DebugVarLoc var_loc) { 442 (void)d; 443 (void)name; 444 (void)type; 445 (void)loc; 446 (void)var_loc; 447 } 448 449 void debug_global(Debug* d, Sym name, DebugTypeId type, SrcLoc loc, 450 DebugVarLoc var_loc, int external) { 451 (void)d; 452 (void)name; 453 (void)type; 454 (void)loc; 455 (void)var_loc; 456 (void)external; 457 } 458 459 void debug_line(Debug* d, ObjSecId text_section_id, u32 text_offset, SrcLoc loc, 460 int is_stmt) { 461 (void)d; 462 (void)text_section_id; 463 (void)text_offset; 464 (void)loc; 465 (void)is_stmt; 466 } 467 468 void debug_set_pending_loc(Debug* d, SrcLoc loc) { 469 (void)d; 470 (void)loc; 471 } 472 473 void debug_emit_row(Debug* d, ObjSecId text_section_id, u32 text_offset, 474 SrcLoc loc) { 475 (void)d; 476 (void)text_section_id; 477 (void)text_offset; 478 (void)loc; 479 } 480 481 void debug_emit(Debug* d) { (void)d; } 482 483 KitStatus kit_dwarf_open(const KitContext* ctx, const KitObjFile* obj, 484 KitDebugInfo** out) { 485 (void)ctx; 486 (void)obj; 487 if (out) *out = NULL; 488 return KIT_UNSUPPORTED; 489 } 490 491 void kit_dwarf_free(KitDebugInfo* d) { (void)d; } 492 493 KitStatus kit_dwarf_addr_to_line(KitDebugInfo* d, uint64_t pc, 494 KitSlice* file_out, uint32_t* line_out, 495 uint32_t* col_out) { 496 (void)d; 497 (void)pc; 498 (void)file_out; 499 (void)line_out; 500 (void)col_out; 501 return KIT_UNSUPPORTED; 502 } 503 504 KitStatus kit_dwarf_line_to_addr(KitDebugInfo* d, KitSlice file, uint32_t line, 505 uint64_t* pc_out) { 506 (void)d; 507 (void)file; 508 (void)line; 509 (void)pc_out; 510 return KIT_UNSUPPORTED; 511 } 512 513 KitStatus kit_dwarf_line_to_addr_all(KitDebugInfo* d, KitSlice file, 514 uint32_t line, KitDwarfLineMatch* out, 515 uint32_t cap, uint32_t* n_out) { 516 (void)d; 517 (void)file; 518 (void)line; 519 (void)out; 520 (void)cap; 521 if (n_out) *n_out = 0; 522 return KIT_UNSUPPORTED; 523 } 524 525 KitStatus kit_dwarf_func_at(KitDebugInfo* d, uint64_t pc, KitSlice* name_out, 526 uint64_t* low_pc_out, uint64_t* high_pc_out) { 527 (void)d; 528 (void)pc; 529 (void)name_out; 530 (void)low_pc_out; 531 (void)high_pc_out; 532 return KIT_UNSUPPORTED; 533 } 534 535 KitStatus kit_dwarf_subprogram_at(KitDebugInfo* d, uint64_t pc, 536 KitDwarfSubprogram* out) { 537 (void)d; 538 (void)pc; 539 (void)out; 540 return KIT_UNSUPPORTED; 541 } 542 543 KitStatus kit_dwarf_subprogram_named(KitDebugInfo* d, KitSlice name, 544 KitDwarfSubprogram* out) { 545 (void)d; 546 (void)name; 547 (void)out; 548 return KIT_UNSUPPORTED; 549 } 550 551 KitStatus kit_dwarf_unwind_step(KitDebugInfo* d, KitUnwindFrame* frame) { 552 (void)d; 553 (void)frame; 554 return KIT_UNSUPPORTED; 555 } 556 557 KitDwarfTypeInfo kit_dwarf_type_info(const KitDwarfType* t) { 558 KitDwarfTypeInfo info; 559 (void)t; 560 info.kind = KIT_DT_VOID; 561 info.byte_size = 0; 562 info.name = KIT_SLICE_NULL; 563 info.element_count = 0; 564 info.inner = NULL; 565 return info; 566 } 567 568 KitStatus kit_dwarf_field_iter_new(KitDebugInfo* d, const KitDwarfType* t, 569 KitDwarfFieldIter** out) { 570 (void)d; 571 (void)t; 572 if (out) *out = NULL; 573 return KIT_UNSUPPORTED; 574 } 575 576 KitIterResult kit_dwarf_field_iter_next(KitDwarfFieldIter* it, 577 KitDwarfField* out) { 578 (void)it; 579 (void)out; 580 return KIT_ITER_ERROR; 581 } 582 583 void kit_dwarf_field_iter_free(KitDwarfFieldIter* it) { (void)it; } 584 585 KitStatus kit_dwarf_enum_iter_new(KitDebugInfo* d, const KitDwarfType* t, 586 KitDwarfEnumIter** out) { 587 (void)d; 588 (void)t; 589 if (out) *out = NULL; 590 return KIT_UNSUPPORTED; 591 } 592 593 KitIterResult kit_dwarf_enum_iter_next(KitDwarfEnumIter* it, 594 KitDwarfEnumVal* out) { 595 (void)it; 596 (void)out; 597 return KIT_ITER_ERROR; 598 } 599 600 void kit_dwarf_enum_iter_free(KitDwarfEnumIter* it) { (void)it; } 601 602 KitStatus kit_dwarf_var_at(KitDebugInfo* d, uint64_t pc, KitSlice name, 603 KitDwarfVarLoc* out) { 604 (void)d; 605 (void)pc; 606 (void)name; 607 (void)out; 608 return KIT_UNSUPPORTED; 609 } 610 611 KitStatus kit_dwarf_loc_read(KitDebugInfo* d, const KitDwarfVarLoc* loc, 612 const KitUnwindFrame* frame, 613 KitDwarfReadMemFn read_mem, void* read_user, 614 void* dst, size_t cap, size_t* read_out) { 615 (void)d; 616 (void)loc; 617 (void)frame; 618 (void)read_mem; 619 (void)read_user; 620 (void)dst; 621 (void)cap; 622 if (read_out) *read_out = 0; 623 return KIT_UNSUPPORTED; 624 } 625 626 KitStatus kit_dwarf_vars_at_new(KitDebugInfo* d, uint64_t pc, 627 uint32_t role_mask, KitDwarfVarIter** out) { 628 (void)d; 629 (void)pc; 630 (void)role_mask; 631 if (out) *out = NULL; 632 return KIT_UNSUPPORTED; 633 } 634 635 KitIterResult kit_dwarf_vars_at_next(KitDwarfVarIter* it, KitDwarfVar* out) { 636 (void)it; 637 (void)out; 638 return KIT_ITER_ERROR; 639 } 640 641 void kit_dwarf_vars_at_free(KitDwarfVarIter* it) { (void)it; } 642 643 KitStatus kit_dwarf_param_iter_new(KitDebugInfo* d, uint64_t pc, 644 KitDwarfParamIter** out) { 645 (void)d; 646 (void)pc; 647 if (out) *out = NULL; 648 return KIT_UNSUPPORTED; 649 } 650 651 KitStatus kit_dwarf_param_iter_new_named(KitDebugInfo* d, KitSlice name, 652 KitDwarfParamIter** out) { 653 (void)d; 654 (void)name; 655 if (out) *out = NULL; 656 return KIT_UNSUPPORTED; 657 } 658 659 KitIterResult kit_dwarf_param_iter_next(KitDwarfParamIter* it, 660 KitDwarfVar* out) { 661 (void)it; 662 (void)out; 663 return KIT_ITER_ERROR; 664 } 665 666 void kit_dwarf_param_iter_free(KitDwarfParamIter* it) { (void)it; } 667 #endif 668 669 #if !KIT_LINK_ENABLED 670 KitStatus kit_link_script_parse(const KitContext* ctx, KitSlice text, 671 KitLinkScript** out) { 672 (void)ctx; 673 (void)text; 674 if (out) *out = NULL; 675 return KIT_UNSUPPORTED; 676 } 677 678 void kit_link_script_free(const KitContext* ctx, KitLinkScript* s) { 679 (void)ctx; 680 (void)s; 681 } 682 683 KitStatus kit_link_session_new(KitCompiler* c, 684 const KitLinkSessionOptions* opts, 685 KitLinkSession** out) { 686 (void)c; 687 (void)opts; 688 if (out) *out = NULL; 689 return KIT_UNSUPPORTED; 690 } 691 692 KitStatus kit_link_session_add_obj(KitLinkSession* s, KitObjBuilder* ob) { 693 (void)s; 694 (void)ob; 695 return KIT_UNSUPPORTED; 696 } 697 698 KitStatus kit_link_session_add_obj_bytes(KitLinkSession* s, KitSlice name, 699 const KitSlice* bytes) { 700 (void)s; 701 (void)name; 702 (void)bytes; 703 return KIT_UNSUPPORTED; 704 } 705 706 KitStatus kit_link_session_add_archive_bytes( 707 KitLinkSession* s, const KitLinkArchiveInput* archive) { 708 (void)s; 709 (void)archive; 710 return KIT_UNSUPPORTED; 711 } 712 713 KitStatus kit_link_session_add_dso_bytes(KitLinkSession* s, KitSlice name, 714 const KitSlice* bytes) { 715 (void)s; 716 (void)name; 717 (void)bytes; 718 return KIT_UNSUPPORTED; 719 } 720 721 KitStatus kit_link_session_resolve(KitLinkSession* s) { 722 (void)s; 723 return KIT_UNSUPPORTED; 724 } 725 726 KitStatus kit_link_session_emit(KitLinkSession* s, KitWriter* out) { 727 (void)s; 728 (void)out; 729 return KIT_UNSUPPORTED; 730 } 731 732 KitStatus kit_link_session_write_map(KitLinkSession* s, KitWriter* out) { 733 (void)s; 734 (void)out; 735 return KIT_UNSUPPORTED; 736 } 737 738 KitStatus kit_link_session_write_symbols(KitLinkSession* s, uint8_t format, 739 KitWriter* out) { 740 (void)s; 741 (void)format; 742 (void)out; 743 return KIT_UNSUPPORTED; 744 } 745 746 KitStatus kit_link_session_jit(KitLinkSession* s, KitJit** out_jit) { 747 (void)s; 748 if (out_jit) *out_jit = NULL; 749 return KIT_UNSUPPORTED; 750 } 751 752 void kit_link_session_free(KitLinkSession* s) { (void)s; } 753 #endif 754 755 #if !KIT_JIT_ENABLED 756 KitJit* kit_jit_from_image(LinkImage* img) { 757 (void)img; 758 return NULL; 759 } 760 761 const KitExecMem* kit_jit_image_execmem(KitJit* jit) { 762 (void)jit; 763 return NULL; 764 } 765 766 int kit_jit_image_contains(KitJit* jit, uint64_t runtime_addr) { 767 (void)jit; 768 (void)runtime_addr; 769 return 0; 770 } 771 772 KitArchKind kit_jit_image_arch(KitJit* jit) { 773 (void)jit; 774 return KIT_ARCH_X86_64; 775 } 776 777 Compiler* kit_jit_compiler(KitJit* jit) { 778 (void)jit; 779 return NULL; 780 } 781 782 void kit_jit_free(KitJit* jit) { (void)jit; } 783 784 void* kit_jit_lookup(KitJit* jit, KitSlice name) { 785 (void)jit; 786 (void)name; 787 return NULL; 788 } 789 790 uint64_t kit_jit_generation(KitJit* jit) { 791 (void)jit; 792 return 0; 793 } 794 795 void kit_jit_run_dtors(KitJit* jit) { (void)jit; } 796 797 KitStatus kit_jit_publish(KitJit* jit, const KitJitPublishOptions* opts, 798 KitJitPublishResult* result) { 799 (void)jit; 800 (void)opts; 801 (void)result; 802 return KIT_UNSUPPORTED; 803 } 804 805 const KitObjFile* kit_jit_view(KitJit* jit) { 806 (void)jit; 807 return NULL; 808 } 809 810 KitStatus kit_jit_addr_to_sym(KitJit* jit, uint64_t addr, KitSlice* name_out, 811 uint64_t* off_out) { 812 (void)jit; 813 (void)addr; 814 (void)name_out; 815 (void)off_out; 816 return KIT_UNSUPPORTED; 817 } 818 819 uint64_t kit_jit_runtime_to_image(KitJit* jit, uint64_t runtime_pc) { 820 (void)jit; 821 (void)runtime_pc; 822 return 0; 823 } 824 825 uint64_t kit_jit_image_to_runtime(KitJit* jit, uint64_t image_vaddr) { 826 (void)jit; 827 (void)image_vaddr; 828 return 0; 829 } 830 831 KitStatus kit_jit_sym_iter_new(KitJit* jit, KitJitSymIter** out) { 832 (void)jit; 833 if (out) *out = NULL; 834 return KIT_UNSUPPORTED; 835 } 836 837 KitIterResult kit_jit_sym_iter_next(KitJitSymIter* it, KitJitSym* out) { 838 (void)it; 839 (void)out; 840 return KIT_ITER_ERROR; 841 } 842 843 void kit_jit_sym_iter_free(KitJitSymIter* it) { (void)it; } 844 #endif 845 846 #if !KIT_DBG_ENABLED 847 KitStatus kit_dbg_session_new(KitJit* jit, const KitDbgHost* host, 848 KitDebugSession** out) { 849 (void)jit; 850 (void)host; 851 if (out) *out = NULL; 852 return KIT_UNSUPPORTED; 853 } 854 855 void kit_dbg_session_free(KitDebugSession* s) { (void)s; } 856 857 KitStatus kit_dbg_session_attach_dwarf(KitDebugSession* s, 858 KitDebugInfo* dwarf) { 859 (void)s; 860 (void)dwarf; 861 return KIT_UNSUPPORTED; 862 } 863 864 KitStatus kit_dbg_session_call(KitDebugSession* s, void* entry, 865 KitEntryKind kind, int argc, char** argv, 866 KitStopInfo* stop_out) { 867 (void)s; 868 (void)entry; 869 (void)kind; 870 (void)argc; 871 (void)argv; 872 (void)stop_out; 873 return KIT_UNSUPPORTED; 874 } 875 876 KitStatus kit_dbg_session_call_u64(KitDebugSession* s, void* entry, 877 const uint64_t* args, uint32_t nargs, 878 uint64_t* ret_out, KitStopInfo* stop_out) { 879 (void)s; 880 (void)entry; 881 (void)args; 882 (void)nargs; 883 (void)ret_out; 884 (void)stop_out; 885 return KIT_UNSUPPORTED; 886 } 887 888 KitStatus kit_dbg_session_resume(KitDebugSession* s, KitResumeMode mode, 889 KitStopInfo* stop_out) { 890 (void)s; 891 (void)mode; 892 (void)stop_out; 893 return KIT_UNSUPPORTED; 894 } 895 896 KitStatus kit_dbg_session_interrupt(KitDebugSession* s) { 897 (void)s; 898 return KIT_UNSUPPORTED; 899 } 900 901 KitStatus kit_dbg_session_read_mem(KitDebugSession* s, uint64_t addr, void* dst, 902 size_t n) { 903 (void)s; 904 (void)addr; 905 (void)dst; 906 (void)n; 907 return KIT_UNSUPPORTED; 908 } 909 910 KitStatus kit_dbg_session_write_mem(KitDebugSession* s, uint64_t addr, 911 const void* src, size_t n) { 912 (void)s; 913 (void)addr; 914 (void)src; 915 (void)n; 916 return KIT_UNSUPPORTED; 917 } 918 919 KitStatus kit_dbg_session_get_regs(KitDebugSession* s, KitUnwindFrame* out) { 920 (void)s; 921 (void)out; 922 return KIT_UNSUPPORTED; 923 } 924 925 KitStatus kit_dbg_session_set_regs(KitDebugSession* s, 926 const KitUnwindFrame* in) { 927 (void)s; 928 (void)in; 929 return KIT_UNSUPPORTED; 930 } 931 932 KitStatus kit_dbg_session_breakpoint_set(KitDebugSession* s, uint64_t addr, 933 uint32_t* bp_id_out) { 934 (void)s; 935 (void)addr; 936 (void)bp_id_out; 937 return KIT_UNSUPPORTED; 938 } 939 940 KitStatus kit_dbg_session_breakpoint_clear(KitDebugSession* s, uint32_t bp_id) { 941 (void)s; 942 (void)bp_id; 943 return KIT_UNSUPPORTED; 944 } 945 946 KitStatus kit_dbg_session_breakpoint_set_spec(KitDebugSession* s, 947 const KitBreakpointSpec* spec, 948 uint32_t* bp_id_out) { 949 (void)s; 950 (void)spec; 951 (void)bp_id_out; 952 return KIT_UNSUPPORTED; 953 } 954 955 /* Symbolic inspection layer (symbolic.c). */ 956 KitStatus kit_dbg_symbolize_pc(KitJit* jit, KitDebugInfo* dwarf, uint64_t pc, 957 KitDebugFrame* out) { 958 (void)jit; 959 (void)dwarf; 960 (void)pc; 961 (void)out; 962 return KIT_UNSUPPORTED; 963 } 964 965 KitStatus kit_dbg_backtrace_new(KitDebugSession* s, const KitUnwindFrame* top, 966 KitDebugBacktrace** out) { 967 (void)s; 968 (void)top; 969 if (out) *out = NULL; 970 return KIT_UNSUPPORTED; 971 } 972 973 uint32_t kit_dbg_backtrace_count(const KitDebugBacktrace* bt) { 974 (void)bt; 975 return 0; 976 } 977 978 KitStatus kit_dbg_backtrace_frame(const KitDebugBacktrace* bt, uint32_t level, 979 KitDebugFrame* out) { 980 (void)bt; 981 (void)level; 982 (void)out; 983 return KIT_UNSUPPORTED; 984 } 985 986 void kit_dbg_backtrace_free(KitDebugBacktrace* bt) { (void)bt; } 987 988 KitStatus kit_dbg_var_read(KitDebugSession* s, const KitUnwindFrame* frame, 989 KitSlice name, KitDebugValue* out) { 990 (void)s; 991 (void)frame; 992 (void)name; 993 (void)out; 994 return KIT_UNSUPPORTED; 995 } 996 997 KitStatus kit_dbg_value_at(KitDebugSession* s, uint64_t addr, 998 const KitDwarfType* type, KitDebugValue* out) { 999 (void)s; 1000 (void)addr; 1001 (void)type; 1002 (void)out; 1003 return KIT_UNSUPPORTED; 1004 } 1005 1006 KitStatus kit_dbg_value_field(KitDebugSession* s, const KitDebugValue* v, 1007 KitSlice field, KitDebugValue* out) { 1008 (void)s; 1009 (void)v; 1010 (void)field; 1011 (void)out; 1012 return KIT_UNSUPPORTED; 1013 } 1014 1015 KitStatus kit_dbg_value_index(KitDebugSession* s, const KitDebugValue* v, 1016 uint64_t index, KitDebugValue* out) { 1017 (void)s; 1018 (void)v; 1019 (void)index; 1020 (void)out; 1021 return KIT_UNSUPPORTED; 1022 } 1023 1024 KitStatus kit_dbg_value_deref(KitDebugSession* s, const KitDebugValue* v, 1025 KitDebugValue* out) { 1026 (void)s; 1027 (void)v; 1028 (void)out; 1029 return KIT_UNSUPPORTED; 1030 } 1031 1032 KitStatus kit_dbg_value_as_u64(const KitDebugValue* v, uint64_t* out) { 1033 (void)v; 1034 (void)out; 1035 return KIT_UNSUPPORTED; 1036 } 1037 1038 KitStatus kit_dbg_value_as_i64(const KitDebugValue* v, int64_t* out) { 1039 (void)v; 1040 (void)out; 1041 return KIT_UNSUPPORTED; 1042 } 1043 1044 KitStatus kit_dbg_value_as_f64(const KitDebugValue* v, double* out) { 1045 (void)v; 1046 (void)out; 1047 return KIT_UNSUPPORTED; 1048 } 1049 1050 KitStatus kit_dbg_value_format(KitDebugSession* s, const KitDebugValue* v, 1051 KitWriter* out, 1052 const KitDebugFormatOptions* opt) { 1053 (void)s; 1054 (void)v; 1055 (void)out; 1056 (void)opt; 1057 return KIT_UNSUPPORTED; 1058 } 1059 1060 KitStatus kit_dbg_var_write_u64(KitDebugSession* s, const KitUnwindFrame* frame, 1061 KitSlice name, uint64_t value) { 1062 (void)s; 1063 (void)frame; 1064 (void)name; 1065 (void)value; 1066 return KIT_UNSUPPORTED; 1067 } 1068 1069 KitStatus kit_dbg_vars_new(KitDebugSession* s, const KitUnwindFrame* frame, 1070 uint32_t roles, KitDebugVarIter** out) { 1071 (void)s; 1072 (void)frame; 1073 (void)roles; 1074 if (out) *out = NULL; 1075 return KIT_UNSUPPORTED; 1076 } 1077 1078 KitIterResult kit_dbg_vars_next(KitDebugVarIter* it, KitSlice* name_out, 1079 KitDebugValue* value_out) { 1080 (void)it; 1081 (void)name_out; 1082 (void)value_out; 1083 return KIT_ITER_ERROR; 1084 } 1085 1086 void kit_dbg_vars_free(KitDebugVarIter* it) { (void)it; } 1087 1088 KitStatus kit_dbg_resolve(KitDebugSession* s, KitSlice spec, uint64_t* addr_out, 1089 KitDwarfLineMatch* cands, uint32_t cap, 1090 uint32_t* ncand) { 1091 (void)s; 1092 (void)spec; 1093 (void)addr_out; 1094 (void)cands; 1095 (void)cap; 1096 (void)ncand; 1097 return KIT_UNSUPPORTED; 1098 } 1099 1100 KitStatus kit_dbg_break(KitDebugSession* s, KitSlice spec, 1101 uint32_t* bp_id_out) { 1102 (void)s; 1103 (void)spec; 1104 (void)bp_id_out; 1105 return KIT_UNSUPPORTED; 1106 } 1107 1108 KitStatus kit_dbg_disasm_new(KitDebugSession* s, uint64_t addr, uint32_t count, 1109 KitDisasmIter** out) { 1110 (void)s; 1111 (void)addr; 1112 (void)count; 1113 if (out) *out = NULL; 1114 return KIT_UNSUPPORTED; 1115 } 1116 #endif 1117 1118 #if !KIT_EMU_ENABLED 1119 KitStatus kit_emu_run(KitCompiler* c, const KitEmuOptions* opts, 1120 int* out_exit_code) { 1121 (void)c; 1122 (void)opts; 1123 (void)out_exit_code; 1124 return KIT_UNSUPPORTED; 1125 } 1126 1127 KitStatus kit_emu_new(KitCompiler* c, const KitEmuOptions* opts, KitEmu** out) { 1128 (void)c; 1129 (void)opts; 1130 if (out) *out = NULL; 1131 return KIT_UNSUPPORTED; 1132 } 1133 1134 KitStatus kit_emu_step(KitEmu* e, uint32_t nblocks) { 1135 (void)e; 1136 (void)nblocks; 1137 return KIT_UNSUPPORTED; 1138 } 1139 1140 void* kit_emu_lookup(KitEmu* e, uint64_t guest_pc) { 1141 (void)e; 1142 (void)guest_pc; 1143 return NULL; 1144 } 1145 1146 void kit_emu_free(KitEmu* e) { (void)e; } 1147 #endif 1148 1149 #if !KIT_GRAM_ENABLED 1150 /* gram subsystem gated out: stub the public API so libkit still exports 1151 * the full surface (mirrors the subsystem stubs above). The match / token- 1152 * machine / position types are header-only, so only the KIT_API functions 1153 * declared in <kit/gram*.h> need stubs here. */ 1154 KitStatus kit_gram_compile_text(const KitContext* ctx, KitSlice text, KitSlice path, const KitGramOptions* opts, KitGramCompiled** out) { (void)ctx; (void)text; (void)path; (void)opts; (void)out; return KIT_UNSUPPORTED; } 1155 void kit_gram_free(KitGramCompiled* c) { (void)c; } 1156 KitStatus kit_gram_dump_sexpr(const KitContext* ctx, KitSlice text, KitSlice path, const KitGramOptions* opts, KitWriter* out) { (void)ctx; (void)text; (void)path; (void)opts; (void)out; return KIT_UNSUPPORTED; } 1157 const KitGramGrammar* kit_gram_parser_grammar(const KitGramCompiled* c) { (void)c; return NULL; } 1158 const KitGramLexGrammar* kit_gram_lexer_grammar( const KitGramCompiled* c) { (void)c; return NULL; } 1159 size_t kit_gram_lexer_count(const KitGramCompiled* c) { (void)c; return 0; } 1160 const char* kit_gram_lexer_name(const KitGramCompiled* c, size_t i) { (void)c; (void)i; return NULL; } 1161 const KitGramLexGrammar* kit_gram_lexer_grammar_at( const KitGramCompiled* c, size_t i) { (void)c; (void)i; return NULL; } 1162 bool kit_gram_find_lexer(const KitGramCompiled* c, const char* name, size_t* out) { (void)c; (void)name; (void)out; return false; } 1163 size_t kit_gram_token_count(const KitGramCompiled* c) { (void)c; return 0; } 1164 const char* kit_gram_token_name(const KitGramCompiled* c, KitGramTokenKind tok) { (void)c; (void)tok; return NULL; } 1165 const char* kit_gram_token_display(const KitGramCompiled* c, KitGramTokenKind tok) { (void)c; (void)tok; return NULL; } 1166 bool kit_gram_find_token(const KitGramCompiled* c, const char* name, KitGramTokenKind* out) { (void)c; (void)name; (void)out; return false; } 1167 size_t kit_gram_rule_count(const KitGramCompiled* c) { (void)c; return 0; } 1168 const char* kit_gram_rule_name(const KitGramCompiled* c, KitGramRuleId rule) { (void)c; (void)rule; return NULL; } 1169 bool kit_gram_find_rule(const KitGramCompiled* c, const char* name, KitGramRuleId* out) { (void)c; (void)name; (void)out; return false; } 1170 size_t kit_gram_machine_count(const KitGramCompiled* c) { (void)c; return 0; } 1171 const char* kit_gram_machine_name(const KitGramCompiled* c, size_t mi) { (void)c; (void)mi; return NULL; } 1172 bool kit_gram_find_machine(const KitGramCompiled* c, const char* name, size_t* out) { (void)c; (void)name; (void)out; return false; } 1173 size_t kit_gram_machine_rule_count(const KitGramCompiled* c, size_t mi) { (void)c; (void)mi; return 0; } 1174 const char* kit_gram_machine_rule_name(const KitGramCompiled* c, size_t mi, size_t rule) { (void)c; (void)mi; (void)rule; return NULL; } 1175 KitGramGenStatus kit_gram_machine_generate( const KitGramCompiled* c, size_t mi, size_t rule, uint64_t* seed, double stop_prob, size_t max_repeat, size_t max_tokens, const char** out, size_t cap, size_t* n) { (void)c; (void)mi; (void)rule; (void)seed; (void)stop_prob; (void)max_repeat; (void)max_tokens; (void)out; (void)cap; (void)n; return KIT_GRAM_GEN_ERROR; } 1176 KitStatus kit_gram_emit_c(const KitGramCompiled* c, const KitGramEmitOptions* opts, KitWriter* header, KitWriter* source) { (void)c; (void)opts; (void)header; (void)source; return KIT_UNSUPPORTED; } 1177 KitStatus kit_gram_regex_compile(const KitContext* ctx, KitSlice pattern, const KitGramOptions* opts, KitGramCompiled** out) { (void)ctx; (void)pattern; (void)opts; (void)out; return KIT_UNSUPPORTED; } 1178 const KitGramLexGrammar* kit_gram_regex_grammar(const KitGramCompiled* re) { (void)re; return NULL; } 1179 KitGramTokenKind kit_gram_regex_kind(const KitGramCompiled* re) { (void)re; return 0; } 1180 void kit_gram_parser_init(KitGramParser* mem, const KitGramGrammar* g, const KitGramConfig* cfg) { (void)mem; (void)g; (void)cfg; } 1181 KitGramStatus kit_gram_parser_push(KitGramParser* p, KitGramToken t) { (void)p; (void)t; return KIT_GRAM_PARSE_ERROR; } 1182 KitGramStatus kit_gram_parser_push_n(KitGramParser* p, const KitGramToken* toks, size_t n) { (void)p; (void)toks; (void)n; return KIT_GRAM_PARSE_ERROR; } 1183 KitGramStatus kit_gram_parser_finish(KitGramParser* p) { (void)p; return KIT_GRAM_PARSE_ERROR; } 1184 size_t kit_gram_parser_generate_scratch_count(const KitGramGrammar* g) { (void)g; return 0; } 1185 KitGramGenStatus kit_gram_parser_generate_next(KitGramParser* p, KitGramGenConfig* cfg, KitGramToken* out) { (void)p; (void)cfg; (void)out; return KIT_GRAM_GEN_ERROR; } 1186 KitGramSem kit_gram_parser_result(const KitGramParser* p) { (void)p; return NULL; } 1187 size_t kit_gram_parser_errors(const KitGramParser* p) { (void)p; return 0; } 1188 bool kit_gram_parser_overflowed( const KitGramParser* p) { (void)p; return false; } 1189 void kit_gram_stack_bounds(const KitGramGrammar* g, size_t max_depth, size_t* ctl_cap, size_t* val_cap) { (void)g; (void)max_depth; (void)ctl_cap; (void)val_cap; } 1190 size_t kit_gram_parser_ctl_hwm(const KitGramParser* p) { (void)p; return 0; } 1191 size_t kit_gram_parser_val_hwm(const KitGramParser* p) { (void)p; return 0; } 1192 size_t kit_gram_parser_depth(const KitGramParser* p) { (void)p; return 0; } 1193 KitGramRuleId kit_gram_parser_context(const KitGramParser* p) { (void)p; return 0; } 1194 bool kit_gram_parser_expects(const KitGramParser* p, KitGramTokenKind k) { (void)p; (void)k; return false; } 1195 size_t kit_gram_parser_frames(const KitGramParser* p, KitGramFrame* out, size_t cap) { (void)p; (void)out; (void)cap; return 0; } 1196 bool kit_gram_parser_frame(const KitGramParser* p, size_t i, KitGramFrame* out) { (void)p; (void)i; (void)out; return false; } 1197 const char* kit_gram_parser_rule_name(const KitGramParser* p, KitGramRuleId r) { (void)p; (void)r; return NULL; } 1198 const char* kit_gram_parser_tok_name(const KitGramParser* p, KitGramTokenKind k) { (void)p; (void)k; return NULL; } 1199 void kit_gram_lex_input_init(KitGramLexInput* mem, const KitGramLexInputConfig* cfg) { (void)mem; (void)cfg; } 1200 void kit_gram_lex_input_push(KitGramLexInput* in, KitGramLexInputSpan* span) { (void)in; (void)span; } 1201 void kit_gram_lex_input_finish(KitGramLexInput* in) { (void)in; } 1202 const KitGramLexError* kit_gram_lex_input_error(const KitGramLexInput* in) { (void)in; return NULL; } 1203 void kit_gram_lexer_init(KitGramLexer* mem, const KitGramLexGrammar* g, KitGramLexInput* in, const KitGramLexConfig* cfg) { (void)mem; (void)g; (void)in; (void)cfg; } 1204 KitGramLexStatus kit_gram_lexer_next(KitGramLexer* lx, KitGramToken* out) { (void)lx; (void)out; return KIT_GRAM_LEX_ERROR; } 1205 KitGramTokenKind kit_gram_lex_keyword_rewrite(const KitGramLexGrammar* g, KitGramTokenKind kind, const unsigned char* bytes, size_t len) { (void)g; (void)kind; (void)bytes; (void)len; return 0; } 1206 void kit_gram_lexer_lexeme(KitGramLexer* lx, KitGramLexLexeme* it) { (void)lx; (void)it; } 1207 bool kit_gram_lex_lexeme_next(KitGramLexLexeme* it, KitGramLexSegment* seg) { (void)it; (void)seg; return false; } 1208 void kit_gram_matcher_bind(KitGramMatcher* m, const KitGramLexGrammar* g) { (void)m; (void)g; } 1209 bool kit_gram_match_anchored(KitGramMatcher* m, KitGramLexInput* in, const KitGramMatchOpts* opts, KitGramMatch* out) { (void)m; (void)in; (void)opts; (void)out; return false; } 1210 bool kit_gram_match_full(KitGramMatcher* m, KitGramLexInput* in, const KitGramMatchOpts* opts, KitGramMatch* out) { (void)m; (void)in; (void)opts; (void)out; return false; } 1211 bool kit_gram_match_find(KitGramMatcher* m, KitGramLexInput* in, const KitGramMatchOpts* opts, KitGramMatch* out) { (void)m; (void)in; (void)opts; (void)out; return false; } 1212 void kit_gram_match_iter_init(KitGramMatchIter* it, KitGramMatcher* m, KitGramLexInput* in, const KitGramMatchOpts* opts) { (void)it; (void)m; (void)in; (void)opts; } 1213 bool kit_gram_match_iter_next(KitGramMatchIter* it, KitGramMatch* out) { (void)it; (void)out; return false; } 1214 bool kit_gram_unicode_is_surrogate(uint32_t cp) { (void)cp; return false; } 1215 bool kit_gram_unicode_is_scalar(uint32_t cp) { (void)cp; return false; } 1216 bool kit_gram_unicode_is_noncharacter(uint32_t cp) { (void)cp; return false; } 1217 bool kit_gram_unicode_is_line_break(uint32_t cp) { (void)cp; return false; } 1218 size_t kit_gram_utf8_encoded_len(uint32_t cp) { (void)cp; return 0; } 1219 size_t kit_gram_utf8_encode(uint32_t cp, unsigned char out[4]) { (void)cp; (void)out; return 0; } 1220 KitGramUtf8Status kit_gram_utf8_decode_one(const unsigned char* bytes, size_t len, uint32_t* cp, size_t* nbytes) { (void)bytes; (void)len; (void)cp; (void)nbytes; return KIT_GRAM_UTF8_INVALID; } 1221 void kit_gram_unicode_pos_init(KitGramUnicodePos* pos) { (void)pos; } 1222 void kit_gram_unicode_pos_advance(KitGramUnicodePos* pos, uint32_t cp) { (void)pos; (void)cp; } 1223 KitGramUtf8Status kit_gram_unicode_pos_advance_utf8(KitGramUnicodePos* pos, const unsigned char* bytes, size_t len, size_t* nbytes) { (void)pos; (void)bytes; (void)len; (void)nbytes; return KIT_GRAM_UTF8_INVALID; } 1224 size_t kit_gram_unicode_fold_property_key(const char* in, char* out, size_t out_cap) { (void)in; (void)out; (void)out_cap; return 0; } 1225 #endif