rom/dos/internalloadseg_elf.c

   1 /*
   2     Copyright © 1995-2016, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Code to dynamically load ELF executables
   6     Lang: english
   7 */
   8
   9 #define DATTR(x)
  10
  11 #include <aros/asmcall.h>
  12 #include <aros/debug.h>
  13 #include <aros/macros.h>
  14 #include <exec/memory.h>
  15 #include <dos/elf.h>
  16 #include <dos/dosasl.h>
  17 #include <libraries/debug.h>
  18 #include <resources/processor.h>
  19 #include <proto/dos.h>
  20 #include <proto/arossupport.h>
  21 #include <proto/debug.h>
  22 #include <proto/exec.h>
  23
  24 #include <string.h>
  25 #include <stddef.h>
  26
  27 #include "internalloadseg.h"
  28 #include "dos_intern.h"
  29 #include "include/loadseg.h"
  30
  31 struct hunk
  32 {
  33     ULONG size;
  34     BPTR  next;
  35     char  data[0];
  36 } __attribute__((packed));
  37
  38 #define BPTR2HUNK(bptr) ((struct hunk *)((void *)bptr - offsetof(struct hunk, next)))
  39 #define HUNK2BPTR(hunk) MKBADDR(&hunk->next)
  40
  41 #define LOADSEG_SMALL_READ  2048 /* Size adjusted by profiling in Callgrind */
  42
  43 /* [S]mall [R]eads [Buffer]
  44  *
  45  * Due to a fact that Seek flushes buffers, FRead that is used to do small reads
  46  * cannot use the buffer. The problem is visible with C++ executables that
  47  * have a big number of small sections and thus do many (in tens of thousands
  48  * for Odyssey) very small reads.
  49  *
  50  * */
  51 struct SRBuffer
  52 {
  53     ULONG   srb_FileOffset;
  54     APTR    srb_Buffer;
  55 };
  56
  57 static int elf_read_block
  58 (
  59     BPTR               file,
  60     ULONG              offset,
  61     APTR               buffer,
  62     ULONG              size,
  63     SIPTR              *funcarray,
  64     struct SRBuffer    *srb,
  65     struct DosLibrary  *DOSBase
  66 )
  67 {
  68     D(bug("[ELF Loader] elf_read_block (offset=%d, size=%d)\n", offset, size));
  69
  70     if (size <= LOADSEG_SMALL_READ && (offset >= srb->srb_FileOffset) &&
  71             ((offset + size) <= (srb->srb_FileOffset + LOADSEG_SMALL_READ)) &&
  72             srb->srb_Buffer != NULL)
  73     {
  74         CopyMem(srb->srb_Buffer + (offset - srb->srb_FileOffset), buffer, size);
  75         return 0;
  76     }
  77     else
  78     {
  79         if (ilsSeek(file, offset, OFFSET_BEGINNING) < 0)
  80             return 1;
  81
  82         if (size <= LOADSEG_SMALL_READ)
  83         {
  84             if (srb->srb_Buffer == NULL)
  85                 srb->srb_Buffer = AllocMem(LOADSEG_SMALL_READ, MEMF_ANY);
  86
  87             srb->srb_FileOffset = offset;
  88
  89             /* Fill the buffer */
  90             read_block(file, srb->srb_Buffer, LOADSEG_SMALL_READ, funcarray, DOSBase);
  91             /* Re-read, now srb will be used */
  92             return elf_read_block(file, offset, buffer, size, funcarray, srb, DOSBase);
  93         }
  94         else
  95         {
  96             return read_block(file, buffer, size, funcarray, DOSBase);
  97         }
  98     }
  99 }
 100
 101 static void *load_block
 102 (
 103     BPTR               file,
 104     ULONG              offset,
 105     ULONG              size,
 106     SIPTR             *funcarray,
 107     struct SRBuffer   *srb,
 108     struct DosLibrary *DOSBase
 109 )
 110 {
 111     D(bug("[ELF Loader] Load Block\n"));
 112     D(bug("[ELF Loader] (size=%d)\n",size));
 113     D(bug("[ELF Loader] (funcarray=0x%x)\n",funcarray));
 114     D(bug("[ELF Loader] (funcarray[1]=0x%x)\n",funcarray[1]));
 115     void *block = ilsAllocMem(size, MEMF_ANY);
 116     if (block)
 117     {
 118         if (!elf_read_block(file, offset, block, size, funcarray, srb, DOSBase))
 119             return block;
 120
 121         ilsFreeMem(block, size);
 122     }
 123     else
 124         SetIoErr(ERROR_NO_FREE_STORE);
 125
 126     return NULL;
 127 }
 128
 129 static ULONG read_shnum(BPTR file, struct elfheader *eh, SIPTR *funcarray, struct SRBuffer *srb, struct DosLibrary *DOSBase)
 130 {
 131     ULONG shnum = eh->shnum;
 132
 133     /* the ELF header only uses 16 bits to store the count of section headers,
 134      * so it can't handle more than 65535 headers. if the count is 0, and an
 135      * offset is defined, then the real count can be found in the first
 136      * section header (which always exists).
 137      *
 138      * similarly, if the string table index is SHN_XINDEX, then the actual
 139      * index is found in the first section header also.
 140      *
 141      * see the System V ABI 2001-04-24 draft for more details.
 142      */
 143     if (eh->shnum == 0)
 144     {
 145         struct sheader sh;
 146
 147         if (eh->shoff == 0) {
 148             D(bug("[ELF Loader] No section header\n"));
 149             SetIoErr(ERROR_NOT_EXECUTABLE);
 150             return 0;
 151         }
 152
 153         if (elf_read_block(file, eh->shoff, &sh, sizeof(sh), funcarray, srb, DOSBase))
 154             return 0;
 155
 156         /* wider section header count is in the size field */
 157         shnum = sh.size;
 158
 159         /* sanity, if they're still invalid then this isn't elf */
 160         if (shnum == 0) {
 161             D(bug("[ELF Loader] Empty section header\n"));
 162             SetIoErr(ERROR_NOT_EXECUTABLE);
 163         }
 164     }
 165
 166     return shnum;
 167 }
 168
 169 static int load_header(BPTR file, struct elfheader *eh, SIPTR *funcarray, struct SRBuffer *srb, struct DosLibrary *DOSBase)
 170 {
 171     if (elf_read_block(file, 0, eh, sizeof(struct elfheader), funcarray, srb, DOSBase))
 172         return 0;
 173
 174     if (eh->ident[0] != 0x7f || eh->ident[1] != 'E'  ||
 175         eh->ident[2] != 'L'  || eh->ident[3] != 'F') {
 176         D(bug("[ELF Loader] Not an ELF object\n"));
 177         SetIoErr(ERROR_NOT_EXECUTABLE);
 178         return 0;
 179     }
 180     D(bug("[ELF Loader] ELF object\n"));
 181
 182     /* WANT_CLASS should be defined for your target */
 183     if (eh->ident[EI_CLASS]   != AROS_ELF_CLASS  ||
 184         eh->ident[EI_VERSION] != EV_CURRENT      ||
 185         eh->type              != ET_REL          ||
 186         eh->ident[EI_DATA]    != AROS_ELF_DATA   ||
 187         eh->machine           != AROS_ELF_MACHINE)
 188     {
 189         D(bug("[ELF Loader] Object is of wrong type\n"));
 190         D(bug("[ELF Loader] EI_CLASS   is %d - should be %d\n", eh->ident[EI_CLASS]  , AROS_ELF_CLASS ));
 191         D(bug("[ELF Loader] EI_VERSION is %d - should be %d\n", eh->ident[EI_VERSION], EV_CURRENT     ));
 192         D(bug("[ELF Loader] type       is %d - should be %d\n", eh->type             , ET_REL         ));
 193         D(bug("[ELF Loader] EI_DATA    is %d - should be %d\n", eh->ident[EI_DATA]   , AROS_ELF_DATA  ));
 194         D(bug("[ELF Loader] machine    is %d - should be %d\n", eh->machine          , AROS_ELF_MACHINE));
 195
 196         SetIoErr(ERROR_NOT_EXECUTABLE);
 197         return 0;
 198     }
 199
 200     return 1;
 201 }
 202
 203 static int __attribute__ ((noinline)) load_hunk
 204 (
 205     BPTR                 file,
 206     BPTR               **next_hunk_ptr,
 207     struct sheader      *sh,
 208     CONST_STRPTR         strtab,
 209     SIPTR               *funcarray,
 210     BOOL                 do_align,
 211     struct SRBuffer     *srb,
 212     struct DosLibrary   *DOSBase
 213 )
 214 {
 215     struct hunk *hunk;
 216     ULONG  hunk_size;
 217     ULONG  memflags = 0;
 218
 219     if (!sh->size)
 220         return 1;
 221
 222     /* The size of the hunk is the size of the section, plus
 223        the size of the hunk structure, plus the size of the alignment (if necessary)*/
 224     hunk_size = sh->size + sizeof(struct hunk);
 225
 226     if (do_align)
 227     {
 228          hunk_size += sh->addralign;
 229
 230          /* Also create space for a trampoline, if necessary */
 231          if (sh->flags & SHF_EXECINSTR)
 232              hunk_size += sizeof(struct FullJumpVec);
 233     }
 234
 235     if (strtab) {
 236         CONST_STRPTR nameext;
 237
 238         nameext = strrchr(strtab + sh->name, '.');
 239         if (nameext) {
 240             if (strcmp(nameext, ".MEMF_CHIP")==0) {
 241                 memflags |= MEMF_CHIP;
 242             } else if (strcmp(nameext, ".MEMF_LOCAL")==0) {
 243                 memflags |= MEMF_LOCAL;
 244             } else if (strcmp(nameext, ".MEMF_KICK")==0) {
 245                 memflags |= MEMF_KICK;
 246             } else if (strcmp(nameext, ".MEMF_FAST")==0) {
 247                 memflags |= MEMF_FAST;
 248             } else if (strcmp(nameext, ".MEMF_PUBLIC")==0) {
 249                 memflags |= MEMF_PUBLIC;
 250             }
 251         }
 252     }
 253
 254     hunk = ilsAllocMem(hunk_size, memflags | MEMF_PUBLIC | (sh->type == SHT_NOBITS ? MEMF_CLEAR : 0));
 255     if (hunk)
 256     {
 257         hunk->next = 0;
 258         hunk->size = hunk_size;
 259
 260         /* In case we are required to honour alignment, and If this section contains
 261            executable code, create a trampoline to its beginning, so that even if the
 262            alignment requirements make the actual code go much after the end of the
 263            hunk structure, the code can still be reached in the usual way.  */
 264         if (do_align)
 265         {
 266             if (sh->flags & SHF_EXECINSTR)
 267             {
 268                 sh->addr = (char *)AROS_ROUNDUP2
 269                 (
 270                     (IPTR)hunk->data + sizeof(struct FullJumpVec), sh->addralign
 271                 );
 272                 __AROS_SET_FULLJMP((struct FullJumpVec *)hunk->data, sh->addr);
 273             }
 274             else
 275                 sh->addr = (char *)AROS_ROUNDUP2((IPTR)hunk->data, sh->addralign);
 276         }
 277         else
 278             sh->addr = hunk->data;
 279
 280         /* Link the previous one with the new one */
 281         BPTR2HUNK(*next_hunk_ptr)->next = HUNK2BPTR(hunk);
 282
 283         D(bug("[dos] hunk @ %p, size=%08x, addr @ %p\n", hunk, hunk->size, sh->addr));
 284
 285         /* Update the pointer to the previous one, which is now the current one */
 286         *next_hunk_ptr = &hunk->next;
 287
 288         if (sh->type != SHT_NOBITS)
 289             return !elf_read_block(file, sh->offset, sh->addr, sh->size, funcarray, srb, DOSBase);
 290
 291         return 1;
 292
 293     }
 294
 295     SetIoErr(ERROR_NO_FREE_STORE);
 296
 297     return 0;
 298 }
 299
 300 static int relocate
 301 (
 302     struct elfheader  *eh,
 303     struct sheader    *sh,
 304     ULONG              shrel_idx,
 305     struct sheader    *symtab_shndx,
 306     struct DosLibrary *DOSBase
 307 )
 308 {
 309     struct sheader *shrel    = &sh[shrel_idx];
 310     struct sheader *shsymtab = &sh[shrel->link];
 311     struct sheader *toreloc  = &sh[shrel->info];
 312
 313     struct symbol *symtab   = (struct symbol *)shsymtab->addr;
 314     struct relo   *rel      = (struct relo *)shrel->addr;
 315
 316     /*
 317      * Ignore relocs if the target section has no allocation. that can happen
 318      * eg. with a .debug PROGBITS and a .rel.debug section
 319      */
 320     if (!(toreloc->flags & SHF_ALLOC))
 321         return 1;
 322
 323     ULONG numrel = shrel->size / shrel->entsize;
 324     ULONG i;
 325
 326     for (i=0; i<numrel; i++, rel++)
 327     {
 328         struct symbol *sym;
 329         ULONG *p;
 330         IPTR s;
 331         ULONG shindex;
 332
 333 #ifdef __arm__
 334         /*
 335          * R_ARM_V4BX are actually special marks for the linker.
 336          * They even never have a target (shindex == SHN_UNDEF),
 337          * so we simply ignore them before doing any checks.
 338          */
 339         if (ELF_R_TYPE(rel->info) == R_ARM_V4BX)
 340             continue;
 341 #endif
 342
 343         sym = &symtab[ELF_R_SYM(rel->info)];
 344         p = toreloc->addr + rel->offset;
 345
 346         if (sym->shindex != SHN_XINDEX)
 347             shindex = sym->shindex;
 348
 349         else {
 350             if (symtab_shndx == NULL) {
 351                 D(bug("[ELF Loader] got symbol with shndx 0xfff, but there's no symtab shndx table\n"));
 352                 SetIoErr(ERROR_BAD_HUNK);
 353                 return 0;
 354             }
 355             shindex = ((ULONG *)symtab_shndx->addr)[ELF_R_SYM(rel->info)];
 356         }
 357
 358         DB2(bug("[ELF Loader] Processing symbol %s\n", sh[shsymtab->link].addr + sym->name));
 359
 360         switch (shindex)
 361         {
 362
 363             case SHN_COMMON:
 364                 D(bug("[ELF Loader] COMMON symbol '%s'\n",
 365                       (STRPTR)sh[shsymtab->link].addr + sym->name));
 366                       SetIoErr(ERROR_BAD_HUNK);
 367
 368                 return 0;
 369
 370             case SHN_ABS:
 371                 s = sym->value;
 372                 break;
 373
 374             case SHN_UNDEF:
 375                 if (ELF_R_TYPE(rel->info) != 0) {
 376                     D(bug("[ELF Loader] Undefined symbol '%s'\n",
 377                       (STRPTR)sh[shsymtab->link].addr + sym->name));
 378                     SetIoErr(ERROR_BAD_HUNK);
 379                     return 0;
 380                 }
 381                 /* fall through */
 382
 383             default:
 384                 s = (IPTR)sh[shindex].addr + sym->value;
 385         }
 386
 387         switch (ELF_R_TYPE(rel->info))
 388         {
 389             #if defined(__i386__)
 390
 391             case R_386_32: /* 32bit absolute */
 392                 *p += s;
 393                 break;
 394
 395             case R_386_PC32: /* 32bit PC relative */
 396                 *p += s - (ULONG)p;
 397                 break;
 398
 399             case R_386_NONE:
 400                 break;
 401
 402             #elif defined(__x86_64__)
 403             case R_X86_64_64: /* 64bit direct/absolute */
 404                 *(UQUAD *)p = s + rel->addend;
 405                 break;
 406
 407             case R_X86_64_PC32: /* PC relative 32 bit signed */
 408                 *(ULONG *)p = s + rel->addend - (IPTR) p;
 409                 break;
 410
 411             case R_X86_64_32:
 412                 *(ULONG *)p = (UQUAD)s + (UQUAD)rel->addend;
 413                 break;
 414
 415             case R_X86_64_32S:
 416                 *(LONG *)p = (QUAD)s + (QUAD)rel->addend;
 417                 break;
 418
 419             case R_X86_64_NONE: /* No reloc */
 420                 break;
 421
 422             #elif defined(__mc68000__)
 423
 424             case R_68K_32:
 425                 *p = s + rel->addend;
 426                 break;
 427
 428             case R_68K_16:
 429                 *(UWORD *)p = s + rel->addend;
 430                 break;
 431
 432             case R_68K_8:
 433                 *(UBYTE *)p = s + rel->addend;
 434                 break;
 435
 436             case R_68K_PC32:
 437                 *p = s + rel->addend - (ULONG)p;
 438                 break;
 439
 440             case R_68K_PC16:
 441                 *(UWORD *)p = s + rel->addend - (ULONG)p;
 442                 break;
 443
 444             case R_68K_PC8:
 445                 *(UBYTE *)p = s + rel->addend - (ULONG)p;
 446                 break;
 447
 448             case R_68K_NONE:
 449                 break;
 450
 451             #elif defined(__ppc__) || defined(__powerpc__)
 452
 453             case R_PPC_ADDR32:
 454                 *p = s + rel->addend;
 455                 break;
 456
 457             case R_PPC_ADDR16_LO:
 458                 {
 459                     unsigned short *c = (unsigned short *) p;
 460                     *c = (s + rel->addend) & 0xffff;
 461                 }
 462                 break;
 463
 464             case R_PPC_ADDR16_HA:
 465                 {
 466                     unsigned short *c = (unsigned short *) p;
 467                     ULONG temp = s + rel->addend;
 468                     *c = temp >> 16;
 469                     if ((temp & 0x8000) != 0)
 470                         (*c)++;
 471                 }
 472                 break;
 473
 474             case R_PPC_REL16_LO:
 475                 {
 476                     unsigned short *c = (unsigned short *) p;
 477                     *c = (s + rel->addend - (ULONG) p) & 0xffff;
 478                 }
 479                 break;
 480
 481             case R_PPC_REL16_HA:
 482                 {
 483                     unsigned short *c = (unsigned short *) p;
 484                     ULONG temp = s + rel->addend - (ULONG) p;
 485                     *c = temp >> 16;
 486                     if ((temp & 0x8000) != 0)
 487                         (*c)++;
 488                 }
 489                 break;
 490
 491             case R_PPC_REL24:
 492                 *p &= ~0x3fffffc;
 493                 *p |= (s + rel->addend - (ULONG) p) & 0x3fffffc;
 494                 break;
 495
 496             case R_PPC_REL32:
 497                 *p = s + rel->addend - (ULONG) p;
 498                 break;
 499
 500             case R_PPC_NONE:
 501                 break;
 502
 503             #elif defined(__arm__)
 504             case R_ARM_CALL:
 505             case R_ARM_JUMP24:
 506             case R_ARM_PC24:
 507             case R_ARM_PREL31:
 508             {
 509                 /* On ARM the 24 bit offset is shifted by 2 to the right */
 510                 signed long offset = (*p & 0x00ffffff) << 2;
 511                 /* If highest bit set, make offset negative */
 512                 if (offset & 0x02000000)
 513                     offset -= 0x04000000;
 514
 515                 if (offset >= 0x02000000 ||
 516                         offset <= -0x02000000)
 517                 {
 518                         bug("[ELF Loader] Relocation type %d %d out of range!\n", i, ELF_R_TYPE(rel->info));
 519                         SetIoErr(ERROR_BAD_HUNK);
 520                         return 0;
 521                 }
 522                 offset += s - (ULONG)p;
 523
 524                 offset >>= 2;
 525                 *p &= 0xff000000;
 526                 *p |= offset & 0x00ffffff;
 527             }
 528             break;
 529
 530             case R_ARM_THM_CALL:
 531             case R_ARM_THM_JUMP24:
 532             {
 533                 ULONG upper,lower,sign,j1,j2;
 534                 LONG offset;
 535
 536                 upper = *((UWORD *)p);
 537                 lower = *((UWORD *)p+1);
 538
 539                 sign = (upper >> 10) & 1;
 540                 j1 = (lower >> 13) & 1;
 541                 j2 = (lower >> 11) & 1;
 542
 543                 offset = (sign << 24) | ((~(j1 ^ sign) & 1) << 23) |
 544                                 ((~(j2 ^ sign) & 1) << 22) |
 545                                 ((upper & 0x03ff) << 12) |
 546                                 ((lower & 0x07ff) << 1);
 547
 548                 if (offset & 0x01000000)
 549                         offset -= 0x02000000;
 550
 551                 if (offset >= 0x01000000 ||
 552                         offset <= -0x01000000)
 553                 {
 554                         bug("[ELF Loader] Relocation type %d %d out of range!\n", i, ELF_R_TYPE(rel->info));
 555                         SetIoErr(ERROR_BAD_HUNK);
 556                         return 0;
 557                 }
 558                 offset += s - (ULONG)p;
 559
 560                 sign = (offset >> 24) & 1;
 561                 j1 = sign ^ (~(offset >> 23) & 1);
 562                 j2 = sign ^ (~(offset >> 22) & 1);
 563
 564                 *(UWORD *)p = (UWORD)((upper & 0xf800) | (sign << 10) |
 565                                 ((offset >> 12) & 0x03ff));
 566                 *((UWORD *)p + 1) = (UWORD)((lower & 0xd000) |
 567                                 (j1 << 13) | (j2 << 11) | ((offset >> 1) & 0x07ff));
 568
 569             }
 570             break;
 571
 572             case R_ARM_THM_MOVW_ABS_NC:
 573             case R_ARM_THM_MOVT_ABS:
 574             {
 575                 ULONG upper,lower;
 576                 LONG offset;
 577
 578                 upper = *((UWORD *)p);
 579                 lower = *((UWORD *)p+1);
 580
 581                 offset = ((upper & 0x000f) << 12) |
 582                                 ((upper & 0x0400) << 1) |
 583                                 ((lower & 0x7000) >> 4) |
 584                                 (lower & 0x00ff);
 585
 586                 offset = (offset ^ 0x8000) - 0x8000;
 587
 588                 offset += s;
 589
 590                 if (ELF_R_TYPE(rel->info) == R_ARM_THM_MOVT_ABS)
 591                         offset >>= 16;
 592
 593                 *(UWORD *)p = (UWORD)((upper & 0xfbf0) |
 594                                 ((offset & 0xf000) >> 12) |
 595                                 ((offset & 0x0800) >> 1));
 596                 *((UWORD *)p + 1) = (UWORD)((lower & 0x8f00) |
 597                                 ((offset & 0x0700)<< 4) |
 598                                 (offset & 0x00ff));
 599             }
 600             break;
 601
 602             case R_ARM_MOVW_ABS_NC:
 603             case R_ARM_MOVT_ABS:
 604             {
 605                 signed long offset = *p;
 606                 offset = ((offset & 0xf0000) >> 4) | (offset & 0xfff);
 607                 offset = (offset ^ 0x8000) - 0x8000;
 608
 609                 offset += s;
 610
 611                 if (ELF_R_TYPE(rel->info) == R_ARM_MOVT_ABS)
 612                     offset >>= 16;
 613
 614                 *p &= 0xfff0f000;
 615                 *p |= ((offset & 0xf000) << 4) | (offset & 0x0fff);
 616             }
 617             break;
 618
 619             case R_ARM_TARGET2: /* maps to R_ARM_ABS32 under EABI for AROS*/
 620             case R_ARM_TARGET1: /* use for constructors/destructors; maps to
 621                                    R_ARM_ABS32 */
 622             case R_ARM_ABS32:
 623                 *p += s;
 624                 break;
 625
 626             case R_ARM_NONE:
 627                 break;
 628
 629             #else
 630             #    error Your architecture is not supported
 631             #endif
 632
 633             default:
 634                 D(bug("[ELF Loader] Unrecognized relocation type %d %d\n", i, ELF_R_TYPE(rel->info)));
 635                 SetIoErr(ERROR_BAD_HUNK);
 636                 return 0;
 637         }
 638     }
 639
 640     return 1;
 641 }
 642
 643 #ifdef __arm__
 644
 645 /*
 646  * On ARM < v6 all LONG accesses must be LONG-aligned
 647  * TODO: This is useful and can be moved to some public include file.
 648  */
 649 #if (__ARM_ARCH__ > 5)
 650
 651 #define READLONG_UNALIGNED(src) src
 652
 653 #else
 654
 655 static inline ULONG readlong_unaligned(ULONG *src)
 656 {
 657     ULONG res, tmp;
 658
 659     asm volatile(
 660         "ldrb   %0, [%2, #0]\n\t"
 661         "ldrb   %1, [%2, #1]\n\t"
 662         "orr    %0, %0, %1, lsl #8\n\t"
 663         "ldrb   %1, [%2, #2]\n\t"
 664         "orr    %0, %0, %1, lsl #16\n\t"
 665         "ldrb   %1, [%2, #3]\n\t"
 666         "orr    %0, %0, %1, lsl #24"
 667         :"=&r"(res), "=&r"(tmp) : "r"(src)
 668     );
 669
 670     return res;
 671 }
 672
 673 #define READLONG_UNALIGNED(src) readlong_unaligned(&src);
 674 #endif
 675
 676 /*
 677  * This code parses special .ARM.Attributes section and
 678  * extracts system requirements from it. Things like float ABI,
 679  * minimum CPU and FPU version are described there.
 680  */
 681
 682 static UBYTE arm_cpus[] =
 683 {
 684     CPUFAMILY_ARM_3,
 685     CPUFAMILY_ARM_4,
 686     CPUFAMILY_ARM_4T,
 687     CPUFAMILY_ARM_5T,
 688     CPUFAMILY_ARM_5TE,
 689     CPUFAMILY_ARM_5TEJ,
 690     CPUFAMILY_ARM_6,
 691     CPUFAMILY_ARM_6,
 692     CPUFAMILY_ARM_6, /* 6KZ  */
 693     CPUFAMILY_ARM_6, /* 6T2  */
 694     CPUFAMILY_ARM_6, /* 6K   */
 695     CPUFAMILY_ARM_7,
 696     CPUFAMILY_ARM_6, /* 6-M  */
 697     CPUFAMILY_ARM_6, /* 6S-M */
 698     CPUFAMILY_ARM_7  /* 7E-M */
 699 };
 700
 701 static BOOL ARM_ParseAttrs(UBYTE *data, ULONG len, struct DosLibrary *DOSBase)
 702 {
 703     struct attrs_section *attrs;
 704
 705     if (data[0] != ATTR_VERSION_CURRENT)
 706     {
 707         DATTR(bug("[ELF.ARM] Unknown attributes version: 0x%02\n", data[0]));
 708         return FALSE;
 709     }
 710
 711     attrs = (void *)data + 1;
 712     while (len > 0)
 713     {
 714         ULONG attrs_size = READLONG_UNALIGNED(attrs->size);
 715
 716         if (!strcmp(attrs->vendor, "aeabi"))
 717         {
 718             struct attrs_subsection *aeabi_attrs = (void *)attrs->vendor + 6;
 719             ULONG aeabi_len = attrs_size - 10;
 720
 721             DATTR(bug("[ELF.ARM] Found aeabi attributes @ 0x%p (length %u)\n", aeabi_attrs, aeabi_len));
 722
 723             while (aeabi_len > 0)
 724             {
 725                 ULONG aeabi_attrs_size = READLONG_UNALIGNED(aeabi_attrs->size);
 726
 727                 if (aeabi_attrs->tag == Tag_File)
 728                 {
 729                     UBYTE *file_subsection = (void *)aeabi_attrs + sizeof(struct attrs_subsection);
 730                     UBYTE file_len = aeabi_attrs_size - sizeof(struct attrs_subsection);
 731
 732                     DATTR(bug("[ELF.ARM] Found file-wide attributes @ 0x%p (length %u)\n", file_subsection, file_len));
 733
 734                     while (file_len > 0)
 735                     {
 736                         UBYTE tag, shift;
 737                         ULONG val = 0;
 738
 739                         tag = *file_subsection++;
 740                         file_len--;
 741
 742                         if (file_len == 0)
 743                         {
 744                             DATTR(bug("[ELF.ARM] Mailformed attribute tag %d (no data)\n", tag));
 745                             return FALSE;
 746                         }
 747
 748                         switch (tag)
 749                         {
 750                         case Tag_CPU_raw_name:
 751                         case Tag_CPU_name:
 752                         case Tag_compatibility:
 753                         case Tag_also_compatible_with:
 754                         case Tag_conformance:
 755                             /* These two are NULL-terminated strings. Just skip. */
 756                             while (file_len)
 757                             {
 758                                 file_len--;
 759                                 if (*file_subsection++ == 0)
 760                                     break;
 761                             }
 762                             break;
 763
 764                         default:
 765                             /* Read ULEB128 value */
 766                             shift = 0;
 767                             while (file_len)
 768                             {
 769                                 UBYTE byte;
 770
 771                                 byte = *file_subsection++;
 772                                 file_len--;
 773
 774                                 val |= (byte & 0x7F) << shift;
 775                                 if (!(byte & 0x80))
 776                                     break;
 777
 778                                 shift += 7;
 779                             }
 780                         }
 781
 782                         switch (tag)
 783                         {
 784                         case Tag_CPU_arch:
 785                             DATTR(bug("[ELF.ARM] ARM CPU architecture set to %d\n", val));
 786
 787                             if (val > ELF_CPU_ARMv7EM)
 788                             {
 789                                 DATTR(bug("[ELF.ARM] Unknown CPU tag value (%d)\n", val));
 790                                 return FALSE;
 791                             }
 792
 793                             if (arm_cpus[val] > IDosBase(DOSBase)->arm_Arch)
 794                             {
 795                                 DATTR(bug("[ELF.ARM] CPU Requirements too high (system %d, file %d)\n", IDosBase(DOSBase)->arm_Arch, arm_cpus[val]));
 796                                 return FALSE;
 797                             }
 798                             break;
 799
 800                         case Tag_FP_arch:
 801                             DATTR(bug("[ELF.ARM] ARM FPU architecture set to %d\n", val));
 802
 803                             switch (val)
 804                             {
 805                             case ELF_FP_None:
 806                                  break;
 807
 808                             case ELF_FP_v1:
 809                             case ELF_FP_v2:
 810                                 if (!IDosBase(DOSBase)->arm_VFP)
 811                                 {
 812                                     DATTR(bug("[ELF.ARM] VFP required but missing\n"));
 813                                     return FALSE;
 814                                 }
 815                                 break;
 816
 817                             case ELF_FP_v3:
 818                             case ELF_FP_v3_Short:
 819                                 if (!IDosBase(DOSBase)->arm_VFP_v3)
 820                                 {
 821                                     DATTR(bug("[ELF.ARM] VFPv3 required but missing\n"));
 822                                     return FALSE;
 823                                 }
 824                                 break;
 825
 826                             default:
 827                                 /* This includes VFPv4 for now */
 828                                 DATTR(bug("[ELF.ARM] VFP %d required -- unsupported\n", val));
 829                                 return FALSE;
 830                             }
 831
 832                             break;
 833                         }
 834                     }
 835
 836                     /* We allow to execute only files which contain attributes section */
 837                     return TRUE;
 838                 }
 839                 aeabi_attrs = (void *)aeabi_attrs + aeabi_attrs_size;
 840                 aeabi_len -= aeabi_attrs_size;
 841             }
 842
 843             return FALSE;
 844         }
 845         attrs = (void *)attrs + attrs_size;
 846         len -= attrs_size;
 847     }
 848     return FALSE;
 849 }
 850
 851 #endif
 852
 853 BPTR InternalLoadSeg_ELF
 854 (
 855     BPTR               file,
 856     BPTR               table __unused,
 857     SIPTR             *funcarray,
 858     LONG              *stack __unused,
 859     struct DosLibrary *DOSBase
 860 )
 861 {
 862     struct elfheader  eh;
 863     struct sheader   *sh;
 864     struct sheader   *symtab_shndx = NULL;
 865     struct sheader   *strtab = NULL;
 866     BPTR   hunks         = 0;
 867     BPTR  *next_hunk_ptr = &hunks;
 868     ULONG  i;
 869     BOOL   exec_hunk_seen = FALSE;
 870     ULONG  int_shnum;
 871     struct SRBuffer srb = { 0 };
 872
 873     /* load and validate ELF header */
 874     if (!load_header(file, &eh, funcarray, &srb, DOSBase))
 875         return 0;
 876
 877     int_shnum = read_shnum(file, &eh, funcarray, &srb, DOSBase);
 878     if (!int_shnum)
 879         return 0;
 880
 881     /* load section headers */
 882     if (!(sh = load_block(file, eh.shoff, int_shnum * eh.shentsize, funcarray, &srb, DOSBase)))
 883         return 0;
 884
 885 #ifdef __arm__
 886     for (i = 0; i < int_shnum; i++)
 887     {
 888         if (sh[i].type == SHT_ARM_ATTRIBUTES)
 889         {
 890             ULONG len = sh[i].size;
 891             UBYTE *data = load_block(file, sh[i].offset, len, funcarray, &srb, DOSBase);
 892
 893             if (data)
 894             {
 895                 BOOL res = ARM_ParseAttrs(data, len, DOSBase);
 896
 897                 ilsFreeMem(data, len);
 898
 899                 if (!res)
 900                 {
 901                     D(bug("[ELF Loader] Can't parse ARM attributes\n"));
 902                     SetIoErr(ERROR_NOT_EXECUTABLE);
 903                     goto error;
 904                 }
 905             }
 906         }
 907     }
 908 #endif
 909
 910     /* Iterate over the section headers in order to do some stuff... */
 911     for (i = 0; i < int_shnum; i++)
 912     {
 913         /*
 914            Load the symbol and string table(s).
 915
 916            NOTICE: the ELF standard, at the moment (Nov 2002) explicitely states
 917                    that only one symbol table per file is allowed. However, it
 918                    also states that this may change in future... we already handle it.
 919         */
 920         if (sh[i].type == SHT_SYMTAB || sh[i].type == SHT_STRTAB || sh[i].type == SHT_SYMTAB_SHNDX)
 921         {
 922             sh[i].addr = load_block(file, sh[i].offset, sh[i].size, funcarray, &srb, DOSBase);
 923             if (!sh[i].addr)
 924                 goto error;
 925
 926             if (sh[i].type == SHT_STRTAB) {
 927                 if (strtab == NULL) {
 928                     strtab = &sh[i];
 929                 } else {
 930                     D(bug("[ELF Loader] file contains multiple strtab tables. only using the first one\n"));
 931                 }
 932             }
 933
 934             if (sh[i].type == SHT_SYMTAB_SHNDX) {
 935                 if (symtab_shndx == NULL)
 936                     symtab_shndx = &sh[i];
 937                 else
 938                     D(bug("[ELF Loader] file contains multiple symtab shndx tables. only using the first one\n"));
 939             }
 940         }
 941    }
 942
 943     /* Now that we have the string and symbol tables loaded,
 944      * load the rest of the hunks.
 945      */
 946     for (i = 0; i < int_shnum; i++)
 947     {
 948         /* Skip the already loaded hunks */
 949         if (sh[i].type == SHT_SYMTAB || sh[i].type == SHT_STRTAB || sh[i].type == SHT_SYMTAB_SHNDX)
 950             continue;
 951
 952         /* Load the section in memory if needed, and make a hunk out of it */
 953         if (sh[i].flags & SHF_ALLOC)
 954         {
 955             if (sh[i].size)
 956             {
 957                 /* Only allow alignment if this is an executable hunk
 958                    or if an executable hunk has been loaded already,
 959                    so to avoid the situation in which a data hunk has its
 960                    content displaced from the hunk's header in case it's the
 961                    first hunk (this happens with Keymaps, for instance).  */
 962                 if (sh[i].flags & SHF_EXECINSTR)
 963                     exec_hunk_seen = TRUE;
 964
 965                 if (!load_hunk(file, &next_hunk_ptr, &sh[i], strtab ? strtab->addr : NULL, funcarray, exec_hunk_seen, &srb, DOSBase))
 966                     goto error;
 967             }
 968         }
 969     }
 970
 971     /* Relocate the sections */
 972     for (i = 0; i < int_shnum; i++)
 973     {
 974         /* Does this relocation section refer to a hunk? If so, addr must be != 0 */
 975         if ((sh[i].type == AROS_ELF_REL) && sh[sh[i].info].addr)
 976         {
 977             sh[i].addr = load_block(file, sh[i].offset, sh[i].size, funcarray, &srb, DOSBase);
 978             if (!sh[i].addr || !relocate(&eh, sh, i, symtab_shndx, DOSBase))
 979                 goto error;
 980
 981             ilsFreeMem(sh[i].addr, sh[i].size);
 982             sh[i].addr = NULL;
 983         }
 984     }
 985
 986     /* Everything is loaded now. Register the module at kernel.resource */
 987     register_elf(file, hunks, &eh, sh, DOSBase);
 988     goto end;
 989
 990 error:
 991
 992     /* There were some errors, deallocate The hunks */
 993
 994     InternalUnLoadSeg(hunks, (VOID_FUNC)funcarray[2]);
 995     hunks = 0;
 996
 997 end:
 998
 999     /*
1000      * Clear the caches to let the CPU see the new data and instructions.
1001      * We check for SysBase's lib_Version, since this code is also built
1002      * as linklib for AmigaOS version of AROS bootstrap, and it can be
1003      * running on AOS 1.3 or lower.
1004      */
1005     if (SysBase->LibNode.lib_Version >= 36)
1006     {
1007         BPTR curr = hunks;
1008
1009         while (curr)
1010         {
1011              struct hunk *hunk = BPTR2HUNK(BADDR(curr));
1012
1013              CacheClearE(hunk->data, hunk->size, CACRF_ClearD | CACRF_ClearI);
1014
1015              curr = hunk->next;
1016         }
1017     }
1018
1019     /* deallocate the symbol tables */
1020     for (i = 0; i < int_shnum; i++)
1021     {
1022         if (((sh[i].type == SHT_SYMTAB) || (sh[i].type == SHT_STRTAB)) && (sh[i].addr != NULL))
1023             ilsFreeMem(sh[i].addr, sh[i].size);
1024     }
1025
1026     /* Free the section headers */
1027     ilsFreeMem(sh, int_shnum * eh.shentsize);
1028
1029     if (srb.srb_Buffer) FreeMem(srb.srb_Buffer, LOADSEG_SMALL_READ);
1030
1031     return hunks;
1032 }