Add ElfReader

Author: Derek Hower

.devcontainer/Dockerfile

@@ -23,6 +23,7 @@ RUN apt-get install -y --no-install-recommends cmake
 RUN apt-get install -y --no-install-recommends g++
 RUN apt-get install -y --no-install-recommends clang-format
 RUN apt-get install -y --no-install-recommends clang-tidy
+RUN apt-get install -y --no-install-recommends libelf-dev
 RUN apt-get clean autoclean
 RUN apt-get autoremove -y
 RUN rm -rf /var/lib/{apt,dpkg,cache,log}/*

backends/cpp_hart_gen/CMakeLists.txt

@@ -76,6 +76,7 @@ endforeach()
 add_library(hart
   ${CMAKE_SOURCE_DIR}/src/db_data.cxx
   ${CMAKE_SOURCE_DIR}/src/version.cpp
+  ${CMAKE_SOURCE_DIR}/src/memory.cpp
   ${GENERATED_SRCS}
 #  ../gen/iss/oryon/src/types.cxx
 #  ../gen/iss/oryon/src/csr_types.cxx
@@ -87,8 +88,9 @@ target_link_libraries(hart PUBLIC yaml-cpp::yaml-cpp nlohmann_json_schema_valida
 
 add_executable(iss
   ${CMAKE_SOURCE_DIR}/src/iss.cpp
+  ${CMAKE_SOURCE_DIR}/src/elf_reader.cpp
 )
-target_link_libraries(iss PRIVATE hart CLI11::CLI11)
+target_link_libraries(iss PRIVATE hart elf CLI11::CLI11)
 
 
 ## TESTS

backends/cpp_hart_gen/cpp/include/udb/elf_reader.hpp

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <string>
+
+class Elf;
+namespace udb {
+  // Class to read data out of an ELF file
+  class Memory;
+  class ElfReader {
+    // ElfException is thrown when something goes wrong when reading an ELF file
+    class ElfException : public std::exception {
+     public:
+      ElfException() = default;
+      ElfException(const std::string& what) : std::exception(), m_what(what) {}
+      ElfException(std::string&& what)
+          : std::exception(), m_what(std::move(what)) {}
+
+      const char* what() const noexcept override { return m_what.c_str(); }
+
+     private:
+      const std::string m_what;
+    };
+
+   public:
+    ElfReader() = delete;
+    ElfReader(const std::string& path);
+    ~ElfReader();
+
+    // get the address of a symbol named 'name', and put it in 'result'
+    //
+    // returns false if the symbol is not found, true otherwise
+    bool getSym(const std::string& name, Elf64_Addr* result);
+
+    // Loads all LOADable sections from an ELF into 'm'
+    //
+    // returns the start address
+    uint64_t loadLoadableSegments(Memory& m);
+
+   private:
+    int m_fd;
+    Elf* m_elf;
+  };
+}  // namespace udb

backends/cpp_hart_gen/cpp/src/elf_reader.cpp

@@ -0,0 +1,104 @@
+
+#include <fcntl.h>
+#include <libelf.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#include <udb/elf_reader.hpp>
+#include <udb/memory.hpp>
+
+udb::ElfReader::ElfReader(const std::string& path) {
+  if (elf_version(EV_CURRENT) == EV_NONE) {
+    throw ElfException("Bad Elf version");
+  }
+
+  m_fd = open(path.c_str(), O_RDONLY, 0);
+  if (m_fd < 0) {
+    throw ElfException("Could not open ELF file");
+  }
+
+  m_elf = elf_begin(m_fd, ELF_C_READ, NULL);
+  if (m_elf == nullptr) {
+    throw ElfException("Could not begin reading ELF");
+  }
+
+  if (elf_kind(m_elf) != ELF_K_ELF) {
+    throw ElfException("Not an ELF file");
+  }
+}
+
+udb::ElfReader::~ElfReader() {
+  if (m_elf != nullptr) {
+    elf_end(m_elf);
+    close(m_fd);
+  }
+}
+
+bool udb::ElfReader::getSym(const std::string& name, Elf64_Addr* result) {
+  size_t num_sections;
+  if (elf_getshdrnum(m_elf, &num_sections) != 0) {
+    throw ElfException("Could not determine number of sections");
+  }
+  size_t shstrtab_index;
+  if (elf_getshdrstrndx(m_elf, &shstrtab_index) != 0) {
+    throw ElfException("Could not get Section Header String Table");
+  }
+  // first, find the strtab
+  int strtab_index;
+  for (size_t i = 0; i < num_sections; i++) {
+    auto* strtab_section = elf_getscn(m_elf, i);
+    Elf64_Shdr* header = elf64_getshdr(strtab_section);
+    if (strcmp(elf_strptr(m_elf, shstrtab_index, header->sh_name), ".strtab") ==
+        0) {
+      strtab_index = i;
+      break;
+    }
+  }
+  // now, get the symtab
+  for (size_t i = 0; i < num_sections; i++) {
+    Elf_Scn* section;
+    section = elf_getscn(m_elf, i);
+    Elf64_Shdr* section_header = elf64_getshdr(section);
+    if (strcmp(elf_strptr(m_elf, shstrtab_index, section_header->sh_name),
+               ".symtab") == 0) {
+      unsigned num_syms = section_header->sh_size / section_header->sh_entsize;
+      Elf64_Sym* symtab;
+      Elf_Data* data;
+      if ((data = elf_getdata(section, nullptr)) == nullptr) {
+        throw ElfException(fmt::format("Could not get symtab data. {}",
+                                       elf_errmsg(elf_errno()))
+                               .c_str());
+      }
+      symtab = (Elf64_Sym*)data->d_buf;
+      for (unsigned j = 0; j < num_syms; j++) {
+        if (strcmp(elf_strptr(m_elf, strtab_index, symtab[j].st_name),
+                   name.c_str()) == 0) {
+          *result = symtab[j].st_value;
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+
+// returns start address
+uint64_t udb::ElfReader::loadLoadableSegments(Memory& m) {
+  Elf64_Phdr* phdr;
+  size_t n;
+
+  if (elf_getphdrnum(m_elf, &n) != 0) {
+    throw ElfException("Could not find number of Program Headers");
+  }
+
+  phdr = elf64_getphdr(m_elf);
+  for (size_t i = 0; i < n; i++) {
+    if (phdr[i].p_type == PT_LOAD) {
+      Elf_Data* d = elf_getdata_rawchunk(m_elf, phdr[i].p_offset,
+                                         phdr[i].p_filesz, ELF_T_BYTE);
+      m.memcpy_from_host(phdr[i].p_vaddr, d->d_buf, d->d_size);
+    }
+  }
+
+  return elf64_getehdr(m_elf)->e_entry;
+}

backends/cpp_hart_gen/cpp/src/memory.cpp

@@ -0,0 +1,34 @@
+
+#include "udb/memory.hpp"
+
+void udb::Memory::memcpy_from_host(uint64_t guest_paddr, const void* host_ptr,
+                                   size_t size) {
+  const size_t SZ_64 = sizeof(uint64_t);
+  auto host_ptr64 = (const uint64_t*)host_ptr;  // NOLINT
+  while (size >= SZ_64) {
+    write((guest_paddr += SZ_64) - SZ_64, *host_ptr64++);
+    size -= SZ_64;
+  }
+
+  auto host_ptr8 = (const uint8_t*)host_ptr64;  // NOLINT
+  while (size > 0) {
+    write(guest_paddr++, *host_ptr8++);
+    size--;
+  }
+}
+
+void udb::Memory::memcpy_to_host(void* host_ptr, uint64_t guest_paddr,
+                                 size_t size) {
+  const size_t SZ_64 = sizeof(uint64_t);
+  auto host_ptr64 = (uint64_t*)host_ptr;  // NOLINT
+  while (size >= SZ_64) {
+    *(host_ptr64++) = read<uint64_t>(guest_paddr += SZ_64);
+    size -= SZ_64;
+  }
+
+  auto host_ptr8 = (uint8_t*)host_ptr64;  // NOLINT
+  while (size > 0) {
+    *(host_ptr8++) = read<uint8_t>(guest_paddr += SZ_64);
+    size--;
+  }
+}

container.def

@@ -39,6 +39,7 @@ From: ubuntu:24.04
   apt-get install -y --no-install-recommends libgmp-dev
   apt-get install -y --no-install-recommends clang-format
   apt-get install -y --no-install-recommends clang-tidy
+  apt-get install -y --no-install-recommends libelf-dev
 
   # cleanup
   apt-get clean autoclean