RISC-V: Add awareness for RISC-V reloations

[grub2.git] / util / grub-mkimagexx.c

/* grub-mkimage.c - make a bootable image */
/*
 *  GRUB  --  GRand Unified Bootloader
 *  Copyright (C) 2002,2003,2004,2005,2006,2007,2008,2009,2010  Free Software Foundation, Inc.
 *
 *  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/elf.h>
#include <grub/aout.h>
#include <grub/i18n.h>
#include <grub/kernel.h>
#include <grub/disk.h>
#include <grub/emu/misc.h>
#include <grub/util/misc.h>
#include <grub/util/resolve.h>
#include <grub/misc.h>
#include <grub/offsets.h>
#include <grub/crypto.h>
#include <grub/dl.h>
#include <time.h>
#include <multiboot.h>

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include <grub/efi/pe32.h>
#include <grub/uboot/image.h>
#include <grub/arm/reloc.h>
#include <grub/arm64/reloc.h>
#include <grub/ia64/reloc.h>
#include <grub/osdep/hostfile.h>
#include <grub/util/install.h>
#include <grub/util/mkimage.h>

#include <xen/elfnote.h>

#pragma GCC diagnostic ignored "-Wcast-align"

#define GRUB_MKIMAGEXX
#if !defined(MKIMAGE_ELF32) && !defined(MKIMAGE_ELF64)
#if __SIZEOF_POINTER__ == 8
#include "grub-mkimage64.c"
#else
#include "grub-mkimage32.c"
#endif
#endif

/* These structures are defined according to the CHRP binding to IEEE1275,
   "Client Program Format" section.  */

struct grub_ieee1275_note_desc
{
  grub_uint32_t real_mode;
  grub_uint32_t real_base;
  grub_uint32_t real_size;
  grub_uint32_t virt_base;
  grub_uint32_t virt_size;
  grub_uint32_t load_base;
};

#define GRUB_IEEE1275_NOTE_NAME "PowerPC"
#define GRUB_IEEE1275_NOTE_TYPE 0x1275

struct grub_ieee1275_note
{
  Elf32_Nhdr header;
  char name[ALIGN_UP(sizeof (GRUB_IEEE1275_NOTE_NAME), 4)];
  struct grub_ieee1275_note_desc descriptor;
};

#define GRUB_XEN_NOTE_NAME "Xen"

struct fixup_block_list
{
  struct fixup_block_list *next;
  int state;
  struct grub_pe32_fixup_block b;
};

#define ALIGN_ADDR(x) (ALIGN_UP((x), image_target->voidp_sizeof))

struct section_metadata
{
  Elf_Half num_sections;
  Elf_Shdr *sections;
  Elf_Addr *addrs;
  Elf_Addr *vaddrs;
  Elf_Half section_entsize;
  Elf_Shdr *symtab;
  const char *strtab;
};

static int
is_relocatable (const struct grub_install_image_target_desc *image_target)
{
  return image_target->id == IMAGE_EFI || image_target->id == IMAGE_UBOOT
    || (image_target->id == IMAGE_COREBOOT && image_target->elf_target == EM_ARM);
}

#ifdef MKIMAGE_ELF32

/*
 * R_ARM_THM_CALL/THM_JUMP24
 *
 * Relocate Thumb (T32) instruction set relative branches:
 *   B.W, BL and BLX
 */
static grub_err_t
grub_arm_reloc_thm_call (grub_uint16_t *target, Elf32_Addr sym_addr)
{
  grub_int32_t offset;

  offset = grub_arm_thm_call_get_offset (target);

  grub_dprintf ("dl", "    sym_addr = 0x%08x", sym_addr);

  offset += sym_addr;

  grub_dprintf("dl", " BL*: target=%p, sym_addr=0x%08x, offset=%d\n",
               target, sym_addr, offset);

  /* Keep traditional (pre-Thumb2) limits on blx. In any case if the kernel
     is bigger than 2M  (currently under 150K) then we probably have a problem
     somewhere else.  */
  if (offset < -0x200000 || offset >= 0x200000)
    return grub_error (GRUB_ERR_BAD_MODULE,
                       "THM_CALL Relocation out of range.");

  grub_dprintf ("dl", "    relative destination = %p",
                (char *) target + offset);

  return grub_arm_thm_call_set_offset (target, offset);
}

/*
 * R_ARM_THM_JUMP19
 *
 * Relocate conditional Thumb (T32) B<c>.W
 */
static grub_err_t
grub_arm_reloc_thm_jump19 (grub_uint16_t *target, Elf32_Addr sym_addr)
{
  grub_int32_t offset;

  if (!(sym_addr & 1))
    return grub_error (GRUB_ERR_BAD_MODULE,
                       "Relocation targeting wrong execution state");

  offset = grub_arm_thm_jump19_get_offset (target);

  /* Adjust and re-truncate offset */
  offset += sym_addr;

  if (!grub_arm_thm_jump19_check_offset (offset))
    return grub_error (GRUB_ERR_BAD_MODULE,
                       "THM_JUMP19 Relocation out of range.");

  grub_arm_thm_jump19_set_offset (target, offset);

  return GRUB_ERR_NONE;
}

/*
 * R_ARM_JUMP24
 *
 * Relocate ARM (A32) B
 */
static grub_err_t
grub_arm_reloc_jump24 (grub_uint32_t *target, Elf32_Addr sym_addr)
{
  grub_int32_t offset;

  if (sym_addr & 1)
    return grub_error (GRUB_ERR_BAD_MODULE,
                       "Relocation targeting wrong execution state");

  offset = grub_arm_jump24_get_offset (target);
  offset += sym_addr;

  if (!grub_arm_jump24_check_offset (offset))
    return grub_error (GRUB_ERR_BAD_MODULE,
                       "JUMP24 Relocation out of range.");


  grub_arm_jump24_set_offset (target, offset);

  return GRUB_ERR_NONE;
}

#endif

void
SUFFIX (grub_mkimage_generate_elf) (const struct grub_install_image_target_desc *image_target,
                                    int note, char **core_img, size_t *core_size,
                                    Elf_Addr target_addr,
                                    struct grub_mkimage_layout *layout)
{
  char *elf_img;
  size_t program_size;
  Elf_Ehdr *ehdr;
  Elf_Phdr *phdr;
  Elf_Shdr *shdr;
  int header_size, footer_size = 0;
  int phnum = 1;
  int shnum = 4;
  int string_size = sizeof (".text") + sizeof ("mods") + 1;

  if (image_target->id != IMAGE_LOONGSON_ELF)
    phnum += 2;

  if (note)
    {
      phnum++;
      footer_size += sizeof (struct grub_ieee1275_note);
    }
  if (image_target->id == IMAGE_XEN || image_target->id == IMAGE_XEN_PVH)
    {
      phnum++;
      shnum++;
      string_size += sizeof (".xen");
      footer_size += (image_target->id == IMAGE_XEN) ? XEN_NOTE_SIZE : XEN_PVH_NOTE_SIZE;
    }
  header_size = ALIGN_UP (sizeof (*ehdr) + phnum * sizeof (*phdr)
                          + shnum * sizeof (*shdr) + string_size, layout->align);

  program_size = ALIGN_ADDR (*core_size);

  elf_img = xmalloc (program_size + header_size + footer_size);
  memset (elf_img, 0, program_size + header_size + footer_size);
  memcpy (elf_img  + header_size, *core_img, *core_size);
  ehdr = (void *) elf_img;
  phdr = (void *) (elf_img + sizeof (*ehdr));
  shdr = (void *) (elf_img + sizeof (*ehdr) + phnum * sizeof (*phdr));
  memcpy (ehdr->e_ident, ELFMAG, SELFMAG);
  ehdr->e_ident[EI_CLASS] = ELFCLASSXX;
  if (!image_target->bigendian)
    ehdr->e_ident[EI_DATA] = ELFDATA2LSB;
  else
    ehdr->e_ident[EI_DATA] = ELFDATA2MSB;
  ehdr->e_ident[EI_VERSION] = EV_CURRENT;
  ehdr->e_ident[EI_OSABI] = ELFOSABI_NONE;
  ehdr->e_type = grub_host_to_target16 (ET_EXEC);
  ehdr->e_machine = grub_host_to_target16 (image_target->elf_target);
  ehdr->e_version = grub_host_to_target32 (EV_CURRENT);

  ehdr->e_phoff = grub_host_to_target32 ((char *) phdr - (char *) ehdr);
  ehdr->e_phentsize = grub_host_to_target16 (sizeof (*phdr));
  ehdr->e_phnum = grub_host_to_target16 (phnum);

  ehdr->e_shoff = grub_host_to_target32 ((grub_uint8_t *) shdr
                                         - (grub_uint8_t *) ehdr);
  if (image_target->id == IMAGE_LOONGSON_ELF)
    ehdr->e_shentsize = grub_host_to_target16 (0);
  else
    ehdr->e_shentsize = grub_host_to_target16 (sizeof (Elf_Shdr));
  ehdr->e_shnum = grub_host_to_target16 (shnum);
  ehdr->e_shstrndx = grub_host_to_target16 (1);

  ehdr->e_ehsize = grub_host_to_target16 (sizeof (*ehdr));

  phdr->p_type = grub_host_to_target32 (PT_LOAD);
  phdr->p_offset = grub_host_to_target32 (header_size);
  phdr->p_flags = grub_host_to_target32 (PF_R | PF_W | PF_X);

  ehdr->e_entry = grub_host_to_target32 (target_addr);
  phdr->p_vaddr = grub_host_to_target32 (target_addr);
  phdr->p_paddr = grub_host_to_target32 (target_addr);
  phdr->p_align = grub_host_to_target32 (layout->align > image_target->link_align ?
                                         layout->align : image_target->link_align);
  if (image_target->id == IMAGE_LOONGSON_ELF)
    ehdr->e_flags = grub_host_to_target32 (0x1000 | EF_MIPS_NOREORDER 
                                           | EF_MIPS_PIC | EF_MIPS_CPIC);
  else
    ehdr->e_flags = 0;
  if (image_target->id == IMAGE_LOONGSON_ELF)
    {
      phdr->p_filesz = grub_host_to_target32 (*core_size);
      phdr->p_memsz = grub_host_to_target32 (*core_size);
    }
  else
    {
      grub_uint32_t target_addr_mods;
      phdr->p_filesz = grub_host_to_target32 (layout->kernel_size);
      if (image_target->id == IMAGE_COREBOOT && image_target->elf_target == EM_ARM)
        phdr->p_memsz = grub_host_to_target32 (layout->kernel_size);
      else
        phdr->p_memsz = grub_host_to_target32 (layout->kernel_size + layout->bss_size);

      phdr++;
      phdr->p_type = grub_host_to_target32 (PT_GNU_STACK);
      phdr->p_offset = grub_host_to_target32 (header_size + layout->kernel_size);
      phdr->p_paddr = phdr->p_vaddr = phdr->p_filesz = phdr->p_memsz = 0;
      phdr->p_flags = grub_host_to_target32 (PF_R | PF_W | PF_X);
      phdr->p_align = grub_host_to_target32 (image_target->link_align);

      phdr++;
      phdr->p_type = grub_host_to_target32 (PT_LOAD);
      phdr->p_offset = grub_host_to_target32 (header_size + layout->kernel_size);
      phdr->p_flags = grub_host_to_target32 (PF_R | PF_W | PF_X);
      phdr->p_filesz = phdr->p_memsz
        = grub_host_to_target32 (*core_size - layout->kernel_size);

      if (image_target->id == IMAGE_COREBOOT && image_target->elf_target == EM_386)
        target_addr_mods = GRUB_KERNEL_I386_COREBOOT_MODULES_ADDR;
      else if (image_target->id == IMAGE_COREBOOT && image_target->elf_target == EM_ARM)
        target_addr_mods = ALIGN_UP (target_addr + layout->end
                                     + image_target->mod_gap,
                                     image_target->mod_align);
      else
        target_addr_mods = ALIGN_UP (target_addr + layout->kernel_size + layout->bss_size
                                     + image_target->mod_gap,
                                     image_target->mod_align);
      phdr->p_vaddr = grub_host_to_target_addr (target_addr_mods);
      phdr->p_paddr = grub_host_to_target_addr (target_addr_mods);
      phdr->p_align = grub_host_to_target32 (image_target->link_align);
    }

  if (image_target->id == IMAGE_XEN)
    {
      char *note_start = (elf_img + program_size + header_size);
      Elf_Nhdr *note_ptr;
      char *ptr = (char *) note_start;

      grub_util_info ("adding XEN NOTE segment");

      /* Guest OS.  */
      note_ptr = (Elf_Nhdr *) ptr;
      note_ptr->n_namesz = grub_host_to_target32 (sizeof (GRUB_XEN_NOTE_NAME));
      note_ptr->n_descsz = grub_host_to_target32 (sizeof (PACKAGE_NAME));
      note_ptr->n_type = grub_host_to_target32 (XEN_ELFNOTE_GUEST_OS);
      ptr += sizeof (Elf_Nhdr);
      memcpy (ptr, GRUB_XEN_NOTE_NAME, sizeof (GRUB_XEN_NOTE_NAME));
      ptr += ALIGN_UP (sizeof (GRUB_XEN_NOTE_NAME), 4);
      memcpy (ptr, PACKAGE_NAME, sizeof (PACKAGE_NAME));
      ptr += ALIGN_UP (sizeof (PACKAGE_NAME), 4);

      /* Loader.  */
      note_ptr = (Elf_Nhdr *) ptr;
      note_ptr->n_namesz = grub_host_to_target32 (sizeof (GRUB_XEN_NOTE_NAME));
      note_ptr->n_descsz = grub_host_to_target32 (sizeof ("generic"));
      note_ptr->n_type = grub_host_to_target32 (XEN_ELFNOTE_LOADER);
      ptr += sizeof (Elf_Nhdr);
      memcpy (ptr, GRUB_XEN_NOTE_NAME, sizeof (GRUB_XEN_NOTE_NAME));
      ptr += ALIGN_UP (sizeof (GRUB_XEN_NOTE_NAME), 4);
      memcpy (ptr, "generic", sizeof ("generic"));
      ptr += ALIGN_UP (sizeof ("generic"), 4);

      /* Version.  */
      note_ptr = (Elf_Nhdr *) ptr;
      note_ptr->n_namesz = grub_host_to_target32 (sizeof (GRUB_XEN_NOTE_NAME));
      note_ptr->n_descsz = grub_host_to_target32 (sizeof ("xen-3.0"));
      note_ptr->n_type = grub_host_to_target32 (XEN_ELFNOTE_XEN_VERSION);
      ptr += sizeof (Elf_Nhdr);
      memcpy (ptr, GRUB_XEN_NOTE_NAME, sizeof (GRUB_XEN_NOTE_NAME));
      ptr += ALIGN_UP (sizeof (GRUB_XEN_NOTE_NAME), 4);
      memcpy (ptr, "xen-3.0", sizeof ("xen-3.0"));
      ptr += ALIGN_UP (sizeof ("xen-3.0"), 4);

      /* Entry.  */
      note_ptr = (Elf_Nhdr *) ptr;
      note_ptr->n_namesz = grub_host_to_target32 (sizeof (GRUB_XEN_NOTE_NAME));
      note_ptr->n_descsz = grub_host_to_target32 (image_target->voidp_sizeof);
      note_ptr->n_type = grub_host_to_target32 (XEN_ELFNOTE_ENTRY);
      ptr += sizeof (Elf_Nhdr);
      memcpy (ptr, GRUB_XEN_NOTE_NAME, sizeof (GRUB_XEN_NOTE_NAME));
      ptr += ALIGN_UP (sizeof (GRUB_XEN_NOTE_NAME), 4);
      memset (ptr, 0, image_target->voidp_sizeof);
      ptr += image_target->voidp_sizeof;

      /* Virt base.  */
      note_ptr = (Elf_Nhdr *) ptr;
      note_ptr->n_namesz = grub_host_to_target32 (sizeof (GRUB_XEN_NOTE_NAME));
      note_ptr->n_descsz = grub_host_to_target32 (image_target->voidp_sizeof);
      note_ptr->n_type = grub_host_to_target32 (XEN_ELFNOTE_VIRT_BASE);
      ptr += sizeof (Elf_Nhdr);
      memcpy (ptr, GRUB_XEN_NOTE_NAME, sizeof (GRUB_XEN_NOTE_NAME));
      ptr += ALIGN_UP (sizeof (GRUB_XEN_NOTE_NAME), 4);
      memset (ptr, 0, image_target->voidp_sizeof);
      ptr += image_target->voidp_sizeof;

      /* PAE.  */
      if (image_target->elf_target == EM_386)
        {
          note_ptr = (Elf_Nhdr *) ptr;
          note_ptr->n_namesz = grub_host_to_target32 (sizeof (GRUB_XEN_NOTE_NAME));
          note_ptr->n_descsz = grub_host_to_target32 (sizeof ("yes,bimodal"));
          note_ptr->n_type = grub_host_to_target32 (XEN_ELFNOTE_PAE_MODE);
          ptr += sizeof (Elf_Nhdr);
          memcpy (ptr, GRUB_XEN_NOTE_NAME, sizeof (GRUB_XEN_NOTE_NAME));
          ptr += ALIGN_UP (sizeof (GRUB_XEN_NOTE_NAME), 4);
          memcpy (ptr, "yes", sizeof ("yes"));
          ptr += ALIGN_UP (sizeof ("yes"), 4);
        }

      assert (XEN_NOTE_SIZE == (ptr - note_start));

      phdr++;
      phdr->p_type = grub_host_to_target32 (PT_NOTE);
      phdr->p_flags = grub_host_to_target32 (PF_R);
      phdr->p_align = grub_host_to_target32 (image_target->voidp_sizeof);
      phdr->p_vaddr = 0;
      phdr->p_paddr = 0;
      phdr->p_filesz = grub_host_to_target32 (XEN_NOTE_SIZE);
      phdr->p_memsz = 0;
      phdr->p_offset = grub_host_to_target32 (header_size + program_size);
    }

  if (image_target->id == IMAGE_XEN_PVH)
    {
      char *note_start = (elf_img + program_size + header_size);
      Elf_Nhdr *note_ptr;
      char *ptr = (char *) note_start;

      grub_util_info ("adding XEN NOTE segment");

      /* Phys32 Entry.  */
      note_ptr = (Elf_Nhdr *) ptr;
      note_ptr->n_namesz = grub_host_to_target32 (sizeof (GRUB_XEN_NOTE_NAME));
      note_ptr->n_descsz = grub_host_to_target32 (image_target->voidp_sizeof);
      note_ptr->n_type = grub_host_to_target32 (XEN_ELFNOTE_PHYS32_ENTRY);
      ptr += sizeof (Elf_Nhdr);
      memcpy (ptr, GRUB_XEN_NOTE_NAME, sizeof (GRUB_XEN_NOTE_NAME));
      ptr += ALIGN_UP (sizeof (GRUB_XEN_NOTE_NAME), 4);
      memset (ptr, 0, image_target->voidp_sizeof);
      *(grub_uint32_t *) ptr = GRUB_KERNEL_I386_XEN_PVH_LINK_ADDR;
      ptr += image_target->voidp_sizeof;

      assert (XEN_PVH_NOTE_SIZE == (ptr - note_start));

      phdr++;
      phdr->p_type = grub_host_to_target32 (PT_NOTE);
      phdr->p_flags = grub_host_to_target32 (PF_R);
      phdr->p_align = grub_host_to_target32 (image_target->voidp_sizeof);
      phdr->p_vaddr = 0;
      phdr->p_paddr = 0;
      phdr->p_filesz = grub_host_to_target32 (XEN_PVH_NOTE_SIZE);
      phdr->p_memsz = 0;
      phdr->p_offset = grub_host_to_target32 (header_size + program_size);
    }

  if (note)
    {
      int note_size = sizeof (struct grub_ieee1275_note);
      struct grub_ieee1275_note *note_ptr = (struct grub_ieee1275_note *) 
        (elf_img + program_size + header_size);

      grub_util_info ("adding CHRP NOTE segment");

      note_ptr->header.n_namesz = grub_host_to_target32 (sizeof (GRUB_IEEE1275_NOTE_NAME));
      note_ptr->header.n_descsz = grub_host_to_target32 (note_size);
      note_ptr->header.n_type = grub_host_to_target32 (GRUB_IEEE1275_NOTE_TYPE);
      strcpy (note_ptr->name, GRUB_IEEE1275_NOTE_NAME);
      note_ptr->descriptor.real_mode = grub_host_to_target32 (0xffffffff);
      note_ptr->descriptor.real_base = grub_host_to_target32 (0x00c00000);
      note_ptr->descriptor.real_size = grub_host_to_target32 (0xffffffff);
      note_ptr->descriptor.virt_base = grub_host_to_target32 (0xffffffff);
      note_ptr->descriptor.virt_size = grub_host_to_target32 (0xffffffff);
      note_ptr->descriptor.load_base = grub_host_to_target32 (0x00004000);

      phdr++;
      phdr->p_type = grub_host_to_target32 (PT_NOTE);
      phdr->p_flags = grub_host_to_target32 (PF_R);
      phdr->p_align = grub_host_to_target32 (image_target->voidp_sizeof);
      phdr->p_vaddr = 0;
      phdr->p_paddr = 0;
      phdr->p_filesz = grub_host_to_target32 (note_size);
      phdr->p_memsz = 0;
      phdr->p_offset = grub_host_to_target32 (header_size + program_size);
    }

  {
    char *str_start = (elf_img + sizeof (*ehdr) + phnum * sizeof (*phdr)
                       + shnum * sizeof (*shdr));
    char *ptr = str_start + 1;

    shdr++;

    shdr->sh_name = grub_host_to_target32 (0);
    shdr->sh_type = grub_host_to_target32 (SHT_STRTAB);
    shdr->sh_addr = grub_host_to_target_addr (0);
    shdr->sh_offset = grub_host_to_target_addr (str_start - elf_img);
    shdr->sh_size = grub_host_to_target32 (string_size);
    shdr->sh_link = grub_host_to_target32 (0);
    shdr->sh_info = grub_host_to_target32 (0);
    shdr->sh_addralign = grub_host_to_target32 (layout->align);
    shdr->sh_entsize = grub_host_to_target32 (0);
    shdr++;

    memcpy (ptr, ".text", sizeof (".text"));

    shdr->sh_name = grub_host_to_target32 (ptr - str_start);
    ptr += sizeof (".text");
    shdr->sh_type = grub_host_to_target32 (SHT_PROGBITS);
    shdr->sh_addr = grub_host_to_target_addr (target_addr);
    shdr->sh_offset = grub_host_to_target_addr (header_size);
    shdr->sh_size = grub_host_to_target32 (layout->kernel_size);
    shdr->sh_link = grub_host_to_target32 (0);
    shdr->sh_info = grub_host_to_target32 (0);
    shdr->sh_addralign = grub_host_to_target32 (layout->align);
    shdr->sh_entsize = grub_host_to_target32 (0);
    shdr++;

    memcpy (ptr, "mods", sizeof ("mods"));
    shdr->sh_name = grub_host_to_target32 (ptr - str_start);
    ptr += sizeof ("mods");
    shdr->sh_type = grub_host_to_target32 (SHT_PROGBITS);
    shdr->sh_addr = grub_host_to_target_addr (target_addr + layout->kernel_size);
    shdr->sh_offset = grub_host_to_target_addr (header_size + layout->kernel_size);
    shdr->sh_size = grub_host_to_target32 (*core_size - layout->kernel_size);
    shdr->sh_link = grub_host_to_target32 (0);
    shdr->sh_info = grub_host_to_target32 (0);
    shdr->sh_addralign = grub_host_to_target32 (image_target->voidp_sizeof);
    shdr->sh_entsize = grub_host_to_target32 (0);
    shdr++;

    if (image_target->id == IMAGE_XEN || image_target->id == IMAGE_XEN_PVH)
      {
        memcpy (ptr, ".xen", sizeof (".xen"));
        shdr->sh_name = grub_host_to_target32 (ptr - str_start);
        ptr += sizeof (".xen");
        shdr->sh_type = grub_host_to_target32 (SHT_PROGBITS);
        shdr->sh_addr = grub_host_to_target_addr (target_addr + layout->kernel_size);
        shdr->sh_offset = grub_host_to_target_addr (program_size + header_size);
        if (image_target->id == IMAGE_XEN)
          shdr->sh_size = grub_host_to_target32 (XEN_NOTE_SIZE);
        else
          shdr->sh_size = grub_host_to_target32 (XEN_PVH_NOTE_SIZE);
        shdr->sh_link = grub_host_to_target32 (0);
        shdr->sh_info = grub_host_to_target32 (0);
        shdr->sh_addralign = grub_host_to_target32 (image_target->voidp_sizeof);
        shdr->sh_entsize = grub_host_to_target32 (0);
        shdr++;
      }
  }

  free (*core_img);
  *core_img = elf_img;
  *core_size = program_size + header_size + footer_size;
}

/* Relocate symbols; note that this function overwrites the symbol table.
   Return the address of a start symbol.  */
static Elf_Addr
SUFFIX (relocate_symbols) (Elf_Ehdr *e, struct section_metadata *smd,
                           void *jumpers, Elf_Addr jumpers_addr,
                           Elf_Addr bss_start, Elf_Addr end,
                           const struct grub_install_image_target_desc *image_target)
{
  Elf_Word symtab_size, sym_size, num_syms;
  Elf_Off symtab_offset;
  Elf_Addr start_address = (Elf_Addr) -1;
  Elf_Sym *sym;
  Elf_Word i;
  Elf_Shdr *symtab_section;
  const char *symtab;
  grub_uint64_t *jptr = jumpers;

  symtab_section = (Elf_Shdr *) ((char *) smd->sections
                                 + grub_target_to_host32 (smd->symtab->sh_link)
                                   * smd->section_entsize);
  symtab = (char *) e + grub_target_to_host (symtab_section->sh_offset);

  symtab_size = grub_target_to_host (smd->symtab->sh_size);
  sym_size = grub_target_to_host (smd->symtab->sh_entsize);
  symtab_offset = grub_target_to_host (smd->symtab->sh_offset);
  num_syms = symtab_size / sym_size;

  for (i = 0, sym = (Elf_Sym *) ((char *) e + symtab_offset);
       i < num_syms;
       i++, sym = (Elf_Sym *) ((char *) sym + sym_size))
    {
      Elf_Section cur_index;
      const char *name;

      name = symtab + grub_target_to_host32 (sym->st_name);

      cur_index = grub_target_to_host16 (sym->st_shndx);
      if (cur_index == STN_ABS)
        {
          continue;
        }
      else if (cur_index == STN_UNDEF)
        {
          if (sym->st_name && grub_strcmp (name, "__bss_start") == 0)
            sym->st_value = bss_start;
          else if (sym->st_name && grub_strcmp (name, "_end") == 0)
            sym->st_value = end;
          else if (sym->st_name)
            grub_util_error ("undefined symbol %s", name);
          else
            continue;
        }
      else if (cur_index >= smd->num_sections)
        grub_util_error ("section %d does not exist", cur_index);
      else
        {
          sym->st_value = (grub_target_to_host (sym->st_value)
                           + smd->vaddrs[cur_index]);
        }

      if (image_target->elf_target == EM_IA_64 && ELF_ST_TYPE (sym->st_info)
          == STT_FUNC)
        {
          *jptr = grub_host_to_target64 (sym->st_value);
          sym->st_value = (char *) jptr - (char *) jumpers + jumpers_addr;
          jptr++;
          *jptr = 0;
          jptr++;
        }
      grub_util_info ("locating %s at 0x%"  GRUB_HOST_PRIxLONG_LONG
                      " (0x%"  GRUB_HOST_PRIxLONG_LONG ")", name,
                      (unsigned long long) sym->st_value,
                      (unsigned long long) smd->vaddrs[cur_index]);

      if (start_address == (Elf_Addr)-1)
        if (strcmp (name, "_start") == 0 || strcmp (name, "start") == 0)
          start_address = sym->st_value;
    }

  return start_address;
}

/* Return the address of a symbol at the index I in the section S.  */
static Elf_Addr
SUFFIX (get_symbol_address) (Elf_Ehdr *e, Elf_Shdr *s, Elf_Word i,
                             const struct grub_install_image_target_desc *image_target)
{
  Elf_Sym *sym;

  sym = (Elf_Sym *) ((char *) e
                       + grub_target_to_host (s->sh_offset)
                       + i * grub_target_to_host (s->sh_entsize));
  return sym->st_value;
}

/* Return the address of a modified value.  */
static Elf_Addr *
SUFFIX (get_target_address) (Elf_Ehdr *e, Elf_Shdr *s, Elf_Addr offset,
                    const struct grub_install_image_target_desc *image_target)
{
  return (Elf_Addr *) ((char *) e + grub_target_to_host (s->sh_offset) + offset);
}

#ifdef MKIMAGE_ELF64
static Elf_Addr
SUFFIX (count_funcs) (Elf_Ehdr *e, Elf_Shdr *symtab_section,
                      const struct grub_install_image_target_desc *image_target)
{
  Elf_Word symtab_size, sym_size, num_syms;
  Elf_Off symtab_offset;
  Elf_Sym *sym;
  Elf_Word i;
  int ret = 0;

  symtab_size = grub_target_to_host (symtab_section->sh_size);
  sym_size = grub_target_to_host (symtab_section->sh_entsize);
  symtab_offset = grub_target_to_host (symtab_section->sh_offset);
  num_syms = symtab_size / sym_size;

  for (i = 0, sym = (Elf_Sym *) ((char *) e + symtab_offset);
       i < num_syms;
       i++, sym = (Elf_Sym *) ((char *) sym + sym_size))
    if (ELF_ST_TYPE (sym->st_info) == STT_FUNC)
      ret++;

  return ret;
}
#endif

#ifdef MKIMAGE_ELF32
/* Deal with relocation information. This function relocates addresses
   within the virtual address space starting from 0. So only relative
   addresses can be fully resolved. Absolute addresses must be relocated
   again by a PE32 relocator when loaded.  */
static grub_size_t
arm_get_trampoline_size (Elf_Ehdr *e,
                         Elf_Shdr *sections,
                         Elf_Half section_entsize,
                         Elf_Half num_sections,
                         const struct grub_install_image_target_desc *image_target)
{
  Elf_Half i;
  Elf_Shdr *s;
  grub_size_t ret = 0;

  for (i = 0, s = sections;
       i < num_sections;
       i++, s = (Elf_Shdr *) ((char *) s + section_entsize))
    if ((s->sh_type == grub_host_to_target32 (SHT_REL)) ||
        (s->sh_type == grub_host_to_target32 (SHT_RELA)))
      {
        Elf_Rela *r;
        Elf_Word rtab_size, r_size, num_rs;
        Elf_Off rtab_offset;
        Elf_Shdr *symtab_section;
        Elf_Word j;

        symtab_section = (Elf_Shdr *) ((char *) sections
                                         + (grub_target_to_host32 (s->sh_link)
                                            * section_entsize));

        rtab_size = grub_target_to_host (s->sh_size);
        r_size = grub_target_to_host (s->sh_entsize);
        rtab_offset = grub_target_to_host (s->sh_offset);
        num_rs = rtab_size / r_size;

        for (j = 0, r = (Elf_Rela *) ((char *) e + rtab_offset);
             j < num_rs;
             j++, r = (Elf_Rela *) ((char *) r + r_size))
          {
            Elf_Addr info;
            Elf_Addr sym_addr;

            info = grub_target_to_host (r->r_info);
            sym_addr = SUFFIX (get_symbol_address) (e, symtab_section,
                                                    ELF_R_SYM (info), image_target);

            sym_addr += (s->sh_type == grub_target_to_host32 (SHT_RELA)) ?
              grub_target_to_host (r->r_addend) : 0;

            switch (ELF_R_TYPE (info))
              {
              case R_ARM_ABS32:
              case R_ARM_V4BX:
                break;
              case R_ARM_THM_CALL:
              case R_ARM_THM_JUMP24:
              case R_ARM_THM_JUMP19:
                if (!(sym_addr & 1))
                  ret += 8;
                break;

              case R_ARM_CALL:
              case R_ARM_JUMP24:
                if (sym_addr & 1)
                  ret += 16;
                break;

              default:
                grub_util_error (_("relocation 0x%x is not implemented yet"),
                                 (unsigned int) ELF_R_TYPE (info));
                break;
              }
          }
      }
  return ret;
}
#endif

static int
SUFFIX (is_kept_section) (Elf_Shdr *s, const struct grub_install_image_target_desc *image_target);
static int
SUFFIX (is_kept_reloc_section) (Elf_Shdr *s, const struct grub_install_image_target_desc *image_target,
                                struct section_metadata *smd);

/* Deal with relocation information. This function relocates addresses
   within the virtual address space starting from 0. So only relative
   addresses can be fully resolved. Absolute addresses must be relocated
   again by a PE32 relocator when loaded.  */
static void
SUFFIX (relocate_addrs) (Elf_Ehdr *e, struct section_metadata *smd,
                             char *pe_target, Elf_Addr tramp_off, Elf_Addr got_off,
                             const struct grub_install_image_target_desc *image_target)
{
  Elf_Half i;
  Elf_Shdr *s;
#ifdef MKIMAGE_ELF64
  struct grub_ia64_trampoline *tr = (void *) (pe_target + tramp_off);
  grub_uint64_t *gpptr = (void *) (pe_target + got_off);
  unsigned unmatched_adr_got_page = 0;
#define MASK19 ((1 << 19) - 1)
#else
  grub_uint32_t *tr = (void *) (pe_target + tramp_off);
#endif

  for (i = 0, s = smd->sections;
       i < smd->num_sections;
       i++, s = (Elf_Shdr *) ((char *) s + smd->section_entsize))
    if ((s->sh_type == grub_host_to_target32 (SHT_REL)) ||
        (s->sh_type == grub_host_to_target32 (SHT_RELA)))
      {
        Elf_Rela *r;
        Elf_Word rtab_size, r_size, num_rs;
        Elf_Off rtab_offset;
        Elf_Word target_section_index;
        Elf_Addr target_section_addr;
        Elf_Shdr *target_section;
        Elf_Word j;

        if (!SUFFIX (is_kept_section) (s, image_target) &&
            !SUFFIX (is_kept_reloc_section) (s, image_target, smd))
          {
            grub_util_info ("not translating relocations for omitted section %s",
                        smd->strtab + grub_le_to_cpu32 (s->sh_name));
            continue;
          }

        target_section_index = grub_target_to_host32 (s->sh_info);
        target_section_addr = smd->addrs[target_section_index];
        target_section = (Elf_Shdr *) ((char *) smd->sections
                                         + (target_section_index
                                            * smd->section_entsize));

        grub_util_info ("dealing with the relocation section %s for %s",
                        smd->strtab + grub_target_to_host32 (s->sh_name),
                        smd->strtab + grub_target_to_host32 (target_section->sh_name));

        rtab_size = grub_target_to_host (s->sh_size);
        r_size = grub_target_to_host (s->sh_entsize);
        rtab_offset = grub_target_to_host (s->sh_offset);
        num_rs = rtab_size / r_size;

        for (j = 0, r = (Elf_Rela *) ((char *) e + rtab_offset);
             j < num_rs;
             j++, r = (Elf_Rela *) ((char *) r + r_size))
          {
            Elf_Addr info;
            Elf_Addr offset;
            Elf_Addr sym_addr;
            Elf_Addr *target;
            Elf_Addr addend;

            offset = grub_target_to_host (r->r_offset);
            target = SUFFIX (get_target_address) (e, target_section,
                                                  offset, image_target);
            info = grub_target_to_host (r->r_info);
            sym_addr = SUFFIX (get_symbol_address) (e, smd->symtab,
                                                    ELF_R_SYM (info), image_target);

            addend = (s->sh_type == grub_target_to_host32 (SHT_RELA)) ?
              grub_target_to_host (r->r_addend) : 0;

           switch (image_target->elf_target)
             {
             case EM_386:
              switch (ELF_R_TYPE (info))
                {
                case R_386_NONE:
                  break;

                case R_386_32:
                  /* This is absolute.  */
                  *target = grub_host_to_target32 (grub_target_to_host32 (*target)
                                                   + addend + sym_addr);
                  grub_util_info ("relocating an R_386_32 entry to 0x%"
                                  GRUB_HOST_PRIxLONG_LONG " at the offset 0x%"
                                  GRUB_HOST_PRIxLONG_LONG,
                                  (unsigned long long) *target,
                                  (unsigned long long) offset);
                  break;

                case R_386_PC32:
                  /* This is relative.  */
                  *target = grub_host_to_target32 (grub_target_to_host32 (*target)
                                                   + addend + sym_addr
                                                   - target_section_addr - offset
                                                   - image_target->vaddr_offset);
                  grub_util_info ("relocating an R_386_PC32 entry to 0x%"
                                  GRUB_HOST_PRIxLONG_LONG " at the offset 0x%"
                                  GRUB_HOST_PRIxLONG_LONG,
                                  (unsigned long long) *target,
                                  (unsigned long long) offset);
                  break;
                default:
                  grub_util_error (_("relocation 0x%x is not implemented yet"),
                                   (unsigned int) ELF_R_TYPE (info));
                  break;
                }
              break;
#ifdef MKIMAGE_ELF64
             case EM_X86_64:
              switch (ELF_R_TYPE (info))
                {

                case R_X86_64_NONE:
                  break;

                case R_X86_64_64:
                  *target = grub_host_to_target64 (grub_target_to_host64 (*target)
                                                   + addend + sym_addr);
                  grub_util_info ("relocating an R_X86_64_64 entry to 0x%"
                                  GRUB_HOST_PRIxLONG_LONG " at the offset 0x%"
                                  GRUB_HOST_PRIxLONG_LONG,
                                  (unsigned long long) *target,
                                  (unsigned long long) offset);
                  break;

                case R_X86_64_PC32:
                case R_X86_64_PLT32:
                  {
                    grub_uint32_t *t32 = (grub_uint32_t *) target;
                    *t32 = grub_host_to_target64 (grub_target_to_host32 (*t32)
                                                  + addend + sym_addr
                                                  - target_section_addr - offset
                                                  - image_target->vaddr_offset);
                    grub_util_info ("relocating an R_X86_64_PC32 entry to 0x%x at the offset 0x%"
                                    GRUB_HOST_PRIxLONG_LONG,
                                    *t32, (unsigned long long) offset);
                    break;
                  }

                case R_X86_64_PC64:
                  {
                    *target = grub_host_to_target64 (grub_target_to_host64 (*target)
                                                     + addend + sym_addr
                                                     - target_section_addr - offset
                                                     - image_target->vaddr_offset);
                    grub_util_info ("relocating an R_X86_64_PC64 entry to 0x%"
                                    GRUB_HOST_PRIxLONG_LONG " at the offset 0x%"
                                    GRUB_HOST_PRIxLONG_LONG,
                                    (unsigned long long) *target,
                                    (unsigned long long) offset);
                    break;
                  }

                case R_X86_64_32:
                case R_X86_64_32S:
                  {
                    grub_uint32_t *t32 = (grub_uint32_t *) target;
                    *t32 = grub_host_to_target64 (grub_target_to_host32 (*t32)
                                                  + addend + sym_addr);
                    grub_util_info ("relocating an R_X86_64_32(S) entry to 0x%x at the offset 0x%"
                                    GRUB_HOST_PRIxLONG_LONG,
                                    *t32, (unsigned long long) offset);
                    break;
                  }

                default:
                  grub_util_error (_("relocation 0x%x is not implemented yet"),
                                   (unsigned int) ELF_R_TYPE (info));
                  break;
                }
              break;
             case EM_IA_64:
              switch (ELF_R_TYPE (info))
                {
                case R_IA64_PCREL21B:
                  {
                    grub_uint64_t noff;
                    grub_ia64_make_trampoline (tr, addend + sym_addr);
                    noff = ((char *) tr - (char *) pe_target
                            - target_section_addr - (offset & ~3)) >> 4;
                    tr++;
                    if (noff & ~MASK19)
                      grub_util_error ("trampoline offset too big (%"
                                       GRUB_HOST_PRIxLONG_LONG ")",
                                       (unsigned long long) noff);
                    grub_ia64_add_value_to_slot_20b ((grub_addr_t) target, noff);
                  }
                  break;

                case R_IA64_LTOFF22X:
                case R_IA64_LTOFF22:
                  {
                    Elf_Sym *sym;

                    sym = (Elf_Sym *) ((char *) e
                                       + grub_target_to_host (smd->symtab->sh_offset)
                                       + ELF_R_SYM (info) * grub_target_to_host (smd->symtab->sh_entsize));
                    if (ELF_ST_TYPE (sym->st_info) == STT_FUNC)
                      sym_addr = grub_target_to_host64 (*(grub_uint64_t *) (pe_target
                                                                            + sym->st_value
                                                                            - image_target->vaddr_offset));
                  }
                /* FALLTHROUGH */
                case R_IA64_LTOFF_FPTR22:
                  *gpptr = grub_host_to_target64 (addend + sym_addr);
                  grub_ia64_add_value_to_slot_21 ((grub_addr_t) target,
                                                  (char *) gpptr - (char *) pe_target
                                                  + image_target->vaddr_offset);
                  gpptr++;
                  break;

                case R_IA64_GPREL22:
                  grub_ia64_add_value_to_slot_21 ((grub_addr_t) target,
                                                  addend + sym_addr);
                  break;
                case R_IA64_GPREL64I:
                  grub_ia64_set_immu64 ((grub_addr_t) target,
                                        addend + sym_addr);
                  break;
                case R_IA64_PCREL64LSB:
                  *target = grub_host_to_target64 (grub_target_to_host64 (*target)
                                                   + addend + sym_addr
                                                   - target_section_addr - offset
                                                   - image_target->vaddr_offset);
                  break;

                case R_IA64_SEGREL64LSB:
                  *target = grub_host_to_target64 (grub_target_to_host64 (*target)
                                                   + addend + sym_addr - target_section_addr);
                  break;
                case R_IA64_DIR64LSB:
                case R_IA64_FPTR64LSB:
                  *target = grub_host_to_target64 (grub_target_to_host64 (*target)
                                                   + addend + sym_addr);
                  grub_util_info ("relocating a direct entry to 0x%"
                                  GRUB_HOST_PRIxLONG_LONG " at the offset 0x%"
                                  GRUB_HOST_PRIxLONG_LONG,
                                  (unsigned long long)
                                  grub_target_to_host64 (*target),
                                  (unsigned long long) offset);
                  break;

                  /* We treat LTOFF22X as LTOFF22, so we can ignore LDXMOV.  */
                case R_IA64_LDXMOV:
                  break;

                default:
                  grub_util_error (_("relocation 0x%x is not implemented yet"),
                                   (unsigned int) ELF_R_TYPE (info));
                  break;
                }
               break;
             case EM_AARCH64:
               {
                 sym_addr += addend;
                 switch (ELF_R_TYPE (info))
                   {
                   case R_AARCH64_ABS64:
                     {
                       *target = grub_host_to_target64 (grub_target_to_host64 (*target) + sym_addr);
                     }
                     break;
                   case R_AARCH64_PREL32:
                     {
                       grub_uint32_t *t32 = (grub_uint32_t *) target;
                       *t32 = grub_host_to_target64 (grub_target_to_host32 (*t32)
                                                     + sym_addr
                                                     - target_section_addr - offset
                                                     - image_target->vaddr_offset);
                       grub_util_info ("relocating an R_AARCH64_PREL32 entry to 0x%x at the offset 0x%"
                                       GRUB_HOST_PRIxLONG_LONG,
                                       *t32, (unsigned long long) offset);
                       break;
                     }
                   case R_AARCH64_ADD_ABS_LO12_NC:
                     grub_arm64_set_abs_lo12 ((grub_uint32_t *) target,
                                              sym_addr);
                     break;
                   case R_AARCH64_LDST64_ABS_LO12_NC:
                     grub_arm64_set_abs_lo12_ldst64 ((grub_uint32_t *) target,
                                                     sym_addr);
                     break;
                   case R_AARCH64_JUMP26:
                   case R_AARCH64_CALL26:
                     {
                       sym_addr -= offset;
                       sym_addr -= target_section_addr + image_target->vaddr_offset;
                       if (!grub_arm_64_check_xxxx26_offset (sym_addr))
                         grub_util_error ("%s", "CALL26 Relocation out of range");

                       grub_arm64_set_xxxx26_offset((grub_uint32_t *)target,
                                                     sym_addr);
                     }
                     break;
                   case R_AARCH64_ADR_GOT_PAGE:
                     {
                       Elf64_Rela *rel2;
                       grub_int64_t gpoffset = (((char *) gpptr - (char *) pe_target + image_target->vaddr_offset) & ~0xfffULL)
                         - ((offset + target_section_addr + image_target->vaddr_offset) & ~0xfffULL);
                       unsigned k;
                       *gpptr = grub_host_to_target64 (sym_addr);
                       unmatched_adr_got_page++;
                       if (!grub_arm64_check_hi21_signed (gpoffset))
                         grub_util_error ("HI21 out of range");
                       grub_arm64_set_hi21((grub_uint32_t *)target,
                                           gpoffset);
                       for (k = 0, rel2 = (Elf_Rela *) ((char *) r + r_size);
                            k < num_rs;
                            k++, rel2 = (Elf_Rela *) ((char *) rel2 + r_size))
                         if (ELF_R_SYM (rel2->r_info)
                             == ELF_R_SYM (r->r_info)
                             && r->r_addend == rel2->r_addend
                             && ELF_R_TYPE (rel2->r_info) == R_AARCH64_LD64_GOT_LO12_NC)
                           {
                             grub_arm64_set_abs_lo12_ldst64 ((grub_uint32_t *) SUFFIX (get_target_address) (e, target_section,
                                                                                                            grub_target_to_host (rel2->r_offset), image_target),
                                                             ((char *) gpptr - (char *) pe_target + image_target->vaddr_offset));
                             break;
                           }
                       if (k >= num_rs)
                         grub_util_error ("ADR_GOT_PAGE without matching LD64_GOT_LO12_NC");
                       gpptr++;
                     }
                     break;
                   case R_AARCH64_LD64_GOT_LO12_NC:
                     if (unmatched_adr_got_page == 0)
                       grub_util_error ("LD64_GOT_LO12_NC without matching ADR_GOT_PAGE");
                     unmatched_adr_got_page--;
                     break;
                   case R_AARCH64_ADR_PREL_PG_HI21:
                     {
                       sym_addr &= ~0xfffULL;
                       sym_addr -= (offset + target_section_addr + image_target->vaddr_offset) & ~0xfffULL;
                       if (!grub_arm64_check_hi21_signed (sym_addr))
                         grub_util_error ("%s", "CALL26 Relocation out of range");

                       grub_arm64_set_hi21((grub_uint32_t *)target,
                                           sym_addr);
                     }
                     break;
                   default:
                     grub_util_error (_("relocation 0x%x is not implemented yet"),
                                      (unsigned int) ELF_R_TYPE (info));
                     break;
                   }
               break;
               }
#endif
#if defined(MKIMAGE_ELF32)
             case EM_ARM:
               {
                 sym_addr += addend;
                 sym_addr -= image_target->vaddr_offset;
                 switch (ELF_R_TYPE (info))
                   {
                   case R_ARM_ABS32:
                     {
                       grub_util_info ("  ABS32:\toffset=%d\t(0x%08x)",
                                       (int) sym_addr, (int) sym_addr);
                       /* Data will be naturally aligned */
                       if (image_target->id == IMAGE_EFI)
                         sym_addr += 0x400;
                       *target = grub_host_to_target32 (grub_target_to_host32 (*target) + sym_addr);
                     }
                     break;
                     /* Happens when compiled with -march=armv4.
                        Since currently we need at least armv5, keep bx as-is.
                     */
                   case R_ARM_V4BX:
                     break;
                   case R_ARM_THM_CALL:
                   case R_ARM_THM_JUMP24:
                   case R_ARM_THM_JUMP19:
                     {
                       grub_err_t err;
                       Elf_Sym *sym;
                       grub_util_info ("  THM_JUMP24:\ttarget=0x%08lx\toffset=(0x%08x)",
                                       (unsigned long) ((char *) target
                                                        - (char *) e),
                                       sym_addr);
                       sym = (Elf_Sym *) ((char *) e
                                          + grub_target_to_host (smd->symtab->sh_offset)
                                          + ELF_R_SYM (info) * grub_target_to_host (smd->symtab->sh_entsize));
                       if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
                         sym_addr |= 1;
                       if (!(sym_addr & 1))
                         {
                           grub_uint32_t tr_addr;
                           grub_int32_t new_offset;
                           tr_addr = (char *) tr - (char *) pe_target
                             - target_section_addr;
                           new_offset = sym_addr - tr_addr - 12;

                           if (!grub_arm_jump24_check_offset (new_offset))
                             return grub_util_error ("jump24 relocation out of range");

                           tr[0] = grub_host_to_target32 (0x46c04778); /* bx pc; nop  */
                           tr[1] = grub_host_to_target32 (((new_offset >> 2) & 0xffffff) | 0xea000000); /* b new_offset */
                           tr += 2;
                           sym_addr = tr_addr | 1;
                         }
                       sym_addr -= offset;
                       /* Thumb instructions can be 16-bit aligned */
                       if (ELF_R_TYPE (info) == R_ARM_THM_JUMP19)
                         err = grub_arm_reloc_thm_jump19 ((grub_uint16_t *) target, sym_addr);
                       else
                         err = grub_arm_reloc_thm_call ((grub_uint16_t *) target,
                                                        sym_addr);
                       if (err)
                         grub_util_error ("%s", grub_errmsg);
                     }
                     break;

                   case R_ARM_CALL:
                   case R_ARM_JUMP24:
                     {
                       grub_err_t err;
                       grub_util_info ("  JUMP24:\ttarget=0x%08lx\toffset=(0x%08x)",  (unsigned long) ((char *) target - (char *) e), sym_addr);
                       if (sym_addr & 1)
                         {
                           grub_uint32_t tr_addr;
                           grub_int32_t new_offset;
                           tr_addr = (char *) tr - (char *) pe_target
                             - target_section_addr;
                           new_offset = sym_addr - tr_addr - 12;

                           /* There is no immediate version of bx, only register one...  */
                           tr[0] = grub_host_to_target32 (0xe59fc004); /* ldr   ip, [pc, #4] */
                           tr[1] = grub_host_to_target32 (0xe08cc00f); /* add   ip, ip, pc */
                           tr[2] = grub_host_to_target32 (0xe12fff1c); /* bx    ip */
                           tr[3] = grub_host_to_target32 (new_offset | 1);
                           tr += 4;
                           sym_addr = tr_addr;
                         }
                       sym_addr -= offset;
                       err = grub_arm_reloc_jump24 (target,
                                                    sym_addr);
                       if (err)
                         grub_util_error ("%s", grub_errmsg);
                     }
                     break;

                   default:
                     grub_util_error (_("relocation 0x%x is not implemented yet"),
                                      (unsigned int) ELF_R_TYPE (info));
                     break;
                   }
                 break;
               }
#endif /* MKIMAGE_ELF32 */
             case EM_RISCV:
               {
                 grub_uint64_t *t64 = (grub_uint64_t *) target;
                 grub_uint32_t *t32 = (grub_uint32_t *) target;
                 grub_uint16_t *t16 = (grub_uint16_t *) target;
                 grub_uint8_t *t8 = (grub_uint8_t *) target;
                 grub_int64_t off = (long)sym_addr - target_section_addr - offset
                                    - image_target->vaddr_offset;

                 /*
                  * Instructions and instruction encoding are documented in the RISC-V
                  * specification. This file is based on version 2.2:
                  *
                  * https://github.com/riscv/riscv-isa-manual/blob/master/release/riscv-spec-v2.2.pdf
                  */

                 sym_addr += addend;

                 switch (ELF_R_TYPE (info))
                   {
                   case R_RISCV_ADD8:
                     *t8 = *t8 + sym_addr;
                     break;
                   case R_RISCV_ADD16:
                     *t16 = grub_host_to_target16 (grub_target_to_host16 (*t16) + sym_addr);
                     break;
                   case R_RISCV_32:
                   case R_RISCV_ADD32:
                     *t32 = grub_host_to_target32 (grub_target_to_host32 (*t32) + sym_addr);
                     break;
                   case R_RISCV_64:
                   case R_RISCV_ADD64:
                     *t64 = grub_host_to_target64 (grub_target_to_host64 (*t64) + sym_addr);
                     break;

                   case R_RISCV_SUB8:
                     *t8 = sym_addr - *t8;
                     break;
                   case R_RISCV_SUB16:
                     *t16 = grub_host_to_target16 (grub_target_to_host16 (*t16) - sym_addr);
                     break;
                   case R_RISCV_SUB32:
                     *t32 = grub_host_to_target32 (grub_target_to_host32 (*t32) - sym_addr);
                     break;
                   case R_RISCV_SUB64:
                     *t64 = grub_host_to_target64 (grub_target_to_host64 (*t64) - sym_addr);
                     break;
                   case R_RISCV_BRANCH:
                     {
                       grub_uint32_t imm12 = (off & 0x1000) << (31 - 12);
                       grub_uint32_t imm11 = (off & 0x800) >> (11 - 7);
                       grub_uint32_t imm10_5 = (off & 0x7e0) << (30 - 10);
                       grub_uint32_t imm4_1 = (off & 0x1e) << (11 - 4);
                       *t32 = grub_host_to_target32 ((grub_target_to_host32 (*t32) & 0x1fff07f)
                                                     | imm12 | imm11 | imm10_5 | imm4_1);
                     }
                     break;
                   case R_RISCV_JAL:
                     {
                       grub_uint32_t imm20 = (off & 0x100000) << (31 - 20);
                       grub_uint32_t imm19_12 = (off & 0xff000);
                       grub_uint32_t imm11 = (off & 0x800) << (20 - 11);
                       grub_uint32_t imm10_1 = (off & 0x7fe) << (30 - 10);
                       *t32 = grub_host_to_target32 ((grub_target_to_host32 (*t32) & 0xfff)
                                                     | imm20 | imm19_12 | imm11 | imm10_1);
                     }
                     break;
                   case R_RISCV_CALL:
                     {
                       grub_uint32_t hi20, lo12;

                       if (off != (grub_int32_t)off)
                         grub_util_error ("target %lx not reachable from pc=%lx", (long)sym_addr, (long)target);

                       hi20 = (off + 0x800) & 0xfffff000;
                       lo12 = (off - hi20) & 0xfff;
                       t32[0] = grub_host_to_target32 ((grub_target_to_host32 (t32[0]) & 0xfff) | hi20);
                       t32[1] = grub_host_to_target32 ((grub_target_to_host32 (t32[1]) & 0xfffff) | (lo12 << 20));
                     }
                     break;
                   case R_RISCV_RVC_BRANCH:
                     {
                       grub_uint16_t imm8 = (off & 0x100) << (12 - 8);
                       grub_uint16_t imm7_6 = (off & 0xc0) >> (6 - 5);
                       grub_uint16_t imm5 = (off & 0x20) >> (5 - 2);
                       grub_uint16_t imm4_3 = (off & 0x18) << (12 - 5);
                       grub_uint16_t imm2_1 = (off & 0x6) << (12 - 10);
                       *t16 = grub_host_to_target16 ((grub_target_to_host16 (*t16) & 0xe383)
                                                     | imm8 | imm7_6 | imm5 | imm4_3 | imm2_1);
                     }
                     break;
                   case R_RISCV_RVC_JUMP:
                     {
                       grub_uint16_t imm11 = (off & 0x800) << (12 - 11);
                       grub_uint16_t imm10 = (off & 0x400) >> (10 - 8);
                       grub_uint16_t imm9_8 = (off & 0x300) << (12 - 11);
                       grub_uint16_t imm7 = (off & 0x80) >> (7 - 6);
                       grub_uint16_t imm6 = (off & 0x40) << (12 - 11);
                       grub_uint16_t imm5 = (off & 0x20) >> (5 - 2);
                       grub_uint16_t imm4 = (off & 0x10) << (12 - 5);
                       grub_uint16_t imm3_1 = (off & 0xe) << (12 - 10);
                       *t16 = grub_host_to_target16 ((grub_target_to_host16 (*t16) & 0xe003)
                                                     | imm11 | imm10 | imm9_8 | imm7 | imm6
                                                     | imm5 | imm4 | imm3_1);
                     }
                     break;
                   case R_RISCV_PCREL_HI20:
                     {
                       grub_int32_t hi20;

                       if (off != (grub_int32_t)off)
                         grub_util_error ("target %lx not reachable from pc=%lx", (long)sym_addr, (long)target);

                       hi20 = (off + 0x800) & 0xfffff000;
                       *t32 = grub_host_to_target32 ((grub_target_to_host32 (*t32) & 0xfff) | hi20);
                     }
                     break;
                   case R_RISCV_PCREL_LO12_I:
                   case R_RISCV_PCREL_LO12_S:
                     {
                       Elf_Rela *rel2;
                       Elf_Word k;
                       /* Search backwards for matching HI20 reloc.  */
                       for (k = j, rel2 = (Elf_Rela *) ((char *) r - r_size);
                            k > 0;
                            k--, rel2 = (Elf_Rela *) ((char *) rel2 - r_size))
                         {
                           Elf_Addr rel2_info;
                           Elf_Addr rel2_offset;
                           Elf_Addr rel2_sym_addr;
                           Elf_Addr rel2_addend;
                           Elf_Addr rel2_loc;
                           grub_int64_t rel2_off;

                           rel2_offset = grub_target_to_host (rel2->r_offset);
                           rel2_info = grub_target_to_host (rel2->r_info);
                           rel2_loc = target_section_addr + rel2_offset + image_target->vaddr_offset;

                           if (ELF_R_TYPE (rel2_info) == R_RISCV_PCREL_HI20
                               && rel2_loc == sym_addr)
                             {
                               rel2_sym_addr = SUFFIX (get_symbol_address)
                                 (e, smd->symtab, ELF_R_SYM (rel2_info),
                                  image_target);
                               rel2_addend = (s->sh_type == grub_target_to_host32 (SHT_RELA)) ?
                                 grub_target_to_host (rel2->r_addend) : 0;
                               rel2_off = rel2_sym_addr + rel2_addend - rel2_loc;
                               off = rel2_off - ((rel2_off + 0x800) & 0xfffff000);

                               if (ELF_R_TYPE (info) == R_RISCV_PCREL_LO12_I)
                                 *t32 = grub_host_to_target32 ((grub_target_to_host32 (*t32) & 0xfffff) | (off & 0xfff) << 20);
                               else
                                 {
                                   grub_uint32_t imm11_5 = (off & 0xfe0) << (31 - 11);
                                   grub_uint32_t imm4_0 = (off & 0x1f) << (11 - 4);
                                   *t32 = grub_host_to_target32 ((grub_target_to_host32 (*t32) & 0x1fff07f) | imm11_5 | imm4_0);
                                 }
                               break;
                             }
                         }
                       if (k == 0)
                         grub_util_error ("cannot find matching HI20 relocation");
                     }
                     break;
                   case R_RISCV_HI20:
                     *t32 = grub_host_to_target32 ((grub_target_to_host32 (*t32) & 0xfff) | (((grub_int32_t) sym_addr + 0x800) & 0xfffff000));
                     break;
                   case R_RISCV_LO12_I:
                     {
                       grub_int32_t lo12 = (grub_int32_t) sym_addr - (((grub_int32_t) sym_addr + 0x800) & 0xfffff000);
                       *t32 = grub_host_to_target32 ((grub_target_to_host32 (*t32) & 0xfffff) | ((lo12 & 0xfff) << 20));
                     }
                     break;
                   case R_RISCV_LO12_S:
                     {
                       grub_int32_t lo12 = (grub_int32_t) sym_addr - (((grub_int32_t) sym_addr + 0x800) & 0xfffff000);
                       grub_uint32_t imm11_5 = (lo12 & 0xfe0) << (31 - 11);
                       grub_uint32_t imm4_0 = (lo12 & 0x1f) << (11 - 4);
                       *t32 = grub_host_to_target32 ((grub_target_to_host32 (*t32) & 0x1fff07f) | imm11_5 | imm4_0);
                     }
                     break;
                   case R_RISCV_RELAX:
                     break;
                   default:
                     grub_util_error (_("relocation 0x%x is not implemented yet"),
                                      (unsigned int) ELF_R_TYPE (info));
                     break;
                   }
               break;
               }
             default:
               grub_util_error ("unknown architecture type %d",
                                image_target->elf_target);
             }
          }
      }
}

/* Add a PE32's fixup entry for a relocation. Return the resulting address
   after having written to the file OUT.  */
static Elf_Addr
add_fixup_entry (struct fixup_block_list **cblock, grub_uint16_t type,
                 Elf_Addr addr, int flush, Elf_Addr current_address,
                 const struct grub_install_image_target_desc *image_target)
{
  struct grub_pe32_fixup_block *b;

  b = &((*cblock)->b);

  /* First, check if it is necessary to write out the current block.  */
  if ((*cblock)->state)
    {
      if (flush || addr < b->page_rva || b->page_rva + 0x1000 <= addr)
        {
          grub_uint32_t size;

          if (flush)
            {
              /* Add as much padding as necessary to align the address
                 with a section boundary.  */
              Elf_Addr next_address;
              unsigned padding_size;
              size_t cur_index;

              next_address = current_address + b->block_size;
              padding_size = ((ALIGN_UP (next_address, image_target->section_align)
                               - next_address)
                              >> 1);
              cur_index = ((b->block_size - sizeof (*b)) >> 1);
              grub_util_info ("adding %d padding fixup entries", padding_size);
              while (padding_size--)
                {
                  b->entries[cur_index++] = 0;
                  b->block_size += 2;
                }
            }
          else while (b->block_size & (8 - 1))
            {
              /* If not aligned with a 32-bit boundary, add
                 a padding entry.  */
              size_t cur_index;

              grub_util_info ("adding a padding fixup entry");
              cur_index = ((b->block_size - sizeof (*b)) >> 1);
              b->entries[cur_index] = 0;
              b->block_size += 2;
            }

          /* Flush it.  */
          grub_util_info ("writing %d bytes of a fixup block starting at 0x%x",
                          b->block_size, b->page_rva);
          size = b->block_size;
          current_address += size;
          b->page_rva = grub_host_to_target32 (b->page_rva);
          b->block_size = grub_host_to_target32 (b->block_size);
          (*cblock)->next = xmalloc (sizeof (**cblock) + 2 * 0x1000);
          memset ((*cblock)->next, 0, sizeof (**cblock) + 2 * 0x1000);
          *cblock = (*cblock)->next;
        }
    }

  b = &((*cblock)->b);

  if (! flush)
    {
      grub_uint16_t entry;
      size_t cur_index;

      /* If not allocated yet, allocate a block with enough entries.  */
      if (! (*cblock)->state)
        {
          (*cblock)->state = 1;

          /* The spec does not mention the requirement of a Page RVA.
             Here, align the address with a 4K boundary for safety.  */
          b->page_rva = (addr & ~(0x1000 - 1));
          b->block_size = sizeof (*b);
        }

      /* Sanity check.  */
      if (b->block_size >= sizeof (*b) + 2 * 0x1000)
        grub_util_error ("too many fixup entries");

      /* Add a new entry.  */
      cur_index = ((b->block_size - sizeof (*b)) >> 1);
      entry = GRUB_PE32_FIXUP_ENTRY (type, addr - b->page_rva);
      b->entries[cur_index] = grub_host_to_target16 (entry);
      b->block_size += 2;
    }

  return current_address;
}

struct raw_reloc
{
  struct raw_reloc *next;
  grub_uint32_t offset;
  enum raw_reloc_type {
    RAW_RELOC_NONE = -1,
    RAW_RELOC_32 = 0,
    RAW_RELOC_MAX = 1,
  } type;
};

struct translate_context
{
  /* PE */
  struct fixup_block_list *lst, *lst0;
  Elf_Addr current_address;

  /* Raw */
  struct raw_reloc *raw_relocs;
};

static void
translate_reloc_start (struct translate_context *ctx,
                       const struct grub_install_image_target_desc *image_target)
{
  grub_memset (ctx, 0, sizeof (*ctx));
  if (image_target->id == IMAGE_EFI)
    {
      ctx->lst = ctx->lst0 = xmalloc (sizeof (*ctx->lst) + 2 * 0x1000);
      memset (ctx->lst, 0, sizeof (*ctx->lst) + 2 * 0x1000);
      ctx->current_address = 0;
    }
}

static void
translate_relocation_pe (struct translate_context *ctx,
                         Elf_Addr addr,
                         Elf_Addr info,
                         const struct grub_install_image_target_desc *image_target)
{
  /* Necessary to relocate only absolute addresses.  */
  switch (image_target->elf_target)
    {
    case EM_386:
      if (ELF_R_TYPE (info) == R_386_32)
        {
          grub_util_info ("adding a relocation entry for 0x%"
                          GRUB_HOST_PRIxLONG_LONG,
                          (unsigned long long) addr);
          ctx->current_address
            = add_fixup_entry (&ctx->lst,
                               GRUB_PE32_REL_BASED_HIGHLOW,
                               addr, 0, ctx->current_address,
                               image_target);
        }
      break;
    case EM_X86_64:
      if ((ELF_R_TYPE (info) == R_X86_64_32) ||
          (ELF_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)
        {
          grub_util_info ("adding a relocation entry for 0x%"
                          GRUB_HOST_PRIxLONG_LONG,
                          (unsigned long long) addr);
          ctx->current_address
            = add_fixup_entry (&ctx->lst,
                               GRUB_PE32_REL_BASED_DIR64,
                               addr,
                               0, ctx->current_address,
                               image_target);
        }
      break;
    case EM_IA_64:
      switch (ELF_R_TYPE (info))
        {
        case R_IA64_PCREL64LSB:
        case R_IA64_LDXMOV:
        case R_IA64_PCREL21B:
        case R_IA64_LTOFF_FPTR22:
        case R_IA64_LTOFF22X:
        case R_IA64_LTOFF22:
        case R_IA64_GPREL22:
        case R_IA64_GPREL64I:
        case R_IA64_SEGREL64LSB:
          break;

        case R_IA64_FPTR64LSB:
        case R_IA64_DIR64LSB:
#if 1
          {
            grub_util_info ("adding a relocation entry for 0x%"
                            GRUB_HOST_PRIxLONG_LONG,
                            (unsigned long long) addr);
            ctx->current_address
              = add_fixup_entry (&ctx->lst,
                                 GRUB_PE32_REL_BASED_DIR64,
                                 addr,
                                 0, ctx->current_address,
                                 image_target);
          }
#endif
          break;
        default:
          grub_util_error (_("relocation 0x%x is not implemented yet"),
                           (unsigned int) ELF_R_TYPE (info));
          break;
        }
      break;
    case EM_AARCH64:
      switch (ELF_R_TYPE (info))
        {
        case R_AARCH64_ABS64:
          {
            ctx->current_address
              = add_fixup_entry (&ctx->lst,
                                 GRUB_PE32_REL_BASED_DIR64,
                                 addr, 0, ctx->current_address,
                                 image_target);
          }
          break;
          /* Relative relocations do not require fixup entries. */
        case R_AARCH64_CALL26:
        case R_AARCH64_JUMP26:
        case R_AARCH64_PREL32:
          break;
          /* Page-relative relocations do not require fixup entries. */
        case R_AARCH64_ADR_PREL_PG_HI21:
          /* We page-align the whole kernel, so no need
             for fixup entries.
          */
        case R_AARCH64_ADD_ABS_LO12_NC:
        case R_AARCH64_LDST64_ABS_LO12_NC:
          break;

          /* GOT is relocated separately.  */
        case R_AARCH64_ADR_GOT_PAGE:
        case R_AARCH64_LD64_GOT_LO12_NC:
          break;

        default:
          grub_util_error (_("relocation 0x%x is not implemented yet"),
                           (unsigned int) ELF_R_TYPE (info));
          break;
        }
      break;
      break;
#if defined(MKIMAGE_ELF32)
    case EM_ARM:
      switch (ELF_R_TYPE (info))
        {
        case R_ARM_V4BX:
          /* Relative relocations do not require fixup entries. */
        case R_ARM_JUMP24:
        case R_ARM_THM_CALL:
        case R_ARM_THM_JUMP19:
        case R_ARM_THM_JUMP24:
        case R_ARM_CALL:
          {
            grub_util_info ("  %s:  not adding fixup: 0x%08x : 0x%08x", __FUNCTION__, (unsigned int) addr, (unsigned int) ctx->current_address);
          }
          break;
          /* Create fixup entry for PE/COFF loader */
        case R_ARM_ABS32:
          {
            ctx->current_address
              = add_fixup_entry (&ctx->lst,
                                 GRUB_PE32_REL_BASED_HIGHLOW,
                                 addr, 0, ctx->current_address,
                                 image_target);
          }
          break;
        default:
          grub_util_error (_("relocation 0x%x is not implemented yet"),
                           (unsigned int) ELF_R_TYPE (info));
          break;
        }
      break;
#endif /* defined(MKIMAGE_ELF32) */
    case EM_RISCV:
      switch (ELF_R_TYPE (info))
        {
        case R_RISCV_32:
          {
            ctx->current_address
              = add_fixup_entry (&ctx->lst,
                                 GRUB_PE32_REL_BASED_HIGHLOW,
                                 addr, 0, ctx->current_address,
                                 image_target);
          }
          break;
        case R_RISCV_64:
          {
            ctx->current_address
              = add_fixup_entry (&ctx->lst,
                                 GRUB_PE32_REL_BASED_DIR64,
                                 addr, 0, ctx->current_address,
                                 image_target);
          }
          break;
          /* Relative relocations do not require fixup entries. */
        case R_RISCV_BRANCH:
        case R_RISCV_JAL:
        case R_RISCV_CALL:
        case R_RISCV_PCREL_HI20:
        case R_RISCV_PCREL_LO12_I:
        case R_RISCV_PCREL_LO12_S:
        case R_RISCV_RVC_BRANCH:
        case R_RISCV_RVC_JUMP:
        case R_RISCV_ADD32:
        case R_RISCV_SUB32:
          grub_util_info ("  %s:  not adding fixup: 0x%08x : 0x%08x", __FUNCTION__, (unsigned int) addr, (unsigned int) ctx->current_address);
          break;
        case R_RISCV_HI20:
          {
            ctx->current_address
              = add_fixup_entry (&ctx->lst,
                                 GRUB_PE32_REL_BASED_RISCV_HI20,
                                 addr, 0, ctx->current_address,
                                 image_target);
          }
          break;
        case R_RISCV_LO12_I:
          {
            ctx->current_address
              = add_fixup_entry (&ctx->lst,
                                 GRUB_PE32_REL_BASED_RISCV_LOW12I,
                                 addr, 0, ctx->current_address,
                                 image_target);
          }
          break;
        case R_RISCV_LO12_S:
          {
            ctx->current_address
              = add_fixup_entry (&ctx->lst,
                                 GRUB_PE32_REL_BASED_RISCV_LOW12S,
                                 addr, 0, ctx->current_address,
                                 image_target);
          }
          break;
        case R_RISCV_RELAX:
          break;
        default:
          grub_util_error (_("relocation 0x%x is not implemented yet"),
                           (unsigned int) ELF_R_TYPE (info));
          break;
        }
      break;
    default:
      grub_util_error ("unknown machine type 0x%x", image_target->elf_target);
    }
}

static enum raw_reloc_type
classify_raw_reloc (Elf_Addr info,
                    const struct grub_install_image_target_desc *image_target)
{
    /* Necessary to relocate only absolute addresses.  */
  switch (image_target->elf_target)
    {
    case EM_ARM:
      switch (ELF_R_TYPE (info))
        {
        case R_ARM_V4BX:
        case R_ARM_JUMP24:
        case R_ARM_THM_CALL:
        case R_ARM_THM_JUMP19:
        case R_ARM_THM_JUMP24:
        case R_ARM_CALL:
          return RAW_RELOC_NONE;
        case R_ARM_ABS32:
          return RAW_RELOC_32;
        default:
          grub_util_error (_("relocation 0x%x is not implemented yet"),
                           (unsigned int) ELF_R_TYPE (info));
          break;
        }
      break;
    default:
      grub_util_error ("unknown machine type 0x%x", image_target->elf_target);
    }
}

static void
translate_relocation_raw (struct translate_context *ctx,
                          Elf_Addr addr,
                          Elf_Addr info,
                          const struct grub_install_image_target_desc *image_target)
{
  enum raw_reloc_type class = classify_raw_reloc (info, image_target);
  struct raw_reloc *rel;
  if (class == RAW_RELOC_NONE)
    return;
  rel = xmalloc (sizeof (*rel));
  rel->next = ctx->raw_relocs;
  rel->type = class;
  rel->offset = addr;
  ctx->raw_relocs = rel;
}

static void
translate_relocation (struct translate_context *ctx,
                      Elf_Addr addr,
                      Elf_Addr info,
                      const struct grub_install_image_target_desc *image_target)
{
  if (image_target->id == IMAGE_EFI)
    translate_relocation_pe (ctx, addr, info, image_target);
  else
    translate_relocation_raw (ctx, addr, info, image_target);
}

static void
finish_reloc_translation_pe (struct translate_context *ctx, struct grub_mkimage_layout *layout,
                             const struct grub_install_image_target_desc *image_target)
{
  ctx->current_address = add_fixup_entry (&ctx->lst, 0, 0, 1, ctx->current_address, image_target);

  {
    grub_uint8_t *ptr;
    layout->reloc_section = ptr = xmalloc (ctx->current_address);
    for (ctx->lst = ctx->lst0; ctx->lst; ctx->lst = ctx->lst->next)
      if (ctx->lst->state)
        {
          memcpy (ptr, &ctx->lst->b, grub_target_to_host32 (ctx->lst->b.block_size));
          ptr += grub_target_to_host32 (ctx->lst->b.block_size);
        }
    assert ((ctx->current_address + (grub_uint8_t *) layout->reloc_section) == ptr);
  }

  for (ctx->lst = ctx->lst0; ctx->lst; )
    {
      struct fixup_block_list *next;
      next = ctx->lst->next;
      free (ctx->lst);
      ctx->lst = next;
    }

  layout->reloc_size = ctx->current_address;
  if (image_target->elf_target == EM_ARM && layout->reloc_size > GRUB_KERNEL_ARM_STACK_SIZE)
    grub_util_error ("Reloc section (%d) is bigger than stack size (%d). "
                     "This breaks assembly assumptions. Please increase stack size",
                     (int) layout->reloc_size,
                     (int) GRUB_KERNEL_ARM_STACK_SIZE);
}

/*
  Layout:
  <type 0 relocations>
  <fffffffe>
  <type 1 relocations>
  <fffffffe>
  ...
  <type n relocations>
  <ffffffff>
  each relocation starts with 32-bit offset. Rest depends on relocation.
  mkimage stops when it sees first unknown type or end marker.
  This allows images to be created with mismatched mkimage and
  kernel as long as no relocations are present in kernel that mkimage
  isn't aware of (in which case mkimage aborts).
  This also allows simple assembly to do the relocs.
*/

#define RAW_SEPARATOR 0xfffffffe
#define RAW_END_MARKER 0xffffffff

static void
finish_reloc_translation_raw (struct translate_context *ctx, struct grub_mkimage_layout *layout,
                              const struct grub_install_image_target_desc *image_target)
{
  size_t count = 0, sz;
  enum raw_reloc_type highest = RAW_RELOC_NONE;
  enum raw_reloc_type curtype;
  struct raw_reloc *cur;
  grub_uint32_t *p;
  if (!ctx->raw_relocs)
    {
      layout->reloc_section = p = xmalloc (sizeof (grub_uint32_t));
      p[0] = RAW_END_MARKER;
      layout->reloc_size = sizeof (grub_uint32_t);
      return;
    }
  for (cur = ctx->raw_relocs; cur; cur = cur->next)
    {
      count++;
      if (cur->type > highest)
        highest = cur->type;
    }
  /* highest separators, count relocations and one end marker.  */
  sz = (highest + count + 1) * sizeof (grub_uint32_t);
  layout->reloc_section = p = xmalloc (sz);
  for (curtype = 0; curtype <= highest; curtype++)
    {
      /* Support for special cases would go here.  */
      for (cur = ctx->raw_relocs; cur; cur = cur->next)
        if (cur->type == curtype)
          {
            *p++ = cur->offset;
          }
      *p++ = RAW_SEPARATOR;
    }
  *--p = RAW_END_MARKER;
  layout->reloc_size = sz;
}

static void
finish_reloc_translation (struct translate_context *ctx, struct grub_mkimage_layout *layout,
                          const struct grub_install_image_target_desc *image_target)
{
  if (image_target->id == IMAGE_EFI)
    finish_reloc_translation_pe (ctx, layout, image_target);
  else
    finish_reloc_translation_raw (ctx, layout, image_target);
}


static void
create_u64_fixups (struct translate_context *ctx,
                   Elf_Addr jumpers, grub_size_t njumpers,
                   const struct grub_install_image_target_desc *image_target)
{
  unsigned i;
  assert (image_target->id == IMAGE_EFI);
  for (i = 0; i < njumpers; i++)
    ctx->current_address = add_fixup_entry (&ctx->lst,
                                            GRUB_PE32_REL_BASED_DIR64,
                                            jumpers + 8 * i,
                                            0, ctx->current_address,
                                            image_target);
}

/* Make a .reloc section.  */
static void
make_reloc_section (Elf_Ehdr *e, struct grub_mkimage_layout *layout,
                    struct section_metadata *smd,
                    const struct grub_install_image_target_desc *image_target)
{
  unsigned i;
  Elf_Shdr *s;
  struct translate_context ctx;

  translate_reloc_start (&ctx, image_target);

  for (i = 0, s = smd->sections; i < smd->num_sections;
       i++, s = (Elf_Shdr *) ((char *) s + smd->section_entsize))
    if ((grub_target_to_host32 (s->sh_type) == SHT_REL) ||
        (grub_target_to_host32 (s->sh_type) == SHT_RELA))
      {
        Elf_Rel *r;
        Elf_Word rtab_size, r_size, num_rs;
        Elf_Off rtab_offset;
        Elf_Addr section_address;
        Elf_Word j;

        if (!SUFFIX (is_kept_reloc_section) (s, image_target, smd))
          {
            grub_util_info ("not translating the skipped relocation section %s",
                            smd->strtab + grub_le_to_cpu32 (s->sh_name));
            continue;
          }

        grub_util_info ("translating the relocation section %s",
                        smd->strtab + grub_le_to_cpu32 (s->sh_name));

        rtab_size = grub_target_to_host (s->sh_size);
        r_size = grub_target_to_host (s->sh_entsize);
        rtab_offset = grub_target_to_host (s->sh_offset);
        num_rs = rtab_size / r_size;

        section_address = smd->vaddrs[grub_le_to_cpu32 (s->sh_info)];

        for (j = 0, r = (Elf_Rel *) ((char *) e + rtab_offset);
             j < num_rs;
             j++, r = (Elf_Rel *) ((char *) r + r_size))
          {
            Elf_Addr info;
            Elf_Addr offset;
            Elf_Addr addr;

            offset = grub_target_to_host (r->r_offset);
            info = grub_target_to_host (r->r_info);

            addr = section_address + offset;

            translate_relocation (&ctx, addr, info, image_target);
          }
      }

  if (image_target->elf_target == EM_IA_64)
    create_u64_fixups (&ctx,
                       layout->ia64jmp_off
                       + image_target->vaddr_offset,
                       2 * layout->ia64jmpnum,
                       image_target);
  if (image_target->elf_target == EM_IA_64 || image_target->elf_target == EM_AARCH64)
    create_u64_fixups (&ctx,
                       layout->got_off
                       + image_target->vaddr_offset,
                       (layout->got_size / 8),
                       image_target);

  finish_reloc_translation (&ctx, layout, image_target);
}

/* Determine if this section is a text section. Return false if this
   section is not allocated.  */
static int
SUFFIX (is_text_section) (Elf_Shdr *s, const struct grub_install_image_target_desc *image_target)
{
  if (!is_relocatable (image_target)
      && grub_target_to_host32 (s->sh_type) != SHT_PROGBITS)
    return 0;
  return ((grub_target_to_host (s->sh_flags) & (SHF_EXECINSTR | SHF_ALLOC))
          == (SHF_EXECINSTR | SHF_ALLOC));
}

/* Determine if this section is a data section.  */
static int
SUFFIX (is_data_section) (Elf_Shdr *s, const struct grub_install_image_target_desc *image_target)
{
  if (!is_relocatable (image_target) 
      && grub_target_to_host32 (s->sh_type) != SHT_PROGBITS)
    return 0;
  return ((grub_target_to_host (s->sh_flags) & (SHF_EXECINSTR | SHF_ALLOC))
          == SHF_ALLOC) && !(grub_target_to_host32 (s->sh_type) == SHT_NOBITS);
}

static int
SUFFIX (is_bss_section) (Elf_Shdr *s, const struct grub_install_image_target_desc *image_target)
{
  if (!is_relocatable (image_target))
    return 0;
  return ((grub_target_to_host (s->sh_flags) & (SHF_EXECINSTR | SHF_ALLOC))
          == SHF_ALLOC) && (grub_target_to_host32 (s->sh_type) == SHT_NOBITS);
}

/* Determine if a section is going to be in the final output */
static int
SUFFIX (is_kept_section) (Elf_Shdr *s, const struct grub_install_image_target_desc *image_target)
{
  /* We keep .text and .data */
  if (SUFFIX (is_text_section) (s, image_target)
      || SUFFIX (is_data_section) (s, image_target))
    return 1;

  /*
   * And we keep .bss if we're producing PE binaries or the target doesn't
   * have a relocating loader.  Platforms other than EFI and U-boot shouldn't
   * have .bss in their binaries as we build with -Wl,-Ttext.
   */
  if (SUFFIX (is_bss_section) (s, image_target)
      && (image_target->id == IMAGE_EFI || !is_relocatable (image_target)))
    return 1;

  /* Otherwise this is not a section we're keeping in the final output. */
  return 0;
}

static int
SUFFIX (is_kept_reloc_section) (Elf_Shdr *s, const struct grub_install_image_target_desc *image_target,
                                struct section_metadata *smd)
{
  int i;
  int r = 0;
  const char *name = smd->strtab + grub_host_to_target32 (s->sh_name);

  if (!strncmp (name, ".rela.", 6))
    name += 5;
  else if (!strncmp (name, ".rel.", 5))
    name += 4;
  else
    return 1;

  for (i = 0, s = smd->sections; i < smd->num_sections;
       i++, s = (Elf_Shdr *) ((char *) s + smd->section_entsize))
    {
      const char *sname = smd->strtab + grub_host_to_target32 (s->sh_name);
      if (strcmp (sname, name))
        continue;

      return SUFFIX (is_kept_section) (s, image_target);
    }

  return r;
}

/* Return if the ELF header is valid.  */
static int
SUFFIX (check_elf_header) (Elf_Ehdr *e, size_t size, const struct grub_install_image_target_desc *image_target)
{
  if (size < sizeof (*e)
      || e->e_ident[EI_MAG0] != ELFMAG0
      || e->e_ident[EI_MAG1] != ELFMAG1
      || e->e_ident[EI_MAG2] != ELFMAG2
      || e->e_ident[EI_MAG3] != ELFMAG3
      || e->e_ident[EI_VERSION] != EV_CURRENT
      || e->e_ident[EI_CLASS] != ELFCLASSXX
      || e->e_version != grub_host_to_target32 (EV_CURRENT))
    return 0;

  return 1;
}

static Elf_Addr
SUFFIX (put_section) (Elf_Shdr *s, int i,
                      Elf_Addr current_address,
                      struct section_metadata *smd,
                      const struct grub_install_image_target_desc *image_target)
{
        Elf_Word align = grub_host_to_target_addr (s->sh_addralign);
        const char *name = smd->strtab + grub_host_to_target32 (s->sh_name);

        if (align)
          current_address = ALIGN_UP (current_address + image_target->vaddr_offset,
                                      align)
            - image_target->vaddr_offset;

        grub_util_info ("locating the section %s at 0x%"
                        GRUB_HOST_PRIxLONG_LONG,
                        name, (unsigned long long) current_address);
        if (!is_relocatable (image_target))
          current_address = grub_host_to_target_addr (s->sh_addr)
                            - image_target->link_addr;
        smd->addrs[i] = current_address;
        current_address += grub_host_to_target_addr (s->sh_size);
        return current_address;
}

/*
 * Locate section addresses by merging code sections and data sections
 * into .text and .data, respectively.
 */
static void
SUFFIX (locate_sections) (Elf_Ehdr *e, const char *kernel_path,
                          struct section_metadata *smd,
                          struct grub_mkimage_layout *layout,
                          const struct grub_install_image_target_desc *image_target)
{
  int i;
  Elf_Shdr *s;

  layout->align = 1;
  /* Page-aligning simplifies relocation handling.  */
  if (image_target->elf_target == EM_AARCH64)
    layout->align = 4096;

  layout->kernel_size = 0;

  for (i = 0, s = smd->sections;
       i < smd->num_sections;
       i++, s = (Elf_Shdr *) ((char *) s + smd->section_entsize))
    if ((grub_target_to_host (s->sh_flags) & SHF_ALLOC)
        && grub_host_to_target32 (s->sh_addralign) > layout->align)
      layout->align = grub_host_to_target32 (s->sh_addralign);

  /* .text */
  for (i = 0, s = smd->sections;
       i < smd->num_sections;
       i++, s = (Elf_Shdr *) ((char *) s + smd->section_entsize))
    if (SUFFIX (is_text_section) (s, image_target))
      {
        layout->kernel_size = SUFFIX (put_section) (s, i, layout->kernel_size,
                                                smd, image_target);
        if (!is_relocatable (image_target) &&
            grub_host_to_target_addr (s->sh_addr) != image_target->link_addr)
          {
            char *msg
              = grub_xasprintf (_("`%s' is miscompiled: its start address is 0x%llx"
                                  " instead of 0x%llx: ld.gold bug?"),
                                kernel_path,
                                (unsigned long long) grub_host_to_target_addr (s->sh_addr),
                                (unsigned long long) image_target->link_addr);
            grub_util_error ("%s", msg);
          }
      }

  layout->kernel_size = ALIGN_UP (layout->kernel_size + image_target->vaddr_offset,
                              image_target->section_align)
    - image_target->vaddr_offset;
  layout->exec_size = layout->kernel_size;

  /* .data */
  for (i = 0, s = smd->sections;
       i < smd->num_sections;
       i++, s = (Elf_Shdr *) ((char *) s + smd->section_entsize))
    if (SUFFIX (is_data_section) (s, image_target))
      layout->kernel_size = SUFFIX (put_section) (s, i, layout->kernel_size, smd,
                                                  image_target);

#ifdef MKIMAGE_ELF32
  if (image_target->elf_target == EM_ARM)
    {
      grub_size_t tramp;
      layout->kernel_size = ALIGN_UP (layout->kernel_size + image_target->vaddr_offset,
                                      image_target->section_align) - image_target->vaddr_offset;

      layout->kernel_size = ALIGN_UP (layout->kernel_size, 16);

      tramp = arm_get_trampoline_size (e, smd->sections, smd->section_entsize,
                                       smd->num_sections, image_target);

      layout->tramp_off = layout->kernel_size;
      layout->kernel_size += ALIGN_UP (tramp, 16);
    }
#endif

  layout->bss_start = layout->kernel_size;
  layout->end = layout->kernel_size;
  
  /* .bss */
  for (i = 0, s = smd->sections;
       i < smd->num_sections;
       i++, s = (Elf_Shdr *) ((char *) s + smd->section_entsize))
    {
      if (SUFFIX (is_bss_section) (s, image_target))
        layout->end = SUFFIX (put_section) (s, i, layout->end, smd, image_target);

      /*
       * This must to be in the last time this function passes through the loop.
       */
      smd->vaddrs[i] = smd->addrs[i] + image_target->vaddr_offset;
    }

  layout->end = ALIGN_UP (layout->end + image_target->vaddr_offset,
                              image_target->section_align) - image_target->vaddr_offset;
  /* Explicitly initialize BSS
     when producing PE32 to avoid a bug in EFI implementations.
     Platforms other than EFI and U-boot shouldn't have .bss in
     their binaries as we build with -Wl,-Ttext.
  */
  if (image_target->id == IMAGE_EFI || !is_relocatable (image_target))
    layout->kernel_size = layout->end;
}

char *
SUFFIX (grub_mkimage_load_image) (const char *kernel_path,
                                  size_t total_module_size,
                                  struct grub_mkimage_layout *layout,
                                  const struct grub_install_image_target_desc *image_target)
{
  char *kernel_img, *out_img;
  struct section_metadata smd = { 0, 0, 0, 0, 0, 0, 0 };
  Elf_Ehdr *e;
  int i;
  Elf_Shdr *s;
  Elf_Off section_offset;
  grub_size_t kernel_size;

  grub_memset (layout, 0, sizeof (*layout));

  layout->start_address = 0;

  kernel_size = grub_util_get_image_size (kernel_path);
  kernel_img = xmalloc (kernel_size);
  grub_util_load_image (kernel_path, kernel_img);

  e = (Elf_Ehdr *) kernel_img;
  if (! SUFFIX (check_elf_header) (e, kernel_size, image_target))
    grub_util_error ("invalid ELF header");

  section_offset = grub_target_to_host (e->e_shoff);
  smd.section_entsize = grub_target_to_host16 (e->e_shentsize);
  smd.num_sections = grub_target_to_host16 (e->e_shnum);

  if (kernel_size < section_offset
                    + (grub_uint32_t) smd.section_entsize * smd.num_sections)
    grub_util_error (_("premature end of file %s"), kernel_path);

  smd.sections = (Elf_Shdr *) (kernel_img + section_offset);

  /* Relocate sections then symbols in the virtual address space.  */
  s = (Elf_Shdr *) ((char *) smd.sections
                      + grub_host_to_target16 (e->e_shstrndx) * smd.section_entsize);
  smd.strtab = (char *) e + grub_host_to_target_addr (s->sh_offset);

  smd.addrs = xmalloc (sizeof (*smd.addrs) * smd.num_sections);
  memset (smd.addrs, 0, sizeof (*smd.addrs) * smd.num_sections);
  smd.vaddrs = xmalloc (sizeof (*smd.vaddrs) * smd.num_sections);
  memset (smd.vaddrs, 0, sizeof (*smd.vaddrs) * smd.num_sections);

  SUFFIX (locate_sections) (e, kernel_path, &smd, layout, image_target);

  if (!is_relocatable (image_target))
    {
      Elf_Addr current_address = layout->kernel_size;

      for (i = 0, s = smd.sections;
           i < smd.num_sections;
           i++, s = (Elf_Shdr *) ((char *) s + smd.section_entsize))
        if (grub_target_to_host32 (s->sh_type) == SHT_NOBITS)
          {
            Elf_Word sec_align = grub_host_to_target_addr (s->sh_addralign);
            const char *name = smd.strtab + grub_host_to_target32 (s->sh_name);

            if (sec_align)
              current_address = ALIGN_UP (current_address
                                          + image_target->vaddr_offset,
                                          sec_align)
                - image_target->vaddr_offset;

            grub_util_info ("locating the section %s at 0x%"
                            GRUB_HOST_PRIxLONG_LONG,
                            name, (unsigned long long) current_address);
            if (!is_relocatable (image_target))
              current_address = grub_host_to_target_addr (s->sh_addr)
                - image_target->link_addr;

            smd.vaddrs[i] = current_address
              + image_target->vaddr_offset;
            current_address += grub_host_to_target_addr (s->sh_size);
          }
      current_address = ALIGN_UP (current_address + image_target->vaddr_offset,
                                  image_target->section_align)
        - image_target->vaddr_offset;
      layout->bss_size = current_address - layout->kernel_size;
    }
  else
    layout->bss_size = 0;

  if (image_target->id == IMAGE_SPARC64_AOUT
      || image_target->id == IMAGE_SPARC64_RAW
      || image_target->id == IMAGE_UBOOT
      || image_target->id == IMAGE_COREBOOT
      || image_target->id == IMAGE_SPARC64_CDCORE)
    layout->kernel_size = ALIGN_UP (layout->kernel_size, image_target->mod_align);

  if (is_relocatable (image_target))
    {
      smd.symtab = NULL;
      for (i = 0, s = smd.sections;
           i < smd.num_sections;
           i++, s = (Elf_Shdr *) ((char *) s + smd.section_entsize))
        if (s->sh_type == grub_host_to_target32 (SHT_SYMTAB))
          {
            smd.symtab = s;
            break;
          }
      if (! smd.symtab)
        grub_util_error ("%s", _("no symbol table"));
#ifdef MKIMAGE_ELF64
      if (image_target->elf_target == EM_IA_64)
        {
          grub_size_t tramp;

          layout->kernel_size = ALIGN_UP (layout->kernel_size, 16);

          grub_ia64_dl_get_tramp_got_size (e, &tramp, &layout->got_size);

          layout->tramp_off = layout->kernel_size;
          layout->kernel_size += ALIGN_UP (tramp, 16);

          layout->ia64jmp_off = layout->kernel_size;
          layout->ia64jmpnum = SUFFIX (count_funcs) (e, smd.symtab,
                                                     image_target);
          layout->kernel_size += 16 * layout->ia64jmpnum;

          layout->got_off = layout->kernel_size;
          layout->kernel_size += ALIGN_UP (layout->got_size, 16);
        }
      if (image_target->elf_target == EM_AARCH64)
        {
          grub_size_t tramp;

          layout->kernel_size = ALIGN_UP (layout->kernel_size, 16);

          grub_arm64_dl_get_tramp_got_size (e, &tramp, &layout->got_size);

          layout->got_off = layout->kernel_size;
          layout->kernel_size += ALIGN_UP (layout->got_size, 16);
        }
#endif
    }
  else
    {
      layout->reloc_size = 0;
      layout->reloc_section = NULL;
    }

  out_img = xmalloc (layout->kernel_size + total_module_size);
  memset (out_img, 0, layout->kernel_size + total_module_size);

  if (is_relocatable (image_target))
    {
      layout->start_address = SUFFIX (relocate_symbols) (e, &smd,
                                  (char *) out_img + layout->ia64jmp_off,
                                  layout->ia64jmp_off + image_target->vaddr_offset,
                                  layout->bss_start, layout->end, image_target);

      if (layout->start_address == (Elf_Addr) -1)
        grub_util_error ("start symbol is not defined");

      /* Resolve addrs in the virtual address space.  */
      SUFFIX (relocate_addrs) (e, &smd, out_img, layout->tramp_off,
                                   layout->got_off, image_target);

      make_reloc_section (e, layout, &smd, image_target);
      if (image_target->id != IMAGE_EFI)
        {
          out_img = xrealloc (out_img, layout->kernel_size + total_module_size
                              + ALIGN_UP (layout->reloc_size, image_target->mod_align));
          memcpy (out_img + layout->kernel_size, layout->reloc_section, layout->reloc_size);
          memset (out_img + layout->kernel_size + layout->reloc_size, 0,
                  total_module_size + ALIGN_UP (layout->reloc_size, image_target->mod_align) - layout->reloc_size);
          layout->kernel_size += ALIGN_UP (layout->reloc_size, image_target->mod_align);
        }
    }

  for (i = 0, s = smd.sections;
       i < smd.num_sections;
       i++, s = (Elf_Shdr *) ((char *) s + smd.section_entsize))
    if (SUFFIX (is_kept_section) (s, image_target))
      {
        if (grub_target_to_host32 (s->sh_type) == SHT_NOBITS)
          memset (out_img + smd.addrs[i], 0,
                  grub_host_to_target_addr (s->sh_size));
        else
          memcpy (out_img + smd.addrs[i],
                  kernel_img + grub_host_to_target_addr (s->sh_offset),
                  grub_host_to_target_addr (s->sh_size));
      }
  free (kernel_img);

  free (smd.vaddrs);
  smd.vaddrs = NULL;
  free (smd.addrs);
  smd.addrs = NULL;

  return out_img;
}