From 6b0582fa0af9c5b2c3537198b3b142222137978c Mon Sep 17 00:00:00 2001

From: Vladimir 'phcoder' Serbinenko <phcoder@gmail.com>

Date: Sat, 2 Mar 2013 16:45:57 +0100

Subject: [PATCH 185/482] 	Make elfload not use hooks. Opt for flags and

 iterators instead.

---

 ChangeLog                                    |   4 +

 grub-core/kern/elf.c                         | 455 +++------------------------

 grub-core/kern/elfXX.c                       | 144 +++++++++

 grub-core/loader/i386/bsd.c                  | 137 +++-----

 grub-core/loader/i386/coreboot/chainloader.c |  69 ++--

 grub-core/loader/mips/linux.c                |  37 +--

 grub-core/loader/powerpc/ieee1275/linux.c    |  34 +-

 grub-core/loader/sparc64/ieee1275/linux.c    |  18 +-

 include/grub/elfload.h                       |  35 ++-

 9 files changed, 301 insertions(+), 632 deletions(-)

 create mode 100644 grub-core/kern/elfXX.c

diff --git a/ChangeLog b/ChangeLog

index d55dd8f..7c80ed6 100644

--- a/ChangeLog

+++ b/ChangeLog

@@ -1,5 +1,9 @@

 2013-03-02  Vladimir Serbinenko  <phcoder@gmail.com>

+	Make elfload not use hooks. Opt for flags and iterators instead.

+

+2013-03-02  Vladimir Serbinenko  <phcoder@gmail.com>

+

 	* grub-core/lib/ia64/longjmp.S: Fix the name of longjmp function.

 	* grub-core/lib/ia64/setjmp.S: Fix the name of setjmp function.

diff --git a/grub-core/kern/elf.c b/grub-core/kern/elf.c

index f52ca21..5f99c43 100644

--- a/grub-core/kern/elf.c

+++ b/grub-core/kern/elf.c

@@ -51,6 +51,7 @@ grub_elf_close (grub_elf_t elf)

   grub_file_t file = elf->file;

   grub_free (elf->phdrs);

+  grub_free (elf->filename);

   grub_free (elf);

   if (file)

@@ -85,9 +86,14 @@ grub_elf_file (grub_file_t file, const char *filename)

   if (grub_elf_check_header (elf))

     goto fail;

+  elf->filename = grub_strdup (filename);

+  if (!elf->filename)

+    goto fail;

+

   return elf;

 fail:

+  grub_free (elf->filename);

   grub_free (elf->phdrs);

   grub_free (elf);

   return 0;

@@ -112,420 +118,41 @@ grub_elf_open (const char *name)

 /* 32-bit */

-

-int

-grub_elf_is_elf32 (grub_elf_t elf)

-{

-  return elf->ehdr.ehdr32.e_ident[EI_CLASS] == ELFCLASS32;

-}

-

-static grub_err_t

-grub_elf32_load_phdrs (grub_elf_t elf, const char *filename)

-{

-  grub_ssize_t phdrs_size;

-

-  phdrs_size = elf->ehdr.ehdr32.e_phnum * elf->ehdr.ehdr32.e_phentsize;

-

-  grub_dprintf ("elf", "Loading program headers at 0x%llx, size 0x%lx.\n",

-		(unsigned long long) elf->ehdr.ehdr32.e_phoff,

-		(unsigned long) phdrs_size);

-

-  elf->phdrs = grub_malloc (phdrs_size);

-  if (! elf->phdrs)

-    return grub_errno;

-

-  if ((grub_file_seek (elf->file, elf->ehdr.ehdr32.e_phoff) == (grub_off_t) -1)

-      || (grub_file_read (elf->file, elf->phdrs, phdrs_size) != phdrs_size))

-    {

-      if (!grub_errno)

-	grub_error (GRUB_ERR_FILE_READ_ERROR, N_("premature end of file %s"),

-		    filename);

-      return grub_errno;

-    }

-

-  return GRUB_ERR_NONE;

-}

-

-grub_err_t

-grub_elf32_phdr_iterate (grub_elf_t elf,

-			 const char *filename,

-			 grub_elf32_phdr_iterate_hook_t hook, void *hook_arg)

-{

-  Elf32_Phdr *phdrs;

-  unsigned int i;

-

-  if (! elf->phdrs)

-    if (grub_elf32_load_phdrs (elf, filename))

-      return grub_errno;

-  phdrs = elf->phdrs;

-

-  for (i = 0; i < elf->ehdr.ehdr32.e_phnum; i++)

-    {

-      Elf32_Phdr *phdr = phdrs + i;

-      grub_dprintf ("elf",

-		    "Segment %u: type 0x%x paddr 0x%lx memsz 0x%lx "

-		    "filesz %lx\n",

-		    i, phdr->p_type,

-		    (unsigned long) phdr->p_paddr,

-		    (unsigned long) phdr->p_memsz,

-		    (unsigned long) phdr->p_filesz);

-      if (hook (elf, phdr, hook_arg))

-	break;

-    }

-

-  return grub_errno;

-}

-

-struct grub_elf32_size_ctx

-{

-  Elf32_Addr segments_start, segments_end;

-  int nr_phdrs;

-  grub_uint32_t curr_align;

-};

-

-/* Run through the program headers to calculate the total memory size we

- * should claim.  */

-static int

-grub_elf32_calcsize (grub_elf_t _elf  __attribute__ ((unused)),

-		     Elf32_Phdr *phdr, void *data)

-{

-  struct grub_elf32_size_ctx *ctx = data;

-

-  /* Only consider loadable segments.  */

-  if (phdr->p_type != PT_LOAD)

-    return 0;

-  ctx->nr_phdrs++;

-  if (phdr->p_paddr < ctx->segments_start)

-    ctx->segments_start = phdr->p_paddr;

-  if (phdr->p_paddr + phdr->p_memsz > ctx->segments_end)

-    ctx->segments_end = phdr->p_paddr + phdr->p_memsz;

-  if (ctx->curr_align < phdr->p_align)

-    ctx->curr_align = phdr->p_align;

-  return 0;

-}

-

-/* Calculate the amount of memory spanned by the segments.  */

-grub_size_t

-grub_elf32_size (grub_elf_t elf, const char *filename,

-		 Elf32_Addr *base, grub_uint32_t *max_align)

-{

-  struct grub_elf32_size_ctx ctx = {

-    .segments_start = (Elf32_Addr) -1,

-    .segments_end = 0,

-    .nr_phdrs = 0,

-    .curr_align = 1

-  };

-

-  grub_elf32_phdr_iterate (elf, filename, grub_elf32_calcsize, &ctx;;

-

-  if (base)

-    *base = 0;

-

-  if (ctx.nr_phdrs == 0)

-    {

-      grub_error (GRUB_ERR_BAD_OS, "no program headers present");

-      return 0;

-    }

-

-  if (ctx.segments_end < ctx.segments_start)

-    {

-      /* Very bad addresses.  */

-      grub_error (GRUB_ERR_BAD_OS, "bad program header load addresses");

-      return 0;

-    }

-

-  if (base)

-    *base = ctx.segments_start;

-  if (max_align)

-    *max_align = ctx.curr_align;

-  return ctx.segments_end - ctx.segments_start;

-}

-

-struct grub_elf32_load_ctx

-{

-  const char *filename;

-  grub_elf32_load_hook_t load_hook;

-  grub_addr_t load_base;

-  grub_size_t load_size;

-};

-

-static int

-grub_elf32_load_segment (grub_elf_t elf, Elf32_Phdr *phdr, void *data)

-{

-  struct grub_elf32_load_ctx *ctx = data;

-  grub_addr_t load_addr;

-  int do_load = 1;

-

-  load_addr = phdr->p_paddr;

-  if (ctx->load_hook && ctx->load_hook (phdr, &load_addr, &do_load))

-    return 1;

-

-  if (! do_load)

-    return 0;

-

-  if (load_addr < ctx->load_base)

-    ctx->load_base = load_addr;

-

-  grub_dprintf ("elf", "Loading segment at 0x%llx, size 0x%llx\n",

-		(unsigned long long) load_addr,

-		(unsigned long long) phdr->p_memsz);

-

-  if (grub_file_seek (elf->file, phdr->p_offset) == (grub_off_t) -1)

-    return grub_errno;

-

-  if (phdr->p_filesz)

-    {

-      grub_ssize_t read;

-      read = grub_file_read (elf->file, (void *) load_addr, phdr->p_filesz);

-      if (read != (grub_ssize_t) phdr->p_filesz)

-	{

-	  /* XXX How can we free memory from `ctx->load_hook'? */

-	  if (!grub_errno)

-	    grub_error (GRUB_ERR_FILE_READ_ERROR, N_("premature end of file %s"),

-			ctx->filename);

-	  return grub_errno;

-	}

-    }

-

-  if (phdr->p_filesz < phdr->p_memsz)

-    grub_memset ((void *) (long) (load_addr + phdr->p_filesz),

-		 0, phdr->p_memsz - phdr->p_filesz);

-

-  ctx->load_size += phdr->p_memsz;

-

-  return 0;

-}

-

-/* Load every loadable segment into memory specified by `_load_hook'.  */

-grub_err_t

-grub_elf32_load (grub_elf_t elf, const char *filename,

-		 grub_elf32_load_hook_t load_hook,

-		 grub_addr_t *base, grub_size_t *size)

-{

-  struct grub_elf32_load_ctx ctx = {

-    .filename = filename,

-    .load_hook = load_hook,

-    .load_base = (grub_addr_t) -1ULL,

-    .load_size = 0

-  };

-  grub_err_t err;

-

-  err = grub_elf32_phdr_iterate (elf, filename, grub_elf32_load_segment, &ctx;;

-

-  if (base)

-    *base = ctx.load_base;

-  if (size)

-    *size = ctx.load_size;

-

-  return err;

-}

+#define ehdrXX ehdr32

+#define ELFCLASSXX ELFCLASS32

+#define ElfXX_Addr Elf32_Addr

+#define grub_elfXX_size grub_elf32_size

+#define grub_elfXX_load grub_elf32_load

+#define FOR_ELFXX_PHDRS FOR_ELF32_PHDRS

+#define grub_elf_is_elfXX grub_elf_is_elf32

+#define grub_elfXX_load_phdrs grub_elf32_load_phdrs

+#define ElfXX_Phdr Elf32_Phdr

+#define grub_uintXX_t grub_uint32_t

+

+#include "elfXX.c"

+

+#undef ehdrXX

+#undef ELFCLASSXX

+#undef ElfXX_Addr

+#undef grub_elfXX_size

+#undef grub_elfXX_load

+#undef FOR_ELFXX_PHDRS

+#undef grub_elf_is_elfXX

+#undef grub_elfXX_load_phdrs

+#undef ElfXX_Phdr

+#undef grub_uintXX_t

 /* 64-bit */

-

-int

-grub_elf_is_elf64 (grub_elf_t elf)

-{

-  return elf->ehdr.ehdr64.e_ident[EI_CLASS] == ELFCLASS64;

-}

-

-static grub_err_t

-grub_elf64_load_phdrs (grub_elf_t elf, const char *filename)

-{

-  grub_ssize_t phdrs_size;

-

-  phdrs_size = elf->ehdr.ehdr64.e_phnum * elf->ehdr.ehdr64.e_phentsize;

-

-  grub_dprintf ("elf", "Loading program headers at 0x%llx, size 0x%lx.\n",

-		(unsigned long long) elf->ehdr.ehdr64.e_phoff,

-		(unsigned long) phdrs_size);

-

-  elf->phdrs = grub_malloc (phdrs_size);

-  if (! elf->phdrs)

-    return grub_errno;

-

-  if ((grub_file_seek (elf->file, elf->ehdr.ehdr64.e_phoff) == (grub_off_t) -1)

-      || (grub_file_read (elf->file, elf->phdrs, phdrs_size) != phdrs_size))

-    {

-      if (!grub_errno)

-	grub_error (GRUB_ERR_FILE_READ_ERROR, N_("premature end of file %s"),

-		    filename);

-      return grub_errno;

-    }

-

-  return GRUB_ERR_NONE;

-}

-

-grub_err_t

-grub_elf64_phdr_iterate (grub_elf_t elf,

-			 const char *filename,

-			 grub_elf64_phdr_iterate_hook_t hook, void *hook_arg)

-{

-  Elf64_Phdr *phdrs;

-  unsigned int i;

-

-  if (! elf->phdrs)

-    if (grub_elf64_load_phdrs (elf, filename))

-      return grub_errno;

-  phdrs = elf->phdrs;

-

-  for (i = 0; i < elf->ehdr.ehdr64.e_phnum; i++)

-    {

-      Elf64_Phdr *phdr = phdrs + i;

-      grub_dprintf ("elf",

-		    "Segment %u: type 0x%x paddr 0x%lx memsz 0x%lx "

-		    "filesz %lx\n",

-		    i, phdr->p_type,

-		    (unsigned long) phdr->p_paddr,

-		    (unsigned long) phdr->p_memsz,

-		    (unsigned long) phdr->p_filesz);

-      if (hook (elf, phdr, hook_arg))

-	break;

-    }

-

-  return grub_errno;

-}

-

-struct grub_elf64_size_ctx

-{

-  Elf64_Addr segments_start, segments_end;

-  int nr_phdrs;

-  grub_uint64_t curr_align;

-};

-

-/* Run through the program headers to calculate the total memory size we

- * should claim.  */

-static int

-grub_elf64_calcsize (grub_elf_t _elf  __attribute__ ((unused)),

-		     Elf64_Phdr *phdr, void *data)

-{

-  struct grub_elf64_size_ctx *ctx = data;

-

-  /* Only consider loadable segments.  */

-  if (phdr->p_type != PT_LOAD)

-    return 0;

-  ctx->nr_phdrs++;

-  if (phdr->p_paddr < ctx->segments_start)

-    ctx->segments_start = phdr->p_paddr;

-  if (phdr->p_paddr + phdr->p_memsz > ctx->segments_end)

-    ctx->segments_end = phdr->p_paddr + phdr->p_memsz;

-  if (ctx->curr_align < phdr->p_align)

-    ctx->curr_align = phdr->p_align;

-  return 0;

-}

-

-/* Calculate the amount of memory spanned by the segments.  */

-grub_size_t

-grub_elf64_size (grub_elf_t elf, const char *filename,

-		 Elf64_Addr *base, grub_uint64_t *max_align)

-{

-  struct grub_elf64_size_ctx ctx = {

-    .segments_start = (Elf64_Addr) -1,

-    .segments_end = 0,

-    .nr_phdrs = 0,

-    .curr_align = 1

-  };

-

-  grub_elf64_phdr_iterate (elf, filename, grub_elf64_calcsize, &ctx;;

-

-  if (base)

-    *base = 0;

-

-  if (ctx.nr_phdrs == 0)

-    {

-      grub_error (GRUB_ERR_BAD_OS, "no program headers present");

-      return 0;

-    }

-

-  if (ctx.segments_end < ctx.segments_start)

-    {

-      /* Very bad addresses.  */

-      grub_error (GRUB_ERR_BAD_OS, "bad program header load addresses");

-      return 0;

-    }

-

-  if (base)

-    *base = ctx.segments_start;

-  if (max_align)

-    *max_align = ctx.curr_align;

-  return ctx.segments_end - ctx.segments_start;

-}

-

-struct grub_elf64_load_ctx

-{

-  const char *filename;

-  grub_elf64_load_hook_t load_hook;

-  grub_addr_t load_base;

-  grub_size_t load_size;

-};

-

-static int

-grub_elf64_load_segment (grub_elf_t elf, Elf64_Phdr *phdr, void *data)

-{

-  struct grub_elf64_load_ctx *ctx = data;

-  grub_addr_t load_addr;

-  int do_load = 1;

-

-  load_addr = phdr->p_paddr;

-  if (ctx->load_hook && ctx->load_hook (phdr, &load_addr, &do_load))

-    return 1;

-

-  if (! do_load)

-    return 0;

-

-  if (load_addr < ctx->load_base)

-    ctx->load_base = load_addr;

-

-  grub_dprintf ("elf", "Loading segment at 0x%llx, size 0x%llx\n",

-		(unsigned long long) load_addr,

-		(unsigned long long) phdr->p_memsz);

-

-  if (grub_file_seek (elf->file, phdr->p_offset) == (grub_off_t) -1)

-    return grub_errno;

-

-  if (phdr->p_filesz)

-    {

-      grub_ssize_t read;

-      read = grub_file_read (elf->file, (void *) load_addr, phdr->p_filesz);

-      if (read != (grub_ssize_t) phdr->p_filesz)

-	{

-	  /* XXX How can we free memory from `ctx->load_hook'?  */

-	  if (!grub_errno)

-	    grub_error (GRUB_ERR_FILE_READ_ERROR, N_("premature end of file %s"),

-			ctx->filename);

-	  return grub_errno;

-	}

-    }

-

-  if (phdr->p_filesz < phdr->p_memsz)

-    grub_memset ((void *) (long) (load_addr + phdr->p_filesz),

-		 0, phdr->p_memsz - phdr->p_filesz);

-

-  ctx->load_size += phdr->p_memsz;

-

-  return 0;

-}

-

-/* Load every loadable segment into memory specified by `_load_hook'.  */

-grub_err_t

-grub_elf64_load (grub_elf_t elf, const char *filename,

-		 grub_elf64_load_hook_t load_hook,

-		 grub_addr_t *base, grub_size_t *size)

-{

-  struct grub_elf64_load_ctx ctx = {

-    .filename = filename,

-    .load_hook = load_hook,

-    .load_base = (grub_addr_t) -1ULL,

-    .load_size = 0

-  };

-  grub_err_t err;

-

-  err = grub_elf64_phdr_iterate (elf, filename, grub_elf64_load_segment, &ctx;;

-

-  if (base)

-    *base = ctx.load_base;

-  if (size)

-    *size = ctx.load_size;

-

-  return err;

-}

+#define ehdrXX ehdr64

+#define ELFCLASSXX ELFCLASS64

+#define ElfXX_Addr Elf64_Addr

+#define grub_elfXX_size grub_elf64_size

+#define grub_elfXX_load grub_elf64_load

+#define FOR_ELFXX_PHDRS FOR_ELF64_PHDRS

+#define grub_elf_is_elfXX grub_elf_is_elf64

+#define grub_elfXX_load_phdrs grub_elf64_load_phdrs

+#define ElfXX_Phdr Elf64_Phdr

+#define grub_uintXX_t grub_uint64_t

+

+#include "elfXX.c"

diff --git a/grub-core/kern/elfXX.c b/grub-core/kern/elfXX.c

new file mode 100644

index 0000000..b35e235

--- /dev/null

+++ b/grub-core/kern/elfXX.c

@@ -0,0 +1,144 @@

+int

+grub_elf_is_elfXX (grub_elf_t elf)

+{

+  return elf->ehdr.ehdrXX.e_ident[EI_CLASS] == ELFCLASSXX;

+}

+

+grub_err_t

+grub_elfXX_load_phdrs (grub_elf_t elf)

+{

+  grub_ssize_t phdrs_size;

+

+  if (elf->phdrs)

+    return GRUB_ERR_NONE;

+

+  phdrs_size = elf->ehdr.ehdrXX.e_phnum * elf->ehdr.ehdrXX.e_phentsize;

+

+  grub_dprintf ("elf", "Loading program headers at 0x%llx, size 0x%lx.\n",

+		(unsigned long long) elf->ehdr.ehdrXX.e_phoff,

+		(unsigned long) phdrs_size);

+

+  elf->phdrs = grub_malloc (phdrs_size);

+  if (! elf->phdrs)

+    return grub_errno;

+

+  if ((grub_file_seek (elf->file, elf->ehdr.ehdrXX.e_phoff) == (grub_off_t) -1)

+      || (grub_file_read (elf->file, elf->phdrs, phdrs_size) != phdrs_size))

+    {

+      if (!grub_errno)

+	grub_error (GRUB_ERR_FILE_READ_ERROR, N_("premature end of file %s"),

+		    elf->filename);

+      return grub_errno;

+    }

+

+  return GRUB_ERR_NONE;

+}

+

+/* Calculate the amount of memory spanned by the segments.  */

+grub_size_t

+grub_elfXX_size (grub_elf_t elf,

+		 ElfXX_Addr *base, grub_uintXX_t *max_align)

+{

+  ElfXX_Addr segments_start = (ElfXX_Addr) -1;

+  ElfXX_Addr segments_end = 0;

+  int nr_phdrs = 0;

+  grub_uint32_t curr_align = 1;

+  ElfXX_Phdr *phdr;

+

+  /* Run through the program headers to calculate the total memory size we

+   * should claim.  */

+  FOR_ELFXX_PHDRS (elf, phdr)

+    {

+      /* Only consider loadable segments.  */

+      if (phdr->p_type != PT_LOAD)

+	continue;

+      nr_phdrs++;

+      if (phdr->p_paddr < segments_start)

+	segments_start = phdr->p_paddr;

+      if (phdr->p_paddr + phdr->p_memsz > segments_end)

+	segments_end = phdr->p_paddr + phdr->p_memsz;

+      if (curr_align < phdr->p_align)

+	curr_align = phdr->p_align;

+    }

+

+  if (base)

+    *base = 0;

+

+  if (nr_phdrs == 0)

+    {

+      grub_error (GRUB_ERR_BAD_OS, "no program headers present");

+      return 0;

+    }

+

+  if (segments_end < segments_start)

+    {

+      /* Very bad addresses.  */

+      grub_error (GRUB_ERR_BAD_OS, "bad program header load addresses");

+      return 0;

+    }

+

+  if (base)

+    *base = segments_start;

+  if (max_align)

+    *max_align = curr_align;

+  return segments_end - segments_start;

+}

+

+grub_err_t

+grub_elfXX_load (grub_elf_t elf, const char *filename,

+		 void *load_offset, enum grub_elf_load_flags load_flags,

+		 grub_addr_t *base, grub_size_t *size)

+{

+  grub_addr_t load_base = (grub_addr_t) -1ULL;

+  grub_size_t load_size = 0;

+  ElfXX_Phdr *phdr;

+

+  FOR_ELFXX_PHDRS(elf, phdr)

+  {

+    grub_addr_t load_addr;

+

+    if (phdr->p_type != PT_LOAD && !((load_flags & GRUB_ELF_LOAD_FLAGS_LOAD_PT_DYNAMIC) && phdr->p_type == PT_DYNAMIC))

+      continue;

+

+    load_addr = (grub_addr_t) phdr->p_paddr;

+    if (load_flags & GRUB_ELF_LOAD_FLAGS_28BITS)

+      load_addr &= 0xFFFFFFF;

+    load_addr += (grub_addr_t) load_offset;

+

+    if (load_addr < load_base)

+      load_base = load_addr;

+

+    grub_dprintf ("elf", "Loading segment at 0x%llx, size 0x%llx\n",

+		  (unsigned long long) load_addr,

+		  (unsigned long long) phdr->p_memsz);

+

+    if (grub_file_seek (elf->file, phdr->p_offset) == (grub_off_t) -1)

+      return grub_errno;

+

+    if (phdr->p_filesz)

+      {

+	grub_ssize_t read;

+	read = grub_file_read (elf->file, (void *) load_addr, phdr->p_filesz);

+	if (read != (grub_ssize_t) phdr->p_filesz)

+	  {

+	    if (!grub_errno)

+	      grub_error (GRUB_ERR_FILE_READ_ERROR, N_("premature end of file %s"),

+			  filename);

+	    return grub_errno;

+	  }

+      }

+

+    if (phdr->p_filesz < phdr->p_memsz)

+      grub_memset ((void *) (long) (load_addr + phdr->p_filesz),

+		   0, phdr->p_memsz - phdr->p_filesz);

+

+    load_size += phdr->p_memsz;

+  }

+

+  if (base)

+    *base = load_base;

+  if (size)

+    *size = load_size;

+

+  return grub_errno;

+}

diff --git a/grub-core/loader/i386/bsd.c b/grub-core/loader/i386/bsd.c

index 9b86158..6199609 100644

--- a/grub-core/loader/i386/bsd.c

+++ b/grub-core/loader/i386/bsd.c

@@ -1311,89 +1311,6 @@ grub_bsd_load_aout (grub_file_t file, const char *filename)

 			 bss_size);

 }

-static int

-grub_bsd_elf32_size_hook (grub_elf_t elf __attribute__ ((unused)),

-			  Elf32_Phdr *phdr, void *arg __attribute__ ((unused)))

-{

-  Elf32_Addr paddr;

-

-  if (phdr->p_type != PT_LOAD

-      && phdr->p_type != PT_DYNAMIC)

-      return 0;

-

-  paddr = phdr->p_paddr & 0xFFFFFFF;

-

-  if (paddr < kern_start)

-    kern_start = paddr;

-

-  if (paddr + phdr->p_memsz > kern_end)

-    kern_end = paddr + phdr->p_memsz;

-

-  return 0;

-}

-

-static grub_err_t

-grub_bsd_elf32_hook (Elf32_Phdr * phdr, grub_addr_t * addr, int *do_load)

-{

-  Elf32_Addr paddr;

-

-  if (phdr->p_type != PT_LOAD

-      && phdr->p_type != PT_DYNAMIC)

-    {

-      *do_load = 0;

-      return 0;

-    }

-

-  *do_load = 1;

-  phdr->p_paddr &= 0xFFFFFFF;

-  paddr = phdr->p_paddr;

-

-  *addr = (grub_addr_t) (paddr - kern_start + (grub_uint8_t *) kern_chunk_src);

-

-  return GRUB_ERR_NONE;

-}

-

-static int

-grub_bsd_elf64_size_hook (grub_elf_t elf __attribute__ ((unused)),

-			  Elf64_Phdr *phdr, void *arg __attribute__ ((unused)))