--- a/packages/services/objloader/current/src/objelf.c
+++ b/packages/services/objloader/current/src/objelf.c
@@ -42,7 +42,7 @@
  * =================================================================
  * #####DESCRIPTIONBEGIN####
  * 
- *  Author(s):    atonizzo@lycos.com
+ *  Author(s):    Anthony Tonizzo (atonizzo@gmail.com)
  *  Contributors: nickg@ecoscentric.com
  *  Date:         2005-05-13
  *  Purpose:      
@@ -62,161 +62,161 @@
 #include <cyg/objloader/elf.h>
 #include <cyg/objloader/objelf.h>
 
-CYG_HAL_TABLE_BEGIN( cyg_ldr_table, ldr_table );
-CYG_HAL_TABLE_END( cyg_ldr_table_end, ldr_table );
+CYG_HAL_TABLE_BEGIN(cyg_ldr_table, ldr_table);
+CYG_HAL_TABLE_END(cyg_ldr_table_end, ldr_table);
 
 __externC cyg_ldr_table_entry cyg_ldr_table[];
 __externC cyg_ldr_table_entry cyg_ldr_table_end[];
 
 #if CYGPKG_SERVICES_OBJLOADER_DEBUG_LEVEL > 0
 void 
-cyg_ldr_print_section_data( PELF_OBJECT p )
+cyg_ldr_print_section_data(PELF_OBJECT p)
 {
-    cyg_int32  i;
-    cyg_uint8  strname[32];
-    cyg_uint8  *p_strtab = (cyg_uint8*)p->sections[p->p_elfhdr->e_shstrndx];
+    int    i;
+    char   strname[32];
+    char  *p_strtab = (char*)p->sections[p->p_elfhdr->e_shstrndx];
     
-    diag_printf( "\n\nSection Headers:\n" ); 
-    diag_printf( "[Nr]  Name                  Addr    Offset    Size     Info\n" );
-    for ( i = 0; i < p->p_elfhdr->e_shnum; i++ )
+    diag_printf("\n\nSection Headers:\n"); 
+    diag_printf("[Nr]  Name                  Addr    Offset    Size     Info\n");
+    for (i = 0; i < p->p_elfhdr->e_shnum; i++)
     {
-        sprintf( strname, "%s", p_strtab + p->p_sechdr[i].sh_name );
-        while ( strlen( strname ) < 20 )
-            strcat( strname, " " );
-        diag_printf( "[%02d] %s %08X %08X %08X %08X\n",  
+        sprintf(strname, "%s", p_strtab + p->p_sechdr[i].sh_name);
+        while (strlen(strname) < 20)
+            strcat(strname, " ");
+        diag_printf("[%02d] %s %08X %08X %08X %08X\n",  
                      i, 
                      strname,
                      p->p_sechdr[i].sh_addr,
                      p->p_sechdr[i].sh_offset,
                      p->p_sechdr[i].sh_size,
-                     p->p_sechdr[i].sh_info );
+                     p->p_sechdr[i].sh_info);
     }                 
-    diag_printf( "\n" ); 
+    diag_printf("\n"); 
 }
 
 void 
-cyg_ldr_print_symbol_names( PELF_OBJECT p )
+cyg_ldr_print_symbol_names(PELF_OBJECT p)
 {
-    cyg_int32  i, symtab_entries;
+    int        i;
     Elf32_Sym *p_symtab = (Elf32_Sym*)p->sections[p->hdrndx_symtab];
-    cyg_uint8 *p_strtab = (cyg_uint8*)p->sections[p->hdrndx_strtab];
-    cyg_uint8  strname[32];
+    char      *p_strtab = (char*)p->sections[p->hdrndx_strtab];
+    char       strname[32];
 
     // Total number of entries in the symbol table.
-    symtab_entries = p->p_sechdr[p->hdrndx_symtab].sh_size / 
+    int symtab_entries = p->p_sechdr[p->hdrndx_symtab].sh_size / 
                                 p->p_sechdr[p->hdrndx_symtab].sh_entsize;
-    diag_printf( "Num  Value     Size Ndx   Name\n" ); 
-    for ( i = 1; i < symtab_entries; i++ )
+    diag_printf("Num  Value     Size Ndx   Name\n"); 
+    for (i = 1; i < symtab_entries; i++)
     {
-        sprintf( strname, "%d", i );
-        while ( strlen( strname ) < 5 )
-            strcat( strname, " " );
-        diag_printf( strname );         
+        sprintf(strname, "%d", i);
+        while (strlen(strname) < 5)
+            strcat(strname, " ");
+        diag_printf(strname);         
         
-        sprintf( strname, 
+        sprintf(strname, 
                  "%08X  %d", 
                  p_symtab[i].st_value, 
-                 p_symtab[i].st_size );
-        while ( strlen( strname ) < 15 )
-            strcat( strname, " " );
-        diag_printf( strname );         
+                 p_symtab[i].st_size);
+        while (strlen(strname) < 15)
+            strcat(strname, " ");
+        diag_printf(strname);         
         
-        sprintf( strname, "%d", p_symtab[i].st_shndx );
-        while ( strlen( strname ) < 6 )
-            strcat( strname, " " );
-        diag_printf( strname );         
+        sprintf(strname, "%d", p_symtab[i].st_shndx);
+        while (strlen(strname) < 6)
+            strcat(strname, " ");
+        diag_printf(strname);         
         
-        strncpy( strname, 
+        strncpy(strname, 
                  p_strtab + p_symtab[i].st_name, 
-                 sizeof( strname ) - 1 );
-        strname[strlen( p_strtab + p_symtab[i].st_name )] = '\0';
-        diag_printf( strname );         
-        diag_printf( "\n" );         
+                 sizeof(strname) - 1);
+        strname[strlen(p_strtab + p_symtab[i].st_name)] = '\0';
+        diag_printf(strname);         
+        diag_printf("\n");         
     }
 }
 
 void 
-cyg_ldr_print_rel_names( PELF_OBJECT p )
+cyg_ldr_print_rel_names(PELF_OBJECT p)
 {
-    cyg_int32     i, j, r_entries, sym_index;
+    int        i, j, r_entries, sym_index;
     Elf32_Sym *p_symtab = (Elf32_Sym*)p->sections[p->hdrndx_symtab];
-    cyg_uint8 *p_strtab = (cyg_uint8*)p->sections[p->hdrndx_strtab];
-    cyg_uint8 *p_shstrtab = (cyg_uint8*)p->sections[p->p_elfhdr->e_shstrndx];
+    char      *p_strtab = (char*)p->sections[p->hdrndx_strtab];
+    char      *p_shstrtab = (char*)p->sections[p->p_elfhdr->e_shstrndx];
 #if ELF_ARCH_RELTYPE == Elf_Rela        
     Elf32_Rela*   p_rela;
 #else
     Elf32_Rel*    p_rel;
 #endif
-    cyg_uint8  strname[32];
+    char       strname[32];
 
-    for ( i = 1; i < p->p_elfhdr->e_shnum; i++ )
+    for (i = 1; i < p->p_elfhdr->e_shnum; i++)
     {
-        if ( ( p->p_sechdr[i].sh_type == SHT_REL ) ||
-                                  ( p->p_sechdr[i].sh_type == SHT_RELA ) )
+        if ((p->p_sechdr[i].sh_type == SHT_REL) ||
+                                  (p->p_sechdr[i].sh_type == SHT_RELA))
         {                                  
             // Calculate the total number of entries in the .rela section.
             r_entries = p->p_sechdr[i].sh_size / p->p_sechdr[i].sh_entsize;
 
-            diag_printf( "\n\nSymbols at: %s\n\n", 
-                         p_shstrtab + p->p_sechdr[i].sh_name );
+            diag_printf("\n\nSymbols at: %s\n\n", 
+                         p_shstrtab + p->p_sechdr[i].sh_name);
 #if ELF_ARCH_RELTYPE == Elf_Rela        
-            p_rela = (Elf32_Rela*)cyg_ldr_load_elf_section( p, i );
-            printf( "Offset    Info      Name [+ Addend]\n" );
+            p_rela = (Elf32_Rela*)cyg_ldr_load_elf_section(p, i);
+            printf("Offset    Info      Name [+ Addend]\n");
 #else
-            p_rel = (Elf32_Rel*)cyg_ldr_load_elf_section( p, i );
-            printf( "Offset    Info     Name\n" );
+            p_rel = (Elf32_Rel*)cyg_ldr_load_elf_section(p, i);
+            printf("Offset    Info     Name\n");
 #endif
 
-            for ( j = 0; j < r_entries; j++ )
+            for (j = 0; j < r_entries; j++)
             {
-                sprintf( strname, 
+                sprintf(strname, 
                          "%08X  %08X  ", 
 #if ELF_ARCH_RELTYPE == Elf_Rela        
-                         p_rela[j].r_offset,
-                         p_rela[j].r_info 
+                        p_rela[j].r_offset,
+                        p_rela[j].r_info 
 #else
-                         p_rel[j].r_offset,
-                         p_rel[j].r_info 
+                        p_rel[j].r_offset,
+                        p_rel[j].r_info 
 #endif
-                         );
+                        );
 
-                diag_printf( strname );         
+                diag_printf(strname);         
 
 #if ELF_ARCH_RELTYPE == Elf_Rela        
-                cyg_uint8 sym_type = ELF32_R_SYM( p_rela[j].r_info );
+                cyg_uint8 sym_type = ELF32_R_SYM(p_rela[j].r_info);
 #else
-                cyg_uint8 sym_type = ELF32_R_SYM( p_rel[j].r_info );
+                cyg_uint8 sym_type = ELF32_R_SYM(p_rel[j].r_info);
 #endif
-                if ( strlen ( p_strtab + p_symtab[sym_type].st_name ) > 0 )
-                    diag_printf( p_strtab + p_symtab[sym_type].st_name );         
+                if (strlen (p_strtab + p_symtab[sym_type].st_name) > 0)
+                    diag_printf(p_strtab + p_symtab[sym_type].st_name);         
                 else 
                 {   
                     // If the symbol name is not available, then print
                     //  the name of the section.
                     sym_index = p_symtab[sym_type].st_shndx;                    
-                    diag_printf( p_shstrtab + p->p_sechdr[sym_index].sh_name );         
+                    diag_printf(p_shstrtab + p->p_sechdr[sym_index].sh_name);         
                 }    
 #if ELF_ARCH_RELTYPE == Elf_Rela        
-                if ( p_rela[j].r_addend != 0 )
-                    diag_printf( " + %08X", p_rela[j].r_addend );
+                if (p_rela[j].r_addend != 0)
+                    diag_printf(" + %08X", p_rela[j].r_addend);
 #endif
-                diag_printf( "\n" );         
+                diag_printf("\n");         
             }            
             // After all the printing is done, the relocation table can 
             //  be dumped.
-            cyg_ldr_delete_elf_section( p, i );
+            cyg_ldr_delete_elf_section(p, i);
         } 
     }    
 }
 #endif // DEBUG_PRINT
 
 static void
-*cyg_ldr_local_address( PELF_OBJECT p, cyg_uint32 sym_index )
+*cyg_ldr_local_address(PELF_OBJECT p, cyg_uint32 sym_index)
 {
     cyg_uint32 data_sec, addr;
     Elf32_Sym *p_symtab;
 
-    p_symtab = (Elf32_Sym*)cyg_ldr_section_address( p, p->hdrndx_symtab );
+    p_symtab = (Elf32_Sym*)cyg_ldr_section_address(p, p->hdrndx_symtab);
     
     // Find out the section number in which the data for this symbol is 
     //  located.
@@ -224,14 +224,14 @@ static void
 
     // From the section number we get the start of the memory area in 
     //  memory.
-    addr = (cyg_uint32)cyg_ldr_section_address( p, data_sec );
+    addr = (cyg_uint32)cyg_ldr_section_address(p, data_sec);
 
     // And now return the address of the data.
-    return (void*)( addr + p_symtab[sym_index].st_value);
+    return (void*)(addr + p_symtab[sym_index].st_value);
 }    
 
 void
-*cyg_ldr_external_address( PELF_OBJECT p, cyg_uint32 sym_index )
+*cyg_ldr_external_address(PELF_OBJECT p, cyg_uint32 sym_index)
 {
     cyg_uint8*    tmp2;
     Elf32_Sym *p_symtab;
@@ -239,14 +239,14 @@ void
     cyg_ldr_table_entry *entry = cyg_ldr_table;
   
   
-    p_symtab = (Elf32_Sym*)cyg_ldr_section_address( p, p->hdrndx_symtab );
-    p_strtab = (cyg_uint8*)cyg_ldr_section_address( p, p->hdrndx_strtab );
+    p_symtab = (Elf32_Sym*)cyg_ldr_section_address(p, p->hdrndx_symtab);
+    p_strtab = (cyg_uint8*)cyg_ldr_section_address(p, p->hdrndx_strtab);
   
     // This is the name of the external reference to search.
     tmp2 = p_strtab + p_symtab[sym_index].st_name;
-    while ( entry != cyg_ldr_table_end )
+    while (entry != cyg_ldr_table_end)
     {
-        if ( !strcmp( (const char*)tmp2, entry->symbol_name  ) )
+        if (!strcmp((const char*)tmp2, entry->symbol_name ))
             return entry->handler;
         entry++;
     }
@@ -263,42 +263,38 @@ void
 // 0          : Symbol not found
 // Other      : Address of the symbol in absolute memory.
 void 
-*cyg_ldr_symbol_address( PELF_OBJECT p, cyg_uint32 sym_index )
+*cyg_ldr_symbol_address(PELF_OBJECT p, cyg_uint32 sym_index)
 {
     cyg_uint32 addr;
-    cyg_uint8  sym_info;
-    Elf32_Sym *p_symtab;
-
-    p_symtab = (Elf32_Sym*)cyg_ldr_section_address( p, p->hdrndx_symtab );
-    sym_info = p_symtab[sym_index].st_info;
-    
-    switch ( ELF32_ST_TYPE( sym_info ) )
+    Elf32_Sym *p_symtab = (Elf32_Sym*)cyg_ldr_section_address(p, 
+                                                              p->hdrndx_symtab);
+    cyg_uint8 sym_info = p_symtab[sym_index].st_info;
+    switch (ELF32_ST_TYPE(sym_info))
     {
     case STT_NOTYPE:
     case STT_FUNC:
     case STT_OBJECT:
-        switch ( ELF32_ST_BIND( sym_info ) )
+        switch (ELF32_ST_BIND(sym_info))
         {
         case STB_LOCAL:
         case STB_GLOBAL:
-            if ( p_symtab[sym_index].st_shndx == SHN_UNDEF ) 
-                return cyg_ldr_external_address( p, sym_index );
+            if (p_symtab[sym_index].st_shndx == SHN_UNDEF) 
+                return cyg_ldr_external_address(p, sym_index);
             else
-                return cyg_ldr_local_address( p, sym_index );
+                return cyg_ldr_local_address(p, sym_index);
         case STB_WEAK:
-            addr = (cyg_uint32)cyg_ldr_external_address( p, sym_index );
-            if ( addr != 0 )
+            addr = (cyg_uint32)cyg_ldr_external_address(p, sym_index);
+            if (addr != 0)
                 return (void*)addr;
             else    
-                return cyg_ldr_local_address( p, sym_index );
+                return cyg_ldr_local_address(p, sym_index);
         default:
             return 0;
         }
         break;
     case STT_SECTION:
         // Return the starting address of a section, given its index.
-        return (void*)cyg_ldr_section_address( p, 
-                                               p_symtab[sym_index].st_shndx );
+        return (void*)cyg_ldr_section_address(p, p_symtab[sym_index].st_shndx);
     default:
         return 0;
     }
@@ -307,64 +303,60 @@ void
 // Loads the relocation information, relocates, and dumps the relocation
 //  information once the process is complete.
 cyg_int32 
-cyg_ldr_relocate_section( PELF_OBJECT p, cyg_uint32 r_shndx )
+cyg_ldr_relocate_section(PELF_OBJECT p, cyg_uint32 r_shndx)
 {
-    cyg_int32   i, rc;
-    cyg_uint32  r_entries, r_target_shndx, r_target_addr;
-    cyg_uint32  sym_value, sym_index;
-    Elf32_Addr  r_offset;
-    Elf32_Word  r_type;
-    Elf32_Sword r_addend;
+    int         i, rc;
 #if ELF_ARCH_RELTYPE == Elf_Rela        
-    Elf32_Rela* p_rela = (Elf32_Rela*)cyg_ldr_load_elf_section( p, r_shndx );
+    Elf32_Rela* p_rela = (Elf32_Rela*)cyg_ldr_load_elf_section(p, r_shndx);
 #else
-    Elf32_Rel*  p_rel = (Elf32_Rel*)cyg_ldr_load_elf_section( p, r_shndx );
+    Elf32_Rel*  p_rel = (Elf32_Rel*)cyg_ldr_load_elf_section(p, r_shndx);
 #endif
 
 #if CYGPKG_SERVICES_OBJLOADER_DEBUG_LEVEL > 0
-    Elf32_Sym *p_symtab = (Elf32_Sym*)cyg_ldr_section_address( p, 
-                                                           p->hdrndx_symtab );
-    cyg_uint8 *p_strtab = (cyg_uint8*)cyg_ldr_section_address( p, 
-                                                           p->hdrndx_strtab );
-    cyg_uint8 *p_shstrtab = (cyg_uint8*)cyg_ldr_section_address( p, 
-                                                     p->p_elfhdr->e_shstrndx );
+    Elf32_Sym *p_symtab = (Elf32_Sym*)cyg_ldr_section_address(p, 
+                                                           p->hdrndx_symtab);
+    char      *p_strtab = (char*)cyg_ldr_section_address(p, p->hdrndx_strtab);
+    char      *p_shstrtab = (char*)cyg_ldr_section_address(p, 
+                                                     p->p_elfhdr->e_shstrndx);
 #endif
 
     // Now we can get the address of the contents of the section to modify.
-    r_target_shndx = p->p_sechdr[r_shndx].sh_info;
-    r_target_addr  = (cyg_uint32)cyg_ldr_section_address( p, r_target_shndx );
+    cyg_uint32 r_target_shndx = p->p_sechdr[r_shndx].sh_info;
+    cyg_uint32 r_target_addr  = (cyg_uint32)cyg_ldr_section_address(p, 
+                                                                r_target_shndx);
 
 #if CYGPKG_SERVICES_OBJLOADER_DEBUG_LEVEL > 0
-    diag_printf( "Relocating section \"%s\"\n",
-            p_shstrtab + p->p_sechdr[r_target_shndx].sh_name );
+    diag_printf("Relocating section \"%s\"\n",
+            p_shstrtab + p->p_sechdr[r_target_shndx].sh_name);
 #if CYGPKG_SERVICES_OBJLOADER_DEBUG_LEVEL > 1
-    diag_printf( "Ndx   Type   Offset    Name\"\n" );
+    diag_printf("Ndx   Type   Offset    Name\"\n");
 #endif
 #endif
 
     // Perform relocatation for each of the members of this table.
-    r_entries = p->p_sechdr[r_shndx].sh_size / p->p_sechdr[r_shndx].sh_entsize;
-    for ( i = 0; i < r_entries; i++ )
+    cyg_uint32 r_entries = p->p_sechdr[r_shndx].sh_size / 
+                                             p->p_sechdr[r_shndx].sh_entsize;
+    for (i = 0; i < r_entries; i++)
     {
 #if ELF_ARCH_RELTYPE == Elf_Rela        
-        r_offset  = p_rela[i].r_offset; 
-        r_type    = ELF32_R_TYPE( p_rela[i].r_info ); 
-        sym_index = ELF32_R_SYM( p_rela[i].r_info );
-        r_addend  = p_rela[i].r_addend; 
+        Elf32_Addr  r_offset = p_rela[i].r_offset; 
+        Elf32_Word  r_type   = ELF32_R_TYPE(p_rela[i].r_info); 
+        cyg_uint32  sym_index = ELF32_R_SYM(p_rela[i].r_info);
+        Elf32_Sword r_addend  = p_rela[i].r_addend; 
 #else
-        r_offset  = p_rel[i].r_offset; 
-        r_type    = ELF32_R_TYPE( p_rel[i].r_info ); 
-        sym_index = ELF32_R_SYM( p_rel[i].r_info );
-        r_addend  = 0; 
+        Elf32_Addr  r_offset  = p_rel[i].r_offset; 
+        Elf32_Word  r_type    = ELF32_R_TYPE(p_rel[i].r_info); 
+        cyg_uint32  sym_index = ELF32_R_SYM(p_rel[i].r_info);
+        Elf32_Sword r_addend  = 0; 
 #endif
 
-        sym_value = (cyg_uint32)cyg_ldr_symbol_address( p, sym_index );
-        if ( sym_value == 0 )
+        cyg_uint32 sym_value = (cyg_uint32)cyg_ldr_symbol_address(p, sym_index);
+        if (sym_value == 0)
         {
 #if CYGPKG_SERVICES_OBJLOADER_DEBUG_LEVEL > 0
-            diag_printf( "Unknown symbol value: %s Index: %d\n",
+            diag_printf("Unknown symbol value: %s Index: %d\n",
                          p_strtab + p_symtab[sym_index].st_name,
-                         sym_index );
+                         sym_index);
 #endif
             return -1;
         }    
@@ -372,36 +364,36 @@ cyg_ldr_relocate_section( PELF_OBJECT p,
         // This is architecture dependent, and deals with whether we have
         //  '.rel' or '.rela' sections.
 #if CYGPKG_SERVICES_OBJLOADER_DEBUG_LEVEL > 1
-        diag_printf( "%04X  %04X  %08X  ",
+        diag_printf("%04X  %04X  %08X  ",
                      sym_index,
                      r_type,
-                     r_offset );
-        if ( strlen ( p_strtab + p_symtab[sym_index].st_name ) > 0 )
-            diag_printf( p_strtab + p_symtab[sym_index].st_name );         
+                     r_offset);
+        if (strlen(p_strtab + p_symtab[sym_index].st_name) > 0)
+            diag_printf(p_strtab + p_symtab[sym_index].st_name);         
         else 
         {   
             // If the symbol name is not available, then print
             //  the name of the section.
             cyg_uint32 sec_ndx = p_symtab[sym_index].st_shndx;                    
-            diag_printf( p_shstrtab + p->p_sechdr[sec_ndx].sh_name );         
+            diag_printf(p_shstrtab + p->p_sechdr[sec_ndx].sh_name);         
         }    
-        diag_printf( "\n" );         
+        diag_printf("\n");         
 #endif
-        rc = cyg_ldr_relocate( r_type,
+        rc = cyg_ldr_relocate(r_type,
                                r_target_addr + r_offset, 
-                               sym_value + r_addend );
-        if ( rc != 0 )
+                               sym_value + r_addend);
+        if (rc != 0)
         {
 #if CYGPKG_SERVICES_OBJLOADER_DEBUG_LEVEL > 0
-            diag_printf( "Relocation error: Cannot find symbol: %s\n",
-                      p_strtab + p_symtab[sym_index].st_name );
+            diag_printf("Relocation error: Cannot find symbol: %s\n",
+                      p_strtab + p_symtab[sym_index].st_name);
 #endif
             return -1;
         }    
     }
 
     // After the relocation is done, the relocation table can be dumped.
-    cyg_ldr_delete_elf_section( p, r_shndx );
+    cyg_ldr_delete_elf_section(p, r_shndx);
     return 0;
 }