Expose libtcc symbol listing

Author: sounkou-bioinfo

NAMESPACE

@@ -47,6 +47,7 @@ export(tcc_lib_paths)
 export(tcc_library)
 export(tcc_library_path)
 export(tcc_link)
+export(tcc_list_symbols)
 export(tcc_malloc)
 export(tcc_map_c_type_to_ffi)
 export(tcc_null_ptr)

NEWS.md

@@ -1,5 +1,6 @@
 # Rtinycc 0.1.11
 
+- Add `tcc_list_symbols()` to inspect global symbol names and resolved hexadecimal addresses known to a libtcc state.
 - Fix `PROTECT` and memory-balance hygiene bugs in internal C state initialization (`RC_libtcc_state_new`, `RC_libtcc_get_symbol`, and callback registration paths). Previously, class string attributes could be inadvertently allocated without proper protection.
 - Fix a stack-depth and protection imbalance bug in `RC_invoke_callback_internal` where callback execution could unexpectedly unprotect the `call` object prior to evaluation.
 

R/tinycc.R

@@ -307,6 +307,21 @@ tcc_get_symbol <- function(state, name) {
   .Call(RC_libtcc_get_symbol, state, name)
 }
 
+#' List symbols known to a libtcc state
+#'
+#' Return the global symbols currently known to a libtcc state. This is a
+#' symbol-table inspection helper for compiled/linked TCC states, not a DLL
+#' export scanner and not a C signature discovery API. For meaningful runtime
+#' addresses, call it after [tcc_relocate()].
+#'
+#' @param state A `tcc_state`.
+#' @return A data frame with columns `name` and `address`, where `address` is a
+#'   hexadecimal character string.
+#' @export
+tcc_list_symbols <- function(state) {
+  .Call(RC_libtcc_list_symbols, state)
+}
+
 
 #' Call a zero-argument symbol with a specified return type
 #' @param state A `tcc_state`.

inst/tinytest/test_libtcc.R

@@ -27,6 +27,11 @@ expect_true(tcc_symbol_is_valid(sym_ptr))
 addr <- get_external_ptr_addr(sym_ptr)
 cat(sprintf("symbol 'forty_two' address: %f\n", addr))
 cat(sprintf("address %% 8: %f\n", addr %% 8))
+symbols <- tcc_list_symbols(state)
+expect_true(is.data.frame(symbols))
+expect_true(identical(names(symbols), c("name", "address")))
+expect_true("forty_two" %in% symbols$name)
+expect_true(all(grepl("^0x[0-9a-fA-F]+$", symbols$address)))
 expect_equal(tcc_call_symbol(state, "forty_two", return = "int"), 42L)
 # CLI compile to object
 # forty_two.c uses stdio.h / printf which are UCRT-inline on Windows,

man/tcc_list_symbols.Rd

@@ -12,6 +12,7 @@
 #include <R_ext/Parse.h>
 #include <stdint.h>
 #include <inttypes.h>
+#include <limits.h>
 #include <math.h>
 #include <stdlib.h>
 #include <string.h>
@@ -46,6 +47,7 @@ SEXP RC_libtcc_compile_string(SEXP ext, SEXP code);
 SEXP RC_libtcc_add_symbol(SEXP ext, SEXP name, SEXP addr);
 SEXP RC_libtcc_relocate(SEXP ext);
 SEXP RC_libtcc_get_symbol(SEXP ext, SEXP name);
+SEXP RC_libtcc_list_symbols(SEXP ext);
 SEXP RC_libtcc_call_symbol(SEXP ext, SEXP name, SEXP ret_type);
 SEXP RC_libtcc_ptr_valid(SEXP ptr);
 SEXP RC_libtcc_output_file(SEXP ext, SEXP filename);
@@ -553,6 +555,87 @@ SEXP RC_libtcc_get_symbol(SEXP ext, SEXP name) {
     return ptr;
 }
 
+typedef struct {
+    R_xlen_t count;
+} RC_tcc_symbol_count_t;
+
+typedef struct {
+    SEXP names;
+    SEXP addresses;
+    R_xlen_t index;
+} RC_tcc_symbol_collect_t;
+
+static void RC_libtcc_count_symbol_cb(void *ctx, const char *name, const void *val) {
+    (void) name;
+    (void) val;
+    RC_tcc_symbol_count_t *counter = (RC_tcc_symbol_count_t *) ctx;
+    counter->count++;
+}
+
+static void RC_libtcc_collect_symbol_cb(void *ctx, const char *name, const void *val) {
+    RC_tcc_symbol_collect_t *collect = (RC_tcc_symbol_collect_t *) ctx;
+    R_xlen_t i = collect->index++;
+    if (i >= XLENGTH(collect->names)) {
+        return;
+    }
+
+    char addr_buf[2 + (sizeof(uintptr_t) * 2) + 1];
+    if (val == NULL) {
+        snprintf(addr_buf, sizeof(addr_buf), "0x0");
+    } else {
+        snprintf(addr_buf, sizeof(addr_buf), "0x%" PRIxPTR, (uintptr_t) val);
+    }
+
+    SET_STRING_ELT(
+        collect->names,
+        i,
+        Rf_mkCharCE(name == NULL ? "" : name, CE_UTF8)
+    );
+    SET_STRING_ELT(collect->addresses, i, Rf_mkChar(addr_buf));
+}
+
+/**
+ * List global symbols known to a TCC state.
+ * Ownership: none.
+ * Allocation: result data frame only.
+ * Protection: PROTECT(6), UNPROTECT(6).
+ */
+SEXP RC_libtcc_list_symbols(SEXP ext) {
+    TCCState *s = RC_tcc_state(ext);
+
+    RC_tcc_symbol_count_t counter = {0};
+    tcc_list_symbols(s, &counter, RC_libtcc_count_symbol_cb);
+    if (counter.count > INT_MAX) {
+        Rf_error("too many TCC symbols to return as a data frame");
+    }
+
+    SEXP names_vec = PROTECT(Rf_allocVector(STRSXP, counter.count));
+    SEXP addresses_vec = PROTECT(Rf_allocVector(STRSXP, counter.count));
+
+    RC_tcc_symbol_collect_t collect = {names_vec, addresses_vec, 0};
+    tcc_list_symbols(s, &collect, RC_libtcc_collect_symbol_cb);
+
+    SEXP out = PROTECT(Rf_allocVector(VECSXP, 2));
+    SET_VECTOR_ELT(out, 0, names_vec);
+    SET_VECTOR_ELT(out, 1, addresses_vec);
+
+    SEXP out_names = PROTECT(Rf_allocVector(STRSXP, 2));
+    SET_STRING_ELT(out_names, 0, Rf_mkChar("name"));
+    SET_STRING_ELT(out_names, 1, Rf_mkChar("address"));
+    Rf_setAttrib(out, R_NamesSymbol, out_names);
+
+    SEXP row_names = PROTECT(Rf_allocVector(INTSXP, 2));
+    INTEGER(row_names)[0] = NA_INTEGER;
+    INTEGER(row_names)[1] = -(int) counter.count;
+    Rf_setAttrib(out, R_RowNamesSymbol, row_names);
+
+    SEXP class_str = PROTECT(Rf_mkString("data.frame"));
+    Rf_setAttrib(out, R_ClassSymbol, class_str);
+
+    UNPROTECT(6);
+    return out;
+}
+
 /**
  * Call a zero-argument symbol, casting to the requested return type.
  * Ownership: none.

src/RC_libtcc.c

@@ -24,6 +24,7 @@ SEXP RC_libtcc_add_host_symbols(SEXP ext);
 SEXP RC_libtcc_relocate(SEXP ext);
 SEXP RC_libtcc_call_symbol(SEXP ext, SEXP name, SEXP ret_type);
 SEXP RC_libtcc_get_symbol(SEXP ext, SEXP name);
+SEXP RC_libtcc_list_symbols(SEXP ext);
 
 SEXP RC_libtcc_ptr_valid(SEXP ptr);
 SEXP RC_get_external_ptr_addr(SEXP ext);
@@ -96,6 +97,7 @@ static const R_CallMethodDef CallEntries[] = {
     {"RC_libtcc_relocate",    (DL_FUNC) &RC_libtcc_relocate,    1},
     {"RC_libtcc_call_symbol", (DL_FUNC) &RC_libtcc_call_symbol, 3},
     {"RC_libtcc_get_symbol",  (DL_FUNC) &RC_libtcc_get_symbol,  2},
+    {"RC_libtcc_list_symbols", (DL_FUNC) &RC_libtcc_list_symbols, 1},
 
     {"RC_libtcc_ptr_valid",   (DL_FUNC) &RC_libtcc_ptr_valid,   1},
     {"RC_get_external_ptr_addr", (DL_FUNC) &RC_get_external_ptr_addr, 1},