kit

link_inputs.h (9741B)

---

 #ifndef KIT_DRIVER_LINK_INPUTS_H
 #define KIT_DRIVER_LINK_INPUTS_H
 
 #include <kit/compile.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include "cflags.h"
 #include "driver.h"
 #include "hosted.h"
 #include "link_flags.h"
 #include "runtime.h"
 
 /* Shared link-input model for the `cc` and `build-*` drivers.
  *
  * Both drivers classify positionals (and resolved `-l` names, runtime
  * archives, and hosted crt/libc files) into an ordered list of link items
  * backed by parallel object / archive / dso arrays, then resolve pending `-l`
  * names and replay the items into the linker. The two had byte-identical copies
  * of that model and its bookkeeping; this module owns the single
  * implementation. Each driver embeds a DriverLinkInputSet (by value, like the
  * shared DriverCflags / DriverLinkFlags) and keeps only its tool-specific state
  * (cc: sources/deps/probes; build: groups/scopes). */
 
 /* Kind of a link item. SOURCE / SOURCE_MEMORY index into the *driver's own*
  * source arrays (interpreted by the driver, never by this module); OBJECT /
  * ARCHIVE / DSO / LIB index into this set's parallel arrays. */
 typedef enum DriverLinkKind {
   DRIVER_LINK_SOURCE = 0,    /* index into the driver's source array        */
   DRIVER_LINK_SOURCE_MEMORY, /* cc: index into in-memory (stdin) sources    */
   DRIVER_LINK_OBJECT,        /* index into object_files                     */
   DRIVER_LINK_ARCHIVE,       /* index into archives                         */
   DRIVER_LINK_DSO,           /* index into dsos                             */
   DRIVER_LINK_LIB,           /* index into pending_libs (resolved later)    */
   DRIVER_LINK_FRAMEWORK,     /* index into pending_frameworks               */
 } DriverLinkKind;
 
 typedef struct DriverLinkItem {
   uint8_t kind; /* DriverLinkKind */
   uint8_t pad[3];
   uint32_t index;
 } DriverLinkItem;
 
 typedef struct DriverArchiveInput {
   const char* path;
   int owned;
   size_t owned_size;
   uint8_t whole_archive;
   uint8_t link_mode;
   uint8_t group_id;
   uint8_t pad;
 } DriverArchiveInput;
 
 typedef struct DriverDsoInput {
   const char* path;
   int owned;
   size_t owned_size;
 } DriverDsoInput;
 
 typedef struct DriverPendingLib {
   const char* name;
   uint8_t whole_archive;
   uint8_t link_mode;
   uint8_t group_id;
   uint8_t resolved_kind; /* DriverLinkKind: ARCHIVE or DSO */
   uint32_t resolved_index;
 } DriverPendingLib;
 
 typedef struct DriverPendingFramework {
   const char* name;
   uint32_t resolved_index;
 } DriverPendingFramework;
 
 typedef struct DriverLinkInputSet {
   DriverEnv* env;
   const char* tool;
   size_t bound; /* per-array capacity (for fini) */
 
   /* Positional / resolved inputs, split by kind. */
   const char** object_files; /* .o/.obj paths */
   uint32_t nobject_files;
   DriverArchiveInput* archives; /* .a paths + resolved -l names */
   uint32_t narchives;
   DriverDsoInput* dsos;
   uint32_t ndsos;
   const char** lib_search_paths; /* -L dirs (+ hosted/sysroot dirs) */
   uint32_t nlib_search_paths;
   const char** framework_search_paths; /* -F dirs (+ SDK framework dirs) */
   uint32_t nframework_search_paths;
   DriverPendingLib* pending_libs; /* -l names, resolved at end-of-parse */
   uint32_t npending_libs;
   DriverPendingFramework* pending_frameworks; /* -framework names */
   uint32_t npending_frameworks;
   DriverLinkItem* link_items; /* ordered link sequence */
   uint32_t nlink_items;
 
   /* Attributes applied to the next archive positional, driven by
    * -Wl,--whole-archive / -Bstatic|-Bdynamic / --start-group. */
   uint8_t cur_whole_archive;
   uint8_t cur_link_mode;
   uint8_t cur_group_id;
 
   /* Owned `<sysroot>/lib` slot appended for Windows targets when a sysroot is
    * in effect (see driver_link_inputs_append_windows_lib_dirs). */
   char* owned_sysroot_lib_dir;
   size_t owned_sysroot_lib_dir_size;
   char* owned_sysroot_framework_dirs[2];
   size_t owned_sysroot_framework_dir_sizes[2];
   uint32_t nowned_sysroot_framework_dirs;
 } DriverLinkInputSet;
 
 /* Allocate the parallel arrays (each sized `bound`) and seed defaults
  * (cur_link_mode = KIT_LM_DEFAULT). Returns 0, or 1 on OOM (diagnostic via
  * `tool`). */
 int driver_link_inputs_init(DriverLinkInputSet* set, DriverEnv* env,
                             const char* tool, size_t bound);
 
 /* Free owned archive/dso paths, the owned sysroot lib dir, and the arrays. */
 void driver_link_inputs_fini(DriverLinkInputSet* set);
 
 /* True for a `.so` / `.dylib` / `.tbd` shared-object path. */
 int driver_is_dso_path(const char* s);
 
 /* Append / insert a link item referencing array slot `index`. */
 void driver_link_inputs_push(DriverLinkInputSet* set, uint8_t kind,
                              uint32_t index);
 void driver_link_inputs_insert(DriverLinkInputSet* set, uint32_t pos,
                                uint8_t kind, uint32_t index);
 
 /* Record one hosted crt/libc input (object/archive/dso) into the set and order
  * it: insert at `insert_pos` when `insert`, else append. Returns 0/1. */
 int driver_link_inputs_append_hosted(DriverLinkInputSet* set,
                                      const DriverHostedInput* in,
                                      uint32_t insert_pos, int insert);
 
 /* Move a runtime archive (ownership transferred out of `rt`) into the set and
  * insert its link item at `insert_pos`. */
 void driver_link_inputs_insert_runtime_archive(DriverLinkInputSet* set,
                                                DriverRuntimeArchive* rt,
                                                uint32_t insert_pos);
 
 /* Insert the compiler runtime archive `rt` (ownership transferred out) at the
  * position(s) that satisfy the target's link order. For Windows this is a
  * two-position insert (a strong-_setjmp entry before the hosted `after` group
  * plus a late ___chkstk_ms entry before crtend; see the implementation), so a
  * second owned copy of the path is allocated. For every other target it is the
  * single end-insert (before the `nfinal` crt-end group). `nfinal` / `nafter`
  * are the hosted plan's final / after group sizes. */
 void driver_link_inputs_insert_runtime_archives(DriverLinkInputSet* set,
                                                 DriverRuntimeArchive* rt,
                                                 KitTargetSpec target,
                                                 uint32_t nfinal,
                                                 uint32_t nafter);
 
 /* Translate the recorded link-item sequence into the engine's public
  * KitLinkInputOrder list, writing into `order` (sized >= set->nlink_items) and
  * returning the count produced. SOURCE / SOURCE_MEMORY items index the caller's
  * parallel `source_obj_index` / `source_order_keep` arrays — the latter gates
  * whether a compiled source survived DCE; dropped sources are skipped.
  * SOURCE_MEMORY (cc stdin sources) indexes past `nsource_files` into those same
  * arrays; build records no SOURCE_MEMORY items, so it may pass any
  * nsource_files. OBJECT / ARCHIVE / DSO map straight through; LIB resolves via
  * its pending-lib slot's resolved kind/index. */
 uint32_t driver_link_inputs_build_order(const DriverLinkInputSet* set,
                                         const uint32_t* source_obj_index,
                                         const uint8_t* source_order_keep,
                                         uint32_t nsource_files,
                                         KitLinkInputOrder* order);
 
 /* Resolve every pending `-l` name against lib_search_paths into a concrete
  * archive or dso slot, filling each pending lib's resolved_kind/index. Returns
  * 0, or 1 with a diagnostic on not-found. */
 int driver_link_inputs_resolve_pending(DriverLinkInputSet* set,
                                        KitTargetSpec target, int static_link);
 
 /* For Windows targets, append `<sysroot>/lib` to the search path. The sysroot
  * is `*sysroot` if set, else KIT_SYSROOT (which is then written back through
  * `*sysroot`). No-op for non-Windows targets or when no sysroot applies.
  * Returns 0/1. */
 int driver_link_inputs_append_windows_lib_dirs(DriverLinkInputSet* set,
                                                const char** sysroot,
                                                KitTargetSpec target);
 
 /* True when the target uses Mach-O framework search dirs (Apple SDK): obj is
  * Mach-O and the target OS's hosted ops set uses_framework_dirs. Shared between
  * the cc/build link-input path and the `ld` driver. */
 int driver_target_uses_framework_dirs(KitTargetSpec target);
 
 /* For Mach-O SDK targets, append `<sysroot>/System/Library/Frameworks` and
  * `<sysroot>/System/Library/PrivateFrameworks` to the framework search path.
  * The sysroot is `*sysroot` if set, else KIT_SYSROOT (which is written back
  * through `*sysroot`). No-op for non-Apple-Mach-O targets or no sysroot. */
 int driver_link_inputs_append_sysroot_framework_dirs(DriverLinkInputSet* set,
                                                      const char** sysroot,
                                                      KitTargetSpec target);
 
 /* Apply a hosted libc profile: resolve `plan` for the target/sysroot, add its
  * system includes + defines to `cf`, add its lib search dirs to the set, and
  * (when `link_action`) insert its crt inputs and adopt its interpreter into
  * `link`. The wants-hosted / -nostdlib guard belongs to the caller. Returns
  * 0/1. */
 int driver_link_inputs_apply_hosted(DriverLinkInputSet* set,
                                     DriverHostedPlan* plan, DriverCflags* cf,
                                     DriverLinkFlags* link, KitTargetSpec target,
                                     const char* sysroot, int static_link,
                                     int shared_link, int no_startfiles,
                                     int link_action);
 
 #endif