Re: [PATCH] fix for loading modules from read-only memory area (Re: clean patch for i386-qemu port (Re: [PATCH] i386-qemu port))

[Pavel Roskin <proski@gnu.org>]

[-- Attachment #1: Type: text/plain, Size: 830 bytes --]

On Fri, 2009-06-26 at 16:41 +0200, Robert Millan wrote:
> On Thu, Jun 25, 2009 at 04:51:11PM -0400, Pavel Roskin wrote:
> > 
> > I'd like to avoid preprocessor conditionals in kern/ARCH/dl.c files if
> > possible.
> 
> Alright, here's a new patch.  It follows your earlier suggestion to use
> a wrapper to obtain the initialization address for symtab.  This way we
> don't put any ifdefs in kern/ARCH/dl.c files.
> 
> I also avoid the #undefs in efiemu.  This required many changes in
> loadcore.c, but they're just a sed search & replace run.

More redefinitions are needed to make all platforms compile.  At this
point I think maybe we should try something less intrusive.  But anyway,
02-elf-renames.patch contains those renames.

03-simple-symtab.patch simplifies the logic in kern/ARCH/dl.c files.

-- 
Regards,
Pavel Roskin

[-- Attachment #2: 02-elf-renames.patch --]
[-- Type: text/x-patch, Size: 29661 bytes --]

More elf definitions changed.

From: Pavel Roskin <proski@gnu.org>

Use ElfT in grub-mkelfimage, ElfK in loaders.
---

 loader/i386/bsd32.c           |    6 -
 loader/i386/bsd64.c           |    6 -
 loader/i386/bsdXX.c           |   44 +++--
 loader/i386/multiboot_elfxx.c |   18 +-
 util/i386/efi/grub-mkimage.c  |  344 +++++++++++++++++++++--------------------
 5 files changed, 209 insertions(+), 209 deletions(-)


diff --git a/loader/i386/bsd32.c b/loader/i386/bsd32.c
index 24dab6c..cf3e958 100644
--- a/loader/i386/bsd32.c
+++ b/loader/i386/bsd32.c
@@ -1,7 +1,7 @@
 #define SUFFIX(x) x ## 32
-#define Elf_Ehdr Elf32_Ehdr
-#define Elf_Shdr Elf32_Shdr
-#define Elf_Sym Elf32_Sym
+#define ElfK_Ehdr Elf32_Ehdr
+#define ElfK_Shdr Elf32_Shdr
+#define ElfK_Sym Elf32_Sym
 #define OBJSYM 0
 #include <grub/types.h>
 typedef grub_uint32_t grub_freebsd_addr_t;
diff --git a/loader/i386/bsd64.c b/loader/i386/bsd64.c
index f4ff8b2..514006f 100644
--- a/loader/i386/bsd64.c
+++ b/loader/i386/bsd64.c
@@ -1,7 +1,7 @@
 #define SUFFIX(x) x ## 64
-#define Elf_Ehdr Elf64_Ehdr
-#define Elf_Shdr Elf64_Shdr
-#define Elf_Sym Elf64_Sym
+#define ElfK_Ehdr Elf64_Ehdr
+#define ElfK_Shdr Elf64_Shdr
+#define ElfK_Sym Elf64_Sym
 #define OBJSYM 1
 #include <grub/types.h>
 typedef grub_uint64_t grub_freebsd_addr_t;
diff --git a/loader/i386/bsdXX.c b/loader/i386/bsdXX.c
index 3f15579..4f67fb3 100644
--- a/loader/i386/bsdXX.c
+++ b/loader/i386/bsdXX.c
@@ -27,7 +27,7 @@ load (grub_file_t file, void *where, grub_off_t off, grub_size_t size)
 }
 
 static inline grub_err_t
-read_headers (grub_file_t file, Elf_Ehdr *e, char **shdr)
+read_headers (grub_file_t file, ElfK_Ehdr *e, char **shdr)
 {
  if (grub_file_seek (file, 0) == (grub_off_t) -1)
     return grub_errno;
@@ -78,8 +78,8 @@ grub_err_t
 SUFFIX (grub_freebsd_load_elfmodule_obj) (grub_file_t file, int argc,
 					  char *argv[], grub_addr_t *kern_end)
 {
-  Elf_Ehdr e;
-  Elf_Shdr *s;
+  ElfK_Ehdr e;
+  ElfK_Shdr *s;
   char *shdr;
   grub_addr_t curload, module;
   grub_err_t err;
@@ -90,9 +90,9 @@ SUFFIX (grub_freebsd_load_elfmodule_obj) (grub_file_t file, int argc,
 
   curload = module = ALIGN_PAGE (*kern_end);
 
-  for (s = (Elf_Shdr *) shdr; s < (Elf_Shdr *) ((char *) shdr
-						+ e.e_shnum * e.e_shentsize);
-       s = (Elf_Shdr *) ((char *) s + e.e_shentsize))
+  for (s = (ElfK_Shdr *) shdr; s < (ElfK_Shdr *) ((char *) shdr +
+						  e.e_shnum * e.e_shentsize);
+       s = (ElfK_Shdr *) ((char *) s + e.e_shentsize))
     {
       if (s->sh_size == 0)
 	continue;
@@ -146,8 +146,8 @@ grub_err_t
 SUFFIX (grub_freebsd_load_elfmodule) (grub_file_t file, int argc, char *argv[],
 				      grub_addr_t *kern_end)
 {
-  Elf_Ehdr e;
-  Elf_Shdr *s;
+  ElfK_Ehdr e;
+  ElfK_Shdr *s;
   char *shdr;
   grub_addr_t curload, module;
   grub_err_t err;
@@ -158,9 +158,9 @@ SUFFIX (grub_freebsd_load_elfmodule) (grub_file_t file, int argc, char *argv[],
 
   curload = module = ALIGN_PAGE (*kern_end);
 
-  for (s = (Elf_Shdr *) shdr; s < (Elf_Shdr *) ((char *) shdr
-						+ e.e_shnum * e.e_shentsize);
-       s = (Elf_Shdr *) ((char *) s + e.e_shentsize))
+  for (s = (ElfK_Shdr *) shdr; s < (ElfK_Shdr *) ((char *) shdr +
+						  e.e_shnum * e.e_shentsize);
+       s = (ElfK_Shdr *) ((char *) s + e.e_shentsize))
     {
       if (s->sh_size == 0)
 	continue;
@@ -221,13 +221,13 @@ grub_err_t
 SUFFIX (grub_freebsd_load_elf_meta) (grub_file_t file, grub_addr_t *kern_end)
 {
   grub_err_t err;
-  Elf_Ehdr e;
-  Elf_Shdr *s;
+  ElfK_Ehdr e;
+  ElfK_Shdr *s;
   char *shdr;
   unsigned symoff, stroff, symsize, strsize;
   grub_addr_t curload;
   grub_freebsd_addr_t symstart, symend, symentsize, dynamic;
-  Elf_Sym *sym;
+  ElfK_Sym *sym;
   const char *str;
   unsigned i;
 
@@ -241,18 +241,18 @@ SUFFIX (grub_freebsd_load_elf_meta) (grub_file_t file, grub_addr_t *kern_end)
   if (err)
     return err;
 
-  for (s = (Elf_Shdr *) shdr; s < (Elf_Shdr *) (shdr
-						+ e.e_shnum * e.e_shentsize);
-       s = (Elf_Shdr *) ((char *) s + e.e_shentsize))
+  for (s = (ElfK_Shdr *) shdr; s < (ElfK_Shdr *) (shdr +
+						  e.e_shnum * e.e_shentsize);
+       s = (ElfK_Shdr *) ((char *) s + e.e_shentsize))
       if (s->sh_type == SHT_SYMTAB)
 	break;
-  if (s >= (Elf_Shdr *) ((char *) shdr
-			+ e.e_shnum * e.e_shentsize))
+  if (s >= (ElfK_Shdr *) ((char *) shdr +
+			  e.e_shnum * e.e_shentsize))
     return grub_error (GRUB_ERR_BAD_OS, "no symbol table");
   symoff = s->sh_offset;
   symsize = s->sh_size;
   symentsize = s->sh_entsize;
-  s = (Elf_Shdr *) (shdr + e.e_shentsize * s->sh_link);
+  s = (ElfK_Shdr *) (shdr + e.e_shentsize * s->sh_link);
   stroff = s->sh_offset;
   strsize = s->sh_size;
 
@@ -266,7 +266,7 @@ SUFFIX (grub_freebsd_load_elf_meta) (grub_file_t file, grub_addr_t *kern_end)
   curload += sizeof (grub_freebsd_addr_t);
   if (grub_file_seek (file, symoff) == (grub_off_t) -1)
     return grub_errno;
-  sym = (Elf_Sym *) UINT_TO_PTR (curload);
+  sym = (ElfK_Sym *) UINT_TO_PTR (curload);
   if (grub_file_read (file, UINT_TO_PTR (curload), symsize) !=
       (grub_ssize_t) symsize)
     {
@@ -294,7 +294,7 @@ SUFFIX (grub_freebsd_load_elf_meta) (grub_file_t file, grub_addr_t *kern_end)
 
   for (i = 0;
        i * symentsize < symsize;
-       i++, sym = (Elf_Sym *) ((char *) sym + symentsize))
+       i++, sym = (ElfK_Sym *) ((char *) sym + symentsize))
     {
       const char *name = str + sym->st_name;
       if (grub_strcmp (name, "_DYNAMIC") == 0)
diff --git a/loader/i386/multiboot_elfxx.c b/loader/i386/multiboot_elfxx.c
index 77c4711..732c90f 100644
--- a/loader/i386/multiboot_elfxx.c
+++ b/loader/i386/multiboot_elfxx.c
@@ -20,14 +20,14 @@
 # define XX		32
 # define E_MACHINE	EM_386
 # define ELFCLASSXX	ELFCLASS32
-# define Elf_Ehdr	Elf32_Ehdr
-# define Elf_Phdr	Elf32_Phdr
+# define ElfK_Ehdr	Elf32_Ehdr
+# define ElfK_Phdr	Elf32_Phdr
 #elif defined(MULTIBOOT_LOAD_ELF64)
 # define XX		64
 # define E_MACHINE	EM_X86_64
 # define ELFCLASSXX	ELFCLASS64
-# define Elf_Ehdr	Elf64_Ehdr
-# define Elf_Phdr	Elf64_Phdr
+# define ElfK_Ehdr	Elf64_Ehdr
+# define ElfK_Phdr	Elf64_Phdr
 #else
 #error "I'm confused"
 #endif
@@ -39,7 +39,7 @@
 static int
 CONCAT(grub_multiboot_is_elf, XX) (void *buffer)
 {
-  Elf_Ehdr *ehdr = (Elf_Ehdr *) buffer;
+  ElfK_Ehdr *ehdr = (ElfK_Ehdr *) buffer;
 
   return ehdr->e_ident[EI_CLASS] == ELFCLASSXX;
 }
@@ -47,7 +47,7 @@ CONCAT(grub_multiboot_is_elf, XX) (void *buffer)
 static grub_err_t
 CONCAT(grub_multiboot_load_elf, XX) (grub_file_t file, void *buffer)
 {
-  Elf_Ehdr *ehdr = (Elf_Ehdr *) buffer;
+  ElfK_Ehdr *ehdr = (ElfK_Ehdr *) buffer;
   char *phdr_base;
   int lowest_segment = -1, highest_segment = -1;
   int i;
@@ -78,7 +78,7 @@ CONCAT(grub_multiboot_load_elf, XX) (grub_file_t file, void *buffer)
 #endif
 
   phdr_base = (char *) buffer + ehdr->e_phoff;
-#define phdr(i)			((Elf_Phdr *) (phdr_base + (i) * ehdr->e_phentsize))
+#define phdr(i)			((ElfK_Phdr *) (phdr_base + (i) * ehdr->e_phentsize))
 
   for (i = 0; i < ehdr->e_phnum; i++)
     if (phdr(i)->p_type == PT_LOAD && phdr(i)->p_filesz != 0)
@@ -151,5 +151,5 @@ CONCAT(grub_multiboot_load_elf, XX) (grub_file_t file, void *buffer)
 #undef XX
 #undef E_MACHINE
 #undef ELFCLASSXX
-#undef Elf_Ehdr
-#undef Elf_Phdr
+#undef ElfK_Ehdr
+#undef ElfK_Phdr
diff --git a/util/i386/efi/grub-mkimage.c b/util/i386/efi/grub-mkimage.c
index 2813e79..2ab25f3 100644
--- a/util/i386/efi/grub-mkimage.c
+++ b/util/i386/efi/grub-mkimage.c
@@ -33,39 +33,39 @@
 
 #if GRUB_TARGET_SIZEOF_VOID_P == 4
 
-typedef Elf32_Word Elf_Word;
-typedef Elf32_Addr Elf_Addr;
-typedef Elf32_Ehdr Elf_Ehdr;
-typedef Elf32_Shdr Elf_Shdr;
-typedef Elf32_Sym Elf_Sym;
-typedef Elf32_Half Elf_Half;
-typedef Elf32_Off Elf_Off;
-typedef Elf32_Section Elf_Section;
-typedef Elf32_Rel Elf_Rel;
-typedef Elf32_Rela Elf_Rela;
-
-#define ELF_R_SYM	ELF32_R_SYM
-#define ELF_R_TYPE	ELF32_R_TYPE
-#define ELF_R_INFO	ELF32_R_INFO
+typedef Elf32_Word ElfT_Word;
+typedef Elf32_Addr ElfT_Addr;
+typedef Elf32_Ehdr ElfT_Ehdr;
+typedef Elf32_Shdr ElfT_Shdr;
+typedef Elf32_Sym ElfT_Sym;
+typedef Elf32_Half ElfT_Half;
+typedef Elf32_Off ElfT_Off;
+typedef Elf32_Section ElfT_Section;
+typedef Elf32_Rel ElfT_Rel;
+typedef Elf32_Rela ElfT_Rela;
+
+#define ELFT_R_SYM	ELF32_R_SYM
+#define ELFT_R_TYPE	ELF32_R_TYPE
+#define ELFT_R_INFO	ELF32_R_INFO
 
 #define grub_le_to_cpu	grub_le_to_cpu32
 
 #elif GRUB_TARGET_SIZEOF_VOID_P == 8
 
-typedef Elf64_Word Elf_Word;
-typedef Elf64_Addr Elf_Addr;
-typedef Elf64_Ehdr Elf_Ehdr;
-typedef Elf64_Shdr Elf_Shdr;
-typedef Elf64_Sym Elf_Sym;
-typedef Elf64_Half Elf_Half;
-typedef Elf64_Off Elf_Off;
-typedef Elf64_Section Elf_Section;
-typedef Elf64_Rel Elf_Rel;
-typedef Elf64_Rela Elf_Rela;
-
-#define ELF_R_SYM	ELF64_R_SYM
-#define ELF_R_TYPE	ELF64_R_TYPE
-#define ELF_R_INFO	ELF64_R_INFO
+typedef Elf64_Word ElfT_Word;
+typedef Elf64_Addr ElfT_Addr;
+typedef Elf64_Ehdr ElfT_Ehdr;
+typedef Elf64_Shdr ElfT_Shdr;
+typedef Elf64_Sym ElfT_Sym;
+typedef Elf64_Half ElfT_Half;
+typedef Elf64_Off ElfT_Off;
+typedef Elf64_Section ElfT_Section;
+typedef Elf64_Rel ElfT_Rel;
+typedef Elf64_Rela ElfT_Rela;
+
+#define ELFT_R_SYM	ELF64_R_SYM
+#define ELFT_R_TYPE	ELF64_R_TYPE
+#define ELFT_R_INFO	ELF64_R_INFO
 
 #define grub_le_to_cpu	grub_le_to_cpu64
 
@@ -73,14 +73,14 @@ typedef Elf64_Rela Elf_Rela;
 
 static const grub_uint8_t stub[] = GRUB_PE32_MSDOS_STUB;
 
-static inline Elf_Addr
-align_address (Elf_Addr addr, unsigned alignment)
+static inline ElfT_Addr
+align_address (ElfT_Addr addr, unsigned alignment)
 {
   return (addr + alignment - 1) & ~(alignment - 1);
 }
 
-static inline Elf_Addr
-align_pe32_section (Elf_Addr addr)
+static inline ElfT_Addr
+align_pe32_section (ElfT_Addr addr)
 {
   return align_address (addr, GRUB_PE32_SECTION_ALIGNMENT);
 }
@@ -103,7 +103,7 @@ read_kernel_module (const char *dir, size_t *size)
 
 /* Return if the ELF header is valid.  */
 static int
-check_elf_header (Elf_Ehdr *e, size_t size)
+check_elf_header (ElfT_Ehdr *e, size_t size)
 {
   if (size < sizeof (*e)
       || e->e_ident[EI_MAG0] != ELFMAG0
@@ -125,7 +125,7 @@ check_elf_header (Elf_Ehdr *e, size_t size)
 /* Return the starting address right after the header,
    aligned by the section alignment. Allocate 4 section tables for
    .text, .data, .reloc, and mods.  */
-static Elf_Addr
+static ElfT_Addr
 get_starting_section_address (void)
 {
   return align_pe32_section (sizeof (struct grub_pe32_header)
@@ -135,7 +135,7 @@ get_starting_section_address (void)
 /* Determine if this section is a text section. Return false if this
    section is not allocated.  */
 static int
-is_text_section (Elf_Shdr *s)
+is_text_section (ElfT_Shdr *s)
 {
   return ((s->sh_flags & grub_cpu_to_le32 (SHF_EXECINSTR | SHF_ALLOC))
 	  == grub_cpu_to_le32 (SHF_EXECINSTR | SHF_ALLOC));
@@ -145,7 +145,7 @@ is_text_section (Elf_Shdr *s)
    BSS is also a data section, since the converter initializes BSS
    when producing PE32 to avoid a bug in EFI implementations.  */
 static int
-is_data_section (Elf_Shdr *s)
+is_data_section (ElfT_Shdr *s)
 {
   return (s->sh_flags & grub_cpu_to_le32 (SHF_ALLOC)
 	  && ! (s->sh_flags & grub_cpu_to_le32 (SHF_EXECINSTR)));
@@ -154,14 +154,14 @@ is_data_section (Elf_Shdr *s)
 /* Locate section addresses by merging code sections and data sections
    into .text and .data, respectively. Return the array of section
    addresses.  */
-static Elf_Addr *
-locate_sections (Elf_Shdr *sections, Elf_Half section_entsize,
-		 Elf_Half num_sections, const char *strtab)
+static ElfT_Addr *
+locate_sections (ElfT_Shdr *sections, ElfT_Half section_entsize,
+		 ElfT_Half num_sections, const char *strtab)
 {
   int i;
-  Elf_Addr current_address;
-  Elf_Addr *section_addresses;
-  Elf_Shdr *s;
+  ElfT_Addr current_address;
+  ElfT_Addr *section_addresses;
+  ElfT_Shdr *s;
 
   section_addresses = xmalloc (sizeof (*section_addresses) * num_sections);
   memset (section_addresses, 0, sizeof (*section_addresses) * num_sections);
@@ -171,10 +171,10 @@ locate_sections (Elf_Shdr *sections, Elf_Half section_entsize,
   /* .text */
   for (i = 0, s = sections;
        i < num_sections;
-       i++, s = (Elf_Shdr *) ((char *) s + section_entsize))
+       i++, s = (ElfT_Shdr *) ((char *) s + section_entsize))
     if (is_text_section (s))
       {
-	Elf_Word align = grub_le_to_cpu32 (s->sh_addralign);
+	ElfT_Word align = grub_le_to_cpu32 (s->sh_addralign);
 	const char *name = strtab + grub_le_to_cpu32 (s->sh_name);
 
 	if (align)
@@ -191,10 +191,10 @@ locate_sections (Elf_Shdr *sections, Elf_Half section_entsize,
   /* .data */
   for (i = 0, s = sections;
        i < num_sections;
-       i++, s = (Elf_Shdr *) ((char *) s + section_entsize))
+       i++, s = (ElfT_Shdr *) ((char *) s + section_entsize))
     if (is_data_section (s))
       {
-	Elf_Word align = grub_le_to_cpu32 (s->sh_addralign);
+	ElfT_Word align = grub_le_to_cpu32 (s->sh_addralign);
 	const char *name = strtab + grub_le_to_cpu32 (s->sh_name);
 
 	if (align)
@@ -210,16 +210,16 @@ locate_sections (Elf_Shdr *sections, Elf_Half section_entsize,
 }
 
 /* Return the symbol table section, if any.  */
-static Elf_Shdr *
-find_symtab_section (Elf_Shdr *sections,
-		     Elf_Half section_entsize, Elf_Half num_sections)
+static ElfT_Shdr *
+find_symtab_section (ElfT_Shdr *sections,
+		     ElfT_Half section_entsize, ElfT_Half num_sections)
 {
   int i;
-  Elf_Shdr *s;
+  ElfT_Shdr *s;
 
   for (i = 0, s = sections;
        i < num_sections;
-       i++, s = (Elf_Shdr *) ((char *) s + section_entsize))
+       i++, s = (ElfT_Shdr *) ((char *) s + section_entsize))
     if (s->sh_type == grub_cpu_to_le32 (SHT_SYMTAB))
       return s;
 
@@ -228,12 +228,12 @@ find_symtab_section (Elf_Shdr *sections,
 
 /* Return the address of the string table.  */
 static const char *
-find_strtab (Elf_Ehdr *e, Elf_Shdr *sections, Elf_Half section_entsize)
+find_strtab (ElfT_Ehdr *e, ElfT_Shdr *sections, ElfT_Half section_entsize)
 {
-  Elf_Shdr *s;
+  ElfT_Shdr *s;
   char *strtab;
 
-  s = (Elf_Shdr *) ((char *) sections
+  s = (ElfT_Shdr *) ((char *) sections
 		      + grub_le_to_cpu16 (e->e_shstrndx) * section_entsize);
   strtab = (char *) e + grub_le_to_cpu32 (s->sh_offset);
   return strtab;
@@ -241,21 +241,21 @@ find_strtab (Elf_Ehdr *e, Elf_Shdr *sections, Elf_Half section_entsize)
 
 /* Relocate symbols; note that this function overwrites the symbol table.
    Return the address of a start symbol.  */
-static Elf_Addr
-relocate_symbols (Elf_Ehdr *e, Elf_Shdr *sections,
-		  Elf_Shdr *symtab_section, Elf_Addr *section_addresses,
-		  Elf_Half section_entsize, Elf_Half num_sections)
+static ElfT_Addr
+relocate_symbols (ElfT_Ehdr *e, ElfT_Shdr *sections,
+		  ElfT_Shdr *symtab_section, ElfT_Addr *section_addresses,
+		  ElfT_Half section_entsize, ElfT_Half num_sections)
 {
-  Elf_Word symtab_size, sym_size, num_syms;
-  Elf_Off symtab_offset;
-  Elf_Addr start_address = 0;
-  Elf_Sym *sym;
-  Elf_Word i;
-  Elf_Shdr *strtab_section;
+  ElfT_Word symtab_size, sym_size, num_syms;
+  ElfT_Off symtab_offset;
+  ElfT_Addr start_address = 0;
+  ElfT_Sym *sym;
+  ElfT_Word i;
+  ElfT_Shdr *strtab_section;
   const char *strtab;
 
   strtab_section
-    = (Elf_Shdr *) ((char *) sections
+    = (ElfT_Shdr *) ((char *) sections
 		      + (grub_le_to_cpu32 (symtab_section->sh_link)
 			 * section_entsize));
   strtab = (char *) e + grub_le_to_cpu32 (strtab_section->sh_offset);
@@ -265,11 +265,11 @@ relocate_symbols (Elf_Ehdr *e, Elf_Shdr *sections,
   symtab_offset = grub_le_to_cpu32 (symtab_section->sh_offset);
   num_syms = symtab_size / sym_size;
 
-  for (i = 0, sym = (Elf_Sym *) ((char *) e + symtab_offset);
+  for (i = 0, sym = (ElfT_Sym *) ((char *) e + symtab_offset);
        i < num_syms;
-       i++, sym = (Elf_Sym *) ((char *) sym + sym_size))
+       i++, sym = (ElfT_Sym *) ((char *) sym + sym_size))
     {
-      Elf_Section index;
+      ElfT_Section index;
       const char *name;
 
       name = strtab + grub_le_to_cpu32 (sym->st_name);
@@ -302,22 +302,22 @@ relocate_symbols (Elf_Ehdr *e, Elf_Shdr *sections,
 }
 
 /* Return the address of a symbol at the index I in the section S.  */
-static Elf_Addr
-get_symbol_address (Elf_Ehdr *e, Elf_Shdr *s, Elf_Word i)
+static ElfT_Addr
+get_symbol_address (ElfT_Ehdr *e, ElfT_Shdr *s, ElfT_Word i)
 {
-  Elf_Sym *sym;
+  ElfT_Sym *sym;
 
-  sym = (Elf_Sym *) ((char *) e
+  sym = (ElfT_Sym *) ((char *) e
 		       + grub_le_to_cpu32 (s->sh_offset)
 		       + i * grub_le_to_cpu32 (s->sh_entsize));
   return sym->st_value;
 }
 
 /* Return the address of a modified value.  */
-static Elf_Addr *
-get_target_address (Elf_Ehdr *e, Elf_Shdr *s, Elf_Addr offset)
+static ElfT_Addr *
+get_target_address (ElfT_Ehdr *e, ElfT_Shdr *s, ElfT_Addr offset)
 {
-  return (Elf_Addr *) ((char *) e + grub_le_to_cpu32 (s->sh_offset) + offset);
+  return (ElfT_Addr *) ((char *) e + grub_le_to_cpu32 (s->sh_offset) + offset);
 }
 
 /* Deal with relocation information. This function relocates addresses
@@ -325,35 +325,35 @@ get_target_address (Elf_Ehdr *e, Elf_Shdr *s, Elf_Addr offset)
    addresses can be fully resolved. Absolute addresses must be relocated
    again by a PE32 relocator when loaded.  */
 static void
-relocate_addresses (Elf_Ehdr *e, Elf_Shdr *sections,
-		    Elf_Addr *section_addresses,
-		    Elf_Half section_entsize, Elf_Half num_sections,
+relocate_addresses (ElfT_Ehdr *e, ElfT_Shdr *sections,
+		    ElfT_Addr *section_addresses,
+		    ElfT_Half section_entsize, ElfT_Half num_sections,
 		    const char *strtab)
 {
-  Elf_Half i;
-  Elf_Shdr *s;
+  ElfT_Half i;
+  ElfT_Shdr *s;
 
   for (i = 0, s = sections;
        i < num_sections;
-       i++, s = (Elf_Shdr *) ((char *) s + section_entsize))
+       i++, s = (ElfT_Shdr *) ((char *) s + section_entsize))
     if ((s->sh_type == grub_cpu_to_le32 (SHT_REL)) ||
         (s->sh_type == grub_cpu_to_le32 (SHT_RELA)))
       {
-	Elf_Rela *r;
-	Elf_Word rtab_size, r_size, num_rs;
-	Elf_Off rtab_offset;
-	Elf_Shdr *symtab_section;
-	Elf_Word target_section_index;
-	Elf_Addr target_section_addr;
-	Elf_Shdr *target_section;
-	Elf_Word j;
-
-	symtab_section = (Elf_Shdr *) ((char *) sections
+	ElfT_Rela *r;
+	ElfT_Word rtab_size, r_size, num_rs;
+	ElfT_Off rtab_offset;
+	ElfT_Shdr *symtab_section;
+	ElfT_Word target_section_index;
+	ElfT_Addr target_section_addr;
+	ElfT_Shdr *target_section;
+	ElfT_Word j;
+
+	symtab_section = (ElfT_Shdr *) ((char *) sections
 					 + (grub_le_to_cpu32 (s->sh_link)
 					    * section_entsize));
 	target_section_index = grub_le_to_cpu32 (s->sh_info);
 	target_section_addr = section_addresses[target_section_index];
-	target_section = (Elf_Shdr *) ((char *) sections
+	target_section = (ElfT_Shdr *) ((char *) sections
 					 + (target_section_index
 					    * section_entsize));
 
@@ -366,26 +366,26 @@ relocate_addresses (Elf_Ehdr *e, Elf_Shdr *sections,
 	rtab_offset = grub_le_to_cpu32 (s->sh_offset);
 	num_rs = rtab_size / r_size;
 
-	for (j = 0, r = (Elf_Rela *) ((char *) e + rtab_offset);
+	for (j = 0, r = (ElfT_Rela *) ((char *) e + rtab_offset);
 	     j < num_rs;
-	     j++, r = (Elf_Rela *) ((char *) r + r_size))
+	     j++, r = (ElfT_Rela *) ((char *) r + r_size))
 	  {
-            Elf_Addr info;
-	    Elf_Addr offset;
-	    Elf_Addr sym_addr;
-	    Elf_Addr *target;
-	    Elf_Addr addend;
+            ElfT_Addr info;
+	    ElfT_Addr offset;
+	    ElfT_Addr sym_addr;
+	    ElfT_Addr *target;
+	    ElfT_Addr addend;
 
 	    offset = grub_le_to_cpu (r->r_offset);
 	    target = get_target_address (e, target_section, offset);
 	    info = grub_le_to_cpu (r->r_info);
 	    sym_addr = get_symbol_address (e, symtab_section,
-					   ELF_R_SYM (info));
+					   ELFT_R_SYM (info));
 
             addend = (s->sh_type == grub_cpu_to_le32 (SHT_RELA)) ?
 	      r->r_addend : 0;
 
-            switch (ELF_R_TYPE (info))
+            switch (ELFT_R_TYPE (info))
 	      {
 #if GRUB_TARGET_SIZEOF_VOID_P == 4
 	      case R_386_NONE:
@@ -445,7 +445,7 @@ relocate_addresses (Elf_Ehdr *e, Elf_Shdr *sections,
 #endif
 	      default:
 		grub_util_error ("unknown relocation type %d",
-				 ELF_R_TYPE (info));
+				 ELFT_R_TYPE (info));
 		break;
 	      }
 	  }
@@ -464,9 +464,9 @@ write_padding (FILE *out, size_t size)
 
 /* Add a PE32's fixup entry for a relocation. Return the resulting address
    after having written to the file OUT.  */
-Elf_Addr
+ElfT_Addr
 add_fixup_entry (struct grub_pe32_fixup_block **block, grub_uint16_t type,
-		 Elf_Addr addr, int flush, Elf_Addr current_address,
+		 ElfT_Addr addr, int flush, ElfT_Addr current_address,
 		 FILE *out)
 {
   struct grub_pe32_fixup_block *b = *block;
@@ -482,7 +482,7 @@ add_fixup_entry (struct grub_pe32_fixup_block **block, grub_uint16_t type,
 	    {
 	      /* Add as much padding as necessary to align the address
 		 with a section boundary.  */
-	      Elf_Addr next_address;
+	      ElfT_Addr next_address;
 	      unsigned padding_size;
               size_t index;
 
@@ -555,10 +555,10 @@ add_fixup_entry (struct grub_pe32_fixup_block **block, grub_uint16_t type,
 }
 
 /* Write out zeros to make space for the header.  */
-static Elf_Addr
+static ElfT_Addr
 make_header_space (FILE *out)
 {
-  Elf_Addr addr;
+  ElfT_Addr addr;
 
   addr = get_starting_section_address ();
   write_padding (out, addr);
@@ -567,24 +567,24 @@ make_header_space (FILE *out)
 }
 
 /* Write text sections.  */
-static Elf_Addr
-write_text_sections (FILE *out, Elf_Addr current_address,
-		     Elf_Ehdr *e, Elf_Shdr *sections,
-		     Elf_Half section_entsize, Elf_Half num_sections,
+static ElfT_Addr
+write_text_sections (FILE *out, ElfT_Addr current_address,
+		     ElfT_Ehdr *e, ElfT_Shdr *sections,
+		     ElfT_Half section_entsize, ElfT_Half num_sections,
 		     const char *strtab)
 {
-  Elf_Half i;
-  Elf_Shdr *s;
-  Elf_Addr addr;
+  ElfT_Half i;
+  ElfT_Shdr *s;
+  ElfT_Addr addr;
 
   for (i = 0, s = sections;
        i < num_sections;
-       i++, s = (Elf_Shdr *) ((char *) s + section_entsize))
+       i++, s = (ElfT_Shdr *) ((char *) s + section_entsize))
     if (is_text_section (s))
       {
-	Elf_Word align = grub_le_to_cpu32 (s->sh_addralign);
-	Elf_Off offset = grub_le_to_cpu32 (s->sh_offset);
-	Elf_Word size = grub_le_to_cpu32 (s->sh_size);
+	ElfT_Word align = grub_le_to_cpu32 (s->sh_addralign);
+	ElfT_Off offset = grub_le_to_cpu32 (s->sh_offset);
+	ElfT_Word size = grub_le_to_cpu32 (s->sh_size);
 	const char *name = strtab + grub_le_to_cpu32 (s->sh_name);
 
 	if (align)
@@ -620,24 +620,24 @@ write_text_sections (FILE *out, Elf_Addr current_address,
 }
 
 /* Write data sections.  */
-static Elf_Addr
-write_data_sections (FILE *out, Elf_Addr current_address,
-		     Elf_Ehdr *e, Elf_Shdr *sections,
-		     Elf_Half section_entsize, Elf_Half num_sections,
+static ElfT_Addr
+write_data_sections (FILE *out, ElfT_Addr current_address,
+		     ElfT_Ehdr *e, ElfT_Shdr *sections,
+		     ElfT_Half section_entsize, ElfT_Half num_sections,
 		     const char *strtab)
 {
-  Elf_Half i;
-  Elf_Shdr *s;
-  Elf_Addr addr;
+  ElfT_Half i;
+  ElfT_Shdr *s;
+  ElfT_Addr addr;
 
   for (i = 0, s = sections;
        i < num_sections;
-       i++, s = (Elf_Shdr *) ((char *) s + section_entsize))
+       i++, s = (ElfT_Shdr *) ((char *) s + section_entsize))
     if (is_data_section (s))
       {
-	Elf_Word align = grub_le_to_cpu32 (s->sh_addralign);
-	Elf_Off offset = grub_le_to_cpu32 (s->sh_offset);
-	Elf_Word size = grub_le_to_cpu32 (s->sh_size);
+	ElfT_Word align = grub_le_to_cpu32 (s->sh_addralign);
+	ElfT_Off offset = grub_le_to_cpu32 (s->sh_offset);
+	ElfT_Word size = grub_le_to_cpu32 (s->sh_size);
 	const char *name = strtab + grub_le_to_cpu32 (s->sh_name);
 
 	if (align)
@@ -676,15 +676,15 @@ write_data_sections (FILE *out, Elf_Addr current_address,
 }
 
 /* Write modules.  */
-static Elf_Addr
-make_mods_section (FILE *out, Elf_Addr current_address,
+static ElfT_Addr
+make_mods_section (FILE *out, ElfT_Addr current_address,
 		   const char *dir, char *mods[])
 {
   struct grub_util_path_list *path_list;
   grub_size_t total_module_size;
   struct grub_util_path_list *p;
   struct grub_module_info modinfo;
-  Elf_Addr addr;
+  ElfT_Addr addr;
 
   memset (&modinfo, 0, sizeof (modinfo));
 
@@ -752,27 +752,27 @@ make_mods_section (FILE *out, Elf_Addr current_address,
 }
 
 /* Make a .reloc section.  */
-static Elf_Addr
-make_reloc_section (FILE *out, Elf_Addr current_address, Elf_Ehdr *e,
-		    Elf_Addr *section_addresses, Elf_Shdr *sections,
-		    Elf_Half section_entsize, Elf_Half num_sections,
+static ElfT_Addr
+make_reloc_section (FILE *out, ElfT_Addr current_address, ElfT_Ehdr *e,
+		    ElfT_Addr *section_addresses, ElfT_Shdr *sections,
+		    ElfT_Half section_entsize, ElfT_Half num_sections,
 		    const char *strtab)
 {
-  Elf_Half i;
-  Elf_Shdr *s;
+  ElfT_Half i;
+  ElfT_Shdr *s;
   struct grub_pe32_fixup_block *fixup_block = 0;
 
   for (i = 0, s = sections;
        i < num_sections;
-       i++, s = (Elf_Shdr *) ((char *) s + section_entsize))
+       i++, s = (ElfT_Shdr *) ((char *) s + section_entsize))
     if ((s->sh_type == grub_cpu_to_le32 (SHT_REL)) ||
         (s->sh_type == grub_cpu_to_le32 (SHT_RELA)))
       {
-	Elf_Rel *r;
-	Elf_Word rtab_size, r_size, num_rs;
-	Elf_Off rtab_offset;
-	Elf_Addr section_address;
-	Elf_Word j;
+	ElfT_Rel *r;
+	ElfT_Word rtab_size, r_size, num_rs;
+	ElfT_Off rtab_offset;
+	ElfT_Addr section_address;
+	ElfT_Word j;
 
 	grub_util_info ("translating the relocation section %s",
 			strtab + grub_le_to_cpu32 (s->sh_name));
@@ -784,21 +784,21 @@ make_reloc_section (FILE *out, Elf_Addr current_address, Elf_Ehdr *e,
 
 	section_address = section_addresses[grub_le_to_cpu32 (s->sh_info)];
 
-	for (j = 0, r = (Elf_Rel *) ((char *) e + rtab_offset);
+	for (j = 0, r = (ElfT_Rel *) ((char *) e + rtab_offset);
 	     j < num_rs;
-	     j++, r = (Elf_Rel *) ((char *) r + r_size))
+	     j++, r = (ElfT_Rel *) ((char *) r + r_size))
 	  {
-	    Elf_Addr info;
-	    Elf_Addr offset;
+	    ElfT_Addr info;
+	    ElfT_Addr offset;
 
 	    offset = grub_le_to_cpu32 (r->r_offset);
 	    info = grub_le_to_cpu32 (r->r_info);
 
 	    /* Necessary to relocate only absolute addresses.  */
 #if GRUB_TARGET_SIZEOF_VOID_P == 4
-	    if (ELF_R_TYPE (info) == R_386_32)
+	    if (ELFT_R_TYPE (info) == R_386_32)
 	      {
-		Elf_Addr addr;
+		ElfT_Addr addr;
 
 		addr = section_address + offset;
 		grub_util_info ("adding a relocation entry for 0x%x", addr);
@@ -808,14 +808,14 @@ make_reloc_section (FILE *out, Elf_Addr current_address, Elf_Ehdr *e,
 						   out);
 	      }
 #else
-	    if ((ELF_R_TYPE (info) == R_X86_64_32) ||
-                (ELF_R_TYPE (info) == R_X86_64_32S))
+	    if ((ELFT_R_TYPE (info) == R_X86_64_32) ||
+                (ELFT_R_TYPE (info) == R_X86_64_32S))
 	      {
 		grub_util_error ("Can\'t add fixup entry for R_X86_64_32(S)");
 	      }
-	    else if (ELF_R_TYPE (info) == R_X86_64_64)
+	    else if (ELFT_R_TYPE (info) == R_X86_64_64)
 	      {
-		Elf_Addr addr;
+		ElfT_Addr addr;
 
 		addr = section_address + offset;
 		grub_util_info ("adding a relocation entry for 0x%llx", addr);
@@ -837,9 +837,9 @@ make_reloc_section (FILE *out, Elf_Addr current_address, Elf_Ehdr *e,
 
 /* Create the header.  */
 static void
-make_header (FILE *out, Elf_Addr text_address, Elf_Addr data_address,
-	     Elf_Addr mods_address, Elf_Addr reloc_address,
-	     Elf_Addr end_address, Elf_Addr start_address)
+make_header (FILE *out, ElfT_Addr text_address, ElfT_Addr data_address,
+	     ElfT_Addr mods_address, ElfT_Addr reloc_address,
+	     ElfT_Addr end_address, ElfT_Addr start_address)
 {
   struct grub_pe32_header header;
   struct grub_pe32_coff_header *c;
@@ -964,22 +964,22 @@ convert_elf (const char *dir, char *prefix, FILE *out, char *mods[])
   char *kernel_image;
   size_t kernel_size;
   const char *strtab;
-  Elf_Ehdr *e;
-  Elf_Shdr *sections;
-  Elf_Off section_offset;
-  Elf_Half section_entsize;
-  Elf_Half num_sections;
-  Elf_Addr *section_addresses;
-  Elf_Shdr *symtab_section;
-  Elf_Addr start_address;
-  Elf_Addr text_address, data_address, reloc_address, mods_address;
-  Elf_Addr end_address;
-  Elf_Shdr *s;
+  ElfT_Ehdr *e;
+  ElfT_Shdr *sections;
+  ElfT_Off section_offset;
+  ElfT_Half section_entsize;
+  ElfT_Half num_sections;
+  ElfT_Addr *section_addresses;
+  ElfT_Shdr *symtab_section;
+  ElfT_Addr start_address;
+  ElfT_Addr text_address, data_address, reloc_address, mods_address;
+  ElfT_Addr end_address;
+  ElfT_Shdr *s;
   int i;
 
   /* Get the kernel image and check the format.  */
   kernel_image = read_kernel_module (dir, &kernel_size);
-  e = (Elf_Ehdr *) kernel_image;
+  e = (ElfT_Ehdr *) kernel_image;
   if (! check_elf_header (e, kernel_size))
     grub_util_error ("invalid ELF header");
 
@@ -990,15 +990,15 @@ convert_elf (const char *dir, char *prefix, FILE *out, char *mods[])
   if (kernel_size < section_offset + section_entsize * num_sections)
     grub_util_error ("invalid ELF format");
 
-  sections = (Elf_Shdr *) (kernel_image + section_offset);
+  sections = (ElfT_Shdr *) (kernel_image + section_offset);
   strtab = find_strtab (e, sections, section_entsize);
 
   for (i = 0, s = sections;
        i < num_sections;
-       i++, s = (Elf_Shdr *) ((char *) s + section_entsize))
+       i++, s = (ElfT_Shdr *) ((char *) s + section_entsize))
     if (is_text_section (s))
       {
-	  Elf_Off offset = grub_le_to_cpu32 (s->sh_offset);
+	  ElfT_Off offset = grub_le_to_cpu32 (s->sh_offset);
 
 	  if (GRUB_KERNEL_MACHINE_PREFIX + strlen (prefix) + 1 > GRUB_KERNEL_MACHINE_DATA_END)
 	    grub_util_error ("prefix too long");

[-- Attachment #3: 03-simple-symtab.patch --]
[-- Type: text/x-patch, Size: 5163 bytes --]

Simplify symtab logic

From: Pavel Roskin <proski@gnu.org>


---

 include/grub/dl.h |    5 -----
 kern/dl.c         |    4 +++-
 kern/i386/dl.c    |    4 +---
 kern/powerpc/dl.c |    4 +---
 kern/sparc64/dl.c |    4 +---
 kern/x86_64/dl.c  |    4 +---
 6 files changed, 7 insertions(+), 18 deletions(-)


diff --git a/include/grub/dl.h b/include/grub/dl.h
index fbd77b2..b507989 100644
--- a/include/grub/dl.h
+++ b/include/grub/dl.h
@@ -85,12 +85,7 @@ struct grub_dl
   int ref_count;
   grub_dl_dep_t dep;
   grub_dl_segment_t segment;
-#ifdef GRUB_MODULES_MACHINE_READONLY
   Elf_Sym *symtab;
-#define get_symtab()	mod->symtab
-#else
-#define get_symtab()	((Elf_Sym *) ((char *) e + s->sh_offset))
-#endif
   void (*init) (struct grub_dl *mod);
   void (*fini) (void);
 };
diff --git a/kern/dl.c b/kern/dl.c
index ce1e269..0ee4649 100644
--- a/kern/dl.c
+++ b/kern/dl.c
@@ -314,8 +314,10 @@ grub_dl_resolve_symbols (grub_dl_t mod, Elf_Ehdr *e)
 #ifdef GRUB_MODULES_MACHINE_READONLY
   mod->symtab = grub_malloc (size);
   memcpy (mod->symtab, (char *) e + s->sh_offset, size);
+#else
+  mod->symtab = ((Elf_Sym *) ((char *) e + s->sh_offset));
 #endif
-  sym = get_symtab ();
+  sym = mod->symtab;
 
   s = (Elf_Shdr *) ((char *) e + e->e_shoff + e->e_shentsize * s->sh_link);
   str = (char *) e + s->sh_offset;
diff --git a/kern/i386/dl.c b/kern/i386/dl.c
index 6d5b95a..a17f175 100644
--- a/kern/i386/dl.c
+++ b/kern/i386/dl.c
@@ -43,7 +43,6 @@ grub_arch_dl_relocate_symbols (grub_dl_t mod, void *ehdr)
 {
   Elf32_Ehdr *e = ehdr;
   Elf32_Shdr *s;
-  Elf32_Sym *symtab;
   Elf32_Word entsize;
   unsigned i;
 
@@ -57,7 +56,6 @@ grub_arch_dl_relocate_symbols (grub_dl_t mod, void *ehdr)
   if (i == e->e_shnum)
     return grub_error (GRUB_ERR_BAD_MODULE, "no symtab found");
 
-  symtab = get_symtab ();
   entsize = s->sh_entsize;
 
   for (i = 0, s = (Elf32_Shdr *) ((char *) e + e->e_shoff);
@@ -89,7 +87,7 @@ grub_arch_dl_relocate_symbols (grub_dl_t mod, void *ehdr)
 				     "reloc offset is out of the segment");
 
 		addr = (Elf32_Word *) ((char *) seg->addr + rel->r_offset);
-		sym = (Elf32_Sym *) ((char *) symtab
+		sym = (Elf32_Sym *) ((char *) mod->symtab
 				     + entsize * ELF32_R_SYM (rel->r_info));
 
 		switch (ELF32_R_TYPE (rel->r_info))
diff --git a/kern/powerpc/dl.c b/kern/powerpc/dl.c
index a85ceef..9b1cb14 100644
--- a/kern/powerpc/dl.c
+++ b/kern/powerpc/dl.c
@@ -44,7 +44,6 @@ grub_arch_dl_relocate_symbols (grub_dl_t mod, void *ehdr)
 {
   Elf32_Ehdr *e = ehdr;
   Elf32_Shdr *s;
-  Elf32_Sym *symtab;
   Elf32_Word entsize;
   unsigned i;
 
@@ -58,7 +57,6 @@ grub_arch_dl_relocate_symbols (grub_dl_t mod, void *ehdr)
   if (i == e->e_shnum)
     return grub_error (GRUB_ERR_BAD_MODULE, "no symtab found");
 
-  symtab = get_symtab ();
   entsize = s->sh_entsize;
 
   for (i = 0, s = (Elf32_Shdr *) ((char *) e + e->e_shoff);
@@ -91,7 +89,7 @@ grub_arch_dl_relocate_symbols (grub_dl_t mod, void *ehdr)
 				     "reloc offset is out of the segment");
 
 		addr = (Elf32_Word *) ((char *) seg->addr + rel->r_offset);
-		sym = (Elf32_Sym *) ((char *) symtab
+		sym = (Elf32_Sym *) ((char *) mod->symtab
 				     + entsize * ELF32_R_SYM (rel->r_info));
 
 		/* On the PPC the value does not have an explicit
diff --git a/kern/sparc64/dl.c b/kern/sparc64/dl.c
index e427468..5334896 100644
--- a/kern/sparc64/dl.c
+++ b/kern/sparc64/dl.c
@@ -44,7 +44,6 @@ grub_arch_dl_relocate_symbols (grub_dl_t mod, void *ehdr)
 {
   Elf64_Ehdr *e = ehdr;
   Elf64_Shdr *s;
-  Elf64_Sym *symtab;
   Elf64_Word entsize;
   unsigned i;
 
@@ -58,7 +57,6 @@ grub_arch_dl_relocate_symbols (grub_dl_t mod, void *ehdr)
   if (i == e->e_shnum)
     return grub_error (GRUB_ERR_BAD_MODULE, "no symtab found");
 
-  symtab = get_symtab ();
   entsize = s->sh_entsize;
 
   for (i = 0, s = (Elf64_Shdr *) ((char *) e + e->e_shoff);
@@ -91,7 +89,7 @@ grub_arch_dl_relocate_symbols (grub_dl_t mod, void *ehdr)
 				     "reloc offset is out of the segment");
 
 		addr = (Elf64_Word *) ((char *) seg->addr + rel->r_offset);
-		sym = (Elf64_Sym *) ((char *) symtab
+		sym = (Elf64_Sym *) ((char *) mod->symtab
 				     + entsize * ELF64_R_SYM (rel->r_info));
 
 		value = sym->st_value + rel->r_addend;
diff --git a/kern/x86_64/dl.c b/kern/x86_64/dl.c
index 74ae188..9e5de6e 100644
--- a/kern/x86_64/dl.c
+++ b/kern/x86_64/dl.c
@@ -43,7 +43,6 @@ grub_arch_dl_relocate_symbols (grub_dl_t mod, void *ehdr)
 {
   Elf64_Ehdr *e = ehdr;
   Elf64_Shdr *s;
-  Elf64_Sym *symtab;
   Elf64_Word entsize;
   unsigned i;
 
@@ -57,7 +56,6 @@ grub_arch_dl_relocate_symbols (grub_dl_t mod, void *ehdr)
   if (i == e->e_shnum)
     return grub_error (GRUB_ERR_BAD_MODULE, "no symtab found");
 
-  symtab = get_symtab ();
   entsize = s->sh_entsize;
 
   for (i = 0, s = (Elf64_Shdr *) ((char *) e + e->e_shoff);
@@ -91,7 +89,7 @@ grub_arch_dl_relocate_symbols (grub_dl_t mod, void *ehdr)
 
 		addr32 = (Elf64_Word *) ((char *) seg->addr + rel->r_offset);
 		addr64 = (Elf64_Xword *) addr32;
-		sym = (Elf64_Sym *) ((char *) symtab
+		sym = (Elf64_Sym *) ((char *) mod->symtab
 				     + entsize * ELF64_R_SYM (rel->r_info));
 
 		switch (ELF64_R_TYPE (rel->r_info))