[k2] add k2 resolve symbol (#1325)

Author: astrophysik

runtime-light/k2-platform/k2-api.h

@@ -8,6 +8,7 @@
 #include <cstddef>
 #include <cstdint>
 #include <ctime>
+#include <expected>
 #include <memory>
 #include <string_view>
 #include <sys/utsname.h>
@@ -27,6 +28,9 @@ inline constexpr size_t DEFAULT_MEMORY_ALIGN = 16;
 
 inline constexpr int32_t errno_ok = 0;
 inline constexpr int32_t errno_einval = EINVAL;
+inline constexpr int32_t errno_enodata = ENODATA;
+inline constexpr int32_t errno_efault = EFAULT;
+inline constexpr int32_t errno_enomem = ENOMEM;
 
 inline constexpr uint64_t INVALID_PLATFORM_DESCRIPTOR = 0;
 
@@ -234,4 +238,47 @@ inline int32_t iconv(size_t* result, void* iconv_cd, char** inbuf, size_t* inbyt
   return k2_iconv(result, iconv_cd, inbuf, inbytesleft, outbuf, outbytesleft);
 }
 
+struct SymbolInfo {
+  std::unique_ptr<char, decltype(std::addressof(k2::free))> name;
+  std::unique_ptr<char, decltype(std::addressof(k2::free))> filename;
+  uint32_t lineno;
+};
+
+inline std::expected<k2::SymbolInfo, int32_t> resolve_symbol(void* addr) noexcept {
+  size_t name_len{};
+  if (auto error_code{k2_symbol_name_len(addr, std::addressof(name_len))}; error_code != k2::errno_ok) [[unlikely]] {
+    return std::unexpected{error_code};
+  }
+  size_t filename_len{};
+  if (auto error_code{k2_symbol_filename_len(addr, std::addressof(filename_len))}; error_code != k2::errno_ok) [[unlikely]] {
+    return std::unexpected{error_code};
+  }
+
+  // +1 since we get non-null-terminated strings from platform and we want to null-terminate them on our side
+  auto* name{static_cast<char*>(k2::alloc(name_len + 1))};
+  if (name == nullptr) [[unlikely]] {
+    return std::unexpected{k2::errno_enomem};
+  }
+
+  auto* filename{static_cast<char*>(k2::alloc(filename_len + 1))};
+  if (filename == nullptr) [[unlikely]] {
+    return std::unexpected{k2::errno_enomem};
+  }
+
+  ::SymbolInfo symbol_info{.name = name, .filename = filename, .lineno = 0};
+  if (auto error_code{k2_resolve_symbol(addr, std::addressof(symbol_info))}; error_code != k2::errno_ok) [[unlikely]] {
+    k2::free(filename);
+    k2::free(name);
+    return std::unexpected{error_code};
+  }
+
+  // null-terminate
+  name[name_len] = '\0';
+  filename[filename_len] = '\0';
+
+  return k2::SymbolInfo{.name = std::unique_ptr<char, decltype(std::addressof(k2::free))>{name, k2::free},
+                        .filename = std::unique_ptr<char, decltype(std::addressof(k2::free))>{filename, k2::free},
+                        .lineno = symbol_info.lineno};
+}
+
 } // namespace k2

runtime-light/k2-platform/k2-header.h

@@ -436,6 +436,51 @@ uint32_t k2_env_value_len(uint32_t env_num);
  */
 void k2_env_fetch(uint32_t env_num, char* key, char* value);
 
+// diagnostic functions for instance debugging
+
+/**
+ * Return symbol name's len that overlaps address
+ * @param `addr` pointer to code instruction
+ * @param `name_len` buffer where symbol name's len will be written
+ * @return: `0` on success, `errno != 0` otherwise
+ * `errno` options:
+ * `EINVAL`  => `addr` symbol can't be resolved
+ * `ENODATA` => there is no debug information for the image
+ * `EFAULT`  => attempt to dereference a nullptr
+ */
+int32_t k2_symbol_name_len(const void* addr, size_t* name_len);
+
+/**
+ * Return symbol filename's len
+ * @param `addr` pointer to code instruction
+ * @param `filename_len` buffer where symbol filename's will be written
+ * @return: `0` on success, `errno != 0` otherwise
+ * `errno` options:
+ * `EINVAL`  => `addr` symbol can't be resolved
+ * `ENODATA` => there is no debug information for the image
+ * `EFAULT`  => attempt to dereference a nullptr
+ */
+int32_t k2_symbol_filename_len(const void* addr, size_t* filename_len);
+
+struct SymbolInfo {
+  char* name;
+  char* filename;
+  uint32_t lineno;
+};
+
+/**
+ * Returns information about the symbol that overlaps addr and it's position in source code.
+ * Note: name and filename in symbol_info are **not** null-terminated.
+ * @param `addr` pointer to code instruction
+ * @param `symbol_info` structure stores buffers where the name and file name will be written. The buffer
+ *        lens must staisfy `name_len >= k2_symbol_name_len and filename_len >= k2_symbol_filename_len`
+ * `errno` options:
+ * `EINVAL`  => `addr` symbol can't be resolved
+ * `ENODATA` => there is no debug information for the image
+ * `EFAULT`  => attempt to dereference a nullptr
+ */
+int32_t k2_resolve_symbol(const void* addr, struct SymbolInfo* symbol_info);
+
 // ---- libc analogues, designed to work instance-local ----
 
 /**