initial push

m68k/flashlib/elf-utils.c

@@ -0,0 +1,448 @@
+/*
+ * $Id: elf-utils.c,v 1.2 2008/07/31 01:53:44 cjohns Exp $
+ * 
+ * Motorola Background Debug Mode Driver
+ * Copyright (C) 2008  Chris Johns
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ *
+ * ELF Support for libelf.
+ */
+
+#include <fcntl.h>
+#include <string.h>
+#include <stdint.h>
+#include <elf-utils.h>
+
+#if defined (__WIN32__)
+#define ELF_OPEN_MODE (O_RDONLY | O_BINARY)
+#else
+#define ELF_OPEN_MODE (O_RDONLY)
+#endif
+
+void
+elf_handle_init (elf_handle* handle)
+{
+  memset (handle, 0, sizeof (*handle));
+}
+
+int
+elf_open (const char* file, elf_handle* handle, elf_output output)
+{
+  if (handle->fd)
+  {
+    if (output)
+      output ("elf-utils: ELF handle already initialised\n");
+    return 0;
+  }
+
+  if (elf_version (EV_CURRENT) == EV_NONE)
+  {
+    if (output)
+      output ("elf-utils: ELF library initialization failed: %s\n",
+              elf_errmsg (-1));
+    return 0;
+  }
+
+  handle->output = output;
+
+  if ((handle->fd = open (file, ELF_OPEN_MODE, 0)) < 0)
+  {
+    if (handle->output)
+      output ("elf-utils: open %s failed\n", file);
+    return 0;
+  }
+
+  if ((handle->elf = elf_begin (handle->fd, ELF_C_READ, NULL)) == NULL)
+  {
+    close (handle->fd);
+    handle->fd = 0;
+    if (handle->output)
+      output ("elf-utils: elf_begin failed: %s\n", elf_errmsg (-1));
+    return 0;
+  }
+
+  handle->file = strdup (file);
+  handle->ek = elf_kind (handle->elf);
+
+  /* 
+   * Check the executable header.
+   */
+  if (gelf_getehdr (handle->elf, &handle->ehdr) == NULL)
+  {
+    if (handle->output)
+      output ("elf-utils: elf_getehdr failed: %s\n", elf_errmsg (-1));
+    elf_close (handle);
+    return 0;
+  }
+
+  if (handle->ehdr.e_machine != EM_68K)
+  {
+    if (handle->output)
+      output ("elf-utils: machine type not Motorola 68000\n");
+    elf_close (handle);
+    return 0;
+  }
+
+  if ((handle->ehdr.e_type != ET_REL) && (handle->ehdr.e_type != ET_EXEC))
+  {
+    output ("elf-utils: file type no relocable or executable\n");
+    elf_close (handle);
+    return 0;
+  }
+
+  if ((handle->eclass = gelf_getclass (handle->elf)) == ELFCLASSNONE)
+  {
+    if (handle->output)
+      output ("elf-utils: elf_getclass failed: %s\n", elf_errmsg (-1));
+    elf_close (handle);
+    return 0;
+  }
+
+  /* 
+   * No 64-bit Coldfires yet !
+   */
+  if (handle->eclass != ELFCLASS32)
+  {
+    if (handle->output)
+      output ("elf-utils: ELF 64-bit, only 32-bit support: %s\n",
+              handle->file);
+    elf_close (handle);
+    return 0;
+  }
+
+  if (elf_getshnum (handle->elf, &handle->shnum) == 0)
+  {
+    if (handle->output)
+      output ("elf-utils: elf_getshnum failed: %s\n", elf_errmsg (-1));
+    elf_close (handle);
+    return 0;
+  }
+
+  if (elf_getshstrndx (handle->elf, &handle->shstrndx) == 0)
+  {
+    if (handle->output)
+      output ("elf-utils: elf_getshstrndx failed: %s\n", elf_errmsg (-1));
+    elf_close (handle);
+    return 0;
+  }
+
+  if (elf_getphnum (handle->elf, &handle->phnum) == 0)
+  {
+    if (handle->output)
+      output ("elf-utils: elf_getphnum failed: %s\n", elf_errmsg (-1));
+    elf_close (handle);
+    return 0;
+  }
+
+  return 1;
+}
+
+int
+elf_close (elf_handle* handle)
+{
+  if (!handle->fd)
+    return 0;
+
+  elf_end (handle->elf);
+  close (handle->fd);
+  free (handle->file);
+
+  handle->elf = NULL;
+  handle->file = NULL;
+  handle->fd = 0;
+
+  return 1;
+}
+
+int
+elf_has_symbol_table (elf_handle* handle)
+{
+  Elf_Scn* section = NULL;
+  while ((section = elf_nextscn (handle->elf, section)) != 0)
+  {
+    GElf_Shdr shdr;
+    if (gelf_getshdr (section, &shdr) != &shdr)
+    {
+      if (shdr.sh_type == SHT_SYMTAB)
+      {
+        Elf_Data* data = NULL;
+        
+        data = elf_getdata (section, data);
+
+        if ((data == NULL) || (data->d_size == 0))
+          return 0;
+
+        return 1;
+      }
+    }
+  }
+  return 0;
+}
+
+int
+elf_get_symbol (elf_handle* handle, const char* label, GElf_Sym* sym)
+{
+  Elf_Scn* section = NULL;
+  while ((section = elf_nextscn (handle->elf, section)) != 0)
+  {
+    GElf_Shdr shdr;
+
+    if (gelf_getshdr (section, &shdr) == &shdr)
+    {
+      if (shdr.sh_type == SHT_SYMTAB)
+      {
+        Elf_Data* data = NULL;
+        int       symbol = 0;
+        char*     name;
+        
+        data = elf_getdata (section, data);
+
+        if ((data == NULL) || (data->d_size == 0))
+          return 0;
+
+        while (gelf_getsym (data, symbol, sym) == sym)
+        {
+          name = elf_strptr (handle->elf,
+                             shdr.sh_link, (size_t) sym->st_name);
+          if (!name)
+          {
+            if (handle->output)
+              handle->output ("elf-utils: find symbol: %s\n",
+                              elf_errmsg (elf_errno ()));
+            return 0;
+          }
+
+          if (strcmp (label, name) == 0)
+            return 1;
+
+          symbol++;
+        }
+      }
+    }
+  }
+
+  return 0;
+}
+
+int
+elf_get_section_hdr (elf_handle* handle, int secindex, GElf_Shdr* shdr)
+{
+  Elf_Scn* section = NULL;
+  int      count = 1;
+
+  while ((section = elf_nextscn (handle->elf, section)) != 0)
+  {
+    if (count == secindex)
+    {
+      if (gelf_getshdr (section, shdr) == shdr)
+      {
+        return 1;
+      }
+    }
+    count++;
+  }
+  return 0;
+}
+
+void*
+elf_get_section_data (elf_handle* handle, int secindex, uint32_t* size)
+{
+  Elf_Scn* section = NULL;
+  int      count = 1;
+
+  *size = 0;
+  while ((section = elf_nextscn (handle->elf, section)) != 0)
+  {
+    if (count == secindex)
+    {
+      Elf_Data* data = NULL;
+      void*     buffer;
+
+      data = elf_getdata (section, data);
+
+      if (data == NULL)
+        return NULL;
+
+      *size = (uint32_t) data->d_size;
+      return data->d_buf;
+    }
+    count++;
+  }
+  return 0;
+}
+
+void*
+elf_get_section_data_sym (elf_handle* handle, const char* label)
+{
+  GElf_Sym esym;
+
+  if (elf_get_symbol (handle, label, &esym))
+  {
+    Elf_Scn* section = NULL;
+    int      count = 1;
+
+    while ((section = elf_nextscn (handle->elf, section)) != 0)
+    {
+      if (count == esym.st_shndx)
+      {
+        Elf_Data* data = NULL;
+
+        data = elf_getdata (section, data);
+
+        if ((data == NULL) || (data->d_size == 0))
+          return NULL;
+
+        return ((uint8_t *) data->d_buf) + esym.st_value;
+      }
+      count++;
+    }
+  }
+
+  return NULL;
+}
+
+int 
+elf_map_over_sections (elf_handle* handle, elf_section_handler handler,
+                       const char* sname)
+{
+  /*
+   * We need to iterate over the sections, and then for each section we decide
+   * to load, we need to find the program header for that section.  we match
+   * the program header by finding the program header that has the same virtaul
+   * address range.  This yields us with the physical address which is needed
+   * to know where to load the section on the target.  I don't know if this is
+   * the correct way to do this, if not, please fix.
+   */
+  
+  Elf_Scn* section = NULL;
+  int      count = 1;
+  size_t   num_headers = 0;
+
+  if (elf_getphnum (handle->elf, &num_headers) == 0)
+  {
+    if (handle->output)
+      handle->output ("elf-utils: elf_getphnum error\n");
+    return 0;
+  }
+  
+  while ((section = elf_nextscn (handle->elf, section)) != 0)
+  {
+    GElf_Shdr shdr;
+
+    if (gelf_getshdr (section, &shdr) == &shdr) {
+      const char* name;
+      name = elf_strptr (handle->elf, handle->shstrndx, shdr.sh_name);
+
+      if (!sname || (strcmp (sname, name) == 0))
+      {
+        /*
+         * Find a LOAD program header in the same virtual address range.
+         */
+        GElf_Addr vaddr = shdr.sh_addr - shdr.sh_offset;
+        GElf_Phdr phdr;
+        size_t i;
+        
+        for (i = 0; i < num_headers; ++i)
+        {
+          if (gelf_getphdr (handle->elf, i, &phdr) != &phdr)
+          {
+            if (handle->output)
+              handle->output ("elf-utils: gelf_getphdr error\n");
+            return 0;
+          }
+          
+          if(phdr.p_type == PT_LOAD)
+          {
+            if(phdr.p_vaddr <= shdr.sh_addr && 
+               phdr.p_vaddr + phdr.p_memsz > shdr.sh_addr)
+              break;
+          }
+        }
+
+        if(!handler (handle, (i == num_headers) ? 0 : &phdr, &shdr, name, count))
+          return 0;
+      }
+    }
+
+    ++count;
+  }
+  return 1;    
+}
+
+#define PRINT_FORMAT   " %-12s %d\n"
+#define PRINT_FORMAT_X " %-12s 0x%x\n"
+
+void
+elf_show_exeheader (elf_handle* handle)
+{
+#define EHDR_PRINT_FIELD(N) do {                                    \
+    handle->output (PRINT_FORMAT ,#N, (uintmax_t) handle->ehdr.N);  \
+  } while (0)
+
+  char* s;
+
+  if (!handle->output)
+    return;
+
+  switch (handle->ek)
+  {
+    case ELF_K_AR:
+      s = "ar(1) archive";
+      break;
+    case ELF_K_ELF:
+      s = "elf object";
+      break;
+    case ELF_K_NONE:
+      s = "data";
+      break;
+    default:
+      s = "unrecognized";
+  }
+
+  handle->output ("%s: %s\n", handle->file, s);
+
+  EHDR_PRINT_FIELD (e_type);
+  EHDR_PRINT_FIELD (e_machine);
+  EHDR_PRINT_FIELD (e_version);
+  EHDR_PRINT_FIELD (e_entry);
+  EHDR_PRINT_FIELD (e_phoff);
+  EHDR_PRINT_FIELD (e_shoff);
+  EHDR_PRINT_FIELD (e_flags);
+  EHDR_PRINT_FIELD (e_ehsize);
+  EHDR_PRINT_FIELD (e_phentsize);
+  EHDR_PRINT_FIELD (e_shentsize);
+
+  handle->output (PRINT_FORMAT, "(shnum)", (uintmax_t) handle->shnum);
+  handle->output (PRINT_FORMAT, "(shstrndx)", (uintmax_t) handle->shstrndx);
+  handle->output (PRINT_FORMAT, "(phnum)", (uintmax_t) handle->phnum);
+}
+
+void
+elf_show_symbol (elf_handle* handle, GElf_Sym* esym)
+{
+#define ESYM_PRINT_FIELD(N) do {                               \
+    handle->output (PRINT_FORMAT_X ,#N, (uintmax_t) esym->N);  \
+  } while (0)
+
+  if (!handle->output)
+    return;
+
+  ESYM_PRINT_FIELD (st_name);
+  ESYM_PRINT_FIELD (st_value);
+  ESYM_PRINT_FIELD (st_size);
+  ESYM_PRINT_FIELD (st_info);
+  ESYM_PRINT_FIELD (st_other);
+  ESYM_PRINT_FIELD (st_shndx);
+}