AcessNative/ld-acess_src/elf.c

   1 /*\r
   2  * Acess v0.1\r
   3  * ELF Executable Loader Code\r
   4  */\r
   5 #define DEBUG   0\r
   6 #include <stdlib.h>\r
   7 #include <stdio.h>\r
   8 #include <string.h>\r
   9 #include <unistd.h>\r
  10 #include "common.h"\r
  11 #include "elf.h"\r
  12 \r
  13 #define DEBUG_WARN      1\r
  14 \r
  15 #define MKPTR(_type,_val)       ((_type*)(uintptr_t)(_val))\r
  16 #define PTRMK(_type,_val)       MKPTR(_type,_val)\r
  17 #define PTR(_val)       ((void*)(uintptr_t)(_val))\r
  18 \r
  19 #if DEBUG\r
  20 # define ENTER(...)\r
  21 # define LOG(s, ...)    printf("%s: " s, __func__, __VA_ARGS__)\r
  22 # define LOGS(s)        printf("%s: " s, __func__)\r
  23 # define LEAVE(...)\r
  24 #else\r
  25 # define ENTER(...)\r
  26 # define LOG(...)\r
  27 # define LOGS(...)\r
  28 # define LEAVE(...)\r
  29 #endif\r
  30 \r
  31 // === PROTOTYPES ===\r
  32 void    *Elf_Load(FILE *FP);\r
  33 uintptr_t       Elf_Relocate(void *Base);\r
  34  int    Elf_GetSymbol(void *Base, char *Name, uintptr_t *ret);\r
  35  int    Elf_Int_DoRelocate(uint32_t r_info, uint32_t *ptr, uint32_t addend, Elf32_Sym *symtab, void *Base);\r
  36 uint32_t        Elf_Int_HashString(char *str);\r
  37 \r
  38 // === CODE ===\r
  39 void *Elf_Load(FILE *FP)\r
  40 {\r
  41         Elf32_Ehdr      hdr;\r
  42         Elf32_Phdr      *phtab;\r
  43          int    i, j;\r
  44          int    iPageCount;\r
  45         uint32_t        max, base = -1;\r
  46         uint32_t        addr;\r
  47         uint32_t        baseDiff = 0;\r
  48         \r
  49         ENTER("pFP", FP);\r
  50         \r
  51         // Read ELF Header\r
  52         fread(&hdr, sizeof(hdr), 1, FP);\r
  53         \r
  54         // Check the file type\r
  55         if(hdr.ident[0] != 0x7F || hdr.ident[1] != 'E' || hdr.ident[2] != 'L' || hdr.ident[3] != 'F') {\r
  56                 Warning("Non-ELF File was passed to the ELF loader\n");\r
  57                 LEAVE('n');\r
  58                 return NULL;\r
  59         }\r
  60         \r
  61         // Check for a program header\r
  62         if(hdr.phoff == 0) {\r
  63                 #if DEBUG_WARN\r
  64                 Warning("ELF File does not contain a program header\n");\r
  65                 #endif\r
  66                 LEAVE('n');\r
  67                 return NULL;\r
  68         }\r
  69         \r
  70         // Read Program Header Table\r
  71         phtab = malloc( sizeof(Elf32_Phdr) * hdr.phentcount );\r
  72         if( !phtab ) {\r
  73                 LEAVE('n');\r
  74                 return NULL;\r
  75         }\r
  76         LOG("hdr.phoff = 0x%08x\n", hdr.phoff);\r
  77         fseek(FP, hdr.phoff, SEEK_SET);\r
  78         fread(phtab, sizeof(Elf32_Phdr), hdr.phentcount, FP);\r
  79         \r
  80         // Count Pages\r
  81         iPageCount = 0;\r
  82         LOG("hdr.phentcount = %i\n", hdr.phentcount);\r
  83         for( i = 0; i < hdr.phentcount; i++ )\r
  84         {\r
  85                 // Ignore Non-LOAD types\r
  86                 if(phtab[i].Type != PT_LOAD)\r
  87                         continue;\r
  88                 iPageCount += ((phtab[i].VAddr&0xFFF) + phtab[i].MemSize + 0xFFF) >> 12;\r
  89                 LOG("phtab[%i] = {VAddr:0x%x, MemSize:0x%x}\n", i, phtab[i].VAddr, phtab[i].MemSize);\r
  90         }\r
  91         \r
  92         LOG("iPageCount = %i\n", iPageCount);\r
  93         \r
  94         // Allocate Information Structure\r
  95         //ret = malloc( sizeof(tBinary) + sizeof(tBinaryPage)*iPageCount );\r
  96         // Fill Info Struct\r
  97         //ret->Entry = hdr.entrypoint;\r
  98         //ret->Base = -1;               // Set Base to maximum value\r
  99         //ret->NumPages = iPageCount;\r
 100         //ret->Interpreter = NULL;\r
 101 \r
 102         // Prescan for base and size\r
 103         for( i = 0; i < hdr.phentcount; i ++)\r
 104         {\r
 105                 if( phtab[i].Type != PT_LOAD )\r
 106                         continue;\r
 107                 if( phtab[i].VAddr < base )\r
 108                         base = phtab[i].VAddr;\r
 109                 if( phtab[i].VAddr > max )\r
 110                         max = phtab[i].VAddr;\r
 111         }\r
 112 \r
 113         LOG("base = %08x, max = %08x\n", base, max);\r
 114 \r
 115         if( base == 0 ) {\r
 116                 // Find a nice space (31 address bits allowed)\r
 117                 base = FindFreeRange( max, 31 );\r
 118                 LOG("new base = %08x\n", base);\r
 119                 if( base == 0 ) return NULL;\r
 120                 baseDiff = base;\r
 121         }\r
 122         \r
 123         // Load Pages\r
 124         j = 0;\r
 125         for( i = 0; i < hdr.phentcount; i++ )\r
 126         {\r
 127                 //LOG("phtab[%i].Type = 0x%x", i, phtab[i].Type);\r
 128                 LOG("phtab[%i] = {\n", i);\r
 129                 LOG(" .Type = 0x%08x\n", phtab[i].Type);\r
 130                 LOG(" .Offset = 0x%08x\n", phtab[i].Offset);\r
 131                 LOG(" .VAddr = 0x%08x\n", phtab[i].VAddr);\r
 132                 LOG(" .PAddr = 0x%08x\n", phtab[i].PAddr);\r
 133                 LOG(" .FileSize = 0x%08x\n", phtab[i].FileSize);\r
 134                 LOG(" .MemSize = 0x%08x\n", phtab[i].MemSize);\r
 135                 LOG(" .Flags = 0x%08x\n", phtab[i].Flags);\r
 136                 LOG(" .Align = 0x%08x\n", phtab[i].Align);\r
 137                 LOGS(" }\n");\r
 138                 // Get Interpreter Name\r
 139                 if( phtab[i].Type == PT_INTERP )\r
 140                 {\r
 141                         char *tmp;\r
 142                         //if(ret->Interpreter)  continue;\r
 143                         tmp = malloc(phtab[i].FileSize);\r
 144                         fseek(FP, phtab[i].Offset, SEEK_SET);\r
 145                         fread(tmp, phtab[i].FileSize, 1, FP);\r
 146                         //ret->Interpreter = Binary_RegInterp(tmp);\r
 147                         LOG("Interpreter '%s'\n", tmp);\r
 148                         free(tmp);\r
 149                         continue;\r
 150                 }\r
 151                 // Ignore non-LOAD types\r
 152                 if(phtab[i].Type != PT_LOAD)    continue;\r
 153                 \r
 154                 LOG("phtab[%i] = {VAddr:0x%x,Offset:0x%x,FileSize:0x%x}\n",\r
 155                         i, phtab[i].VAddr+baseDiff, phtab[i].Offset, phtab[i].FileSize);\r
 156                 \r
 157                 addr = phtab[i].VAddr + baseDiff;\r
 158 \r
 159                 if( AllocateMemory( addr, phtab[i].MemSize ) ) {\r
 160                         return NULL;\r
 161                 }\r
 162                 \r
 163                 fseek(FP, phtab[i].Offset, SEEK_SET);\r
 164                 fread( PTRMK(void, addr), phtab[i].FileSize, 1, FP );\r
 165                 memset( PTRMK(char, addr) + phtab[i].FileSize, 0, phtab[i].MemSize - phtab[i].FileSize );\r
 166         }\r
 167         \r
 168         // Clean Up\r
 169         free(phtab);\r
 170         // Return\r
 171         LEAVE('p', base);\r
 172         return PTRMK(void, base);\r
 173 }\r
 174 \r
 175 // --- ELF RELOCATION ---\r
 176 /**\r
 177  * \brief Relocates a loaded ELF Executable\r
 178  */\r
 179 uintptr_t Elf_Relocate(void *Base)\r
 180 {\r
 181         Elf32_Ehdr      *hdr = Base;\r
 182         Elf32_Phdr      *phtab;\r
 183          int    i, j;   // Counters\r
 184         char    *libPath;\r
 185         uint32_t        iRealBase = -1;\r
 186         uintptr_t       iBaseDiff;\r
 187          int    iSegmentCount;\r
 188          int    iSymCount = 0;\r
 189         Elf32_Rel       *rel = NULL;\r
 190         Elf32_Rela      *rela = NULL;\r
 191         uint32_t        *pltgot = NULL;\r
 192         void    *plt = NULL;\r
 193         uint32_t        *ptr;\r
 194          int    relSz=0, relEntSz=8;\r
 195          int    relaSz=0, relaEntSz=8;\r
 196          int    pltSz=0, pltType=0;\r
 197         Elf32_Dyn       *dynamicTab = NULL;     // Dynamic Table Pointer\r
 198         char    *dynstrtab = NULL;      // .dynamic String Table\r
 199         Elf32_Sym       *dynsymtab = NULL;\r
 200          int    bFailed = 0;\r
 201         \r
 202         ENTER("pBase", Base);\r
 203         LOG("Base = %p\n", Base);\r
 204         \r
 205         // Parse Program Header to get Dynamic Table\r
 206         phtab = Base + hdr->phoff;\r
 207         iSegmentCount = hdr->phentcount;\r
 208         for(i = 0; i < iSegmentCount; i ++ )\r
 209         {\r
 210                 // Determine linked base address\r
 211                 if(phtab[i].Type == PT_LOAD && iRealBase > phtab[i].VAddr)\r
 212                         iRealBase = phtab[i].VAddr;\r
 213                 \r
 214                 // Find Dynamic Section\r
 215                 if(phtab[i].Type == PT_DYNAMIC) {\r
 216                         if(dynamicTab) {\r
 217                                 Warning("Elf_Relocate - Multiple PT_DYNAMIC segments\n");\r
 218                                 continue;\r
 219                         }\r
 220                         dynamicTab = MKPTR(void, phtab[i].VAddr);\r
 221                         j = i;  // Save Dynamic Table ID\r
 222                         break;\r
 223                 }\r
 224         }\r
 225         \r
 226         // Check if a PT_DYNAMIC segement was found\r
 227         if(!dynamicTab) {\r
 228                 Warning("Elf_Relocate: No PT_DYNAMIC segment in image, returning\n");\r
 229                 LEAVE('x', hdr->entrypoint);\r
 230                 return hdr->entrypoint;\r
 231         }\r
 232         \r
 233         // Page Align real base\r
 234         iRealBase &= ~0xFFF;\r
 235         \r
 236         LOG("dynamicTab = %p\n", dynamicTab);\r
 237         // Adjust "Real" Base\r
 238         iBaseDiff = (uintptr_t)Base - iRealBase;\r
 239         LOG("iBaseDiff = %p\n", (void*)iBaseDiff);\r
 240         // Adjust Dynamic Table\r
 241         dynamicTab = PTR( (uintptr_t)dynamicTab + iBaseDiff);\r
 242         LOG("dynamicTab = %p\n", dynamicTab);\r
 243 \r
 244         hdr->entrypoint += iBaseDiff;\r
 245         \r
 246         // === Get Symbol table and String Table ===\r
 247         for( j = 0; dynamicTab[j].d_tag != DT_NULL; j++)\r
 248         {\r
 249                 switch(dynamicTab[j].d_tag)\r
 250                 {\r
 251                 // --- Symbol Table ---\r
 252                 case DT_SYMTAB:\r
 253                         dynamicTab[j].d_val += iBaseDiff;\r
 254                         dynsymtab = PTRMK(void, dynamicTab[j].d_val);\r
 255                         hdr->misc.SymTable = dynamicTab[j].d_val;       // Saved in unused bytes of ident\r
 256                         break;\r
 257                 \r
 258                 // --- String Table ---\r
 259                 case DT_STRTAB:\r
 260                         dynamicTab[j].d_val += iBaseDiff;\r
 261                         dynstrtab = PTRMK(void, dynamicTab[j].d_val);\r
 262                         break;\r
 263                 \r
 264                 // --- Hash Table --\r
 265                 case DT_HASH:\r
 266                         dynamicTab[j].d_val += iBaseDiff;\r
 267                         iSymCount = (PTRMK(uint32_t, dynamicTab[j].d_val))[1];\r
 268                         hdr->misc.HashTable = dynamicTab[j].d_val;      // Saved in unused bytes of ident\r
 269                         break;\r
 270                 }\r
 271         }\r
 272 \r
 273 \r
 274         // Alter Symbols to true base\r
 275         for(i = 0; i < iSymCount; i ++)\r
 276         {\r
 277                 dynsymtab[i].nameOfs += (uintptr_t)dynstrtab;\r
 278                 if( dynsymtab[i].shndx == SHN_UNDEF )\r
 279                 {\r
 280                         LOG("Sym '%s' = UNDEF\n", MKPTR(char,dynsymtab[i].name));\r
 281                 }\r
 282                 else\r
 283                 {\r
 284                         dynsymtab[i].value += iBaseDiff;\r
 285                         LOG("Sym '%s' = 0x%x (relocated)\n", MKPTR(char,dynsymtab[i].name), dynsymtab[i].value);\r
 286                 }\r
 287         }\r
 288         \r
 289         // === Add to loaded list (can be imported now) ===\r
 290         Binary_SetReadyToUse( Base );\r
 291 \r
 292         // === Parse Relocation Data ===\r
 293         for( j = 0; dynamicTab[j].d_tag != DT_NULL; j++)\r
 294         {\r
 295                 switch(dynamicTab[j].d_tag)\r
 296                 {\r
 297                 // --- Shared Library Name ---\r
 298                 case DT_SONAME:\r
 299                         LOG(".so Name '%s'\n", dynstrtab + dynamicTab[j].d_val);\r
 300                         break;\r
 301                 // --- Needed Library ---\r
 302                 case DT_NEEDED:\r
 303                         libPath = dynstrtab + dynamicTab[j].d_val;\r
 304                         Binary_LoadLibrary(libPath);\r
 305                         break;\r
 306                 // --- PLT/GOT ---\r
 307                 case DT_PLTGOT: pltgot = (void*)(iBaseDiff+dynamicTab[j].d_val);        break;\r
 308                 case DT_JMPREL: plt = (void*)(iBaseDiff+dynamicTab[j].d_val);   break;\r
 309                 case DT_PLTREL: pltType = dynamicTab[j].d_val;  break;\r
 310                 case DT_PLTRELSZ:       pltSz = dynamicTab[j].d_val;    break;\r
 311                 \r
 312                 // --- Relocation ---\r
 313                 case DT_REL:    rel = (void*)(iBaseDiff + dynamicTab[j].d_val); break;\r
 314                 case DT_RELSZ:  relSz = dynamicTab[j].d_val;    break;\r
 315                 case DT_RELENT: relEntSz = dynamicTab[j].d_val; break;\r
 316                 \r
 317                 case DT_RELA:   rela = (void*)(iBaseDiff + dynamicTab[j].d_val);        break;\r
 318                 case DT_RELASZ: relaSz = dynamicTab[j].d_val;   break;\r
 319                 case DT_RELAENT:        relaEntSz = dynamicTab[j].d_val;        break;\r
 320                 }\r
 321         }\r
 322         \r
 323         // Parse Relocation Entries\r
 324         if(rel && relSz)\r
 325         {\r
 326                 j = relSz / relEntSz;\r
 327                 for( i = 0; i < j; i++ )\r
 328                 {\r
 329                         ptr = (void*)(iBaseDiff + rel[i].r_offset);\r
 330                         if( !Elf_Int_DoRelocate(rel[i].r_info, ptr, *ptr, dynsymtab, Base) ) {\r
 331                                 bFailed = 1;\r
 332                         }\r
 333                 }\r
 334         }\r
 335         // Parse Relocation Entries\r
 336         if(rela && relaSz)\r
 337         {\r
 338                 j = relaSz / relaEntSz;\r
 339                 for( i = 0; i < j; i++ )\r
 340                 {\r
 341                         ptr = (void*)(iBaseDiff + rela[i].r_offset);\r
 342                         if( !Elf_Int_DoRelocate(rel[i].r_info, ptr, rela[i].r_addend, dynsymtab, Base) ) {\r
 343                                 bFailed = 1;\r
 344                         }\r
 345                 }\r
 346         }\r
 347         \r
 348         // === Process PLT (Procedure Linkage Table) ===\r
 349         if(plt && pltSz)\r
 350         {\r
 351                 if(pltType == DT_REL)\r
 352                 {\r
 353                         Elf32_Rel       *pltRel = plt;\r
 354                         j = pltSz / sizeof(Elf32_Rel);\r
 355                         LOG("PLT Rel - plt = %p, pltSz = %i (%i ents)\n", plt, pltSz, j);\r
 356                         for(i = 0; i < j; i++)\r
 357                         {\r
 358                                 ptr = (void*)(iBaseDiff + pltRel[i].r_offset);\r
 359                                 if( !Elf_Int_DoRelocate(pltRel[i].r_info, ptr, *ptr, dynsymtab, Base) ) {\r
 360                                         bFailed = 1;\r
 361                                 }\r
 362                         }\r
 363                 }\r
 364                 else\r
 365                 {\r
 366                         Elf32_Rela      *pltRela = plt;\r
 367                         j = pltSz / sizeof(Elf32_Rela);\r
 368                         LOG("PLT RelA - plt = %p, pltSz = %i (%i ents)\n", plt, pltSz, j);\r
 369                         for(i=0;i<j;i++)\r
 370                         {\r
 371                                 ptr = (void*)(iBaseDiff + pltRela[i].r_offset);\r
 372                                 if( !Elf_Int_DoRelocate(pltRela[i].r_info, ptr, pltRela[i].r_addend, dynsymtab, Base) ) {\r
 373                                         bFailed = 1;\r
 374                                 }\r
 375                         }\r
 376                 }\r
 377         }\r
 378         \r
 379         if(bFailed) {\r
 380                 LEAVE('i', 0);\r
 381                 return 0;\r
 382         }\r
 383         \r
 384         LEAVE('x', hdr->entrypoint);\r
 385         return hdr->entrypoint;\r
 386 }\r
 387 \r
 388 /**\r
 389  * \fn void Elf_Int_DoRelocate(uint32_t r_info, uint32_t *ptr, uint32_t addend, Elf32_Sym *symtab, void *base)\r
 390  * \brief Performs a relocation\r
 391  * \param r_info        Field from relocation entry\r
 392  * \param ptr   Pointer to location of relocation\r
 393  * \param addend        Value to add to symbol\r
 394  * \param symtab        Symbol Table\r
 395  * \param base  Base of loaded binary\r
 396  */\r
 397 int Elf_Int_DoRelocate(uint32_t r_info, uint32_t *ptr, uint32_t addend, Elf32_Sym *symtab, void *base)\r
 398 {\r
 399         uintptr_t       val;\r
 400          int    type = ELF32_R_TYPE(r_info);\r
 401          int    sym = ELF32_R_SYM(r_info);\r
 402         char    *sSymName = PTRMK(char, symtab[sym].name);\r
 403         \r
 404         //LogF("Elf_Int_DoRelocate: (r_info=0x%x, ptr=0x%x, addend=0x%x, .., base=0x%x)\n",\r
 405         //      r_info, ptr, addend, base);\r
 406         \r
 407         switch( type )\r
 408         {\r
 409         // Standard 32 Bit Relocation (S+A)\r
 410         case R_386_32:\r
 411                 if( !Elf_GetSymbol( base, sSymName, &val ) && !Binary_GetSymbol( sSymName, &val ) ) {\r
 412                         Warning("Unable to find symbol '%s'", sSymName);\r
 413                         return 0;\r
 414                 }\r
 415                 LOG("%08x R_386_32 *%p += %p('%s')\n", r_info, ptr, (void*)val, sSymName);\r
 416                 *ptr = val + addend;\r
 417                 break;\r
 418                 \r
 419         // 32 Bit Relocation wrt. Offset (S+A-P)\r
 420         case R_386_PC32:\r
 421                 if( !Elf_GetSymbol( base, sSymName, &val ) && !Binary_GetSymbol( sSymName, &val ) ) {\r
 422                         Warning("Unable to find symbol '%s'", sSymName);\r
 423                         return 0;\r
 424                 }\r
 425                 LOG("%08x R_386_PC32 *%p = 0x%x + %p('%s') - %p\n", r_info, ptr, *ptr, (void*)val, sSymName, ptr );\r
 426                 // TODO: Check if it needs the true value of ptr or the compiled value\r
 427                 // NOTE: Testing using true value\r
 428                 *ptr = val + addend - (uintptr_t)ptr;\r
 429                 break;\r
 430 \r
 431         // Absolute Value of a symbol (S)\r
 432         case R_386_GLOB_DAT:\r
 433                 if( !Elf_GetSymbol( base, sSymName, &val ) && !Binary_GetSymbol( sSymName, &val ) ) {\r
 434                         Warning("Unable to find symbol '%s'", sSymName);\r
 435                         return 0; \r
 436                 }\r
 437                 LOG("%08x R_386_GLOB_DAT *%p = 0x%x(%s)\n", r_info, ptr, (unsigned int)val, sSymName);\r
 438                 *ptr = val;\r
 439                 break;\r
 440         \r
 441         // Absolute Value of a symbol (S)\r
 442         case R_386_JMP_SLOT:\r
 443                 if( !Elf_GetSymbol( base, sSymName, &val ) && !Binary_GetSymbol( sSymName, &val ) ) {\r
 444                         Warning("Unable to find symbol '%s'", sSymName);\r
 445                         return 0;\r
 446                 }\r
 447                 LOG("%08x R_386_JMP_SLOT *%p = 0x%x (%s)\n", r_info, ptr, (unsigned int)val, sSymName);\r
 448                 *ptr = val;\r
 449                 break;\r
 450 \r
 451         // Base Address (B+A)\r
 452         case R_386_RELATIVE:\r
 453                 LOG("%08x R_386_RELATIVE *%p = %p + 0x%x\n", r_info, ptr, base, addend);\r
 454                 *ptr = (uintptr_t)base + addend;\r
 455                 break;\r
 456                 \r
 457         default:\r
 458                 LOG("Rel %p: 0x%x,%i\n", ptr, sym, type);\r
 459                 break;\r
 460         }\r
 461         return 1;\r
 462 }\r
 463 \r
 464 /**\r
 465  * \fn int Elf_GetSymbol(void *Base, char *name, uintptr_t *ret)\r
 466  * \brief Get a symbol from the loaded binary\r
 467  */\r
 468 int Elf_GetSymbol(void *Base, char *Name, uintptr_t *ret)\r
 469 {\r
 470         Elf32_Ehdr      *hdr = (void*)Base;\r
 471         Elf32_Sym       *symtab;\r
 472          int    nbuckets = 0;\r
 473          int    iSymCount = 0;\r
 474          int    i;\r
 475         uint32_t        *pBuckets;\r
 476         uint32_t        *pChains;\r
 477         uint32_t        iNameHash;\r
 478 \r
 479         if(!Base)       return 0;\r
 480 \r
 481         pBuckets = PTR(hdr->misc.HashTable);\r
 482         symtab = PTR(hdr->misc.SymTable);\r
 483         \r
 484         nbuckets = pBuckets[0];\r
 485         iSymCount = pBuckets[1];\r
 486         pBuckets = &pBuckets[2];\r
 487         pChains = &pBuckets[ nbuckets ];\r
 488         \r
 489         // Get hash\r
 490         iNameHash = Elf_Int_HashString(Name);\r
 491         iNameHash %= nbuckets;\r
 492 \r
 493         // Check Bucket\r
 494         i = pBuckets[ iNameHash ];\r
 495         if(symtab[i].shndx != SHN_UNDEF && strcmp(MKPTR(char,symtab[i].name), Name) == 0) {\r
 496                 if(ret) *ret = symtab[ i ].value;\r
 497                 return 1;\r
 498         }\r
 499         \r
 500         // Walk Chain\r
 501         while(pChains[i] != STN_UNDEF)\r
 502         {\r
 503                 i = pChains[i];\r
 504                 if(symtab[i].shndx != SHN_UNDEF && strcmp(MKPTR(char,symtab[i].name), Name) == 0) {\r
 505                         if(ret) *ret = symtab[ i ].value;\r
 506                         return 1;\r
 507                 }\r
 508         }\r
 509         return 0;\r
 510 }\r
 511 \r
 512 /**\r
 513  * \fn uint32_t Elf_Int_HashString(char *str)\r
 514  * \brief Hash a string in the ELF format\r
 515  * \param str   String to hash\r
 516  * \return Hash value\r
 517  */\r
 518 uint32_t Elf_Int_HashString(char *str)\r
 519 {\r
 520         uint32_t        h = 0, g;\r
 521         while(*str)\r
 522         {\r
 523                 h = (h << 4) + *str++;\r
 524                 if( (g = h & 0xf0000000) )\r
 525                         h ^= g >> 24;\r
 526                 h &= ~g;\r
 527         }\r
 528         return h;\r
 529 }\r