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");