More elf definitions changed.
From: Pavel Roskin
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
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
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");