2008-07-24 14:56:30 +00:00
|
|
|
/* grub-pe2elf.c - tool to convert pe image to elf. */
|
|
|
|
/*
|
|
|
|
* GRUB -- GRand Unified Bootloader
|
2009-11-25 23:10:02 +00:00
|
|
|
* Copyright (C) 2008,2009 Free Software Foundation, Inc.
|
2008-07-24 14:56:30 +00:00
|
|
|
*
|
|
|
|
* GRUB 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 3 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* GRUB 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 GRUB. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <config.h>
|
|
|
|
#include <grub/types.h>
|
|
|
|
#include <grub/util/misc.h>
|
|
|
|
#include <grub/elf.h>
|
|
|
|
#include <grub/efi/pe32.h>
|
2012-03-02 10:27:48 +00:00
|
|
|
#include <grub/misc.h>
|
2008-07-24 14:56:30 +00:00
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <getopt.h>
|
|
|
|
|
2010-03-04 15:25:26 +00:00
|
|
|
|
2011-11-11 23:34:14 +00:00
|
|
|
/* Please don't internationalise this file. It's pointless. */
|
|
|
|
|
2008-07-24 14:56:30 +00:00
|
|
|
/*
|
|
|
|
* Section layout
|
|
|
|
*
|
|
|
|
* null
|
|
|
|
* .text
|
|
|
|
* .rdata
|
|
|
|
* .data
|
|
|
|
* .bss
|
|
|
|
* .modname
|
|
|
|
* .moddeps
|
|
|
|
* .symtab
|
|
|
|
* .strtab
|
|
|
|
* relocation sections
|
|
|
|
*/
|
|
|
|
|
2013-12-16 14:30:50 +00:00
|
|
|
#if GRUB_TARGET_WORDSIZE == 64
|
|
|
|
typedef Elf64_Rela elf_reloc_t;
|
|
|
|
#define GRUB_PE32_MACHINE GRUB_PE32_MACHINE_X86_64
|
|
|
|
#else
|
|
|
|
typedef Elf32_Rel elf_reloc_t;
|
|
|
|
#define GRUB_PE32_MACHINE GRUB_PE32_MACHINE_I386
|
|
|
|
#endif
|
2008-07-24 14:56:30 +00:00
|
|
|
|
|
|
|
#define STRTAB_BLOCK 256
|
|
|
|
|
|
|
|
static char *strtab;
|
|
|
|
static int strtab_max, strtab_len;
|
|
|
|
|
2013-12-16 14:30:50 +00:00
|
|
|
static Elf_Ehdr ehdr;
|
|
|
|
static Elf_Shdr *shdr;
|
|
|
|
static int num_sections, first_reloc_section, reloc_sections_end, symtab_section, strtab_section;
|
2013-12-14 22:12:53 +00:00
|
|
|
static grub_uint32_t offset, image_base;
|
2008-07-24 14:56:30 +00:00
|
|
|
|
|
|
|
static int
|
2011-05-14 15:47:59 +00:00
|
|
|
insert_string (const char *name)
|
2008-07-24 14:56:30 +00:00
|
|
|
{
|
|
|
|
int len, result;
|
|
|
|
|
|
|
|
if (*name == '_')
|
|
|
|
name++;
|
|
|
|
|
|
|
|
len = strlen (name);
|
|
|
|
if (strtab_len + len >= strtab_max)
|
|
|
|
{
|
|
|
|
strtab_max += STRTAB_BLOCK;
|
|
|
|
strtab = xrealloc (strtab, strtab_max);
|
|
|
|
}
|
|
|
|
|
|
|
|
strcpy (strtab + strtab_len, name);
|
|
|
|
result = strtab_len;
|
|
|
|
strtab_len += len + 1;
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int *
|
2012-02-05 10:07:33 +00:00
|
|
|
write_section_data (FILE* fp, const char *name, char *image,
|
2008-07-24 14:56:30 +00:00
|
|
|
struct grub_pe32_coff_header *pe_chdr,
|
|
|
|
struct grub_pe32_section_table *pe_shdr)
|
|
|
|
{
|
|
|
|
int *section_map;
|
|
|
|
int i;
|
2013-12-16 14:30:50 +00:00
|
|
|
grub_uint32_t last_category = 0;
|
|
|
|
grub_uint32_t idx, idx_reloc;
|
2011-05-14 15:47:59 +00:00
|
|
|
char *pe_strtab = (image + pe_chdr->symtab_offset
|
|
|
|
+ pe_chdr->num_symbols * sizeof (struct grub_pe32_symbol));
|
2008-07-24 14:56:30 +00:00
|
|
|
|
2013-12-16 14:30:50 +00:00
|
|
|
section_map = xmalloc ((2 * pe_chdr->num_sections + 5) * sizeof (int));
|
2008-07-24 14:56:30 +00:00
|
|
|
section_map[0] = 0;
|
2013-12-16 14:30:50 +00:00
|
|
|
shdr = xmalloc ((2 * pe_chdr->num_sections + 5) * sizeof (shdr[0]));
|
|
|
|
idx = 1;
|
|
|
|
idx_reloc = pe_chdr->num_sections + 1;
|
2008-07-24 14:56:30 +00:00
|
|
|
|
|
|
|
for (i = 0; i < pe_chdr->num_sections; i++, pe_shdr++)
|
|
|
|
{
|
2013-12-16 14:30:50 +00:00
|
|
|
grub_uint32_t category;
|
2012-03-02 10:27:48 +00:00
|
|
|
const char *shname = pe_shdr->name;
|
2013-12-14 22:12:53 +00:00
|
|
|
grub_size_t secsize;
|
2008-07-24 14:56:30 +00:00
|
|
|
|
2012-03-02 10:27:48 +00:00
|
|
|
if (shname[0] == '/' && grub_isdigit (shname[1]))
|
2011-05-14 15:47:59 +00:00
|
|
|
{
|
|
|
|
char t[sizeof (pe_shdr->name) + 1];
|
2012-03-02 10:27:48 +00:00
|
|
|
memcpy (t, shname, sizeof (pe_shdr->name));
|
2011-05-14 15:47:59 +00:00
|
|
|
t[sizeof (pe_shdr->name)] = 0;
|
2012-03-02 10:27:48 +00:00
|
|
|
shname = pe_strtab + atoi (t + 1);
|
2011-05-14 15:47:59 +00:00
|
|
|
}
|
|
|
|
|
2013-12-14 22:12:53 +00:00
|
|
|
secsize = pe_shdr->raw_data_size;
|
|
|
|
|
2013-12-16 14:30:50 +00:00
|
|
|
shdr[idx].sh_type = SHT_PROGBITS;
|
|
|
|
|
2012-03-02 10:27:48 +00:00
|
|
|
if (! strcmp (shname, ".text"))
|
2008-07-24 14:56:30 +00:00
|
|
|
{
|
2013-12-16 14:30:50 +00:00
|
|
|
category = 0;
|
2008-07-24 14:56:30 +00:00
|
|
|
shdr[idx].sh_flags = SHF_ALLOC | SHF_EXECINSTR;
|
|
|
|
}
|
2013-12-16 14:30:50 +00:00
|
|
|
else if (! strncmp (shname, ".rdata", 6))
|
2008-07-24 14:56:30 +00:00
|
|
|
{
|
2013-12-16 14:30:50 +00:00
|
|
|
category = 1;
|
2008-07-24 14:56:30 +00:00
|
|
|
shdr[idx].sh_flags = SHF_ALLOC;
|
|
|
|
}
|
2012-03-02 10:27:48 +00:00
|
|
|
else if (! strcmp (shname, ".data"))
|
2008-07-24 14:56:30 +00:00
|
|
|
{
|
2013-12-16 14:30:50 +00:00
|
|
|
category = 2;
|
2008-07-24 14:56:30 +00:00
|
|
|
shdr[idx].sh_flags = SHF_ALLOC | SHF_WRITE;
|
|
|
|
}
|
2012-03-02 10:27:48 +00:00
|
|
|
else if (! strcmp (shname, ".bss"))
|
2008-07-24 14:56:30 +00:00
|
|
|
{
|
2013-12-16 14:30:50 +00:00
|
|
|
category = 3;
|
|
|
|
shdr[idx].sh_type = SHT_NOBITS;
|
2008-07-24 14:56:30 +00:00
|
|
|
shdr[idx].sh_flags = SHF_ALLOC | SHF_WRITE;
|
2013-12-14 23:55:17 +00:00
|
|
|
if (secsize < pe_shdr->virtual_size)
|
|
|
|
secsize = pe_shdr->virtual_size;
|
2008-07-24 14:56:30 +00:00
|
|
|
}
|
2013-12-16 14:30:50 +00:00
|
|
|
else if (strcmp (shname, ".modname") == 0 || strcmp (shname, ".moddeps") == 0
|
|
|
|
|| strcmp (shname, ".module_license") == 0)
|
|
|
|
category = 4;
|
2008-07-24 14:56:30 +00:00
|
|
|
else
|
|
|
|
{
|
|
|
|
section_map[i + 1] = -1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2013-12-16 14:30:50 +00:00
|
|
|
if (category < last_category)
|
|
|
|
grub_util_error ("out of order sections");
|
|
|
|
|
2008-07-24 14:56:30 +00:00
|
|
|
section_map[i + 1] = idx;
|
|
|
|
|
2013-12-14 22:12:53 +00:00
|
|
|
if (pe_shdr->virtual_size
|
|
|
|
&& pe_shdr->virtual_size < secsize)
|
|
|
|
secsize = pe_shdr->virtual_size;
|
|
|
|
|
|
|
|
shdr[idx].sh_size = secsize;
|
2008-07-24 14:56:30 +00:00
|
|
|
shdr[idx].sh_addralign = 1 << (((pe_shdr->characteristics >>
|
|
|
|
GRUB_PE32_SCN_ALIGN_SHIFT) &
|
|
|
|
GRUB_PE32_SCN_ALIGN_MASK) - 1);
|
2013-12-14 22:12:53 +00:00
|
|
|
shdr[idx].sh_addr = pe_shdr->virtual_address + image_base;
|
2008-07-24 14:56:30 +00:00
|
|
|
|
2013-12-16 14:30:50 +00:00
|
|
|
if (shdr[idx].sh_type != SHT_NOBITS)
|
2008-07-24 14:56:30 +00:00
|
|
|
{
|
|
|
|
shdr[idx].sh_offset = offset;
|
|
|
|
grub_util_write_image_at (image + pe_shdr->raw_data_offset,
|
2012-02-05 10:07:33 +00:00
|
|
|
pe_shdr->raw_data_size, offset, fp,
|
2012-03-02 10:27:48 +00:00
|
|
|
shname);
|
2008-07-24 14:56:30 +00:00
|
|
|
|
2013-12-14 22:12:53 +00:00
|
|
|
offset += secsize;
|
2008-07-24 14:56:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (pe_shdr->relocations_offset)
|
|
|
|
{
|
2012-03-02 10:27:48 +00:00
|
|
|
char relname[5 + strlen (shname)];
|
2008-07-24 14:56:30 +00:00
|
|
|
|
2012-03-02 10:27:48 +00:00
|
|
|
sprintf (relname, ".rel%s", shname);
|
2008-07-24 14:56:30 +00:00
|
|
|
|
2013-12-16 14:30:50 +00:00
|
|
|
shdr[idx_reloc].sh_name = insert_string (relname);
|
|
|
|
shdr[idx_reloc].sh_link = i;
|
|
|
|
shdr[idx_reloc].sh_info = idx;
|
2008-07-24 14:56:30 +00:00
|
|
|
|
2013-12-16 14:30:50 +00:00
|
|
|
shdr[idx].sh_name = shdr[idx_reloc].sh_name + 4;
|
2008-07-24 14:56:30 +00:00
|
|
|
|
2013-12-16 14:30:50 +00:00
|
|
|
idx_reloc++;
|
2008-07-24 14:56:30 +00:00
|
|
|
}
|
|
|
|
else
|
2012-03-02 10:27:48 +00:00
|
|
|
shdr[idx].sh_name = insert_string (shname);
|
2013-12-16 14:30:50 +00:00
|
|
|
idx++;
|
2008-07-24 14:56:30 +00:00
|
|
|
}
|
|
|
|
|
2013-12-16 14:30:50 +00:00
|
|
|
idx_reloc -= pe_chdr->num_sections + 1;
|
|
|
|
num_sections = idx + idx_reloc + 2;
|
|
|
|
first_reloc_section = idx;
|
|
|
|
reloc_sections_end = idx + idx_reloc;
|
|
|
|
memmove (shdr + idx, shdr + pe_chdr->num_sections + 1,
|
|
|
|
idx_reloc * sizeof (shdr[0]));
|
|
|
|
memset (shdr + idx + idx_reloc, 0, 3 * sizeof (shdr[0]));
|
|
|
|
memset (shdr, 0, sizeof (shdr[0]));
|
|
|
|
|
|
|
|
symtab_section = idx + idx_reloc;
|
|
|
|
strtab_section = idx + idx_reloc + 1;
|
|
|
|
|
2008-07-24 14:56:30 +00:00
|
|
|
return section_map;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-02-05 10:07:33 +00:00
|
|
|
write_reloc_section (FILE* fp, const char *name, char *image,
|
2008-07-24 14:56:30 +00:00
|
|
|
struct grub_pe32_coff_header *pe_chdr,
|
2013-12-16 14:30:50 +00:00
|
|
|
struct grub_pe32_section_table *pe_shdr,
|
|
|
|
Elf_Sym *symtab,
|
2008-07-24 14:56:30 +00:00
|
|
|
int *symtab_map)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2013-12-16 14:30:50 +00:00
|
|
|
for (i = first_reloc_section; i < reloc_sections_end; i++)
|
2008-07-24 14:56:30 +00:00
|
|
|
{
|
|
|
|
struct grub_pe32_section_table *pe_sec;
|
|
|
|
struct grub_pe32_reloc *pe_rel;
|
2013-12-16 14:30:50 +00:00
|
|
|
elf_reloc_t *rel;
|
2008-07-24 14:56:30 +00:00
|
|
|
int num_rels, j, modified;
|
|
|
|
|
|
|
|
pe_sec = pe_shdr + shdr[i].sh_link;
|
|
|
|
pe_rel = (struct grub_pe32_reloc *) (image + pe_sec->relocations_offset);
|
2013-12-16 14:30:50 +00:00
|
|
|
rel = (elf_reloc_t *) xmalloc (pe_sec->num_relocations * sizeof (elf_reloc_t));
|
2008-07-24 14:56:30 +00:00
|
|
|
num_rels = 0;
|
|
|
|
modified = 0;
|
|
|
|
|
|
|
|
for (j = 0; j < pe_sec->num_relocations; j++, pe_rel++)
|
|
|
|
{
|
|
|
|
int type;
|
|
|
|
grub_uint32_t ofs, *addr;
|
|
|
|
|
|
|
|
if ((pe_rel->symtab_index >= pe_chdr->num_symbols) ||
|
|
|
|
(symtab_map[pe_rel->symtab_index] == -1))
|
2010-01-16 00:26:52 +00:00
|
|
|
grub_util_error ("invalid symbol");
|
2008-07-24 14:56:30 +00:00
|
|
|
|
|
|
|
ofs = pe_rel->offset - pe_sec->virtual_address;
|
|
|
|
addr = (grub_uint32_t *)(image + pe_sec->raw_data_offset + ofs);
|
2013-12-16 14:30:50 +00:00
|
|
|
|
|
|
|
switch (pe_rel->type)
|
|
|
|
{
|
|
|
|
#if GRUB_TARGET_WORDSIZE == 64
|
|
|
|
case 1:
|
|
|
|
type = R_X86_64_64;
|
|
|
|
rel[num_rels].r_addend = *(grub_int64_t *)addr;
|
|
|
|
*(grub_int64_t *)addr = 0;
|
|
|
|
modified = 1;
|
|
|
|
break;
|
|
|
|
case 4:
|
|
|
|
type = R_X86_64_PC32;
|
|
|
|
rel[num_rels].r_addend = *(grub_int32_t *)addr;
|
|
|
|
*addr = 0;
|
|
|
|
modified = 1;
|
|
|
|
break;
|
|
|
|
case 14:
|
|
|
|
type = R_X86_64_PC64;
|
|
|
|
rel[num_rels].r_addend = *(grub_uint64_t *)addr - 8;
|
|
|
|
*(grub_uint64_t *)addr = 0;
|
|
|
|
modified = 1;
|
|
|
|
break;
|
|
|
|
#else
|
|
|
|
case GRUB_PE32_REL_I386_DIR32:
|
|
|
|
type = R_386_32;
|
|
|
|
break;
|
|
|
|
case GRUB_PE32_REL_I386_REL32:
|
|
|
|
type = R_386_PC32;
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
default:
|
2015-05-13 06:47:17 +00:00
|
|
|
grub_util_error ("unknown pe relocation type %d", pe_rel->type);
|
2013-12-16 14:30:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (type ==
|
|
|
|
#if GRUB_TARGET_WORDSIZE == 64
|
|
|
|
R_386_PC32
|
|
|
|
#else
|
|
|
|
R_X86_64_PC32
|
|
|
|
#endif
|
|
|
|
|
|
|
|
)
|
2008-07-24 14:56:30 +00:00
|
|
|
{
|
|
|
|
unsigned char code;
|
|
|
|
|
|
|
|
code = image[pe_sec->raw_data_offset + ofs - 1];
|
|
|
|
|
2013-12-16 14:30:50 +00:00
|
|
|
#if GRUB_TARGET_WORDSIZE == 32
|
2008-07-24 14:56:30 +00:00
|
|
|
if (((code != 0xe8) && (code != 0xe9)) || (*addr))
|
2010-01-16 00:26:52 +00:00
|
|
|
grub_util_error ("invalid relocation (%x %x)", code, *addr);
|
2013-12-16 14:30:50 +00:00
|
|
|
#endif
|
2008-07-24 14:56:30 +00:00
|
|
|
|
2013-12-16 14:30:50 +00:00
|
|
|
if (symtab[symtab_map[pe_rel->symtab_index]].st_shndx
|
|
|
|
&& symtab[symtab_map[pe_rel->symtab_index]].st_shndx
|
|
|
|
== shdr[i].sh_info)
|
2008-07-24 14:56:30 +00:00
|
|
|
{
|
2013-12-16 14:30:50 +00:00
|
|
|
modified = 1;
|
|
|
|
*addr += (symtab[symtab_map[pe_rel->symtab_index]].st_value
|
|
|
|
- ofs - 4);
|
2008-07-24 14:56:30 +00:00
|
|
|
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
else
|
2013-12-16 14:30:50 +00:00
|
|
|
{
|
|
|
|
#if GRUB_TARGET_WORDSIZE == 64
|
|
|
|
rel[num_rels].r_addend -= 4;
|
|
|
|
#else
|
|
|
|
modified = 1;
|
|
|
|
*addr = -4;
|
|
|
|
#endif
|
|
|
|
}
|
2008-07-24 14:56:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
rel[num_rels].r_offset = ofs;
|
2013-12-16 14:30:50 +00:00
|
|
|
rel[num_rels].r_info = ELF_R_INFO (symtab_map[pe_rel->symtab_index],
|
|
|
|
type);
|
2008-07-24 14:56:30 +00:00
|
|
|
num_rels++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (modified)
|
|
|
|
grub_util_write_image_at (image + pe_sec->raw_data_offset,
|
|
|
|
shdr[shdr[i].sh_info].sh_size,
|
|
|
|
shdr[shdr[i].sh_info].sh_offset,
|
2012-02-05 10:07:33 +00:00
|
|
|
fp, name);
|
2008-07-24 14:56:30 +00:00
|
|
|
|
2013-12-16 14:30:50 +00:00
|
|
|
#if GRUB_TARGET_WORDSIZE == 64
|
|
|
|
shdr[i].sh_type = SHT_RELA;
|
|
|
|
#else
|
2008-07-24 14:56:30 +00:00
|
|
|
shdr[i].sh_type = SHT_REL;
|
2013-12-16 14:30:50 +00:00
|
|
|
#endif
|
2008-07-24 14:56:30 +00:00
|
|
|
shdr[i].sh_offset = offset;
|
2013-12-16 14:30:50 +00:00
|
|
|
shdr[i].sh_link = symtab_section;
|
2008-07-24 14:56:30 +00:00
|
|
|
shdr[i].sh_addralign = 4;
|
2013-12-16 14:30:50 +00:00
|
|
|
shdr[i].sh_entsize = sizeof (elf_reloc_t);
|
|
|
|
shdr[i].sh_size = num_rels * sizeof (elf_reloc_t);
|
2008-07-24 14:56:30 +00:00
|
|
|
|
2012-02-05 10:07:33 +00:00
|
|
|
grub_util_write_image_at (rel, shdr[i].sh_size, offset, fp, name);
|
2008-07-24 14:56:30 +00:00
|
|
|
offset += shdr[i].sh_size;
|
|
|
|
free (rel);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-02-05 10:07:33 +00:00
|
|
|
write_symbol_table (FILE* fp, const char *name, char *image,
|
2008-07-24 14:56:30 +00:00
|
|
|
struct grub_pe32_coff_header *pe_chdr,
|
|
|
|
struct grub_pe32_section_table *pe_shdr,
|
|
|
|
int *section_map)
|
|
|
|
{
|
|
|
|
struct grub_pe32_symbol *pe_symtab;
|
|
|
|
char *pe_strtab;
|
2013-12-16 14:30:50 +00:00
|
|
|
Elf_Sym *symtab;
|
2008-07-24 14:56:30 +00:00
|
|
|
int *symtab_map, num_syms;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
pe_symtab = (struct grub_pe32_symbol *) (image + pe_chdr->symtab_offset);
|
|
|
|
pe_strtab = (char *) (pe_symtab + pe_chdr->num_symbols);
|
|
|
|
|
2013-12-16 14:30:50 +00:00
|
|
|
symtab = (Elf_Sym *) xmalloc ((pe_chdr->num_symbols + 1) *
|
|
|
|
sizeof (Elf_Sym));
|
|
|
|
memset (symtab, 0, (pe_chdr->num_symbols + 1) * sizeof (Elf_Sym));
|
2008-07-24 14:56:30 +00:00
|
|
|
num_syms = 1;
|
|
|
|
|
|
|
|
symtab_map = (int *) xmalloc (pe_chdr->num_symbols * sizeof (int));
|
|
|
|
|
|
|
|
for (i = 0; i < (int) pe_chdr->num_symbols;
|
|
|
|
i += pe_symtab->num_aux + 1, pe_symtab += pe_symtab->num_aux + 1)
|
|
|
|
{
|
|
|
|
int bind, type;
|
|
|
|
|
|
|
|
symtab_map[i] = -1;
|
|
|
|
if ((pe_symtab->section > pe_chdr->num_sections) ||
|
|
|
|
(section_map[pe_symtab->section] == -1))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (! pe_symtab->section)
|
|
|
|
type = STT_NOTYPE;
|
|
|
|
else if (pe_symtab->type == GRUB_PE32_DT_FUNCTION)
|
|
|
|
type = STT_FUNC;
|
|
|
|
else
|
|
|
|
type = STT_OBJECT;
|
|
|
|
|
|
|
|
if (pe_symtab->storage_class == GRUB_PE32_SYM_CLASS_EXTERNAL)
|
|
|
|
bind = STB_GLOBAL;
|
|
|
|
else
|
|
|
|
bind = STB_LOCAL;
|
|
|
|
|
2011-01-13 21:23:49 +00:00
|
|
|
if ((pe_symtab->type != GRUB_PE32_DT_FUNCTION) && (pe_symtab->num_aux))
|
2008-07-24 14:56:30 +00:00
|
|
|
{
|
|
|
|
if (! pe_symtab->value)
|
|
|
|
type = STT_SECTION;
|
|
|
|
|
|
|
|
symtab[num_syms].st_name = shdr[section_map[pe_symtab->section]].sh_name;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2009-04-14 16:56:35 +00:00
|
|
|
char short_name[9];
|
2012-03-02 10:27:48 +00:00
|
|
|
char *symname;
|
2008-07-24 14:56:30 +00:00
|
|
|
|
2009-04-14 16:56:35 +00:00
|
|
|
if (pe_symtab->long_name[0])
|
|
|
|
{
|
|
|
|
strncpy (short_name, pe_symtab->short_name, 8);
|
|
|
|
short_name[8] = 0;
|
2012-03-02 10:27:48 +00:00
|
|
|
symname = short_name;
|
2009-04-14 16:56:35 +00:00
|
|
|
}
|
|
|
|
else
|
2012-03-02 10:27:48 +00:00
|
|
|
symname = pe_strtab + pe_symtab->long_name[1];
|
2008-07-24 14:56:30 +00:00
|
|
|
|
2012-03-02 10:27:48 +00:00
|
|
|
if ((strcmp (symname, "_grub_mod_init")) &&
|
|
|
|
(strcmp (symname, "_grub_mod_fini")) &&
|
2013-12-16 14:30:50 +00:00
|
|
|
(strcmp (symname, "grub_mod_init")) &&
|
|
|
|
(strcmp (symname, "grub_mod_fini")) &&
|
2008-07-24 14:56:30 +00:00
|
|
|
(bind == STB_LOCAL))
|
|
|
|
continue;
|
|
|
|
|
2012-03-02 10:27:48 +00:00
|
|
|
symtab[num_syms].st_name = insert_string (symname);
|
2008-07-24 14:56:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
symtab[num_syms].st_shndx = section_map[pe_symtab->section];
|
|
|
|
symtab[num_syms].st_value = pe_symtab->value;
|
2013-12-16 14:30:50 +00:00
|
|
|
symtab[num_syms].st_info = ELF_ST_INFO (bind, type);
|
2008-07-24 14:56:30 +00:00
|
|
|
|
|
|
|
symtab_map[i] = num_syms;
|
|
|
|
num_syms++;
|
|
|
|
}
|
|
|
|
|
2012-03-02 10:27:48 +00:00
|
|
|
write_reloc_section (fp, name, image, pe_chdr, pe_shdr,
|
|
|
|
symtab, symtab_map);
|
2008-07-24 14:56:30 +00:00
|
|
|
|
2013-12-16 14:30:50 +00:00
|
|
|
shdr[symtab_section].sh_name = insert_string (".symtab");
|
|
|
|
shdr[symtab_section].sh_type = SHT_SYMTAB;
|
|
|
|
shdr[symtab_section].sh_offset = offset;
|
|
|
|
shdr[symtab_section].sh_size = num_syms * sizeof (Elf_Sym);
|
|
|
|
shdr[symtab_section].sh_entsize = sizeof (Elf_Sym);
|
|
|
|
shdr[symtab_section].sh_link = strtab_section;
|
|
|
|
shdr[symtab_section].sh_addralign = 4;
|
2008-07-24 14:56:30 +00:00
|
|
|
|
2013-12-16 14:30:50 +00:00
|
|
|
grub_util_write_image_at (symtab, shdr[symtab_section].sh_size,
|
2012-02-05 10:07:33 +00:00
|
|
|
offset, fp, name);
|
2013-12-16 14:30:50 +00:00
|
|
|
offset += shdr[symtab_section].sh_size;
|
2008-07-24 14:56:30 +00:00
|
|
|
|
|
|
|
free (symtab);
|
|
|
|
free (symtab_map);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-02-05 10:07:33 +00:00
|
|
|
write_string_table (FILE *fp, const char *name)
|
2008-07-24 14:56:30 +00:00
|
|
|
{
|
2013-12-16 14:30:50 +00:00
|
|
|
shdr[strtab_section].sh_name = insert_string (".strtab");
|
|
|
|
shdr[strtab_section].sh_type = SHT_STRTAB;
|
|
|
|
shdr[strtab_section].sh_offset = offset;
|
|
|
|
shdr[strtab_section].sh_size = strtab_len;
|
|
|
|
shdr[strtab_section].sh_addralign = 1;
|
2012-02-05 10:07:33 +00:00
|
|
|
grub_util_write_image_at (strtab, strtab_len, offset, fp,
|
|
|
|
name);
|
2008-07-24 14:56:30 +00:00
|
|
|
offset += strtab_len;
|
|
|
|
|
|
|
|
free (strtab);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-02-05 10:07:33 +00:00
|
|
|
write_section_header (FILE *fp, const char *name)
|
2008-07-24 14:56:30 +00:00
|
|
|
{
|
|
|
|
ehdr.e_ident[EI_MAG0] = ELFMAG0;
|
|
|
|
ehdr.e_ident[EI_MAG1] = ELFMAG1;
|
|
|
|
ehdr.e_ident[EI_MAG2] = ELFMAG2;
|
|
|
|
ehdr.e_ident[EI_MAG3] = ELFMAG3;
|
|
|
|
ehdr.e_ident[EI_VERSION] = EV_CURRENT;
|
|
|
|
ehdr.e_version = EV_CURRENT;
|
|
|
|
ehdr.e_type = ET_REL;
|
|
|
|
|
2013-12-16 14:30:50 +00:00
|
|
|
#if GRUB_TARGET_WORDSIZE == 64
|
|
|
|
ehdr.e_ident[EI_CLASS] = ELFCLASS64;
|
|
|
|
ehdr.e_ident[EI_DATA] = ELFDATA2LSB;
|
|
|
|
ehdr.e_machine = EM_X86_64;
|
|
|
|
#else
|
2008-07-24 14:56:30 +00:00
|
|
|
ehdr.e_ident[EI_CLASS] = ELFCLASS32;
|
|
|
|
ehdr.e_ident[EI_DATA] = ELFDATA2LSB;
|
|
|
|
ehdr.e_machine = EM_386;
|
2013-12-16 14:30:50 +00:00
|
|
|
#endif
|
2008-07-24 14:56:30 +00:00
|
|
|
ehdr.e_ehsize = sizeof (ehdr);
|
2013-12-16 14:30:50 +00:00
|
|
|
ehdr.e_shentsize = sizeof (Elf_Shdr);
|
|
|
|
ehdr.e_shstrndx = strtab_section;
|
2008-07-24 14:56:30 +00:00
|
|
|
|
|
|
|
ehdr.e_shoff = offset;
|
|
|
|
ehdr.e_shnum = num_sections;
|
2013-12-16 14:30:50 +00:00
|
|
|
grub_util_write_image_at (shdr, sizeof (Elf_Shdr) * num_sections,
|
2012-02-05 10:07:33 +00:00
|
|
|
offset, fp, name);
|
2008-07-24 14:56:30 +00:00
|
|
|
|
2013-12-16 14:30:50 +00:00
|
|
|
grub_util_write_image_at (&ehdr, sizeof (Elf_Ehdr), 0, fp, name);
|
2008-07-24 14:56:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-02-05 10:07:33 +00:00
|
|
|
convert_pe (FILE* fp, const char *name, char *image)
|
2008-07-24 14:56:30 +00:00
|
|
|
{
|
|
|
|
struct grub_pe32_coff_header *pe_chdr;
|
|
|
|
struct grub_pe32_section_table *pe_shdr;
|
|
|
|
int *section_map;
|
|
|
|
|
2013-12-14 22:12:53 +00:00
|
|
|
if (image[0] == 'M' && image[1] == 'Z')
|
|
|
|
pe_chdr = (struct grub_pe32_coff_header *) (image + (grub_le_to_cpu32 (((grub_uint32_t *)image)[0xf]) + 4));
|
|
|
|
else
|
|
|
|
pe_chdr = (struct grub_pe32_coff_header *) image;
|
2013-12-16 14:30:50 +00:00
|
|
|
if (grub_le_to_cpu16 (pe_chdr->machine) != GRUB_PE32_MACHINE)
|
2013-12-14 22:12:53 +00:00
|
|
|
grub_util_error ("invalid coff image (%x != %x)",
|
2013-12-16 14:30:50 +00:00
|
|
|
grub_le_to_cpu16 (pe_chdr->machine), GRUB_PE32_MACHINE);
|
2008-07-24 14:56:30 +00:00
|
|
|
|
|
|
|
strtab = xmalloc (STRTAB_BLOCK);
|
|
|
|
strtab_max = STRTAB_BLOCK;
|
|
|
|
strtab[0] = 0;
|
|
|
|
strtab_len = 1;
|
|
|
|
|
|
|
|
offset = sizeof (ehdr);
|
2013-12-14 22:12:53 +00:00
|
|
|
if (pe_chdr->optional_header_size)
|
|
|
|
{
|
2013-12-16 14:30:50 +00:00
|
|
|
#if GRUB_TARGET_WORDSIZE == 64
|
|
|
|
struct grub_pe64_optional_header *o;
|
|
|
|
#else
|
2013-12-14 22:12:53 +00:00
|
|
|
struct grub_pe32_optional_header *o;
|
2013-12-16 14:30:50 +00:00
|
|
|
#endif
|
|
|
|
o = (void *) (pe_chdr + 1);
|
2013-12-14 22:12:53 +00:00
|
|
|
image_base = o->image_base;
|
|
|
|
}
|
|
|
|
pe_shdr = (struct grub_pe32_section_table *) ((char *) (pe_chdr + 1) + pe_chdr->optional_header_size);
|
2008-07-24 14:56:30 +00:00
|
|
|
|
2012-02-05 10:07:33 +00:00
|
|
|
section_map = write_section_data (fp, name, image, pe_chdr, pe_shdr);
|
2008-07-24 14:56:30 +00:00
|
|
|
|
2012-02-05 10:07:33 +00:00
|
|
|
write_symbol_table (fp, name, image, pe_chdr, pe_shdr, section_map);
|
2008-07-24 14:56:30 +00:00
|
|
|
free (section_map);
|
|
|
|
|
2012-02-05 10:07:33 +00:00
|
|
|
write_string_table (fp, name);
|
2008-07-24 14:56:30 +00:00
|
|
|
|
2012-02-05 10:07:33 +00:00
|
|
|
write_section_header (fp, name);
|
2008-07-24 14:56:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
main (int argc, char *argv[])
|
|
|
|
{
|
|
|
|
char *image;
|
|
|
|
FILE* fp;
|
2013-08-22 15:00:59 +00:00
|
|
|
char *in, *out;
|
2008-07-24 14:56:30 +00:00
|
|
|
|
|
|
|
/* Obtain PATH. */
|
2013-08-22 15:00:59 +00:00
|
|
|
if (1 >= argc)
|
2008-07-24 14:56:30 +00:00
|
|
|
{
|
|
|
|
fprintf (stderr, "Filename not specified.\n");
|
2013-08-22 15:00:59 +00:00
|
|
|
return 1;
|
2008-07-24 14:56:30 +00:00
|
|
|
}
|
|
|
|
|
2013-08-22 15:00:59 +00:00
|
|
|
in = argv[1];
|
|
|
|
if (argc > 2)
|
|
|
|
out = argv[2];
|
|
|
|
else
|
|
|
|
out = in;
|
|
|
|
image = grub_util_read_image (in);
|
2008-07-24 14:56:30 +00:00
|
|
|
|
2013-10-13 18:36:28 +00:00
|
|
|
fp = grub_util_fopen (out, "wb");
|
2008-07-24 14:56:30 +00:00
|
|
|
if (! fp)
|
2013-08-22 15:00:59 +00:00
|
|
|
grub_util_error ("cannot open %s", out);
|
2008-07-24 14:56:30 +00:00
|
|
|
|
2013-08-22 15:00:59 +00:00
|
|
|
convert_pe (fp, out, image);
|
2008-07-24 14:56:30 +00:00
|
|
|
|
|
|
|
fclose (fp);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|