emu_elf_symbols.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.h>
#include <string.h>
 
#include "emu_elf.h"
#include "emu_elf_source_internal.h"

typedef enum : uint32_t {
  k_elf_symbol_entry_min     = 16U,  
  k_elf_string_chunk         = 256U, 
  k_elf_sht_symtab           = 2U,   
  k_elf_word_high_shift      = 24U,  
  k_elf_data_offset          = 5U,   
  k_elf_shentsize_offset     = 46U,  
  k_elf_section_count_offset = 48U,  
} emu_elf_symbol_limit_t;

typedef struct {
  uint32_t offset;     
  uint16_t entry_size; 
  uint16_t count;      
} emu_elf_section_table_t;

typedef struct {
  uint32_t symbol_offset; 
  uint32_t symbol_count;  
  uint32_t entry_size;    
  uint32_t string_offset; 
  uint32_t string_size;   
} emu_elf_symbol_table_t;

RA8_INTERNAL static uint16_t internal_symbol_u16(const uint8_t* bytes)
{
  return (uint16_t)((uint16_t)bytes[0] | ((uint16_t)bytes[1] << 8U));
}

RA8_INTERNAL static uint32_t internal_symbol_u32(const uint8_t* bytes)
{
  return (uint32_t)bytes[0] | ((uint32_t)bytes[1] << 8U) | ((uint32_t)bytes[2] << 16U) |
         ((uint32_t)bytes[3] << k_elf_word_high_shift);
}

RA8_INTERNAL static bool
internal_symbol_read(const emu_elf_source_t* elf, uint64_t offset, uint8_t* bytes, size_t length)
{
  emu_elf_view_t view = {};
  return priv_emu_elf_read(elf, offset, length, bytes, length, &view).status == k_emu_elf_io_ok;
}

RA8_INTERNAL static bool internal_section_table(const emu_elf_source_t*  elf,
                                                emu_elf_section_table_t* table)
{
  uint8_t bytes[k_elf_ehdr_size] = {};
  if (!internal_symbol_read(elf, 0U, bytes, sizeof(bytes)) ||
      (memcmp(bytes,
              "\x7F"
              "ELF",
              4U) != 0) ||
      (bytes[4] != 1U) || (bytes[k_elf_data_offset] != 1U)) {
    return false;
  }
  const emu_elf_section_table_t decoded = {
    .offset     = internal_symbol_u32(&bytes[32]),
    .entry_size = internal_symbol_u16(&bytes[k_elf_shentsize_offset]),
    .count      = internal_symbol_u16(&bytes[k_elf_section_count_offset]),
  };
  const uint64_t table_bytes = (uint64_t)decoded.entry_size * decoded.count;
  if ((decoded.offset == 0U) || (decoded.entry_size < k_elf_shentsize_min) ||
      ((uint64_t)decoded.offset > elf->length) || (table_bytes > (elf->length - decoded.offset))) {
    return false;
  }
  *table = decoded;
  return true;
}

RA8_INTERNAL static bool internal_section_read(const emu_elf_source_t*        elf,
                                               const emu_elf_section_table_t* sections,
                                               uint32_t                       index,
                                               uint8_t bytes[k_elf_shentsize_min])
{
  const uint64_t offset = (uint64_t)sections->offset + ((uint64_t)index * sections->entry_size);
  return internal_symbol_read(elf, offset, bytes, k_elf_shentsize_min);
}

RA8_INTERNAL static bool internal_symbol_table(const emu_elf_source_t*        elf,
                                               const emu_elf_section_table_t* sections,
                                               const uint8_t           bytes[k_elf_shentsize_min],
                                               emu_elf_symbol_table_t* table)
{
  const uint32_t type       = internal_symbol_u32(&bytes[4]);
  const uint32_t symbol_off = internal_symbol_u32(&bytes[16]);
  const uint32_t symbol_sz  = internal_symbol_u32(&bytes[k_elf_sh_size_off]);
  const uint32_t link       = internal_symbol_u32(&bytes[k_elf_sh_link_off]);
  const uint32_t entry_sz   = internal_symbol_u32(&bytes[k_elf_sh_entsize_off]);
  if ((type != k_elf_sht_symtab) || (entry_sz < k_elf_symbol_entry_min) ||
      (link >= sections->count) || ((uint64_t)symbol_off > elf->length) ||
      ((uint64_t)symbol_sz > (elf->length - symbol_off))) {
    return false;
  }
  uint8_t strings[k_elf_shentsize_min] = {};
  if (!internal_section_read(elf, sections, link, strings)) {
    return false;
  }
  const uint32_t string_off = internal_symbol_u32(&strings[16]);
  const uint32_t string_sz  = internal_symbol_u32(&strings[k_elf_sh_size_off]);
  if (((uint64_t)string_off > elf->length) || ((uint64_t)string_sz > (elf->length - string_off))) {
    return false;
  }
  *table = (emu_elf_symbol_table_t){
    .symbol_offset = symbol_off,
    .symbol_count  = symbol_sz / entry_sz,
    .entry_size    = entry_sz,
    .string_offset = string_off,
    .string_size   = string_sz,
  };
  return true;
}

RA8_INTERNAL static bool internal_symbol_walk(const emu_elf_source_t*       elf,
                                              const emu_elf_symbol_table_t* table,
                                              emu_elf_symbol_fn             fn,
                                              void*                         ctx,
                                              uint32_t*                     visited)
{
  for (uint32_t index = 0U; index < table->symbol_count; index++) {
    uint8_t        bytes[k_elf_symbol_entry_min] = {};
    const uint64_t offset = (uint64_t)table->symbol_offset + ((uint64_t)index * table->entry_size);
    if (!internal_symbol_read(elf, offset, bytes, sizeof(bytes))) {
      return false;
    }
    const uint32_t relative_name = internal_symbol_u32(bytes);
    if (relative_name >= table->string_size) {
      continue;
    }
    const emu_elf_symbol_t symbol = {
      .name_offset = (uint64_t)table->string_offset + relative_name,
      .value       = internal_symbol_u32(&bytes[4]),
      .size        = internal_symbol_u32(&bytes[8]),
      .info        = bytes[k_elf_sym_info_off],
    };
    (*visited)++;
    if (!fn(&symbol, ctx)) {
      return false;
    }
  }
  return true;
}
 
uint32_t elf_foreach_symbol(const emu_elf_source_t* elf, emu_elf_symbol_fn fn, void* ctx)
{
  if ((elf == nullptr) || (fn == nullptr)) {
    return 0U;
  }
  emu_elf_section_table_t sections = {};
  if (!internal_section_table(elf, &sections)) {
    return 0U;
  }
  uint32_t visited = 0U;
  for (uint32_t index = 0U; index < sections.count; index++) {
    uint8_t                bytes[k_elf_shentsize_min] = {};
    emu_elf_symbol_table_t table                      = {};
    if (!internal_section_read(elf, &sections, index, bytes) ||
        !internal_symbol_table(elf, &sections, bytes, &table)) {
      continue;
    }
    if (!internal_symbol_walk(elf, &table, fn, ctx, &visited)) {
      break;
    }
  }
  return visited;
}
 
bool elf_string_foreach(const emu_elf_source_t* elf,
                        uint64_t                offset,
                        emu_elf_string_fn       fn,
                        void*                   ctx)
{
  if ((elf == nullptr) || (fn == nullptr) || ((uint64_t)offset >= elf->length)) {
    return false;
  }
  uint8_t  bytes[k_elf_string_chunk];
  uint64_t cursor = offset;
  while (cursor < elf->length) {
    const uint64_t remaining = elf->length - cursor;
    const size_t   chunk     = (remaining < sizeof(bytes)) ? (size_t)remaining : sizeof(bytes);
    if (!internal_symbol_read(elf, cursor, bytes, chunk)) {
      return false;
    }
    const uint8_t* const end    = (const uint8_t*)memchr(bytes, 0, chunk);
    const size_t         length = (end == nullptr) ? chunk : (size_t)(end - bytes);
    if ((length > 0U) && !fn((const char*)bytes, length, ctx)) {
      return false;
    }
    if (end != nullptr) {
      return true;
    }
    cursor += chunk;
  }
  return false;
}

typedef struct {
  const char* expected; 
  size_t      length;   
  size_t      compared; 
  bool        equal;    
} emu_elf_name_match_t;

RA8_INTERNAL static bool internal_name_chunk(const char* bytes, size_t length, void* opaque)
{
  emu_elf_name_match_t* const match = (emu_elf_name_match_t*)opaque;
  if ((length > (match->length - match->compared)) ||
      (memcmp(bytes, &match->expected[match->compared], length) != 0)) {
    match->equal = false;
    return false;
  }
  match->compared += length;
  return true;
}

typedef struct {
  const emu_elf_source_t* source;  
  const char*             name;    
  size_t                  length;  
  uint32_t                address; 
  uint32_t                size;    
} emu_elf_lookup_t;

RA8_INTERNAL static bool internal_lookup_symbol(const emu_elf_symbol_t* symbol, void* opaque)
{
  emu_elf_lookup_t* const lookup = (emu_elf_lookup_t*)opaque;
  emu_elf_name_match_t match = {.expected = lookup->name, .length = lookup->length, .equal = true};
  const bool           complete =
    elf_string_foreach(lookup->source, symbol->name_offset, internal_name_chunk, &match);
  if (!complete || !match.equal || (match.compared != match.length)) {
    return true;
  }
  lookup->address = symbol->value & ~1U;
  lookup->size    = symbol->size;
  return false;
}
 
uint32_t elf_sym_addr(const emu_elf_source_t* elf, const char* name, uint32_t* size_out)
{
  if (size_out != nullptr) {
    *size_out = 0U;
  }
  if ((elf == nullptr) || (name == nullptr)) {
    return 0U;
  }
  emu_elf_lookup_t lookup = {.source = elf, .name = name, .length = strlen(name)};
  (void)elf_foreach_symbol(elf, internal_lookup_symbol, &lookup);
  if ((lookup.address != 0U) && (size_out != nullptr)) {
    *size_out = lookup.size;
  }
  return lookup.address;
}