5 files changed, 159 insertions, 167 deletions

diff --git a/arch/x86/boot/compressed/Makefile b/arch/x86/boot/compressed/Makefile
index 92fdd35bd93e..1771c804e02f 100644
--- a/arch/x86/boot/compressed/Makefile
+++ b/arch/x86/boot/compressed/Makefile
@@ -27,9 +27,8 @@ $(obj)/vmlinux.bin: vmlinux FORCE
         $(call if_changed,objcopy)
 
 
-ifeq ($(CONFIG_X86_32),y)
-targets += vmlinux.bin.all vmlinux.relocs
-hostprogs-y := relocs
+targets += vmlinux.bin.all vmlinux.relocs relocs
+hostprogs-$(CONFIG_X86_32) += relocs
 
 quiet_cmd_relocs = RELOCS  $@
       cmd_relocs = $(obj)/relocs $< > $@;$(obj)/relocs --abs-relocs $<
@@ -43,6 +42,8 @@ quiet_cmd_relocbin = BUILD   $@
 $(obj)/vmlinux.bin.all: $(vmlinux.bin.all-y) FORCE
         $(call if_changed,relocbin)
 
+ifeq ($(CONFIG_X86_32),y)
+
 ifdef CONFIG_RELOCATABLE
 $(obj)/vmlinux.bin.gz: $(obj)/vmlinux.bin.all FORCE
         $(call if_changed,gzip)
@@ -59,6 +60,5 @@ $(obj)/vmlinux.bin.gz: $(obj)/vmlinux.bin FORCE
 LDFLAGS_piggy.o := -r --format binary --oformat elf64-x86-64 -T
 endif
 
-
 $(obj)/piggy.o: $(obj)/vmlinux.scr $(obj)/vmlinux.bin.gz FORCE
         $(call if_changed,ld)
diff --git a/arch/x86/boot/compressed/head_32.S b/arch/x86/boot/compressed/head_32.S
index ba7736cf2ec7..29c5fbf08392 100644
--- a/arch/x86/boot/compressed/head_32.S
+++ b/arch/x86/boot/compressed/head_32.S
@@ -137,14 +137,15 @@ relocated:
  */
         movl output_len(%ebx), %eax
         pushl %eax
+                        # push arguments for decompress_kernel:
         pushl %ebp      # output address
         movl input_len(%ebx), %eax
         pushl %eax      # input_len
         leal input_data(%ebx), %eax
         pushl %eax      # input_data
         leal boot_heap(%ebx), %eax
-        pushl %eax      # heap area as third argument
-        pushl %esi      # real mode pointer as second arg
+        pushl %eax      # heap area
+        pushl %esi      # real mode pointer
         call decompress_kernel
         addl $20, %esp
         popl %ecx
diff --git a/arch/x86/boot/compressed/head_64.S b/arch/x86/boot/compressed/head_64.S
index d8819efac81d..1d5dff4123e1 100644
--- a/arch/x86/boot/compressed/head_64.S
+++ b/arch/x86/boot/compressed/head_64.S
@@ -30,6 +30,7 @@
 #include <asm/page.h>
 #include <asm/boot.h>
 #include <asm/msr.h>
+#include <asm/processor-flags.h>
 #include <asm/asm-offsets.h>
 
 .section ".text.head"
@@ -109,7 +110,7 @@ startup_32:
 
         /* Enable PAE mode */
         xorl    %eax, %eax
-        orl     $(1 << 5), %eax
+        orl     $(X86_CR4_PAE), %eax
         movl    %eax, %cr4
 
  /*
@@ -170,7 +171,7 @@ startup_32:
         pushl   %eax
 
         /* Enter paged protected Mode, activating Long Mode */
-        movl    $0x80000001, %eax /* Enable Paging and Protected mode */
+        movl    $(X86_CR0_PG | X86_CR0_PE), %eax /* Enable Paging and Protected mode */
         movl    %eax, %cr0
 
         /* Jump from 32bit compatibility mode into 64bit mode. */
diff --git a/arch/x86/boot/compressed/misc.c b/arch/x86/boot/compressed/misc.c
index 90456cee47c3..5780d361105b 100644
--- a/arch/x86/boot/compressed/misc.c
+++ b/arch/x86/boot/compressed/misc.c
@@ -16,7 +16,7 @@
  */
 #undef CONFIG_PARAVIRT
 #ifdef CONFIG_X86_32
-#define _ASM_DESC_H_ 1
+#define ASM_X86__DESC_H 1
 #endif
 
 #ifdef CONFIG_X86_64
@@ -27,9 +27,10 @@
 #include <linux/linkage.h>
 #include <linux/screen_info.h>
 #include <linux/elf.h>
-#include <asm/io.h>
+#include <linux/io.h>
 #include <asm/page.h>
 #include <asm/boot.h>
+#include <asm/bootparam.h>
 
 /* WARNING!!
  * This code is compiled with -fPIC and it is relocated dynamically
@@ -181,32 +182,23 @@ static unsigned		outcnt;
 static int  fill_inbuf(void);
 static void flush_window(void);
 static void error(char *m);
-static void gzip_mark(void **);
-static void gzip_release(void **);
 
 /*
  * This is set up by the setup-routine at boot-time
  */
-static unsigned char *real_mode; /* Pointer to real-mode data */
-
-#define RM_EXT_MEM_K   (*(unsigned short *)(real_mode + 0x2))
-#ifndef STANDARD_MEMORY_BIOS_CALL
-#define RM_ALT_MEM_K   (*(unsigned long *)(real_mode + 0x1e0))
-#endif
-#define RM_SCREEN_INFO (*(struct screen_info *)(real_mode+0))
+static struct boot_params *real_mode;           /* Pointer to real-mode data */
+static int quiet;
 
 extern unsigned char input_data[];
 extern int input_len;
 
 static long bytes_out;
 
-static void *malloc(int size);
-static void free(void *where);
-
 static void *memset(void *s, int c, unsigned n);
 static void *memcpy(void *dest, const void *src, unsigned n);
 
-static void putstr(const char *);
+static void __putstr(int, const char *);
+#define putstr(__x)  __putstr(0, __x)
 
 #ifdef CONFIG_X86_64
 #define memptr long
@@ -221,46 +213,8 @@ static char *vidmem;
 static int vidport;
 static int lines, cols;
 
-#ifdef CONFIG_X86_NUMAQ
-void *xquad_portio;
-#endif
-
 #include "../../../../lib/inflate.c"
 
-static void *malloc(int size)
-{
-        void *p;
-
-        if (size < 0)
-                error("Malloc error");
-        if (free_mem_ptr <= 0)
-                error("Memory error");
-
-        free_mem_ptr = (free_mem_ptr + 3) & ~3; /* Align */
-
-        p = (void *)free_mem_ptr;
-        free_mem_ptr += size;
-
-        if (free_mem_ptr >= free_mem_end_ptr)
-                error("Out of memory");
-
-        return p;
-}
-
-static void free(void *where)
-{       /* Don't care */
-}
-
-static void gzip_mark(void **ptr)
-{
-        *ptr = (void *) free_mem_ptr;
-}
-
-static void gzip_release(void **ptr)
-{
-        free_mem_ptr = (memptr) *ptr;
-}
-
 static void scroll(void)
 {
         int i;
@@ -270,18 +224,24 @@ static void scroll(void)
                 vidmem[i] = ' ';
 }
 
-static void putstr(const char *s)
+static void __putstr(int error, const char *s)
 {
         int x, y, pos;
         char c;
 
+#ifndef CONFIG_X86_VERBOSE_BOOTUP
+        if (!error)
+                return;
+#endif
+
 #ifdef CONFIG_X86_32
-        if (RM_SCREEN_INFO.orig_video_mode == 0 && lines == 0 && cols == 0)
+        if (real_mode->screen_info.orig_video_mode == 0 &&
+            lines == 0 && cols == 0)
                 return;
 #endif
 
-        x = RM_SCREEN_INFO.orig_x;
-        y = RM_SCREEN_INFO.orig_y;
+        x = real_mode->screen_info.orig_x;
+        y = real_mode->screen_info.orig_y;
 
         while ((c = *s++) != '\0') {
                 if (c == '\n') {
@@ -291,7 +251,7 @@ static void putstr(const char *s)
                                 y--;
                         }
                 } else {
-                        vidmem [(x + cols * y) * 2] = c;
+                        vidmem[(x + cols * y) * 2] = c;
                         if (++x >= cols) {
                                 x = 0;
                                 if (++y >= lines) {
@@ -302,8 +262,8 @@ static void putstr(const char *s)
                 }
         }
 
-        RM_SCREEN_INFO.orig_x = x;
-        RM_SCREEN_INFO.orig_y = y;
+        real_mode->screen_info.orig_x = x;
+        real_mode->screen_info.orig_y = y;
 
         pos = (x + cols * y) * 2;       /* Update cursor position */
         outb(14, vidport);
@@ -317,7 +277,8 @@ static void *memset(void *s, int c, unsigned n)
         int i;
         char *ss = s;
 
-        for (i = 0; i < n; i++) ss[i] = c;
+        for (i = 0; i < n; i++)
+                ss[i] = c;
         return s;
 }
 
@@ -327,7 +288,8 @@ static void *memcpy(void *dest, const void *src, unsigned n)
         const char *s = src;
         char *d = dest;
 
-        for (i = 0; i < n; i++) d[i] = s[i];
+        for (i = 0; i < n; i++)
+                d[i] = s[i];
         return dest;
 }
 
@@ -366,9 +328,9 @@ static void flush_window(void)
 
 static void error(char *x)
 {
-        putstr("\n\n");
-        putstr(x);
-        putstr("\n\n -- System halted");
+        __putstr(1, "\n\n");
+        __putstr(1, x);
+        __putstr(1, "\n\n -- System halted");
 
         while (1)
                 asm("hlt");
@@ -395,7 +357,8 @@ static void parse_elf(void *output)
                 return;
         }
 
-        putstr("Parsing ELF... ");
+        if (!quiet)
+                putstr("Parsing ELF... ");
 
         phdrs = malloc(sizeof(*phdrs) * ehdr.e_phnum);
         if (!phdrs)
@@ -430,7 +393,10 @@ asmlinkage void decompress_kernel(void *rmode, memptr heap,
 {
         real_mode = rmode;
 
-        if (RM_SCREEN_INFO.orig_video_mode == 7) {
+        if (real_mode->hdr.loadflags & QUIET_FLAG)
+                quiet = 1;
+
+        if (real_mode->screen_info.orig_video_mode == 7) {
                 vidmem = (char *) 0xb0000;
                 vidport = 0x3b4;
         } else {
@@ -438,8 +404,8 @@ asmlinkage void decompress_kernel(void *rmode, memptr heap,
                 vidport = 0x3d4;
         }
 
-        lines = RM_SCREEN_INFO.orig_video_lines;
-        cols = RM_SCREEN_INFO.orig_video_cols;
+        lines = real_mode->screen_info.orig_video_lines;
+        cols = real_mode->screen_info.orig_video_cols;
 
         window = output;                /* Output buffer (Normally at 1M) */
         free_mem_ptr     = heap;        /* Heap */
@@ -465,9 +431,11 @@ asmlinkage void decompress_kernel(void *rmode, memptr heap,
 #endif
 
         makecrc();
-        putstr("\nDecompressing Linux... ");
+        if (!quiet)
+                putstr("\nDecompressing Linux... ");
         gunzip();
         parse_elf(output);
-        putstr("done.\nBooting the kernel.\n");
+        if (!quiet)
+                putstr("done.\nBooting the kernel.\n");
         return;
 }
diff --git a/arch/x86/boot/compressed/relocs.c b/arch/x86/boot/compressed/relocs.c
index edaadea90aaf..857e492c571e 100644
--- a/arch/x86/boot/compressed/relocs.c
+++ b/arch/x86/boot/compressed/relocs.c
@@ -10,16 +10,20 @@
 #define USE_BSD
 #include <endian.h>
 
-#define MAX_SHDRS 100
 #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
 static Elf32_Ehdr ehdr;
-static Elf32_Shdr shdr[MAX_SHDRS];
-static Elf32_Sym  *symtab[MAX_SHDRS];
-static Elf32_Rel  *reltab[MAX_SHDRS];
-static char *strtab[MAX_SHDRS];
 static unsigned long reloc_count, reloc_idx;
 static unsigned long *relocs;
 
+struct section {
+        Elf32_Shdr     shdr;
+        struct section *link;
+        Elf32_Sym      *symtab;
+        Elf32_Rel      *reltab;
+        char           *strtab;
+};
+static struct section *secs;
+
 /*
  * Following symbols have been audited. There values are constant and do
  * not change if bzImage is loaded at a different physical address than
@@ -35,7 +39,7 @@ static int is_safe_abs_reloc(const char* sym_name)
 {
         int i;
 
-        for(i = 0; i < ARRAY_SIZE(safe_abs_relocs); i++) {
+        for (i = 0; i < ARRAY_SIZE(safe_abs_relocs); i++) {
                 if (!strcmp(sym_name, safe_abs_relocs[i]))
                         /* Match found */
                         return 1;
@@ -137,10 +141,10 @@ static const char *sec_name(unsigned shndx)
 {
         const char *sec_strtab;
         const char *name;
-        sec_strtab = strtab[ehdr.e_shstrndx];
+        sec_strtab = secs[ehdr.e_shstrndx].strtab;
         name = "<noname>";
         if (shndx < ehdr.e_shnum) {
-                name = sec_strtab + shdr[shndx].sh_name;
+                name = sec_strtab + secs[shndx].shdr.sh_name;
         }
         else if (shndx == SHN_ABS) {
                 name = "ABSOLUTE";
@@ -159,7 +163,7 @@ static const char *sym_name(const char *sym_strtab, Elf32_Sym *sym)
                 name = sym_strtab + sym->st_name;
         }
         else {
-                name = sec_name(shdr[sym->st_shndx].sh_name);
+                name = sec_name(secs[sym->st_shndx].shdr.sh_name);
         }
         return name;
 }
@@ -244,29 +248,34 @@ static void read_ehdr(FILE *fp)
 static void read_shdrs(FILE *fp)
 {
         int i;
-        if (ehdr.e_shnum > MAX_SHDRS) {
-                die("%d section headers supported: %d\n",
-                        ehdr.e_shnum, MAX_SHDRS);
+        Elf32_Shdr shdr;
+
+        secs = calloc(ehdr.e_shnum, sizeof(struct section));
+        if (!secs) {
+                die("Unable to allocate %d section headers\n",
+                    ehdr.e_shnum);
         }
         if (fseek(fp, ehdr.e_shoff, SEEK_SET) < 0) {
                 die("Seek to %d failed: %s\n",
                         ehdr.e_shoff, strerror(errno));
         }
-        if (fread(&shdr, sizeof(shdr[0]), ehdr.e_shnum, fp) != ehdr.e_shnum) {
-                die("Cannot read ELF section headers: %s\n",
-                        strerror(errno));
-        }
-        for(i = 0; i < ehdr.e_shnum; i++) {
-                shdr[i].sh_name      = elf32_to_cpu(shdr[i].sh_name);
-                shdr[i].sh_type      = elf32_to_cpu(shdr[i].sh_type);
-                shdr[i].sh_flags     = elf32_to_cpu(shdr[i].sh_flags);
-                shdr[i].sh_addr      = elf32_to_cpu(shdr[i].sh_addr);
-                shdr[i].sh_offset    = elf32_to_cpu(shdr[i].sh_offset);
-                shdr[i].sh_size      = elf32_to_cpu(shdr[i].sh_size);
-                shdr[i].sh_link      = elf32_to_cpu(shdr[i].sh_link);
-                shdr[i].sh_info      = elf32_to_cpu(shdr[i].sh_info);
-                shdr[i].sh_addralign = elf32_to_cpu(shdr[i].sh_addralign);
-                shdr[i].sh_entsize   = elf32_to_cpu(shdr[i].sh_entsize);
+        for (i = 0; i < ehdr.e_shnum; i++) {
+                struct section *sec = &secs[i];
+                if (fread(&shdr, sizeof shdr, 1, fp) != 1)
+                        die("Cannot read ELF section headers %d/%d: %s\n",
+                            i, ehdr.e_shnum, strerror(errno));
+                sec->shdr.sh_name      = elf32_to_cpu(shdr.sh_name);
+                sec->shdr.sh_type      = elf32_to_cpu(shdr.sh_type);
+                sec->shdr.sh_flags     = elf32_to_cpu(shdr.sh_flags);
+                sec->shdr.sh_addr      = elf32_to_cpu(shdr.sh_addr);
+                sec->shdr.sh_offset    = elf32_to_cpu(shdr.sh_offset);
+                sec->shdr.sh_size      = elf32_to_cpu(shdr.sh_size);
+                sec->shdr.sh_link      = elf32_to_cpu(shdr.sh_link);
+                sec->shdr.sh_info      = elf32_to_cpu(shdr.sh_info);
+                sec->shdr.sh_addralign = elf32_to_cpu(shdr.sh_addralign);
+                sec->shdr.sh_entsize   = elf32_to_cpu(shdr.sh_entsize);
+                if (sec->shdr.sh_link < ehdr.e_shnum)
+                        sec->link = &secs[sec->shdr.sh_link];
         }
 
 }
@@ -274,20 +283,22 @@ static void read_shdrs(FILE *fp)
 static void read_strtabs(FILE *fp)
 {
         int i;
-        for(i = 0; i < ehdr.e_shnum; i++) {
-                if (shdr[i].sh_type != SHT_STRTAB) {
+        for (i = 0; i < ehdr.e_shnum; i++) {
+                struct section *sec = &secs[i];
+                if (sec->shdr.sh_type != SHT_STRTAB) {
                         continue;
                 }
-                strtab[i] = malloc(shdr[i].sh_size);
-                if (!strtab[i]) {
+                sec->strtab = malloc(sec->shdr.sh_size);
+                if (!sec->strtab) {
                         die("malloc of %d bytes for strtab failed\n",
-                                shdr[i].sh_size);
+                                sec->shdr.sh_size);
                 }
-                if (fseek(fp, shdr[i].sh_offset, SEEK_SET) < 0) {
+                if (fseek(fp, sec->shdr.sh_offset, SEEK_SET) < 0) {
                         die("Seek to %d failed: %s\n",
-                                shdr[i].sh_offset, strerror(errno));
+                                sec->shdr.sh_offset, strerror(errno));
                 }
-                if (fread(strtab[i], 1, shdr[i].sh_size, fp) != shdr[i].sh_size) {
+                if (fread(sec->strtab, 1, sec->shdr.sh_size, fp)
+                    != sec->shdr.sh_size) {
                         die("Cannot read symbol table: %s\n",
                                 strerror(errno));
                 }
@@ -297,28 +308,31 @@ static void read_strtabs(FILE *fp)
 static void read_symtabs(FILE *fp)
 {
         int i,j;
-        for(i = 0; i < ehdr.e_shnum; i++) {
-                if (shdr[i].sh_type != SHT_SYMTAB) {
+        for (i = 0; i < ehdr.e_shnum; i++) {
+                struct section *sec = &secs[i];
+                if (sec->shdr.sh_type != SHT_SYMTAB) {
                         continue;
                 }
-                symtab[i] = malloc(shdr[i].sh_size);
-                if (!symtab[i]) {
+                sec->symtab = malloc(sec->shdr.sh_size);
+                if (!sec->symtab) {
                         die("malloc of %d bytes for symtab failed\n",
-                                shdr[i].sh_size);
+                                sec->shdr.sh_size);
                 }
-                if (fseek(fp, shdr[i].sh_offset, SEEK_SET) < 0) {
+                if (fseek(fp, sec->shdr.sh_offset, SEEK_SET) < 0) {
                         die("Seek to %d failed: %s\n",
-                                shdr[i].sh_offset, strerror(errno));
+                                sec->shdr.sh_offset, strerror(errno));
                 }
-                if (fread(symtab[i], 1, shdr[i].sh_size, fp) != shdr[i].sh_size) {
+                if (fread(sec->symtab, 1, sec->shdr.sh_size, fp)
+                    != sec->shdr.sh_size) {
                         die("Cannot read symbol table: %s\n",
                                 strerror(errno));
                 }
-                for(j = 0; j < shdr[i].sh_size/sizeof(symtab[i][0]); j++) {
-                        symtab[i][j].st_name  = elf32_to_cpu(symtab[i][j].st_name);
-                        symtab[i][j].st_value = elf32_to_cpu(symtab[i][j].st_value);
-                        symtab[i][j].st_size  = elf32_to_cpu(symtab[i][j].st_size);
-                        symtab[i][j].st_shndx = elf16_to_cpu(symtab[i][j].st_shndx);
+                for (j = 0; j < sec->shdr.sh_size/sizeof(Elf32_Sym); j++) {
+                        Elf32_Sym *sym = &sec->symtab[j];
+                        sym->st_name  = elf32_to_cpu(sym->st_name);
+                        sym->st_value = elf32_to_cpu(sym->st_value);
+                        sym->st_size  = elf32_to_cpu(sym->st_size);
+                        sym->st_shndx = elf16_to_cpu(sym->st_shndx);
                 }
         }
 }
@@ -327,26 +341,29 @@ static void read_symtabs(FILE *fp)
 static void read_relocs(FILE *fp)
 {
         int i,j;
-        for(i = 0; i < ehdr.e_shnum; i++) {
-                if (shdr[i].sh_type != SHT_REL) {
+        for (i = 0; i < ehdr.e_shnum; i++) {
+                struct section *sec = &secs[i];
+                if (sec->shdr.sh_type != SHT_REL) {
                         continue;
                 }
-                reltab[i] = malloc(shdr[i].sh_size);
-                if (!reltab[i]) {
+                sec->reltab = malloc(sec->shdr.sh_size);
+                if (!sec->reltab) {
                         die("malloc of %d bytes for relocs failed\n",
-                                shdr[i].sh_size);
+                                sec->shdr.sh_size);
                 }
-                if (fseek(fp, shdr[i].sh_offset, SEEK_SET) < 0) {
+                if (fseek(fp, sec->shdr.sh_offset, SEEK_SET) < 0) {
                         die("Seek to %d failed: %s\n",
-                                shdr[i].sh_offset, strerror(errno));
+                                sec->shdr.sh_offset, strerror(errno));
                 }
-                if (fread(reltab[i], 1, shdr[i].sh_size, fp) != shdr[i].sh_size) {
+                if (fread(sec->reltab, 1, sec->shdr.sh_size, fp)
+                    != sec->shdr.sh_size) {
                         die("Cannot read symbol table: %s\n",
                                 strerror(errno));
                 }
-                for(j = 0; j < shdr[i].sh_size/sizeof(reltab[0][0]); j++) {
-                        reltab[i][j].r_offset = elf32_to_cpu(reltab[i][j].r_offset);
-                        reltab[i][j].r_info   = elf32_to_cpu(reltab[i][j].r_info);
+                for (j = 0; j < sec->shdr.sh_size/sizeof(Elf32_Rel); j++) {
+                        Elf32_Rel *rel = &sec->reltab[j];
+                        rel->r_offset = elf32_to_cpu(rel->r_offset);
+                        rel->r_info   = elf32_to_cpu(rel->r_info);
                 }
         }
 }
@@ -357,19 +374,21 @@ static void print_absolute_symbols(void)
         int i;
         printf("Absolute symbols\n");
         printf(" Num:    Value Size  Type       Bind        Visibility  Name\n");
-        for(i = 0; i < ehdr.e_shnum; i++) {
+        for (i = 0; i < ehdr.e_shnum; i++) {
+                struct section *sec = &secs[i];
                 char *sym_strtab;
                 Elf32_Sym *sh_symtab;
                 int j;
-                if (shdr[i].sh_type != SHT_SYMTAB) {
+
+                if (sec->shdr.sh_type != SHT_SYMTAB) {
                         continue;
                 }
-                sh_symtab = symtab[i];
-                sym_strtab = strtab[shdr[i].sh_link];
-                for(j = 0; j < shdr[i].sh_size/sizeof(symtab[0][0]); j++) {
+                sh_symtab = sec->symtab;
+                sym_strtab = sec->link->strtab;
+                for (j = 0; j < sec->shdr.sh_size/sizeof(Elf32_Sym); j++) {
                         Elf32_Sym *sym;
                         const char *name;
-                        sym = &symtab[i][j];
+                        sym = &sec->symtab[j];
                         name = sym_name(sym_strtab, sym);
                         if (sym->st_shndx != SHN_ABS) {
                                 continue;
@@ -389,26 +408,27 @@ static void print_absolute_relocs(void)
 {
         int i, printed = 0;
 
-        for(i = 0; i < ehdr.e_shnum; i++) {
+        for (i = 0; i < ehdr.e_shnum; i++) {
+                struct section *sec = &secs[i];
+                struct section *sec_applies, *sec_symtab;
                 char *sym_strtab;
                 Elf32_Sym *sh_symtab;
-                unsigned sec_applies, sec_symtab;
                 int j;
-                if (shdr[i].sh_type != SHT_REL) {
+                if (sec->shdr.sh_type != SHT_REL) {
                         continue;
                 }
-                sec_symtab  = shdr[i].sh_link;
-                sec_applies = shdr[i].sh_info;
-                if (!(shdr[sec_applies].sh_flags & SHF_ALLOC)) {
+                sec_symtab  = sec->link;
+                sec_applies = &secs[sec->shdr.sh_info];
+                if (!(sec_applies->shdr.sh_flags & SHF_ALLOC)) {
                         continue;
                 }
-                sh_symtab = symtab[sec_symtab];
-                sym_strtab = strtab[shdr[sec_symtab].sh_link];
-                for(j = 0; j < shdr[i].sh_size/sizeof(reltab[0][0]); j++) {
+                sh_symtab  = sec_symtab->symtab;
+                sym_strtab = sec_symtab->link->strtab;
+                for (j = 0; j < sec->shdr.sh_size/sizeof(Elf32_Rel); j++) {
                         Elf32_Rel *rel;
                         Elf32_Sym *sym;
                         const char *name;
-                        rel = &reltab[i][j];
+                        rel = &sec->reltab[j];
                         sym = &sh_symtab[ELF32_R_SYM(rel->r_info)];
                         name = sym_name(sym_strtab, sym);
                         if (sym->st_shndx != SHN_ABS) {
@@ -456,26 +476,28 @@ static void walk_relocs(void (*visit)(Elf32_Rel *rel, Elf32_Sym *sym))
 {
         int i;
         /* Walk through the relocations */
-        for(i = 0; i < ehdr.e_shnum; i++) {
+        for (i = 0; i < ehdr.e_shnum; i++) {
                 char *sym_strtab;
                 Elf32_Sym *sh_symtab;
-                unsigned sec_applies, sec_symtab;
+                struct section *sec_applies, *sec_symtab;
                 int j;
-                if (shdr[i].sh_type != SHT_REL) {
+                struct section *sec = &secs[i];
+
+                if (sec->shdr.sh_type != SHT_REL) {
                         continue;
                 }
-                sec_symtab  = shdr[i].sh_link;
-                sec_applies = shdr[i].sh_info;
-                if (!(shdr[sec_applies].sh_flags & SHF_ALLOC)) {
+                sec_symtab  = sec->link;
+                sec_applies = &secs[sec->shdr.sh_info];
+                if (!(sec_applies->shdr.sh_flags & SHF_ALLOC)) {
                         continue;
                 }
-                sh_symtab = symtab[sec_symtab];
-                sym_strtab = strtab[shdr[sec_symtab].sh_link];
-                for(j = 0; j < shdr[i].sh_size/sizeof(reltab[0][0]); j++) {
+                sh_symtab = sec_symtab->symtab;
+                sym_strtab = sec_symtab->link->strtab;
+                for (j = 0; j < sec->shdr.sh_size/sizeof(Elf32_Rel); j++) {
                         Elf32_Rel *rel;
                         Elf32_Sym *sym;
                         unsigned r_type;
-                        rel = &reltab[i][j];
+                        rel = &sec->reltab[j];
                         sym = &sh_symtab[ELF32_R_SYM(rel->r_info)];
                         r_type = ELF32_R_TYPE(rel->r_info);
                         /* Don't visit relocations to absolute symbols */
@@ -539,7 +561,7 @@ static void emit_relocs(int as_text)
                  */
                 printf(".section \".data.reloc\",\"a\"\n");
                 printf(".balign 4\n");
-                for(i = 0; i < reloc_count; i++) {
+                for (i = 0; i < reloc_count; i++) {
                         printf("\t .long 0x%08lx\n", relocs[i]);
                 }
                 printf("\n");
@@ -550,7 +572,7 @@ static void emit_relocs(int as_text)
                 /* Print a stop */
                 printf("%c%c%c%c", buf[0], buf[1], buf[2], buf[3]);
                 /* Now print each relocation */
-                for(i = 0; i < reloc_count; i++) {
+                for (i = 0; i < reloc_count; i++) {
                         buf[0] = (relocs[i] >>  0) & 0xff;
                         buf[1] = (relocs[i] >>  8) & 0xff;
                         buf[2] = (relocs[i] >> 16) & 0xff;
@@ -577,7 +599,7 @@ int main(int argc, char **argv)
         show_absolute_relocs = 0;
         as_text = 0;
         fname = NULL;
-        for(i = 1; i < argc; i++) {
+        for (i = 1; i < argc; i++) {
                 char *arg = argv[i];
                 if (*arg == '-') {
                         if (strcmp(argv[1], "--abs-syms") == 0) {