Remove nested functions from ELF iterators.

ChangeLog

@@ -1,3 +1,7 @@
+2013-01-20  Colin Watson  <cjwatson@ubuntu.com>
+
+	Remove nested functions from ELF iterators.
+
 2013-01-20  Colin Watson  <cjwatson@ubuntu.com>
 
 	Remove nested functions from device iterators.

grub-core/kern/elf.c

@@ -149,8 +149,7 @@ grub_elf32_load_phdrs (grub_elf_t elf, const char *filename)
 grub_err_t
 grub_elf32_phdr_iterate (grub_elf_t elf,
 			 const char *filename,
-			 int NESTED_FUNC_ATTR (*hook) (grub_elf_t, Elf32_Phdr *, void *),
+			 grub_elf32_phdr_iterate_hook_t hook, void *hook_arg)
-			 void *hook_arg)
 {
   Elf32_Phdr *phdrs;
   unsigned int i;
@@ -177,48 +176,58 @@ grub_elf32_phdr_iterate (grub_elf_t elf,
   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)
 {
-  Elf32_Addr segments_start = (Elf32_Addr) -1;
+  struct grub_elf32_size_ctx ctx = {
-  Elf32_Addr segments_end = 0;
+    .segments_start = (Elf32_Addr) -1,
-  int nr_phdrs = 0;
+    .segments_end = 0,
-  grub_uint32_t curr_align = 1;
+    .nr_phdrs = 0,
+    .curr_align = 1
+  };
 
-  /* Run through the program headers to calculate the total memory size we
+  grub_elf32_phdr_iterate (elf, filename, grub_elf32_calcsize, &ctx);
-   * should claim.  */
-  auto int NESTED_FUNC_ATTR calcsize (grub_elf_t _elf, Elf32_Phdr *phdr, void *_arg);
-  int NESTED_FUNC_ATTR calcsize (grub_elf_t _elf  __attribute__ ((unused)),
-				 Elf32_Phdr *phdr,
-				 void *_arg __attribute__ ((unused)))
-    {
-      /* Only consider loadable segments.  */
-      if (phdr->p_type != PT_LOAD)
-	return 0;
-      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;
-      return 0;
-    }
-
-  grub_elf32_phdr_iterate (elf, filename, calcsize, 0);
 
   if (base)
     *base = 0;
 
-  if (nr_phdrs == 0)
+  if (ctx.nr_phdrs == 0)
     {
       grub_error (GRUB_ERR_BAD_OS, "no program headers present");
       return 0;
     }
 
-  if (segments_end < segments_start)
+  if (ctx.segments_end < ctx.segments_start)
     {
       /* Very bad addresses.  */
       grub_error (GRUB_ERR_BAD_OS, "bad program header load addresses");
@@ -226,76 +235,87 @@ grub_elf32_size (grub_elf_t elf, const char *filename,
     }
 
   if (base)
-    *base = segments_start;
+    *base = ctx.segments_start;
   if (max_align)
-    *max_align = curr_align;
+    *max_align = ctx.curr_align;
-  return segments_end - segments_start;
+  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 (grub_elf_t elf, const char *filename,
-		 grub_elf32_load_hook_t _load_hook,
+		 grub_elf32_load_hook_t load_hook,
 		 grub_addr_t *base, grub_size_t *size)
 {
-  grub_addr_t load_base = (grub_addr_t) -1ULL;
+  struct grub_elf32_load_ctx ctx = {
-  grub_size_t load_size = 0;
+    .filename = filename,
+    .load_hook = load_hook,
+    .load_base = (grub_addr_t) -1ULL,
+    .load_size = 0
+  };
   grub_err_t err;
 
-  auto int NESTED_FUNC_ATTR grub_elf32_load_segment (grub_elf_t elf, Elf32_Phdr *phdr, void *hook);
+  err = grub_elf32_phdr_iterate (elf, filename, grub_elf32_load_segment, &ctx);
-  int NESTED_FUNC_ATTR grub_elf32_load_segment (grub_elf_t elf, Elf32_Phdr *phdr, void *hook)
-  {
-    grub_elf32_load_hook_t load_hook = (grub_elf32_load_hook_t) hook;
-    grub_addr_t load_addr;
-    int do_load = 1;
-
-    load_addr = phdr->p_paddr;
-    if (load_hook && load_hook (phdr, &load_addr, &do_load))
-      return 1;
-
-    if (! do_load)
-      return 0;
-
-    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)
-	  {
-	    /* XXX How can we free memory from `load_hook'? */
-	    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;
-
-    return 0;
-  }
-
-  err = grub_elf32_phdr_iterate (_elf, filename,
-				 grub_elf32_load_segment, _load_hook);
 
   if (base)
-    *base = load_base;
+    *base = ctx.load_base;
   if (size)
-    *size = load_size;
+    *size = ctx.load_size;
 
   return err;
 }
@@ -339,8 +359,7 @@ grub_elf64_load_phdrs (grub_elf_t elf, const char *filename)
 grub_err_t
 grub_elf64_phdr_iterate (grub_elf_t elf,
 			 const char *filename,
-			 int NESTED_FUNC_ATTR (*hook) (grub_elf_t, Elf64_Phdr *, void *),
+			 grub_elf64_phdr_iterate_hook_t hook, void *hook_arg)
-			 void *hook_arg)
 {
   Elf64_Phdr *phdrs;
   unsigned int i;
@@ -367,48 +386,58 @@ grub_elf64_phdr_iterate (grub_elf_t elf,
   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)
 {
-  Elf64_Addr segments_start = (Elf64_Addr) -1;
+  struct grub_elf64_size_ctx ctx = {
-  Elf64_Addr segments_end = 0;
+    .segments_start = (Elf64_Addr) -1,
-  int nr_phdrs = 0;
+    .segments_end = 0,
-  grub_uint64_t curr_align = 1;
+    .nr_phdrs = 0,
+    .curr_align = 1
+  };
 
-  /* Run through the program headers to calculate the total memory size we
+  grub_elf64_phdr_iterate (elf, filename, grub_elf64_calcsize, &ctx);
-   * should claim.  */
-  auto int NESTED_FUNC_ATTR calcsize (grub_elf_t _elf, Elf64_Phdr *phdr, void *_arg);
-  int NESTED_FUNC_ATTR calcsize (grub_elf_t _elf  __attribute__ ((unused)),
-				 Elf64_Phdr *phdr,
-				 void *_arg __attribute__ ((unused)))
-    {
-      /* Only consider loadable segments.  */
-      if (phdr->p_type != PT_LOAD)
-	return 0;
-      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;
-      return 0;
-    }
-
-  grub_elf64_phdr_iterate (elf, filename, calcsize, 0);
 
   if (base)
     *base = 0;
 
-  if (nr_phdrs == 0)
+  if (ctx.nr_phdrs == 0)
     {
       grub_error (GRUB_ERR_BAD_OS, "no program headers present");
       return 0;
     }
 
-  if (segments_end < segments_start)
+  if (ctx.segments_end < ctx.segments_start)
     {
       /* Very bad addresses.  */
       grub_error (GRUB_ERR_BAD_OS, "bad program header load addresses");
@@ -416,77 +445,87 @@ grub_elf64_size (grub_elf_t elf, const char *filename,
     }
 
   if (base)
-    *base = segments_start;
+    *base = ctx.segments_start;
   if (max_align)
-    *max_align = curr_align;
+    *max_align = ctx.curr_align;
-  return segments_end - segments_start;
+  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 (grub_elf_t elf, const char *filename,
-		 grub_elf64_load_hook_t _load_hook,
+		 grub_elf64_load_hook_t load_hook,
 		 grub_addr_t *base, grub_size_t *size)
 {
-  grub_addr_t load_base = (grub_addr_t) -1ULL;
+  struct grub_elf64_load_ctx ctx = {
-  grub_size_t load_size = 0;
+    .filename = filename,
+    .load_hook = load_hook,
+    .load_base = (grub_addr_t) -1ULL,
+    .load_size = 0
+  };
   grub_err_t err;
 
-  auto int NESTED_FUNC_ATTR grub_elf64_load_segment (grub_elf_t elf, Elf64_Phdr *phdr,
+  err = grub_elf64_phdr_iterate (elf, filename, grub_elf64_load_segment, &ctx);
-						     void *hook);
-  int NESTED_FUNC_ATTR grub_elf64_load_segment (grub_elf_t elf, Elf64_Phdr *phdr, void *hook)
-  {
-    grub_elf64_load_hook_t load_hook = (grub_elf64_load_hook_t) hook;
-    grub_addr_t load_addr;
-    int do_load = 1;
-
-    load_addr = phdr->p_paddr;
-    if (load_hook && load_hook (phdr, &load_addr, &do_load))
-      return 1;
-
-    if (! do_load)
-      return 0;
-
-    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)
-          {
-	    /* XXX How can we free memory from `load_hook'?  */
-	    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;
-
-    return 0;
-  }
-
-  err = grub_elf64_phdr_iterate (_elf, filename,
-				 grub_elf64_load_segment, _load_hook);
 
   if (base)
-    *base = load_base;
+    *base = ctx.load_base;
   if (size)
-    *size = load_size;
+    *size = ctx.load_size;
 
   return err;
 }

grub-core/loader/i386/bsd.c

@@ -1311,7 +1311,7 @@ grub_bsd_load_aout (grub_file_t file, const char *filename)
 			 bss_size);
 }
 
-static int NESTED_FUNC_ATTR
+static int
 grub_bsd_elf32_size_hook (grub_elf_t elf __attribute__ ((unused)),
 			  Elf32_Phdr *phdr, void *arg __attribute__ ((unused)))
 {
@@ -1353,7 +1353,7 @@ grub_bsd_elf32_hook (Elf32_Phdr * phdr, grub_addr_t * addr, int *do_load)
   return GRUB_ERR_NONE;
 }
 
-static int NESTED_FUNC_ATTR
+static int
 grub_bsd_elf64_size_hook (grub_elf_t elf __attribute__ ((unused)),
 			  Elf64_Phdr *phdr, void *arg __attribute__ ((unused)))
 {

include/grub/elfload.h

@@ -41,6 +41,11 @@ typedef grub_err_t (*grub_elf32_load_hook_t)
 typedef grub_err_t (*grub_elf64_load_hook_t)
   (Elf64_Phdr *phdr, grub_addr_t *addr, int *load);
 
+typedef int (*grub_elf32_phdr_iterate_hook_t)
+  (grub_elf_t elf, Elf32_Phdr *phdr, void *arg);
+typedef int (*grub_elf64_phdr_iterate_hook_t)
+  (grub_elf_t elf, Elf64_Phdr *phdr, void *arg);
+
 grub_elf_t grub_elf_open (const char *);
 grub_elf_t grub_elf_file (grub_file_t file, const char *filename);
 grub_err_t grub_elf_close (grub_elf_t);
@@ -63,12 +68,10 @@ grub_err_t grub_elf64_load (grub_elf_t, const char *filename,
 grub_err_t
 grub_elf32_phdr_iterate (grub_elf_t elf,
 			 const char *filename,
-			 int NESTED_FUNC_ATTR (*hook) (grub_elf_t, Elf32_Phdr *, void *),
+			 grub_elf32_phdr_iterate_hook_t hook, void *hook_arg);
-			 void *hook_arg);
 grub_err_t
 grub_elf64_phdr_iterate (grub_elf_t elf,
 			 const char *filename,
-			 int NESTED_FUNC_ATTR (*hook) (grub_elf_t, Elf64_Phdr *, void *),
+			 grub_elf64_phdr_iterate_hook_t hook, void *hook_arg);
-			 void *hook_arg);
 
 #endif /* ! GRUB_ELFLOAD_HEADER */